Programa para programación de CPU FCFS | Conjunto 2 (Procesos con diferentes tiempos de llegada) – Part 1

Ya hemos discutido la Programación FCFS de procesos con el mismo tiempo de llegada . En esta publicación, se analizan escenarios en los que los procesos tienen tiempos de llegada diferentes. Dados n procesos con sus tiempos de ráfaga y tiempos de llegada, la tarea es encontrar el tiempo de espera promedio y el tiempo de respuesta promedio utilizando el algoritmo de programación FCFS. 
FIFO simplemente pone en cola los procesos en el orden en que llegan a la cola de listos. Aquí, el proceso que viene primero se ejecutará primero y el siguiente proceso comenzará solo después de que el anterior se haya ejecutado por completo. 

  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 vuelta – Tiempo de ráfaga.

ff2_ff23_

Process     Wait Time : Service Time - Arrival Time
   P0                        0 - 0   = 0
   P1                        5 - 1   = 4
   P2                        8 - 2   = 6
   P3                        16 - 3  = 13

Average Wait Time: (0 + 4 + 6 + 13) / 4 = 5.75

Tiempo de servicio: el tiempo de servicio significa la cantidad de tiempo después del cual un proceso puede comenzar a ejecutarse. Es la suma del tiempo de ráfaga de procesos anteriores (Procesos que vinieron antes)

Cambios en el código en comparación con el código de FCFS con el mismo tiempo de llegada : 
Para encontrar el tiempo de espera: tiempo que tardan todos los procesos antes de que se inicie el proceso actual (es decir, tiempo de ráfaga de todos los procesos anteriores) – tiempo de llegada del proceso actual 
wait_time[i] = (bt[0] + bt[1] +…… bt[i-1] ) – hora_llegada[i]

Implementación: 

1- Input the processes along with their burst time(bt)
   and arrival time(at)
2- Find waiting time for all other processes i.e. for
   a given process  i:
       wt[i] = (bt[0] + bt[1] +...... bt[i-1]) - at[i] 
3- Now find turn around time 
          = waiting_time + burst_time for all processes
4- Average waiting time = 
                    total_waiting_time / no_of_processes
5- Average turn around time = 
                 total_turn_around_time / no_of_processes

C++

// C++ program for implementation of FCFS
// scheduling with different arrival time
#include<iostream>
using namespace std;
 
// Function to find the waiting time for all
// processes
void findWaitingTime(int processes[], int n, int bt[],
                                   int wt[], int at[])
{
    int service_time[n];
    service_time[0] = at[0];
    wt[0] = 0;
 
    // calculating waiting time
    for (int i = 1; i < n ; i++)
    {
        // Add burst time of previous processes
        service_time[i] = service_time[i-1] + bt[i-1];
 
        // Find waiting time for current process =
        // sum - at[i]
        wt[i] = service_time[i] - at[i];
 
        // If waiting time for a process is in negative
        // that means it is already in the ready queue
        // before CPU becomes idle so its waiting time is 0
        if (wt[i] < 0)
            wt[i] = 0;
    }
}
 
// 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 waiting and turn-around
// times.
void findavgTime(int processes[], int n, int bt[], int at[])
{
    int wt[n], tat[n];
 
    // Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt, at);
 
    // 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 " << " Arrival Time "
         << " Waiting Time " << " Turn-Around Time "
         << " Completion Time \n";
    int total_wt = 0, total_tat = 0;
    for (int i = 0 ; i < n ; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        int compl_time = tat[i] + at[i];
        cout << " " << i+1 << "\t\t" << bt[i] << "\t\t"
             << at[i] << "\t\t" << wt[i] << "\t\t "
             << tat[i]  <<  "\t\t " << compl_time << 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[] = {5, 9, 6};
 
    // Arrival time of all processes
    int arrival_time[] = {0, 3, 6};
 
    findavgTime(processes, n, burst_time, arrival_time);
 
    return 0;
}

Java

// Java program for implementation of FCFS
// scheduling with different arrival time
public class GFG{
 
 
// Function to find the waiting time for all
// processes
static void findWaitingTime(int processes[], int n, int bt[], int wt[], int at[])
{
    int service_time[] = new int[n];
    service_time[0] = at[0];
    wt[0] = 0;
 
    // calculating waiting time
    for (int i = 1; i < n ; i++)
    {
        //representing wasted time in queue
        int wasted=0;
        // Add burst time of previous processes
        service_time[i] = service_time[i-1] + bt[i-1];
 
        // Find waiting time for current process =
        // sum - at[i]
        wt[i] = service_time[i] - at[i];
 
        // If waiting time for a process is in negative
        // that means it is already in the ready queue
        // before CPU becomes idle so its waiting time is 0
        // wasted time is basically time for process to wait after a process is over
        if (wt[i] < 0) {
            wasted = Math.abs(wt[i]);
            wt[i] = 0;
        }
        //Add wasted time
        service_time[i] = service_time[i] + wasted;
    }
}
 
// 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 waiting and turn-around
// times.
static void findavgTime(int processes[], int n, int bt[], int at[])
{
    int wt[] = new int[n], tat[] = new int[n];
 
    // Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt, at);
 
    // Function to find turn around time for all processes
    findTurnAroundTime(processes, n, bt, wt, tat);
 
    // Display processes along with all details
    System.out.print("Processes " + " Burst Time " + " Arrival Time "
        + " Waiting Time " + " Turn-Around Time "
        + " Completion Time \n");
    int total_wt = 0, total_tat = 0;
    for (int i = 0 ; i < n ; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        int compl_time = tat[i] + at[i];
        System.out.println(i+1 + "\t\t" + bt[i] + "\t\t"
            + at[i] + "\t\t" + wt[i] + "\t\t "
            + tat[i] + "\t\t " + compl_time);
    }
 
    System.out.print("Average waiting time = "
        + (float)total_wt / (float)n);
    System.out.print("\nAverage turn around time = "
        + (float)total_tat / (float)n);
}
 
// 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[] = {5, 9, 6};
 
    // Arrival time of all processes
    int arrival_time[] = {0, 3, 6};
 
    findavgTime(processes, n, burst_time, arrival_time);
 
    }
}
 
/*This code is contributed by PrinciRaj1992*/

Python3

# Python3 program for implementation of FCFS
# scheduling with different arrival time
 
# Function to find the waiting time
# for all processes
def findWaitingTime(processes, n, bt, wt, at):
    service_time = [0] * n
    service_time[0] = 0
    wt[0] = 0
 
    # calculating waiting time
    for i in range(1, n):
         
        # Add burst time of previous processes
        service_time[i] = (service_time[i - 1] +
                                     bt[i - 1])
 
        # Find waiting time for current
        # process = sum - at[i]
        wt[i] = service_time[i] - at[i]
 
        # If waiting time for a process is in
        # negative that means it is already
        # in the ready queue before CPU becomes
        # idle so its waiting time is 0
        if (wt[i] < 0):
            wt[i] = 0
     
# 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 waiting
# and turn-around times.
def findavgTime(processes, n, bt, at):
    wt = [0] * n
    tat = [0] * n
 
    # Function to find waiting time
    # of all processes
    findWaitingTime(processes, n, bt, wt, at)
 
    # 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   Arrival Time     Waiting",
          "Time   Turn-Around Time  Completion Time \n")
    total_wt = 0
    total_tat = 0
    for i in range(n):
 
        total_wt = total_wt + wt[i]
        total_tat = total_tat + tat[i]
        compl_time = tat[i] + at[i]
        print(" ", i + 1, "\t\t", bt[i], "\t\t", at[i],
              "\t\t", wt[i], "\t\t ", tat[i], "\t\t ", compl_time)
 
    print("Average waiting time = %.5f "%(total_wt /n))
    print("\nAverage turn around time = ", total_tat / n)
 
# Driver code
if __name__ =="__main__":
     
    # Process id's
    processes = [1, 2, 3]
    n = 3
 
    # Burst time of all processes
    burst_time = [5, 9, 6]
 
    # Arrival time of all processes
    arrival_time = [0, 3, 6]
 
    findavgTime(processes, n, burst_time,
                            arrival_time)
 
# This code is contributed
# Shubham Singh(SHUBHAMSINGH10)

C#

// C# program for implementation of FCFS
// scheduling with different arrival time
using System;
     
public class GFG{
  
  
// Function to find the waiting time for all
// processes
static void findWaitingTime(int []processes, int n, int []bt, int []wt, int []at)
{
    int []service_time = new int[n];
    service_time[0] = 0;
    wt[0] = 0;
  
    // calculating waiting time
    for (int i = 1; i < n ; i++)
    {
        // Add burst time of previous processes
        service_time[i] = service_time[i-1] + bt[i-1];
  
        // Find waiting time for current process =
        // sum - at[i]
        wt[i] = service_time[i] - at[i];
  
        // If waiting time for a process is in negative
        // that means it is already in the ready queue
        // before CPU becomes idle so its waiting time is 0
        if (wt[i] < 0)
            wt[i] = 0;
    }
}
  
// 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 waiting and turn-around
// times.
static void findavgTime(int []processes, int n, int []bt, int []at)
{
    int []wt = new int[n]; int []tat = new int[n];
  
    // Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt, at);
  
    // 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 " + " Arrival Time "
        + " Waiting Time " + " Turn-Around Time "
        + " Completion Time \n");
    int total_wt = 0, total_tat = 0;
    for (int i = 0 ; i < n ; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        int compl_time = tat[i] + at[i];
        Console.WriteLine(i+1 + "\t\t" + bt[i] + "\t\t"
            + at[i] + "\t\t" + wt[i] + "\t\t "
            + tat[i] + "\t\t " + compl_time);
    }
  
    Console.Write("Average waiting time = "
        + (float)total_wt / (float)n);
    Console.Write("\nAverage turn around time = "
        + (float)total_tat / (float)n);
}
  
// 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 = {5, 9, 6};
  
    // Arrival time of all processes
    int []arrival_time = {0, 3, 6};
  
    findavgTime(processes, n, burst_time, arrival_time);
  
    }
}
// This code is contributed by Princi Singh

Javascript

<script>
  
// JavaScript program for implementation of FCFS
// scheduling with different arrival time
  
// Function to find the waiting time for all
// processes
function findWaitingTime(processes , n , bt , wt , at)
{
    var service_time = Array.from({length: n}, (_, i) => 0);
    service_time[0] = at[0];
    wt[0] = 0;
  
    // calculating waiting time
    for (var i = 1; i < n ; i++)
    {
        //representing wasted time in queue
        var wasted=0;
        // Add burst time of previous processes
        service_time[i] = service_time[i-1] + bt[i-1];
  
        // Find waiting time for current process =
        // sum - at[i]
        wt[i] = service_time[i] - at[i];
  
        // If waiting time for a process is in negative
        // that means it is already in the ready queue
        // before CPU becomes idle so its waiting time is 0
        // wasted time is basically time for process to
        // wait after a process is over
        if (wt[i] < 0) {
            wasted = Math.abs(wt[i]);
            wt[i] = 0;
        }
        // Add wasted time
        service_time[i] = service_time[i] + wasted;
    }
}
  
// Function to calculate turn around time
function findTurnAroundTime(processes , n , bt, wt , tat)
{
    // Calculating turnaround time by adding bt[i] + wt[i]
    for (var i = 0; i < n ; i++)
        tat[i] = bt[i] + wt[i];
}
  
// Function to calculate average waiting and turn-around
// times.
function findavgTime(processes , n , bt , at)
{
    var wt = Array.from({length: n}, (_, i) => 0.0);
    var tat = Array.from({length: n}, (_, i) => 0.0);
  
    // Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt, at);
  
    // 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 " + " Arrival Time "
        + " Waiting Time " + " Turn-Around Time "
        + " Completion Time <br>");
    var total_wt = 0, total_tat = 0;
    for (var i = 0 ; i < n ; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        var compl_time = tat[i] + at[i];
        document.write(i+1 + "  " + bt[i]
        + "  "
            + at[i] + "  " + wt[i] + "  "
            + tat[i] + "  " + compl_time+"<br>");
    }
  
    document.write("<br>Average waiting time = "
        + total_wt/n +"<br>");
    document.write("<br>Average turn around time = "
        + total_tat/n+"<br>");
}
  
// Driver code
  
       
    // Process id's
   var processes = [1, 2, 3];
   var n = processes.length;
  
// Burst time of all processes
var burst_time = [5, 9, 6];
  
// Arrival time of all processes
var arrival_time = [0, 3, 6];
  
findavgTime(processes, n, burst_time, arrival_time);
  
  
  
// This code is contributed by 29AjayKumar
  
</script>

Producción: 

Processes  Burst Time  Arrival Time  Waiting Time  Turn-Around Time  Completion Time 
 1        5        0        0         5         5
 2        9        3        2         11         14
 3        6        6        8         14         20
Average waiting time = 3.33333
Average turn around time = 10.0

Este artículo es una contribución de Sahil Chhabra (akku) . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a contribuido@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente. 

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 *