logo

TechCodeview

Programa de programación Round Robin para la misma hora de llegada

Ronda Robin es un algoritmo de programación de CPU donde a cada proceso se le asigna cíclicamente un intervalo de tiempo fijo. Es la versión preventiva del algoritmo de programación de CPU por orden de llegada.

conectar base de datos java
  • El algoritmo de CPU Round Robin generalmente se centra en la técnica de tiempo compartido.
  • El período de tiempo durante el cual se permite ejecutar un proceso o trabajo en un método preventivo se llama tiempo. cuántico .
  • A cada proceso o trabajo presente en la cola lista se le asigna la CPU para ese cuanto de tiempo; si la ejecución del proceso se completa durante ese tiempo, entonces el proceso fin de lo contrario, el proceso volverá al mesa de espera y espera su siguiente turno para completar la ejecución.

Características del algoritmo de programación de CPU Round Robin

  • Es simple, fácil de implementar y no requiere hambre, ya que todos los procesos obtienen una parte justa de la CPU.
  • Una de las técnicas más utilizadas en programación de CPU es un núcleo.
  • Es con derecho preferente ya que a los procesos se les asigna CPU solo durante un período de tiempo fijo como máximo.
  • La desventaja de esto es una mayor sobrecarga del cambio de contexto.

Ventajas del algoritmo de programación de CPU Round Robin

  • Hay justicia ya que cada proceso recibe una parte igual de la CPU.
  • El proceso recién creado se agrega al final de la cola lista.
  • Un programador por turnos generalmente emplea el tiempo compartido, dando a cada trabajo un intervalo de tiempo o una cantidad.
  • Mientras se realiza una programación por turnos, se asigna una cantidad de tiempo particular a diferentes trabajos.
  • Cada proceso tiene la oportunidad de reprogramarse después de un tiempo cuántico particular en esta programación.

Desventajas del algoritmo de programación de CPU Round Robin

  • Hay un mayor tiempo de espera y tiempo de respuesta.
  • Hay un rendimiento bajo.
  • Hay cambios de contexto.
  • El diagrama de Gantt parece ser demasiado grande (si el tiempo cuántico es menor para la programación. Por ejemplo: 1 ms para una programación grande).
  • Programación que requiere mucho tiempo para cuantos pequeños.

Ejemplos para mostrar el funcionamiento de Ronda Robin Algoritmo de programación

Ejemplo 1: Considere la siguiente tabla de tiempo de llegada y tiempo de ráfaga para cuatro procesos. P1, P2, P3 y P4 y dado Tiempo cuántico = 2

Proceso Tiempo quemado Hora de llegada
P1 5 ms 0 ms
P2 4 ms 1 ms
P3 2 ms 2 ms
P4 1 ms 4 ms

El algoritmo de programación de CPU Round Robin funcionará según los pasos que se mencionan a continuación:



En el tiempo = 0,

  • La ejecución comienza con el proceso P1, que tiene un tiempo de ráfaga 5.
  • Aquí, cada proceso se ejecuta durante 2 milisegundos ( Período cuántico de tiempo ). P2 y P3 todavía están en la cola de espera.
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
0-2 ms P1 0ms P2, P3 P1 2 ms 5 ms 3ms

En el tiempo = 2,

  • Los procesos P1 y P3 llegan a la cola de listos y P2 comienza a ejecutarse por TQ período
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
2-4 ms P1 0ms P3, P1 P2 0ms 3ms 3ms
P2 1ms 2 ms 4ms 2 ms

En el tiempo = 4,

  • El proceso P4 llega al cola lista ,
  • Entonces P3 se ejecuta para TQ período.
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
4-6 ms P1 0ms P1, P4, P2 P3 0ms 3ms 3ms
P2 1ms 0ms 2 ms 2 ms
P3 2 ms 2 ms 2 ms 0ms

En el momento = 6,

  • El proceso P3 completa su ejecución.
  • El proceso P1 comienza a ejecutarse durante TQ período como es el siguiente en el b.
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
6-8 ms P1 0ms P4, P2 P1 2 ms 3ms 1ms
P2 1ms 0ms 2 ms 2 ms

En el momento = 8,

  • El proceso P4 comienza a ejecutarse, no se ejecutará durante Tiempo Período cuántico ya que tiene tiempo de ráfaga = 1
  • Por lo tanto, se ejecutará durante sólo 1 ms.
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
8-9ms P1 0ms P2, P1 P4 0ms 3ms 1ms
P2 1ms 0ms 2 ms 2 ms
P4 4ms 1ms 1ms 0ms

En el momento = 9,

  • El proceso P4 completa su ejecución.
  • El proceso P2 comienza a ejecutarse para TQ período como el siguiente en el cola lista
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
9-11ms P1 0ms P1 P2 0ms 3ms 1ms
P2 1ms 2 ms 2 ms 0ms

En el momento = 11,

  • El proceso P2 completa su ejecución.
  • El proceso P1 comienza a ejecutarse, se ejecutará solo durante 1 ms
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
11-12 ms P1 0ms P1 1ms 1ms 0ms

En el momento = 12,

  • El proceso P1 completa su ejecución.
  • La ejecución general de los procesos será la que se muestra a continuación:
Instancia de tiempo Proceso Hora de llegada Cola lista Cola en ejecución Tiempo de ejecución Tiempo de ráfaga inicial Explosión restante
Tiempo
0-2 ms P1 0ms P2, P3 P1 2 ms 5 ms 3ms
2-4 ms P1 0ms P3, P1 P2 0ms 3ms 3ms
P2 1ms 2 ms 4ms 2 ms
4-6 ms P1 0ms P1, P4, P2 P3 0ms 3ms 3ms
P2 1ms 0ms 2 ms 2 ms
P3 2 ms 2 ms 2 ms 0ms
6-8 ms P1 0ms P4, P2 P1 2 ms 3ms 1ms
P2 1ms 0ms 2 ms 2 ms
8-9ms P1 0ms P2, P1 P4 0ms 3ms 1ms
P2 1ms 0ms 2 ms 2 ms
P4 4ms 1ms 1ms 0ms
9-11ms P1 0ms P1 P2 0ms 3ms 1ms
P2 1ms 2 ms 2 ms 0ms
11-12 ms P1 0ms P1 1ms 1ms 0ms

Gráfico de gantt será el siguiente a continuación:

diagrama de Gantt para el algoritmo de programación Round Robin

Diagrama de Gantt para el algoritmo de programación Round Robin

¿Cómo calcular los siguientes tiempos en Round Robin usando un programa?

  • Tiempo de finalización: Hora en la que el proceso completa su ejecución.
  • Tiempo de vuelta: Hora Diferencia entre la hora de finalización y la hora de llegada. Tiempo de respuesta = Hora de finalización – Hora de llegada
  • Tiempo de espera (W.T): Tiempo Diferencia entre el tiempo de respuesta y el tiempo de ráfaga.
    Tiempo de espera = tiempo de respuesta – tiempo de ráfaga

Ahora, calculemos el promedio. tiempo de espera y vuelta tiempo:

Procesos EN BT Connecticut HACER ENCAJE peso
P1 0 5 12 12-0 = 12 12-5 = 7
P2 1 4 11 11-1 = 10 10-4 = 6
P3 2 2 6 6-2 = 4 4-2 = 2
P4 4 1 9 9-4 = 5 5-1 = 4

Ahora,

  • Tiempo promedio de respuesta = (12 + 10 + 4 + 5)/4 = 31/4 = 7.7
  • tiempo promedio de espera = (7 + 6 + 2 + 4)/4 = 19/4 = 4.7

Ejemplo 2: Considere la siguiente tabla de tiempo de llegada y tiempo de ráfaga para tres procesos P1, P2 y P3 y dado Tiempo cuántico = 2

Proceso Tiempo quemado Hora de llegada
P1 10 ms 0 ms
P2 5 ms 0 ms
P3 8 ms 0 ms

Similarmente, Gráfico de gantt para este ejemplo:

Diagrama de Gantt por ejemplo 2

Diagrama de Gantt por ejemplo 2

Ahora, calculemos el promedio. tiempo de espera y vuelta tiempo:

Procesos EN BT Connecticut HACER ENCAJE peso
P1 0 10 23 23-0 = 23 23-10 = 13
P2 0 5 15 15-0 = 15 15-5 = 10
P3 0 8 21 21-0 = 21 21-8 = 13

Tiempo total de respuesta = 59 ms
Entonces, Tiempo promedio de respuesta = 59/3 = 19,667 ms

Y tiempo total de espera = 36 ms
Entonces, Tiempo promedio de espera = 36/3 = 12,00 ms

cadena.reemplazar todo en java

Programa de programación Round Robin con hora de llegada como 0 para todos los procesos

Pasos para encontrar tiempos de espera de todos los procesos

  • Crear una matriz rem_bt[] para realizar un seguimiento del tiempo de ráfaga restante de los procesos. Esta matriz es inicialmente una copia de bt[] (matriz de tiempos de ráfaga)
  • Crea otra matriz peso[] para almacenar tiempos de espera de procesos. Inicialice esta matriz como 0.
  • Tiempo de inicialización: t = 0
  • Continúe recorriendo todos los procesos mientras no hayan terminado. Haz lo siguiente para yo proceso si aún no se ha hecho.
    • Si rem_bt[i]> cuántico
      • t = t + cuántico
      • rem_bt[i] -= cantidad;
    • De lo contrario // Último ciclo para este proceso
      • t = t + rem_bt[i];
      • peso[i] = t – bt[i]
      • rem_bt[yo] = 0; // Este proceso ha terminado

Una vez que tenemos los tiempos de espera, podemos calcular el tiempo de respuesta tat[i] de un proceso como la suma de los tiempos de espera y de ráfaga, es decir, wt[i] + bt[i].
A continuación se muestra la implementación de los pasos anteriores.

C++




// C++ program for implementation of RR scheduling> #include> using> namespace> std;> // Function to find the waiting time for all> // processes> void> findWaitingTime(>int> processes[],>int> n,> >int> bt[],>int> wt[],>int> quantum)> {> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >int> rem_bt[n];> >for> (>int> i = 0 ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while (1) { bool done = true; // Traverse all processes one by one repeatedly for (int i = 0 ; i { // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { hecho = falso; // Hay un proceso pendiente if (rem_bt[i]> quantum) { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t += quantum; // Disminuir el tiempo de ráfaga del proceso actual // por quantum rem_bt[i] -= quantum; } // Si el tiempo de ráfaga es menor o igual que // quantum. Último ciclo para este proceso else { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t = t + rem_bt[i]; // El tiempo de espera es el tiempo actual menos el tiempo // utilizado por este proceso wt[i] = t - bt[i]; // A medida que el proceso se ejecuta por completo // haz que el tiempo de ráfaga restante = 0 rem_bt[i] = 0; } } } // Si todos los procesos finalizan if (done == true) break; } } // Función para calcular el tiempo de respuesta void findTurnAroundTime(intprocesses[], int n, int bt[], int wt[], int tat[]) { // calculando el tiempo de respuesta sumando // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Función para calcular el tiempo promedio void findavgTime(int procesos[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Función para encontrar el tiempo de espera de todos los procesos findWaitingTime(processes, n, bt, wt, quantum); Función para encontrar el tiempo de respuesta para todos los procesos findTurnAroundTime(processes, n, bt, wt, tat // Muestra los procesos junto con todos los detalles cout);<< 'PN '<< ' BT ' << ' WT ' << ' TAT '; // Calculate total waiting time and total turn // around time for (int i=0; i { total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; cout << ' ' << i+1 << ' ' << bt[i] <<' ' << wt[i] <<' ' << tat[i] < } cout << 'Average waiting time = ' << (float)total_wt / (float)n; cout << ' Average 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}; // Time quantum int quantum = 2; findavgTime(processes, n, burst_time, quantum); return 0; }> 

>

>

Java




// Java program for implementation of RR scheduling> public> class> GFG> {> >// Method to find the waiting time for all> >// processes> >static> void> findWaitingTime(>int> processes[],>int> n,> >int> bt[],>int> wt[],>int> quantum)> >{> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >int> rem_bt[] =>new> int>[n];> >for> (>int> i =>0> ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while(true) { boolean done = true; // Traverse all processes one by one repeatedly for (int i = 0 ; i { // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { hecho = falso; // Hay un proceso pendiente if (rem_bt[i]> quantum) { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t += quantum; // Disminuir el tiempo de ráfaga del proceso actual // por quantum rem_bt[i] -= quantum; } // Si el tiempo de ráfaga es menor o igual que // quantum. Último ciclo para este proceso else { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t = t + rem_bt[i]; // El tiempo de espera es el tiempo actual menos el tiempo // utilizado por este proceso wt[i] = t - bt[i]; // A medida que el proceso se ejecuta por completo // haz que el tiempo de ráfaga restante = 0 rem_bt[i] = 0; } } } // Si todos los procesos finalizan if (done == true) break; } } // Método para calcular el tiempo de respuesta static void findTurnAroundTime(intprocesses[], int n, int bt[], int wt[], int tat[]) { // calculando el tiempo de respuesta agregando // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Método para calcular el tiempo promedio static void findavgTime(int procesos[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Función para encontrar el tiempo de espera de todos los procesos findWaitingTime( procesos, n, bt, wt, quantum); // Función para encontrar el tiempo de respuesta para todos los procesos findTurnAroundTime(processes, n, bt, wt, tat // Muestra los procesos junto con todos los detalles System.out.println(); 'PN ' + ' B ' + ' WT ' + ' TAT'); // Calcular el tiempo total de espera y el tiempo total // de vuelta para (int i=0; i { total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; System.out.println(' ' + (i+1) + ' ' + bt[i] +' ' + wt[i] +' ' + tat[i]); } System.out.println('Tiempo de espera promedio = ' + (float)total_wt / (float)n); System.out.println('Tiempo de respuesta promedio = ' + (float)total_tat / (float)n); } // Método del controlador public static void main(String[] args) { // ID del proceso int procesos[] = { 1, 2, 3}; int n = procesos.longitud; // Tiempo de ráfaga de todos los procesos int burst_time[] = {10, 5, 8}; // Cuántico de tiempo int quantum = 2; findavgTime(procesos, n, tiempo_ráfaga, cuántico); } }> 

>

git rebase 
>

Python3




# Python3 program for implementation of> # RR scheduling> # Function to find the waiting time> # for all processes> def> findWaitingTime(processes, n, bt,> >wt, quantum):> >rem_bt>=> [>0>]>*> n> ># Copy the burst time into rt[]> >for> i>in> range>(n):> >rem_bt[i]>=> bt[i]> >t>=> 0> # Current time> ># Keep traversing processes in round> ># robin manner until all of them are> ># not done.> >while>(>1>):> >done>=> True> ># Traverse all processes one by> ># one repeatedly> >for> i>in> range>(n):> > ># If burst time of a process is greater> ># than 0 then only need to process further> >if> (rem_bt[i]>>0>) :> >done>=> False> # There is a pending process> > >if> (rem_bt[i]>cuántico):> > ># Increase the value of t i.e. shows> ># how much time a process has been processed> >t>+>=> quantum> ># Decrease the burst_time of current> ># process by quantum> >rem_bt[i]>->=> quantum> > ># If burst time is smaller than or equal> ># to quantum. Last cycle for this process> >else>:> > ># Increase the value of t i.e. shows> ># how much time a process has been processed> >t>=> t>+> rem_bt[i]> ># Waiting time is current time minus> ># time used by this process> >wt[i]>=> t>-> bt[i]> ># As the process gets fully executed> ># make its remaining burst time = 0> >rem_bt[i]>=> 0> > ># If all processes are done> >if> (done>=>=> True>):> >break> > # Function to calculate turn around time> def> findTurnAroundTime(processes, n, bt, wt, tat):> > ># Calculating turnaround time> >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, quantum):> >wt>=> [>0>]>*> n> >tat>=> [>0>]>*> n> ># Function to find waiting time> ># of all processes> >findWaitingTime(processes, n, bt,> >wt, quantum)> ># 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'>)> >total_wt>=> 0> >total_tat>=> 0> >for> i>in> range>(n):> >total_wt>=> total_wt>+> wt[i]> >total_tat>=> total_tat>+> tat[i]> >print>(>' '>, i>+> 1>,>' '>, bt[i],> >' '>, wt[i],>' '>, tat[i])> >print>(>' Average waiting time = %.5f '>%>(total_wt>/>n) )> >print>(>'Average turn around time = %.5f '>%> (total_tat>/> n))> > # Driver code> if> __name__>=>=>'__main__'>:> > ># Process id's> >proc>=> [>1>,>2>,>3>]> >n>=> 3> ># Burst time of all processes> >burst_time>=> [>10>,>5>,>8>]> ># Time quantum> >quantum>=> 2>;> >findavgTime(proc, n, burst_time, quantum)> # This code is contributed by> # Shubham Singh(SHUBHAMSINGH10)> 

>

>

C#




// C# program for implementation of RR> // scheduling> using> System;> public> class> GFG {> > >// Method to find the waiting time> >// for all processes> >static> void> findWaitingTime(>int> []processes,> >int> n,>int> []bt,>int> []wt,>int> quantum)> >{> > >// Make a copy of burst times bt[] to> >// store remaining burst times.> >int> []rem_bt =>new> int>[n];> > >for> (>int> i = 0 ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round // robin manner until all of them are // not done. while(true) { bool done = true; // Traverse all processes one by // one repeatedly for (int i = 0 ; i { // If burst time of a process // is greater than 0 then only // need to process further if (rem_bt[i]>0) { // Hay un proceso pendiente realizado = false; if (rem_bt[i]> quantum) { // Aumenta el valor de t, es decir, // muestra cuánto tiempo // ha sido procesado un proceso t += quantum; // Disminuir el tiempo de ráfaga del // proceso actual en cuanto a cuántico rem_bt[i] -= quantum; } // Si el tiempo de ráfaga es menor que // o igual al cuanto. Último ciclo // para este proceso else { // Aumenta el valor de t, es decir, // muestra cuánto tiempo // ha sido procesado un proceso t = t + rem_bt[i]; // El tiempo de espera es el actual // tiempo menos el tiempo utilizado por // este proceso wt[i] = t - bt[i]; // A medida que el proceso // se ejecuta completamente, haga que el // tiempo de ráfaga restante = 0 rem_bt[i] = 0; } } } // Si todos los procesos finalizan if (done == true) break; } } // Método para calcular el tiempo de respuesta static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // calculando el tiempo de respuesta agregando // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Método para calcular el tiempo promedio static void findavgTime(int []processes, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0 // Función para encontrar el tiempo de espera de // todos; procesos findWaitingTime(processes, n, bt, wt, quantum); // Función para encontrar el tiempo de respuesta // para todos los procesos findTurnAroundTime(processes, n, bt, wt, tat // Muestra los procesos junto con // todos los detalles); Console.WriteLine('Processes ' + ' Tiempo de ráfaga ' + ' Tiempo de espera ' + ' Tiempo de respuesta'); // Calcular el tiempo total de espera y // el tiempo total de vuelta para (int i = 0; i { peso_total = peso_total + peso[i]; tat_total + tat[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Tiempo de espera promedio = ' + (float)total_wt / (float)n); Console.Write('Tiempo de respuesta promedio = ' + (float)total_tat / (float)n); } // Método del controlador public static void Main() { // ID del proceso int []procesos = { 1, 2, 3}; int n = procesos.Longitud; // Tiempo de ráfaga de todos los procesos int []burst_time = {10, 5, 8}; // Cuántico de tiempo int quantum = 2; findavgTime(procesos, n, tiempo_ráfaga, cuántico); } } // Este código es aportado por nitin mittal.> 

>

>

JavaScript




tutorial de pyspark

> >// JavaScript program for implementation of RR scheduling> >// Function to find the waiting time for all> >// processes> >const findWaitingTime = (processes, n, bt, wt, quantum) =>{> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >let rem_bt =>new> Array(n).fill(0);> >for> (let i = 0; i rem_bt[i] = bt[i]; let t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while (1) { let done = true; // Traverse all processes one by one repeatedly for (let i = 0; i // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { hecho = falso; // Hay un proceso pendiente if (rem_bt[i]> quantum) { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t += quantum; // Disminuir el tiempo de ráfaga del proceso actual // por quantum rem_bt[i] -= quantum; } // Si el tiempo de ráfaga es menor o igual que // quantum. Último ciclo para este proceso else { // Aumenta el valor de t, es decir, muestra // cuánto tiempo se ha procesado un proceso t = t + rem_bt[i]; // El tiempo de espera es el tiempo actual menos el tiempo // utilizado por este proceso wt[i] = t - bt[i]; // A medida que el proceso se ejecuta por completo // haz que el tiempo de ráfaga restante = 0 rem_bt[i] = 0; } } } // Si todos los procesos finalizan if (done == true) break; } } // Función para calcular el tiempo de respuesta const findTurnAroundTime = (processes, n, bt, wt, tat) => { // calcula el tiempo de respuesta sumando // bt[i] + wt[i] for (let i = 0; i tat[i] = bt[i] + wt[i]; } // Función para calcular el tiempo promedio const findavgTime = (procesos, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Función para encontrar el tiempo de espera de todos los procesos findWaitingTime(processes, n, bt, wt, quantum); // Función para encontrar el tiempo de respuesta para todos los procesos findTurnAroundTime(processes, n, bt, wt, tat); // Muestra los procesos junto con todos los detalles document.write(`Procesos Tiempo de ráfaga Tiempo de espera `); Calcule el tiempo total de espera y el tiempo total de vuelta // para (sea i = 0; i total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; document.write(`${i + 1} ${ bt[i]} ${wt[i]} ${tat[i]} ` } document.write(`Tiempo de espera promedio = ${total_wt / n}`); = ${total_tat / n}`); } // Código del controlador // procesos de identificación del proceso = [1, 2, 3]; sea ​​n = procesos.longitud; // Tiempo de ráfaga de todos los procesos let burst_time = [10, 5, 8]; // Cuanto de tiempo let quantum = 2; findavgTime(procesos, n, tiempo_ráfaga, cuántico); // Este código es aportado por rakeshsahni> 

>

>

Producción 

PN BT WT TAT 1 10 13 23 2 5 10 15 3 8 13 21 Average waiting time = 12 Average turn around time = 19.6667>

Programa de programación Round Robin con hora de llegada cero, horas de llegada diferentes e iguales

C++




#include> #include> using> namespace> std;> struct> Process {> >int> AT, BT, ST[20], WT, FT, TAT, pos;> };> int> quant;> int> main() {> >int> n, i, j;> >// Taking Input> >cout <<>'Enter the no. of processes: '>;> >cin>>n;> >Process p[n];> >cout <<>'Enter the quantum: '> << endl;> >cin>>cuanto;> >cout <<>'Enter the process numbers: '> << endl;> >for> (i = 0; i cin>> p[i].pos; corte<< 'Enter the Arrival time of processes: ' << endl; for (i = 0; i cin>> p[i].AT; corte<< 'Enter the Burst time of processes: ' << endl; for (i = 0; i cin>> p[i].BT; // Declarando variables int c = n, s[n][20]; tiempo de flotación = 0, mini = INT_MAX, b[n], a[n]; // Inicializando matrices de ráfaga y tiempo de llegada int index = -1; para (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; para (j = 0; j<20; j++) { s[i][j] = -1; } } int tot_wt, tot_tat; tot_wt = 0; tot_tat = 0; bool flag = false; while (c != 0) { mini = INT_MAX; flag = false; for (i = 0; i float p = time + 0.1; if (a[i] <= p && mini>a[i] && b[i]> 0) { índice = i; mini = a[yo]; bandera = verdadero; } } // si en =1 entonces el bucle sale, por lo tanto establece el indicador en falso if (!flag) { time++; continuar; } // calculando la hora de inicio j = 0; mientras (s[índice][j] != -1) { j++; } if (s[índice][j] == -1) { s[índice][j] = tiempo; p[índice].ST[j] = tiempo; } si (b[índice]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[índice] = tiempo + 0,1; } // calculando llegada, ráfaga, tiempos finales if (b[index] == 0) { c--; p[índice].FT = tiempo; p[índice].WT = p[índice].FT - p[índice].AT - p[índice].BT; tot_wt += p[índice].WT; p[índice].TAT = p[índice].BT + p[índice].WT; tot_tat += p[índice].TAT; } } // fin del ciclo while // Impresión de salida cout<< 'Process number '; cout << 'Arrival time '; cout << 'Burst time '; cout << ' Start time'; j = 0; while (j != 10) { j += 1; cout << ' '; } cout << ' Final time'; cout << ' Wait Time '; cout << ' TurnAround Time' << endl; for (i = 0; i cout << p[i].pos << ' '; cout << p[i].AT << ' '; cout << p[i].BT << ' '; j = 0; int v = 0; while (s[i][j] != -1) { cout << p[i].ST[j] << ' '; j++; v += 3; } while (v != 40) { cout << ' '; v += 1; } cout << p[i].FT << ' '; cout << p[i].WT << ' '; cout << p[i].TAT << endl; } // Calculating average wait time and turnaround time double avg_wt, avg_tat; avg_wt = tot_wt / static_cast(n); avg_tat = tot_tat / static_cast(norte); // Imprimir el tiempo de espera promedio y el tiempo de respuesta cout<< 'The average wait time is: ' << avg_wt << endl; cout << 'The average TurnAround time is: ' << avg_tat << endl; return 0; }> 

>

>

C




#include> #include> #include> struct> P{> int> AT,BT,ST[20],WT,FT,TAT,pos;> };> int> quant;> int> main(){> int> n,i,j;> // Taking Input> printf>(>'Enter the no. of processes :'>);> scanf>(>'%d'>,&n);> struct> P p[n];> > printf>(>'Enter the quantum '>);> scanf>(>'%d'>,&quant);> printf>(>'Enter the process numbers '>);> for>(i=0;i scanf('%d',&(p[i].pos)); printf('Enter the Arrival time of processes '); for(i=0;i scanf('%d',&(p[i].AT)); printf('Enter the Burst time of processes '); for(i=0;i scanf('%d',&(p[i].BT)); // Declaring variables int c=n,s[n][20]; float time=0,mini=INT_MAX,b[n],a[n]; // Initializing burst and arrival time arrays int index=-1; for(i=0;i b[i]=p[i].BT; a[i]=p[i].AT; for(j=0;j<20;j++){ s[i][j]=-1; } } int tot_wt,tot_tat; tot_wt=0; tot_tat=0; bool flag=false; while(c!=0){ mini=INT_MAX; flag=false; for(i=0;i float p=time+0.1; if(a[i]a[i] && b[i]>0){ índice=i; mini=a[yo]; bandera = verdadero; } } // si en =1 entonces el bucle sale, por lo tanto establece el indicador en falso if(!flag){ time++; continuar; } //calculando la hora de inicio j=0; while(s[índice][j]!=-1){ j++; } if(s[índice][j]==-1){ s[índice][j]=hora; p[índice].ST[j]=tiempo; } si(b[índice]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[índice]=tiempo+0.1; } // calculando llegada, ráfaga, tiempos finales if(b[index]==0){ c--; p[índice].FT=tiempo; p[índice].WT=p[índice].FT-p[índice].AT-p[índice].BT; tot_wt+=p[índice].WT; p[índice].TAT=p[índice].BT+p[índice].WT; tot_tat+=p[índice].TAT; } } // fin del ciclo while // Impresión del resultado printf('Número de proceso '); printf('Hora de llegada '); printf('Tiempo de ráfaga '); printf(' Hora de inicio'); j=0; mientras(j!=10){ j+=1; printf(''); } printf(' Hora final'); printf(' Tiempo de espera '); printf(' Tiempo de respuesta '); for(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d ',p[i].BT); j=0; int v=0; mientras(s[i][j]!=-1){ printf('%d ' ,p[i].ST[j]); j++; v+=3; mientras(v!=40){ printf(' ' } printf('%d ); ',p[i].FT); printf('%d ',p[i].WT); printf('%d ',p[i].TAT) ; } //Calculando el tiempo de espera promedio y el tiempo de respuesta double avg_wt,avg_tat; avg_wt=tot_wt/(float)n; avg_tat=tot_tat/(float)n; //Imprimiendo el tiempo de espera promedio y el tiempo de respuesta printf('La espera promedio el tiempo es: %lf ',avg_wt); printf('El tiempo promedio de respuesta es: %lf ',avg_tat return }>'>); 

> 
mapa vs conjunto

    
 Enter the number of processes : 4 Enter the time quanta : 2 Enter the process numbers : 1 2 3 4 Enter the arrival time of the processes : 0 1 2 3 Enter the burst time of the processes : 5 4 2 1 Program No. Arrival Time Burst Time Wait Time TurnAround Time 1 0 5 7 12 2 1 4 6 10 3 2 2 2 4 4 3 1 5 6 Average wait time : 5 Average Turn Around Time : 8>

Programa de programación Round Robin con diferentes horarios de llegada para todos los procesos

Para una implementación detallada del algoritmo Round Robin preventivo con diferentes tiempos de llegada para todos los procesos, consulte: Programa de programación Round Robin con diferentes horarios de llegada .

Conclusión

En conclusión, la programación de CPU Round Robin es un algoritmo justo y preventivo que asigna una cantidad de tiempo fija a cada proceso, garantizando un acceso equitativo a la CPU. Es sencillo de implementar, pero puede generar una mayor sobrecarga de cambio de contexto. Si bien promueve la equidad y previene la hambruna, puede resultar en tiempos de espera más largos y un rendimiento reducido, dependiendo de la cantidad de tiempo. La implementación efectiva del programa permite calcular métricas clave como el tiempo de finalización, el tiempo de respuesta y el tiempo de espera, lo que ayuda en la evaluación y optimización del desempeño.