Devoir

Cours Algorithmique répartie
Master 2
Université Paris-Diderot
Devoir 1
(à rendre avant le 22 février 2010)
Détection de la terminaison distribuée
Généralités
Π = {p0 , . . . , pn−1 } est l’ensemble des processus. Les processus communiquent par envoi-réception de messages. Un message de p à q transite par le canal de p à q. On suppose que les processus exécutent un
algorithme tel que chaque processus a une variable locale T erp qui indique s’il a localement terminé, et tel
que pour cet algorithme chaque processus p peut:
• S’il est dans l’état ¬T erp envoyer un message à un autre processus
• S’il est dans l’état ¬T erp finir son travail local et passer dans l’état T erp = T rue
• S’il est dans l’état T erp et qu’il reçoit un message passer dans l’état T erp = F alse.
On ne connaît pas l’algorithme exécuté (qu’on appellera l’algorithme sous-jacent) on sait seulement qu’il
vérifie les règles précédentes.
Soit P RED un prédicat (par exemple un prédicat correspondant à la terminaison distribuée). Étant
donné une exécution de l’algorithme sous-jacent, on note P REDt la valeur de ce prédicat au temps t dans
cette exécution. On dit qu’un prédicat P RED est stable si et seulement si ∀t(P REDt =⇒ ∀t0 > t :
0
P REDt )
1. On suppose pour cette question que la communication est instantanée: il n’y a jamais de messages en
transit dans les canaux de communication. Soit T ER = (∀p ∈ Π : T erp = T rue) montrer que T ER
est stable.
2. On suppose maintenant que la communication n’est plus instantanée et que des messages peuvent être
en transit dans les canaux.
(a) T ER est-il stable? (Prouvez-le ou donnez un contre-exemple)
(b) Soit CALV IDE = (∀pq ∈ Π×Π : le canal de p à q est vide). CALV IDE est-il stable? (Prouvezle ou donnez un contre-exemple)
Soit T ERG = T ER∧CALV IDE. T ERG est-il stable? (Prouvez le ou donnez un contre-exemple)
Un algorithme de détection d’un prédicat P RED doit détecter si le prédicat P RED est vrai; plus précisément, il s’agit d’un algorithme distribué (son code s’exécute sur chaque processus) et on dira qu’il détecte
P RED si au cours de l’exécution au moins un des processus exécute l’action DET ECT E. Cet algorithme
doit vérifier:
• Non-interférence. L’algorithme de détection ne doit pas perturber l’algorithme que les processus exécutent.
1
• Sûreté. Si l’algorithme de détection détecte P RED alors P RED est vraie.
• Vivacité. Si dans l’algorithme sous-jacent P RED est vrai alors il existe un instant pour lequel
l’algorithme de détection détecte P RED.
Un algorithme avec communication instantanée
Dans toute cette section, on suppose que la communication est instantanée: les canaux de communications
sont toujours vides.
On va construire un algorithme de détection de la terminaison: c’est-à-dire un algorithme qui détecte le
prédicat T ER précédent. Dans cet algorithme, p0 est l’initiateur de l’algorithme: initialement, uniquement
T erp0 est false. Le principe de cet algorithme est de maintenir un arbre de calcul de racine p0 qui essentiellement contient les processus actifs (un processus p est actif si T erp = T rue) Plus précisément, cet arbre
T =< ST , AT > a comme racine p0 et vérifie:
• T est un arbre de racine p0 (ou T est vide)
• A chaque instant ST contient exactement tous les processus actifs
Pour assurer ces propriétés, quand p envoie un message m à q, si q n’était pas actif auparavant, p devient le
père de q. Quand maintenant, q devient inactif et qu’il n’a pas de descendant dans l’arbre, q est supprimé
de l’arbre. Si T a bien les propriétés précédentes, il est clair que si p0 est le seul élément de l’arbre et si
T erp0 est vrai, alors T ER est vrai et on a bien détecté la terminaison.
Plus précisément l’arbre T est réparti et le processus p correspond au sommet p de T . Chaque processus
q maintient une variable pereq qui indique le processus père de q pour T (nil s’il n’a pas de père), chaque
processus maintient aussi une variable N f ils qui compte le nombre de fils qu’il a dans T .
L’algorithme est décrit Figure 1.
Soit T =< ST , AT > l’arbre défini par: ST = {p|perep 6= nil} et AT = {(p, perep )|perep 6= nil}
Soient:
P1
≡
¬T erp =⇒ p ∈ ST
P2
≡
N F ilsp = |{q|(q, p) ∈ AT }|
P3
≡
T est un arbre de racine p0
P4
≡ (T erp ∧ N f ilsp = 0) =⇒ p ∈
/ ST
Soit P = P1 ∧ P2 ∧ P3 ∧ P4 .
1. Montrer qu’initialement, P est vraie, et que si P est vraie alors si un processus exécute Envoi, Reception, Inactif et Fini (et possiblement un autre processus exécute les actions qui permettent l’une
de ces actions) alors P reste vrai. En déduire que pour toutes les exécutions P est toujours vrai.
2. Montrer que l’algorithme vérifie bien la propriété de sûreté pour la détection de T ER
3. Montrer que l’algorithme vérifie bien la propriété de vivacité pour la détection de T ER
4. Est-ce que si initialement pour d’autres processus p que p0 , T erp est faux, l’algorithme est encore
correct? Si non proposez succinctement des idées pour une solution.
Un algorithme avec communication asynchrone
Dans cette partie on suppose que la communication est asynchrone: des messages peuvent être en transit
dans les canaux de communication. On cherche donc à détecter le prédicat T ERG.
2
Initialisations:
1
N f ilsp := 0;
2
if p = p0 then perep0 = p0 else perep = nil
3
if p = p0 then T erp = F alse else T erp = T rue
Envoi:
4
{¬T erp }
5
send< m, p > to q
6
recevoir< P ERE, b >
7
if b then N f ils := N f ils + 1
Reception:
8
{message < m, q > présent }
9
recevoir< m, q >; T erp := F alse
10
if perep == nil then
11
perep = q; send < P ERE, true > to q
12
else send< P ERE, f alse > to q
Inactif:
13
{¬T erp }
14
T erp := T rue
15
if N f ilsp = 0 then
16
if p = p0 then DET ECT E
17
else send< F IN I > to perep
18
perep = nil
Fini:
19
{message < F IN I > présent }
20
recevoir < F IN I >; N f ilsp := N f ilsp − 1
21
if N f ilsp = 0 ∧ T erp then
22
if p = p0 then DET ECT E
23
else send< F IN I > to perep
24
perep = nil
Figure 1: Algorithme de détection synchrone.
3
L’arbre T maintenant contient aussi les messages en transit: quand un processus p envoie un message m
à q, le message est ajouté à l’arbre T (comme fils de p). Aussi, quand q reçoit m, le message m doit être
retiré de T . Et quand un processus p devient inactif et (1) que tous les messages qu’il a émis ont été reçus
et (2) qu’il n’est le père d’aucun processus (ce qui signifie que dans T , p est une feuille), il est aussi retiré de
T . L’arbre sera donc représenté par la variable perep du processus p qui indique le processus père de p dans
T et un compteur cp qui compte le nombre de fils de p.
Pour résumé:
• Quand un processus p reçoit un message de q, s’il n’a pas encore de père, q devient son père. Sinon il
envoie un message SIG à q (pour l’informer que le message reçu n’est plus en transit).
• Quand un processus p envoie un message à q, il incrémente cp
• Quand p reçoit un SIG il décrémente cp
• Quand p devient inactif et cp = 0 il envoie SIG à son père et se retire de T .
L’algorithme se trouve Figure 2.
Pour prouver l’algorithme on va montrer que l’arbre construit par l’algorithme correspond bien à ce que
l’on suppose. Soit une configuration au cours d’une exécution de l’algorithme et T < ST , AT > le graphe
défini par:
ST = {p|perep 6= nil} ∪ {< m, p > est en transit } ∪ {< SIG, p > est en transit }
AT = {(p, perep )|perep 6= nil} ∪ {(< m, p >, p)| < m, p > est en transit} ∪ {(< SIG, p >, p)| < SIG, p >
est en transit}
Soient:
Q1
≡
¬T erp =⇒ p ∈ ST
Q2
≡
cp = |{q|(q, p) ∈ AT }|
Q3
≡
T est un arbre de racine p0
Q4
≡
(T erp ∧ cp = 0) =⇒ p ∈
/ ST
Q5
≡
(u, v) ∈ AT =⇒ u ∈ St ∧ v ∈ Π
Soit Q = Q1 ∧ Q2 ∧ Q3 ∧ Q4 ∧ Q5 .
1. Prouver que Q est un invariant du programme (Q est vrai initialement et si Q est vrai et un processus
exécute une des actions Envoi, Reception, Inactif ou SIG alors Q reste vrai.
2. En déduire que cet algorithme vérifie la propriété de sûreté pour la détection de T ERG .
3. Montrer que cet algorithme vérifie la propriété de vivacité pour la détection de T ERG.
4
Initialisations:
1
cp := 0;
2
if p = p0 then perep0 = p0 else perep = nil
3
if p = p0 then T erp = F alse else T erp = T rue
Envoi:
4
{¬T erp }
5
send< m, p > to q
6
cp := cp + 1
Reception:
7
{message < m, q > disponible}
8
recevoir< m, q >; T erp := F alse
9
if perep == nil then perep = q
10
else send< SIG, p > to q
Inactif:
11
{¬T erp }
12
T erp := T rue
13
if cp = 0 then
14
if p = p0 then DET ECT E
15
else send< SIG, perep > to perep
16
perep = nil
SIG:
17
{message < SIG, q > disponible}
18
recevoir < SIG, q >; cp := cp − 1
19
if cp = 0 then
20
if p = p0 then DET ECT E
21
else send< SIG, perep > to perep
22
perep = nil
Figure 2: Algorithm de détection.
5