c2 Tnsi Processus
c2 Tnsi Processus
c2 Tnsi Processus
Les processus
Objectifs pédagogiques :
Toute machine est dotée d’un système d’exploitation qui a pour fonction de charger les programmes depuis la
mémoire de masse et de lancer leur exécution en leur créant des processus (process en anglais), de gérer l’ensemble
des ressources, de traiter les interruptions ainsi que les entrées-sorties et enfin d’assurer la sécurité globale du
système.
1. Processus
Tous les systèmes d'exploitation "modernes" (Linux, Windows, MacOS, Android, iOS...) sont capables de gérer
l'exécution de plusieurs processus en même temps. Mais pour être précis, cela n'est pas un réel "en même temps",
mais plutôt un "chacun son tour". Pour gérer ce "chacun son tour", les systèmes d'exploitation attributs des "états"
au processus afin de les hiérarchiser.
Lorsqu’un processus est en train de s'exécuter, c’est-à-dire qu'il utilise les Diagramme d’état d’un processus
ressources du microprocesseur, on dit qu’il est dans l'état "élu".
Un processus qui se trouve dans l'état élu peut demander à accéder à une ressource pas forcément disponible
instantanément (typiquement lire une donnée sur le disque dur). Le processus ne peut pas poursuivre son exécution
tant qu'il n'a pas obtenu cette ressource. En attendant de recevoir cette ressource, il passe de l'état "élu" à l'état
"bloqué".
Lorsque le processus finit par obtenir la ressource attendue, celui-ci peut potentiellement reprendre son exécution.
Cependant, bien que les systèmes d'exploitation permettent de gérer plusieurs processus "en même temps", il n’en
demeure pas moins qu’un seul processus peut se trouver dans un état "élu" (le microprocesseur ne peut "s'occuper"
que d'un seul processus à la fois). Quand un processus passe d'un état "élu" à un état "bloqué", un autre processus
Le passage de l'état "prêt" vers l'état "élu" constitue l'opération "d'élection". Le passage de l'état élu vers l'état bloqué
est l'opération de "blocage". Un processus est toujours créé dans l'état "prêt". Pour se terminer, un processus doit
obligatoirement se trouver dans l'état "élu".
Il est fondamental de bien comprendre que le "chef d'orchestre" qui attribue aux processus leur état "élu", "bloqué"
ou "prêt" est le système d'exploitation (OS – Operating System). On dit que le système d’exploitation gère
l'ordonnancement des processus (un processus sera prioritaire sur un autre...).
Remarque : un processus qui utilise une ressource doit la "libérer" une fois qu'il a fini de l'utiliser afin de la rendre
disponible pour les autres processus. Pour libérer une ressource, un processus doit obligatoirement être dans un état
"élu".
Un processus peut-être démarré par un utilisateur par l'intermédiaire d'un périphérique ou bien par un autre
processus : les applications des utilisateurs sont des ensembles de processus plus ou moins complexes.
Comme nous venons de le voir, Le système d'exploitation est chargé d'allouer les ressources (mémoires,
temps processeur, entrées/sorties) nécessaires aux processus et d'assurer que le fonctionnement d'un processus
n'interfère pas avec celui des autres (isolation). Il peut aussi fournir une API (Application Programming Interface) pour
permettre la communication inter-processus (IPC).
Outre le multiplexage des ressources matérielles, le système peut contrôler l'accès des processus aux ressources selon
une matrice de droits (permissions d'accès) et également associer les processus aux utilisateurs, qui sont les
récipiendaires d'un ensemble de droits d'accès : un processus a les droits de l'utilisateur qui l'a démarré.
La plupart des systèmes offrent la distinction entre processus lourd (tels que nous les avons décrits), qui sont a
priori complètement isolés les uns des autres, et processus légers (Threads en anglais), qui ont un espace mémoire (et
d'autres ressources) en commun.
Dans le cas de processus comportant plusieurs processus légers (ou suivant l'expression souvent utilisée multi-thread)
il existe un état du processeur (un contexte d'exécution) distinct pour chaque processus léger.
Un processus peut créer un ou plusieurs processus à l'aide d'une commande système ("fork"
sous les systèmes de type Unix). Imaginons un processus A qui crée un processus B. On dira que
A est le père de B et que B est le fils de A. B peut, à son tour créé un processus C (B sera le père
de C et C le fils de B). On peut modéliser ces relations père/fils par une structure arborescente
(voir le schéma ci-contre).
Si un processus est créé à partir d'un autre processus, comment est créé le tout premier
processus ?
Sous un système d'exploitation comme Linux, au moment du démarrage de l'ordinateur un tout
premier processus (appelé processus 0 ou encore Swapper) est créé à partir de "rien" (il n'est le
fils d'aucun processus). Ensuite, ce processus 0 crée un processus souvent appelé "init" ("init"
est donc le fils du processus 0).
À partir de "init", les processus nécessaires au bon fonctionnement du système d’exploitation Linux sont créés (par
exemple les processus "crond", "inetd", "getty",...). Puis d'autres processus sont créés à partir des fils de "init"...
Schéma de la création des processus de base sous Linux lors du lancement du système
Chaque processus possède un identifiant appelé PID (Process Identification), ce PID est un nombre entier. Le premier
processus créé au démarrage du système à pour PID 0, le second 1, le troisième 2... Le système d'exploitation utilise
un compteur qui est incrémenté de 1 à chaque création de processus, le système utilise ce compteur pour attribuer
les PID aux processus.
Chaque processus possède aussi un PPID (Parent Process Identification). Ce PPID permet de connaitre le processus
parent d'un processus (par exemple le processus "init" vu ci-dessus à un PID de 1 et un PPID de 0). À noter que le
processus 0 ne possède pas de PPID (c'est le seul dans cette situation).
Dans un système multi-utilisateurs à temps partagé, plusieurs processus peuvent être présents en mémoire centrale
en attente d’exécution. Si plusieurs processus sont prêts, le système d’exploitation doit gérer l’allocation du
processeur aux différents processus à exécuter. C’est l’ordonnanceur qui s’acquitte de cette tâche.
Le système d’exploitation d’un ordinateur peut être vu comme un ensemble de processus dont l’exécution est gérée
par un processus particulier : l’ordonnanceur (scheduler en anglais).
Les objectifs d’un ordonnanceur d’un système multi-utilisateurs sont, entre autres :
• s’assurer que chaque processus en attente d’exécution reçoive sa part de temps processeur ;
• minimiser le temps de réponse ;
• utiliser le processeur à 100% ;
• utiliser d’une manière équilibrée les ressources ;
• prendre en compte les priorités ;
• être prédictible.
Ces objectifs sont parfois complémentaires, parfois contradictoires : augmenter la performance par rapport à l’un
d’entre eux peut se faire au détriment d’un autre. Il est impossible de créer un algorithme qui optimise tous les critères
de façon simultanée.
2.3. Ordonnanceurs non préemptifs : First-Come First-Served (FCFS) et Short Job First (SJF)
Dans un système à ordonnancement non préemptif ou sans réquisition, le système d’exploitation choisit le prochain
processus à exécuter, en général, le Premier Arrivé est le Premier Servi PAPS (ou First-Come First-Served FCFS) ou le
plus court d’abord (Short Job First SJF). Il lui alloue le processeur jusqu’à ce qu’il se termine ou qu’il se bloque (en
attente d’un événement). Il n’y a pas de réquisition. Si l’ordonnanceur fonctionne selon la stratégie SJF, il choisit, parmi
le lot de processus à exécuter, le plus court (plus petit temps d’exécution). Cette stratégie est bien adaptée au
traitement par lots de processus dont les temps maximaux d’exécution sont connus ou fixés par les utilisateurs car elle
offre un meilleur temps moyen de séjour. Le temps de séjour d’un processus (temps de rotation ou de virement) est
l’intervalle de temps entre la soumission du processus et son achèvement.
Considérons par exemple un lot de quatre processus notés A, B, C, D dont les temps respectifs d’exécution sont , tA ,
tB, tC et tD . Le premier processus se termine au bout du temps tA ; le deuxième processus se termine au bout du temps
tA + tB ; le troisième processus se termine au bout du temps tA + tB + tC ; le quatrième processus se termine au bout du
temps tA + tB + tC + tD.
Activité Terminale NSI – Architectures matérielles, système d’exploitation et réseaux
4/11
LGT Saint-Exupéry, Mantes-la-Jolie
Le temps moyen de séjour noté <t> est : <t> = (4 tA + 3 tB + 2 tB + tD) / 4
On obtient le meilleur temps de séjour pour tA ≤ tB ≤ tC ≤ tD.
Toutefois, l’ordonnancement du plus court d’abord est optimal que si les travaux sont disponibles simultanément.
Exemple :
Considérons cinq processus notés A, B, C, D et E, dont les
temps d’exécution et leurs arrivages respectifs sont
donnés dans le tableau ci-contre.
On peut également représenter le tableau précédent de la manière suivante afin de faciliter la compréhension de
l’ordonnancement des processus :
0 1 2 3 4 5 6 7 8 Temps CPU
(cycles)
A A A
B B B B B B
C C C C
D D
E
Schéma d’exécution :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Temps CPU
(cycles)
A A A B B B B B B C C C C D D E
Au temps 0, seulement le processus A est dans le système et il s’exécute. Au temps 1 le processus B arrive mais il doit
attendre que A se termine car il lui reste encore 2 unités de temps à effectuer. Ensuite B s’exécute pendant 4 unités
de temps. Au temps 4, 6, et 7 les processus C, D et E arrivent mais B a encore 2 unités de temps. Une fois que B a
terminé, C, D et E entrent dans le système dans l’ordre (on suppose qu’il y a aucun blocage).
Le temps de séjour pour chaque processus est obtenu soustrayant le temps d’entrée du processus du temps de
terminaison. Ainsi :
Il y a cinq tâches exécutées dans 16 unités de temps, alors 16 / 5 = 3,2 unités de temps par processus.
Schéma d’exécution :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Temps CPU
(cycles)
A A A B B B B B B E D D C C C C
Le processeur traite d’abord comme précédemment les processus A puis B. Le processus B s’achève à la date t = 9 qui
est supérieure au temps d’arrivage des processus C, D et E : ceux-ci sont donc déjà présents dans la pile des processus
en attente de traitement par le processeur. Celui-ci choisi d’abord d’exécuter le processus le plus court des 3 c’est-à-
dire E conformément à l’algorithme SJF. Puis selon la même logique, il exécute le processus D et enfin le processus C.
Temps de séjour :
Temps d’attente :
Il y a cinq tâches exécutées dans 16 unités de temps, alors 16 / 5 = 3,2 unités de temps par processus.
On observe que dans ce cas de figure l’algorithme Short Job First (SJF) est plus performant que l’algorithme First-
Come First-Served (FCFS).
2.4. Ordonnanceurs préemptifs : Shortest Remaining Time (SRT) et Round Robin (RR)
Dans un schéma d’ordonnanceur préemptif, ou avec réquisition, pour s’assurer qu’aucun processus ne s’exécute
pendant trop de temps, les ordinateurs ont une horloge électronique qui génère périodiquement une interruption. A
chaque interruption d’horloge, le système d’exploitation reprend la main et décide si le processus courant doit
poursuivre son exécution ou s’il doit être suspendu pour laisser place à un autre. S’il décide de suspendre son exécution
au profit d’un autre, il doit d’abord sauvegarder l’état des registres du processeur avant de charger dans les registres
les données du processus à lancer. C’est qu’on appelle la commutation de contexte ou le changement de contexte.
Cette sauvegarde est nécessaire pour pouvoir poursuivre ultérieurement l’exécution du processus suspendu. Le
processeur passe donc d’un processus à un autre en exécutant chaque processus pendant quelques dizaines ou
centaines de millisecondes. Le temps d’allocation du processeur au processus est appelé quantum. Cette commutation
entre processus doit être rapide, c’est-à-dire, exiger un temps nettement inférieur au quantum. Le processeur, à un
instant donné, n’exécute réellement qu’un seul processus, mais pendant une seconde, le processeur peut exécuter
plusieurs processus et donne ainsi l’impression de parallélisme (pseudo-parallélisme).
Problèmes soulevés :
– Choix de la valeur du quantum.
– Choix du prochain processus à exécuter dans chacune des situations suivantes :
1. Le processus en cours se bloque (passe à l’état Attente).
2. Le processus en cours passe à l’état Prêt (fin du quantum...).
3. Un processus passe de l’état Attente à l’état Prêt (fin d’une E/S).
4. Le processus en cours se termine.
Ordonnancement circulaire
• Choix du processus à exécuter
Il alloue le processeur au processus en tête de file, pendant un quantum de temps. Si le processus se bloque
ou se termine avant la fin de son quantum, le processeur est immédiatement alloué à un autre processus (celui
en tête de file). Si le processus ne se termine pas au bout de son quantum, son exécution est suspendue. Le
processeur est alloué à un autre processus (celui en tête de file). Le processus suspendu est inséré en queue
de file. Les processus qui arrivent ou qui passent de l’état bloqué à l’état prêt sont insérés en queue de file.
• Choix de la valeur du quantum
Un quantum trop petit provoque trop de commutations de processus et abaisse l’efficacité du processeur. Un
quantum trop élevé augmente le temps de réponse des courtes commandes en mode interactif. Un quantum
entre 20 et 50 ms est souvent un compromis raisonnable.
Exemple :
Soient deux processus A et B prêts tels que A est arrivé en premier suivi de B, 2 unités de temps après. Les temps CPU
nécessaires pour l’exécution des processus A et B sont respectivement 15 et 4 unités de temps. Le temps de
commutation est supposé nul.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Temps CPU
(cycles)
A A A A A A A A A A A A A A A
B B B B
>>> Algorithme du plus petit temps de séjour : Shortest Remaining Time (SRT)
• Schéma d’exécution :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Temps CPU
(cycles)
A A B B B B A A A A A A A A A A A A A
• Temps de séjour :
• Temps d’attente :
• Schéma d’exécution :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Temps CPU
(cycles)
A A A A A A A A A A B B B B A A A A A
• Temps de séjour :
• Schéma d’exécution :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Temps CPU
(cycles)
A A A B B B A A A B A A A A A A A A A
• Temps de séjour :
• Temps d’attente :
Dans le trois solutions (SRT, RR Qt =10 et RR Qt =3), il y a 2 tâches exécutées dans 19 unités de temps, alors 19 / 2 = 9,5
unités de temps par processus. L’algorithme SRT donne dans le contexte étudié le meilleur résultat.
3. Interblocage (deadlock)
3.1. Définition
Un interblocage (ou étreinte fatale, deadlock en anglais) est un phénomène qui peut survenir en programmation
concurrente. L'interblocage se produit lorsque des processus concurrents s'attendent mutuellement. Un processus
peut aussi s'attendre lui-même. Les processus bloqués dans cet état le sont définitivement, il s'agit donc d'une
situation catastrophique provoquant le blocage du système.
3.2. Exemple
Pour que P1 puisse poursuivre son exécution, il faut que P2 libère la ressource R2, mais P2 ne peut pas poursuivre son
exécution (et donc libérer R2) puisqu'il est bloqué dans l'attente de R1. Pour que P2 puisse poursuivre son exécution,
il faut que P1 libère la ressource R1, mais P1 ne peut pas poursuivre son exécution (et donc libérer R1) puisqu'il est
bloqué dans l'attente de R2. Bref, la situation est totalement bloquée !
Il existe plusieurs solutions permettant soit de mettre fin à un interblocage (cela passe par l'arrêt d'un des 2 processus
fautifs) ou d'éviter les interblocage, mais ces solutions ne seront pas étudiées ici.
QUESTIONS
Q9. Trois processus A, B et C ont été chargés dans un système informatique comme indiqué ci-dessous :
Q10. Rendez-vous sur le site suivant afin de lancer une machine virtuelle Linux en ligne :
https://www.offidocs.com/index.php/desktop-online-utilitaires-apps-fr-fr/xlinux-linux-en-ligne-fr-fr
a) Dans le terminal de la machine virtuelle Linux tapez la commande suivante : ps -aef
Que permet de faire cette commande ?
b) Dans le terminal de la machine virtuelle Linux tapez la commande suivante : top (ctrl + c pour quitter)
Que permet de faire cette commande ?