Synchronisation de

Processus

Chapitre 5

1
Synchronisation de Processus

1. Conditions de Concurrence
2. Sections Critiques
3. Exclusion Mutuelle
4. Sommeil & Activation
5. Smaphores
6. Mutex

2
 Concurrence

Les processus concurrents doivent parfois

partager donnes (fichiers ou mmoire
commune) et ressources
On parle donc de tches coopratives
Si laccs nest pas contrl, le rsultat de
lexcution du programme pourra dpendre
de lordre dentrelacement de lexcution
des instructions (non-dterminisme).
Un programme pourra donner des rsultats
diffrents et parfois indsirables

3
 Un exemple
Deux processus M. X demande une
excutent cette mme rservation
procdure et partagent la davion
mme base de donnes
Ils peuvent tre Base de donnes
interrompus nimporte o dit que fauteuil
Le rsultat de lexcution A est disponible
concurrente de P1 et P2
dpend de lordre de leur Fauteuil A est
entrelacement assign X et
marqu occup

4
 Exemple dexcution possible

P1
Interruption P2
M. Leblanc demande une ou retard
rservation davion
M. Guy demande une
rservation davion

Base de donnes dit

que fauteuil 30A est
disponible Base de donnes dit
que fauteuil 30A est
disponible

Fauteuil 30A est Fauteuil 30A est

assign Leblanc et assign Guy et
marqu occup marqu occup

5
 Un autre exemple
P1 interruption P2
Deux
b=a oprations
b=a en parallle
sur une
b++ variable a
a=b partage
(b est priv
b++ chaque
processus)
a=b
Supposons que a soit 0 au dbut
P1 travaille sur le vieux a donc le rsultat final sera a=1.
Il serait a=2 si les deux tches sont excutes lune aprs lautre
Si a tait sauvegard quand P1 est interrompu, il ne pourrait pas tre partag avec P2
(il y aurait deux a tandis que nous en voulons une seule)
6
 Section Critique

Partie dun programme dont lexcution ne

doit pas entrelacer avec autres programmes

Une fois quun tche y entre, il faut lui

permettre de terminer cette section sans
permettre autres tches de jouer sur les
mmes donnes

7
Le problme de la section critique

Lorsquun processus manipule une donne (ou

ressource) partage, nous disons quil se trouve dans
une section critique (SC) (associe cette donne)
Le problme de la section critique est de trouver un
algorithme d`exclusion mutuelle de processus dans
lexcution de leur Section Critiques afin que le rsultat
de leurs actions ne dpendent pas de lordre
dentrelacement de leur excution (avec un ou plusieurs
processeurs)
Lexcution des sections critiques doit tre mutuellement
exclusive: tout instant, un seul processus peut
excuter une SC pour une var donne (mme lorsquil y
a plusieurs processeurs)
Ceci peut tre obtenu en plaant des instructions
spciales dans les sections d`entre et sortie
Pour simplifier, dornavant nous faisons lhypothse quil
ny a qu'une seule SC dans un programme. 8
 Structure du programme
Chaque processus doit donc demander une permission
avant dentrer dans une section critique (SC)
La section de code qui effectue cette requte est la
section dentre
La section critique est normalement suivie dune
section de sortie
Le code qui reste est la section restante (SR): non-
critique
repeat
section dentre
section critique
section de sortie
section restante
forever 9
 Application
M. X demande une
rservation davion

Section dentre

Section Base de donnes dit que

critique fauteuil A est disponible

Fauteuil A est assign X et

marqu occup

Section de sortie

10
 Critres ncessaires pour solutions valides

Exclusion Mutuelle
tout instant, au plus un processus peut
tre dans une section critique (SC) pour une
variable donne
Non interfrence:
Si un processus sarrte dans sa section
restante, ceci ne devrait pas affecter les
autres processus
Mais on fait lhypothse quun
processus qui entre dans une section
critique, en sortira.

11
 Critres ncessaires pour solutions valides

Progrs:
absence dinterblocage
si un processus demande d`entrer dans une
section critique un moment o aucun autre
processus en fait requte, il devrait tre en
mesure dy entrer
Absence de famine: aucun processus ne
sera ternellement empch datteindre sa
Section Critique

12
 Conditions de Concurrence
Conditions de concurrence (race conditions): situation o 2
processus ou plus effectuent des lectures et des critures
conflictuelles.
Exemple du Spouler dimpression
Un processus qui veut imprimer un fichier, entre son
nom dans un rpertoire de spoule
Le processus dmon dimpression regarde
priodiquement sil y a des fichiers imprimer. Il a 2
variables:
in: pointe vers la prochaine entre libre.
out: pointe vers le prochain fichier imprimer
in = 7, out = 4
A et B deux processus qui veulent imprimer un fichier
A >> lire in, next_free_slot = 7
Interruption: la CPU bascule vers le processus B
B >> lire in, next_free_slot = 7, entre7 = fichierB, in
=8
A >> entre7 = fichierA, in = 8
Problme: le fichierB ne sera pas imprim

13
 Conditions de Concurrence

Comment viter les conditions de concurrence?

Solution: Interdire que plusieurs processus lisent
et crivent des donnes partages simultanment.
Exclusion Mutuelle: permet dassurer que si un
processus utilise une variable ou fichier partags,
les autres processus seront exclus de la mme
activit

14
 Les Sections Critiques
les Sections Critiques, mthode dexclusion mutuelle
A entre dans sa A quitte sa
section critique section critique
A
B quitte sa
section critique

t1 t2 t3 t4
B tente dentrer dans sa B entre dans sa
section critique section critique

15
 LExclusion Mutuelle avec Attente Active
(busy waiting)
Dsactivation des interruptions
Aprs son entre dans une SC, un processus dsactive les
interruptions, puis les ractive
Il empche ainsi lhorloge denvoyer des interruptions et le
processeur de basculer
Il est imprudent de permettre des processus user de
dsactiver les interruptions
Variables de verrou (lock)
Avant dentrer en SC, tester la valeur de verrou, si verrou
= 0, verrou 1, entrer en SC
Dfaillance: 2 processus peuvent entrer simultanment
dans leurs sections critiques comme le spouler
dimpression
Alternance Stricte
la variable turn porte le numro du processus dont cest le
tour dentrer en SC. Chaque processus inspecte la valeur
de la variable, avant dentrer en SC.
Inconvnient: consomme bcp de temps CPU
16
 Exclusion Mutuelle avec Attente Active
(busy waiting)

Alternance Stricte
while (TRUE) { while (TRUE) {
while (turn != 0); while (turn != 1);
critical_region(); critical_region();
turn = 1; turn = 0;
non_critical_region(); non_critical_region();
} }
Les attentes actives sont performantes dans le cas o elles
sont brves. En effet, il y a risque dattente
P0 quitte la CS, turn = 1
P1 termine sa CS, turn = 0
Les 2 processus sont en section non critique
P0 excute sa boucle, quitte la SC et turn = 1
Les 2 processus sont en section non critique
P0 quoiquil a termin, il ne peut pas entrer en SC, il est
bloqu

17
 Une leon retenir
fin que des processus avec des variables
partages puissent russir, il est ncessaire
que tous les processus impliqus utilisent le
mme algorithme de coordination
Un protocole commun

18
 Critique des solutions par logiciel

Difficiles programmer! Et comprendre!

Les solutions que nous verrons dornavant
sont toutes bases sur lexistence
dinstructions spcialises, qui facilitent le
travail.

Les processus qui requirent lentre dans

leur SC sont occups attendre (busy
waiting); consommant ainsi du temps de
processeur
Pour de longues sections critiques, il serait
prfrable de bloquer les processus qui
doivent attendre...
19
 Solutions matrielles:
dsactivation des interruptions

Sur un uniprocesseur:
exclusion mutuelle est
prserve mais
lefficacit se dtriore: Process Pi:
lorsque dans SC il est repeat
impossible dentrelacer
lexcution avec dautres
inhiber interrupt
processus dans une SR section critique
Perte dinterruptions rtablir interrupt
Sur un multiprocesseur: section restante
exclusion mutuelle nest forever
pas prserve
Une solution qui nest
gnralement pas
acceptable
20
 Solutions bases sur des instructions
fournies par le SE (appels du systme)

Les solutions vues jusqu prsent sont

difficiles programmer et conduisent du
mauvais code.
On voudrait aussi qu`il soit plus facile
dviter des erreurs communes, comme
interblocages, famine, etc.
Besoin dinstruction plus haut niveau
Les mthodes que nous verrons dornavant
utilisent des instructions puissantes, qui
sont implantes par des appels au SE
(system calls)

21
 Smaphores
Un smaphore S est un entier qui, sauf pour
l'Initialisation, est accessible seulement par ces 2
oprations atomiques et mutuellement exclusives:
wait(S)
signal(S)
Il est partag entre tous les procs qui s`intressent
la mme section critique
Les smaphores seront prsents en deux tapes:
smaphores qui sont occups attendre (busy
waiting)
smaphores qui utilisent des files d attente
On fait distinction aussi entre smaphores compteurs et
smaphores binaires, mais ce derniers sont moins
puissants.
22
 Smaphores occups attendre
(busy waiting)
La faon la plus simple
dimplanter les smaphores. wait(S):
Utiles pour des situations o while S<=0 {};
lattente est brve, ou il y a S--;
beaucoup dUCTs
S est un entier initialis une
Attend si no. de processus qui
valeur positive, de faon que
un premier processus puisse peuvent entrer = 0 ou ngatif
entrer dans la SC
Quand S>0, jusqu n
processus peuvent entrer
Quand S<=0, il faut attendre signal(S):
S+1 signals (dautres S++;
processus) pour entrer

Augmente de 1 le no des processus

qui peuvent entrer
23
Atomicit

Wait: La squence test-

dcrment est atomique,
mais pas la boucle! V
S <= 0
Signal est atomique. F
atomique S--
Rappel: les sections atomiques ne
peuvent pas tre excutes
simultanment par diffrent processus

(ceci peut tre obtenu en utilisant un des SC

mcanismes prcdents)

24
 Atomicit et interruptibilit
SC
interruptible S++ autre Pro.
V
S <= 0
F

atomique S--

SC
La boucle nest pas atomique pour permettre un autre processus
dinterrompre lattente sortant de la SC
25
Utilisation des smaphores pour sections critiques

Pour n processus
processus Ti:
Initialiser S 1
repeat
Alors 1 seul processus wait(S);
peut tre dans sa SC SC
Pour permettre k signal(S);
processus dexcuter SR
SC, initialiser S k forever

26
 Initialise S >=1

processus T1: processus T2:

repeat repeat
wait(S); wait(S);
SC SC
signal(S); signal(S);
SR SR
forever forever

Semaphores: vue globale

Peut tre facilement gnralis plus. processus

27
 Utilisation des smaphores pour
synchronisation de processus

On a 2 processus : Synchronisation
T1 et T2 correcte lorsque T1
nonc S1 dans T1 contient:
doit tre excut S1;
avant nonc S2 signal(S);
dans T2
Dfinissons un et que T2 contient:
smaphore S wait(S);
Initialiser S 0 S2;

28
 Interblocage et famine avec
les smaphores
Famine: un processus peut ne jamais arriver
sexcuter car il ne teste jamais le
smaphore au bon moment
Interblocage: Supposons S et Q initialiss 1
T0 T1
wait(S)
wait(Q)

wait(Q) wait(S)

29
 Smaphores: observations
wait(S):
Quand S >= 0: while S<=0 {};
S--;
Le nombre de processus qui peuvent
excuter wait(S) sans devenir bloqus= S
S processus peuvent entrer dans la SC
noter puissance par rapport mcanismes dj vus
dans les solutions o S peut tre >1il faudra avoir un
2me sm. pour les faire entrer un la fois (excl.
mutuelle)
Quand S devient > 1, le processus qui entre
le premier dans la SC est le premier tester
S (choix alatoire)
ceci ne sera plus vrai dans la solution
suivante
Quand S < 0: le nombre de processus qui
attendent sur S est = |S| 30
 Comment viter lattente occupe et le
choix alatoire dans les smaphores
Quand un processus doit attendre quun
smaphore devienne plus grand que 0, il est
mis dans une file dattente de processus qui
attendent sur le mme smaphore.
Les files peuvent tre PAPS (FIFO), avec
priorits, etc. Le SE contrle l`ordre dans
lequel les processus entrent dans leur SC.
wait et signal sont des appels au SE comme
les appels des oprations dE/S.
Il y a une file dattente pour chaque
smaphore comme il y a une file dattente
pour chaque unit dE/S.
31
 Smaphores sans attente
occupe
Un smaphore S devient une structure de donnes:
Une valeur
Une liste dattente L
Un processus devant attendre un smaphore S, est
bloqu et ajout la file dattente S.L du smaphore (v. tat
bloqu = attente chap 4).

signal(S) enlve (selon une politique juste, ex:

PAPS/FIFO) un processus de S.L et le place sur la liste
des processus prts/ready.

32
 Implementation
(les botes rprsentent des squences non-
non-interruptibles)

wait(S): S.value --;

if S.value < 0 { // SC occupe

add this processus to S.L;

block // processus mis en tat attente (wait)

signal(S): S.value ++;

if S.value 0 { // des processus attendent

remove a process P from S.L;

wakeup(P) // processus choisi devient prt
}

S.value doit tre initialis une valeur non-

ngative (dpendant de lapplication, v. exemples)
33
 Wait et signal contiennent elles mmes
des SC!

Les oprations wait et signal doivent tre

excutes atomiquement
Dans un systme avec 1 seule UCT, ceci
peut tre obtenu en inhibant les
interruptions quand un processus excute
ces oprations
Lattente occupe dans ce cas ne sera pas
trop onreuse car wait et signal sont brefs

34
 Problmes classiques de
synchronisation

Tampon born (producteur-consommateur)

crivains - Lecteurs
Les philosophes mangeant

35
Le pb du producteur - consommateur

Un problme classique dans l tude des

processus communicants
un processus producteur produit des donnes
(p.ex.des enregistrements d un fichier) pour un
processus consommateur

36
 Tampons de communication

Prod Prod

1 donn 1 donn 1 donn 1 donn

Cons Cons

Si le tampon est de longueur 1, le producteur et consommateur

doivent forcement aller la mme vitesse
Des tampons de longueur plus grandes permettent une certaine
indpendance. P.ex. droite le consommateur a t plus lent 37
 Le tampon born (bounded buffer)
une structure de donnes fondamentale dans les SE

in: 1re
b[0] b[1] pos. libre b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7]
b[7] b[2]

b[6] b[3] ou
in: 1re out: 1re
b[5] b[4] pos. libre pos.
pleine
out: 1re bleu: plein, blanc: libre
pos. pleine

Le tampon born se trouve dans la mmoire partage entre

consommateur et usager

38
 Problme de synchronisation entre
processus pour le tampon born

tant donn que le producteur et le

consommateur sont des processus
indpendants, des problmes pourraient
se produire en permettant accs simultan
au tampon
Les smaphores peuvent rsoudre ce
problme

39
 Smaphores: rappel.
Soit S un smaphore sur une SC
il est associ une file d attente
S positif: S processus peuvent entrer dans SC
S zro: aucun processus ne peut entrer, aucun processus en
attente
S ngatif: |S| processus dans file d attente
Wait(S): S - -
si aprs S >= 0, processus peut entrer dans SC
si S < 0, processus est mis dans file d attente
Signal(S): S++
si aprs S<= 0, il y avait des processus en attente, et un
processus est rveill
Indivisibilit = atomicit de ces ops

40
Solution avec smaphores
Un smaphore S pour exclusion mutuelle
sur laccs au tampon
Les smaphores suivants ne font pas lEM
Un smaphore N pour synchroniser
producteur et consommateur sur le
nombre dlments consommables dans le
tampon
Un smaphore E pour synchroniser
producteur et consommateur sur le
nombre despaces libres

41
 Solution de P/C: tampon circulaire fini de dimension k

Initialization: S.count=1; //excl. mut.

N.count=0; //esp. pleins
E.count=k; //esp. vides
append(v):
b[in]=v; Producer: Consumer:
In ++ mod k; repeat repeat
produce v; wait(N);
take(): wait(E); wait(S);
w=b[out]; wait(S); w=take();
Out ++ mod k; append(v); signal(S);
return w; signal(S); signal(E);
signal(N); consume(w);
forever forever

Sections critiques 42
Points importants tudier

dgts possibles en interchangeant les

instructions sur les smaphores
ou en changeant leur initialisation

Gnralisation au cas de plus. Producteurs

et consommateur

43
 Problme des lecteurs - rdacteurs

Plusieurs processus peuvent accder une

base de donnes
Pour y lire ou pour y crire
Les rdacteurs doivent tre synchroniss
entre eux et par rapport aux lecteurs
il faut empcher un processus de lire pendant
lcriture
il faut empcher deux rdacteurs d crire
simultanment
Les lecteurs peuvent y accder
simultanment

44
 Une solution (nexclut pas la famine)
Variable readcount: nombre de processus lisant la base
de donnes
Smaphore mutex: protge la SC o readcount est mis
jour
Smaphore wrt: exclusion mutuelle entre rdacteurs et
lecteurs
Les rdacteurs doivent attendre sur wrt
les uns pour les autres
et aussi la fin de toutes les lectures
Les lecteurs doivent
attendre sur wrt quand il y a des rdacteurs qui
crivent
bloquer les rdacteurs sur wrt quand il y a des
lecteurs qui lisent
redmarrer les rdacteurs quand personne ne lit45
 Les donnes et les rdacteurs

Donnes: deux smaphores et une variable

mutex, wrt: semaphore (init. 1);
readcount : integer (init. 0);

Rdacteur
wait(wrt);
. . .
// criture
. . .
signal(wrt);

46
 Les lecteurs
wait(mutex);
readcount ++ ;
if readcount == 1 then wait(wrt);
signal(mutex);
Le premier lecteur d un groupe pourrait
devoir attendre sur wrt, il doit aussi
bloquer les rdacteurs. Quand il sera
//SC: lecture entr, les suivants pourront entrer
librement

wait(mutex);
readcount -- ;
if readcount == 0 then signal(wrt);
signal(mutex):

Le dernier lecteur sortant doit permettre

l`accs aux rdacteurs
47
 Observations

Le 1er lecteur qui entre dans la SC bloque

les rdacteurs (wait (wrt)), le dernier les
remet en marche (signal (wrt))
Si 1 rdacteur est dans la SC, 1 lecteur
attend sur wrt, les autres sur mutex
un signal(wrt) peut faire excuter un lecteur
ou un rdacteur

48
Le problme des philosophes mangeant

5 philosophes qui
mangent et pensent
Pour manger il faut 2
fourchettes, droite et
gauche
On en a seulement 5!
Un problme classique
de synchronisation
Illustre la difficult
dallouer ressources aux
processus tout en vitant
interblocage et famine

49
Le problme des philosophes mangeant

Un processus par
philosophe
Un smaphore par processus Pi:
fourchette: repeat
fork: array[0..4] of think;
semaphores wait(fork[i]);
wait(fork[i+1 mod 5]);
Initialisation: fork[i ] =1
eat;
for i:=0..4
signal(fork[i+1 mod 5]);
Premire tentative: signal(fork[i]);
interblocage si chacun forever
dbute en prenant sa
fourchette gauche!
Wait(fork[i])

50
Le problme des philosophes mangeant

Une solution: admettre processus Pi:

seulement 4 philosophes la repeat
fois qui peuvent tenter de think;
manger wait(T);
Il y aura toujours au moins 1 wait(fork[i]);
philosophe qui pourra manger
wait(fork[i+1 mod 5]);
mme si tous prennent 1
fourchette eat;
Ajout dun smaphore T qui signal(fork[i+1 mod 5]);
limite 4 le nombre de signal(fork[i]);
philosophes assis la table signal(T);
initial. de T 4 forever
Nempche pas famine!

51
Avantage des smaphores
(par rapport aux solutions prcdentes)

Une seule variable partage par section

critique
deux seules oprations: wait, signal
contrle plus localis (que avec les
prcdents)
extension facile au cas de plus. processus
possibilit de faire entrer plus. processus la
fois dans une section critique
gestion de files d`attente par le SE: famine
vite si le SE est quitable (p.ex. files FIFO)

52
 Problme avec smaphores:
difficult de programmation

wait et signal sont disperss parmi

plusieurs processus, mais ils doivent se
correspondre
V. programme du tampon born
Utilisation doit tre correcte dans tous les
processus
Un seul mauvais processus peut faire
chouer toute une collection de processus
(p.ex. oublie de faire signal)
Considrez le cas d`un processus qui a
des waits et signals dans des boucles et
des tests... 53
Le problme de la SC en pratique...

Les systmes rels rendent disponibles

plusieurs mcanismes qui peuvent tre
utiliss pour obtenir la solution la plus
efficace dans diffrentes situations

54