Okrągły Robin to algorytm planowania procesora, w którym każdemu procesowi przypisuje się cyklicznie stały przedział czasowy. Jest to wersja z wywłaszczaniem algorytmu planowania procesora według zasady „kto pierwszy, ten lepszy”.
odczytać z pliku csv w Javie
- Algorytm procesora Round Robin ogólnie skupia się na technice współdzielenia czasu.
- Okres czasu, przez który proces lub zadanie może działać metodą z wywłaszczaniem, nazywany jest czasem kwant .
- Każdemu procesowi lub zadaniu znajdującemu się w kolejce gotowych przypisany jest procesor na ten kwant czasu. Jeśli wykonanie procesu zostanie zakończone w tym czasie, proces zostanie koniec w przeciwnym razie proces powróci do stół oczekujący i poczekaj na swoją następną turę, aby zakończyć egzekucję.
Charakterystyka algorytmu planowania procesora okrężnego
- Jest prosty, łatwy do wdrożenia i wolny od głodu, ponieważ wszystkie procesy otrzymują sprawiedliwy udział procesora.
- Jedna z najczęściej stosowanych technik w Planowanie procesora jest rdzeniem.
- To jest dotyczący pierwokupu ponieważ procesom przypisuje się procesor tylko na ustalony okres czasu.
- Wadą tego jest większe obciążenie związane z przełączaniem kontekstu.
Zalety algorytmu planowania procesora okrężnego
- Istnieje sprawiedliwość, ponieważ każdy proces otrzymuje równy udział procesora.
- Nowo utworzony proces dodawany jest na koniec kolejki gotowych.
- Harmonogram okrężny zazwyczaj wykorzystuje podział czasu, przydzielając każdemu zadaniu przedział czasowy lub kwant.
- Podczas planowania okrężnego określony kwant czasu jest przydzielany różnym zadaniom.
- Każdy proces ma szansę na zmianę harmonogramu po upływie określonego czasu kwantowego w tym harmonogramie.
Wady algorytmu planowania procesora okrężnego
- Wydłuża się czas oczekiwania i czas reakcji.
- Przepustowość jest niska.
- Istnieją przełączniki kontekstu.
- Wykres Gantta wydaje się być za duży (jeśli czas kwantowy jest krótszy w przypadku planowania. Na przykład: 1 ms w przypadku dużego planowania).
- Czasochłonne planowanie dla małych ilości.
Przykłady pokazujące działanie Okrągły Robin Algorytm planowania
Przykład 1: Rozważ poniższą tabelę czasu przybycia i czasu serii dla czterech procesów P1, P2, P3 i P4 i dane Kwant czasu = 2
| Proces | Czas wybuchu | Czas przybycia |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Algorytm planowania procesora okrężnego będzie działać w oparciu o kroki wymienione poniżej:
W czasie = 0,
- Wykonywanie rozpoczyna się od procesu P1, którego czas impulsu wynosi 5.
- Tutaj każdy proces jest wykonywany przez 2 milisekundy ( Okres kwantowy czasu ). P2 i P3 nadal czekają w kolejce.
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
W czasie = 2,
- Procesy P1 i P3 trafiają do kolejki gotowości i proces P2 rozpoczyna wykonywanie TQ okres
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
W czasie = 4,
- Proces P4 dociera do gotowa kolejka ,
- Następnie P3 wykonuje TQ okres.
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 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 |
W czasie = 6,
- Proces P3 kończy swoje wykonanie
- Proces P1 rozpoczyna wykonywanie przez TQ okres taki sam jak następny w b.
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0 ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms |
W czasie = 8,
- Rozpocznie się wykonywanie procesu P4, nie będzie on wykonywany przez jakiś czas Czas Okres kwantowy ponieważ ma czas pękania = 1
- Dlatego będzie wykonywany tylko przez 1 ms.
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 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 |
O godzinie = 9,
- Proces P4 kończy swoje wykonanie
- Proces P2 rozpoczyna wykonywanie TQ okres taki sam jak następny w gotowa kolejka
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0 ms | P1 | P2 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0 ms |
O godzinie = 11,
- Proces P2 kończy swoje wykonanie.
- Proces P1 rozpoczyna wykonywanie, będzie on wykonywany tylko przez 1 ms
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0 ms | P1 | 1 ms | 1 ms | 0 ms |
O godzinie = 12,
- Proces P1 kończy swoje wykonanie.
- Ogólna realizacja procesów będzie wyglądać następująco:
| Instancja czasowa | Proces | Czas przybycia | Gotowa kolejka | Działająca kolejka | Czas egzekucji | Początkowy czas wybuchu | Pozostały wybuch Czas |
|---|---|---|---|---|---|---|---|
| 0-2ms | 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 |
Wykres Gantta będzie wyglądać następująco:
Wykres Gantta dla algorytmu planowania okrężnego
Jak obliczyć poniższe czasy w Round Robin za pomocą programu?
- Czas realizacji: Czas, w którym proces kończy swoje wykonanie.
- Czas zwrotu: Czas Różnica między czasem zakończenia a czasem przybycia. Czas zwrotu = Czas zakończenia – Czas przybycia
- Czas oczekiwania (WT): Czas Różnica między czasem zwrotu a czasem wybuchu.
Czas oczekiwania = czas zwrotu – czas rozbicia
Teraz obliczmy średnią czas oczekiwania i zawróć czas:
| Procesy | NA | BT | CT | ROBIĆ FRYWOLITKI | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | jedenaście | 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,
- Średni czas zwrotu = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Średni czas oczekiwania = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Przykład 2: Rozważ poniższą tabelę czasu przybycia i czasu impulsu dla trzech procesów P1, P2 i P3 oraz podane Kwant czasu = 2
| Proces | Czas wybuchu | Czas przybycia |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Podobnie, Wykres Gantta dla tego przykładu:
Przykładowy wykres Gantta 2
Teraz obliczmy średnią czas oczekiwania i zawróć czas:
| Procesy | NA | BT | CT | ROBIĆ FRYWOLITKI | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | piętnaście | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | dwadzieścia jeden | 21-0 = 21 | 21-8 = 13 |
Całkowity czas obrotu = 59 ms
Więc, Średni czas zwrotu = 59/3 = 19,667 msOraz całkowity czas oczekiwania = 36 ms
Więc, Średni czas oczekiwania = 36/3 = 12,00 ms
Program do planowania okrężnego z czasem przybycia równym 0 dla wszystkich procesów
Kroki, aby znaleźć czasy oczekiwania wszystkich procesów
- Utwórz tablicę rem_bt[] aby śledzić pozostały czas serii procesów. Ta tablica jest początkowo kopią bt[] (tablica czasów serii)
- Utwórz kolejną tablicę wt[] do przechowywania czasów oczekiwania procesów. Zainicjuj tę tablicę jako 0.
- Czas inicjalizacji: t = 0
- Kontynuuj przechodzenie przez wszystkie procesy, dopóki nie są one ukończone. Wykonaj następujące czynności dla ja proces, jeśli jeszcze się nie zakończył.
- Jeśli rem_bt[i]> kwant
- t = t + kwant
- rem_bt[i] -= kwota;
- Else // Ostatni cykl dla tego procesu
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Ten proces się zakończył
Kiedy już mamy czasy oczekiwania, możemy obliczyć czas realizacji tat[i] procesu jako sumę czasów oczekiwania i serii, tj. wt[i] + bt[i].
Poniżej znajduje się realizacja powyższych kroków.
sortowanie listy tablic Java
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) { zrobione = fałsz; // Istnieje proces oczekujący if (rem_bt[i]> quantum) { // Zwiększ wartość t, czyli pokazuje // ile czasu proces był przetwarzany t += quantum; // Zmniejsz czas trwania bieżącego procesu // o wartość quantum rem_bt[i] -= quantum; } // Jeśli czas impulsu jest mniejszy lub równy // quantum. Ostatni cykl dla tego procesu else { // Zwiększ wartość t, tj. pokazuje // ile czasu proces był przetwarzany t = t + rem_bt[i]; // Czas oczekiwania to bieżący czas minus // czas używany przez ten proces wt[i] = t - bt[i]; // Gdy proces zostanie w pełni wykonany // ustaw pozostały czas impulsu = 0 rem_bt[i] = 0; } } } // Jeśli wszystkie procesy zostały zakończone if (done == true) break; } } // Funkcja obliczająca czas realizacji void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // obliczanie czasu realizacji poprzez dodanie // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funkcja obliczająca średni czas void findavgTime(int procesy[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Funkcja obliczająca czas oczekiwania wszystkich procesów findWaitingTime(process, n, bt, wt, quantum); Funkcja obliczająca czas realizacji wszystkich procesów findTurnAroundTime(processes, n, bt, wt, tat); // Wyświetla procesy wraz ze wszystkimi szczegółami 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; }> |
>
>
Jawa
// 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) { zrobione = fałsz; // Istnieje proces oczekujący if (rem_bt[i]> quantum) { // Zwiększ wartość t, czyli pokazuje // ile czasu proces był przetwarzany t += quantum; // Zmniejsz czas trwania bieżącego procesu // o wartość quantum rem_bt[i] -= quantum; } // Jeśli czas impulsu jest mniejszy lub równy // quantum. Ostatni cykl dla tego procesu else { // Zwiększ wartość t, tj. pokazuje // ile czasu proces był przetwarzany t = t + rem_bt[i]; // Czas oczekiwania to bieżący czas minus // czas używany przez ten proces wt[i] = t - bt[i]; // Gdy proces zostanie w pełni wykonany // ustaw pozostały czas impulsu = 0 rem_bt[i] = 0; } } } // Jeśli wszystkie procesy zostały zakończone if (done == true) break; } } // Metoda obliczania czasu realizacji static void findTurnAroundTime(int procesy[], int n, int bt[], int wt[], int tat[]) { // obliczanie czasu realizacji poprzez dodanie // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda obliczania średniego czasu statycznego void findavgTime(int procesy[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0; // Funkcja obliczająca czas oczekiwania wszystkich procesów findWaitingTime( procesów, n, bt, wt, quantum); // Funkcja obliczająca czas realizacji wszystkich procesów findTurnAroundTime(proceses, n, bt, wt, tat); // Wyświetla procesy wraz ze wszystkimi szczegółami System.out.println( 'PN ' + ' B ' + ' WT ' + ' TAT'); // Oblicz całkowity czas oczekiwania i całkowity czas obrotu // dla (int i=0; i { total_wt = total_wt + wt[i]; suma_tat = suma_tat + tat[i]; System.out.println(' ' + (i+1) + ' ' + bt[i] +' ' + wt[i] +' ' + tat[i]); System.out.println('Średni czas oczekiwania = ' + (float)total_wt / (float)n); System.out.println('Średni czas zwrotu = ' + (float)total_tat / (float)n); } // Metoda sterownika public static void main(String[] args) { // identyfikator procesu int procesy[] = { 1, 2, 3}; int n = procesy.długość; // Czas serii wszystkich procesów int Burst_time[] = {10, 5, 8}; // Kwant czasu int quantum = 2; findavgTime(procesy, n, czas_przerwy, kwant); } }> |
>
>
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]>kwantowa):> > ># 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)> |
>
char na int java
>
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) { // Zakończono oczekujący proces = false; if (rem_bt[i]> quantum) { // Zwiększ wartość t, // pokazuje, ile czasu // proces był przetwarzany t += quantum; // Zmniejsz czas trwania // bieżącego procesu o wartość quantum rem_bt[i] -= quantum; } // Jeśli czas impulsu jest mniejszy niż // lub równy kwantowi. Ostatni cykl // dla tego procesu else { // Zwiększ wartość t, // pokazuje, ile czasu // proces był przetwarzany t = t + rem_bt[i]; // Czas oczekiwania to bieżący // czas minus czas używany przez // ten proces wt[i] = t - bt[i]; // Gdy proces zostanie w pełni // wykonany, pozostaw // pozostały czas = 0 rem_bt[i] = 0; } } } // Jeśli wszystkie procesy zostały zakończone if (done == true) break; } } // Metoda obliczania czasu realizacji static void findTurnAroundTime(int []process, int n, int []bt, int []wt, int []tat) { // obliczanie czasu realizacji poprzez dodanie // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metoda obliczania średniego czasu statycznego void findavgTime(int []procesy, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0; // Funkcja obliczająca czas oczekiwania // wszystkich procesy findWaitingTime(process, n, bt, wt, quantum); // Funkcja znajdująca czas realizacji // dla wszystkich procesów findTurnAroundTime(process, n, bt, wt, tat); // Wyświetla procesy wraz z // wszystkimi szczegółami Console.WriteLine('Procesy ' + ' Czas serii ' + ' Czas oczekiwania ' + ' Czas realizacji'); // Oblicz całkowity czas oczekiwania i całkowity czas // obrotu dla (int i = 0; i { suma_wt = suma_wt + wt[i]; suma_tat = suma_tat + tat[i]; Console.WriteLine(' ' + (i+1) + ' ' + bt[i ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Średni czas oczekiwania = ' + (float)total_wt / (float)n); Console.Write('Średni czas zwrotu = ' + (float)total_tat / (float)n); } // Metoda sterownika public static void Main() { // identyfikator procesu int []process = { 1, 2, 3}; int n = procesy.Długość; // Czas serii wszystkich procesów int []burst_time = {10, 5, 8}; // Kwant czasu int quantum = 2; findavgTime(procesy, n, czas_przerwy, kwant); } } // Ten kod został stworzony przez nitin mittal.> |
łączenie w przód
>
>
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) { zrobione = fałsz; // Istnieje proces oczekujący if (rem_bt[i]> quantum) { // Zwiększ wartość t, czyli pokazuje // ile czasu proces był przetwarzany t += quantum; // Zmniejsz czas trwania bieżącego procesu // o wartość quantum rem_bt[i] -= quantum; } // Jeśli czas impulsu jest mniejszy lub równy // quantum. Ostatni cykl dla tego procesu else { // Zwiększ wartość t, tj. pokazuje // ile czasu proces był przetwarzany t = t + rem_bt[i]; // Czas oczekiwania to bieżący czas minus // czas używany przez ten proces wt[i] = t - bt[i]; // Gdy proces zostanie w pełni wykonany // ustaw pozostały czas impulsu = 0 rem_bt[i] = 0; } } } // Jeśli wszystkie procesy zostały zakończone if (done == true) break; } } // Funkcja obliczająca czas realizacji const findTurnAroundTime = (process, n, bt, wt, tat) => { // obliczanie czasu realizacji poprzez dodanie // bt[i] + wt[i] for (let i = 0; i tat[i] = bt[i] + wt[i]; } // Funkcja obliczająca średni czas const findavgTime = (procesy, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Funkcja obliczająca czas oczekiwania wszystkich procesów findWaitingTime(process, n, bt, wt, quantum); // Funkcja obliczająca czas realizacji wszystkich procesów findTurnAroundTime(process, n, bt, wt, tat); // Wyświetla procesy wraz ze wszystkimi szczegółami document.write(`Procesy Czas serii Czas oczekiwania Czas realizacji `); Oblicz całkowity czas oczekiwania i całkowity czas obrotu // dla (let 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(`Średni czas oczekiwania = ${total_wt / n}`); document.write(` Średni czas realizacji = ${total_tat / n}`); } // Kod sterownika // identyfikator procesu procesy = [1, 2, 3]; niech n = procesy.długość; // Czas serii wszystkich procesów niech Burst_time = [10, 5, 8]; // Kwant czasu niech quantum = 2; findavgTime(procesy, n, czas_przerwy, kwant); // Ten kod został napisany przez rakeshsahni> |
>
>Wyjście
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 do planowania okrężnego z czasem przybycia równym zero, różnymi i takimi samymi czasami przybycia
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>> ilość;> >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; // Deklaracja zmiennych int c = n, s[n][20]; czas pływania = 0, mini = INT_MAX, b[n], a[n]; // Inicjowanie tablic z czasem przybycia i serii int indeks = -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] <= p && mini>a[i] && b[i]> 0) { indeks = i; mini = a[i]; flaga = prawda; } } // jeśli at =1, pętla kończy działanie, dlatego ustawiamy flagę na false if (!flag) { time++; Kontynuować; } // obliczanie czasu rozpoczęcia j = 0; podczas gdy (s[indeks][j] != -1) { j++; } if (s[indeks][j] == -1) { s[indeks][j] = czas; p[indeks].ST[j] = czas; } jeśli (b[indeks]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[indeks] = czas + 0,1; } // obliczanie czasu przybycia, serii, czasu końcowego if (b[index] == 0) { c--; p[indeks].FT = czas; p[indeks].WT = p[indeks].FT – p[indeks].AT – p[indeks].BT; tot_wt += p[indeks].WT; p[indeks].TAT = p[indeks].BT + p[indeks].WT; tot_tat += p[indeks].TAT; } } // koniec pętli while // Wydruk 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]; flaga=prawda; } } // jeśli at =1, pętla kończy działanie, dlatego ustawiamy flagę na false if(!flag){ time++; Kontynuować; } //obliczanie czasu rozpoczęcia j=0; while(s[indeks][j]!=-1){ j++; } if(s[indeks][j]==-1){ s[indeks][j]=czas; p[indeks].ST[j]=czas; } if(b[indeks]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[indeks]=czas+0,1; } // obliczanie czasu przybycia, serii, czasu końcowego if(b[index]==0){ c--; p[indeks].FT=czas; p[indeks].WT=p[indeks].FT-p[indeks].AT-p[indeks].BT; tot_wt+=p[indeks].WT; p[indeks].TAT=p[indeks].BT+p[indeks].WT; tot_tat+=p[indeks].TAT; } } // koniec pętli while // Wydruk wyniku printf('Numer procesu '); printf('Czas przybycia '); printf('Czas serii '); printf(' Czas rozpoczęcia'); j=0; podczas gdy(j!=10){ j+=1; printf(''); } printf(' Ostateczny czas'); printf(' Czas oczekiwania '); printf(' Czas realizacji
'); for(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d ',p[i].BT); j=0; int v=0; while(s[i][j]!=-1){ printf('%d ' ,p[i].ST[j]); j++; v+=3; } while(v!=40){ printf(' '); v+=1; ',p[i].FT); printf('%d ',p[i].WT); printf('%d
',p[i].TAT) ; } //Obliczanie średniego czasu oczekiwania i czasu realizacji double avg_wt,avg_tat; avg_wt=tot_wt/(float)n; avg_tat=tot_tat/(float)n; //Drukowanie średniego czasu oczekiwania i czasu realizacji printf('Średni czas oczekiwania czas wynosi: %lf
',avg_wt); printf('Średni czas realizacji wynosi: %lf
',avg_tat); return 0 }> |
>
jeśli przez Ruyarda Kiplinga wyjaśnienie linijka po linijce
>
Wyjście:
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 do planowania okrężnego z różnymi czasami przybycia dla wszystkich procesów
Szczegółowa implementacja algorytmu Preemptive Round Robin z różnymi czasami przybycia dla wszystkich procesów znajduje się w: Program do planowania okrężnego z różnymi czasami przybycia .
Wniosek
Podsumowując, planowanie okrężne procesora jest sprawiedliwym i wyprzedzającym algorytmem, który przydziela każdemu procesowi określony kwant czasu, zapewniając równy dostęp procesora. Jest prosty do wdrożenia, ale może prowadzić do większego narzutu związanego z przełączaniem kontekstu. Chociaż promuje to uczciwość i zapobiega głodowi, może skutkować dłuższym czasem oczekiwania i zmniejszoną przepustowością, w zależności od ilości czasu. Skuteczne wdrożenie programu pozwala na obliczenie kluczowych wskaźników, takich jak czas realizacji, czas realizacji i czas oczekiwania, pomagając w ocenie i optymalizacji wyników.