Les processus inactifs, souvent appelés « processus zombie » ou « processus idle », sont présents dans de nombreux systèmes d’exploitation pour plusieurs raisons.

Si aucun processus n’est dans l’état « prêt », le processus inactif du système se voit attribuer l’unité centrale. Le processus inactif du système est toujours actif mais avec la priorité la plus basse, permet au planificateur de garantir qu’il y a toujours un processus prêt à s’exécuter, même lorsque aucun autre processus n’est disponible. Cela évite des situations où l’unité centrale (UC) serait inoccupée. En créant un processus inactif pour chaque cœur de processeur, les systèmes d’exploitation modernes assurent une gestion efficace des ressources et optimisent l’utilisation de l’UC.

En résumé, les processus inactifs sont essentiels pour la performance, la réactivité et l’efficacité des systèmes d’exploitation.

Ordonnancement préemptif: Permet à un processus en cours d’exécution d’être interrompu pour donner la priorité à un autre processus. Utilisé dans les systèmes multitâches pour assurer une réactivité élevée. Par exemple, un processus avec une priorité plus élevée peut prendre le contrôle du CPU à tout moment.

Ordonnancement non préemptif: Un processus en cours d’exécution doit se terminer ou libérer le CPU volontairement avant qu’un autre processus puisse être exécuté. Utilisé dans des systèmes où la prévisibilité est essentielle, comme certains systèmes embarqués.

En résumé, l’ordonnancement préemptif permet des interruptions pour un meilleur contrôle, tandis que l’ordonnancement non préemptif laisse les processus terminer leur exécution sans interruption.

Un inconvénient de l’ordonnancement préemptif est l’augmentation de l’overhead du système. Les interruptions fréquentes pour passer d’un processus à un autre peuvent entraîner un coût en termes de temps de gestion et de ressources, ce qui peut nuire à la performance globale, surtout si les processus sont courts et que le temps de commutation devient significatif par rapport à leur temps d’exécution.

Un inconvénient de l’ordonnancement non préemptif est le risque de starvation. Si un processus à faible priorité est bloqué par des processus à priorité plus élevée, il peut ne jamais obtenir l’accès au CPU, entraînant des délais d’exécution imprévus et une mauvaise réactivité du système.

Il fonctionne avec plusieurs files d’attente. Chaque file d’attente a une priorité différente ou un multiplex temporel. Chaque nouveau processus est inséré dans la file d’attente supérieure, ce qui lui confère la priorité la plus élevée. Pour chaque file d’attente, le système Round Robin est utilisé. Si un processus abandonne volontairement l’unité centrale, il est réinséré dans la même file d’attente. Si un processus a utilisé toute sa tranche de temps, il est inséré dans la file d’attente immédiatement inférieure, avec une priorité plus faible.

Une méthode d’ordonnancement est équitable lorsque chaque processus se voit attribuer l’unité centrale à un moment donné.

Les méthodes d’ordonnancement équitables sont les suivantes:

• C. Round Robin avec quantum de temps: Cette méthode alloue des tranches de temps égales à chaque tâche, ce qui favorise l’équité.
• E. Partage équitable: Cette méthode vise à garantir que tous les utilisateurs ou toutes les tâches reçoivent une part équitable des ressources.

Les méthodes d’ordonnancement préemptif sont les suivantes:

• Round Robin avec quantum de temps: Cette méthode permet aux tâches d’être préemptées après l’expiration de leur tranche de temps, ce qui garantit la réactivité.
• Multilevel Queues: Cette méthode peut également préempter des tâches en fonction de leur priorité et de leur comportement, ce qui permet des ajustements dynamiques.

Les méthodes non préemptives sont les suivantes:

• Premier arrivé, premier servi: Une fois qu’une tâche commence à s’exécuter, elle est exécutée jusqu’à son terme.
• Partage équitable: Typiquement non préemptive, car elle se concentre sur la distribution des ressources sans interrompre les tâches en cours.

• Round Robin (RR): Chaque processus reçoit un quantum de temps fixe (q = 1 ms). Si le processus n’a pas terminé à la fin de son quantum, il est préempté et remis à la fin de la file d’attente. Ce cycle continue jusqu’à ce que tous les processus soient terminés.
• First Come First Served (FCFS): Les processus sont exécutés dans l’ordre de leur arrivée. Le premier processus dans la file d’attente est servi jusqu’à sa terminaison, puis le suivant est exécuté.
• Priority-Driven Scheduling: Chaque processus se voit attribuer une priorité. Les processus avec une priorité plus élevée sont exécutés avant ceux avec une priorité plus basse. Si un processus de priorité plus élevée arrive, il peut préempter le processus en cours.

Le temps CPU est le temps dont le processus a besoin pour accéder au CPU afin de terminer son exécution.

Durée d’exécution = durée de vie = période de temps entre la création et la fin d’un processus = (temps CPU + temps d’attente).

+------------------------------------------+----+----+----+----+----+
| Durée d'exécution                        |  A |  B |  C |  D |  E |
+------------------------------------------+----+----+----+----+----+
| Round Robin                              | 20 | 32 | 13 | 25 | 30 |
+------------------------------------------+----+----+----+----+----+
| FCFS(First Come First Served)            | 5  | 15 | 18 | 24 | 32 |
+------------------------------------------+----+----+----+----+----+
| Ordonnancement par priorités             | 5  | 29 | 32 | 11 | 19 |
+------------------------------------------+----+----+----+----+----+

RR   (20 + 32 + 13 + 25 + 30) / 5  = 24   ms
FCFS (5 + 15 + 18 + 24 + 32)  / 5  = 18,8 ms
PS   (5 + 29 + 32 + 11 + 19)  / 5  = 19,2 ms

Temps d’attente = temps pendant lequel un processus est dans l’état prêt.

Temps d’attente = temps d’exécution – temps CPU.

+------------------------------------------+----+----+----+----+----+
| Temps d'attente                          |  A |  B |  C |  D |  E |
+------------------------------------------+----+----+----+----+----+
| Round Robin                              | 15 | 22 | 10 | 19 | 22 |
+------------------------------------------+----+----+----+----+----+
| FCFS(First Come First Served)            | 0  | 5  | 15 | 18 | 24 |
+------------------------------------------+----+----+----+----+----+
| Ordonnancement en fonction des priorités | 0  | 19 | 29 | 5  | 11 |
+------------------------------------------+----+----+----+----+----+

RR   (15 + 22 + 10 + 19 + 22) / 5 = 17,6 ms
FCFS (0 + 5 + 15 + 18 + 24)   / 5 = 12,4 ms
PS   (0 + 19 + 29 + 5 + 11)   / 5 = 12,8 ms

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

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

 

Temps moyen de rotation = 2+4+8+11+16/5 = 41/5 = 8.2 
Temps moyen d'attente   = 0+1+3+7+10/5  = 21/5 = 4.2 

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        | 0               | 24                |
+-----------+-----------------+-------------------+
| P2        | 24              | 27                |
+-----------+-----------------+-------------------+
| P3        | 27              | 30                |
+-----------+-----------------+-------------------+

Temps d'attente total = 0 + 24 + 27 = 51 ms
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = 51 / 3 
                      = 17 ms
					  
Temps de rotation total = 24 + 27 + 30 = 81 ms
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = 81 / 3 
                        = 27 ms
						
Débit = 3 jobs/30 sec = 0.1 jobs/sec

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        | 0               | 8 – 0 = 8         |
+-----------+-----------------+-------------------+
| P2        | 8 – 1 = 7       | 12 – 1 = 11       |
+-----------+-----------------+-------------------+
| P3        | 12 – 2 = 10     | 21 – 2 = 19       |
+-----------+-----------------+-------------------+
| P4        | 21 – 3 = 18     | 26 – 3 = 23       |
+-----------+-----------------+-------------------+

Temps d'attente total = 0 + 7 + 10 + 18 = 35 ms
Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = 35 / 4
                      = 8.75 ms
					  
Temps de rotation total = 8 + 11 + 19 + 23 = 61 ms
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = 61 / 4
                        = 15.25 ms
						
Débit = 4 jobs/26 sec = 0.15385 jobs/sec

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 – 1 = 3       | 7 – 3 = 4         |
+-----------+-----------------+-------------------+
| P2        | 15 – 4 = 11     | 16 – 1 = 15       |
+-----------+-----------------+-------------------+
| P3        | 5 – 2 = 3       | 9 – 4 = 5         |
+-----------+-----------------+-------------------+
| P4        | 6 – 6 = 0       | 6 – 0 = 6         |
+-----------+-----------------+-------------------+
| P5        | 10 – 3 = 7      | 12 – 2 = 10       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (3 + 11 + 3 + 0 + 7) / 5 
                      = 24 / 5
                      = 4.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (4 + 15 + 5 + 6 + 10) / 5 
                        = 40 / 5
                        = 8 unités

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        | 1 – 1 = 0       | 4 – 3 = 1         |
+-----------+-----------------+-------------------+
| P2        | 5 – 4 = 1       | 6 – 1 = 5         |
+-----------+-----------------+-------------------+
| P3        | 4 – 2 = 2       | 8 – 4 = 4         |
+-----------+-----------------+-------------------+
| P4        | 16 – 6 = 10     | 16 – 0 = 16       |
+-----------+-----------------+-------------------+
| P5        | 9 – 3 = 6       | 11 – 2 = 9        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (0 + 1 + 2 + 10 + 6) / 5 
                      = 19 / 5
                      = 3.8 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (1 + 5 + 4 + 16 + 9) / 5
                        = 35 / 5
                        = 7 unités

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        | 19 – 7 = 12     | 19 – 0 = 19       |
+-----------+-----------------+-------------------+
| P2        | 12 – 5 = 7      | 13 – 1 = 12       |
+-----------+-----------------+-------------------+
| P3        | 4 – 3 = 1       | 6 – 2 = 4         |
+-----------+-----------------+-------------------+
| P4        | 1 – 1 = 0       | 4 – 3 = 1         |
+-----------+-----------------+-------------------+
| P5        | 5 – 2 = 3       | 9 – 4 = 5         |
+-----------+-----------------+-------------------+
| P6        | 2 – 1 = 1       | 7 – 5 = 2         |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (12 + 7 + 1 + 0 + 3 + 1) / 6
                      = 24 / 6
                      = 4 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (19 + 12 + 4 + 1 + 5 + 2) / 6
                        = 43 / 6
                        = 7.17 unités

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        | 13 – 9 = 4      | 13 – 0 = 13       |
+-----------+-----------------+-------------------+
| P2        | 4 – 4 = 0       | 5 – 1 = 4         |
+-----------+-----------------+-------------------+
| P3        | 20 – 9 = 11     | 22- 2 = 20        |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (4 + 0 + 11) / 3
                      = 15 / 3
                      = 5 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (13 + 4 + 20) / 3
                        = 37 / 3
                        = 12.33 unités

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

Donc:

Temps moyen d’attente du processus P2 = 55 – 15 = 40 unités

Temps moyen de rotation du processus P2 = 40 – 25 = 15 unités

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

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

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

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

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

D’après la question, nous avons:

Rafale = Temps d’exécution

+--------------+------------------+------------+------------+------------+
|              | Totale du Rafale | Rafale E/S | Rafale CPU | Rafale E/S |
+--------------+------------------+------------+------------+------------+
| Processus P1 | 10               | 2          | 7          | 1          |
+--------------+------------------+------------+------------+------------+
| Processus P2 | 20               | 4          | 14         | 2          |
+--------------+------------------+------------+------------+------------+
| Processus P3 | 30               | 6          | 21         | 3          |
+--------------+------------------+------------+------------+------------+

L’algorithme d’ordonnancement utilisé est celui du SRTF « plus court temps restant en premier ».

Pourcentage de temps d’inactivité de l’unité centrale (CPU)
= (5 / 47) x 100
= 10.638%
L’option correcte est donc (B).

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        | 11 – (3+2) = 6  | 11 – 0 = 11       |
+-----------+-----------------+-------------------+
| P2        | 7 – (2+1) = 4   | 7 – 0 = 7         |
+-----------+-----------------+-------------------+
| P3        | 7 – (1+2) = 4   | 9 – 2 = 7         |
+-----------+-----------------+-------------------+
| P4        | 11 – (2+1) = 8  | 16 – 5 = 11       |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (6 + 4 + 4 + 8) / 4
                      = 22 / 4
                      = 5.5 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (11 + 7 + 7 + 11) / 4
                        = 36 / 4
                        = 9 unités

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        | 10 – (1+3) = 6  | 10 – 0 = 10       |
+-----------+-----------------+-------------------+
| P2        | 13 – (3+1) = 9  | 15 – 2 = 13       |
+-----------+-----------------+-------------------+
| P3        | 6 – (2+1) = 3   | 9 – 3 = 6         |
+-----------+-----------------+-------------------+

Temps moyen d'attente = (Temps d'attente total) / (Nombre total de processus) 
                      = (6 + 9 + 3) / 3
                      = 18 / 3
                      = 6 unités
					  
Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus) 
                        = (10 + 13 + 6) / 3
                        = 29 / 3
                        = 9.67 unités

Pour n processus, le nombre d’ordonnances différentes possibles est donné par la formule:

n! (n factorial = n * n – 1 * n – 2 * … * 2 * 1)

Cela signifie que pour chaque processus, vous pouvez le placer dans une position de la file d’attente, et en répétant cela pour tous les processus, vous obtenez toutes les permutations possibles.

Ici, δ représente le temps d’attente pour le changement de contexte.
Maintenant,
Temps inutile / Temps perdu = 6 x δ = 6 x 1 = 6 unités
Temps total = 23 unités
Temps utile = 23 unités – 6 unités = 17 unités

Efficacité (η)
= Temps utile / Total Total
= 17 unités / 23 unités
= 0.7391
= 73.91%

Les quatre diagrammes de Gantt sont:

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

+-----------+--------+--------+---------+--------------+
| Processus |  FCFS  |   RR   |   SJF   | Par priorité |
+-----------+--------+--------+---------+--------------+
| P1        | 10     | 19     | 19      | 16           |
+-----------+--------+--------+---------+--------------+
| P2        | 11     | 2      | 1       | 1            |
+-----------+--------+--------+---------+--------------+
| P3        | 13     | 7      | 4       | 18           |
+-----------+--------+--------+---------+--------------+
| P4        | 14     | 4      | 2       | 19           |
+-----------+--------+--------+---------+--------------+
| P5        | 19     | 14     | 9       |  6           |
+-----------+--------+--------+---------+--------------+

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

+-----------+--------+--------+---------+--------------+
| Processus |  FCFS  |   RR   |   SJF   | Par priorité |
+-----------+--------+--------+---------+--------------+
| P1        | 0      | 9      | 9       | 6            |
+-----------+--------+--------+---------+--------------+
| P2        | 10     | 1      | 0       | 0            |
+-----------+--------+--------+---------+--------------+
| P3        | 11     | 5      | 2       | 16           |
+-----------+--------+--------+---------+--------------+
| P4        | 13     | 3      | 1       | 18           |
+-----------+--------+--------+---------+--------------+
| P5        | 14     | 9      | 4       |  1           |
+-----------+--------+--------+---------+--------------+

On sait que:

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

Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus)

Temps moyen de rotation = 10.53 unités

On sait que:

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

Temps moyen de rotation = (Temps de rotation total) / (Nombre total de processus)

Temps moyen de rotation = 9.53 unités

Temps moyen de rotation = 6.86 unités

A. Quand β > α > 0

Dans ce cas, la priorité d’un processus en cours d’exécution augmente plus rapidement (β) que celle d’un processus en attente (α). Étant donné que les processus en cours d’exécution gagnent de la priorité plus rapidement, ils tendent à préempter les processus en attente qui n’ont pas été exécutés. Par conséquent, cette configuration favorise les processus qui utilisent activement le CPU, leur permettant de continuer à s’exécuter sans être interrompus tant qu’ils sont en cours d’exécution. Cela conduit à un comportement similaire à l’Ordonnancement Premier Arrivé, Premier Servi (First-Come, First-Served – FCFS), car une fois qu’un processus commence à s’exécuter, il est moins susceptible d’être préempté par d’autres en attente dans la file d’attente.

B. Quand α < β < 0

Dans ce scénario, les deux taux sont négatifs, ce qui signifie qu’au fil du temps, les priorités des processus en attente et en cours d’exécution diminuent. Cependant, comme β (le taux pour les processus en cours d’exécution) est moins négatif que α (le taux pour les processus en attente), les processus en cours d’exécution perdent de la priorité plus lentement que ceux en attente. En conséquence, les processus en cours d’exécution sont susceptibles de conserver leur priorité plus élevée pendant un certain temps, tandis que les processus en attente diminueront leur priorité plus rapidement. Ce comportement ressemble à un ordonnancement Dernier Entré, Premier Sorti (Last-In, First-Out – LIFO), car les processus les plus récents en attente seront priorisés par rapport aux processus plus anciens, ce qui conduit à une situation où les processus ajoutés le plus récemment sont plus susceptibles d’être programmés ensuite.

Résumé

• A. β > α > 0 → FCFS
• B. α < β < 0 → LIFO

L’algorithme d’ordonnancement qui favorise les processus ayant utilisé le moins de temps processeur récemment va privilégier les programmes liés aux E/S pour plusieurs raisons, tout en évitant de rendre les programmes liés aux CPU définitivement affamés.

Favoriser les programmes liés aux E/S

• Courtes périodes d’utilisation du CPU: Les programmes liés aux E/S nécessitent généralement moins de temps CPU et passent plus de temps en attente d’opérations d’entrée/sortie. Ils ont donc des périodes d’utilisation du CPU relativement courtes, ce qui les rend plus susceptibles d’avoir moins de temps CPU accumulé.
• Utilisation récente du CPU: L’algorithme favorise les processus ayant utilisé le moins de temps CPU récemment. Comme les programmes liés aux E/S utilisent le CPU pendant des périodes plus courtes, ils auront souvent une priorité plus élevée dans la file d’attente des processus.

Prévention de la starvation des programmes liés aux CPU

• Changement de contexte fréquent: Les programmes liés aux E/S libèrent régulièrement le CPU pour effectuer leurs opérations d’E/S. Cela crée des occasions pour le planificateur d’allouer du temps CPU aux processus liés aux CPU.
• Mécanismes d’équité: La plupart des algorithmes d’ordonnancement modernes intègrent des mécanismes pour garantir que tous les processus, y compris ceux liés aux CPU, reçoivent du temps CPU. Même s’ils consomment plus de temps CPU, ils ne seront pas définitivement affamés, car les programmes liés aux E/S cèdent souvent le CPU.

Conclusion

En résumé, cet algorithme d’ordonnancement favorise les programmes liés aux E/S en raison de leur utilisation courte du CPU tout en s’assurant que les programmes liés aux CPU continuent de recevoir du temps CPU périodiquement, évitant ainsi la starvation.

Voici une explication des différences dans le degré de discrimination des algorithmes d’ordonnancement en faveur des processus courts:

A. FCFS (First-Come, First-Served)

• Discrimination: FCFS désavantage les jobs courts.
• Raison: Les jobs courts qui arrivent après des jobs longs doivent attendre que ces derniers soient terminés, ce qui entraîne des temps d’attente plus longs pour les jobs courts.

B. RR (Round Robin)

• Discrimination: RR traite tous les jobs de manière égale.
• Raison: Chaque travail reçoit des tranches de temps CPU égales. Cependant, les jobs courts peuvent quitter le système plus rapidement, car ils sont susceptibles de terminer leur exécution pendant leur première ou deuxième tranche de temps, surtout s’ils arrivent tôt dans le cycle.

C. Multilevel Feedback Queues

• Discrimination: Les files d’attente à rétroaction multiple favorisent également les jobs courts.
• Raison: Cet algorithme fonctionne de manière similaire à RR, mais il utilise plusieurs niveaux de priorité. Les jobs qui utilisent moins de temps CPU peuvent être déplacés vers des niveaux de priorité plus élevés, leur permettant d’obtenir plus de temps CPU et de terminer plus rapidement.

Résumé:

• FCFS: Désavantage les jobs courts.
• RR: Traite tous les jobs également, mais permet aux jobs courts de partir plus rapidement.
• Multilevel Feedback Queues: Favorise activement les jobs courts en leur donnant une meilleure priorité.

A. Est-il possible que le thread T2 s’exécute pendant le quantum de temps de T1 ? Expliquez.

Oui, si le thread T1 se bloque pour une raison quelconque (comme une opération d’E/S), la JVM programmera un autre thread. Dans ce cas, ce serait le thread T2.

B. Que se passe-t-il si le thread actuellement en cours d’exécution a sa méthode stop() invoquée pendant son quantum de temps ?

Le reste de son quantum de temps sera partagé par tous les autres threads dans la file d’attente en utilisant l’algorithme d’ordonnancement par défaut de la JVM.

C. Que se passe-t-il si le planificateur sélectionne un thread à exécuter qui a eu sa méthode suspend() invoquée ?

Le reste de son quantum de temps sera également partagé par tous les autres threads dans la file d’attente en utilisant l’algorithme d’ordonnancement par défaut de la JVM.

Réponse:
A. Les priorités assignées aux processus sont respectivement 80, 69 et 65.
B. Le planificateur abaisse la priorité relative des processus liés aux CPU.

Explication:
 
Calcul des Priorités:

 
Interprétation des Résultats:

Les valeurs des priorités calculées (80, 69, 65) signifient que P1 a la priorité la plus faible (80) et P3 la plus élevée (65).

Dans le contexte du planificateur UNIX, un numéro de priorité plus élevé indique une priorité plus faible. Ainsi, P1, qui est probablement un processus liés aux CPU avec une utilisation élevée, a une priorité plus basse.

Conclusion:

Le planificateur UNIX traditionnel abaisse donc la priorité relative des processus liés aux CPU, car une utilisation intensive du CPU (comme pour P1) conduit à une augmentation du numéro de priorité (donc une diminution de la priorité). Cela encourage le système à donner plus de temps à des processus moins gourmands en CPU.

Dans un système d’exploitation, le traitement par lots vise à maximiser l’utilisation de l’unité centrale (CPU) en:

• Exécutant des tâches en parallèle pour éviter les temps d’inactivité.
• Organisant les tâches dans des files d’attente pour une exécution optimisée.
• Allocant dynamiquement les ressources selon les besoins des tâches.
• Minimisant les changements de contexte pour réduire les interruptions.

Cela permet à l’UC de rester occupée et d’améliorer l’efficacité globale.

Le traitement par lots provoque un effet d’accélération en:

• Réduisant les frais généraux grâce à moins de transitions entre les tâches.
• Optimisant les ressources par le partage de mémoire entre tâches similaires.
• Planifiant intelligemment pour maximiser l’utilisation du CPU.
• Minimisant les temps d’inactivité, gardant le CPU active.
• Améliorant l’efficacité du cache en traitant des données similaires ensemble.

Ces éléments contribuent à une exécution plus rapide des tâches.

Pour que le traitement par lots commence, chaque programme doit être fourni complètement, incluant toutes les données d’entrée nécessaires. Cela garantit que toutes les informations requises sont disponibles pour une exécution fluide et efficace des tâches.

Le traitement par lots est bien adapté à l’exécution de tâches routinières, car il permet de gérer efficacement des opérations répétitives et prévisibles, optimisant ainsi le temps et les ressources nécessaires. Exemple:

• Sauvegarde de données: Création de sauvegardes régulières de systèmes ou de bases de données.
• Traitement de données massives: Analyse de grandes quantités de données, comme dans le big data.
• Mise à jour de bases de données: Exécution de mises à jour régulières sur des ensembles de données.

une application populaire du mode batch est l’utilisation de fichiers batch et de shell scripts pour automatiser des tâches dans les systèmes d’exploitation. Ces scripts permettent d’exécuter des commandes ou des programmes en série, facilitant ainsi la gestion des tâches répétitives, comme la sauvegarde de fichiers, la mise à jour de logiciels ou le déploiement d’applications.

Le spooling (Simultaneous Peripheral Operations On-Line) est un processus qui gère les opérations d’entrée/sortie en les déchargeant dans des fichiers temporaires ou des files d’attente. Cela permet au processeur de continuer à travailler sur d’autres tâches sans attendre la fin de l’opération I/O, optimisant ainsi l’utilisation des ressources. Un exemple courant est l’impression, où les documents sont d’abord mis en file d’attente avant d’être imprimés.

L’objectif du partage du temps dans les systèmes d’exploitation est de permettre à plusieurs utilisateurs ou tâches de partager efficacement les ressources d’un ordinateur, en donnant à chacun un accès équitable et interactif au processeur.

Le partage du temps répartit le temps de calcul entre les processus en utilisant plusieurs techniques:

• Tranches de temps: Chaque processus se voit attribuer une période fixe, appelée tranche de temps, durant laquelle il peut s’exécuter. Une fois la tranche écoulée, le système d’exploitation suspend le processus et passe au suivant.
• Planification des processus: Un algorithme de planification détermine l’ordre d’exécution des processus, souvent en fonction de critères tels que la priorité ou le temps d’attente.
• Changement de contexte: Lorsque le système d’exploitation passe d’un processus à un autre, il effectue un changement de contexte, sauvegardant l’état du processus en cours et chargeant l’état du prochain processus à exécuter.
• Équité: Les processus sont généralement traités de manière équitable, permettant à chacun d’accéder au processeur sans être bloqué indéfiniment.

Grâce à ces mécanismes, le partage du temps permet une utilisation efficace du processeur et garantit que plusieurs processus peuvent s’exécuter de manière fluide et simultanée.

Multitâche ou Multitasking. Cela désigne la capacité d’un système d’exploitation à exécuter plusieurs processus simultanément ou à les faire passer rapidement d’un état à un autre, donnant l’illusion d’une exécution quasi-parallèle.

L’objectif de l’exécution quasi-parallèle (multitâche) est de maximiser l’utilisation des ressources système, améliorer la réactivité et l’efficacité, et permettre aux utilisateurs d’interagir avec plusieurs applications simultanément sans délai. Cela facilite également la gestion de tâches de fond sans interrompre les activités en cours.

L’ordonnancement (scheduling) est le processus par lequel un système d’exploitation détermine l’ordre et la durée d’exécution des processus sur le processeur. Il optimise l’utilisation des ressources, gère les priorités, utilise différents algorithmes (comme FIFO et Round Robin) et vise à assurer équité et réactivité pour les tâches.

Le swapping est un processus dans les systèmes d’exploitation où des segments de mémoire (processus ou pages) sont temporairement déplacés entre la mémoire principale et le stockage secondaire (comme un disque) pour libérer de l’espace mémoire. Cela permet de gérer efficacement la mémoire en exécutant plus de processus que ce que la RAM peut contenir simultanément. Le swapping aide à maintenir les performances du système lorsque la mémoire est saturée.

La protection de la mémoire empêche les processus d’accéder à la mémoire des autres ou du système d’exploitation. Elle fonctionne par:

• Segmentation et pagination: Division de la mémoire en segments ou pages pour chaque processus.
• Table des pages: Mapping des adresses virtuelles aux adresses physiques.
• Registres de protection: Définition des limites d’accès en mémoire pour chaque processus.
• Gestion des exceptions: Déclenchement d’une erreur si un accès non autorisé est tenté.
• Isolation des processus: Chaque processus fonctionne dans son propre espace mémoire.

Cela assure la sécurité et la stabilité du système.

Le but de la protection de la mémoire est de garantir la sécurité et la stabilité du système en empêchant les processus d’accéder à la mémoire d’autres processus ou du système d’exploitation. Cela protège contre les erreurs et les comportements malveillants, assurant l’intégrité des données et l’isolation des processus.

$ mkdir ~/MyRep

La commande mkdir (make directory) est utilisée dans les systèmes d’exploitation de type Unix/Linux et Windows pour créer un nouveau répertoire (dossier).

$ cd ~/MyRep && touch File1.txt

• cd ~/MyRep: Change le répertoire courant vers « MyRep » dans le répertoire personnel.
• &&: Exécute la prochaine commande seulement si la première réussit.
• touch File1.txt: Crée un fichier vide nommé « File1.txt » dans « MyRep ».

Si « MyRep » n’existe pas, le fichier ne sera pas créé.

$ ls -lh File1.txt

• ls: Commande de base pour lister le contenu d’un répertoire.
• -l: Affiche les détails en format long (permissions, propriétaire, taille, date de modification, etc.).
• -h: Rend la taille des fichiers lisible par l’homme (par exemple, 1K, 234M, 2G).

$ touch -t XXXXYYZZAABB File1.txt

• XXXX spécifie l’année.
• YY spécifie le mois.
• ZZ spécifie le jour du mois.
• AA spécifie l’heure.
• BB spécifie les minutes.

$ echo -e "Ligne1\nLigne2" > File2.txt

• echo -e: Affiche une chaîne de texte et active l’interprétation des caractères spéciaux grâce à -e.
• \n: Représente un saut de ligne.
• "Ligne1\nLigne2": La chaîne affichée contiendra « Ligne1 » sur une ligne et « Ligne2 » sur la ligne suivante.
• >: Redirige la sortie de la commande vers un fichier.
• File2.txt: Nom du fichier où le texte sera enregistré. Si le fichier existe, il sera écrasé.

$ head -n 1 File2.txt

• head: Affiche les premières lignes d’un fichier.
• -n 1: Spécifie que l’on veut afficher seulement la première ligne.
• File2.txt: Nom du fichier dont on souhaite afficher le contenu.

$ cat File2.txt >> File1.txt

• cat File2.txt: Lit et affiche le contenu du fichier « File2.txt ».
• >>: Redirige la sortie vers un fichier, en ajoutant le contenu à la fin de celui-ci, sans écraser son contenu existant.
• File1.txt: Nom du fichier cible où le contenu sera ajouté.

$ mkdir ~/cours_university

La commande mkdir (make directory) est utilisée dans les systèmes d’exploitation de type Unix/Linux et Windows pour créer un nouveau répertoire (dossier).

$ cp ~/MyRep/* ~/cours_university

• cp: Commande utilisée pour copier des fichiers ou des répertoires.
• ~/MyRep/*: Sélectionne tous les fichiers et répertoires dans le répertoire « MyRep » situé dans le répertoire personnel de l’utilisateur.
• ~/cours_university: Destination où les fichiers seront copiés, qui est le répertoire « cours_university » dans le répertoire personnel.

$ rm -rf ~/MyRep

• rm: Commande utilisée pour supprimer des fichiers ou des répertoires.
• -r: Indique une suppression récursive, permettant de supprimer des répertoires et leur contenu (fichiers et sous-répertoires).
• -f: Force la suppression sans demander de confirmation, même si le fichier ou le répertoire est protégé en écriture.
• ~/MyRep: Chemin vers le répertoire « MyRep » situé dans le répertoire personnel de l’utilisateur.

Le terme technique pour ce mode de fonctionnement est « singletasking« . Cela signifie qu’à chaque instant, un seul programme peut être exécuté, contrairement au multitâche où plusieurs programmes peuvent fonctionner simultanément.

Le numéro du bit indique la longueur de l’adresse mémoire avec laquelle le système d’exploitation fonctionne en interne. La différence entre les systèmes d’exploitation 8 bits, 16 bits, 32 bits et 64 bits se résume ainsi:

• 8 bits: Peut adresser jusqu’à 256 octets. Très ancien (ex.: certains ordinateurs personnels).
• 16 bits: Peut adresser jusqu’à 65 536 octets (64 Ko). Ex.: MS-DOS.
• 32 bits: Peut adresser jusqu’à 4 Go de RAM. Ex.: Windows XP, certaines versions de Linux.
• 64 bits: Peut adresser jusqu’à 16 exaoctets de RAM. Ex.: Windows 10, macOS modernes.

Plus le nombre de bits est élevé, plus le système peut traiter de données et gérer de mémoire.

Dans les systèmes d’exploitation en temps réel, le temps de réponse (ou latence courte) et le respect des délais sont cruciaux. Cela signifie que le système doit:

• Réagir rapidement aux événements, minimisant le temps entre la détection d’un événement et la réponse.
• Respecter les délais fixés pour chaque tâche, garantissant que les opérations critiques soient exécutées dans un temps prédéfini.

Ces caractéristiques sont essentielles pour garantir le bon fonctionnement d’applications où la temporisation est vitale, comme dans les systèmes de contrôle industriels ou les applications médicales.

Les deux types de systèmes d’exploitation en temps réel sont:

• Systèmes d’exploitation en temps réel dur: Ces systèmes garantissent que les délais sont strictement respectés. Toute tâche doit être terminée dans un délai prédéfini, sinon le système peut échouer. Ils sont utilisés dans des applications critiques, comme le contrôle de processus industriels ou les systèmes embarqués.
• Systèmes d’exploitation en temps réel souple: Ces systèmes offrent une certaine flexibilité dans le respect des délais. Bien que le temps de réponse soit important, un léger dépassement des délais n’entraîne pas nécessairement une défaillance. Ils sont souvent utilisés dans des applications moins critiques, comme le traitement multimédia.

Ces distinctions permettent de choisir le type de système en fonction des exigences de l’application.

Voici quatre domaines d’application typiques des systèmes d’exploitation en temps réel, classés en fonction des catégories mentionnées:

1. Systèmes d’exploitation en temps réel dur:

• Contrôle industriel: Utilisé dans les systèmes de contrôle de processus, comme les usines automatisées.
• Aérospatial: Systèmes de contrôle de vol dans les avions ou les satellites, où la sécurité est critique.

2. Systèmes d’exploitation en temps réel souple:

• Traitement multimédia: Applications de vidéo et de son en temps réel, comme la diffusion en direct.
• Jeux vidéo: Systèmes de jeu interactifs qui nécessitent des réponses rapides mais peuvent tolérer de légers délais.

Ces domaines illustrent comment les systèmes en temps réel sont adaptés à des besoins spécifiques en fonction de la criticité des délais.

Un nano-noyau (ou nanokernel) a une structure minimale et modulaire:

• Noyau minimal: Contient uniquement les fonctions essentielles (gestion de la mémoire, des interruptions).
• Modularité: Les services supplémentaires (systèmes de fichiers, gestion des périphériques) sont implémentés en tant que modules externes.
• Communication inter-processus (IPC): Utilise des mécanismes d’IPC pour permettre la communication entre modules et applications.
• Gestion des ressources: Alloue et libère les ressources de manière sécurisée.

Un noyau monolithique est un type de noyau d’un système d’exploitation où toutes les fonctionnalités essentielles sont intégrées dans un seul binaire. Un noyau monolithique a la structure suivante:

• Code unique: Tout le code (gestion de la mémoire, des processus, des périphériques) est intégré dans un seul binaire.
• Accès direct: Modules peuvent accéder directement aux ressources matérielles, offrant de bonnes performances.
• Gestion des processus et de la mémoire: Inclut des fonctions pour la planification, la synchronisation et la gestion de la mémoire.
• Pilotes inclus: Les pilotes de périphériques sont souvent intégrés, augmentant la taille du noyau.

Un micro-noyau a une structure minimaliste et modulaire:

• Fonctionnalités essentielles: Ne contient que la gestion de la mémoire, des processus et la communication inter-processus (IPC).
• Modularité: Services supplémentaires (systèmes de fichiers, pilotes) fonctionnent en espace utilisateur.
• IPC: Utilise des mécanismes efficaces pour échanger des messages entre le micro-noyau et les services externes.

Un noyau hybride combine des éléments des noyaux monolithiques et des micro-noyaux. Voici ses principales caractéristiques:

• Architecture mixte: Intègre des fonctionnalités essentielles dans le noyau (comme la gestion de la mémoire et des processus), tout en permettant des modules externes pour d’autres services (comme les pilotes).
• Flexibilité: Les composants critiques fonctionnent dans le noyau pour de meilleures performances, tandis que les services moins critiques peuvent être exécutés en espace utilisateur.
• Communication: Utilise des mécanismes d’IPC, mais peut également permettre des appels directs pour les composants noyau.

Linux implémente un noyau monolithique:

• Intégration: Toutes les fonctions essentielles (gestion des processus, mémoire, pilotes) sont dans un seul binaire.
• Accès direct: Les modules du noyau accèdent directement au matériel, offrant de bonnes performances.
• Modularité: Permet le chargement dynamique de modules pour une certaine flexibilité.

MacOS X implémente un noyau hybride, appelé XNU (X is Not Unix). Voici ses principales caractéristiques:

• Architecture mixte: Combine des éléments d’un noyau monolithique et d’un micro-noyau, intégrant des fonctionnalités essentielles tout en permettant des modules externes.
• Micro-noyau Mach: Utilise le micro-noyau Mach pour la gestion des processus et de la mémoire, tandis que les services comme les pilotes de périphériques sont intégrés dans le noyau.
• Performances optimisées: Les composants critiques fonctionnent dans le noyau pour des performances élevées, tandis que d’autres services peuvent s’exécuter en espace utilisateur.

Les systèmes d’exploitation Windows NT (y compris NT4, XP, Vista, 7, 8 et 10) implémentent un noyau hybride. Voici ses principales caractéristiques:

• Architecture mixte: Combine des éléments d’un noyau monolithique et d’un micro-noyau, intégrant des fonctionnalités essentielles tout en permettant l’exécution de certains services en espace utilisateur.
• Noyau NT: Le noyau NT gère les processus, la mémoire, et les pilotes, tout en utilisant des modules pour des fonctionnalités supplémentaires.
• Performances et modularité: Les composants critiques fonctionnent dans le noyau pour des performances optimales, tandis que d’autres services peuvent être modulaires et s’exécuter en espace utilisateur.

Avantages:

• Moins de changements de contexte ⇒ meilleures performances
• Stabilité accrue

Inconvénients:

• Les composants bloqués ne peuvent pas être démarrés séparément dans le noyau et peuvent entraîner le blocage de l’ensemble du système.
• Les extensions du noyau entraînent un effort de développement important, car pour chaque compilation de l’extension, le noyau complet doit être recompilé.

Avantages:

• Les composants peuvent être échangés facilement
• Meilleure stabilité et sécurité en théorie, car moins de fonctions s’exécutent en mode noyau.

Inconvénients:

• Ralentissement en raison d’un plus grand nombre de changements de contexte
• Le développement d’un nouveau (micro)noyau est une tâche complexe.

Avantages:

• Meilleures performances qu’avec les micro-noyaux (parce qu’il y a moins de changements de contexte)
• La stabilité est (théoriquement) meilleure qu’avec les noyaux monolithiques.

Inconvénients:

• Le développement d’un nouveau noyau (hybride) est une tâche complexe.

reboot OU shutdown -r now

halt OU shutdown