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 mes-
sages. Un message de pàqtransite par le canal de pàq. On suppose que les processus exécutent un
algorithme tel que chaque processus a une variable locale T erpqui indique s’il a localement terminé, et tel
que pour cet algorithme chaque processus ppeut:
•S’il est dans l’état ¬T erpenvoyer un message à un autre processus
•S’il est dans l’état ¬T erpfinir son travail local et passer dans l’état T erp=T rue
•S’il est dans l’état T erpet 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 REDtla valeur de ce prédicat au temps tdans
cette exécution. On dit qu’un prédicat P RED est stable si et seulement si ∀t(P REDt=⇒ ∀t0> t :
P REDt0)
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àqest vide).CALV IDE est-il stable? (Prouvez-
le 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, p0est l’initiateur de l’algorithme: initialement, uniquement
T erp0est false. Le principe de cet algorithme est de maintenir un arbre de calcul de racine p0qui essen-
tiellement contient les processus actifs (un processus pest actif si T erp=T rue) Plus précisément, cet arbre
T=< ST, AT>a comme racine p0et vérifie:
•Test un arbre de racine p0(ou Test vide)
•A chaque instant STcontient exactement tous les processus actifs
Pour assurer ces propriétés, quand penvoie un message màq, si qn’était pas actif auparavant, pdevient le
père de q. Quand maintenant, qdevient inactif et qu’il n’a pas de descendant dans l’arbre, qest supprimé
de l’arbre. Si Ta bien les propriétés précédentes, il est clair que si p0est le seul élément de l’arbre et si
T erp0est vrai, alors T ER est vrai et on a bien détecté la terminaison.
Plus précisément l’arbre Test réparti et le processus pcorrespond au sommet pde T. Chaque processus
qmaintient une variable pereqqui indique le processus père de qpour T(nil s’il n’a pas de père), chaque
processus maintient aussi une variable N fils 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|perep6=nil}et AT={(p, perep)|perep6=nil}
Soient:
P1≡ ¬T erp=⇒p∈ST
P2≡NF ilsp=|{q|(q, p)∈AT}|
P3≡Test un arbre de racine p0
P4≡(T erp∧Nf ilsp= 0) =⇒p /∈ST
Soit P=P1∧P2∧P3∧P4.
1. Montrer qu’initialement, Pest vraie, et que si Pest vraie alors si un processus exécute Envoi,Re-
ception,Inactif et Fini (et possiblement un autre processus exécute les actions qui permettent l’une
de ces actions) alors Preste vrai. En déduire que pour toutes les exécutions Pest 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 pque p0,T erpest 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:
1Nf ilsp:= 0;
2if p=p0then perep0=p0else perep=nil
3if p=p0then T erp=F alse else T erp=T rue
Envoi:
4{¬T erp}
5send< m, p > to q
6recevoir< P ERE, b >
7if bthen Nf ils := N fils + 1
Reception:
8{message < m, q > présent }
9recevoir< 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 Nf ilsp= 0 then
16 if p=p0then 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 >;Nfilsp:= Nfilsp−1
21 if Nf ilsp= 0 ∧T erpthen
22 if p=p0then DET ECT E
23 else send< F IN I > to perep
24 perep=nil
Figure 1: Algorithme de détection synchrone.
3

L’arbre Tmaintenant contient aussi les messages en transit: quand un processus penvoie un message m
àq, le message est ajouté à l’arbre T(comme fils de p). Aussi, quand qreçoit m, le message mdoit être
retiré de T. Et quand un processus pdevient 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,pest une feuille), il est aussi retiré de
T. L’arbre sera donc représenté par la variable perepdu processus pqui indique le processus père de pdans
Tet un compteur cpqui compte le nombre de fils de p.
Pour résumé:
•Quand un processus preçoit un message de q, s’il n’a pas encore de père, qdevient 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 penvoie un message à q, il incrémente cp
•Quand preçoit un SIG il décrémente cp
•Quand pdevient 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|perep6=nil}∪{< m, p > est en transit }∪{< SIG, p > est en transit }
AT={(p, perep)|perep6=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≡Test 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 Qest un invariant du programme (Qest vrai initialement et si Qest vrai et un processus
exécute une des actions Envoi,Reception,Inactif ou SIG alors Qreste 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:
1cp:= 0;
2if p=p0then perep0=p0else perep=nil
3if p=p0then T erp=F alse else T erp=T rue
Envoi:
4{¬T erp}
5send< m, p > to q
6cp:= cp+ 1
Reception:
7{message < m, q > disponible}
8recevoir< m, q >;T erp:= F alse
9if 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=p0then 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=p0then DET ECT E
21 else send< SIG, perep>to perep
22 perep=nil
Figure 2: Algorithm de détection.
5