Exclusion mutuelle entre processus

1. EXCLUSION MUTUELLE
22/05/19 DIU 1/18

2. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
22/05/19 DIU 2/18

3. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
COA Compteur ordinal du processus A
COB Compteur ordinal du processus B
ACCA Accumulateur du processus A
ACCB Accumulateur du processus B
22/05/19 DIU 3/18

4. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
< A1, ?, 1, ?, B1 >
22/05/19 DIU 4/18

5. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
< A1, ?, 1, ?, B1 >
< A2, 2, 1, ?, B1 > < A1, ?, 1, 0, B2 >
22/05/19 DIU 5/18

6. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
< A1, ?, 1, ?, B1 >
< A2, 2, 1, ?, B1 > < A1, ?, 1, 0, B2 >
< A3, 2, 2, ?, B1 > < A2, 2, 1, 0, B2 > < A1, ?, 0, 0, B3 >
22/05/19 DIU 6/18

7. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
< A1, ?, 1, ?, B1 >
< A2, 2, 1, ?, B1 > < A1, ?, 1, 0, B2 >
< A3, 2, 2, ?, B1 > < A2, 2, 1, 0, B2 > < A1, ?, 0, 0, B3 >
< A3, 2, 2, 1, B2 > < A3, 2, 2, 0, B2 > < A2, 2, 0, 0, B3 > < A2, 1, 0, 0, B3 >
22/05/19 DIU 7/18

8. Graphes d'état
1. Alice en Bob sans verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
Processus A
A1 CHA X
ADD UN
A2 STO X
A3
Processus B
B1 CHA X
SUB UN
B2 STO X
B3
< COA, ACCA, X, ACCB, COB >
< A1, ?, 1, ?, B1 >
< A2, 2, 1, ?, B1 > < A1, ?, 1, 0, B2 >
< A3, 2, 2, ?, B1 > < A2, 2, 1, 0, B2 > < A1, ?, 0, 0, B3 >
< A3, 2, 2, 1, B2 > < A3, 2, 2, 0, B2 > < A2, 2, 0, 0, B3 > < A2, 1, 0, 0, B3 >
< A3, 2, 1, 1, B3 > < A3, 2, 0, 0, B3 > < A3, 2, 2, 0, B3 > < A3, 1, 1, 0, B3 >
22/05/19 DIU 8/18

9. 2. Verrouillage par Test And Set :
Imaginons 2 processus P1 et P2 partageant une ressource commune exclusive S gérée
par un verrou w pouvant prendre la valeur 0 (verrou ouvert) ou 1 (verrou fermé).
Une opération indivisible (c'est à dire qu'elle ne peut être exécutée que par un seul
processus à un instant donné) TAS (Test And Set) est associée à une cellule de mémoire
w :
TAS (w) : si w = 0 alors {w ← 1 ; CO ← CO + 1 }
Pour simplifier, imaginons d'abord que ces processus s'exécutent sur des machines
différentes ; ils possèdent donc leur propre contexte d'exécution (mémoire, compteur
ordinal, accumulateur, etc …) et peuvent s'exécuter en parallèle.
Bien entendu la ressource S et le verrou w sont situés sur un site ou au moins une
mémoire commune à P1 et P2.
On suppose qu'à l'état initial le valeur du verrou est w = 0 et que la cellule ZERO contient
la valeur 0.
Chacun des processus exécute la suite d'instructions ci-dessous :
P1 :
A1 TAS w
A2 SIN A1
. . .
A3 < section critique >
. . .
A4 CHA ZERO
A5 STO w
A6
P2 :
B1 TAS w
B2 SIN B1
. . .
B3 < section critique >
. . .
B4 CHA ZERO
B5 STO w
B6
Il est facile de constater que si les processus P1 et P2 s'exécutent en parallèle, et ce quel
que soit l'ordre des instructions TAS (qui elles sont obligées de s'exécuter
séquentiellement car elles sont indivisibles), P1 et P2 ne peuvent jamais se trouver en
même temps dans leur section critique.
Je vous laisse le soin de vérifier cette propriété.
Il faut aussi s'assurer qu'il n'y a pas d'interblocage. Vous vérifierez aussi facilement cette
seconde propriété.
Malheureusement, et vous pouvez le vérifier par l'exemple, ce mécanisme ne garantit pas
l'absence de famine, contrairement à l'algorithme de Dekker qui fait l'objet d'un exercice.
Supposons maintenant que P1 et P2 s'exécutent sur la même machine. Alors c'est le
système de gestion des processus de cette machine qui donnera alternativement le
contrôle à P1 et P2, donnant ainsi à une échelle de temps macroscopique (celle d'un
utilisateur) l'illusion que ces processus se déroulent en parallèle. On est donc ramené au
cas précédent.
22/05/19 DIU 9/18

10. 3. Alice en Bob avec verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
entier ZERO ← 0
entier w ← 0 verrou
Processus A
A0 TAS w
SIN A0
A1 CHA X
ADD UN
A2 STO X
CHA ZERO
A3 STO w
A4
Processus B
B0 TAS w
SIN B0
B1 CHA X
SUB UN
B2 STO X
CHA ZERO
B3 STO w
B4
< COA, ACCA, X, w, ACCB, COB >
22/05/19 DIU 10/18

11. 3. Alice en Bob avec verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
entier ZERO ← 0
entier w ← 0 verrou
Processus A
A0 TAS w
SIN A0
A1 CHA X
ADD UN
A2 STO X
CHA ZERO
A3 STO w
A4
Processus B
B0 TAS w
SIN B0
B1 CHA X
SUB UN
B2 STO X
CHA ZERO
B3 STO w
B4
< COA, ACCA, X, w, ACCB, COB >
< A0, ?, 1, 0, ?, B0 >
22/05/19 DIU 11/18

12. 3. Alice en Bob avec verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
entier ZERO ← 0
entier w ← 0 verrou
Processus A
A0 TAS w
SIN A0
A1 CHA X
ADD UN
A2 STO X
CHA ZERO
A3 STO w
A4
Processus B
B0 TAS w
SIN B0
B1 CHA X
SUB UN
B2 STO X
CHA ZERO
B3 STO w
B4
< COA, ACCA, X, w, ACCB, COB >
< A0, ?, 1, 0, ?, B0 >
< A1, ?, 1, 1, ?, B0 > < A0, ?, 1, 1, ?, B1 >
22/05/19 DIU 12/18

13. 3. Alice en Bob avec verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
entier ZERO ← 0
entier w ← 0 verrou
Processus A
A0 TAS w
SIN A0
A1 CHA X
ADD UN
A2 STO X
CHA ZERO
A3 STO w
A4
Processus B
B0 TAS w
SIN B0
B1 CHA X
SUB UN
B2 STO X
CHA ZERO
B3 STO w
B4
< COA, ACCA, X, w, ACCB, COB >
< A0, ?, 1, 0, ?, B0 >
< A1, ?, 1, 1, ?, B0 > < A0, ?, 1, 1, ?, B1 >
< A2, 2, 1, 1, ?, B0 > < A0, ?, 1, 1, 0, B2 >
< A3, 2, 2, 1, ?, B0 > < A0, ?, 0, 1, 0, B3 >
< A4, 2, 2, 0, ?, B0 > < A0, ?, 0, 0, 0, B4 >
22/05/19 DIU 13/18

14. 3. Alice en Bob avec verrou
Variables partagées
entier X ← 1 compte bancaire
entier UN ← 1
entier ZERO ← 0
entier w ← 0 verrou
Processus A
A0 TAS w
SIN A0
A1 CHA X
ADD UN
A2 STO X
CHA ZERO
A3 STO w
A4
Processus B
B0 TAS w
SIN B0
B1 CHA X
SUB UN
B2 STO X
CHA ZERO
B3 STO w
B4
< COA, ACCA, X, w, ACCB, COB >
< A0, ?, 1, 0, ?, B0 >
< A1, ?, 1, 1, ?, B0 > < A0, ?, 1, 1, ?, B1 >
< A2, 2, 1, 1, ?, B0 > < A0, ?, 1, 1, 0, B2 >
< A3, 2, 2, 1, ?, B0 > < A0, ?, 0, 1, 0, B3 >
< A4, 2, 2, 0, ?, B0 > < A0, ?, 0, 0, 0, B4 >
< A4, 2, 2, 1, ?, B1 > < A1, ?, 0, 1, 0, B4 >
< A4, 2, 2, 1, 1, B2 > < A2, 1, 0, 1, 0, B4 >
< A4, 2, 1, 1, 0, B3 > < A3, 0, 1, 1, 0, B4 >
< A4, 2, 1, 0, 0, B4 > < A4, 0, 1, 0, 0, B4 >
22/05/19 DIU 14/18

15. 4. Verrouillage avec d'autres instructions :
4.1 Avec une instruction d'échange mémoire
EXM X : M[X] ↔ ACC
On suppose qu'à l'état initial le valeur du verrou est w = 0, que la cellule ZERO contient la
valeur 0 et que la cellule UN contient la valeur 1.
P1 :
A0 CHA UN
A1 EXM w
A2 SSP A1
. . .
A3 < section critique >
. . .
A4 CHA ZERO
A5 STO w
P2 :
B0 CHA UN
B1 EXM w
B2 SSP B1
. . .
B3 < section critique >
. . .
B4 CHA ZERO
B5 STO w
4.2 Avec une instruction de lecture destructrice
CHD X : ACC ← M[X] ; M[X] ← 0
Attention ☛
Avec cette instruction, il faut inverser la signification du verrou :
w pouvant prendre la valeur 1 (verrou ouvert) ou 0 (verrou fermé).
On suppose donc qu'à l'état initial le valeur du verrou est w = 1.
P1 :
A1 CHD w
A2 SSZ A1
. . .
A3 < section critique >
. . .
A4 CHA UN
A5 STO w
P2 :
B1 CHD w
B2 SSZ B1
. . .
B3 < section critique >
. . .
B4 CHA UN
B5 STO w
22/05/19 DIU 15/18

16. 5. Algorithme de Dekker
Variables partagées
entier ZERO 0 { et aussi code de faux }
entier UN 1 { et aussi code de vrai }
entier DEUX 2
entier C1 0
entier C2 0
entier T 1
Processus A
A1 CHA UN
STO C1
A2 CHA C2
SSZ A7
A3 CHA T
SUB UN
SSZ A2
A4 CHA ZERO
STO C1
A5 CHA T
SUB DEUX
SSZ A5
A6 SIN A1
A7 .
section critique
.
A8 CHA DEUX
STO T
A9 CHA ZERO
STO C1
A10
Processus B
B1 CHA UN
STO C2
B2 CHA C1
SSZ B7
B3 CHA T
SUB DEUX
SSZ B2
B4 CHA ZERO
STO C2
B5 CHA T
SUB UN
SSZ B5
B6 SIN B1
B7 .
section critique
.
B8 CHA UN
STO T
B9 CHA ZERO
STO C2
B10
Preuve de l'algorithme :
En utilisant des invariants, pouvant inclure la valeur du compteur ordinal de chaque
processus (A1 à A10 pour P1 ; B1 à B10 pour P2), on demande de prouver que :
1*. Les sections critiques sont mutuellement exclusives
2**. Il n'y a pas d'interblocage, c'est à dire que si les processus P1 et P2 sont tous les
deux dans leur protocole de demande d'accès (A1 à A6 et B1 à B6), il ne peuvent pas y
rester bloqués indéfiniment
3***. Il n'y a pas de famine, c'est à dire qu'un processus demandant l'accès à sa section
critique verra sa demande satisfaite au bout d'un temps fini, moyennant l'hypothèse
d'équité entre processus (un processus prêt est élu pour devenir actif au bout d'un temps
fini) et en supposant que toute section critique termine et conduit à l'exécution du
protocole de fin d'accès (A8 à A9 pour P1 et B8 à B9 pour P2)
22/05/19 DIU 16/18

17. Invariants
Soit
«ai» la propriété : le compteur ordinal de P1 est en Ai
«bi» la propriété : le compteur ordinal de P2 est en Bi
«ci» la propriété : Ci = 1
[I1] = (a2 ∨ a3 ∨ a4 ∨ a7 ∨ a8 ∨ a9) ⇔ c1 est un invariant
[I2] = (b2 ∨ b3 ∨ b4 ∨ b7 ∨ b8 ∨ b9) ⇔ c2 est un invariant
Preuve
• vrai à l'état initial
• doit rester vrai quel que soit l'entrelacement possible des instructions des processus
Graphe d'état < COA, C1, T, C2, COB >
Nombre potentiel d'états : 10 x 2 x 2 x 2 x 10 = 800 !!!
On fait une projection sur : < COA, C1 >
< A1, 0 > < A7, 1 >
C2 = 0 section critique
< A2, 1 > < A8, 1 >
C2 = 1
T = 1
< A3, 1 > < A9, 1 > < A10, 0 >
T = 2
< A4, 1 >
T = 1
< A5, 0 > < A6, 0 >
en tenant compte des valeurs possibles de C2 et T
Preuve immédiate de I1 (idem pour I2)
Exclusion mutuelle : preuve
Le processus A n'atteint l'état A7 que si C2 = 0.
D'après [I2] le processus B ne peut être dans l'état B7.
De même :
Le processus B n'atteint l'état B7 que si C1 = 0.
D'après [I1] le processus A ne peut être dans l'état A7.
C.Q.F.D.
22/05/19 DIU 17/18

18. Non interblocage : preuve
Les processus A et B ne peuvent être interbloqués que quand ils sont simultanément :
• pour A entre A2 et A6 (bornes incluses)
• pour B entre B2 et B6 (bornes incluses)
T n'est modifié par aucune de ces instructions.
On suppose T = 1 ; le raisonnement sera identique pour T = 2.
Le processus A ne peut boucler qu'en (A2 → A3)* avec C2 = 1
simultanément, le processus B ne peut boucler qu'en (B5)* donc d'après [I2] C2 = 0
Ce qui est contradictoire
C.Q.F.D.
Non famine : preuve
A faire par le lecteur
Indication : commencer par prouver que les états :
< A8, C1=1, ?, C2=1, B9 > ou < A9, C1=1, ?, C2=1, B8 >
sont inaccessibles (indépendamment de la valeur de T)
Pour cela, construire le graphe des états précédents et prouver (récursivement) qu'aucun
de ces états n'est accessible
22/05/19 DIU 18/18