Programa para programación de CPU FCFS | Serie 1 – Part 1

 

Dados n procesos con sus tiempos de ráfaga, la tarea es encontrar el tiempo de espera promedio y el tiempo de respuesta promedio utilizando el algoritmo de programación FCFS. 
Primero en entrar, primero en salir (FIFO), también conocido como primero en llegar, primero en ser atendido (FCFS), es el algoritmo de programación más simple. FIFO simplemente pone en cola los procesos en el orden en que llegan a la cola de listos. 
En esto, el proceso que viene primero se ejecutará primero y el siguiente proceso comienza solo después de que el anterior se haya ejecutado por completo. 
Aquí estamos considerando que el tiempo de llegada para todos los procesos es 0.
¿Cómo calcular los tiempos a continuación en Round Robin usando un programa? 
 

  1. Hora de finalización: Hora en la que el proceso completa su ejecución.
  2. Turn Around Time: Diferencia horaria entre la hora de finalización y la hora de llegada. Hora de vuelta = Hora de finalización – Hora de llegada
  3. Tiempo de espera (WT): diferencia de tiempo entre el tiempo de respuesta y el tiempo de ráfaga. 
    Tiempo de espera = Tiempo de respuesta – Tiempo de ráfaga
 

En esta publicación, asumimos que los tiempos de llegada son 0, por lo que los tiempos de vuelta y finalización son los mismos.
 

Implementación: 
 

1-  Input the processes along with their burst time (bt).
2-  Find waiting time (wt) for all processes.
3-  As first process that comes need not to wait so 
    waiting time for process 1 will be 0 i.e. wt[0] = 0.
4-  Find waiting time for all other processes i.e. for
     process i -> 
       wt[i] = bt[i-1] + wt[i-1] .
5-  Find turnaround time = waiting_time + burst_time 
    for all processes.
6-  Find average waiting time = 
                 total_waiting_time / no_of_processes.
7-  Similarly, find average turnaround time = 
                 total_turn_around_time / no_of_processes.

C++

// C++ program for implementation of FCFS
// scheduling
#include<iostream>
using namespace std;
 
// Function to find the waiting time for all
// processes
void findWaitingTime(int processes[], int n,
                          int bt[], int wt[])
{
    // waiting time for first process is 0
    wt[0] = 0;
 
    // calculating waiting time
    for (int  i = 1; i < n ; i++ )
        wt[i] =  bt[i-1] + wt[i-1] ;
}
 
// Function to calculate turn around time
void findTurnAroundTime( int processes[], int n,
                  int bt[], int wt[], int tat[])
{
    // calculating turnaround time by adding
    // bt[i] + wt[i]
    for (int  i = 0; i < n ; i++)
        tat[i] = bt[i] + wt[i];
}
 
//Function to calculate average time
void findavgTime( int processes[], int n, int bt[])
{
    int wt[n], tat[n], total_wt = 0, total_tat = 0;
 
    //Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt);
 
    //Function to find turn around time for all processes
    findTurnAroundTime(processes, n, bt, wt, tat);
 
    //Display processes along with all details
    cout << "Processes  "<< " Burst time  "
         << " Waiting time  " << " Turn around time\n";
 
    // Calculate total waiting time and total turn
    // around time
    for (int  i=0; i<n; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        cout << "   " << i+1 << "\t\t" << bt[i] <<"\t    "
            << wt[i] <<"\t\t  " << tat[i] <<endl;
    }
 
    cout << "Average waiting time = "
         << (float)total_wt / (float)n;
    cout << "\nAverage turn around time = "
         << (float)total_tat / (float)n;
}
 
// Driver code
int main()
{
    //process id's
    int processes[] = { 1, 2, 3};
    int n = sizeof processes / sizeof processes[0];
 
    //Burst time of all processes
    int  burst_time[] = {10, 5, 8};
 
    findavgTime(processes, n,  burst_time);
    return 0;
}

C

// C program for implementation of FCFS 
// scheduling
#include<stdio.h>
// Function to find the waiting time for all 
// processes
void findWaitingTime(int processes[], int n, 
                          int bt[], int wt[])
{
    // waiting time for first process is 0
    wt[0] = 0;
   
    // calculating waiting time
    for (int  i = 1; i < n ; i++ )
        wt[i] =  bt[i-1] + wt[i-1] ;
}
   
// Function to calculate turn around time
void findTurnAroundTime( int processes[], int n, 
                  int bt[], int wt[], int tat[])
{
    // calculating turnaround time by adding
    // bt[i] + wt[i]
    for (int  i = 0; i < n ; i++)
        tat[i] = bt[i] + wt[i];
}
   
//Function to calculate average time
void findavgTime( int processes[], int n, int bt[])
{
    int wt[n], tat[n], total_wt = 0, total_tat = 0;
   
    //Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt);
   
    //Function to find turn around time for all processes
    findTurnAroundTime(processes, n, bt, wt, tat);
   
    //Display processes along with all details
    printf("Processes   Burst time   Waiting time   Turn around time\n");
   
    // Calculate total waiting time and total turn 
    // around time
    for (int  i=0; i<n; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        printf("   %d ",(i+1));
        printf("       %d ", bt[i] );
        printf("       %d",wt[i] );
        printf("       %d\n",tat[i] );
    }
    int s=(float)total_wt / (float)n;
    int t=(float)total_tat / (float)n;
    printf("Average waiting time = %d",s);
    printf("\n");
    printf("Average turn around time = %d ",t);
}
   
// Driver code
int main()
{
    //process id's
    int processes[] = { 1, 2, 3};
    int n = sizeof processes / sizeof processes[0];
   
    //Burst time of all processes
    int  burst_time[] = {10, 5, 8};
   
    findavgTime(processes, n,  burst_time);
    return 0;
}
// This code is contributed by Shivi_Aggarwal

Java

// Java program for implementation of FCFS
// scheduling
 
import java.text.ParseException;
 
class GFG {
 
    // Function to find the waiting time for all
    // processes
    static void findWaitingTime(int processes[], int n,
            int bt[], int wt[]) {
        // waiting time for first process is 0
        wt[0] = 0;
 
        // calculating waiting time
        for (int i = 1; i < n; i++) {
            wt[i] = bt[i - 1] + wt[i - 1];
        }
    }
 
    // Function to calculate turn around time
    static void findTurnAroundTime(int processes[], int n,
            int bt[], int wt[], int tat[]) {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (int i = 0; i < n; i++) {
            tat[i] = bt[i] + wt[i];
        }
    }
 
    //Function to calculate average time
    static void findavgTime(int processes[], int n, int bt[]) {
        int wt[] = new int[n], tat[] = new int[n];
        int total_wt = 0, total_tat = 0;
 
        //Function to find waiting time of all processes
        findWaitingTime(processes, n, bt, wt);
 
        //Function to find turn around time for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
 
        //Display processes along with all details
        System.out.printf("Processes Burst time Waiting"
                       +" time Turn around time\n");
 
        // Calculate total waiting time and total turn
        // around time
        for (int i = 0; i < n; i++) {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            System.out.printf(" %d ", (i + 1));
            System.out.printf("     %d ", bt[i]);
            System.out.printf("     %d", wt[i]);
            System.out.printf("     %d\n", tat[i]);
        }
        float s = (float)total_wt /(float) n;
        int t = total_tat / n;
        System.out.printf("Average waiting time = %f", s);
        System.out.printf("\n");
        System.out.printf("Average turn around time = %d ", t);
    }
 
    // Driver code
    public static void main(String[] args) throws ParseException {
        //process id's
        int processes[] = {1, 2, 3};
        int n = processes.length;
 
        //Burst time of all processes
        int burst_time[] = {10, 5, 8};
 
        findavgTime(processes, n, burst_time);
 
    }
}
// This code is contributed by 29ajaykumar

Python 3

# Python3 program for implementation
# of FCFS scheduling
 
# Function to find the waiting
# time for all processes
def findWaitingTime(processes, n,
                    bt, wt):
 
    # waiting time for
    # first process is 0
    wt[0] = 0
 
    # calculating waiting time
    for i in range(1, n ):
        wt[i] = bt[i - 1] + wt[i - 1]
 
# Function to calculate turn
# around time
def findTurnAroundTime(processes, n,
                       bt, wt, tat):
 
    # calculating turnaround
    # time by adding bt[i] + wt[i]
    for i in range(n):
        tat[i] = bt[i] + wt[i]
 
# Function to calculate
# average time
def findavgTime( processes, n, bt):
 
    wt = [0] * n
    tat = [0] * n
    total_wt = 0
    total_tat = 0
 
    # Function to find waiting
    # time of all processes
    findWaitingTime(processes, n, bt, wt)
 
    # Function to find turn around
    # time for all processes
    findTurnAroundTime(processes, n,
                       bt, wt, tat)
 
    # Display processes along
    # with all details
    print( "Processes Burst time " +
                  " Waiting time " +
                " Turn around time")
 
    # Calculate total waiting time
    # and total turn around time
    for i in range(n):
     
        total_wt = total_wt + wt[i]
        total_tat = total_tat + tat[i]
        print(" " + str(i + 1) + "\t\t" +
                    str(bt[i]) + "\t " +
                    str(wt[i]) + "\t\t " +
                    str(tat[i]))
 
    print( "Average waiting time = "+
                   str(total_wt / n))
    print("Average turn around time = "+
                     str(total_tat / n))
 
# Driver code
if __name__ =="__main__":
     
    # process id's
    processes = [ 1, 2, 3]
    n = len(processes)
 
    # Burst time of all processes
    burst_time = [10, 5, 8]
 
    findavgTime(processes, n, burst_time)
 
# This code is contributed
# by ChitraNayal

C#

// C# program for implementation of FCFS
// scheduling
using System;
     
class GFG
{
 
    // Function to find the waiting time for all
    // processes
    static void findWaitingTime(int []processes, int n,
                                int []bt, int[] wt)
    {
        // waiting time for first process is 0
        wt[0] = 0;
 
        // calculating waiting time
        for (int i = 1; i < n; i++)
        {
            wt[i] = bt[i - 1] + wt[i - 1];
        }
    }
 
    // Function to calculate turn around time
    static void findTurnAroundTime(int []processes, int n,
            int []bt, int []wt, int []tat) {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (int i = 0; i < n; i++)
        {
            tat[i] = bt[i] + wt[i];
        }
    }
 
    // Function to calculate average time
    static void findavgTime(int []processes, int n, int []bt)
    {
        int []wt = new int[n];
        int []tat = new int[n];
        int total_wt = 0, total_tat = 0;
 
        //Function to find waiting time of all processes
        findWaitingTime(processes, n, bt, wt);
 
        //Function to find turn around time for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
 
        //Display processes along with all details
        Console.Write("Processes Burst time Waiting"
                    +" time Turn around time\n");
 
        // Calculate total waiting time and total turn
        // around time
        for (int i = 0; i < n; i++)
        {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            Console.Write(" {0} ", (i + 1));
            Console.Write("     {0} ", bt[i]);
            Console.Write("     {0}", wt[i]);
            Console.Write("     {0}\n", tat[i]);
        }
        float s = (float)total_wt /(float) n;
        int t = total_tat / n;
        Console.Write("Average waiting time = {0}", s);
        Console.Write("\n");
        Console.Write("Average turn around time = {0} ", t);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        // process id's
        int []processes = {1, 2, 3};
        int n = processes.Length;
 
        // Burst time of all processes
        int []burst_time = {10, 5, 8};
 
        findavgTime(processes, n, burst_time);
    }
}
 
// This code contributed by Rajput-Ji

Javascript

<script>
 
    // JavaScript program for implementation of FCFS
   // scheduling
    
    
   // Function to find the waiting time for all
  // processes
    function findWaitingTime(processes,n,bt,wt)
    {
        // waiting time for first process is 0
        wt[0] = 0;
   
        // calculating waiting time
        for (let i = 1; i < n; i++) {
            wt[i] = bt[i - 1] + wt[i - 1];
        }
    }
     
    function findTurnAroundTime(processes,n,bt,wt,tat)
    {
        // calculating turnaround time by adding
        // bt[i] + wt[i]
        for (let i = 0; i < n; i++) {
            tat[i] = bt[i] + wt[i];
        }
    }
     
    function findavgTime(processes,n,bt)
    {
        let wt = new Array(n), tat = new Array(n);
        for(let i=0;i<n;i++)
        {
            wt[i]=0;
            tat[i]=0;
        }
        let total_wt = 0, total_tat = 0;
   
        //Function to find waiting time of all processes
        findWaitingTime(processes, n, bt, wt);
   
        //Function to find turn around time for all processes
        findTurnAroundTime(processes, n, bt, wt, tat);
   
        //Display processes along with all details
        document.write("Processes Burst time Waiting"
                       +" time Turn around time<br>");
   
        // Calculate total waiting time and total turn
        // around time
        for (let i = 0; i < n; i++) {
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            document.write("    ", (i + 1)+" ");
            document.write("     "+  bt[i]+" ");
            document.write("     "+ wt[i]);
            document.write("     "+ tat[i]+"<br>");
        }
        let s = total_wt / n;
        let t = Math.floor(total_tat / n);
        document.write("Average waiting time = "+ s);
        document.write("<br>");
        document.write("Average turn around time = ", t+" ");
    }
     
    let processes=[1,2,3];
    let  n = processes.length;
     
    let burst_time=[10,5,8];
    findavgTime(processes, n, burst_time);
     
    // This code is contributed by rag2127
     
</script>

Producción: 

Processes  Burst time  Waiting time  Turn around time
 1        10     0         10
 2        5     10         15
 3        8     15         23
Average waiting time = 8.33333
Average turn around time = 16

Puntos importantes: 
 

  1. no preventivo
  2. El tiempo promedio de espera no es óptimo
  3. No se pueden utilizar recursos en paralelo: da como resultado el efecto Convoy (considere una situación en la que hay muchos procesos vinculados a IO y un proceso vinculado a CPU. Los procesos vinculados a IO tienen que esperar el proceso vinculado a CPU cuando el proceso vinculado a CPU adquiere CPU. El proceso vinculado a IO podría es mejor haber tomado CPU durante algún tiempo, luego usar dispositivos IO).

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *