Round Robin er en CPU-planleggingsalgoritme der hver prosess er syklisk tildelt en fast tidsluke. Det er den forebyggende versjonen av førstemann til mølla CPU-planleggingsalgoritmen.
javascript kommentar
- Round Robin CPU Algorithm fokuserer generelt på tidsdelingsteknikk.
- Tidsperioden som en prosess eller jobb tillates å kjøre i en forebyggende metode kalles tid kvante .
- Hver prosess eller jobb som er tilstede i klarkøen blir tildelt CPU for det tidskvantemet, hvis utførelsen av prosessen er fullført i løpet av den tiden vil prosessen slutt ellers vil prosessen gå tilbake til ventebord og vent på neste tur for å fullføre utførelsen.
Kjennetegn ved Round Robin CPU-planleggingsalgoritme
- Det er enkelt, lett å implementere og sultefritt ettersom alle prosesser får en rettferdig del av CPU.
- En av de mest brukte teknikkene i CPU-planlegging er en kjerne.
- Det er forebyggende som prosesser er tildelt CPU kun for en fast del av tiden på det meste.
- Ulempen med det er mer overhead av kontekstbytte.
Fordeler med Round Robin CPU-planleggingsalgoritme
- Det er rettferdighet siden hver prosess får en like stor andel av CPU.
- Den nyopprettede prosessen legges til på slutten av klarkøen.
- En round-robin-planlegger bruker vanligvis tidsdeling, og gir hver jobb en tidsluke eller kvante.
- Mens du utfører en round-robin-planlegging, blir et bestemt tidskvante tildelt forskjellige jobber.
- Hver prosess får en sjanse til å omplanlegge etter en bestemt kvantetid i denne planleggingen.
Ulemper med Round Robin CPU Scheduling Algorithm
- Det er større ventetid og responstid.
- Det er lav gjennomstrømning.
- Det er kontekstbrytere.
- Gantt-diagrammet ser ut til å bli for stort (hvis kvantetiden er mindre for planlegging. For eksempel: 1 ms for stor planlegging.)
- Tidkrevende planlegging for små kvante.
Eksempler å vise hvordan det fungerer Round Robin Planleggingsalgoritme
Eksempel-1: Vurder følgende tabell over ankomsttid og eksplosjonstid for fire prosesser P1, P2, P3 og P4 og gitt Tidskvante = 2
| Prosess | 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-planleggingsalgoritmen vil fungere på grunnlag av trinn som nevnt nedenfor:
På tidspunktet = 0,
- Utførelsen begynner med prosess P1, som har bruddtid 5.
- Her kjøres hver prosess i 2 millisekunder ( Tid Kvanteperiode ). P2 og P3 står fortsatt i ventekø.
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
Til tider = 2,
- Prosessene P1 og P3 kommer i klarkøen og P2 begynner å kjøre for TQ periode
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
Til tider = 4,
- Prosessen P4 ankommer i klar kø ,
- Deretter kjører P3 for TQ periode.
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 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 |
På tid = 6,
- Prosess P3 fullfører utførelsen
- Prosess P1 begynner å kjøre for TQ periode som den er neste i b.
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0 ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms |
Til tider = 8,
- Prosess P4 begynner å kjøre, den vil ikke kjøre for Tid Kvanteperiode ettersom den har eksplodert tid = 1
- Derfor vil den kjøre i bare 1 ms.
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 8-9 ms | P1 | 0 ms | P2, P1 | P4 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1 ms | 1 ms | 0 ms |
Til tider = 9,
- Prosess P4 fullfører sin utførelse
- Prosess P2 begynner å kjøre for TQ periode som det er neste i klar kø
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0 ms | P1 | P2 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0 ms |
På tid = 11,
- Prosess P2 fullfører sin utførelse.
- Prosess P1 begynner å kjøre, den vil bare kjøre i 1 ms
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1 ms | 0 ms |
På tid = 12,
- Prosess P1 fullfører utførelsen.
- Den generelle gjennomføringen av prosessene vil være som vist nedenfor:
| Tidsforekomst | Prosess | Ankomsttid | Klar kø | Kjører kø | Utførelsestid | Innledende Burst Time | Gjenværende Burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0ms | 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 | 0ms | 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 | 0ms |
Gantt-diagram vil være som følger nedenfor:
Gantt-diagram for Round Robin Scheduling Algorithm
Hvordan beregne undertidene i Round Robin ved hjelp av et program?
- Fullføringstid: Tidspunkt da prosessen fullfører utførelsen.
- Omløpstid: Tid Forskjellen mellom ferdigstillelsestid og ankomsttid. Omløpstid = Fullføringstid – Ankomsttid
- Ventetid (W.T): Tid Forskjellen mellom snutid og eksplosjonstid.
Ventetid = Omløpstid – Burst Time
La oss nå beregne gjennomsnittet ventetid og snu tid:
| Prosesser | PÅ | BT | CT | KRIMSKRAMS | 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 |
Nå,
- Gjennomsnittlig snutid = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Gjennomsnittlig ventetid = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Eksempel 2: Tenk på følgende tabell over ankomsttid og bruddtid for tre prosesser P1, P2 og P3 og gitt Tidskvante = 2
| Prosess | Burst Time | Ankomsttid |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
På samme måte, Gantt-diagram for dette eksemplet:
Gantt-diagram for eksempel 2
La oss nå beregne gjennomsnittet ventetid og snu tid:
| Prosesser | PÅ | BT | CT | KRIMSKRAMS | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | femten | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | tjueen | 21-0 = 21 | 21-8 = 13 |
Total omløpstid = 59 ms
Så, Gjennomsnittlig omløpstid = 59/3 = 19,667 msOg total ventetid = 36 ms
Så, Gjennomsnittlig ventetid = 36/3 = 12,00 ms
Program for Round Robin-planlegging med ankomsttid som 0 for alle prosesser
Trinn for å finne ventetider for alle prosesser
- Lag en matrise rem_bt[] for å holde styr på gjenværende eksplosjonstid for prosesser. Denne arrayen er opprinnelig en kopi av bt[] (burst times array)
- Lag en annen matrise wt[] å lagre ventetider på prosesser. Initialiser denne matrisen som 0.
- Initialiser tid: t = 0
- Fortsett å krysse alle prosessene mens de ikke er ferdige. Følg for i’th prosess hvis det ikke er gjort ennå.
- Hvis rem_bt[i]> kvante
- t = t + kvante
- rem_bt[i] -= beløp;
- Else // Siste syklus for denne prosessen
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Denne prosessen er over
Når vi har ventetider, kan vi beregne omdreiningstiden tat[i] av en prosess som summen av vente- og eksplosjonstider, dvs. wt[i] + bt[i].
Nedenfor er implementeringen av trinnene ovenfor.
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) { ferdig = usann; // Det er en ventende prosess hvis (rem_bt[i]> quantum) { // Øk verdien av t dvs. viser // hvor lang tid en prosess har blitt behandlet t += quantum; // Reduser burst_time for gjeldende prosess // med quantum rem_bt[i] -= quantum; } // Hvis bruddtiden er mindre enn eller lik // kvante. Siste syklus for denne prosessen else { // Øk verdien av t, dvs. viser // hvor lang tid en prosess har blitt behandlet t = t + rem_bt[i]; // Ventetid er gjeldende tid minus tid // brukt av denne prosessen wt[i] = t - bt[i]; // Ettersom prosessen blir fullstendig utført // gjør dens gjenværende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle prosesser er utført hvis (gjort == sant) bryter; } } // Funksjon for å beregne omløpstid void findTurnAroundTime(int prosesser[], int n, int bt[], int wt[], int tat[]) { // beregner behandlingstid ved å legge til // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funksjon for å beregne gjennomsnittlig tid void findavgTime(int prosesser[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0 // Funksjon for å finne ventetid for alle prosesser findWaitingTime(prosesser, n, bt, wt, quantum); Funksjon for å finne omløpstid for alle prosesser findTurnAroundTime(prosesser, n, bt, wt, tat) // Vis prosesser 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
abstrakt klasse i java
// 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) { ferdig = usann; // Det er en ventende prosess hvis (rem_bt[i]> quantum) { // Øk verdien av t dvs. viser // hvor lang tid en prosess har blitt behandlet t += quantum; // Reduser burst_time for gjeldende prosess // med quantum rem_bt[i] -= quantum; } // Hvis bruddtiden er mindre enn eller lik // kvante. Siste syklus for denne prosessen else { // Øk verdien av t, dvs. viser // hvor lang tid en prosess har blitt behandlet t = t + rem_bt[i]; // Ventetid er gjeldende tid minus tid // brukt av denne prosessen wt[i] = t - bt[i]; // Ettersom prosessen blir fullstendig utført // gjør dens gjenværende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle prosesser er utført hvis (gjort == sant) bryter; } } // Metode for å beregne omløpstid static void findTurnAroundTime(int prosesser[], int n, int bt[], int wt[], int tat[]) { // beregner behandlingstid ved å legge til // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metode for å beregne gjennomsnittlig tid static void findavgTime(int prosesser[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Funksjon for å finne ventetid for alle prosesser findWaitingTime( prosesser, n, bt, wt, quantum); // Funksjon for å finne omløpstid for alle prosesser. 'PN ' + ' B ' + ' WT ' + ' TAT'); // Beregn total ventetid og total tur // rundt tid 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('Gjennomsnittlig ventetid = ' + (float)total_wt / (float)n); System.out.println('Gjennomsnittlig omløpstid = ' + (float)total_tat / (float)n); } // Drivermetode public static void main(String[] args) { // prosess-ids int-prosesser[] = { 1, 2, 3}; int n = prosesser.lengde; // Burst-tid for alle prosesser int burst_time[] = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(prosesser, n, burst_time, quantum); } }> |
>
>
streng som en matrise
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) { // Det er en ventende prosess utført = false; if (rem_bt[i]> quantum) { // Øk verdien av t dvs. // viser hvor lang tid en prosess // har blitt behandlet t += quantum; // Reduser burst_time for // gjeldende prosess med quantum rem_bt[i] -= quantum; } // Hvis bruddtiden er mindre enn // eller lik kvante. Siste syklus // for denne prosessen else { // Øk verdien av t dvs. // viser hvor lang tid en prosess // har blitt behandlet t = t + rem_bt[i]; // Ventetiden er gjeldende // tid minus tid brukt av // denne prosessen wt[i] = t - bt[i]; // Når prosessen blir fullstendig // utført, gjør dens gjenværende // burst tid = 0 rem_bt[i] = 0; } } } // Hvis alle prosesser er utført hvis (gjort == sant) bryter; } } // Metode for å beregne omløpstid static void findTurnAroundTime(int []prosesser, int n, int []bt, int []wt, int []tat) { // beregner behandlingstid ved å legge til // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metode for å beregne gjennomsnittlig tid static void findavgTime(int []prosesser, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0 // Funksjon for å finne ventetid for // alle prosesser findWaitingTime(prosesser, n, bt, wt, quantum); // Funksjon for å finne omløpstid // for alle prosesser findTurnAroundTime(prosesser, n, bt, wt, tat); Console.WriteLine('Prosesser ' + ' Burst tid ' + ' Ventetid ' + ' Omløpstid'); // Beregn total ventetid og total omdreiningstid for (int i = 0; i { total_wt = total_wt + wt[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Gjennomsnittlig ventetid = ' + (float)total_wt / (float)n); Console.Write('Gjennomsnittlig omløpstid = ' + (float)total_tat / (float)n); } // Drivermetode public static void Main() { // prosess-id's int []prosesser = { 1, 2, 3}; int n = prosesser.Lengde; // Burst-tid for alle prosesser int []burst_time = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(prosesser, n, burst_time, quantum); } } // Denne koden er bidratt av 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) { ferdig = usann; // Det er en ventende prosess hvis (rem_bt[i]> quantum) { // Øk verdien av t dvs. viser // hvor lang tid en prosess har blitt behandlet t += quantum; // Reduser burst_time for gjeldende prosess // med quantum rem_bt[i] -= quantum; } // Hvis bruddtiden er mindre enn eller lik // kvante. Siste syklus for denne prosessen else { // Øk verdien av t, dvs. viser // hvor lang tid en prosess har blitt behandlet t = t + rem_bt[i]; // Ventetid er gjeldende tid minus tid // brukt av denne prosessen wt[i] = t - bt[i]; // Ettersom prosessen blir fullstendig utført // gjør dens gjenværende bursttid = 0 rem_bt[i] = 0; } } } // Hvis alle prosesser er utført hvis (gjort == sant) bryter; } } // Funksjon for å beregne omløpstid const findTurnAroundTime = (prosesser, n, bt, wt, tat) => { // beregner omløpstid ved å legge til // bt[i] + wt[i] for (la i = 0; i tat[i] = bt[i] + wt[i]; } // Funksjon for å beregne gjennomsnittlig tid const findavgTime = (prosesser, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); // Funksjon for å finne omløpstid for alle prosesser findTurnAroundTime(prosesser, n, bt, wt, tat); Beregn total ventetid og total tur // rundt tid for (la 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(`Gjennomsnittlig ventetid = ${total_wt / n}`); = ${total_tat / n}`); } // Driverkode // prosess-IDs prosesser = [1, 2, 3]; la n = prosesser.lengde; // Burst tid for alle prosesser la burst_time = [10, 5, 8]; // Tidskvante la kvantum = 2; findavgTime(prosesser, n, burst_time, quantum); // Denne koden er bidratt av rakeshsahni> |
indeks over java
>
>Produksjon
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-planlegging med ankomsttid som null, forskjellige 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>> quant;> >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; // Deklarerer variabler int c = n, s[n][20]; flytetid = 0, mini = INT_MAX, b[n], a[n]; // Initialiserer burst og ankomsttid 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] <= p && mini>a[i] && b[i]> 0) { indeks = i; mini = a[i]; flagg = sant; } } // hvis ved =1, går løkken ut og setter derfor flagget til usann hvis (!flagg) { time++; Fortsette; } // beregner starttid j = 0; while (s[indeks][j] != -1) { j++; } if (s[indeks][j] == -1) { s[indeks][j] = tid; p[indeks].ST[j] = tid; } if (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, siste tider 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 // Printing 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]; flagg=sant; } } // hvis ved =1 så kommer løkken ut og setter derfor flagget til usann if(!flag){ time++; Fortsette; } //beregner starttid j=0; while(s[indeks][j]!=-1){ j++; } if(s[indeks][j]==-1){ s[indeks][j]=tid; p[indeks].ST[j]=tid; } if(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, siste tider 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; } } // slutten av while-løkken // Utskrift printf('Prosessnummer '); printf('Ankomsttid '); printf('Bursttid '); printf(' Starttid'); j=0; while(j!=10){ j+=1; printf(' '); } printf(' Endelig tid'); printf(' Ventetid '); printf(' Omløpstid
'); 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) } //Beregner gjennomsnittlig ventetid og behandlingstid dobbel avg_wt=tot_wt/(float)n; //Skriv ut gjennomsnittlig ventetid og behandlingstid tid er: %lf
',avg_wt); printf('Den gjennomsnittlige omløpstiden er: %lf
',avg_tat }>'>; |
>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 for Round Robin-planlegging med forskjellige ankomsttider for alle prosesser
For detaljert implementering av Preemptive Round Robin-algoritmen med forskjellige ankomsttider for alle prosesser, se: Program for Round Robin-planlegging med ulike ankomsttider .
Konklusjon
Avslutningsvis er Round Robin CPU-planlegging en rettferdig og forebyggende algoritme som tildeler et fast tidskvante til hver prosess, og sikrer lik CPU-tilgang. Det er enkelt å implementere, men kan føre til høyere kontekstbytte overhead. Selv om det fremmer rettferdighet og forhindrer sult, kan det resultere i lengre ventetider og redusert gjennomstrømning, avhengig av tidskvantumet. Effektiv programimplementering gjør det mulig å beregne nøkkeltall som gjennomføringstid, behandlingstid og ventetid, noe som hjelper til med ytelsesevaluering og optimalisering.