Round Robin je plánovací algoritmus CPU, kde je každému procesu cyklicky přiřazen pevný časový slot. Je to preventivní verze plánovacího algoritmu CPU „kdo dřív přijde, je dřív na řadě“.
řetězec pro char v Javě
- Round Robin CPU Algorithm se obecně zaměřuje na techniku sdílení času.
- Časové období, po které může proces nebo úloha běžet v preventivní metodě, se nazývá čas kvantová .
- Každému procesu nebo úloze přítomné ve frontě připravenosti je přiřazeno CPU pro dané časové kvantum, pokud je provádění procesu dokončeno během této doby, proces se konec jinak se proces vrátí do čekací stůl a počkejte na jeho další kolo, aby se provedení dokončilo.
Charakteristika plánovacího algoritmu Round Robin CPU
- Je to jednoduché, snadno implementovatelné a bez hladovění, protože všechny procesy dostávají spravedlivý podíl na CPU.
- Jedna z nejčastěji používaných technik v plánování CPU je jádro.
- to je preventivní protože procesům je přiřazen CPU pouze na pevně stanovený úsek času.
- Nevýhodou je větší režie přepínání kontextu.
Výhody plánovacího algoritmu Round Robin CPU
- Existuje spravedlnost, protože každý proces dostane stejný podíl na CPU.
- Nově vytvořený proces je přidán na konec připravené fronty.
- Plánovač typu round-robin obecně využívá sdílení času, které dává každé práci časový úsek nebo kvantum.
- Při provádění cyklického plánování je různým úlohám přiděleno určité časové množství.
- Každý proces má možnost přeplánovat po určitém kvantovém čase v tomto plánování.
Nevýhody Round Robin CPU plánovacího algoritmu
- Je zde delší čekací doba a doba odezvy.
- Je zde nízká propustnost.
- Existují přepínače kontextu.
- Ganttův diagram se zdá být příliš velký (pokud je kvantový čas kratší pro plánování. Například: 1 ms pro velké plánování.)
- Časově náročné plánování pro malé kvantum.
Příklady k ukázce fungování Round Robin Algoritmus plánování
Příklad-1: Zvažte následující tabulku doby příchodu a doby shluku pro čtyři procesy P1, P2, P3 a P4 a dáno Kvantový čas = 2
| Proces | Burst Time | Čas příjezdu |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Round Robin CPU Scheduling Algorithm bude fungovat na základě kroků uvedených níže:
V čase = 0,
- Provádění začíná procesem P1, který má dobu shluku 5.
- Zde se každý proces provádí po dobu 2 milisekund ( Časové kvantové období ). P2 a P3 jsou stále ve frontě.
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
V čase = 2,
- Procesy P1 a P3 dorazí do připravené fronty a P2 se začne provádět TQ doba
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
V čase = 4,
- Proces P4 přichází do připravená fronta ,
- Poté se P3 provede pro TQ doba.
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 4-6 ms | P1 | 0 ms | P1, P4, P2 | P3 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| P3 | 2 ms | 2 ms | 2 ms | 0 ms |
V čase = 6,
- Proces P3 dokončí své provádění
- Proces P1 se spustí pro TQ období jako další v b.
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0 ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms |
V čase = 8,
- Proces P4 se spustí, nebude se provádět Čas Kvantové období protože doba prasknutí = 1
- Spustí se tedy pouze 1 ms.
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 8-9 ms | P1 | 0 ms | P2, P1 | P4 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1 ms | 1 ms | 0 ms |
V čase = 9,
- Proces P4 dokončí své provádění
- Proces P2 se spustí pro TQ období, jako je další v připravená fronta
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0 ms | P1 | P2 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0 ms |
V čase = 11,
- Proces P2 dokončí své provádění.
- Proces P1 se spustí, bude probíhat pouze 1 ms
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0 ms | P1 | 1 ms | 1 ms | 0 ms |
V čase = 12,
- Proces P1 dokončí své provádění.
- Celkové provedení procesů bude, jak je uvedeno níže:
| Časová instance | Proces | Čas příjezdu | Připravená fronta | Běžící fronta | Doba provedení | Počáteční čas burst | Zbývající burst Čas |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms | |||
| 4-6 ms | P1 | 0 ms | P1, P4, P2 | P3 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| P3 | 2 ms | 2 ms | 2 ms | 0 ms | |||
| 6-8 ms | P1 | 0 ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| 8-9 ms | P1 | 0 ms | P2, P1 | P4 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1 ms | 1 ms | 0 ms | |||
| 9-11 ms | P1 | 0 ms | P1 | P2 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0 ms | |||
| 11-12 ms | P1 | 0 ms | P1 | 1 ms | 1 ms | 0 ms |
Ganttův diagram bude následující:
Ganttův diagram pro Round Robin Scheduling Algorithm
Jak vypočítat níže uvedené časy v Round Robin pomocí programu?
- Čas dokončení: Čas, kdy proces dokončí své provádění.
- Doba obratu: Čas Rozdíl mezi časem dokončení a časem příjezdu. Turn Around Time = Čas dokončení – Čas příjezdu
- Čekací doba (W.T): Čas Rozdíl mezi časem otočení a časem výbuchu.
Čekací doba = Turn Around Time – Burst Time
Nyní pojďme vypočítat průměr čekací dobu a otočte se čas:
| Procesy | NA | BT | ČT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | jedenáct | 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 |
Nyní,
- Průměrný čas obratu = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Průměrná čekací doba = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Příklad 2: Vezměme v úvahu následující tabulku doby příchodu a doby shluku pro tři procesy P1, P2 a P3 a je daná Kvantový čas = 2
| Proces | Burst Time | Čas příjezdu |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Podobně, Ganttův diagram pro tento příklad:
Ganttův diagram například 2
Nyní pojďme vypočítat průměr čekací dobu a otočte se čas:
| Procesy | NA | BT | ČT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | patnáct | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | dvacet jedna | 21-0 = 21 | 21-8 = 13 |
Celková doba obratu = 59 ms
Tak, Průměrná doba obratu = 59/3 = 19,667 msA celková čekací doba = 36 ms
Tak, Průměrná čekací doba = 36/3 = 12,00 ms
Program pro Round Robin Scheduling s časem příjezdu jako 0 pro všechny procesy
Kroky k nalezení čekacích dob všech procesů
- Vytvořte pole rem_bt[] ke sledování zbývající doby burst procesů. Toto pole je zpočátku kopií bt[] (pole burst times)
- Vytvořte další pole wt[] ukládat čekací doby procesů. Inicializujte toto pole jako 0.
- Čas inicializace: t = 0
- Pokračujte v procházení všech procesů, dokud nejsou hotové. Sledujte pro já proces, pokud ještě není hotový.
- Pokud rem_bt[i]> kvantové
- t = t + kvantum
- rem_bt[i] -= částka;
- Else // Poslední cyklus tohoto procesu
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Tento proces je u konce
Jakmile máme čekací doby, můžeme spočítat čas obratu tat[i] procesu jako součet čekacích a burst časů, tj. wt[i] + bt[i].
Níže je implementace výše uvedených kroků.
C++
mylivecricket
// 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) { done = false; // Existuje nevyřízený proces if (rem_bt[i]> quantum) { // Zvýšení hodnoty t, tj. ukazuje // jak dlouho byl proces zpracováván t += quantum; // Snížení doby burst_time aktuálního procesu // o kvantové rem_bt[i] -= kvantové; } // Pokud je doba výbuchu menší nebo rovna // kvantové. Poslední cyklus pro tento proces else { // Zvýšení hodnoty t tj. ukazuje // jak dlouho byl proces zpracováván t = t + rem_bt[i]; // Doba čekání je aktuální čas mínus čas // použitý tímto procesem wt[i] = t - bt[i]; // Jakmile se proces plně spustí, // udělejte zbývající čas burst = 0 rem_bt[i] = 0; } } } // Pokud jsou všechny procesy hotové if (done == true) break; } } // Funkce pro výpočet doby obratu void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // výpočet doby obratu přidáním // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funkce pro výpočet průměrného času void findavgTime(int procesů[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0 // Funkce pro zjištění čekací doby všech procesů findWaitingTime(processes, n, bt, wt, quantum); Funkce pro zjištění času obratu pro všechny procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazení procesů spolu se všemi detaily 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; }> |
>
>
Jáva
// 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) { done = false; // Existuje nevyřízený proces if (rem_bt[i]> quantum) { // Zvýšení hodnoty t, tj. ukazuje // jak dlouho byl proces zpracováván t += quantum; // Snížení doby burst_time aktuálního procesu // o kvantové rem_bt[i] -= kvantové; } // Pokud je doba výbuchu menší nebo rovna // kvantové. Poslední cyklus pro tento proces else { // Zvýšení hodnoty t tj. ukazuje // jak dlouho byl proces zpracováván t = t + rem_bt[i]; // Doba čekání je aktuální čas mínus čas // použitý tímto procesem wt[i] = t - bt[i]; // Jakmile se proces plně spustí, // udělejte zbývající čas burstu = 0 rem_bt[i] = 0; } } } // Pokud jsou všechny procesy hotové if (done == true) break; } } // Metoda pro výpočet doby obratu static void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // výpočet doby obratu přidáním // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda výpočtu průměrného času static void findavgTime(int process[], int n, int bt[], int kvantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Funkce pro zjištění doby čekání všech procesů findWaitingTime(; procesy, n, bt, wt, kvantum // Funkce pro nalezení času obratu pro všechny procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazení procesů spolu se všemi detaily System.out.println(); 'PN ' + ' B ' + ' WT ' + ' TAT' // Vypočítejte celkovou dobu čekání a celkový obrat // kolem času pro (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('Průměrná doba čekání = ' + (float)total_wt / (float)n); System.out.println('Průměrná doba obratu = ' + (float)total_tat / (float)n); } // Metoda ovladače public static void main(String[] args) { // ID procesu int procesy[] = { 1, 2, 3}; int n = procesy.délka; // Doba burst všech procesů int burst_time[] = {10, 5, 8}; // Časové kvantum int kvantum = 2; findavgTime(process, n, burst_time, quantum); } }> |
>
>
síťový operační systém
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]>kvantové) :> > ># 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) { // Čeká se na proces done = false; if (rem_bt[i]> kvantum) { // Zvýšení hodnoty t tj. // ukazuje, jak dlouho byl proces // zpracován t += kvantum; // Snížení doby burst_time // aktuálního procesu o quantum rem_bt[i] -= quantum; } // Pokud je doba výbuchu menší než // nebo rovna kvantu. Poslední cyklus // pro tento proces else { // Zvýšení hodnoty t tj. // ukazuje, jak dlouho byl proces // zpracováván t = t + rem_bt[i]; // Doba čekání je aktuální // čas mínus čas použitý // tímto procesem wt[i] = t - bt[i]; // Jak se proces plně // vykoná, udělejte zbývající // čas burst = 0 rem_bt[i] = 0; } } } // Pokud jsou všechny procesy hotové if (done == true) break; } } // Metoda pro výpočet doby obratu static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // výpočet doby obratu přidáním // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda výpočtu průměrného času static void findavgTime(int []process, int n, int []bt, int kvantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0; procesy findWaitingTime(processes, n, bt, wt, quantum // Funkce pro nalezení času obratu // pro všechny procesy findTurnAroundTime(processes, n, bt, wt, tat); Console.WriteLine('Procesy ' + ' Doba shluku ' + ' Doba čekání ' + ' Doba otočení' // Vypočítejte celkovou dobu čekání a celkovou dobu obratu // pro (int i = 0 i { total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Průměrná čekací doba = ' + (float)total_wt / (float)n); Console.Write('Průměrná doba obratu = ' + (float)total_tat / (float)n); } // Metoda ovladače public static void Main() { // ID procesu's int []processes = { 1, 2, 3}; int n = procesy.Délka; // Doba burst všech procesů int []burst_time = {10, 5, 8}; // Časové kvantum int kvantum = 2; findavgTime(process, n, burst_time, quantum); } } // Tento kód přispěl nitin mittal.> |
>
>
Javascript
> >// 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; // Existuje nevyřízený proces if (rem_bt[i]> quantum) { // Zvýšení hodnoty t, tj. ukazuje // jak dlouho byl proces zpracováván t += quantum; // Snížení doby burst_time aktuálního procesu // o kvantové rem_bt[i] -= kvantové; } // Pokud je doba výbuchu menší nebo rovna // kvantové. Poslední cyklus pro tento proces else { // Zvýšení hodnoty t tj. ukazuje // jak dlouho byl proces zpracováván t = t + rem_bt[i]; // Doba čekání je aktuální čas mínus čas // použitý tímto procesem wt[i] = t - bt[i]; // Jakmile se proces plně spustí, // udělejte zbývající čas burstu = 0 rem_bt[i] = 0; } } } // Pokud jsou všechny procesy hotové if (done == true) break; } } // Funkce pro výpočet doby obratu const findTurnAroundTime = (procesy, n, bt, wt, tat) => { // výpočet doby obratu přidáním // bt[i] + wt[i] for (ať i = 0 i tat[i] = bt[i] + wt[i] } // Funkce pro výpočet průměrného času const findavgTime = (procesy, n, bt, kvantum) => { nechť wt = new Array(n). fill(0), tat = new Array(n).fill(0); nech total_wt = 0, total_tat = 0; // Funkce pro zjištění času obratu pro všechny procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazení procesů spolu se všemi podrobnostmi document.write(`Procesy Burst time Waiting time // Doba otočení `); Vypočítejte celkovou dobu čekání a celkový obrat // čas kolem (ať 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(`Průměrná doba čekání = ${total_wt / n}` document.write(` Průměrná doba obratu = ${total_tat / n}`); } // Kód ovladače // procesy id procesu = [1, 2, 3]; nechť n = procesy.délka; // Doba burst všech procesů let burst_time = [10, 5, 8]; // Časové kvantum nechť kvantum = 2; findavgTime(process, n, burst_time, quantum); // Tento kód přispěl rakeshsahni> |
jinak smyčka v Javě
>
>Výstup
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 pro Round Robin Scheduling s časem příjezdu jako nula, různé a stejné časy příjezdu
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>> množství;> >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; // Deklarace proměnných int c = n, s[n][20]; float time = 0, mini = INT_MAX, b[n], a[n]; // Inicializace burst a pole časů příchodu int index = -1; pro (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; pro (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]; flag = true; } } // pokud je na =1, pak se smyčka dostane ven, proto nastavte příznak na false if (!příznak) { time++; pokračovat; } // výpočet počátečního času j = 0; while (s[index][j] != -1) { j++; } if (s[index][j] == -1) { s[index][j] = čas; p[index].ST[j] = čas; } if (b[index]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[index] = čas + 0,1; } // výpočet příchodu, shluku, konečných časů if (b[index] == 0) { c--; p[index].FT = čas; 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; } } // konec smyčky while // Tisk výstupu 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){ index=i; mini=a[i]; flag=true; } } // pokud je na =1, pak se smyčka dostane ven, proto nastavte příznak na false if(!příznak){ time++; pokračovat; } //výpočet počátečního času j=0; while(s[index][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=čas; p[index].ST[j]=čas; } if(b[index]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[index]=čas+0,1; } // výpočet příchodu, shluku, konečných časů if(b[index]==0){ c--; p[index].FT=čas; 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; } } // konec cyklu while // Tisk výstupu printf('Číslo procesu '); printf('Čas příjezdu '); printf('Doba prasknutí '); printf(' Čas začátku'); j=0; while(j!=10){ j+=1; printf(' '); } printf(' Konečný čas'); printf(' Doba čekání '); printf(' Čas obratu
'); 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]; v+=3 } while(v!=40){ v+=1 } printf('%d ; ',p[i].FTf('%d ',p[i].WT); } //Výpočet průměrné doby čekání a doby obrátky double avg_wt,avg_tat avg_wt=tot_wt/(float)n; čas je: %lf
',avg_wt('Průměrná doba obratu je: %lf
',avg_tat return 0); |
>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 pro plánování Round Robin s různými časy příjezdu pro všechny procesy
Podrobnou implementaci algoritmu Preemptive Round Robin s různými časy příchodu pro všechny procesy najdete na: Program pro Round Robin Scheduling s různými časy příjezdu .
Závěr
Závěrem lze říci, že plánování Round Robin CPU je spravedlivý a preemptivní algoritmus, který každému procesu přiděluje kvantum pevného času a zajišťuje stejný přístup CPU. Implementace je jednoduchá, ale může vést k vyšší režii při přepínání kontextu. I když to podporuje spravedlnost a zabraňuje hladovění, může to mít za následek delší čekací doby a sníženou propustnost v závislosti na časovém kvantu. Efektivní implementace programu umožňuje výpočet klíčových metrik, jako je doba dokončení, doba obratu a čekací doba, což pomáhá při hodnocení a optimalizaci výkonu.