Chapitre 3 : Gestion du processeur

I. Notion de processus

I.1 Introduction

Dans un système multiprogrammé, un processeur peut exécuter une

séquence d'instructions d'1 pgm, puis ensuite 1 séquence d'instructions d'1 autre
pgm avant de revenir au premier, et ainsi de suite.

Si la durée d'exécution des séquences est assez petite, les UT auront l'impression que
les 2 pgms s'exécutent en parallèle  On parle alors de pseudo-parallélisme.

Vu du processeur lui-même : Il s'agit d'une activité unique et séquentielle. Vu de l'UT

: Ce sont des pgms en parallèle.

La gestion de ces activités // est assez complexe et difficile à appréhender  D'où la

notion de processus : Concept fondamental pour la compréhension de cette gestion.

I.2 Notion de processus

* Un processus est l'entité dynamique qui correspond à l'exécution d'une suite

d'instructions définie par le programme. Le processeur est l'entité qui exécute les
instructions pour le compte du processus.
* Lorsqu'1 processus n'a pas le processeur, il ne peut évoluer, et son état doit être
conservé en mémoire. Lorsqu'il a le processeur, son état évolue, et est représenté en
partie par les registres du processeur.
* Eg. de processus :
- L'exécution d'1 pgm ;
- La recopie d'un fichier sur disque ;
- La transmission d'1 séquence de données sur 1 réseau.
* Processus # Programme : Le pgm est une description statique ; le processus est 1
entité dynamique (il a 1 début, 1 déroulement et 1 fin, il a 1 état qui évolue au cours
du temps). 2 exécutions d'1 même pgm constituent 2 processus différents.
(Voir l'eg. de l'informaticien préparant 1 gâteau qui montre la différence entre pgm &
processus –de Tanenbaum-).
* Plusieurs éléments sont associés à 1 processus : son code, ses données, les
ressources d'exploitation qui lui sont attribuées ainsi qu'un ou plusieurs threads
d'exécution.
* Un thread est un flot d'exécution dans le code du processus, doté d'un CO, de
registres système et d'1 pile qui lui sont propres.
* Les SE peuvent être classés selon 3 grandes familles :
- Les systèmes monoprocessus à thread unique ;
- = = multiprocessus = = = ;
- = = = multithread.
* Le système doit permettre :
- Distinguer les différents processus à 1 instant donné ;
- et, représenter leur état.

1
 I.3 Concept de TACHE et concept de JOB

* On utilise parfois le terme tâche (TASK) pour faire référence à une entité
multithread alors que processus lourd fait référence à une tâche dotée d'1 seul
thread. Il arrive d'utiliser l'expression processus léger pour désigner un thread.
* Sur les premiers systèmes par lots, le terme JOB (travail) était utilisé pour faire
référence à 1 ou plusieurs pgms exécutés de manière séquentielle et traités par le
système comme une entité unique.
* Un job en cours d'exécution est un processus  C'est pourquoi, il arrive que les
termes soient employés indifféremment.

I.4 Hiérarchie des processus

* Certains systèmes créent à l'initialisation, 1 nbre fixe de processus.

* Une autre façon consiste à fournir une opération de création dynamique de
processus ainsi qu'une opération de destruction de ces processus :
id  créer_processus(pgm, contexte)

identité du instructions données

processus Etat initial du processus
crée
 Relation entre le processus créateur (père) et le processus créé (fils)  Structurer
l'ensemble des processus sous la forme d'un arbre.

* Lors de la fin du père :

- Détruire les fils non achevés ;
- Attendre l'achèvement des fils ;
- Rattachement à un ancètre (la racine).
* Sous UNIX (& Linux : Voir TP), la fonction fork() crée le processus fils comme copie
conforme du processus père.

I.5 Relations entre processus

* Compétition :
- Situation dans laquelle plusieurs processus doivent utiliser simultanément
une ressource à accès exclusif (i.e : ressource ne pouvant être utilisée que par un seul
processus à la fois).
- Eg. : . Processeur (cas du pseudo-parallélisme) ;
. Imprimante.
- Une solution possible : Faire attendre le processus demandeurs que l'occupant
actuel ait fini.
* Coopération :
- Situation dans laquelle plusieurs processus collaborent à une tâche commune et
doivent se synchroniser pour réaliser cette tâche.
- Eg. : . P1 produit un fichier ; P2 imprime le fichier
. P1 met à jour un fichier ; P2 consulte le fichier.
- La synchronisation se ramène au cas suivant : Un processus doit attendre qu'un
autre processus ait franchi un certain point de son exécution.

2
 Dans les 2 types de relations (compétition ou coopération), on est conduit à faire
attendre un processus.

I.6 Notion de ressources

* On appelle ressource, toute entité dont a besoin un processus pour

s'exécuter : processeur physique, MC, périphériques, événements, ….
* Pour chaque ressource, une caractéristique importante est le nombre de processus
qui peuvent utiliser la ressource au même moment (i.e : nbre de points d'accès) :
- Il peut y avoir 1 nbre quelconque  Il n'y a alors pas de contrôle à mettre en
œuvre.
- Il peut y en avoir plusieurs, mais en nbre limité  Il faut alors contrôler lors des
allocations que ce nbre n'est pas dépassé.
- Il peut y avoir au plus un processus qui utilise la ressource  On dit alors que la
ressource est 1 ressource critique  On dit aussi que les processus sont en exclusion
mutuelle pour l'accès à cette ressource.

I.7 Les différents états d'un processus

* 1 processus peut se trouver dans différents états, suivant qu'il dispose de tout
ou partie des ressources dont il a besoin pour s'exécuter.
* La ressource processeur doit être distingué de l'ensemble des autres ressources : S'il
manque une ressource autre que le processeur, celui-ci ne peut faire évoluer le
processus  Il est inutile que cette ressource chère lui soit allouée.
* Il est nécessaire de bloquer un processus qui n'a pas toutes les ressources dont il a
besoin pour s'exécuter, dans l'attente que ces ressources soient disponibles.

* Lorsqu'un processus existe, il peut prendre les états suivants :

Actif

3
Bloqué Prêt4

- L'état actif (élu) où le processus dispose de toutes les ressources dont il a

besoin ;
- L'état bloqué où le processus a besoin d'au moins une ressource autre que le
processeur physique ;
- L'état prêt où le processus dispose de toutes les ressources à l'exception du
processeur physique.

II. Techniques d'ordonnancement

* Les transitions entre les états Actif & Prêt sont provoquées par un module du SE
(au niveau le plus bas), appelé ordonnanceur de processus (Scheduler). Si plusieurs
processus sont prêts, l'ordonnanceur doit donc choisir le processus à exécuter ;
l'algorithme utilisé est l'algorithme d'ordonnancement. Un ordonnanceur doit faire
face à 2 pbs principaux :
- Le choix du processus à exécuter, et
- Le temps d'allocation du processeur au processus choisi.

* Critères d'ordonnancement :
- Equité : Chaque processus doit avoir du temps processus ;

3
 - Efficacité : Le processeur doit être utilisé à 100 % (% d'utilisation de l'UC à
maximiser) ;
- Temps de réponse : L'UT devant sa machine ne doit pas trop attendre (à minimiser
pour les UT en mode interactif) ;
- Temps d'exécution : Une séquence d'instructions ne doit pas trop durer (minimiser
l'attente pour les UT en mode batch) ;
- Rendement : Il faut faire le plus de chose en une heure.

* Au début, l'ordonnancement était la plupart du temps non préemptif  1 processus

conservait le contrôle du processeur jusqu'à ce qu'il se bloque ou qu'il se termine.
Cette approche correspondait parfaitement aux besoins des travaux par lots.

* Sur les systèmes interactifs actuels, c'est l'ordonnancement préemptif qui est utilisé
 L'ordonnanceur peut préempter 1 processus avant qu'il se bloque ou se termine,
afin d'attribuer l'UC à 1 autre processus.

* Dans la littérature, il y a plusieurs algorithmes d'ordonnancement mais quelques un

sont largement répandus.

1) L'algorithme du premier entré, premier servi (sorti) ou FCFS (First-

Come First-Served) :
- C'est l'algorithme d'ordonnancement le plus simple.
- Les tâches sont ordonnancées dans l'ordre où elles sont reçues.
- Cet algorithme n'est pas préemptif & son implémentation est très simple :
Mettre en œuvre une file des processus à ordonnancer ou stocker l'heure à
laquelle le processus a été reçu, puis sélectionner le processus arrivé le plus
tôt.
- Cet algorithme favorise davantage les processus tributaires de l'UC au
détriment des processus tributaires des E/S.

2) L'algorithme du travail le plus court d'abord ou SJF(Shortest Job

First) :
- C'est 1 algo non préemptif aussi.
- Il sélectionne le processus dont il suppose que le temps de traitement
sera le plus court.
- En cas d'égalité, l'ordonnancement FCFS peut être utilisé.
- Cet algo favorise les travaux courts par rapport aux longs.

3) L'algorithme du temps restant le plus court ou SRT (Shortest

Remaining Time) :
- C'est la version préemptive de l'algorithme SJF.
- Chaque fois qu'un nouveau processus est introduit, l'ordonnanceur
compare la valeur estimée de temps de traitement restant à celle du
processus en cours d'ordonnancement. Si le temps de traitement du
nouveau processus est < alors le processus en cours
d'ordonnancement est préempté.
- Tout comme l'algo SJF, cet algorithme favorise les travaux courts.

4) L'algorithme à tourniquet (circulaire) ou RR (Round Robin) :

- C'est l'1 des algorithmes les plus anciens, les plus simples, les plus
fiables et les plus utilisés.
- C'est 1 algo préemptif.
- Chaque processus possède un intervalle de temps, son quantum,
pendant lequel il est autorisé à s'exécuter.

4
 - Si un processus s'exécute toujours au bout de son quantum, le
processeur est réquisitionné et alloué à 1 autre processus. Si, par
contre, le processus se bloque ou se termine avant la fin de son
quantum, le processeur est immédiatement alloué à 1 autre processus.
- Cet algo est facile à réaliser : L'ordonnanceur doit mémoriser une liste
des processus prêts & lorsque son quantum est épuisé, le processus en
cours est mis à la fin de la liste.
- Pb : Choix de la durée du quantum.

5) L'algorithme avec priorité :

- Il peut être préemptif ou non.
- Il requiert qu'une valeur de priorité soit attribuée à chaque processus.
- Le processus sélectionné est celui à la priorité la plus élevée. En cas
d'égalité, c'est l'algo FCFS qui est utilisé.

III. Gestion des activités parallèles

Les processus concurrents s’exécutant dans le SE peuvent être des processus coopératifs ou
indépendants. 1 processus est coopératif s’il peut affecter les autres processus en cours
d’exécution dans le système ou être affecté par eux  Tout processus qui partage des
données avec d’autres processus est 1 processus coopératif.
Les accès concurrents à des données partagées peuvent produire des incohérences de données.
L’exécution concurrentielle, qui demande la coopération entre les processus, requiert des
mécanismes permettant aux processus de communiquer entre eux et de synchroniser leurs
actions.
3.1 Pb de la section critique :
Soit 1 système constitué de n processus {P0, P1, ………,Pn-1}. Chaque processus possède 1
segment de code, appelé section critique (SC), dans laquelle le processus peut modifier des
variables communes, actualiser 1 table, écrire dans 1 fichier, ….
La caractéristique importante du système est que, quand 1 processus exécute sa section
critique, aucun autre processus n’est autorisé à exécuter sa section critique  Ainsi,
l’exécution des sections critiques par les processus est mutuellement exclusive dans le temps.
Le pb de la section critique est de concevoir 1 protocole que les processus puissent utiliser pour
coopérer :
- Chaque processus doit demander la permission d’entrer à sa SC : La section de code qui
implémente cette requête est la section d’entrée ;
- La SC doit être suivie par 1 section de sortie ;
- Le code restant est la section restante.
Tantque (vrai) faire
section d’entrée
section critique
section de sortie
section restante
Fintantque
Structure générale d’1 processus Pi typique
1 solution au pb de la SC doit satisfaire aux 3 besoins suivants :
a) Exclusion mutuelle b) Déroulement c) Attente limitée

a) Exclusion mutuelle :

Si le processus Pi exécute sa SC, aucun autre processus ne peut exécuter sa SC.

b) Déroulement :

Si aucun processus n’exécute sa SC et si certains processus désirent entrer dans les

leurs alors seulement les processus qui ne se trouvent pas dans leurs sections
restantes peuvent décider qui rentrera prochainement à sa SC. Cette sélection ne peut
être reportée indéfiniment.
c) Attente limitée :

5
 Il doit exister 1 limite au nbre de fois que l’on permet à d’autres processus à entrer
dans leurs SCs après qu’1 processus a effectué 1 requête pour entrer dans sa SC et
avant que la requête ne soit accordée.
Nous supposons que chaque processus s’exécute à 1 vitesse <> 0. Cependant, nous ne
pouvons effectuer aucune supposition concernant la vitesse relative des n processus.

3.2 Exclusion mutuelle par attente active :

L’attente peut-être :
- Active : La « section d’entrée » est 1 boucle dont la condition est un test qui porte sur
des variables indiquant la présence ou non d’1 processus en SC ;
- Passive : Le processus passe dans l’état endormi et ne sera réveillé que lorsqu’il sera
autorisé à entrer.
Solution 1 : Masquage des interuptions (ITs).
Section d’entrée : Masquer ITs()
Section de sortie : Démasquer ITs()
Le moyen le plus simple est que chaque processus puisse masquer les ITs avant d’entrer en
SC  L’IT d’horloge qui permet d’interrompre 1 processus lorsqu’il a épuisé son quantum
serait ignorée  Il n’y aura plus de commutation de contexte.
Lorsqu’1 processus quitte la SC, il doit démasquer les ITs.
Cette solution est dangereuse en mode utilisateur : Si dans un processus le programmeur a
oublié de démasquer les ITs, c’est la fin du système.
Solution 2 : Les variables de verouillage.
La deuxième solution est d’utiliser un moyen logiciel
verrou  0 ; // Variable partagée
Processus P0 Processus P1
Tque (vrai) faire Tque (vrai) faire
Tque (verrou <> 0) faire Ftque Tque (verrou <> 0) faire Ftque
verrou  1 verrou  1
Section critique Section critique
verrou  0 verrou  0
……………… ………………
Ftque Ftque
Exercice : Montrer qu’avec cette solution, les besoins d’exclusion mutuelle ne sont pas
satisfaits.
Solution 3 : L’alternance.
Une autre solution possible du pb de la SC est la suivante :
tour  0 ; // Variable partagée
Processus P0 Processus P1
Tque (vrai) faire Tque (vrai) faire
Tque (tour != 0) faire Ftque Tque (tour != 1) faire Ftque
Section critique Section critique
tour  1 tour  0
……………… ………………
Ftque Ftque
Le processus P0 peut être bloqué par le processus P1 qui n’est pas en SC  Cette solution
n’est pas valable s’il y a 1 grande différence de vitesse entre les processus. (Cd b) déroulement
non satisfaite).
Cette solution –pour être correcte- impose 1 alternance stricte des processus qui entrent en
SC.
Solution 4 : Solution de Dekker-Peterson. //Pour le cas de 2 processus P0 et P1.
Interesse[0] = interesse[1]  faux ;
Processus Pi
Début
Tque (vrai) faire
autre  1 – i ;
interesse[i]  vrai ;
tour  i ;
Tque ((interesse[autre] == vrai) et (tour == i) faire ftque
Section critique
interesse[i]  faux ;
………………………
Ftque

6
Fin
Exercice : Montrer que cette solution est correcte.
Nous devons démontrer que :
1. L’exclusion mutuelle est préservée ;

2. Le besoin de déroulement est satisfait ;

3. Le besoin d’attente limitée est respecté.

L’instruction Test And Set (TAS)

Elle s’exécute comme action élémentaire et indivisible. TAS peut être mis en œuvre dans 1
environnement multiprocesseur.
Elle agit sur 1 variable booléenne p :
Instruction TAS(p) ;
Début
Bloquer l’accès à la cellule de mémoire p ; //par câblage
Lire le contenu de p ;
Si (p) alors CO  CO + 1 sinon p vrai ; CO  CO +2 finsi
Libérer l’accès à la cellule de mémoire p
Fin

Utilisation :
P  faux ;
// entrée
E : TAS(p) ;
Aller à E ;
//SC
//sortie
P  faux
Ré-écriture de TAS :
TAS(p : booléen) : booléen
Début
Si (p) alors TAS  vrai sinon p  vrai ; TAS  faux finsi
Fin
Usage :
P  faux ;
……………….
Tque (TAS(p)) faire ftque
SC
P  faux ;
…………….
3.3 Exclusion mutuelle par attente passive :
Les solutions basées sur l’attente active testent si 1 processus peut entrer en SC ; le processus
exécute 1 boucle jusqu’à ce qu’il soit autorisé à entrer en SC. Cependant, l’attente active
consomme beaucoup de temps processeur.
Les techniques de l’attente passive demandent 1 certaine intervention mais évite 1 surcharge
inutile du processeur.
Ils existent 1 grand nombre de solutions pour implémenter les méthodes d’attente passive :
- Les verrous ;

- Les sémaphores ;

- Les moniteurs ;

- ………………………

D’1 point de vue formel, on peut –généralement- montrer qu’elles sont toutes équivalentes.