Program for Round Robin-planlegging for samme ankomsttid
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.
- 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
// 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); } }> |
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> |
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 }>'>; |
>
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.
