Exercice Corrigé Ordonnancement Des Processus – Partie 3

L‘ordonnancement du processus est à la base des systèmes d’exploitation multiprogrammés. En répartissant l’unité centrale entre les processus, le système d’exploitation peut rendre l’ordinateur plus productif. Dans ce chapitre, nous présentons des exercices corrigés sur les concepts de base de l’ordonnancement, l’idée d’allocation de ressources et discutons en détail de l’ordonnancement de l’unité centrale. FCFS, SJF, Round-Robin, Priorité et les autres algorithmes d’ordonnancement devraient être familiers à vous.

 

Exercice 1: Ordonnancement Round Robin

Rappel: Dans l’ordonnancement Round Robin

  • L’unité centrale est attribuée au processus sur la base de la méthode FCFS pour une durée déterminée.
  • Cette durée fixe est appelée « time quantum » ou « time slice ».
  • À l’expiration du quantum de temps, le processus en cours est préempté et envoyé dans la file d’attente des processus prêts.
  • Le processeur est alors attribué au processus suivant.
  • Il s’agit toujours d’un processus préemptif par nature.

1.1) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 2 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+------------------------------------------+
| ID du processus | Temps d'arrivée | Temps de rafale/temps d'exécution du CPU |
+-----------------+-----------------+------------------------------------------+
| P1              | 0               | 5                                        |
+-----------------+-----------------+------------------------------------------+
| P2              | 1               | 3                                        |
+-----------------+-----------------+------------------------------------------+
| P3              | 2               | 1                                        |
+-----------------+-----------------+------------------------------------------+
| P4              | 3               | 2                                        |
+-----------------+-----------------+------------------------------------------+
| P5              | 4               | 3                                        |
+-----------------+-----------------+------------------------------------------+

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 13 – 5 = 8      | 13 – 0 = 13       |
+-----------+-----------------+-------------------+
| P2        | 11 – 3 = 8      | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 3 – 1 = 2       | 5 – 2 = 3         |
+-----------+-----------------+-------------------+
| P4        | 6 – 2 = 4       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 10 – 3 = 7      | 14 – 4 = 10       |
+-----------+-----------------+-------------------+
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (8 + 8 + 2 + 4 + 7) / 5 
                      = 29 / 5
                      = 5.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (13 + 11 + 3 + 6 + 10) / 5 
                        = 43 / 5
                        = 8.6 unités

1.2) Considérons les 6 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 2 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 0               | 4               |
+-----------------+-----------------+-----------------+
| P2              | 1               | 5               |
+-----------------+-----------------+-----------------+
| P3              | 2               | 2               |
+-----------------+-----------------+-----------------+
| P4              | 3               | 1               |
+-----------------+-----------------+-----------------+
| P5              | 4               | 6               |
+-----------------+-----------------+-----------------+
| P6              | 6               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 8 – 4 = 4       | 8 – 0 = 8         |
+-----------+-----------------+-------------------+
| P2        | 17 – 5 = 12     | 18 – 1 = 17       |
+-----------+-----------------+-------------------+
| P3        | 4 – 2 = 2       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P4        | 6 – 1 = 5       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 17 – 6 = 11     | 21 – 4 = 17       |
+-----------+-----------------+-------------------+
| P6        | 13 – 3 = 10     | 19 – 6 = 13       |
+-----------+-----------------+-------------------+
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (4 + 12 + 2 + 5 + 11 + 10) / 6
                      = 44 / 6
                      = 7.33 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (8 + 17 + 4 + 6 + 17 + 13) / 6
                        = 65 / 6
                        = 10.84 unités

1.3) Considérons les 6 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement Round Robin avec un quantum de temps = 3 unités, et calculez le temps d’attente moyen et le temps moyen de rotation.

+-----------------+-----------------+-----------------+
| ID du processus | Temps d'arrivée | Temps de rafale |
+-----------------+-----------------+-----------------+
| P1              | 5               | 5               |
+-----------------+-----------------+-----------------+
| P2              | 4               | 6               |
+-----------------+-----------------+-----------------+
| P3              | 3               | 7               |
+-----------------+-----------------+-----------------+
| P4              | 1               | 9               |
+-----------------+-----------------+-----------------+
| P5              | 2               | 2               |
+-----------------+-----------------+-----------------+
| P6              | 6               | 3               |
+-----------------+-----------------+-----------------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 27 – 5 = 22     | 32 – 5 = 27       |
+-----------+-----------------+-------------------+
| P2        | 23 – 6 = 17     | 27 – 4 = 23       |
+-----------+-----------------+-------------------+
| P3        | 30 – 7 = 23     | 33 – 3 = 30       |
+-----------+-----------------+-------------------+
| P4        | 29 – 9 = 20     | 30 – 1 = 29       |
+-----------+-----------------+-------------------+
| P5        | 4 – 2 = 2       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P6        | 15 – 3 = 12     | 21 – 6 = 15       |
+-----------+-----------------+-------------------+
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (22 + 17 + 23 + 20 + 2 + 12) / 6
                      = 96 / 6
                      = 16 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (27 + 23 + 30 + 29 + 4 + 15) / 6 
                        = 128 / 6
                        = 21.33 unités
 

Exercice 2: Ordonnancement par priorité (Priority Scheduling)

Rappel: Dans l’ordonnancement par priorité

  • Parmi tous les processus disponibles, l’unité centrale est attribuée au processus ayant la priorité la plus élevée.
  • En cas d’égalité, le processus est départagé par l’ordonnancement FCFS.
  • L’ordonnancement par priorité peut être utilisé en mode préemptif ou non préemptif.
  • Le temps d’attente pour le processus ayant la priorité la plus élevée sera toujours nul en mode préemptif.
  • Le temps d’attente pour le processus ayant la priorité la plus élevée peut ne pas être nul en mode non préemptif.

L’ordonnancement par priorité en mode préemptif et non préemptif se comporte exactement de la même manière dans les conditions suivantes:

  • L’heure d’arrivée de tous les processus est la même
  • Tous les processus deviennent disponibles

Avantages:

  • Il prend en compte la priorité des processus et permet aux processus importants de s’exécuter en premier.
  • L’ordonnancement par priorité en mode préemptif est le mieux adapté aux systèmes d’exploitation en temps réel.

Inconvénients:

  • Les processus moins prioritaires risquent d’être affamés par l’unité centrale.
  • Il n’y a aucune idée du temps de réponse et du temps d’attente.

2.1) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement par priorité non préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation. (Le chiffre le plus élevé correspond à une priorité plus importante).

+-----------+-----------------+-----------------+----------+
| Processus | Temps d'arrivée | Temps de rafale | Priorité |
+-----------+-----------------+-----------------+----------+
| P1        | 0               | 4               | 2        |
+-----------+-----------------+-----------------+----------+
| P2        | 1               | 3               | 3        |
+-----------+-----------------+-----------------+----------+
| P3        | 2               | 1               | 4        |
+-----------+-----------------+-----------------+----------+
| P4        | 3               | 5               | 5        |
+-----------+-----------------+-----------------+----------+
| P5        | 4               | 2               | 5        |
+-----------+-----------------+-----------------+----------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 4 – 4 = 0       | 4 – 0 = 4         |
+-----------+-----------------+-------------------+
| P2        | 14 – 3 = 11     | 15 – 1 = 14       |
+-----------+-----------------+-------------------+
| P3        | 10 – 1 = 9      | 12 – 2 = 10       |
+-----------+-----------------+-------------------+
| P4        | 6 – 5 = 1       | 9 – 3 = 6         |
+-----------+-----------------+-------------------+
| P5        | 7 – 2 = 5       | 11 – 4 = 7        |
+-----------+-----------------+-------------------+
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (0 + 11 + 9 + 1 + 5) / 5
                      = 26 / 5
                      = 5.2 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (4 + 14 + 10 + 6 + 7) / 5
                        = 41 / 5
                        = 8.2 unités

2.2) Considérons les 5 processus suivants avec un temps de rafale (temps d’exécution de l’unité centrale). Dessinez l’ordre d’exécution des processus à l’aide d’un diagramme de Gantt (ligne temporelle) en utilisant l’algorithme d’ordonnancement par priorité préemptive, et calculez le temps d’attente moyen et le temps moyen de rotation. (Le chiffre le plus élevé correspond à une priorité plus importante).

+-----------+-----------------+-----------------+----------+
| Processus | Temps d'arrivée | Temps de rafale | Priorité |
+-----------+-----------------+-----------------+----------+
| P1        | 0               | 4               | 2        |
+-----------+-----------------+-----------------+----------+
| P2        | 1               | 3               | 3        |
+-----------+-----------------+-----------------+----------+
| P3        | 2               | 1               | 4        |
+-----------+-----------------+-----------------+----------+
| P4        | 3               | 5               | 5        |
+-----------+-----------------+-----------------+----------+
| P5        | 4               | 2               | 5        |
+-----------+-----------------+-----------------+----------+

Maintenant, on sait que:

Temps de rotation = Temps fin d’exécution – Temps d’arrivée

Temps d’attente = Temps de rotation – Temps de rafale

+-----------+-----------------+-------------------+
| Processus | Temps d'attente | Temps de rotation |
+-----------+-----------------+-------------------+
| P1        | 15 – 4 = 11     | 15 – 0 = 15       |
+-----------+-----------------+-------------------+
| P2        | 11 – 3 = 8      | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 1 – 1 = 0       | 3 – 2 = 1         |
+-----------+-----------------+-------------------+
| P4        | 5 – 5 = 0       | 8 – 3 = 5         |
+-----------+-----------------+-------------------+
| P5        | 6 – 2 = 4       | 10 – 4 = 6        |
+-----------+-----------------+-------------------+
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (11 + 8 + 0 + 0 + 4) / 5
                      = 23 / 5
                      = 4.6 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (15 + 11 + 1 + 5 + 6) / 5
                        = 38 / 5
                        = 7.6 unités
 

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *