PROGRAM DO PLANOWANIA OKRĘŻNEGO NA TEN SAM CZAS PRZYJAZDU - TECHCODEVIEW.COM

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”.

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	BT	CT	ROBIĆ FRYWOLITKI	WT
P1	10	23	23-0 = 23	23-10 = 13
P2	5	piętnaście	15-0 = 15	15-5 = 10
P3	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 ms

Oraz 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.

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)>

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.>

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 (N);  avg_tat = tot_tat / static_cast (N);  // Drukowanie średniego czasu oczekiwania i czasu realizacji < < 'The average wait time is: '  < < avg_wt  < < endl;  cout  < < 'The average TurnAround time is: '  < < avg_tat  < < endl;  return 0; }>

C

#include> #include> #include> struct> P{> int> AT,BT,ST[20],WT,FT,TAT,pos;> };> int> quant;> int> main(){> int> n,i,j;> // Taking Input> printf> (> 'Enter the no. of processes :'> );> scanf> (> '%d'> ,&n);> struct> P p[n];> > printf> (>

'Enter the quantum 
'>

);> scanf> (> '%d'> ,&quant);> printf> (>

'Enter the process numbers 
'>

);> for>

(i=0;i scanf('%d',&(p[i].pos));   printf('Enter the Arrival time of processes 
'); for(i=0;i scanf('%d',&(p[i].AT));   printf('Enter the Burst time of processes 
'); for(i=0;i scanf('%d',&(p[i].BT));   // Declaring variables int c=n,s[n][20]; float time=0,mini=INT_MAX,b[n],a[n]; // Initializing burst and arrival time arrays int index=-1; for(i=0;i  b[i]=p[i].BT;  a[i]=p[i].AT;  for(j=0;j <20;j++){  s[i][j]=-1;  } } int tot_wt,tot_tat; tot_wt=0; tot_tat=0; bool flag=false; while(c!=0){ mini=INT_MAX; flag=false; for(i=0;i  float p=time+0.1;  if(a[i]a[i] && b[i]>0){ 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 }>

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.