Vous êtes sur la page 1sur 13

Systèmes d’exploitation ISET de Jendouba

Chapitre 3 : Gestion des processus et threads

Plan du chapitre

1. La notion de processus ........................................................................................................................... 2


a) Définition........................................................................................................................................... 2
b) Etats d’un processus ........................................................................................................................... 3
c) Bloc de contrôle de processus ............................................................................................................. 3
d) Changement de contexte de processus ................................................................................................ 4
2. La notion de thread ................................................................................................................................ 4
3. Les processus sous Linux ....................................................................................................................... 6
a) Types de processus sous linux ............................................................................................................ 6
b) Lister des informations sur les processus ............................................................................................ 6
c) Hiérarchie de processus ...................................................................................................................... 7
d) Les processus et le démarrage du système Linux ................................................................................ 7
 Espace utilisateur ......................................................................................................................... 8
 Espace Noyau................................................................................................................................ 8
4. L’ordonnancement des processus ........................................................................................................... 9
a) La notion d’ordonnanceur .................................................................................................................. 9
b) Mesure de performance d’un algorithme d’ordonnancement ............................................................. 10
c) Types d’algorithmes d’ordonnancement ........................................................................................... 10
d) Algorithmes d’ordonnancement ........................................................................................................ 10
i. L’algorithme d’ordonnancement FIFO (First In First Out) ................................................................ 10
ii. L’algorithme d’ordonnancement SJF (Shortest Job First) .................................................................. 11
iii. L’algorithme d’ordonnancement RR ............................................................................................. 12
iv. L’algorithme d’ordonnancement HPF ........................................................................................... 13
v. Les files d’attente rétroactives .......................................................................................................... 13

1/13
Systèmes d’exploitation ISET de Jendouba

1. La notion de processus
a) Définition
Le concept de processus est le plus important dans un système d’exploitation. Il est en lien direct
avec la notion de « programme ».
En effet, Un programme informatique est un ensemble d’instructions (un code écrit par un
informaticien dans un langage de programmation) destinées à être exécutées par un processeur.
L’exécution d’un programme par un processeur s’appelle « processus ».

Définition : un processus est un programme en cours d’exécution.

Pour faciliter la compréhension de la différence entre programme et processus prenons l’exemple


suivant : Supposons que vous voulez préparer un gâteau. Vous allez tout d’abord récupérer la recette
du gâteau qui est la liste des ingrédients et des instructions nécessaires pour préparer le gâteau. La
recette du gâteau est l’équivalent du programme dans un système informatique. Maintenant le
processus est le fait d’entrer dans la cuisine et de commencer l’exécution de la recette.

Attention !!! Processus ≠ Programme

Les processus sont initialisés à chaque fois qu’une tâche est lancée. Ils sont initialisés par un
utilisateur ou par le système.
L’exécution d’un processus doit progresser séquentiellement, c’est à dire, à n’importe quel moment
une seule instruction au plus est exécutée au nom du processus.
Les processus permettent de lancer plusieurs tâches ”en même temps”.

Attention!!! Ne pas confondre processus et processeur (CPU)

Un Processus peut en créer un autre, cela donne une hiérarchie de ce type :

Dans les systèmes linux, les processus sont identifiés par un numéro unique appelé PID (Process
IDentifier) et tous les processus sont organisés de façon hiérarchique. Ainsi, il existe une relation
père / fils entre les processus et chaque fils possède un autre identifiant appelé PPID (Parent PID) qui
est l'identifiant de son père.

2/13
Systèmes d’exploitation ISET de Jendouba

b) Etats d’un processus


Quand un processus s’exécute, il change d’état. Chaque processus peut se trouver dans chacun
des états suivants :
En exécution: Les instructions sont en cours d’exécution (en train d’utiliser le CPU).
Bloqué (En attente): Le processus attend qu’un événement se produise.
Prêt: Le processus attend d’être affecté à un processeur.

Un seul processus peut être en exécution sur n’importe quel processeur à tout moment.
Toutefois, plusieurs processus peuvent être prêts ou bloqué.

c) Bloc de contrôle de processus


Chaque processus est représenté dans le SE par un PCB (Process Control Block).

Le PCB contient plusieurs informations concernant un processus spécifique, comme par exemple:
 Etat du processus
 Numéro du processus : Dans les systèmes linux ce numéro est le PID.
 Compteur d’instructions: indique l’adresse de l’instruction suivante devant être exécutée
par ce processus.
 Informations sur l’ordonnancement du CPU: information concernant la priorité du
processus.
 Informations sur la gestion de la mémoire: valeurs des registres, des tables de pages ou
des tables de segments.
 Informations sur l’état des E/S: liste des périphériques E/S allouées à ce processus, une
liste des fichiers ouverts.
 Etc.,,,.

3/13
Systèmes d’exploitation ISET de Jendouba

d) Changement de contexte de processus

Une des principales raisons pour justifier l’utilisation des blocs de contrôle des processus est que
dans un système multiprogrammé on a souvent besoin de redonner le contrôle du CPU à un autre
processus. Il faut donc mémoriser toutes les informations nécessaires pour pouvoir éventuellement
relancer le processus courant dans le même état. Par exemple, il faut absolument se rappeler à quelle
instruction il est rendu.

Le système d’exploitation maintient dans une table appelée «/*table des processus» les informations
sur tous les processus créés (une entrée par processus : PCB).

2. La notion de thread
Thread ou processus léger est une unité d'exécution rattachée à un processus. Un thread est chargé
d'exécuter une partie du programme d’un processus.

Exemple :

La figure ci-dessous représente un processus qui exécute un programme de traitement de texte.


Ce processus crée trois thread chacune prend en charge une sous tâche :

4/13
Systèmes d’exploitation ISET de Jendouba

• Un thread pour interagir avec l’utilisateur (interaction avec le clavier),

• Un thread pour reformater en arrière plan (détection automatique des erreurs


d’orthographe,…),

• Un thread pour sauvegarder périodiquement le document.

En effet, un processus est vu comme étant un ensemble de ressources (espace d’adressage, fichiers,
périphériques...) que ses threads (fils) d'exécution partagent.
Important !!!!! Un thread partage avec son processus père le même code du programme, le même
espace d’adressage et les données et les fichiers utilisés. Le thread ne partage pas avec son père les
registres des données et la pile d’exécution (voir figure ci-dessous).

Lorsqu’un processus est créé, un seul fil d’exécution (thread) est associé au processus => thread
principal exécutant la fonction principale du programme du processus. Ce thread principal peut en
créer d’autres.

Processus Subdivision du processus en un ensemble de thread

Chaque thread a:

– un identificateur unique
– une pile d'exécution
– des registres (un compteur ordinal)
– un état...

Important!!!! Un processus peut créer soit un autre processus (processus fils) soit un thread.

5/13
Systèmes d’exploitation ISET de Jendouba

3. Les processus sous Linux


a) Types de processus sous linux
On peut distinguer 4 types de processus sous les systèmes linux :
Nom Description
Démon (deamon) Processus lancé en arrière plan
Parent Processus père
Fils Processus fils
Zombie Processus mort qui n’a plus de père ni de fils

b) Lister des informations sur les processus


La commande ps liste les processus de l'utilisateur. L'option -e affiche tous les processus en cours
d'exécution sur un ordinateur et les options –l et –f affichent des informations détaillées. Ainsi, la
commande produit une sortie semblable à :

 UID nom de l'utilisateur qui a lancé le processus.

 PID correspond au numéro du processus.

 PPID correspond au numéro du processus parent.

 C au facteur de priorité : plus la valeur est grande, plus le processus est prioritaire

6/13
Systèmes d’exploitation ISET de Jendouba

 STIME correspond à l'heure de lancement du processus

 TTY correspond au nom du terminal

 TIME correspond à la durée de traitement du processus

 COMMAND correspond au nom du processus.

c) Hiérarchie de processus
Dans les systèmes Linux, lorsqu’un processus crée un autre processus, les processus parent et enfant
continuent d’être associés d’une certaine manière. Le processus enfant peut lui même créer plusieurs
processus, formant une hiérarchie de processus. Un processus a un seul parent et peut avoir 0 ou
plusieurs fils. Sous Linux, si le processus A crée le processus B, A est le parent de B, B est le fils de
A. B peut à son tour créer des processus. Un processus avec tous ses descendants forment un groupe
de processus représenté par un arbre de processus.

d) Les processus et le démarrage du système Linux


Avant le lancement du système, le chargeur de démarrage (bootloader) fait appel à la fonction
start_kernel() du fichier init/main.c. Cette fonction va créer le tout premier processus : le swapper
(ou Processus 0) qui occupera la première entrée de la table des processus. Le swapper va ensuite
créer deux autres processus, le processus init et le processus [kthreadd] et va s’endormir.
À partir de ce moment-là, nous pouvons considérer qu'il existe 2 espaces au sein du système. Un
espace utilisateur avec init au sommet de la hiérarchie et un espace noyau avec [kthreadd].

Notons que Init et [kthreadd] étant tout les deux des fils du swapper ont leur PPID égal à 0. La
commande ps permet de le vérifier.

7/13
Systèmes d’exploitation ISET de Jendouba

 Espace utilisateur
Au sommet de l'espace utilisateur se trouve le processus init, ayant le PID 1, qui est le premier à
avoir été lancé. Il se chargera ensuite de créer les autres processus utilisateurs nécessaires au
fonctionnement du système, notamment les processus daemons et les processus gettys qui à leur tour
créeront d'autres processus fils et ainsi de suite. Init sera ici l’ancêtre de tous les processus utilisateur.

Les processus getty (get teletype) sont chargés de la surveillance des terminaux. Ils permettent entre
autres aux utilisateurs de se connecter. Quand un utilisateur veut se connecter à un terminal, le
processus getty va créer un nouveau processus fils, le processus login. Ce dernier va vérifier à l'aide
du fichier /etc/passwd la correspondance login/mot de passe et les autorisations de l'utilisateur. Si la
connexion est réussie, le processus login va à son tour créer un nouveau processus fils, le processus
shell (interpréteur de commandes). Il va analyser si l’utilisateur entre une commande et créera un
nouveau processus chargé de l’exécuter. Ce dernier processus prendra fin lorsque la commande (ou
le programme lancé en ligne de commande) se terminera.
Les daemons sont des processus, pour la plupart lancés au démarrage du système, qui restent en
tâche de fond jusqu’à ce qu'on fasse appel à eux. Leurs noms se terminent généralement par la lettre
d (pour daemon). Parmi les plus connus, nous avons par exemple crond (tâches planifiées), inetd
(surveillance réseau), rsyslogd (logs du système), lpd (gestion de l’imprimante), etc.

 Espace Noyau
Cet espace est occupé par les threads noyau (ou kthreads, ou encore processus noyau) qui gèrent la
partie hardware et ont une priorité haute. Ils s’exécutent dans l'espace d'adressage du noyau.

8/13
Systèmes d’exploitation ISET de Jendouba

Au sommet de cet espace se trouve le daemon [kthreadd], processus qui se chargera de lancer tous
les autres kthreads, reconnaissables de par leurs noms entre crochets [], [kthreadd] est donc l'unique
père de cette hiérarchie et de ce fait tous les kthreads présents dans cet espace (sauf [kthreadd] lui
même) ont un PPID de 2. Parmi les plus connus nous avons par exemple [kswapd0] (daemon du
swap), etc.

4. L’ordonnancement des processus

a) La notion d’ordonnanceur
L’ordonnanceur (scheduler) est la partie du SE qui décide quel processus dans la file prêt obtient le
CPU quand il devient libre. Donc la tâche principale de l’ordonnanceur est de choisir parmi les
processus prêts et d’allouer le CPU à l’un d’eux.

L’ordonnanceur utilise un algorithme d’ordonnancement pour décider sur le prochain processus à


exécuter. L’algorithme d’ordonnancement se base dans sa décision sur un critère de sélection. Il
existe plusieurs critères de sélection, parmi lesquels l’équité (degré auquel tous les processus
reçoivent une chance égale de s’exécuter), les priorités des processus (attribue un traitement
préférentiel aux processus dont le niveau de priorité est supérieur), etc.

9/13
Systèmes d’exploitation ISET de Jendouba

b) Mesure de performance d’un algorithme d’ordonnancement


La performance d’un algorithme peut être analysée en se basant sur des mesures de performances.
Dans les prochaines sections nous allons étudier un ensemble d’algorithmes d’ordonnancement et
nous allons mesurer leurs performances en utilisant les mesures suivantes :
 Temps de réponse = le temps entre une demande et la réponse.
 Temps de rotation = temps terminaison moins temps arrivée.
 Temps d’attente = temps d’attente dans la file prêt.
𝑡𝑒𝑚𝑝𝑠 𝑑 ′ 𝑒𝑥 é𝑐𝑢𝑡𝑖𝑜𝑛 𝑑𝑒𝑠 𝑝𝑟𝑜𝑐𝑒𝑠𝑠𝑢𝑠
 Rendement = 𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑝𝑟𝑜𝑐𝑒𝑠𝑠𝑢𝑠

c) Types d’algorithmes d’ordonnancement


On peut classifier les algorithmes d’ordonnancement en deux catégories :
i. Ordonnancement non préemptif : ou ordonnancement jusqu’à achèvement :
le processus élu garde le contrôle jusqu’à épuisement du temps qui lui a été
alloué même si des processus plus prioritaires ont atteint la liste des Prêts.
ii. Ordonnancement préemptif : L’ordonnanceur peut interrompre un processus
en cours d’exécution si un nouveau processus de priorité plus élevée est inséré
dans la file des Prêts.

d) Algorithmes d’ordonnancement

i. L’algorithme d’ordonnancement FIFO (First In First Out)


L'ordonnancement est fait dans l'ordre d'arrivée sans priorité ni réquisition. Chaque processus
s’exécute jusqu’à son terme Le processus élu est celui qui est en tête de liste des Prêts : le premier
arrivé.
Exemple :
Soit les processus P1, P2 et P3 qui arrivent dans l’état prêt selon l’ordre indiqué dans la table ci-
dessous :
Processus Temps d’arrivée Temps d’exécution
P2 0 3
P3 1 3
P1 3 24

Le diagramme de Gant sera comme suit :

P2 P3 P1
0 3 6 30
P2 P3 P1

10/13
Systèmes d’exploitation ISET de Jendouba

Exercice :
Soit les données suivantes :
Processus Temps d’arrivée Temps d’exécution
P1 0 20
P2 6 5
P3 10 3

Donner le diagramme de Gant et calculer, pour chaque processus, le temps de rotation, le temps de
réponse, Temps d’attente,

Solution :

P1 P2 P3
0 20 25 28
P1 P2 P3

Temps de Temps de Temps


Rendement
rotation réponse d’attente
P1 27 3 0
P2 3 0 14
9.33
P3 5 2 15
Moyenne

ii. L’algorithme d’ordonnancement SJF (Shortest Job First)


L'Ordonnanceur élit (choisit) le plus court processus (en terme de temps d’exécution) d'abord.
- Deux versions :
 Avec préemption: si un processus qui dure moins que le restant du processus courant se
présente plus tard, le CPU est donnée à ce nouveau processus (SRTF: shortest remaining-time
first)
 Sans préemption: on permet au processus courant de terminer son cycle même si un
processus plus court se présente dans la file prêt.
Exercice :
Processus Temps d’arrivée Temps d’exécution
P1 0 7
P2 2 4
P3 4 1
P4 5 4

1) Tracer le diagramme de Gant relatif au données ci-dessus en utilisant l’algorithme SJF sans
préemption

11/13
Systèmes d’exploitation ISET de Jendouba

2) Calculer, pour chaque processus, l’utilisation CPU, Débit, Temps de réponse, Temps de rotation,
Temps d’attente,
3) Refaire les questions 1) et 2) pour l’algorithme SRTF
Correction :

1)
P1 P3 P2 P4
0 7 8 12 16
P1 P2 P3 P4

2)
Temps de Temps de Temps
Rendement
rotation réponse d’attente
P1
P2
P3
P4
Moyenne

3)

P1 P2 P3 P2 P4 P1
0 2 4 5 7 11 16
P1 P2 P3 P4

Temps de Temps de Temps


Rendement
rotation réponse d’attente
P1
P2
P3
P4
Moyenne

iii. L’algorithme d’ordonnancement RR


Le processeur gère une liste circulaire de processus. Chaque processus dispose d'un quantum de
temps pendant lequel il est autorisé à s'exécuter. Si le processus actif se bloque ou s'achève avant la
fin de son quantum, le processeur est immédiatement alloué à un autre processus. Si le quantum

12/13
Systèmes d’exploitation ISET de Jendouba

s'achève avant la fin du processus, le processeur est alloué au processus suivant dans la liste et le
processus précédent se trouve ainsi en queue de liste.
Exercice :
Tracer le diagramme de Gantt pour Quantum=5
Processus Temps d’exécution
P1 13
P2 7
P3 10
P4 15

Solution :

iv. L’algorithme d’ordonnancement HPF


L’ordonnanceur à priorité attribue à chaque processus une priorité. Le choix du processus à élire
dépend des priorités des processus prêts. Les processus de même priorité sont regroupés dans une
file. Il y a autant de files qu’il y a de niveaux de priorité. L’ordonnanceur choisit le processus le plus
prioritaire qui se trouve en tête de file. En général, les processus de même priorité sont ordonnancés
selon l’algorithme RR.

v. Les files d’attente rétroactives


Cet algorithme met en œuvre N files (N>1) d’attentes classées de 1 à N. Un processus qui vient
d’être crée est placée dans la file du niveau le plus élevé. Une fois sélectionnés les processus de la
file reçoivent une tranche de temps relativement courte. A l’expiration de cette dernière, le processus
est déplacé dans la file de niveau inférieur. Les tranches de temps associées aux files s’allongent au
fur et à mesure que le niveau décroît. Si un processus est bloqué avant d’avoir utilisé la totalité de sa
tranche de temps, il passe à la file de niveau supérieur. Le processus sélectionné par cet algorithme
est le prochain processus de la file la plus élevée contenant des processus. La sélection au sein d’une
file se fait suivant la stratégie RR ou FIFO. Si un processus entre dans une file alors qu’un autre
processus d’un niveau inférieur est en cours d’exécution, ce dernier peut être préempté.

13/13