Round Robin je algoritem za razporejanje procesorja, kjer je vsakemu procesu ciklično dodeljena fiksna časovna reža. Je preventivna različica algoritma za razporejanje procesorja prvi pride, prvi melje.
cdr polna oblika
- CPU algoritem Round Robin se na splošno osredotoča na tehniko delitve časa.
- Časovno obdobje, v katerem se postopek ali opravilo lahko izvaja v preventivni metodi, se imenuje čas kvantni .
- Vsakemu procesu ali opravilu, prisotnemu v pripravljeni čakalni vrsti, je dodeljen CPE za ta časovni kvantum; če je izvajanje procesa v tem času končano, bo proces konec drugače se bo postopek vrnil na čakalna miza in počakajte na naslednjo vrsto, da dokončate izvedbo.
Značilnosti algoritma za razporejanje CPU Round Robin
- Je preprost, enostaven za implementacijo in brez stradanja, saj vsi procesi dobijo pošten delež CPE-ja.
- Ena najpogosteje uporabljenih tehnik pri CPE razporejanje je jedro.
- je preventivno saj je procesom dodeljen CPE samo za največ določen čas.
- Pomanjkljivost je večja poraba preklapljanja konteksta.
Prednosti algoritma za razporejanje procesorja Round Robin
- Obstaja pravičnost, saj vsak proces dobi enak delež CPE-ja.
- Novo ustvarjeni proces je dodan na konec pripravljene čakalne vrste.
- Round-robin razporejevalnik na splošno uporablja deljenje časa, tako da vsakemu opravilu dodeli časovno režo ali kvantum.
- Med izvajanjem krožnega razporejanja je določena količina časa dodeljena različnim opravilom.
- Vsak proces dobi priložnost za prerazporeditev po določenem kvantnem času v tem razporejanju.
Slabosti algoritma za razporejanje CPU Round Robin
- Obstaja večja čakalna doba in odzivni čas.
- Obstaja nizka prepustnost.
- Obstajajo kontekstna stikala.
- Zdi se, da je gantogram prevelik (če je kvantni čas manjši za razporejanje. Na primer: 1 ms za veliko razporejanje.)
- Časovno potratno načrtovanje za majhne količine.
Primeri za prikaz delovanja Round Robin Algoritem za razporejanje
Primer-1: Upoštevajte naslednjo tabelo časa prihoda in časa izbruha za štiri procese P1, P2, P3 in P4 in dano Časovni kvant = 2
| Proces | Burst Time | Čas prihoda |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Algoritem za razporejanje CPU Round Robin bo deloval na podlagi spodaj navedenih korakov:
Ob času = 0,
- Izvajanje se začne s procesom P1, ki ima čas izbruha 5.
- Tu se vsak proces izvaja 2 milisekundi ( Časovno kvantno obdobje ). P2 in P3 sta še vedno v čakalni vrsti.
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0ms | P2, P3 | P1 | 2ms | 5ms | 3ms |
Ob času = 2,
- Procesa P1 in P3 prispeta v pripravljeno čakalno vrsto in P2 se začne izvajati za TQ obdobje
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3ms | 3ms |
| P2 | 1ms | 2ms | 4ms | 2ms |
Ob času = 4,
- Proces P4 prispe v pripravljena čakalna vrsta ,
- Nato se P3 izvede za TQ obdobje.
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3ms | 3ms |
| P2 | 1ms | 0ms | 2ms | 2ms | |||
| P3 | 2ms | 2ms | 2ms | 0ms |
Ob času = 6,
- Proces P3 zaključi svojo izvedbo
- Proces P1 se začne izvajati za TQ obdobje, kot je naslednje v b.
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 6-8ms | P1 | 0ms | P4, P2 | P1 | 2ms | 3ms | 1ms |
| P2 | 1ms | 0ms | 2ms | 2ms |
Ob času = 8,
- Proces P4 se začne izvajati, ne bo se izvajal za Čas Kvantno obdobje saj ima čas razpoke = 1
- Zato se bo izvajal samo 1 ms.
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 8-9 ms | P1 | 0ms | P2, P1 | P4 | 0ms | 3ms | 1ms |
| P2 | 1ms | 0ms | 2ms | 2ms | |||
| P4 | 4ms | 1ms | 1ms | 0ms |
Ob času = 9,
- Proces P4 zaključi svojo izvedbo
- Proces P2 se začne izvajati za TQ obdobju, kot je naslednje v pripravljena čakalna vrsta
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3ms | 1ms |
| P2 | 1ms | 2ms | 2ms | 0ms |
Ob času = 11,
- Proces P2 zaključi svojo izvedbo.
- Proces P1 se začne izvajati, izvajal se bo samo 1 ms
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0ms | P1 | 1ms | 1ms | 0ms |
Ob času = 12,
- Proces P1 zaključi svojo izvedbo.
- Celotna izvedba postopkov bo prikazana spodaj:
| Časovni primerek | Proces | Čas prihoda | Čakalna vrsta pripravljena | Čakalna vrsta v teku | Čas izvedbe | Začetni čas izbruha | Preostali izbruh Čas |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0ms | P2, P3 | P1 | 2ms | 5ms | 3ms |
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3ms | 3ms |
| P2 | 1ms | 2ms | 4ms | 2ms | |||
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3ms | 3ms |
| P2 | 1ms | 0ms | 2ms | 2ms | |||
| P3 | 2ms | 2ms | 2ms | 0ms | |||
| 6-8ms | P1 | 0ms | P4, P2 | P1 | 2ms | 3ms | 1ms |
| P2 | 1ms | 0ms | 2ms | 2ms | |||
| 8-9 ms | P1 | 0ms | P2, P1 | P4 | 0ms | 3ms | 1ms |
| P2 | 1ms | 0ms | 2ms | 2ms | |||
| P4 | 4ms | 1ms | 1ms | 0ms | |||
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3ms | 1ms |
| P2 | 1ms | 2ms | 2ms | 0ms | |||
| 11-12 ms | P1 | 0ms | P1 | 1ms | 1ms | 0ms |
Gantogram bo sledeče:
Ganttov grafikon za algoritem krožnega razporejanja
Kako s programom izračunati spodnje čase v Round Robin?
- Čas dokončanja: Čas, ko proces zaključi svojo izvedbo.
- Čas obračanja: Časovna razlika med časom dokončanja in časom prihoda. Čas obračanja = čas dokončanja – čas prihoda
- Čakalna doba (W.T): Časovna razlika med časom obračanja in časom porušitve.
Čakalna doba = Čas obračanja – Čas porušitve
Zdaj pa izračunajmo povprečje čakalne dobe in se obrnite čas:
| Procesi | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | enajst | 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 |
zdaj,
- Povprečni čas obračanja = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Povprečna čakalna doba = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Primer 2: Upoštevajte naslednjo tabelo časa prihoda in časa izbruha za tri procese P1, P2 in P3 in podane Časovni kvant = 2
| Proces | Burst Time | Čas prihoda |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Podobno, Gantogram za ta primer:
Ganttov grafikon na primer 2
Zdaj pa izračunajmo povprečje čakalne dobe in se obrnite čas:
| Procesi | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | petnajst | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | enaindvajset | 21-0 = 21 | 21-8 = 13 |
Skupni čas obračanja = 59 ms
Torej, Povprečni čas obračanja = 59/3 = 19,667 msIn skupni čakalni čas = 36 ms
Torej, Povprečna čakalna doba = 36/3 = 12,00 ms
Program za Round Robin Scheduling s časom prihoda 0 za vse procese
Koraki za iskanje čakalnih dob vseh procesov
- Ustvarite niz rem_bt[] za spremljanje preostalega časa izbruha procesov. Ta niz je na začetku kopija bt[] (matrika burst times)
- Ustvarite drugo matriko teža [] za shranjevanje čakalnih dob procesov. Inicializirajte to matriko kot 0.
- Čas inicializacije: t = 0
- Še naprej prečkajte vse procese, dokler niso končani. Sledite za i’th postopek, če še ni končan.
- Če je rem_bt[i]> quantum
- t = t + kvant
- rem_bt[i] -= znesek;
- Drugače // Zadnji cikel za ta proces
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Ta proces je končan
Ko imamo čakalne dobe, lahko izračunamo obratovalni čas tat[i] procesa kot vsoto čakalnih in razpočnih časov, tj. wt[i] + bt[i].
Spodaj je izvedba zgornjih korakov.
C++
pomen dhl
// 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) { narejeno = napačno; // Obstaja proces v teku if (rem_bt[i]> quantum) { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t += quantum; // Zmanjšaj burst_time trenutnega procesa // za kvantni rem_bt[i] -= kvantni; } // Če je razpočni čas manjši ali enak // kvantumu. Zadnji cikel za ta proces else { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t = t + rem_bt[i]; // Čakalni čas je trenutni čas minus čas // ki ga uporablja ta proces wt[i] = t - bt[i]; // Ko se proces v celoti izvede // naj bo njegov preostali čas izbruha = 0 rem_bt[i] = 0; } } } // Če so vsi procesi končani if (done == true) break; } } // Funkcija za izračun časa obtoka void findTurnAroundTime(int processs[], int n, int bt[], int wt[], int tat[]) { // izračun časa obtoka z dodajanjem // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funkcija za izračun povprečnega časa void findavgTime(int processs[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Funkcija za iskanje čakalne dobe vseh procesov findWaitingTime(processes, n, bt, wt, quantum); Funkcija za iskanje časa obračanja za vse procese findTurnAroundTime(processes, n, bt, wt, tat); // Prikaži procese skupaj z vsemi podrobnostmi 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) { narejeno = napačno; // Obstaja proces v teku if (rem_bt[i]> quantum) { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t += quantum; // Zmanjšaj burst_time trenutnega procesa // za kvantni rem_bt[i] -= kvantni; } // Če je razpočni čas manjši ali enak // kvantumu. Zadnji cikel za ta proces else { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t = t + rem_bt[i]; // Čakalni čas je trenutni čas minus čas // ki ga uporablja ta proces wt[i] = t - bt[i]; // Ko se proces v celoti izvede // naj bo njegov preostali čas izbruha = 0 rem_bt[i] = 0; } } } // Če so vsi procesi končani if (done == true) break; } } // Metoda za izračun časa obtoka static void findTurnAroundTime(int processs[], int n, int bt[], int wt[], int tat[]) { // izračun časa obtoka z dodajanjem // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda za izračun povprečnega časa static void findavgTime(int processs[], int n, int bt[], int quantum) { int wt[] = new int[n]; int total_wt = 0; // Funkcija za iskanje čakalne dobe vseh procesov findWaitingTime( processs, n, bt, wt, quantum); // Funkcija za iskanje časa obračanja za vse procese findTurnAroundTime(processes, n, bt, wt, tat); // Prikaži procese skupaj z vsemi podrobnostmi System.out.println( 'PN ' + ' B ' + ' WT ' + ' TAT'); // Izračunaj skupni čas čakanja in skupni čas obrata // za (int i=0; i { total_wt = total_wt + wt[i]; total_tat + tat[i]; System.out.println(' ' + (i+1) + ' ' + bt[i] +' ' + wt[i] +' ' + tat[i]); } System.out.println('Povprečni čas čakanja = ' + (float)total_wt / (float)n); System.out.println('Povprečni čas obračanja = ' + (float)total_tat / (float)n); } // Metoda gonilnika public static void main(String[] args) { // ID procesa int processs[] = { 1, 2, 3}; int n = procesi.dolžina; // Čas izbruha vseh procesov int burst_time[] = {10, 5, 8}; // Kvantum časa int quantum = 2; findavgTime(procesi, n, burst_time, quantum); } }> |
>
>
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]>kvantno) :> > ># 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#
pretvorba tipov in pretvorba v javi
// 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) { // Obstaja čakajoč proces done = false; if (rem_bt[i]> quantum) { // Poveča vrednost t tj. // pokaže, koliko časa je bil proces // obdelan t += quantum; // Zmanjšaj burst_time // trenutnega procesa za kvantni rem_bt[i] -= kvantni; } // Če je razpočni čas manjši od // ali enak kvantumu. Zadnji cikel // za ta proces else { // Povečaj vrednost t tj. // pokaže, koliko časa // je bil obdelan proces t = t + rem_bt[i]; // Čakalni čas je trenuten // čas minus čas, ki ga uporablja // ta proces wt[i] = t - bt[i]; // Ko se proces v celoti // izvede, naj bo njegov preostali // razpočni čas = 0 rem_bt[i] = 0; } } } // Če so vsi procesi končani if (done == true) break; } } // Metoda za izračun časa obtoka static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // izračun časa obtoka z dodajanjem // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda za izračun povprečnega časa static void findavgTime(int []processes, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_tat = 0; // Funkcija za iskanje čakalne dobe za vse processs findWaitingTime(processes, n, bt, wt, quantum); // Funkcija za iskanje časa obračanja // za vse procese findTurnAroundTime(processes, n, bt, wt, tat); // Prikaži procese skupaj z // vsemi podrobnostmi Console.WriteLine('Processes ' + ' Burst time ' + ' Waiting time ' + ' Turnround time'); // Izračunajte skupni čakalni čas in skupni čas obratovanja // za (int i = 0; i { total_wt + wt[i]; total_tat + tat[i]; Console.WriteLine(' ' + (i+1) + ' ' + bt[i] ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Povprečni čakalni čas = ' + (float)total_wt / (float)n); Console.Write('Povprečni čas obračanja = ' + (float)total_tat / (float)n); } // Metoda gonilnika public static void Main() { // ID procesa int []processes = { 1, 2, 3}; int n = procesi.Dolžina; // Čas izbruha vseh procesov int []burst_time = {10, 5, 8}; // Kvantum časa int quantum = 2; findavgTime(procesi, n, burst_time, quantum); } } // To kodo je prispeval nitin mittal.> |
>
>
Javascript
seznam programov python
> >// 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) { narejeno = napačno; // Obstaja proces v teku if (rem_bt[i]> quantum) { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t += quantum; // Zmanjšaj burst_time trenutnega procesa // za kvantni rem_bt[i] -= kvantni; } // Če je razpočni čas manjši ali enak // kvantumu. Zadnji cikel za ta proces else { // Povečaj vrednost t, tj. pokaže // koliko časa je bil proces obdelan t = t + rem_bt[i]; // Čakalni čas je trenutni čas minus čas // ki ga uporablja ta proces wt[i] = t - bt[i]; // Ko se proces v celoti izvede // naj bo njegov preostali čas izbruha = 0 rem_bt[i] = 0; } } } // Če so vsi procesi končani if (done == true) break; } } // Funkcija za izračun časa obtoka const findTurnAroundTime = (processes, n, bt, wt, tat) => { // izračun časa obtoka z dodajanjem // bt[i] + wt[i] for (naj i = 0; i tat[i] + wt[i]; // Funkcija za izračun povprečnega časa const findavgTime = (processes, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Funkcija za iskanje čakalne dobe vseh procesov findWaitingTime(processes, n, bt, wt, quantum); // Funkcija za iskanje časa obračanja za vse procese findTurnAroundTime(processes, n, bt, wt, tat); // Prikaz procesov skupaj z vsemi podrobnostmidocument.write(`Processes Burst time Waiting time Turnround time`); Izračunajte skupni čakalni čas in skupni čas obračanja // za (naj i = 0; i total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; document.write(`${i + 1} ${) bt[i]} ${tat[i]} `); `Povprečni čas čakanja = ${total_wt / n}`); = ${total_tat / n}`); } // Koda gonilnika // proces ID procesov = [1, 2, 3]; naj n = procesi.dolžina; // Čas izbruha vseh procesov let burst_time = [10, 5, 8]; // Časovni kvant let kvantni = 2; findavgTime(procesi, n, burst_time, quantum); // To kodo je prispeval rakeshsahni> |
>
>Izhod
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 za krožno razporejanje z ničelnim časom prihoda, različnimi in enakimi časi prihoda
C++
veriženje naprej
#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>> količina;> >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; // Deklaracija spremenljivk int c = n, s[n][20]; plavajoči čas = 0, mini = INT_MAX, b[n], a[n]; // Inicializacija nizov izbruha in časa prihoda int index = -1; za (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; za (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) { indeks = i; mini = a[i]; zastavica = res; } } // če je pri =1, se zanka izklopi, zato je zastavica nastavljena na false if (!flag) { čas++; nadaljevati; } // izračun začetnega časa j = 0; medtem ko (s[indeks][j] != -1) { j++; } if (s[index][j] == -1) { s[index][j] = čas; p[indeks].ST[j] = čas; } če (b[indeks]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[indeks] = čas + 0,1; } // izračun prihoda, izbruha, končnih časov if (b[index] == 0) { c--; p[indeks].FT = čas; p[indeks].WT = p[indeks].FT - p[indeks].AT - p[indeks].BT; tot_wt += p[index].WT; p[indeks].TAT = p[indeks].BT + p[indeks].WT; tot_tat += p[index].TAT; } } // konec zanke while // Izpis izpisa 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 |
>
>
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){ indeks=i; mini=a[i]; zastava=true; } } // if at =1 then loop gets out zato nastavite zastavico na false if(!flag){ time++; nadaljevati; } //izračun začetnega časa j=0; medtem ko(s[indeks][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=čas; p[indeks].ST[j]=čas; } če(b[indeks]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[indeks]=čas+0,1; } // izračun prihodov, izbruhov, končnih časov if(b[index]==0){ c--; p[indeks].FT=čas; p[indeks].WT=p[indeks].FT-p[indeks].AT-p[indeks].BT; tot_wt+=p[index].WT; p[indeks].TAT=p[indeks].BT+p[indeks].WT; tot_tat+=p[index].TAT; } } // konec zanke while // Izpis tiskanja printf('Številka procesa '); printf('Čas prihoda '); printf('Čas izbruha '); printf(' Začetni čas'); j=0; medtem ko(j!=10){ j+=1; printf(' '); } printf(' Končni čas'); printf(' Čakalna doba '); printf(' Čas obrabe
'); for(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d',p[i].BT); int v=0; medtem ko(s[i]!=-1){ printf('%d ' ,p[j]); v+=3; printf(''); printf('%d ',p[i].FT); printf('%d ',p[i].WT); printf('%d
',p[i].TAT) } //Izračun povprečnega časa čakanja in časa obtoka double avg_wt=tot_wt/(float)n; //Izpis povprečnega časa čakanja printf('Povprečni čas čakanja čas je: %lf
',avg_wt); |
>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 za krožno razporejanje z različnimi časi prihoda za vse procese
Za podrobno izvedbo algoritma Preemptive Round Robin z različnimi časi prihoda za vse procese glejte: Program za Round Robin razpored z različnimi časi prihoda .
Zaključek
Skratka, Round Robin CPE razporejanje je pravičen in preventiven algoritem, ki vsakemu procesu dodeli fiksni časovni kvant in zagotavlja enak dostop do CPE. Izvedba je preprosta, vendar lahko povzroči večje stroške preklapljanja konteksta. Čeprav spodbuja pravičnost in preprečuje stradanje, lahko povzroči daljše čakalne dobe in zmanjšan pretok, odvisno od časovnega kvantuma. Učinkovito izvajanje programa omogoča izračun ključnih meritev, kot so čas dokončanja, čas obtoka in čakalna doba, kar pomaga pri ocenjevanju uspešnosti in optimizaciji.