Tournoi à la ronde est un algorithme de planification de CPU dans lequel chaque processus se voit attribuer cycliquement un créneau horaire fixe. Il s'agit de la version préemptive de l'algorithme de planification du processeur Premier arrivé, premier servi.
fichiers Linux
- L'algorithme CPU Round Robin se concentre généralement sur la technique de partage du temps.
- La période de temps pendant laquelle un processus ou une tâche est autorisé à s'exécuter dans une méthode préemptive est appelée temps. quantum .
- Chaque processus ou travail présent dans la file d'attente prête se voit attribuer le processeur pour ce quantum de temps. Si l'exécution du processus est terminée pendant ce temps, le processus le fera. fin sinon, le processus reviendra au table d'attente et attendez son prochain tour pour terminer l'exécution.
Caractéristiques de l'algorithme de planification du processeur Round Robin
- C’est simple, facile à mettre en œuvre et sans famine car tous les processus reçoivent une part équitable du processeur.
- L'une des techniques les plus couramment utilisées dans Planification du processeur est un noyau.
- C'est préemptif car les processus se voient attribuer du CPU uniquement pour une tranche de temps fixe au maximum.
- L'inconvénient est une surcharge liée au changement de contexte.
Avantages de l'algorithme de planification du processeur Round Robin
- Il y a de l'équité puisque chaque processus reçoit une part égale du processeur.
- Le processus nouvellement créé est ajouté à la fin de la file d'attente prête.
- Un planificateur à tour de rôle utilise généralement le temps partagé, attribuant à chaque tâche un créneau horaire ou un quantum.
- Lors de l'exécution d'une planification à tour de rôle, un temps particulier est alloué à différentes tâches.
- Chaque processus a la possibilité d'être reprogrammé après un temps quantique particulier dans cette planification.
Inconvénients de l’algorithme de planification du processeur Round Robin
- Il y a un temps d'attente et un temps de réponse plus longs.
- Le débit est faible.
- Il existe des changements de contexte.
- Le diagramme de Gantt semble trop volumineux (si le temps quantique est inférieur pour la planification. Par exemple : 1 ms pour une planification importante.)
- Planification fastidieuse pour les petits quantums.
Exemples pour montrer le fonctionnement de Tournoi à la ronde Algorithme de planification
Exemple 1: Considérez le tableau suivant de l'heure d'arrivée et du temps de rafale pour quatre processus P1, P2, P3 et P4 et donné Temps Quantique = 2
| Processus | Temps de rafale | Heure d'arrivée |
|---|---|---|
| P1 | 5 ms | 0 ms |
| P2 | 4 ms | 1 ms |
| P3 | 2 ms | 2 ms |
| P4 | 1 ms | 4 ms |
L'algorithme de planification du processeur Round Robin fonctionnera sur la base des étapes mentionnées ci-dessous :
Au temps = 0,
- L'exécution commence par le processus P1, qui a un temps de rafale de 5.
- Ici, chaque processus s'exécute pendant 2 millisecondes ( Période quantique de temps ). P2 et P3 sont toujours dans la file d'attente.
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
Au temps = 2,
- Les processus P1 et P3 arrivent dans la file d'attente prête et P2 commence à s'exécuter pendant QT période
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 3 ms | 3 ms |
| P2 | 1 ms | 2 ms | 4 ms | 2 ms |
Au temps = 4,
- Le processus P4 arrive dans le file d'attente prête ,
- Puis P3 s'exécute pour QT période.
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 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 |
Au temps = 6,
- Le processus P3 termine son exécution
- Le processus P1 commence à s'exécuter pendant QT période telle qu'elle est la suivante dans le b.
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 6-8 ms | P1 | 0 ms | P4, P2 | P1 | 2 ms | 3 ms | 1 ms |
| P2 | 1 ms | 0 ms | 2 ms | 2 ms |
Au temps = 8,
- Le processus P4 commence à s'exécuter, il ne s'exécutera pas pendant Temps Période quantique car il a un temps de rafale = 1
- Par conséquent, il ne s’exécutera que pendant 1 ms.
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 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 |
Au temps = 9,
- Le processus P4 termine son exécution
- Le processus P2 commence à s'exécuter pendant QT période car c'est la prochaine dans le file d'attente prête
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 9-11 ms | P1 | 0 ms | P1 | P2 | 0 ms | 3 ms | 1 ms |
| P2 | 1 ms | 2 ms | 2 ms | 0 ms |
Au temps = 11,
- Le processus P2 termine son exécution.
- Le processus P1 commence à s'exécuter, il s'exécutera pendant 1 ms seulement
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 11-12 ms | P1 | 0 ms | P1 | 1 ms | 1 ms | 0 ms |
Au temps = 12,
- Le processus P1 termine son exécution.
- L’exécution globale des processus sera la suivante :
| Instance temporelle | Processus | Heure d'arrivée | File d'attente prête | File d'attente en cours d'exécution | Temps d'exécution | Temps de rafale initial | Rafale restante Temps |
|---|---|---|---|---|---|---|---|
| 0-2ms | P1 | 0 ms | P2, P3 | P1 | 2 ms | 5 ms | 3 ms |
| 2-4 ms | P1 | 0 ms | P3, P1 | P2 | 0 ms | 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 | 0 ms | 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 | 0 ms |
diagramme de Gantt sera comme suit ci-dessous :
Diagramme de Gantt pour l'algorithme de planification Round Robin
Comment calculer les temps ci-dessous dans Round Robin à l'aide d'un programme ?
- Le temps d'achèvement: Heure à laquelle le processus termine son exécution.
- Délai d'exécution : Temps Différence entre l’heure d’achèvement et l’heure d’arrivée. Temps d’exécution = Heure d’achèvement – Heure d’arrivée
- Temps d'attente (WT) : Temps Différence entre le temps d'exécution et le temps de rafale.
Temps d'attente = Temps d'exécution – Temps de rafale
Maintenant, calculons la moyenne temps d'attente et faire demi-tour temps:
| Processus | À | BT | CT | TAT | POIDS |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | onze | 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 |
Maintenant,
- Délai d'exécution moyen = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Temps d'attente moyen = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
Exemple 2 : Considérons le tableau suivant de l'heure d'arrivée et du temps de rafale pour trois processus P1, P2 et P3 et étant donné Temps Quantique = 2
| Processus | Temps de rafale | Heure d'arrivée |
|---|---|---|
| P1 | 10 ms | 0 ms |
| P2 | 5 ms | 0 ms |
| P3 | 8 ms | 0 ms |
De la même manière, diagramme de Gantt pour cet exemple :
Diagramme de Gantt par exemple 2
Maintenant, calculons la moyenne temps d'attente et faire demi-tour temps:
| Processus | À | BT | CT | TAT | POIDS |
|---|---|---|---|---|---|
| P1 | 0 | dix | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | quinze | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | vingt-et-un | 21-0 = 21 | 21-8 = 13 |
Temps d'exécution total = 59 ms
Donc, Délai d'exécution moyen = 59/3 = 19,667 msEt, Temps d'attente total = 36 ms
Donc, Temps d'attente moyen = 36/3 = 12,00 ms
Programme de planification Round Robin avec une heure d'arrivée égale à 0 pour tous les processus
Étapes pour trouver les temps d'attente de tous les processus
- Créer un tableau rem_bt[] pour garder une trace du temps de rafale restant des processus. Ce tableau est initialement une copie de bt[] (tableau des temps de rafale)
- Créer un autre tableau poids[] pour stocker les temps d'attente des processus. Initialisez ce tableau à 0.
- Temps d'initialisation : t = 0
- Continuez à parcourir tous les processus pendant qu’ils ne sont pas terminés. Faites ce qui suit pour je suis processus si ce n’est pas encore fait.
- Si rem_bt[i]> quantique
- t = t + quantique
- rem_bt[i] -= montant ;
- Sinon // Dernier cycle pour ce processus
- t = t + rem_bt[je];
- poids[je] = t – bt[je]
- rem_bt[i] = 0; // Ce processus est terminé
Une fois que nous avons les temps d'attente, nous pouvons calculer le temps d'exécution tat[i] d'un processus comme la somme des temps d'attente et de rafale, c'est-à-dire wt[i] + bt[i].
Vous trouverez ci-dessous la mise en œuvre des étapes ci-dessus.
âge de Pete Davidson
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) { fait = faux ; // Il y a un processus en attente if (rem_bt[i]> quantum) { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t += quantum; // Diminue le burst_time du processus en cours // de quantum rem_bt[i] -= quantum; } // Si le temps de rafale est inférieur ou égal à // quantum. Dernier cycle pour ce processus else { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t = t + rem_bt[i]; // Le temps d'attente est l'heure actuelle moins l'heure // utilisée par ce processus wt[i] = t - bt[i]; // Au fur et à mesure que le processus est entièrement exécuté //, son temps de rafale restant = 0 rem_bt[i] = 0; } } } // Si tous les processus sont terminés if (done == true) break; } } // Fonction pour calculer le délai d'exécution void findTurnAroundTime(intprocess[], int n, int bt[], int wt[], int tat[]) { // calcul du délai d'exécution en ajoutant // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Fonction pour calculer le temps moyen void findavgTime(intprocess[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Fonction pour trouver le temps d'attente de tous les processus findWaitingTime(processes, n, bt, wt, quantum); Fonction pour trouver le délai d'exécution pour tous les processus findTurnAroundTime(processes, n, bt, wt, tat // Afficher les processus avec tous les détails 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) { fait = faux ; // Il y a un processus en attente if (rem_bt[i]> quantum) { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t += quantum; // Diminue le burst_time du processus en cours // de quantum rem_bt[i] -= quantum; } // Si le temps de rafale est inférieur ou égal à // quantum. Dernier cycle pour ce processus else { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t = t + rem_bt[i]; // Le temps d'attente est l'heure actuelle moins l'heure // utilisée par ce processus wt[i] = t - bt[i]; // Au fur et à mesure que le processus est entièrement exécuté //, son temps de rafale restant = 0 rem_bt[i] = 0; } } } // Si tous les processus sont terminés if (done == true) break; } } // Méthode pour calculer le temps d'exécution static void findTurnAroundTime(intprocess[], int n, int bt[], int wt[], int tat[]) { // calcul du temps d'exécution en ajoutant // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Méthode pour calculer le temps moyen static void findavgTime(intprocess[], int n, int bt[], int quantum) { int wt[] = new int[n], tat[] = new int[n]; process, n, bt, wt, quantum); // Fonction pour trouver le temps d'exécution pour tous les processus findTurnAroundTime(processes, n, bt, wt, tat); // Afficher les processus avec tous les détails System.out.println( 'PN ' + ' B ' + ' WT ' + ' TAT'); // Calculer le temps d'attente total et le temps d'exécution total // pour (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('Temps d'attente moyen = ' + (float)total_wt / (float)n); System.out.println('Délai d'exécution moyen = ' + (float)total_tat / (float)n); } // Méthode du pilote public static void main(String[] args) { // identifiant du processus int processus[] = { 1, 2, 3}; int n = processus.longueur; // Heure de rafale de tous les processus int burst_time[] = {10, 5, 8} ; // Quantum de temps int quantum = 2; findavgTime (processus, 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]>quantique) :> > ># 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)> |
>
La sous-chaîne Java contient
>
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) { // Il y a un processus en attente done = false; if (rem_bt[i]> quantum) { // Augmente la valeur de t, c'est-à-dire // montre combien de temps un processus // a été traité t += quantum; // Diminue le burst_time du // processus actuel de quantum rem_bt[i] -= quantum; } // Si le temps de rafale est inférieur à // ou égal au quantum. Dernier cycle // pour ce processus else { // Augmente la valeur de t, c'est-à-dire // montre combien de temps un processus // a été traité t = t + rem_bt[i]; // Le temps d'attente est actuel // le temps moins le temps utilisé par // ce processus wt[i] = t - bt[i]; // Au fur et à mesure que le processus est complètement // exécuté, son temps de rafale // restant = 0 rem_bt[i] = 0; } } } // Si tous les processus sont terminés if (done == true) break; } } // Méthode pour calculer le temps d'exécution static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // calcul du temps d'exécution en ajoutant // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Méthode pour calculer le temps moyen static void findavgTime(int []processes, int n, int []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0, total_tat = 0; // Fonction pour trouver le temps d'attente de // tous processus findWaitingTime(processes, n, bt, wt, quantum); // Fonction pour trouver le temps d'exécution // pour tous les processus findTurnAroundTime(processes, n, bt, wt, tat); // Afficher les processus avec // tous les détails Console.WriteLine('Processus ' + ' Temps de rafale ' + ' Temps d'attente ' + ' Temps d'exécution'); // Calculer le temps d'attente total et le temps d'exécution total // pour (int i = 0; je { poids_total = poids_total + poids[i]; total_tat = total_tat + tat[i]; Console.WriteLine(' ' + (i+1) + ' ' + bt[i ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Temps d'attente moyen = ' + (float)total_wt / (float)n); Console.Write('Délai d'exécution moyen = ' + (float)total_tat / (float)n); } // Méthode du pilote public static void Main() { // identifiant du processus int []processes = { 1, 2, 3}; int n = processus.Longueur ; // Heure de rafale de tous les processus int []burst_time = {10, 5, 8} ; // Quantum de temps int quantum = 2; findavgTime (processus, n, burst_time, quantum); } } // Ce code est fourni par nitin mittal.> |
chaînage avant
>
>
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) { fait = faux ; // Il y a un processus en attente if (rem_bt[i]> quantum) { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t += quantum; // Diminue le burst_time du processus en cours // de quantum rem_bt[i] -= quantum; } // Si le temps de rafale est inférieur ou égal à // quantum. Dernier cycle pour ce processus else { // Augmente la valeur de t, c'est-à-dire montre // combien de temps un processus a été traité t = t + rem_bt[i]; // Le temps d'attente est l'heure actuelle moins l'heure // utilisée par ce processus wt[i] = t - bt[i]; // Au fur et à mesure que le processus est entièrement exécuté //, son temps de rafale restant = 0 rem_bt[i] = 0; } } } // Si tous les processus sont terminés if (done == true) break; } } // Fonction pour calculer le temps d'exécution const findTurnAroundTime = (processes, n, bt, wt, tat) => { // calcul du temps d'exécution en ajoutant // bt[i] + wt[i] for (let i = 0; i tat[i] = bt[i] + wt[i]; } // Fonction pour calculer le temps moyen const findavgTime = (processus, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Fonction pour trouver le temps d'attente de tous les processus findWaitingTime(processes, n, bt, wt, quantum); // Fonction pour trouver le temps d'exécution pour tous les processus findTurnAroundTime(processes, n, bt, wt, tat); // Afficher les processus avec tous les détails document.write(`Processus Burst time Temps d'attente `); Calculez le temps d'attente total et le // temps d'exécution total pour (soit 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(`Délai d'attente moyen = ${total_wt / n}`); = ${total_tat / n}`); } // Code du pilote // Processus de l'identifiant du processus = [1, 2, 3]; soit n = processus.longueur ; // Temps de rafale de tous les processus let burst_time = [10, 5, 8]; // Quantum de temps soit quantum = 2 ; findavgTime (processus, n, burst_time, quantum); // Ce code est contribué par rakeshsahni> |
>
>Sortir
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>
Programme de planification Round Robin avec une heure d'arrivée nulle, différente et identique
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; // Déclaration des variables int c = n, s[n][20]; temps flottant = 0, mini = INT_MAX, b[n], a[n] ; // Initialisation des tableaux d'heures de rafale et d'arrivée int index = -1; pour (i = 0; je b[i] = p[i].BT; a[i] = p[i].AT; pour (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 = un[je]; drapeau = vrai ; } } // if at =1 alors la boucle sort donc définit l'indicateur sur false if (!flag) { time++; continuer; } // calcul de l'heure de début j = 0 ; while (s[index][j] != -1) { j++; } if (s[index][j] == -1) { s[index][j] = heure ; p[index].ST[j] = heure ; } si (b[index]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[index] = temps + 0,1 ; } // calcul des heures d'arrivée, de rafale et finales if (b[index] == 0) { c--; p[index].FT = heure ; 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; } } // fin de la boucle while // Impression de la sortie 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){ index=i; mini=a[je]; drapeau = vrai ; } } // si à =1 alors la boucle sort donc définit l'indicateur sur false if(!flag){ time++; continuer; } //calcul de l'heure de début j=0; while(s[index][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=heure ; p[index].ST[j]=heure; } si(b[index]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[index]=temps+0,1 ; } // calcul des heures d'arrivée, de rafale et de fin if(b[index]==0){ c--; p[index].FT=heure; 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; } } // fin de la boucle while // Impression de la sortie printf('Numéro de processus '); printf('Heure d'arrivée '); printf('Durée de rafale '); printf(' Heure de début'); j = 0 ; tandis que(j!=10){ j+=1; printf(' '); } printf(' Heure finale'); printf(' Temps d'attente '); printf(' Délai d'exécution
'); pour(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d ',p[i].BT); j=0; int v=0; tandis que(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); ; } //Calcul du temps d'attente moyen et du délai d'exécution double avg_wt,avg_tat; avg_wt=tot_wt/(float)n; avg_tat=tot_tat/(float)n; //Impression du temps d'attente moyen et du délai d'exécution printf('Le temps d'attente moyen le temps est : %lf
',avg_wt); printf('Le temps d'exécution moyen est : %lf
',avg_tat); |
>ordre SQL au hasardEnter 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>
Programme de planification Round Robin avec différentes heures d'arrivée pour tous les processus
Pour une mise en œuvre détaillée de l'algorithme Preemptive Round Robin avec des heures d'arrivée différentes pour tous les processus, veuillez vous référer : Programme de planification Round Robin avec différentes heures d'arrivée .
Conclusion
En conclusion, la planification CPU Round Robin est un algorithme juste et préemptif qui alloue un temps fixe à chaque processus, garantissant un accès égal au CPU. Il est simple à mettre en œuvre mais peut entraîner une surcharge de changement de contexte plus élevée. Même si cela favorise l’équité et évite la famine, cela peut entraîner des temps d’attente plus longs et une réduction du débit, en fonction du temps écoulé. La mise en œuvre efficace du programme permet de calculer des indicateurs clés tels que le délai d'exécution, le délai d'exécution et le temps d'attente, facilitant ainsi l'évaluation et l'optimisation des performances.