Round Robin este un algoritm de planificare a CPU în care fiecărui proces i se atribuie ciclic un interval de timp fix. Este versiunea preventivă a algoritmului de planificare a CPU, primul venit, primul servit.

cum se returnează o matrice în java

• Algoritmul CPU Round Robin se concentrează în general pe tehnica de partajare a timpului.
• Perioada de timp pentru care un proces sau un job este permis să ruleze într-o metodă preventivă se numește timp cuantic .
• Fiecărui proces sau job prezent în coada pregătită i se atribuie CPU pentru acel cuantum de timp, dacă execuția procesului este finalizată în acel timp, atunci procesul va Sfârşit altfel procesul se va întoarce la masa de asteptare și așteptați următorul său rând pentru a finaliza execuția.

Caracteristicile algoritmului de planificare CPU Round Robin

• Este simplu, ușor de implementat și fără înfometare, deoarece toate procesele primesc o parte echitabilă de CPU.
• Una dintre cele mai frecvent utilizate tehnici în programarea procesorului este un nucleu.
• Este preventivă deoarece proceselor li se atribuie CPU numai pentru o perioadă fixă ​​de timp cel mult.
• Dezavantajul acestuia este mai mult peste schimbarea contextului.

Avantajele algoritmului de programare CPU Round Robin

• Există corectitudine, deoarece fiecare proces primește o cotă egală din CPU.
• Procesul nou creat este adăugat la sfârșitul cozii de așteptare.
• Un planificator round-robin folosește, în general, partajarea timpului, oferind fiecărei lucrări un interval de timp sau un cuantum.
• În timp ce se efectuează o programare round-robin, un anumit cuantum de timp este alocat diferitelor locuri de muncă.
• Fiecare proces are șansa de a se reprograma după un anumit timp cuantic din această programare.

Dezavantajele algoritmului de programare CPU Round Robin

• Există un timp de așteptare și un timp de răspuns mai mare.
• Există un randament scăzut.
• Există comutatoare de context.
• Diagrama Gantt pare să fie prea mare (dacă timpul cuantic este mai mic pentru programare. De exemplu: 1 ms pentru programare mare.)
• Programare consumatoare de timp pentru cuantumul mic.

Exemple pentru a arăta funcționarea Round Robin Algoritmul de programare

Exemplul-1: Luați în considerare următorul tabel al timpului de sosire și al timpului de explozie pentru patru procese P1, P2, P3 și P4 și dat Time Quantum = 2

Algoritmul de programare CPU Round Robin va funcționa pe baza pașilor menționați mai jos:

La timp = 0,

• Execuția începe cu procesul P1, care are timpul de explozie 5.
• Aici, fiecare proces se execută timp de 2 milisecunde ( Perioada cuantică de timp ). P2 și P3 sunt încă în coada de așteptare.

La timp = 2,

• Procesele P1 și P3 ajung în coada gata și P2 începe să se execute pentru TQ perioadă

La timp = 4,

• Procesul P4 ajunge în coada gata ,
• Apoi P3 se execută pentru TQ perioadă.

La timp = 6,

• Procesul P3 își finalizează execuția
• Procesul P1 începe să se execute pentru TQ perioada cum este următoarea în b.

La timp = 8,

• Procesul P4 începe să se execute, nu se va executa pentru Perioada cuantică de timp deoarece are timp de explozie = 1
• Prin urmare, se va executa doar 1 ms.

La timp = 9,

• Procesul P4 își finalizează execuția
• Procesul P2 începe să se execute pentru TQ perioada cum este următoarea în coada gata

La timp = 11,

• Procesul P2 își finalizează execuția.
• Procesul P1 începe să se execute, se va executa doar 1 ms

La timp = 12,

• Procesul P1 își finalizează execuția.
• Execuția generală a proceselor va fi după cum se arată mai jos:

Diagrama Gantt va fi după cum urmează:

Diagrama Gantt pentru algoritmul de programare Round Robin

Cum se calculează timpii de mai jos în Round Robin folosind un program?

• Timp de finalizare: Momentul în care procesul își finalizează execuția.
• Ora de întoarcere: Ora Diferența dintre ora de finalizare și ora de sosire. Ora de întoarcere = Ora de finalizare – Ora de sosire
• Timp de așteptare (W.T): Timp Diferența dintre timpul de întoarcere și timpul de explozie.
  Timp de așteptare = Timp de întoarcere – Timp de explozie

Acum, să calculăm media timp de așteptare și întoarce-te timp:

Acum,

• Timp mediu de întoarcere = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
• Timp mediu de așteptare = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7

Exemplul 2: Luați în considerare următorul tabel al timpului de sosire și al timpului de explozie pentru trei procese P1, P2 și P3 și dat Time Quantum = 2

În mod similar, Diagrama Gantt pentru acest exemplu:

Diagrama Gantt de exemplu 2

Acum, să calculăm media timp de așteptare și întoarce-te timp:

Timp total de întoarcere = 59 ms
Asa de, Timp mediu de întoarcere = 59/3 = 19,667 ms

Și, timpul total de așteptare = 36 ms
Asa de, Timp mediu de așteptare = 36/3 = 12,00 ms

Program pentru programare Round Robin cu ora de sosire ca 0 pentru toate procesele

Pași pentru a găsi timpii de așteptare pentru toate procesele

• Creați o matrice rem_bt[] pentru a urmări timpul de explozie rămas al proceselor. Această matrice este inițial o copie a bt[] (matrice de explozie)
• Creați o altă matrice greutate[] pentru a stoca timpii de așteptare ai proceselor. Inițializați această matrice ca 0.
• Timpul de inițializare: t = 0
• Continuați să parcurgeți toate procesele cât timp nu sunt finalizate. Faceți următoarele pentru eu proces dacă nu este încă finalizat.
  • Dacă rem_bt[i]> quantum
    • t = t + cuantică
    • rem_bt[i] -= suma;
  • Else // Ultimul ciclu pentru acest proces
    • t = t + rem_bt[i];
    • wt[i] = t – bt[i]
    • rem_bt[i] = 0; // Acest proces s-a încheiat

Odată ce avem timpii de așteptare, putem calcula timpul de întoarcere tat[i] al unui proces ca sumă a timpilor de așteptare și de explozie, adică wt[i] + bt[i].
Mai jos este implementarea pașilor de mai sus.

C++

șir la int

>

>

Java

> 
    
   
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 # 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]>>>>) :> >done>=> False> # There is a pending process> > >if> (rem_bt[i]>cuantică) :> > ># 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#
    
hashset java
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // 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) { // Există un proces în așteptare făcut = false;    if (rem_bt[i]> quantum) { // Mărește valoarea lui t i.e. // arată cât timp a fost procesat un proces // t += quantum;    // Reduce timpul de explozie al // procesului curent cu quantum rem_bt[i] -= quantum;  } // Dacă timpul de explozie este mai mic decât // sau egal cu quantum. Ultimul ciclu // pentru acest proces else { // Mărește valoarea lui t, adică // arată cât timp a fost procesat un proces // t = t + rem_bt[i];    // Timpul de așteptare este curent // timpul minus timpul utilizat de // acest proces wt[i] = t - bt[i];    // Pe măsură ce procesul devine complet // executat, faceți // timpul de explozie rămas = 0 rem_bt[i] = 0;  } } } // Dacă toate procesele sunt finalizate dacă (terminat == adevărat) break;  } } // Metodă de calculare a timpului de întoarcere static void findTurnAroundTime(int []proceses, int n, int []bt, int []wt, int []tat) { // calcularea timpului de răspuns prin adăugarea // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metodă de calcul al timpului mediu static void findavgTime(int []procese, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; procese findWaitingTime(procese, n, bt, wt, quantum // Funcție pentru a găsi timpul de întoarcere // pentru toate procesele findTurnAroundTime(procese, n, bt, wt, tat // Afișează procesele împreună cu // toate detaliile); Console.WriteLine('Procese ' + ' Timp de explozie ' + ' Timp de așteptare ' + ' Timpul de întoarcere' // Calculați timpul total de așteptare și timpul total de rotație pentru (int i = 0; i { total_wt = total_wt [i] total_tat = total_tat + tat[i]; ] + '	 ' + wt[i] +'		 ' + tat[i]);  } Console.WriteLine('Timp mediu de așteptare = ' + (float)total_wt / (float)n);  Console.Write('Timp mediu de întoarcere = ' + (float)total_tat / (float)n);  } // Metoda driverului public static void Main() { // ID-ul procesului int []procese = { 1, 2, 3};  int n = procese.Lungime;    // Timpul de explozie al tuturor proceselor int []burst_time = {10, 5, 8};    // Time quantum int quantum = 2;  findavgTime(procese, n, burst_time, quantum);  } } // Acest cod este contribuit de nitin mittal.>>>
 
 
 
 
    
 
> 
    
   
 
     
  
emoji-uri iPhone pe telefonul Android
 
    
 
     
     
    
 
 
 
 
 
 > >// 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) { done = false; // Există un proces în așteptare dacă (rem_bt[i]> quantum) { // Mărește valoarea lui t, adică arată // cât timp a fost procesat un proces t += quantum;  // Reduce timpul de explozie a procesului curent // cu quantum rem_bt[i] -= quantum;  } // Dacă timpul de explozie este mai mic sau egal cu // quantum. Ultimul ciclu pentru acest proces else { // Mărește valoarea lui t, adică arată // cât timp a fost procesat un proces t = t + rem_bt[i];  // Timpul de așteptare este timpul curent minus timpul // utilizat de acest proces wt[i] = t - bt[i];  // Pe măsură ce procesul devine complet executat // face ca timpul de explozie rămas = 0 rem_bt[i] = 0;  } } } // Dacă toate procesele sunt finalizate dacă (terminat == adevărat) break;  } } // Funcția de calculare a timpului de întoarcere const findTurnAroundTime = (procese, n, bt, wt, tat) => { // calcularea timpului de întoarcere prin adăugarea // bt[i] + wt[i] pentru (lasă i = 0; i tat[i] = bt[i] + wt[i] } // Funcție pentru calcularea timpului mediu const findavgTime = (procese, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0 // Funcție pentru a găsi timpul de așteptare al tuturor proceselor findWaitingTime(procese, n, bt, wt, quantum); // Funcție pentru a găsi timpul de întoarcere pentru toate procesele findTurnAroundTime(procese, n, bt, wt, tat // Afișează procesele împreună cu toate detaliile document.write(`Procese Timp de explozie Timp de așteptare `); Calculați timpul total de așteptare și timpul total de rotație // în jurul timpului pentru (fie 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(`Timp mediu de așteptare = ${total_wt / n}`]; = ${total_tat / n}`);  } // Cod driver // procese ID-ul procesului = [1, 2, 3];  fie n = procese.lungime;  // Timpul de explozie al tuturor proceselor let burst_time = [10, 5, 8];  // Time quantum fie quantum = 2;  findavgTime(procese, n, burst_time, quantum);  // Acest cod este contribuit de rakeshsahni>
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
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>
 
    Program pentru programare Round Robin cu ora de sosire la zero, ore de sosire diferite și aceleași    
 
C++
    
 
     
  
 
    
 
     
     
    
scrieți json în fișierul python
 
 
 
 
 
 #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;  // Declararea variabilelor int c = n, s[n][20];  timp de flotare = 0, mini = INT_MAX, b[n], a[n];  // Inițializarea matricelor de explozie și timp de sosire int index = -1;  pentru (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; pentru (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) { index = i;  mini = a[i];  steag = adevărat;  } } // dacă la =1 atunci bucla iese, deci setați flag la fals if (!flag) { time++;  continua;  } // calcularea timpului de pornire j = 0;  în timp ce (s[index][j] != -1) { j++;  } if (s[index][j] == -1) { s[index][j] = timp;  p[index].ST[j] = timp;  } dacă (b[index]<= quant) {  time += b[index];  b[index] = 0;  } else {  time += quant;  b[index] -= quant;  }  if (b[index]>0) { a[index] = timp + 0,1;  } // calculând sosirea, explozia, timpii finali dacă (b[index] == 0) { c--;  p[index].FT = timp;  p[index].WT = p[index].FT - p[index].AT - p[index].BT;  tot_wt += p[index].WT;  p[index].TAT = p[index].BT + p[index].WT;  tot_tat += p[index].TAT;  } } // sfârşitul buclei while // Imprimarea ieşirii<< '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);  // Imprimarea timpului mediu de așteptare și a timpului de livrare<< '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){ index=i;  mini=a[i];  steag=adevarat;    } } // dacă la =1 atunci bucla iese deci setați flag la fals if(!flag){ time++;  continua; } //calcularea timpului de începere j=0; while(s[index][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=timp; p[index].ST[j]=timp; } if(b[index]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[index]=timp+0,1; } // calculează sosirea, explozia, timpii finale if(b[index]==0){ c--; p[index].FT=timp; p[index].WT=p[index].FT-p[index].AT-p[index].BT; tot_wt+=p[index].WT; p[index].TAT=p[index].BT+p[index].WT; tot_tat+=p[index].TAT; } } // sfârşitul buclei while // Tipărirea ieşirii printf('Numărul procesului'); printf('Ora de sosire'); printf('Ora exploziei'); printf('	Ora de începere'); j=0; în timp ce(j!=10){ j+=1; printf(' '); } printf('		Ora finală'); printf('	Timp de așteptare'); printf('	TurnAround Time
'); for(i=0;i printf('%d 		',p[i].pos); printf('%d 		',p[i].AT); printf ('%d 	',p[i].BT); int v=0; while(s[i][j]!=-1){ printf('%d '; ,p[i].ST[j]); j++ v+=3; while(v!=40){ printf('%d	; ',p[i].FT); printf('%d 		',p[i].WT); ; } //Calculul timpului mediu de așteptare și a duratei dublu avg_wt,avg_tat=tot_wt/(float)n //Prințirea timpului mediu de așteptare și a timpului mediu de așteptare; time is : %lf
',avg_wt printf('Timpul mediu de retur este: %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>
 
    Program de programare Round Robin cu ore de sosire diferite pentru toate procesele    
 
Pentru implementarea detaliată a algoritmului Preemptive Round Robin cu ore de sosire diferite pentru toate procesele, vă rugăm să consultați: Program de programare Round Robin cu diferite ore de sosire .
 
Concluzie
 
În concluzie, programarea CPU Round Robin este un algoritm corect și preventiv care alocă un cuantum fix de timp fiecărui proces, asigurând acces egal la CPU. Este simplu de implementat, dar poate duce la o suprasarcină mai mare de schimbare a contextului. În timp ce promovează corectitudinea și previne înfometarea, poate duce la timpi de așteptare mai lungi și o capacitate redusă, în funcție de cuantumul de timp. Implementarea eficientă a programului permite calcularea unor valori cheie, cum ar fi timpul de finalizare, timpul de realizare și timpul de așteptare, ajutând la evaluarea și optimizarea performanței.