Runde Robin er en CPU-planlægningsalgoritme, hvor hver proces er cyklisk tildelt en fast tidsslot. Det er den forebyggende version af 'First-til-mølle' CPU-planlægningsalgoritmen.
javascript kommentar
- Round Robin CPU Algorithm fokuserer generelt på Time Sharing teknik.
- Det tidsrum, som en proces eller et job får lov til at køre i en forebyggende metode kaldes tid kvante .
- Hver proces eller job, der er til stede i klarkøen, tildeles CPU'en for det tidskvante, hvis udførelsen af processen er fuldført i løbet af det tidsrum, vil processen ende ellers vil processen gå tilbage til ventebord og vent på næste tur for at fuldføre udførelsen.
Karakteristika for Round Robin CPU-planlægningsalgoritme
- Det er enkelt, nemt at implementere og sult-frit, da alle processer får en rimelig andel af CPU.
- En af de mest brugte teknikker i CPU-planlægning er en kerne.
- det er forebyggende da processer kun tildeles CPU i et fast stykke tid højst.
- Ulempen ved det er mere overhead af kontekstskifte.
Fordele ved Round Robin CPU Scheduling Algorithm
- Der er retfærdighed, da hver proces får en lige stor del af CPU'en.
- Den nyoprettede proces føjes til slutningen af klarkøen.
- En round-robin-planlægger anvender generelt tidsdeling, hvilket giver hvert job et tidsrum eller kvante.
- Mens der udføres en round-robin planlægning, tildeles et bestemt tidskvante til forskellige job.
- Hver proces får en chance for at omplanlægge efter en bestemt kvantetid i denne planlægning.
Ulemper ved Round Robin CPU Scheduling Algorithm
- Der er større ventetid og responstid.
- Der er lav gennemstrømning.
- Der er Context Switches.
- Gantt-diagrammet ser ud til at blive for stort (hvis kvantetiden er mindre til planlægning. For eksempel: 1 ms til stor planlægning).
- Tidskrævende planlægning for små kvante.
Eksempler til at vise arbejdet med Runde Robin Planlægningsalgoritme
Eksempel-1: Overvej følgende tabel over ankomsttid og bursttid for fire processer P1, P2, P3 og P4 og givet Tidskvante = 2
| Behandle | Burst Time | Ankomsttid |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Round Robin CPU-planlægningsalgoritmen vil arbejde på basis af trin som nævnt nedenfor:
Til tiden = 0,
- Udførelsen begynder med proces P1, som har bursttid 5.
- Her udføres hver proces i 2 millisekunder ( Tid Kvanteperiode ). P2 og P3 står stadig i ventekøen.
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
På tidspunktet = 2,
- Processerne P1 og P3 ankommer i klarkøen, og P2 begynder at udføre for TQ periode
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
På tidspunktet = 4,
- Processen P4 ankommer i klar kø ,
- Så udfører P3 for TQ periode.
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3 ms | 3 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P3 | 2 ms | 2 ms | 2 ms | 0ms |
På tidspunktet = 6,
- Proces P3 afslutter sin udførelse
- Proces P1 begynder at udføre for TQ periode, da den er næste i b.
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms |
På tidspunktet = 8,
- Proces P4 begynder at udføre, den vil ikke køre for Tid Kvanteperiode da det har sprængt tid = 1
- Derfor vil den kun køre i 1 ms.
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 8-9 ms | P1 | 0ms | P2, P1 | P4 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1 ms | 1 ms | 0ms |
På tidspunktet = 9,
- Proces P4 afslutter sin udførelse
- Proces P2 begynder at udføre for TQ periode som det er næste i klar kø
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0ms |
På tidspunktet = 11,
- Proces P2 afslutter sin udførelse.
- Proces P1 begynder at udføre, den vil kun køre i 1 ms
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1 ms | 0ms |
Til tiden = 12,
- Proces P1 afslutter sin udførelse.
- Den overordnede udførelse af processerne vil være som vist nedenfor:
| Tidsforekomst | Behandle | Ankomsttid | Klar kø | Løbende kø | Udførelsestid | Indledende burst tid | Resterende burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms | |||
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3 ms | 3 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P3 | 2 ms | 2 ms | 2 ms | 0ms | |||
| 6-8 ms | P1 | 0ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| 8-9 ms | P1 | 0ms | P2, P1 | P4 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1 ms | 1 ms | 0ms | |||
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0ms | |||
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1 ms | 0ms |
Gantt kort vil være som følgende:
Gantt-diagram for Round Robin Scheduling Algorithm
Hvordan beregner man nedenstående tider i Round Robin ved hjælp af et program?
- Gennemførelsestid: Tidspunkt, hvor processen afslutter sin udførelse.
- Omløbstid: Tidsforskel mellem færdiggørelsestidspunkt og ankomsttidspunkt. Turn Around Time = Gennemførelsestid - Ankomsttid
- Ventetid (W.T): Tid Forskel mellem omløbstid og eksplosionstid.
Ventetid = Omløbstid - Burst Time
Lad os nu beregne gennemsnittet ventetid og vend om tid:
| Processer | PÅ | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | elleve | 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 |
Nu,
- Gennemsnitlig omløbstid = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Gennemsnitlig ventetid = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Eksempel 2: Overvej følgende tabel over ankomsttid og bursttid for tre processer P1, P2 og P3 og givet Tidskvante = 2
| Behandle | Burst Time | Ankomsttid |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Tilsvarende Gantt kort for dette eksempel:
Gantt-diagram for eksempel 2
Lad os nu beregne gennemsnittet ventetid og vend om tid:
| Processer | PÅ | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | femten | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | enogtyve | 21-0 = 21 | 21-8 = 13 |
Samlet omløbstid = 59 ms
Så, Gennemsnitlig omløbstid = 59/3 = 19,667 msOg samlet ventetid = 36 ms
Så, Gennemsnitlig ventetid = 36/3 = 12,00 ms
Program for Round Robin-planlægning med ankomsttid som 0 for alle processer
Trin til at finde ventetider for alle processer
- Opret et array rem_bt[] at holde styr på den resterende burst-tid af processer. Dette array er oprindeligt en kopi af bt[] (burst times array)
- Opret et andet array vægt[] at gemme ventetider på processer. Initialiser dette array som 0.
- Initialiseringstid: t = 0
- Bliv ved med at gennemgå alle processer, mens de ikke er færdige. Følg med for i’th proces, hvis det ikke er gjort endnu.
- Hvis rem_bt[i]> kvante
- t = t + kvante
- rem_bt[i] -= beløb;
- Else // Sidste cyklus for denne proces
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Denne proces er slut
Når først vi har ventetider, kan vi beregne omløbstid tat[i] af en proces som summen af vente- og bursttider, dvs. wt[i] + bt[i].
Nedenfor er implementering af ovenstående trin.
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) { udført = falsk; // Der er en afventende proces hvis (rem_bt[i]> kvante) { // Forøg værdien af t dvs. viser // hvor lang tid en proces er blevet behandlet t += kvante; // Reducer burst_time for nuværende proces // med kvante rem_bt[i] -= kvante; } // Hvis bursttiden er mindre end eller lig med // quantum. Sidste cyklus for denne proces ellers { // Forøg værdien af t, dvs. viser // hvor lang tid en proces er blevet behandlet t = t + rem_bt[i]; // Ventetid er aktuel tid minus tid // brugt af denne proces wt[i] = t - bt[i]; // Efterhånden som processen bliver fuldført // gør dens resterende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle processer er udført, hvis (gjort == sand) break; } } // Funktion til at beregne omløbstid void findTurnAroundTime(int processer[], int n, int bt[], int wt[], int tat[]) { // beregner ekspeditionstid ved at tilføje // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funktion til at beregne gennemsnitlig tid void findavgTime(int processer[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0 // Funktion til at finde ventetid for alle processer findWaitingTime(processer, n, bt, wt, quantum); Funktion til at finde omløbstid for alle processer findTurnAroundTime(processer, n, bt, wt, tat // Vis processer sammen med alle detaljer 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
ins nøgle
// 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) { udført = falsk; // Der er en afventende proces hvis (rem_bt[i]> kvante) { // Forøg værdien af t dvs. viser // hvor lang tid en proces er blevet behandlet t += kvante; // Reducer burst_time for nuværende proces // med kvante rem_bt[i] -= kvante; } // Hvis bursttiden er mindre end eller lig med // quantum. Sidste cyklus for denne proces ellers { // Forøg værdien af t, dvs. viser // hvor lang tid en proces er blevet behandlet t = t + rem_bt[i]; // Ventetid er aktuel tid minus tid // brugt af denne proces wt[i] = t - bt[i]; // Efterhånden som processen bliver fuldført // gør dens resterende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle processer er udført, hvis (gjort == sand) break; } } // Metode til at beregne omløbstid statisk tomrum findTurnAroundTime(int processer[], int n, int bt[], int wt[], int tat[]) { // beregner ekspeditionstid ved at tilføje // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metode til at beregne gennemsnitstid static void findavgTime(int processer[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Funktion til at finde ventetid for alle processer findWaitingTime( processer, n, bt, wt, quantum); 'PN ' + ' B ' + ' WT ' + ' TAT'); // Beregn samlet ventetid og samlet omdrejningstid for (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('Gennemsnitlig ventetid = ' + (float)total_wt / (float)n); System.out.println('Gennemsnitlig omløbstid = ' + (float)total_tat / (float)n); } // Drivermetode public static void main(String[] args) { // process id's int processes[] = { 1, 2, 3}; int n = processer.længde; // Burst-tid for alle processer int burst_time[] = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(processer, n, burst_time, quantum); } }> |
>
>
repl i java
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]>kvante) :> > ># 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) { // Der er en afventende proces udført = falsk; if (rem_bt[i]> kvante) { // Forøg værdien af t dvs. // viser hvor lang tid en proces // er blevet behandlet t += kvante; // Reducer burst_time for // nuværende proces med quantum rem_bt[i] -= quantum; } // Hvis bursttiden er mindre end // eller lig med kvante. Sidste cyklus // for denne proces ellers { // Forøg værdien af t, dvs. // viser, hvor lang tid en proces // er blevet behandlet t = t + rem_bt[i]; // Ventetiden er aktuel // tid minus tid brugt af // denne proces wt[i] = t - bt[i]; // Efterhånden som processen bliver fuldstændig // udført, skal dens resterende // burst tid = 0 rem_bt[i] = 0; } } } // Hvis alle processer er udført, hvis (gjort == sand) break; } } // Metode til at beregne omløbstid static void findTurnAroundTime(int []processer, int n, int []bt, int []wt, int []tat) { // beregner ekspeditionstid ved at tilføje // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metode til at beregne gennemsnitstid static void findavgTime(int []processer, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0 // Funktion til at finde ventetid for // alle processer findWaitingTime(processer, n, bt, wt, quantum); // Funktion til at finde omløbstid // for alle processer findTurnAroundTime(processer, n, bt, wt, tat); Console.WriteLine('Processer ' + ' Burst tid ' + ' Ventetid ' + ' Omdrejningstid'); // Beregn samlet ventetid og total omdrejningstid for (int i = 0; i { total_wt = total_wt + wt[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Gennemsnitlig ventetid = ' + (float)total_wt / (float)n); Console.Write('Gennemsnitlig omløbstid = ' + (float)total_tat / (float)n); } // Drivermetode public static void Main() { // proces-id's int []processer = { 1, 2, 3}; int n = processer.Længde; // Burst-tid for alle processer int []burst_time = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(processer, n, burst_time, quantum); } } // Denne kode er bidraget af 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) { udført = falsk; // Der er en afventende proces hvis (rem_bt[i]> kvante) { // Forøg værdien af t dvs. viser // hvor lang tid en proces er blevet behandlet t += kvante; // Reducer burst_time for nuværende proces // med kvante rem_bt[i] -= kvante; } // Hvis bursttiden er mindre end eller lig med // quantum. Sidste cyklus for denne proces ellers { // Forøg værdien af t, dvs. viser // hvor lang tid en proces er blevet behandlet t = t + rem_bt[i]; // Ventetid er aktuel tid minus tid // brugt af denne proces wt[i] = t - bt[i]; // Efterhånden som processen bliver fuldført // gør dens resterende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle processer er udført, hvis (gjort == sand) break; } } // Funktion til at beregne omløbstid const findTurnAroundTime = (processer, n, bt, wt, tat) => { // beregner omløbstid ved at tilføje // bt[i] + wt[i] for (lad i = 0; i tat[i] = bt[i] + wt[i]; } // Funktion til at beregne gennemsnitstid const findavgTime = (processer, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0) lad total_wt = 0, total_tat = 0; // Funktion til at finde ventetid for alle processer findWaitingTime(processer, n, bt, wt, quantum); // Funktion til at finde omløbstid for alle processer findTurnAroundTime(processer, n, bt, wt, tat); Beregn den samlede ventetid og den samlede omdrejningstid for (lad 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(`Gennemsnitlig ventetid = ${total_wt / n}`); = ${total_tat / n}`); } // Driverkode // proces-id's processer = [1, 2, 3]; lad n = processer.længde; // Bursttid for alle processer lad burst_time = [10, 5, 8]; // Tidskvante lad kvante = 2; findavgTime(processer, n, burst_time, quantum); // Denne kode er bidraget af rakeshsahni> |
indeks over java
>
>Produktion
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 for Round Robin-planlægning med ankomsttid som nul, forskellige og samme ankomsttider
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>> kvant;> >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; // Erklæring af variable int c = n, s[n][20]; flydetid = 0, mini = INT_MAX, b[n], a[n]; // Initialisering af burst- og ankomsttidsarrays 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] <= p && mini>a[i] && b[i]> 0) { indeks = i; mini = a[i]; flag = sandt; } } // hvis ved =1, så kommer løkken ud, og sæt flaget til false if (!flag) { time++; Blive ved; } // beregner starttid j = 0; while (s[indeks][j] != -1) { j++; } if (s[indeks][j] == -1) { s[indeks][j] = tid; p[indeks].ST[j] = tid; } hvis (b[indeks]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[indeks] = tid + 0,1; } // beregner ankomst, burst, sluttider if (b[indeks] == 0) { c--; p[indeks].FT = tid; 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; } } // end of while loop // Udskrivning af output 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]; flag=sandt; } } // hvis ved =1, så kommer løkken ud, og sæt flaget til false if(!flag){ time++; Blive ved; } //beregner starttidspunkt j=0; while(s[indeks][j]!=-1){ j++; } if(s[indeks][j]==-1){ s[indeks][j]=tid; p[indeks].ST[j]=tid; } hvis(b[indeks]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[indeks]=tid+0,1; } // beregner ankomst, burst, endelige gange if(b[indeks]==0){ c--; p[indeks].FT=tid; 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; } } // slutningen af while-løkke // Udskriftsoutput printf('Procesnummer '); printf('Ankomsttid '); printf('Bursttid '); printf(' Starttidspunkt'); j=0; mens(j!=10){ j+=1; printf(' '); } printf(' Endelig tid'); printf(' Ventetid '); printf(' Driftstid
'); 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]); v+=3; ',p[i].FT); printf('%d ',p[i].WT); printf('%d
',p[i].TAT) } //Beregning af gennemsnitlig ventetid og behandlingstid dobbelt avg_wt=tot_wt/(float)n; tid er: %lf
',avg_wt); |
>Enter the number of processes : 4 Enter the time quanta : 2 Enter the process numbers : 1 2 3 4 Enter the arrival time of the processes : 0 1 2 3 Enter the burst time of the processes : 5 4 2 1 Program No. Arrival Time Burst Time Wait Time TurnAround Time 1 0 5 7 12 2 1 4 6 10 3 2 2 2 4 4 3 1 5 6 Average wait time : 5 Average Turn Around Time : 8>
Program til Round Robin-planlægning med forskellige ankomsttider for alle processer
For detaljeret implementering af Preemptive Round Robin-algoritme med forskellige ankomsttider for alle processer henvises til: Program for Round Robin-planlægning med forskellige ankomsttider .
Konklusion
Som konklusion er Round Robin CPU-planlægning en retfærdig og forebyggende algoritme, der tildeler et fast tidskvantetal til hver proces, hvilket sikrer lige CPU-adgang. Det er nemt at implementere, men kan føre til højere kontekstskiftende omkostninger. Selvom det fremmer retfærdighed og forhindrer sult, kan det resultere i længere ventetider og reduceret gennemløb, afhængigt af tidskvantumet. Effektiv programimplementering giver mulighed for beregning af nøglemålinger som færdiggørelsestid, ekspeditionstid og ventetid, hvilket hjælper med præstationsevaluering og optimering.