Round Robin är en CPU-schemaläggningsalgoritm där varje process cykliskt tilldelas en fast tidslucka. Det är den förebyggande versionen av Först till kvarn CPU-schemaläggningsalgoritmen.
genericitet i java
- Round Robin CPU Algorithm fokuserar generellt på tidsdelningsteknik.
- Den tidsperiod som en process eller ett jobb tillåts köras i en förebyggande metod kallas tid kvant .
- Varje process eller jobb som finns i den färdiga kön tilldelas CPU för det tidskvantumet, om exekveringen av processen slutförs under den tiden kommer processen att slutet annars kommer processen att gå tillbaka till väntebord och vänta på nästa tur för att slutföra utförandet.
Kännetecken för Round Robin CPU Scheduling Algorithm
- Det är enkelt, lätt att implementera och svältfritt eftersom alla processer får en rättvis del av CPU.
- En av de mest använda teknikerna inom CPU-schemaläggning är en kärna.
- Det är förebyggande eftersom processer endast tilldelas CPU under en fast tidsperiod som mest.
- Nackdelen med det är mer omkostnader för kontextbyte.
Fördelar med Round Robin CPU Scheduling Algorithm
- Det finns rättvisa eftersom varje process får en lika stor andel av CPU:n.
- Den nyskapade processen läggs till i slutet av redo-kön.
- En round-robin-schemaläggare använder i allmänhet tidsdelning, vilket ger varje jobb en tidslucka eller kvantum.
- När du utför en round-robin-schemaläggning tilldelas ett visst tidskvantum till olika jobb.
- Varje process får en chans att schemalägga efter en viss kvanttid i denna schemaläggning.
Nackdelar med Round Robin CPU Scheduling Algorithm
- Det är större väntetid och svarstid.
- Det är låg genomströmning.
- Det finns Context Switches.
- Gantt-diagrammet verkar vara för stort (om kvanttiden är mindre för schemaläggning. Till exempel: 1 ms för stor schemaläggning.)
- Tidskrävande schemaläggning för små kvantum.
Exempel att visa hur man fungerar Round Robin Schemaläggningsalgoritm
Exempel-1: Tänk på följande tabell över ankomsttid och sprängtid för fyra processer P1, P2, P3 och P4 och givet Tidskvantum = 2
| Bearbeta | Burst Time | Ankomst tid |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
Round Robin CPU Scheduling Algorithm kommer att fungera på basis av steg som nämns nedan:
Vid tidpunkten = 0,
- Exekveringen börjar med process P1, som har bursttid 5.
- Här körs varje process i 2 millisekunder ( Tid Kvantperiod ). P2 och P3 står fortfarande i väntekön.
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2 ms | P1 | 0ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
Vid tidpunkten = 2,
- Processerna P1 och P3 anländer i klarkön och P2 börjar exekvera för TQ period
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
Vid tidpunkten = 4,
- Processen P4 anländer i klar kö ,
- Sedan kör P3 för TQ period.
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående 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 |
Vid tidpunkten = 6,
- Process P3 slutför sin exekvering
- Process P1 börjar köras för TQ period som det är nästa i b.
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms |
Vid tidpunkten = 8,
- Process P4 börjar köras, den kommer inte att köras för Tid Kvantperiod eftersom det har sprängt tid = 1
- Därför kommer den att köras i endast 1 ms.
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående 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 |
Vid tidpunkten = 9,
- Process P4 slutför sin exekvering
- Process P2 börjar köras för TQ period som det är nästa i klar kö
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0ms |
Vid tidpunkten = 11,
- Process P2 slutför sin exekvering.
- Process P1 börjar köras, den körs endast i 1 ms
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1 ms | 0ms |
Vid tidpunkten = 12,
- Process P1 slutför sin exekvering.
- Det övergripande utförandet av processerna kommer att se nedan:
| Tidsinstans | Bearbeta | Ankomst tid | Klar kö | Löpande kö | Utförandetid | Initial Burst Time | Återstående burst Tid |
|---|---|---|---|---|---|---|---|
| 0-2 ms | 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-diagram kommer att vara följande:
Gantt-diagram för Round Robin Scheduling Algorithm
Hur beräknar man nedanstående tider i Round Robin med hjälp av ett program?
- Sluttid: Tidpunkt då processen slutförs.
- Omsättningstid: Tid Skillnad mellan färdigställandetid och ankomsttid. Turn Around Time = Slutföringstid – Ankomsttid
- Väntetid (W.T): Tid Skillnad mellan vändningstid och sprängtid.
Väntetid = Omvändningstid – Burst Time
Låt oss nu beräkna genomsnittet väntetid och vända tid:
| Processer | PÅ | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | elva | 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,
- Genomsnittlig vändningstid = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Genomsnittlig väntetid = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Exempel 2: Betrakta följande tabell över ankomsttid och skurtid för tre processer P1, P2 och P3 och givna Tidskvantum = 2
| Bearbeta | Burst Time | Ankomst tid |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Liknande, Gantt-diagram för detta exempel:
Gantt-diagram till exempel 2
Låt oss nu beräkna genomsnittet väntetid och vända tid:
| Processer | PÅ | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | femton | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | tjugoett | 21-0 = 21 | 21-8 = 13 |
Total omläggningstid = 59 ms
Så, Genomsnittlig omläggningstid = 59/3 = 19,667 msOch total väntetid = 36 ms
Så, Genomsnittlig väntetid = 36/3 = 12,00 ms
Program för Round Robin Schemaläggning med ankomsttid som 0 för alla processer
Steg för att hitta väntetider för alla processer
- Skapa en array rem_bt[] för att hålla reda på återstående skurtid av processer. Denna array är initialt en kopia av bt[] (burst times array)
- Skapa en annan array vikt[] att lagra väntetider för processer. Initiera denna matris som 0.
- Initialiseringstid: t = 0
- Fortsätt gå igenom alla processer medan de inte är klara. Följ för i’th process om det inte är gjort ännu.
- Om rem_bt[i]> kvant
- t = t + kvantum
- rem_bt[i] -= belopp;
- Else // Sista cykeln för denna process
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Den här processen är över
När vi väl har väntetider kan vi beräkna omvändningstiden tat[i] för en process som summan av vänte- och skurtider, dvs wt[i] + bt[i].
Nedan är implementeringen av ovanstående steg.
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) { gjort = falskt; // Det finns en väntande process om (rem_bt[i]> quantum) { // Öka värdet på t dvs visar // hur lång tid en process har bearbetats t += quantum; // Minska burst_time för nuvarande process // med quantum rem_bt[i] -= quantum; } // Om skurtiden är mindre än eller lika med // quantum. Sista cykeln för denna process annars { // Öka värdet på t, dvs. visar // hur lång tid en process har bearbetats t = t + rem_bt[i]; // Väntetid är aktuell tid minus tid // som används av denna process wt[i] = t - bt[i]; // När processen körs helt // gör dess återstående skurtid = 0 rem_bt[i] = 0; } } } // Om alla processer är gjorda om (gjort == sant) bryter; } } // Funktion för att beräkna omloppstid void findTurnAroundTime(int processer[], int n, int bt[], int wt[], int tat[]) { // beräknar omloppstid genom att lägga till // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funktion för att beräkna genomsnittlig tid void findavgTime(int processer[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0 // Funktion för att hitta väntetiden för alla processer findWaitingTime(processer, n, bt, wt, quantum); Funktion för att hitta omloppstid för alla processer findTurnAroundTime(processer, n, bt, wt, tat // Visa processer tillsammans med alla 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; }> |
len of array i java
>
>
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) { gjort = falskt; // Det finns en väntande process om (rem_bt[i]> quantum) { // Öka värdet på t dvs visar // hur lång tid en process har bearbetats t += quantum; // Minska burst_time för nuvarande process // med quantum rem_bt[i] -= quantum; } // Om skurtiden är mindre än eller lika med // quantum. Sista cykeln för denna process annars { // Öka värdet på t, dvs. visar // hur lång tid en process har bearbetats t = t + rem_bt[i]; // Väntetid är aktuell tid minus tid // som används av denna process wt[i] = t - bt[i]; // När processen körs helt // gör dess återstående skurtid = 0 rem_bt[i] = 0; } } } // Om alla processer är gjorda om (gjort == sant) bryter; } } // Metod för att beräkna omloppstid static void findTurnAroundTime(int processer[], int n, int bt[], int wt[], int tat[]) { // beräkna omloppstid genom att lägga till // bt[i ] + wt[i] för (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metod för att beräkna genomsnittlig tid 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 för att hitta väntetiden för alla processer findWaitingTime( processer, n, bt, wt, quantum); 'PN ' + ' B ' + ' WT ' + ' TAT'); // Beräkna total väntetid och total vändning // runt tid för (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('Genomsnittlig väntetid = ' + (float)total_wt / (float)n); System.out.println('Genomsnittlig omloppstid = ' + (float)total_tat / (float)n); } // Drivrutinsmetod public static void main(String[] args) { // process id's int processes[] = { 1, 2, 3}; int n = processer.length; // Burst-tid för alla processer int burst_time[] = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(processer, 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]>quantum) :> > ># 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#
binär sökning
// 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 finns en väntande process klar = false; if (rem_bt[i]> quantum) { // Öka värdet på t dvs // visar hur lång tid en process // har bearbetats t += quantum; // Minska burst_time för // aktuell process med quantum rem_bt[i] -= quantum; } // Om skurtiden är mindre än // eller lika med kvantum. Senaste cykeln // för denna process else { // Öka värdet på t dvs // visar hur lång tid en process // har bearbetats t = t + rem_bt[i]; // Väntetiden är aktuell // tid minus tid som används av // denna process wt[i] = t - bt[i]; // När processen blir helt // exekverad gör dess återstående // skurtid = 0 rem_bt[i] = 0; } } } // Om alla processer är gjorda om (gjort == sant) bryter; } } // Metod för att beräkna omloppstid static void findTurnAroundTime(int []processer, int n, int []bt, int []wt, int []tat) { // beräkna omloppstid genom att lägga till // bt[i ] + wt[i] för (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metod för att beräkna genomsnittlig tid 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 för att hitta väntetid för // all processer findWaitingTime(processer, n, bt, wt, quantum); // Funktion för att hitta vändningstid // för alla processer findTurnAroundTime(processer, n, bt, wt, tat); Console.WriteLine('Processer ' + ' Burst-tid ' + ' Väntetid ' + ' Vändtid'); // Beräkna total väntetid och total vändningstid för (int i = 0; i { total_wt = total_wt + wt[i]; ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Genomsnittlig väntetid = ' + (float)total_wt / (float)n); Console.Write('Genomsnittlig omloppstid = ' + (float)total_tat / (float)n); } // Drivrutinsmetod public static void Main() { // process id's int []processer = { 1, 2, 3}; int n = processer.Längd; // Burst-tid för alla processer int []burst_time = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(processer, n, burst_time, quantum); } } // Den här koden bidrar med nitin mittal.> |
>
>
Javascript
java generika
> >// 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) { gjort = falskt; // Det finns en väntande process om (rem_bt[i]> quantum) { // Öka värdet på t dvs visar // hur lång tid en process har bearbetats t += quantum; // Minska burst_time för nuvarande process // med quantum rem_bt[i] -= quantum; } // Om skurtiden är mindre än eller lika med // quantum. Sista cykeln för denna process annars { // Öka värdet på t, dvs. visar // hur lång tid en process har bearbetats t = t + rem_bt[i]; // Väntetid är aktuell tid minus tid // som används av denna process wt[i] = t - bt[i]; // När processen körs helt // gör dess återstående skurtid = 0 rem_bt[i] = 0; } } } // Om alla processer är gjorda om (gjort == sant) bryter; } } // Funktion för att beräkna omloppstid const findTurnAroundTime = (processer, n, bt, wt, tat) => { // beräknar omloppstid genom att lägga till // bt[i] + wt[i] för (låt i = 0; i tat[i] = bt[i] + wt[i]; } // Funktion för att beräkna genomsnittlig tid const findavgTime = (processer, n, bt, quantum) => { let wt = new Array(n). fyll(0), tat = new Array(n).fill(0); // Funktion för att hitta omloppstid för alla processer findTurnAroundTime(processer, n, bt, wt, tat); Beräkna total väntetid och total vändning // runt tid för (låt 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(`Genomsnittlig väntetid = ${total_wt / n}`); = ${total_tat / n}`); } // Drivrutinskod // process id's processer = [1, 2, 3]; låt n = processer.length; // Bursttid för alla processer låt burst_time = [10, 5, 8]; // Tidskvantum låt kvantum = 2; findavgTime(processer, n, burst_time, quantum); // Denna kod bidrar med rakeshsahni> |
>
>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 för Round Robin Schemaläggning med ankomsttid som noll, olika och samma 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; // Deklarerar variabler int c = n, s[n][20]; flyttid = 0, mini = INT_MAX, b[n], a[n]; // Initialisering av skur- och ankomsttider int index = -1; för (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; för (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) { index = i; mini = a[i]; flagga = sant; } } // om vid =1 går loopen ut och sätter därför flaggan till false if (!flagga) { time++; Fortsätta; } // beräknar starttid j = 0; while (s[index][j] != -1) { j++; } if (s[index][j] == -1) { s[index][j] = tid; p[index].ST[j] = tid; } om (b[index]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[index] = tid + 0,1; } // beräknar ankomst, skur, sluttider if (b[index] == 0) { c--; p[index].FT = tid; p[index].WT = p[index].FT - p[index].AT - p[index].BT; tot_wt += p[index].WT; p[index].TAT = p[index].BT + p[index].WT; tot_tat += p[index].TAT; } } // slutet av while-slingan // 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 |
jämföra i java
>
>
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){ index=i; mini=a[i]; flagga=sant; } } // om vid =1 går loopen ut och sätter därför flaggan till false if(!flagga){ time++; Fortsätta; } //beräknar starttid j=0; while(s[index][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=tid; p[index].ST[j]=tid; } om(b[index]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[index]=tid+0,1; } // beräknar ankomst, burst, sista tider if(b[index]==0){ c--; p[index].FT=tid; p[index].WT=p[index].FT-p[index].AT-p[index].BT; tot_wt+=p[index].WT; p[index].TAT=p[index].BT+p[index].WT; tot_tat+=p[index].TAT; } } // slutet av while-slingan // Utskrift printf('Processnummer '); printf('Ankomsttid '); printf('Bursttid '); printf(' Starttid'); j=0; while(j!=10){ j+=1; printf(' '); } printf(' Slutlig tid'); printf(' Väntetid '); printf(' Omloppstid
'); 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) } //Beräknar genomsnittlig väntetid och handläggningstid dubbel avg_wt=tot_wt/(avg_tat=tot_tat/(float)n; tid är: %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 för Round Robin-schemaläggning med olika ankomsttider för alla processer
För detaljerad implementering av Preemptive Round Robin-algoritmen med olika ankomsttider för alla processer, se: Program för Round Robin Schemaläggning med olika ankomsttider .
Slutsats
Sammanfattningsvis är Round Robin CPU-schemaläggning en rättvis och förebyggande algoritm som allokerar ett fast tidskvantum till varje process, vilket säkerställer lika CPU-åtkomst. Det är enkelt att implementera men kan leda till högre omkostnader för kontextbyte. Även om det främjar rättvisa och förhindrar svält, kan det resultera i längre väntetider och minskad genomströmning, beroende på tidskvantum. Effektiv programimplementering möjliggör beräkning av nyckeltal som slutförandetid, handläggningstid och väntetid, vilket hjälper till med prestandautvärdering och optimering.