Round Robin je CPU plánovací algoritmus, kde je každému procesu cyklicky priradený pevný časový slot. Je to preventívna verzia plánovacieho algoritmu CPU „kto prv príde, ten prv melie“.
vytvorenie poľa reťazcov v jazyku Java
- Algoritmus Round Robin CPU sa vo všeobecnosti zameriava na techniku zdieľania času.
- Časový úsek, počas ktorého môže proces alebo úloha bežať preventívnou metódou, sa nazýva čas kvantový .
- Každému procesu alebo úlohe prítomnej vo fronte pripravenosti je pridelený CPU na dané časové kvantum, ak sa vykonávanie procesu dokončí počas tohto času, proces sa koniec inak sa proces vráti späť na čakací stôl a počkajte na jeho ďalší ťah, aby ste dokončili vykonanie.
Charakteristiky Round Robin CPU plánovacieho algoritmu
- Je to jednoduché, ľahko implementovateľné a bez hladovania, keďže všetky procesy získavajú primeraný podiel CPU.
- Jedna z najčastejšie používaných techník v plánovanie CPU je jadro.
- to je preventívne pretože procesy sú priradené CPU iba na určitý čas, najviac na určitý čas.
- Nevýhodou je väčšia réžia prepínania kontextu.
Výhody Round Robin CPU plánovacieho algoritmu
- Existuje spravodlivosť, pretože každý proces dostane rovnaký podiel na CPU.
- Novovytvorený proces sa pridá na koniec pripraveného frontu.
- Plánovač typu round-robin vo všeobecnosti využíva zdieľanie času, pričom každej úlohe dáva časový úsek alebo kvantum.
- Pri vykonávaní cyklického plánovania je rôznym úlohám pridelené určité množstvo času.
- Každý proces dostane šancu preplánovať po určitom kvantovom čase v tomto plánovaní.
Nevýhody Round Robin CPU plánovacieho algoritmu
- K dispozícii je dlhší čas čakania a čas odozvy.
- Má nízku priepustnosť.
- Existujú prepínače kontextu.
- Zdá sa, že Ganttov diagram je príliš veľký (ak je kvantový čas kratší na plánovanie. Napríklad: 1 ms na veľké plánovanie.)
- Časovo náročné plánovanie pre malé množstvo.
Príklady na ukážku fungovania Round Robin Algoritmus plánovania
Príklad-1: Zvážte nasledujúcu tabuľku času príchodu a času zhluku pre štyri procesy P1, P2, P3 a P4 a daný Kvantový čas = 2
| Proces | Burst Time | Čas príchodu |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Algoritmus plánovania CPU Round Robin bude fungovať na základe krokov uvedených nižšie:
V čase = 0,
- Vykonanie začína procesom P1, ktorý má čas zhluku 5.
- Tu sa každý proces vykonáva 2 milisekundy ( Časové kvantové obdobie ). P2 a P3 sú stále v čakacom rade.
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci burst Čas |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
V čase = 2,
- Procesy P1 a P3 dorazia do pripraveného radu a P2 sa začne vykonávať TQ obdobie
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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 prichádza do pripravený rad ,
- Potom sa vykoná P3 TQ obdobie.
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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čí svoju realizáciu
- Proces P1 sa spustí pre TQ obdobie, ako je ďalšie v b.
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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 sa začne vykonávať, nevykoná sa Čas Kvantové obdobie pretože čas prasknutia = 1
- Preto sa vykoná iba 1 ms.
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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čí svoju realizáciu
- Proces P2 sa spustí pre TQ obdobie, ako je to ďalšie v pripravený rad
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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čí svoju realizáciu.
- Proces P1 sa začne vykonávať, bude prebiehať iba 1 ms
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci burst Čas |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0 ms | P1 | 1 ms | 1 ms | 0 ms |
V čase = 12,
- Proces P1 dokončí svoju realizáciu.
- Celkové vykonávanie procesov bude uvedené nižšie:
| Časová inštancia | Proces | Čas príchodu | Pripravený front | Spustený front | Čas vykonania | Počiatočný čas burstu | Zostávajúci 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 |
Ganttov diagram bude nasledovný:
Ganttov diagram pre plánovací algoritmus Round Robin
Ako vypočítať nižšie časy v Round Robin pomocou programu?
- Čas dokončenia: Čas, kedy proces dokončí svoju realizáciu.
- Čas obratu: Čas Rozdiel medzi časom dokončenia a časom príchodu. Čas obratu = čas dokončenia – čas príchodu
- Čakacia doba (W.T): Čas Rozdiel medzi časom otočenia a časom výbuchu.
Čas čakania = Čas obrátenia – Čas zhluku
Teraz vypočítajme priemer čakaciu dobu a otočte sa čas:
| Procesy | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | jedenásť | 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 |
teraz
- Priemerný čas obratu = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Priemerná čakacia doba = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Príklad 2: Zvážte nasledujúcu tabuľku času príchodu a času zhluku pre tri procesy P1, P2 a P3 a sú dané Kvantový čas = 2
| Proces | Burst Time | Čas príchodu |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
podobne, Ganttov diagram pre tento príklad:
Napríklad Ganttov diagram 2
Teraz vypočítajme priemer čakaciu dobu a otočte sa čas:
| Procesy | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | pätnásť | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | dvadsaťjeden | 21-0 = 21 | 21-8 = 13 |
Celkový čas obratu = 59 ms
takže, Priemerný čas obratu = 59/3 = 19,667 msA celkový čas čakania = 36 ms
takže, Priemerný čas čakania = 36/3 = 12,00 ms
Program pre plánovanie Round Robin s časom príchodu ako 0 pre všetky procesy
Kroky na nájdenie čakacích dôb všetkých procesov
- Vytvorte pole rem_bt[] sledovať zostávajúci čas zhluku procesov. Toto pole je pôvodne kópiou bt[] (pole burst times)
- Vytvorte ďalšie pole wt[] ukladať čakacie doby procesov. Inicializujte toto pole ako 0.
- Čas inicializácie: t = 0
- Pokračujte v prechádzaní všetkými procesmi, kým nie sú hotové. Postupujte podľa ja proces, ak ešte nie je urobený.
- Ak rem_bt[i]> kvantum
- t = t + kvantum
- rem_bt[i] -= suma;
- Else // Posledný cyklus tohto procesu
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Tento proces sa skončil
Keď máme čakacie doby, môžeme vypočítať čas obratu tat[i] procesu ako súčet čakacích a burst časov, t.j. wt[i] + bt[i].
Nižšie je uvedená implementácia vyššie uvedených krokov.
C++
// C++ program for implementation of RR scheduling> #include> using> namespace> std;> // Function to find the waiting time for all> // processes> void> findWaitingTime(>int> processes[],>int> n,> >int> bt[],>int> wt[],>int> quantum)> {> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >int> rem_bt[n];> >for> (>int> i = 0 ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while (1) { bool done = true; // Traverse all processes one by one repeatedly for (int i = 0 ; i { // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { hotovo = nepravda; // Existuje čakajúci proces if (rem_bt[i]> quantum) { // Zvýšenie hodnoty t t.j. ukazuje // koľko času bol proces spracovaný t += kvantum; // Znížte burst_time aktuálneho procesu // o quantum rem_bt[i] -= quantum; } // Ak je čas impulzu menší alebo rovný // kvantu. Posledný cyklus tohto procesu else { // Zvýšenie hodnoty t t.j. ukazuje // ako dlho bol proces spracovávaný t = t + rem_bt[i]; // Čas čakania je aktuálny čas mínus čas // použitý týmto procesom wt[i] = t - bt[i]; // Keď sa proces úplne vykoná, // urobí jeho zostávajúci čas burst = 0 rem_bt[i] = 0; } } } // Ak sú všetky procesy hotové if (done == true) break; } } // Funkcia na výpočet času obratu void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // výpočet času obratu pridaním // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funkcia na výpočet priemerného času void findavgTime(int procesy[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0 // Funkcia na zistenie čakacej doby všetkých procesov findWaitingTime (process, n, bt, wt, quantum); Funkcia na nájdenie času obratu pre všetky procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazenie procesov spolu so všetkými detailmi 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
nick pulos čierny blesk
// 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) { hotovo = nepravda; // Existuje čakajúci proces if (rem_bt[i]> quantum) { // Zvýšenie hodnoty t t.j. ukazuje // koľko času bol proces spracovaný t += kvantum; // Znížte burst_time aktuálneho procesu // o quantum rem_bt[i] -= quantum; } // Ak je čas impulzu menší alebo rovný // kvantu. Posledný cyklus tohto procesu else { // Zvýšenie hodnoty t t.j. ukazuje // ako dlho bol proces spracovávaný t = t + rem_bt[i]; // Čas čakania je aktuálny čas mínus čas // použitý týmto procesom wt[i] = t - bt[i]; // Keď sa proces úplne vykoná, // urobí jeho zostávajúci čas burst = 0 rem_bt[i] = 0; } } } // Ak sú všetky procesy hotové if (done == true) break; } } // Metóda výpočtu času obratu static void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // výpočet času obratu pridaním // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metóda výpočtu priemerného času statického void findavgTime(int procesy[], int n, int bt[], int kvantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Funkcia na zistenie čakacej doby všetkých procesov findWaitingTime(; procesy, n, bt, wt, kvantum // Funkcia na nájdenie času obratu pre všetky procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazenie procesov spolu so všetkými detailmi System.out.println(); 'PN ' + ' B ' + ' WT ' + ' TAT' // Vypočítajte celkový čas čakania a celkový obrat // okolo času pre (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('Priemerná doba čakania = ' + (float)total_wt / (float)n); System.out.println('Priemerný čas obratu = ' + (float)total_tat / (float)n); } // Metóda ovládača public static void main(String[] args) { // ID procesu int procesy[] = { 1, 2, 3}; int n = procesy.dĺžka; // Čas burst všetkých procesov int burst_time[] = {10, 5, 8}; // Časové kvantum int kvantum = 2; findavgTime(process, 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]>kvantum):> > ># 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)> |
str na int
>
>
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) { // Čaká sa na proces dokončený = false; if (rem_bt[i]> quantum) { // Zvýšenie hodnoty t t.j. // ukazuje, ako dlho bol proces // spracovaný t += kvantum; // Znížte burst_time // aktuálneho procesu o kvantové rem_bt[i] -= kvantové; } // Ak je čas impulzu menší ako // alebo rovný kvantu. Posledný cyklus // pre tento proces else { // Zvýšenie hodnoty t t.j. // ukazuje, ako dlho bol proces // spracovávaný t = t + rem_bt[i]; // Doba čakania je aktuálna // čas mínus čas použitý // týmto procesom wt[i] = t - bt[i]; // Keď sa proces úplne // vykoná, urobte jeho zostávajúci // čas burst = 0 rem_bt[i] = 0; } } } // Ak sú všetky procesy hotové if (done == true) break; } } // Metóda výpočtu času obratu static void findTurnAroundTime(int []process, int n, int []bt, int []wt, int []tat) { // výpočet času obratu pridaním // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metóda výpočtu priemerného času statického void findavgTime(int []procesy, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; procesy findWaitingTime(processes, n, bt, wt, quantum // Funkcia na nájdenie času obratu // pre všetky procesy findTurnAroundTime(processes, n, bt, wt, tat) // Zobrazenie procesov spolu s // všetkými detailmi Console.WriteLine('Procesy ' + ' Čas prerušenia ' + ' Čas čakania ' + ' Čas obratu' // Vypočítajte celkový čas čakania a celkový čas obratu // pre (int i = 0 i { total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Priemerná doba čakania = ' + (float)total_wt / (float)n); Console.Write('Priemerný čas obratu = ' + (float)total_tat / (float)n); } // Metóda ovládača public static void Main() { // ID procesu's int []processes = { 1, 2, 3}; int n = procesy.Dĺžka; // Čas burst všetkých procesov int []burst_time = {10, 5, 8}; // Časové kvantum int kvantum = 2; findavgTime(process, n, burst_time, quantum); } } // Tento kód prispel 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) { hotovo = nepravda; // Existuje čakajúci proces if (rem_bt[i]> quantum) { // Zvýšenie hodnoty t t.j. ukazuje // koľko času bol proces spracovaný t += kvantum; // Znížte burst_time aktuálneho procesu // o quantum rem_bt[i] -= quantum; } // Ak je čas impulzu menší alebo rovný // kvantu. Posledný cyklus tohto procesu else { // Zvýšenie hodnoty t t.j. ukazuje // ako dlho bol proces spracovávaný t = t + rem_bt[i]; // Čas čakania je aktuálny čas mínus čas // použitý týmto procesom wt[i] = t - bt[i]; // Keď sa proces úplne vykoná, // urobí jeho zostávajúci čas burst = 0 rem_bt[i] = 0; } } } // Ak sú všetky procesy hotové if (done == true) break; } } // Funkcia na výpočet času obratu const findTurnAroundTime = (procesy, n, bt, wt, tat) => { // výpočet času obratu pridaním // bt[i] + wt[i] for (nech i = 0 i tat[i] = bt[i] + wt[i] } // Funkcia na výpočet priemerné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; // Funkcia na nájdenie času obratu pre všetky procesy findTurnAroundTime(processes, n, bt, wt, tat // Zobrazenie procesov spolu so všetkými podrobnosťami document.write(`Procesy Burst time Waiting time // Čas otočenia `); Vypočítajte celkový čas čakania a celkový čas obratu // čas okolo (nech 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(`Priemerná doba čakania = ${total_wt / n}` document.write(` Priemerná doba obratu = ${total_tat / n}`); } // Kód ovládača // procesy id procesu = [1, 2, 3]; nech n = procesy.dĺžka; // Burst time všetkých procesov nech burst_time = [10, 5, 8]; // Časové kvantum nech kvantum = 2; findavgTime(process, n, burst_time, quantum); // Tento kód prispel rakeshsahni> |
>
upraviť súbor linux
>Výkon
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 pre Round Robin Scheduling s časom príchodu ako nula, rôzne a rovnaké časy príchodu
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>> kvantita;> >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; // Deklarovanie premenných int c = n, s[n][20]; float time = 0, mini = INT_MAX, b[n], a[n]; // Inicializácia polí zhluku a času príchodu int index = -1; pre (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; pre (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]; príznak = pravda; } } // ak je na =1, slučka sa dostane von, preto nastavte príznak na hodnotu false if (!flag) { time++; ďalej; } // výpočet počiatoč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 príchodov, zhlukov, konečných časov 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; } } // koniec cyklu while // Tlač 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
10 zo 100,00
#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]; vlajka=pravda; } } // ak je na =1, potom sa cyklus dostane von, preto nastavte príznak na false if(!flag){ time++; ďalej; } //výpočet času začiatku 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 príchodov, zhlukov, konečných časov 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; } } // koniec cyklu while // Tlač výstupu printf('Číslo procesu '); printf('Čas príchodu '); printf('Doba prasknutia '); printf(' Čas začiatku'); j=0; while(j!=10){ j+=1; printf(' '); } printf(' Konečný čas'); printf(' Čakací čas '); 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){ printf(' ' } printf('%d ; ',p[i].FT); printf('%d ',p[i].WT); } //Vypocet priemernej doby cakania a doby obratu double avg_wt=tot_wt/(float)n avg_tat=tot_tat/(float)n //Tlac priemernej doby cakania a doby obratu printf('Priemerne cakanie; čas je: %lf
',avg_wt('Priemerný čas obratu je: %lf
',avg_tat návrat 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 na plánovanie Round Robin s rôznymi časmi príchodu pre všetky procesy
Podrobnú implementáciu algoritmu Preemptive Round Robin s rôznymi časmi príchodu pre všetky procesy nájdete na: Program pre Round Robin Scheduling s rôznymi časmi príchodu .
Záver
Na záver, plánovanie Round Robin CPU je spravodlivý a preventívny algoritmus, ktorý každému procesu prideľuje kvantum s pevným časom, čím zabezpečuje rovnaký prístup k CPU. Implementácia je jednoduchá, ale môže viesť k vyššej réžii pri prepínaní kontextu. Aj keď podporuje spravodlivosť a zabraňuje hladovaniu, môže mať za následok dlhšie čakacie doby a zníženú priepustnosť v závislosti od množstva času. Efektívna implementácia programu umožňuje výpočet kľúčových metrík, ako je čas dokončenia, čas obrátky a čas čakania, čo pomáha pri hodnotení a optimalizácii výkonu.