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?
- Hora de finalización: Hora en la que el proceso completa su ejecución.
- 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
- 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:
- no preventivo
- El tiempo promedio de espera no es óptimo
- 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