Protocole

Le protocolePIR (cf. algorithmes 6.2.13 et 6.2.14) utilise les mˆemes m´ecanismes que le

proto-coleDFS2 (section 5.5, page 69). Donc, la preuve de la stabilisation instantan´ee du protocole PIR

est similaire `a celle deDFS2 (sous-section 5.5.2) et n’est pas pr´esent´ee dans cette th`ese (la preuve

compl`ete de ce protocole est disponible dans le rapport interne [CDV06c]). En fait, dans le protocole

PIR, nous avons juste remplac´e la phase de visite de DFS2 par une phase de P IR, elle-mˆeme

d´ecompos´ee en deux sous-phases : une phase de diffusion et une phase de retour. Les phases de diffusion et de retour sont ex´ecut´ees successivement mais les processeurs ex´ecutent ces phases en parall`ele comme montr´e dans la figure 6.1.1 et ce contrairement `a la phase de visite du protocole

DFS2 qui est ex´ecut´ee de mani`ere s´equentielle.

Le protocolePIR utilise 4 variables :

– Les variables P ar, Que et L ont un rˆole identique `a celles du protocole DFS2 : P ar est un

pointeur p`ere qui est affect´e lors de la phase de diffusion (le p`ere d’un processeur p = r est

le processeur par qui p a rec¸u le message), la variable Que g`ere les questions et la variable de niveau L permet de connaˆıtre la hauteur d’un processeur dans l’arbre couvrant construit par la phase de diffusion afin de casser les cycles possibles dˆus `a la variable P ar dans la configuration

124 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee initiale.

– La variable P IF , quant `a elle, remplace le pointeur de successeur S mais a un rˆole similaire : la variable P IF permet, comme S, de faire progresser un calcul issu de la racine mais de mani`ere parall`ele (alors que S fait progresser le calcul de mani`ere s´equentielle). P IF est d´efini pour chaque processeur comme suit : P IF_r ∈ {B,F ,P C,C} et P IFp ∈ {B,F ,P C,C,EB,EF }

pour p = r. P IFp = B (Broadcast) signifie que le processeur p participe `a une phase de

diffusion. P IF_p = F (Feedback) quand p est dans une phase de retour. Sp = C (Clean)

signifie que p ne participe `a aucun cycle de P IR. L’´etat P C (PreClean) est utilis´e lors de la phase de nettoyage comme dans le protocole DFS2. Enfin les ´etats EB (ErrorBroadcast)

et EF (ErrorFeedback) sont utilis´es pour le gel des processus anormaux lors de la phase de correction.

En utilisant les variables pr´ec´edemment d´ecrites, le protocole PIR fonctionne comme suit. `A la

suite d’une demande (ex´ecution de la r`egle IR, i.e., Request<sub>r</sub> := W ait), la racine ex´ecute sa r`egle

Bst (l’action de d´emarrage) en un temps fini. En ex´ecutant cette r`egle, r amorce la diffusion d’un

message m : P IFr passe de C `a B, une question est initi´e (Quer := Q) et la valeur In est affect´e `a

Request_r(pour signifier `a l’application que sa requˆete a ´et´e prise en compte).

Ensuite, les autres processeurs rec¸oivent le message m (r`egle Bst) lorsqu’ils ne participent `a aucun autre cycle de P IR (i.e., P IF = C) et qu’au moins un de leurs voisins est en train de diffuser le messsage (P IF = B). Lorsqu’un processeur p ex´ecute sa r`egle Bst, il passe dans une phase de diffusion (P IF<sub>p</sub> := B), initie une question par Que<sub>p</sub> := Q, d´esigne son p`ere avec P ar_p et finalement ´evalue sa hauteur dans sa variable de niveau Lp. Le processeur p est ensuite suppos´e diffuser le message m `a tous ses voisins sauf P arp. Ainsi, pas `a pas, la phase de diffusion progresse dans le r´eseau (sans attendre les r´eponses aux questions initi´ees). En particulier, cette phase construit dynamiquement un arbre couvrant enracin´e en r (d´efini par les variables P ar).

Toute phase de diffusion initi´ee par r est assur´ee d’atteindre tous les processeurs du r´eseau grˆace au m´ecanisme de questions. En fait, `a partir du moment o`u un processeur rec¸oit un message provenant de r, il reste dans la phase de diffusion tant qu’il n’a pas rec¸u confirmation par la phase de question que tous ses voisins sont dans la phase de diffusion de la racine (i.e. tant qu’il ne v´erifie pas CF ree et AnswerOk).

La phase de retour suit la phase de diffusion et est ex´ecut´ee `a partir des feuilles de l’arbre cou-vrant. Lorsque la diffusion atteint un processeur q tel que tous ses voisins ont d´ej`a rec¸u le message par d’autres processeurs, q attend la confirmation de la phase de question puis ex´ecute sa r`egle F ck : il passe de la phase de diffusion `a la phase de retour. La phase de retour est ensuite propag´ee dans l’arbre couvrant construit lors de la diffusion (en suivant les pointeurs p`eres) comme suit : un proces-seur interne de l’arbre ex´ecute sa r`egle F ck quand tous ses voisins ont rec¸u le message m (CF ree), il y est autoris´e par la phase de question (AnswerOk) et que tous ses fils dans l’arbre sont dans la phase de retour (BLeaf ). Ainsi, r est le dernier processeur `a ex´ecuter la phase de retour (r`egle F ck). Le cas ´ech´eant, r initie ensuite une phase de nettoyage (n.b. cette phase est identique `a la phase de nettoyage du protocole DFS2). Suite `a cette phase de nettoyage, r ex´ecute sa r`egle de terminaison T : r affecte Out `a Request_r pour signifier `a l’application que le P IR demand´e est termin´e. Apr`es cette derni`ere affectation, r attend la prochaine requˆete, i.e., le prochain message `a envoyer.

Enfin, nous rappelons que la phase de correction permet d’´eviter tout interblocage dans le syst`eme en supprimant les processus anormaux du syst`eme (n.b. la phase de correction reprend les mˆemes principes que la phase de correction deDFS2).

Nous allons maintenant rappeler des r´esultats formels sur le protocole PIR. Ces r´esultats ont ´et´e

publi´es dans [CDV06b]². Ils seront utilis´es dans la preuve de la stabilisation instantan´ee de notre transformateur,SSBB.

6.2 L’outil de base : le PIR 125

Algorithm 6.2.14 AlgorithmePIR pour p = r

Entr´ee : N eig_p: ensemble des voisins (localement ordonn´e) ;

Variables : P IF_p∈ {B,F ,P C,C,EB,EF } ; P ar_p∈ Neig_p; L_p∈ N ; Que_p∈ {Q,R,W ,A} ;

Macros :

Child_p = {q ∈ Neig_p:: (P IF_q = C) ∧ (P ar_q = p) ∧ (L_q = L_p+ 1)

∧ [(P IFq = P IFp)⇒ ((P IFp∈ {B,P C} ∧ P IFq = F ) ∨ (P IFp= EB))]} ;

P re P otential_p = {q ∈ Neigp:: P IFq = B } ;

P otential_p = {q ∈ Neigp:: ∀q∈ P re P otentialp, L_q ≤ Lq
} ;

Pr´edicats g´en´eraux :

CF ree(p) ≡ (∀q ∈ Neigp:: P IFq = C)

Leaf(p) ≡ [∀q ∈ Neigp:: (P IFq = C) ⇒ (P arq = p)]

BLeaf(p) ≡ (P IFp= B) ∧ [∀q ∈ Neigp:: (P arq = p) ⇒ (P IFq = F )]

AnswerOk(p) ≡ (Quep= A) ∧ [∀q ∈ Neigp:: (P IFq = C) ⇒ (Queq = A)]

GoodP IF(p) ≡ (P IFp= C) ∨ [(P IFP arp= P IFp)⇒ ((P IFP arp= EB)

∨ (P IFp= F ∧ P IFP arp∈ {B,P C}))]

GoodL(p) ≡ (P IFp= C) ⇒ (Lp= LP arp+ 1)

AbRoot(p) ≡ ¬GoodP IF (p) ∨ ¬GoodL(p)

Gardes :

EF AbRoot(p) ≡ (P IFp= EF ) ∧ AbRoot(p) ∧ [∀q ∈ Neigp:: (P arq=p ∧ Lq>L_p)⇒ (P IFq∈{EF ,C})] EBroadcast(p) ≡ (P IFp∈ {B,F ,P C}) ∧ [¬AbRoot(p) ⇒ (P IFP arp = EB)]

EF eedback(p) ≡ (P IFp= EB) ∧ [∀q ∈ Neigp:: (P arq = p ∧ Lq > L_p)⇒ (P IFq ∈ {EF ,C})] Broadcast(p) ≡ (P IFp= C) ∧ (P otentialp= ∅) ∧ Leaf(p)

F eedback(p) ≡ BLeaf(p) ∧ CF ree(p) ∧ AnswerOk(p)

P reClean(p) ≡ (P IFp= F ) ∧ (P IFP arp= P C) ∧ [∀q ∈ Neigp:: (P arq = p) ⇒ (P IFq ∈ {F ,C})]

Cleaning(p) ≡ (P IFp= P C) ∧ Leaf(p)

Require(p) ≡ (P IFp∈ {B,F }) ∧ [(P IFp= B) ⇒ CF ree(p)]

∧ [[(Quep= Q) ∧ (∀q ∈ Neigp:: (P IFq= C) ⇒ (Queq∈ {Q,R}))] ∨ [(Quep∈ {W ,A}) ∧ (∃q ∈ Neigp:: (P IFq = C) ∧ ((Queq= Q)

∨ (q ∈ Childp∧ Queq= R)))]]

W ait(p) ≡ (P IFp∈ {B,F }) ∧ [(P IFp= B) ⇒ CF ree(p)] ∧ (Quep= R) ∧ (QueP arp= R)

∧ (∀q ∈ Childp:: Queq ∈ {W ,A}) ∧ (∀q ∈ Neigp:: (P IFq= C) ⇒ (Queq= Q)) Answer(p) ≡ (P IFp∈ {B,F }) ∧ [(P IFp= B) ⇒ CF ree(p)] ∧ (Quep= W ) ∧ (QueP arp= A)

∧ (∀q ∈ Childp:: Queq ∈ {W ,A}) ∧ (∀q ∈ Neigp:: (P IFq= C) ⇒ (Queq= Q))

R`egles : Phase de Correction : EC :: EF AbRoot(p) → P IFp:= C ; EB :: EBroadcast(p) → P IFp:= EB ; EF :: EF eedback(p) → P IFp:= EF ; Phase de PIR :

Bst :: Broadcast(p) → P IF_p:= B ; P ar_p:= min_≺p(P otential_p) ;

L_p:= L_{P arp}+ 1 ; Que_p:= Q ; F ck :: F eedback(p) → P IF_p:= F ; P C :: P reClean(p) → P IFp:= P C ; C :: Cleaning(p) → P IFp:= C ; Phase de Question : QR :: Require(p) → Que_p:= R ; QW :: W ait(p) → Que_p:= W ; QA :: Answer(p) → Quep:= A ;

126 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee