Girotondo è un algoritmo di pianificazione della CPU in cui a ciascun processo viene ciclicamente assegnato un intervallo di tempo fisso. È la versione preventiva dell'algoritmo di pianificazione della CPU First come First Serve.
carattere in lattice di dimensioni
- L'algoritmo CPU Round Robin si concentra generalmente sulla tecnica Time Sharing.
- Il periodo di tempo durante il quale un processo o un lavoro può essere eseguito in un metodo preventivo è chiamato tempo quantistico .
- Ad ogni processo o lavoro presente nella coda pronta viene assegnata la CPU per quel periodo di tempo, se l'esecuzione del processo viene completata durante quel tempo, il processo verrà FINE altrimenti il processo tornerà al tavolo d'attesa e attendi il suo turno successivo per completare l'esecuzione.
Caratteristiche dell'algoritmo di pianificazione della CPU Round Robin
- È semplice, facile da implementare e senza problemi poiché tutti i processi ottengono una buona parte della CPU.
- Una delle tecniche più comunemente utilizzate in Pianificazione della CPU è un nucleo.
- È preventivo poiché ai processi viene assegnata la CPU solo per un periodo di tempo fisso al massimo.
- Lo svantaggio è un maggiore sovraccarico dovuto al cambio di contesto.
Vantaggi dell'algoritmo di pianificazione della CPU Round Robin
- C'è equità poiché ogni processo ottiene una quota uguale della CPU.
- Il processo appena creato viene aggiunto alla fine della coda pronta.
- Uno scheduler round-robin utilizza generalmente il time-sharing, assegnando a ciascun lavoro una fascia oraria o quantum.
- Durante l'esecuzione di una pianificazione round-robin, un particolare quanto di tempo viene assegnato a diversi lavori.
- Ogni processo ha la possibilità di riprogrammarsi dopo un particolare tempo quantico in questa pianificazione.
Svantaggi dell'algoritmo di pianificazione della CPU Round Robin
- C'è un tempo di attesa e un tempo di risposta maggiori.
- Il throughput è basso.
- Ci sono cambi di contesto.
- Il diagramma di Gantt sembra essere troppo grande (se il tempo quantico è inferiore per la pianificazione. Ad esempio: 1 ms per una pianificazione di grandi dimensioni).
- Pianificazione dispendiosa in termini di tempo per piccoli quanti.
Esempi per mostrare il funzionamento di Girotondo Algoritmo di pianificazione
Esempio 1: Considera la seguente tabella del tempo di arrivo e del tempo di burst per quattro processi P1, P2, P3 e P4 e dato Quanto temporale = 2
| Processi | Tempo di scoppio | Orario di arrivo |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
L'algoritmo di pianificazione della CPU Round Robin funzionerà sulla base dei passaggi indicati di seguito:
Al tempo = 0,
- L'esecuzione inizia con il processo P1, che ha tempo di burst 5.
- Qui, ogni processo viene eseguito per 2 millisecondi ( Periodo quantistico temporale ). P2 e P3 sono ancora in coda d'attesa.
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0ms | P2, P3 | P1 | 2 ms | 5ms | 3 ms |
Al tempo = 2,
- I processi P1 e P3 arrivano nella coda pronta e P2 inizia l'esecuzione TQ periodo
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
Al tempo = 4,
- Il processo P4 arriva nel coda pronta ,
- Quindi P3 viene eseguito per TQ periodo.
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3 ms | 3ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P3 | 2 ms | 2 ms | 2 ms | 0ms |
Al tempo = 6,
- Il processo P3 completa la sua esecuzione
- Il processo P1 inizia l'esecuzione per TQ periodo come è successivo nel b.
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms |
Al tempo = 8,
- Il processo P4 inizia l'esecuzione, non verrà eseguito per Periodo quantistico temporale poiché ha tempo di scoppio = 1
- Pertanto, verrà eseguito solo per 1 ms.
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 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 | 1ms | 0ms |
Al tempo = 9,
- Il processo P4 completa la sua esecuzione
- Inizia l'esecuzione del processo P2 TQ periodo come è il prossimo nel coda pronta
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3ms | 1ms |
| P2 | 1ms | 2 ms | 2 ms | 0ms |
Al tempo = 11,
- Il processo P2 completa la sua esecuzione.
- Il processo P1 inizia l'esecuzione, verrà eseguito solo per 1 ms
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1 ms | 0ms |
Al tempo = 12,
- Il processo P1 completa la sua esecuzione.
- L'esecuzione complessiva dei processi sarà come mostrato di seguito:
| Istanza temporale | Processi | Orario di arrivo | Coda pronta | Coda in esecuzione | Tempo di esecuzione | Tempo di scoppio iniziale | Scoppio rimanente Tempo |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0ms | P2, P3 | P1 | 2 ms | 5ms | 3ms |
| 2-4 ms | P1 | 0ms | P3, P1 | P2 | 0ms | 3ms | 3ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms | |||
| 4-6 ms | P1 | 0ms | P1, P4, P2 | P3 | 0ms | 3ms | 3ms |
| 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 | 3ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| 8-9 ms | P1 | 0ms | P2, P1 | P4 | 0ms | 3ms | 1 ms |
| P2 | 1 ms | 0ms | 2 ms | 2 ms | |||
| P4 | 4 ms | 1ms | 1 ms | 0ms | |||
| 9-11 ms | P1 | 0ms | P1 | P2 | 0ms | 3ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0ms | |||
| 11-12 ms | P1 | 0ms | P1 | 1 ms | 1ms | 0ms |
diagramma di Gantt sarà il seguente:
Diagramma di Gantt per l'algoritmo di pianificazione Round Robin
Come calcolare i tempi inferiori in Round Robin utilizzando un programma?
- Tempo di completamento: Ora in cui il processo completa la sua esecuzione.
- Tempo di consegna: Differenza oraria tra l'ora di completamento e l'ora di arrivo. Tempo di consegna = Tempo di completamento - Orario di arrivo
- Tempo di attesa (PESO): Differenza temporale tra il tempo di rotazione e il tempo di scoppio.
Tempo di attesa = Tempo di svolta – Tempo di scoppio
Ora calcoliamo la media tempo di attesa e girarsi tempo:
| Processi | A | BT | CT | TAT | PESO |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | undici | 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 |
Ora,
- Tempo medio di consegna = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Tempo di attesa medio = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Esempio 2: Considera la seguente tabella del tempo di arrivo e del tempo di burst per tre processi P1, P2 e P3 e dati Quanto temporale = 2
| Processi | Tempo di scoppio | Orario di arrivo |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
Allo stesso modo, diagramma di Gantt per questo esempio:
Diagramma di Gantt per esempio 2
Ora calcoliamo la media tempo di attesa e girarsi tempo:
| Processi | A | BT | CT | TAT | PESO |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | quindici | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | ventuno | 21-0 = 21 | 21-8 = 13 |
Tempo totale di risposta = 59 ms
COSÌ, Tempo medio di risposta = 59/3 = 19,667 msE tempo di attesa totale = 36 ms
COSÌ, Tempo medio di attesa = 36/3 = 12,00 ms
Programma per la pianificazione Round Robin con orario di arrivo pari a 0 per tutti i processi
Passaggi per trovare i tempi di attesa di tutti i processi
- Crea una matrice rem_bt[] per tenere traccia del tempo di burst rimanente dei processi. Questo array è inizialmente una copia di bt[] (array dei tempi di burst)
- Crea un altro array peso[] per memorizzare i tempi di attesa dei processi. Inizializza questo array come 0.
- Inizializza il tempo: t = 0
- Continua ad attraversare tutti i processi mentre non sono terminati. Segui per lo sono processo se non è stato ancora completato.
- Se rem_bt[i]> quanto
- t = t + quanto
- rem_bt[i] -= importo;
- Else // Ultimo ciclo per questo processo
- t = t + rem_bt[i];
- peso[i] = t – bt[i]
- rem_bt[i] = 0; // Questo processo è terminato
Una volta ottenuti i tempi di attesa, possiamo calcolare il tempo di risposta tat[i] di un processo come somma dei tempi di attesa e di burst, ovvero wt[i] + bt[i].
Di seguito è riportata l'implementazione dei passaggi precedenti.
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) { fatto = falso; // C'è un processo in sospeso if (rem_bt[i]> quantum) { // Aumenta il valore di t cioè mostra // per quanto tempo un processo è stato elaborato t += quantum; // Diminuisce il burst_time del processo corrente // di quantum rem_bt[i] -= quantum; } // Se il tempo di burst è inferiore o uguale a // quantum. Ultimo ciclo per questo processo else { // Aumenta il valore di t cioè mostra // quanto tempo è stato elaborato un processo t = t + rem_bt[i]; // Il tempo di attesa è il tempo corrente meno il tempo // utilizzato da questo processo wt[i] = t - bt[i]; // Quando il processo viene completamente eseguito // imposta il tempo di burst rimanente = 0 rem_bt[i] = 0; } } } // Se tutti i processi sono stati completati if (done == true) break; } } // Funzione per calcolare il tempo di consegna void findTurnAroundTime(int processi[], int n, int bt[], int wt[], int tat[]) { // calcolo del tempo di consegna aggiungendo // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Funzione per calcolare il tempo medio void findavgTime(int processi[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Funzione per trovare il tempo di attesa di tutti i processi findWaitingTime(processes, n, bt, wt, quantum); Funzione per trovare il tempo di risposta per tutti i processi findTurnAroundTime(processes, n, bt, wt, tat // Visualizza i processi insieme a tutti i dettagli 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; }> |
stringa in Java
>
>
Giava
// 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) { fatto = falso; // C'è un processo in sospeso if (rem_bt[i]> quantum) { // Aumenta il valore di t cioè mostra // per quanto tempo un processo è stato elaborato t += quantum; // Diminuisce il burst_time del processo corrente // di quantum rem_bt[i] -= quantum; } // Se il tempo di burst è inferiore o uguale a // quantum. Ultimo ciclo per questo processo else { // Aumenta il valore di t cioè mostra // quanto tempo è stato elaborato un processo t = t + rem_bt[i]; // Il tempo di attesa è il tempo corrente meno il tempo // utilizzato da questo processo wt[i] = t - bt[i]; // Quando il processo viene completamente eseguito // imposta il tempo di burst rimanente = 0 rem_bt[i] = 0; } } } // Se tutti i processi sono stati completati if (done == true) break; } } // Metodo per calcolare il tempo di consegna static void findTurnAroundTime(int processi[], int n, int bt[], int wt[], int tat[]) { // calcolo del tempo di consegna aggiungendo // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metodo per calcolare il tempo medio static void findavgTime(intprocesss[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; int total_wt = 0, total_tat = 0 // Funzione per trovare il tempo di attesa di tutti i processi findWaitingTime( processs, n, bt, wt, quantum); // Funzione per trovare il tempo di risposta per tutti i processi findTurnAroundTime(processes, n, bt, wt, tat) // Visualizza i processi insieme a tutti i dettagli System.out.println(); 'PN ' + ' B ' + ' WT ' + ' TAT' // Calcola il tempo totale di attesa e il tempo totale di svolta // per (int i=0; i { total_wt = total_wt + wt[i]; totale_tat = totale_tat + tat[i]; System.out.println(' ' + (i+1) + ' ' + bt[i] +' ' + wt[i] +' ' + tat[i]); } System.out.println('Tempo di attesa medio = ' + (float)total_wt / (float)n); System.out.println('Tempo medio di consegna = ' + (float)total_tat / (float)n); } // Metodo driver public static void main(String[] args) { // id processo int processi[] = { 1, 2, 3}; int n = processi.lunghezza; // Orario di burst di tutti i processi int burst_time[] = {10, 5, 8}; // Quanto temporale int quanto = 2; findavgTime(processi, n, burst_time, quantistico); } }> |
>
>
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]>quanto) :> > ># 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#
riga e colonna
// 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) { // C'è un processo in sospeso done = false; if (rem_bt[i]> quantum) { // Aumenta il valore di t cioè // mostra per quanto tempo un processo // è stato elaborato t += quantum; // Diminuisce il burst_time del // processo corrente del quantum rem_bt[i] -= quantum; } // Se il tempo di burst è inferiore // o uguale a quanto. Ultimo ciclo // per questo processo else { // Aumenta il valore di t cioè // mostra per quanto tempo un processo // è stato elaborato t = t + rem_bt[i]; // Il tempo di attesa è quello attuale // tempo meno il tempo utilizzato da // questo processo wt[i] = t - bt[i]; // Man mano che il processo viene // completamente eseguito, il suo // tempo di burst rimanente = 0 rem_bt[i] = 0; } } } // Se tutti i processi sono stati completati if (done == true) break; } } // Metodo per calcolare il tempo di consegna static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // calcolo del tempo di consegna aggiungendo // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Metodo per calcolare il tempo medio static void findavgTime(int []processes, int n, int []bt, int quantum) { int []wt = new int[n]; processi findWaitingTime(processes, n, bt, wt, quantum); // Funzione per trovare il tempo di svolta // per tutti i processi findTurnAroundTime(processes, n, bt, wt, tat); Console.WriteLine('Processi ' + ' Tempo di scoppio ' + ' Tempo di attesa ' + ' Tempo di svolta' // Calcola il tempo di attesa totale e il tempo di svolta totale // per (int i = 0; i { peso_totale = peso_totale + peso_totale = tat_totale + tat[i]; Console.WriteLine(' ' + (i+1) + ' ' + bt[i ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Tempo di attesa medio = ' + (float)total_wt / (float)n); Console.Write('Tempo medio di consegna = ' + (float)total_tat / (float)n); } // Metodo driver public static void Main() { // ID processo int []processes = { 1, 2, 3}; int n = processi.Lunghezza; // Orario di burst di tutti i processi int []burst_time = {10, 5, 8}; // Quanto temporale int quanto = 2; findavgTime(processi, n, burst_time, quantistico); } } // Questo codice è fornito da nitin mittal.> |
>
>
Javascript
strumento di cattura in Ubuntu
> >// 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) { fatto = falso; // C'è un processo in sospeso if (rem_bt[i]> quantum) { // Aumenta il valore di t cioè mostra // per quanto tempo un processo è stato elaborato t += quantum; // Diminuisce il burst_time del processo corrente // di quantum rem_bt[i] -= quantum; } // Se il tempo di burst è inferiore o uguale a // quantum. Ultimo ciclo per questo processo else { // Aumenta il valore di t cioè mostra // quanto tempo è stato elaborato un processo t = t + rem_bt[i]; // Il tempo di attesa è il tempo corrente meno il tempo // utilizzato da questo processo wt[i] = t - bt[i]; // Quando il processo viene completamente eseguito // imposta il tempo di burst rimanente = 0 rem_bt[i] = 0; } } } // Se tutti i processi sono stati completati if (done == true) break; } } // Funzione per calcolare il tempo di consegna const findTurnAroundTime = (processes, n, bt, wt, tat) => { // calcolo del tempo di consegna aggiungendo // bt[i] + wt[i] for (let i = 0; i tat[i] = bt[i] + wt[i]; } // Funzione per calcolare il tempo medio const findavgTime = (processi, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Funzione per trovare il tempo di attesa di tutti i processi findWaitingTime(processes, n, bt, wt, quantum); // Funzione per trovare il tempo di svolta per tutti i processi findTurnAroundTime(processes, n, bt, wt, tat // Visualizza i processi insieme a tutti i dettagli document.write(`Processes Burst time Waiting time `); Calcola il tempo di attesa totale e il tempo // di svolta totale per (let i = 0; i total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; document.write(`${i + 1} ${ bt[i]} ${wt[i]} ${tat[i]} `); } document.write(`Tempo di attesa medio = ${total_wt / n}`); document.write(` Tempo medio di risposta = ${tat_totale / n}`); } // Codice driver // processi dell'id processo = [1, 2, 3]; let n = processi.lunghezza; // Il tempo di burst di tutti i processi lascia burst_time = [10, 5, 8]; // Quanto di tempo lascia quanto = 2; findavgTime(processi, n, burst_time, quantistico); // Questo codice è un contributo di rakeshsahni> |
>
>Produzione
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>
Programma per la pianificazione Round Robin con orario di arrivo pari a zero, orari di arrivo diversi e uguali
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; // Dichiarazione delle variabili int c = n, s[n][20]; tempo float = 0, mini = INT_MAX, b[n], a[n]; // Inizializzazione degli array del burst e dell'ora di arrivo int indice = -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) { indice = i; mini = a[i]; bandiera = vero; } } // se a =1 il ciclo termina quindi imposta flag su false if (!flag) { time++; Continua; } // calcolo dell'ora di inizio j = 0; while (s[indice][j] != -1) { j++; } if (s[indice][j] == -1) { s[indice][j] = tempo; p[indice].ST[j] = tempo; } if (b[indice]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[indice] = tempo + 0,1; } // calcolo dei tempi di arrivo, burst e finale if (b[index] == 0) { c--; p[indice].FT = tempo; p[indice].WT = p[indice].FT - p[indice].AT - p[indice].BT; tot_wt += p[indice].WT; p[indice].TAT = p[indice].BT + p[indice].WT; tot_tat += p[indice].TAT; } } // fine del ciclo while // Stampa dell'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 |
array in 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){ indice=i; mini=a[i]; bandiera=vero; } } // se a =1 il ciclo termina quindi imposta flag su false if(!flag){ time++; Continua; } //calcolo dell'ora di inizio j=0; while(s[indice][j]!=-1){ j++; } if(s[indice][j]==-1){ s[indice][j]=ora; p[indice].ST[j]=tempo; } if(b[indice]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[indice]=tempo+0,1; } // calcolo dei tempi di arrivo, burst, finale if(b[index]==0){ c--; p[indice].FT=ora; p[indice].WT=p[indice].FT-p[indice].AT-p[indice].BT; tot_wt+=p[indice].WT; p[indice].TAT=p[indice].BT+p[indice].WT; tot_tat+=p[indice].TAT; } } // fine del ciclo while // Stampa dell'output printf('Numero processo '); printf('Ora di arrivo'); printf('Tempo di scoppio'); printf(' Ora inizio'); j=0; while(j!=10){ j+=1; printf(''); } printf(' Ora finale'); printf(' Tempo di attesa'); printf(' Tempo di consegna
'); for(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d ',p[i].BT); j=0; int v=0; while(s[i][j]!=-1){ printf('%d ' ,p[i].ST[j]); j++; v+=3; } while(v!=40){ printf(' '); ',p[i].FT); printf('%d ',p[i].WT); printf('%d
',p[i].TAT) ; } //Calcolo del tempo di attesa medio e del tempo di consegna double avg_wt,avg_tat; avg_wt=tot_wt/(float)n; avg_tat=tot_tat/(float)n; time è: %lf
',avg_wt); printf('Il tempo medio di consegna è: %lf
',avg_tat); return 0; |
>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>
Programma per la pianificazione Round Robin con orari di arrivo diversi per tutti i processi
Per l'implementazione dettagliata dell'algoritmo Preemptive Round Robin con tempi di arrivo diversi per tutti i processi, fare riferimento a: Programma per la pianificazione Round Robin con orari di arrivo diversi .
Conclusione
In conclusione, lo scheduling della CPU Round Robin è un algoritmo equo e preventivo che assegna un quanto di tempo fisso a ciascun processo, garantendo pari accesso alla CPU. È semplice da implementare ma può portare a un maggiore sovraccarico di cambio di contesto. Sebbene promuova l’equità e prevenga la fame, può comportare tempi di attesa più lunghi e una riduzione della produttività, a seconda del quanto di tempo. L'implementazione efficace del programma consente il calcolo di parametri chiave come il tempo di completamento, il tempo di consegna e il tempo di attesa, aiutando nella valutazione e nell'ottimizzazione delle prestazioni.