Round Robin és un algorisme de programació de la CPU on a cada procés se li assigna cíclicament un interval de temps fix. És la versió preventiva de l'algoritme de planificació de la CPU del primer en arribar.

avantatges i inconvenients de la tecnologia

• Round Robin CPU Algorithm generalment se centra en la tècnica de temps compartit.
• El període de temps durant el qual es permet que un procés o treball s'executi en un mètode preventiu s'anomena temps quàntic .
• A cada procés o treball present a la cua preparada se li assigna la CPU per a aquest quant de temps, si l'execució del procés es completa durant aquest temps, el procés final en cas contrari, el procés tornarà a taula d'espera i espereu al seu següent torn per completar l'execució.

Característiques de l'algoritme de planificació de CPU Round Robin

• És senzill, fàcil d'implementar i sense fam, ja que tots els processos reben una part justa de la CPU.
• Una de les tècniques més utilitzades en Programació de la CPU és un nucli.
• És preventiva ja que els processos s'assignen CPU només durant un període fix de temps com a màxim.
• El desavantatge d'això és una sobrecàrrega de canvi de context.

Avantatges de l'algoritme de planificació de CPU Round Robin

• Hi ha justícia, ja que cada procés rep una part igual de la CPU.
• El procés acabat de crear s'afegeix al final de la cua preparada.
• Un programador de rondes generalment utilitza temps compartit, donant a cada treball una franja horària o quàntica.
• Mentre es realitza una programació de rondes, s'assigna un quàntic de temps determinat a diferents treballs.
• Cada procés té l'oportunitat de reprogramar-se després d'un temps quàntic particular en aquesta programació.

Desavantatges de l'algoritme de planificació de CPU Round Robin

• Hi ha un temps d'espera i un temps de resposta més grans.
• Hi ha un rendiment baix.
• Hi ha canvis de context.
• El diagrama de Gantt sembla ser massa gran (si el temps quàntic és menor per a la programació. Per exemple: 1 ms per a una gran programació).
• Programació que consumeix temps per a quàntics petits.

Exemples per mostrar el funcionament Round Robin Algoritme de planificació

Exemple-1: Considereu la següent taula de temps d'arribada i temps d'explosió per a quatre processos P1, P2, P3 i P4 i donat Temps quàntic = 2

L'algoritme de planificació de CPU Round Robin funcionarà a partir dels passos que s'esmenten a continuació:

En el temps = 0,

• L'execució comença amb el procés P1, que té un temps d'explosió 5.
• Aquí, cada procés s'executa durant 2 mil·lisegons ( Període quàntic de temps ). P2 i P3 segueixen a la cua d'espera.

En el temps = 2,

• Els processos P1 i P3 arriben a la cua preparada i P2 comença a executar-se TQ període

En el temps = 4,

• El procés P4 arriba al cua a punt ,
• A continuació, P3 s'executa per TQ període.

En el temps = 6,

• El procés P3 finalitza la seva execució
• El procés P1 comença a executar-se per TQ període com és el següent al b.

En el temps = 8,

• El procés P4 comença a executar-se, no s'executarà Temps Període quàntic ja que té temps d'explosió = 1
• Per tant, només s'executarà durant 1 ms.

En el temps = 9,

• El procés P4 finalitza la seva execució
• El procés P2 comença a executar-se per TQ període com és el següent al cua a punt

En el temps = 11,

• El procés P2 finalitza la seva execució.
• El procés P1 comença a executar-se, només s'executarà durant 1 ms

En el temps = 12,

• El procés P1 finalitza la seva execució.
• L'execució global dels processos serà la que es mostra a continuació:

diagrama de Gantt serà el següent:

Diagrama de Gantt per a l'algoritme de planificació Round Robin

Com calcular els temps següents a Round Robin mitjançant un programa?

• Temps de finalització: Moment en què el procés finalitza la seva execució.
• Temps de resposta: Hora Diferència entre l'hora de finalització i l'hora d'arribada. Hora de volta = Temps de finalització - Hora d'arribada
• Temps d'espera (W.T): Temps Diferència entre el temps de gir i el temps d'explosió.
  Temps d'espera = Temps de volta – Temps de ràfega

Ara, calculem la mitjana temps d'espera i volta temps:

Ara,

• Temps mitjà de volta = (12 + 10 + 4 + 5)/4 = 31/4 = 7.7
• Temps mitjà d'espera = (7 + 6 + 2 + 4)/4 = 19/4 = 4.7

Exemple 2: Considereu la següent taula de temps d'arribada i temps d'explosió per a tres processos P1, P2 i P3 i donat Temps quàntic = 2

De la mateixa manera, diagrama de Gantt per aquest exemple:

Diagrama de Gantt per exemple 2

Ara, calculem la mitjana temps d'espera i volta temps:

Temps total de volta = 59 ms
Tan, Temps mitjà de volta = 59/3 = 19,667 ms

I, Temps d'espera total = 36 ms
Tan, Temps d'espera mitjà = 36/3 = 12,00 ms

Programa de Round Robin Scheduling amb l'hora d'arribada com a 0 per a tots els processos

Passos per trobar temps d'espera de tots els processos

• Crea una matriu rem_bt[] per fer un seguiment del temps de ràfega restant dels processos. Aquesta matriu és inicialment una còpia de bt[] (matriu de temps de ràfega)
• Creeu una altra matriu pes[] per emmagatzemar els temps d'espera dels processos. Inicialitzar aquesta matriu com a 0.
• Temps d'inicialització: t = 0
• Continueu recorrent tots els processos mentre no es facin. Fes el següent per jo procés si encara no s'ha fet.
  • Si rem_bt[i]> quàntic
    • t = t + quàntic
    • rem_bt[i] -= import;
  • Else // Últim cicle d'aquest procés
    • t = t + rem_bt[i];
    • pes[i] = t – bt[i]
    • rem_bt[i] = 0; // Aquest procés s'ha acabat

Un cop tenim temps d'espera, podem calcular el temps de gir tat[i] d'un procés com a suma de temps d'espera i d'explosió, és a dir, wt[i] + bt[i].
A continuació es mostra la implementació dels passos anteriors.

C++

'abc' està en números'

>

>

Java

> 
    
   
 
     
  
funcions d'arduino
 
    
 
     
     
    
 
 
 
 
 
 # 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]>quàntic) :> > ># 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) { // Hi ha un procés pendent fet = fals;    if (rem_bt[i]> quàntic) { // Augmenta el valor de t, és a dir, // mostra quant de temps s'ha processat un procés // t += quàntic;    // Disminueix el temps de ràfega del // procés actual per quantum rem_bt[i] -= quantum;  } // Si el temps de ràfega és menor que // o igual al quàntic. Últim cicle // per a aquest procés sinó { // Augmenta el valor de t, és a dir, // mostra quant de temps s'ha processat un procés // t = t + rem_bt[i];    // El temps d'espera és actual // el temps menys el temps utilitzat per // aquest procés wt[i] = t - bt[i];    // A mesura que el procés s'executa completament // fa que el seu // temps d'explosió restant = 0 rem_bt[i] = 0;  } } } // Si es fan tots els processos si (fet == cert) es trenca;  } } // Mètode per calcular el temps de canvi static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // calculant el temps de resposta afegint // bt[i ] + wt[i] per (int i = 0; i tat[i] = bt[i] + wt[i]; } // Mètode per calcular el temps mitjà estàtic void findavgTime(int []processos, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; processes findWaitingTime(processos, n, bt, wt, quantum // Funció per trobar el temps de gir // per a tots els processos findTurnAroundTime(processos, n, bt, wt, tat // Mostra els processos juntament amb // tots els detalls); Console.WriteLine('Processos ' + ' Temps de ràfega ' + ' Temps d'espera ' + ' Temps de volta' // Calcula el temps d'espera total i el temps total de gir // al voltant del (int i = 0; i { total_wt = total_wt + wt[i] = total_tat + tat[i]; ] + '	 ' + wt[i] +'		 ' + tat[i]);  } Console.WriteLine('Temps d'espera mitjà = ' + (float)total_wt / (float)n);  Console.Write('Temps mitjà de volta = ' + (float)total_tat / (float)n);  } // Mètode del controlador public static void Main() { // process id's int []processes = { 1, 2, 3};  int n = processos.Longitud;    // Temps de ràfega de tots els processos int []burst_time = {10, 5, 8};    // Temps quàntic int quàntic = 2;  findavgTime(processos, n, burst_time, quàntic);  } } // Aquest codi és aportat per nitin mittal.>>>
 
 
 
 
    
 
> 
    
   
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > >// 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) { fet = fals; // Hi ha un procés pendent si (rem_bt[i]> quàntic) { // Augmenta el valor de t, és a dir, mostra // quant de temps s'ha processat un procés t += quàntic;  // Disminueix el temps de ràfega del procés actual // per quantum rem_bt[i] -= quantum;  } // Si el temps de ràfega és menor o igual que // quàntic. Últim cicle per a aquest procés sinó { // Augmenta el valor de t, és a dir, mostra // quant de temps s'ha processat un procés t = t + rem_bt[i];  // El temps d'espera és el temps actual menys el temps // utilitzat per aquest procés wt[i] = t - bt[i];  // A mesura que el procés s'executa completament // fa que el seu temps de ràfega restant = 0 rem_bt[i] = 0;  } } } // Si es fan tots els processos si (fet == cert) es trenca;  } } // Funció per calcular el temps de retorn const findTurnAroundTime = (processos, n, bt, wt, tat) => { // calculant el temps de resposta afegint // bt[i] + wt[i] per (deixar i = 0; i tat[i] = bt[i] + wt[i] } // Funció per calcular el temps mitjà const findavgTime = (processos, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0 // Funció per trobar el temps d'espera de tots els processos findWaitingTime(processes, n, bt, wt, quantum); // Funció per trobar el temps de gir per a tots els processos findTurnAroundTime(processos, n, bt, wt, tat // Mostra els processos juntament amb tots els detalls document.write(`Processos Temps de ràfega Temps d'espera `); Calcula el temps d'espera total i la volta total // al voltant del temps per a (permet 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(`Temps d'espera mitjà = ${total_wt / n}` document.write(` Temps mitjà d'espera = ${total_tat / n}`);  } // Codi del controlador // processos d'identificador del procés = [1, 2, 3];  sigui n = processos.longitud;  // El temps de ràfega de tots els processos permet burst_time = [10, 5, 8];  // Temps quàntic deixa quàntic = 2;  findavgTime(processos, n, burst_time, quàntic);  // Aquest codi és aportat per rakeshsahni>
 
 
 
 
    
 
>
 
    
 
>
 
  Sortida  
 
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 Round Robin Scheduling amb hora d'arribada zero, diferents i iguals    
 
C++
    
 
     
  
maneig d'excepcions java
 
    
 
     
     
    
 
hola món amb java
 
 
 
 
 #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>> quant;> >cout <<>'Enter the process numbers: '> << endl;> >for> (i = 0; i   cin>> p[i].pos;  cout<< 'Enter the Arrival time of processes: ' << endl;  for (i = 0; i   cin>> p[i].AT;  cout<< 'Enter the Burst time of processes: ' << endl;  for (i = 0; i   cin>> p[i].BT;  // Declaració de variables int c = n, s[n][20];  temps de flotació = 0, mini = INT_MAX, b[n], a[n];  // Inicialització de matrius d'hora d'arribada i ràfega int índex = -1;  per a (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; per a (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) { índex = i;  mini = a[i];  bandera = cert;  } } // si a =1, llavors el bucle surt, per tant, estableix el senyalador a fals if (!bandera) { temps++;  continuar;  } // calculant l'hora d'inici j = 0;  mentre que (s[índex][j] != -1) { j++;  } if (s[índex][j] == -1) { s[índex][j] = temps;  p[índex].ST[j] = temps;  } si (b[índex]<= quant) {  time += b[index];  b[index] = 0;  } else {  time += quant;  b[index] -= quant;  }  if (b[index]>0) { a[índex] = temps + 0,1;  } // càlcul d'arribada, ràfega, temps finals if (b[índex] == 0) { c--;  p[índex].FT = temps;  p[índex].WT = p[índex].FT - p[índex].AT - p[índex].BT;  tot_wt += p[índex].WT;  p[índex].TAT = p[índex].BT + p[índex].WT;  tot_tat += p[índex].TAT;  } } // final del bucle while // Impressió de la sortida<< '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(n);  // Imprimeix el temps d'espera mitjà i el temps de resposta<< '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){ índex=i;  mini=a[i];  bandera = cert;    } } // si a =1, llavors el bucle surt, per tant, es defineix el senyalador a fals if(!flag){ temps++;  continuar; } //càlcul de l'hora d'inici j=0; mentre(s[índex][j]!=-1){ j++; } if(s[índex][j]==-1){ s[índex][j]=temps; p[índex].ST[j]=temps; } if(b[índex]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[índex]=temps+0,1; } // calculant l'arribada, la ràfega, els temps finals if(b[índex]==0){ c--; p[índex].FT=temps; p[índex].WT=p[índex].FT-p[índex].AT-p[índex].BT; tot_wt+=p[índex].WT; p[índex].TAT=p[índex].BT+p[índex].WT; tot_tat+=p[index].TAT; } } // final del bucle while // Imprimeix la sortida printf('Número de procés '); printf('Hora d'arribada'); printf('Hora d'explosió'); printf('	Hora d'inici'); j=0; mentre que(j!=10){ j+=1; printf(''); } printf('		Hora final'); printf('	Temps d'espera '); printf('	Temps de canvi
'); for(i=0;i printf('%d 		',p[i].pos); printf('%d 		',p[i].AT); printf ('%d 	',p[i].BT); int v=0 (s[i][j]!=-1){ printf('%d ' ,p[i].ST[j]); j++; v+=3; ',p[i].FT); printf('%d	',p[i].WT); printf('%d
',p[i].TAT) } //Càlcul del temps d'espera mitjà i el temps d'execució doble avg_wt, avg_tat=tot_wt/(float)n //Impressió del temps d'espera mitjà i d'espera; el temps és: %lf
',avg_wt printf('El temps mitjà de retorn és: %lf
',avg_tat }>'>);
 
 
 
 
    
 
> 
    
 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ó de Round Robin amb diferents horaris d'arribada per a tots els processos    
 
Per obtenir una implementació detallada de l'algoritme Preemptive Round Robin amb diferents hores d'arribada per a tots els processos, consulteu: Programa de Round Robin Scheduling amb diferents horaris d'arribada .
 
Conclusió
 
En conclusió, la programació de la CPU Round Robin és un algorisme just i preventiu que assigna un quàntic de temps fix a cada procés, assegurant un accés igual a la CPU. És senzill d'implementar, però pot comportar una major sobrecàrrega de canvi de context. Tot i que promou l'equitat i prevé la fam, pot provocar temps d'espera més llargs i un rendiment reduït, depenent del quàntic de temps. La implementació eficaç del programa permet calcular mètriques clau com ara el temps d'acabament, el temps de resposta i el temps d'espera, ajudant a l'avaluació i optimització del rendiment.