Construction d’arbre couvrant en largeur

Dans un r´eseau enracin´e quelconque, un protocole de construction d’arbre couvrant en largeur calcule un arbre enracin´e Arbre(r) contenant tous les processeurs du r´eseau et tel que, ∀p ∈ V ,

la longueur du chemin ´el´ementaire de p `a r dans Arbre(r) est ´egale `a la distance entre p et r dans le r´eseau G (cf. chapitre A, page 159, pour les d´efinitions). Dans la suite, nous noterons BF ST C (i.e., Breath-First Spanning Tree Construction) la tˆache consistant `a construire un arbre couvrant en largeur du r´eseau enracin´e en r.

Plusieurs protocoles auto-stabilisants de construction d’arbre en largeur ont ´et´e propos´es dans la lit´erature : [AKY90, SS92, HC92, DIM93, Joh97]. Dans [AB98, DT01], les auteurs ont propos´e un

6.4 Applications 141

Algorithm 6.4.21 AlgorithmeBFS pour p = r

Entr´ee-sortie : Request_p∈ {W ait,In,Out} ;

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

Constantes : P_p=⊥ ; Levelp= 0 ;

Variable : Status_p∈ {C,R,F ,D} ;

Macros :

Init_p = Statusp:= C ;

Children_p = {q ∈ Neigp:: Statusq = C ∧ Pq= p} ;

Pr´edicats :

End(p) ≡ (Statusp= D)

Error(p) ≡ (Statusp= C) ∧ (∃q ∈ Neigp:: Statusq = C)

F inish(p) ≡ (∀q ∈ Childrenp:: Statusq = D)

N ewP hase(p) ≡ (Statusp= F ) ∧ [∀q ∈ Neigp:: (Statusq = C) ∧ (q ∈ Childrenp⇒ Statusq ∈ {B,D})]

Start(p) ≡ (Statusp= C) ∧ (∀q ∈ Neigp:: Statusq = C)

ROK(p) ≡ (Statusp= R) ∧ (∀q ∈ Childrenp:: Statusq ∈ {R,D})

F orward(p) ≡ Start(p) ∨ ROk(p)

R`egles :

Err :: Error(p) → Statusp:= D ;

N ew :: NewP hase(p) ∧ ¬F inish(p) → Statusp:= R ;

F wd :: F orward(p) → Statusp:= F ;

D :: NewP hase(p) ∧ F inish(p) → Statusp:= D ;

sch´ema d’algorithme g´en´eral permettant, entre autres, d’impl´ementer un protocole auto-stabilisant de construction d’arbre en largeur. Les protocoles propos´es dans [SS92, AB98, Joh97, DT01] fonc-tionnent avec un d´emon distribu´e in´equitable. Cependant, except´e [Joh97], tous ces articles pr´esentent des protocoles silencieux (cf. page 21). L’inconv´enient de telles solutions est qu’aucun processeur n’est capable de d´etecter la terminaison du protocole sans utiliser de m´ecanisme externe (par exemple, utiliser un protocole de d´etection de terminaison). Le protocole propos´e dans [Joh97] est un protocole `a vague auto-stabilisant. Dans ce protocole, chaque vague termine `a la racine. Cependant, comme ce protocole n’est pas instantan´ement stabilisant, la racine ne peut pas d´etecter quand le syst`eme v´erifie ses sp´ecifications. Donc, lorsqu’une vague termine `a la racine, la racine ne peut pas d´etecter si un arbre couvrant en largeur du r´eseau a ´et´e effectivement calcul´e durant la vague ou pas. Finalement, il faut noter que le “transformateur” propos´e dans [CDPV03] permet de construire un protocole `a vague instantan´ement stabilisant de construction d’arbre en largeur `a partir d’un protocole `a vague construit pour un environnement sans fautes (par exemple [AG85]). Un avantage important d’une telle solu-tion est que la racine est capable de d´etecter lorsqu’un arbre couvrant en largeur est disponible dans le r´eseau : d`es la terminaison de la premi`ere vague initi´ee. Cependant, avec ce transformateur, les solutions obtenues ne fonctionnent qu’au plus avec un d´emon faiblement ´equitable et peuvent ˆetre tr`es coˆuteuses en temps d’ex´ecution.

Nous proposons maintenant d’´ecrire un protocole `a vague instantan´ement stabilisant de construc-tion d’arbre couvrant en largeur foncconstruc-tionnant avec un d´emon distribu´e in´equitable. `A cet effet, nous proposons un protocole appel´eBFS et v´erifiant SSBB-F riendly(BF ST C,DUF ). Le code

de ce protocole (cf. algorithmes 6.4.21 et 6.4.22) est tr`es proche de la solution non-tol´erante aux pannes propos´ee par Awerbuch et Gallager dans [AG85]. Seuls les pr´edicats Error(p) peuvent poser probl`eme. Ils sont en fait tr`es facile `a d´eduire de l’algorithme de base.

Tout d’abord, nous montrons qu’il existe une configuration `a partir de laquelleBFS construit un

arbre couvrant en largeur du r´eseau. Consid´erons la configuration γαo`u,∀p ∈ V , Statusp = C. Un

exemple d’ex´ecution deBFS `a partir de la configuration γα est montr´e dans la figure 6.4.5. `A partir de γ_α, BFS construit un arbre couvrant en largeur enracin´e en r par phases : durant la k`eme phase, tous les processeurs `a distance k de r s’accrochent `a l’arbre en construction. Puis, apr`es l’accrochage de ces processeurs, r d´etecte en un temps fini la terminaison de la phase et initialise une nouvelle

142 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee Algorithm 6.4.22 AlgorithmeBFS pour p = r

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

Variables : Status_p∈ {C,R,F ,B,D} ; Pp∈ Neigp; Level_p∈ N ;

Macros :

Init_p = Statusp:= C ;

Children_p = {q ∈ Neigp:: Statusq = C ∧ Pq = p} ;

P otential_p = {q ∈ Neigp:: Statusq = F } ;

Pr´edicats :

F inish(p) ≡ (∀q ∈ Childrenp:: Statusq= D)

Leaf(p) ≡ [∀q ∈ Neigp:: (Pq = p) ⇒ (Statusq ∈ {C,D})]

Hook(p) ≡ (Statusp= C) ∧ (∃q ∈ Neigp:: Statusq = F ) ∧ Leaf(p)

N ewP hase(p) ≡ (Statusp= B) ∧ (StatusPp= R) ∧ (∀q ∈ Childrenp:: Statusq∈ {B,D}) F orward(p) ≡ (Statusp= R) ∧ (StatusPp= F ) ∧ (∀q ∈ Childrenp:: Statusq ∈ {R,D})

Backtrack(p) ≡ (Statusp= F ) ∧ [∀q ∈ Neigp:: (Statusq= C) ∧ (q ∈ Childrenp⇒ Statusq ∈ {B,D})]

GoodR(p) ≡ (Status_p= R) ⇒ (Status_Pp∈ {R,F })

GoodF(p) ≡ (Status_p= F ) ⇒ (Status_Pp= F )

GoodB(p) ≡ (Statusp= B) ⇒ (StatusPp∈ {C,D})/

GoodL(p) ≡ (Statusp= C) ⇒ (Levelp= LevelPp+ 1)

Bad(p) ≡ (¬GoodR(p) ∨ ¬GoodF (p) ∨ ¬GoodB(p) ∨ ¬GoodL(p))

Error(p) ≡ (Statusp= D) ∧ Bad(p)

R`egles :

Err :: Error(p) → Statusp:=D ;

Hk :: Hook(p) → Statusp:=B ; Pp:=min≺p(P otential_p) ; Level_p:=LevelPp+1 ;

N ew :: NewP hase(p) → Statusp:=R ;

F wd :: F orward(p) → Statusp:=F ;

Bck :: Backtrack(p) ∧ ¬F inish(p) → Statusp:=B ;

D :: Backtrack(p) ∧ F inish(p) → Statusp:=D ;

phase si la construction n’est pas termin´ee. Au d´ebut de la 1`erephase (i.e., quand le syst`eme est dans

γ_α), la r`egle F wd de r est la seule r`egle activable du syst`eme. r initie donc le protocole en affectant

F `a Status<sub>r</sub> dans γ<sub>α</sub> → γα+1<sup>. Ensuite, la r`egle Hk de chaque voisin de r, p, devient activable.</sup>

En ex´ecutant la r`egle Hk, chaque processeur p s’accroche `a l’arbre de r : Status_p rec¸oit B, P_p pointe r et Levelp rec¸oit Levelr+ 1, i.e., 1. Quand tous les voisins de r ont rejoint l’arbre, r v´erifie

N ewP hase(r) ∧ ¬F inish(r), i.e., la 1`ere phase est termin´ee et r devient activable pour initier une nouvelle phase avec la r`egle N ew. r commence la 2^`eme phase par une r´einitialisation des variables

Status de son arbre : R est affect´e `a Status<sub>r</sub>. Ensuite, les voisins de r ex´ecutent aussi leur r`egle N ew pour propager la r´einitialisation. Quand tous les voisins de r ont affect´e R `a leur variable Status, r initie une nouvelle diffusion de la valeur F dans l’arbre (r`egle F wd) pour signifier aux processeurs `a distance 2 de la racine qu’ils doivent s’accrocher `a l’arbre. Quand un voisin de r, p, rec¸oit une valeur

F , deux cas sont alors possibles :

- p n’a aucun voisin `a distance 2 de la racine. Dans ce cas, p v´erifie Backtrack(p)∧F inish(p) et

affecte D `a Statusp via la r`egle D pour signifier que son sous-arbre est compl`etement calcul´e. - p a au moins un voisin, q, `a distance 2 de la racine. q rejoint alors l’arbre en s’accrochant `a un de ses voisins appartenant `a l’arbre et v´erifiant Status = F (r`egle Hk). Quand p d´etecte que tous ses voisins ont rejoint l’arbre, p affecte B `a Statusppar la r`egle Bck.

Quand tous les voisins de r ont affect´e B ou D `a leur variable Status, r d´etecte la fin de la 2<sup>`eme</sup>phase et devient activable pour initier une nouvelle phase. R´ecursivement, les autres phases fonctionnent comme suit. r est activable pour initier la k^`emephase (avec k > 2) quand Statusr = F ∧ ∀p ∈ Neigr,

Status_p ∈ {B,D}. La k`emephase commence par une r´einitialisation initi´ee par r (r`egle N ew). Quand

∀p ∈ Neigr, Status_p ∈ {R,D}, r initie une nouvelle diffusion de la valeur F dans l’arbre en

construction pour signifier au processeur `a distance k de la racine qu’ils doivent s’accrocher `a l’arbre. La valeur est diffus´ee dans l’arbre comme suit : quand un processeur a son p`ere dans l’arbre, Pq, tel

6.4 Applications 143 que StatusPq = F , q attend que tous ses fils dans l’arbre (s’il y en a) v´erifient Status ∈ {R,D}, et,

ensuite, diffuse la valeur F `a ses fils (cf. pr´edicat F orward(q)). Durant cette diffusion, un des deux cas suivants finit par apparaˆıtre dans chaque chemin de l’arbre :

- Une valeur F atteint un processeur p tel que tous ses fils dans l’arbre v´erifient Status = D (i.e., p v´erifie Backtrack(p)∧ F inish(p)). p affecte alors D `a Statusp(r`egle D) pour signifier que son sous-arbre est compl`etement construit.

- Une valeur F atteint une feuille f de l’arbre. Si f n’a aucun voisin `a distance k de la racine,

f v´erifie Backtrack(p) ∧ F inish(p) et affecte D `a Statusf par la r`egle D. Sinon, f a au moins un voisin, q, tel que q est `a distance k de r. Dans ce cas, chaque q rejoint l’arbre en s’accrochant `a un processeur de l’arbre v´erifiant Status = F (r`egle Hk). Quand f d´etecte que tous ses voisins sont dans l’arbre (i.e., f v´erifie Backtrack(f )∧ ¬F inish(f)), f affecte B `a Status_f par la r`egle Bck.

les valeurs B et D sont ensuite propag´ees dans l’arbre (via les r`egles Bck et D) et r finit par v´erifier `a nouveau Status_r = F ∧ ∀p ∈ Neigr, Status_p ∈ {B,D}. Dans ce cas, si ∃p ∈ Neigr tel que

Statusp = B, alors r initie une (k + 1)`emephase (r`egle N ew). Sinon, l’arbre couvrant est termin´e et

r affecte D `a Status<sub>r</sub>(r`egle D) pour signifier cette terminaison, i.e., un arbre couvrant en largeur du r´eseau est maintenant disponible.

D’apr`es la discussion pr´ec´edente, `a partir de γ_α, le protocoleBFS construit un arbre couvrant en

largeur par phases : durant la k<sup>`eme</sup>phase, tous les processeurs `a distance k de la racine s’accrochent `a l’arbre. Maintenant, par d´efinition, la hauteur d’un arbre couvrant en largeur est ´egale `a D o`u D est le diam`etre du r´eseau. Donc, `a partir γ_α,BFS ex´ecute exactement D phases pour construire l’arbre. De

plus, nous pouvons remarquer que chaque phase est r´ealis´ee en O(D) rondes et O(n) mouvements. D’o`u, le lemme suivant :

Lemme 6.4.7 `A partir de γ_α,BFS construit un arbre couvrant en largeur en O(D ×n) mouvements

et O(D²) rondes quel que soit le d´emon.

D’apr`es le lemme 6.4.7, nous savons que le protocoleBFS v´erifie le point 2 de la d´efinition SSBB-F riendly (d´efinition 6.1.3, page 121) avec un d´emon distribu´e in´equitable. Nous prouvons

main-tenant que le pr´edicat BFS.End(r) (d´efini dans l’algorithme 6.4.21) v´erifie BreakingIn(DUF )

(point 1 de la d´efinition SSBB-F riendly, page 121). Pour montrer que BFS.End(r) v´erifie la

propri´et´e BreakingIn(DU F ), il faut prouver que quelle que soit la configuration initiale (en par-ticulier, quand la configuration initiale est diff´erente de γ_α), BFS converge en un nombre fini de

mouvements vers une configuration terminale o`u BFS.End(r) est v´erifi´e (cf. cons´equence 6.1.1).

Le comportement du protocole BFS `a partir d’une configuration diff´erente de γα est le suivant : quand un processeur p d´etecte localement que le syst`eme n’est pas dans une configuration atteignable depuis γ_α, il affecte d´efinitivement D `a Status<sub>p</sub> par la r`egle Err qui est la r`egle la plus prioritaire deBFS. Ci-dessous, nous allons montrer que, grˆace `a la r`egle Err et mˆeme si le syst`eme d´emarre

d’une configuration diff´erente de γ_α, le syst`eme atteint une configuration terminale o`uBFS.End(r)

est v´erifi´e en un nombre fini de mouvements. Pour cela, nous allons utiliser le sch´ema de preuve suivant :

(i) Nous prouvons que toute ex´ecution de BFS contient un nombre fini de mouvements. (ii) Puis, nous montrons que BFS.End(r) est v´erifi´e dans toute configuration terminale.

Pour cela, nous allons utiliser les d´efinitions suivantes :

D´efinition 6.4.2 (CheminBFS(p)) Pour tout processeur p tel que Statusp = C, CheminBF S(p)

est l’unique chemin p₀, p₁, p₂, . . . p_k = p v´erifiant les conditions suivantes : 1. ∀i, 1 ≤ i ≤ k, Ppi = pi−1^.

144 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee r (Fwd) r F (Hk) (Hk) r F B B 1 1 (Bck) B B 1 1 r R (New) (New) 1 1 r R R R (Fwd) 1 1 r R R F (Fwd) (Fwd) 1 1 r F F F (Hk) (Hk) 1 1 r F F F B B 2 2 0 (D) (Bck) 1 1 r F B B 2 2 0 B D (New) 1 1 r B B 2 2 0 B D R (New) 1 1 r B B 2 2 0 D R R (New) (New) (Fwd) 1 1 r 2 2 0 D R F R R (Fwd) 1 1 r 2 2 0 D F R R F (Fwd) (Fwd) 1 1 r 2 2 0 D F F F F (D) (D) 1 1 r 2 2 0 D F F D D (D) 1 1 r 2 2 0 D F D D (D) D 1 1 r 2 2 0 D D D D D Pp Statusp Levelp D 1 (Fwd) Règle activable 0 0 0 0 0 0 0 (xiii) (xii) (xi) (x) (ix) (viii) (vii) (vi) (v) (iv) (iii) (ii) (i)

6.4 Applications 145

2. ∀i, 1 ≤ i ≤ k, (Statuspi = C) ∧ ¬Bad(pi). 3. (p₀ = r) ⇒ Bad(p₀).

D´efinition 6.4.3 (ArbreBFSp) Pour tout processeur p tel que (p = r) ∨ Bad(p), nous d´efinissons

l’ensemble de processeurs ArbreBF S_p de la mani`ere suivante : ∀q ∈ V , q ∈ ArbreBF Sp si et seulement si Statusq= C et p est l’extr´emit´e initiale de CheminBF S(q).

Remarque 6.4.1 Dans toute configuration atteignable `a partir de γ_α, nous avons∀p ∈ V , (Statusp

= C) ∨ (p ∈ ArbreBF Sr).

D´efinition 6.4.4 (TraceStatus) Soit Y un tuple de processeurs (Y = (p₀, p₁, . . ., p_k)). T

race-Status(Y ) = Status₀Status₁ . . . Status_kest la liste des valeurs de la variable Status des proces-seurs pi(i = 0 . . . k).

D’apr`es la d´efintion 6.4.2, seule l’extr´emit´e d’un CheminBF S peit v´erifi´e le pr´edicat Bad donc, nous d´eduisons le lemme suivant d’apr`es la d´efinition du pr´edicat Bad (cf. algorithme 6.4.22).

Lemme 6.4.8 ∀p ∈ V tel que Statusp = C, T raceStatus(CheminBF S(p)) ∈ F+_R∗_B∗_D∗ ∪ R⁺B^∗D^∗ ∪ D∗_.

Lemme 6.4.9 `A partir de n’importe quelle configuration initiale, BFS atteint une configuration

terminale en O(D× n) mouvements.

Preuve. Soit p ∈ V un processeur. Si Statusp = C, alors, apr`es avoir ex´ecut´e une r`egle (Hk

si p = r, F wd sinon), p v´erifie Statusp = C pour toujours. Ensuite, d`es que Statusp = D, p

n’est plus jamais activable. Donc, pour prouver ce lemme, nous allons montrer que chaque proces-seur p v´erifiant Status_p ∈ {C,D} ex´ecute O(D) r`egles avant d’ex´ecuter Status/ p := D, i.e., avant

d’ex´ecuter les r`egles D ou Err.

Soit p ∈ V tel que Statusp ∈ {R,F ,B} et q l’extr´emit´e initiale de CheminBF S(p). Deux cas

sont alors possibles :

a) q= r. Dans ce cas, p = r et nous ´etudions les trois possibilit´es suivantes :

1. Status_p = F . Alors, d’apr`es le lemme 6.4.8, T raceStatus(CheminBF S(p)) = F+ <sub>et</sub> p ne peut pas ex´ecuter de r`egle tant que¬Backtrack(p). Supposons donc que p finit par

v´erifier Backtrack(p). p peut alors uniquement ex´ecuter la r`egle Bck. En ex´ecutant Bck,

p affecte B `a Status_p, la valeur B remonte alors dans CheminBF S(p) et p n’est plus activable tant que Status_Pp = R. Or, ∀p
∈ CheminBF S(p), p
= r ∧ Statusp
= R et

r est le seul processeur capable de g´en´erer une valeur R. Donc, p ne peut plus ex´ecuter de

r`egle except´e les r`egles D ou Err. Ainsi, si Status_p = F , alors p peut au plus ex´ecuter

une r`egle avant d’ex´ecuter la r`egle D ou la r`egle Err.

2. Statusp=R. Alors, d’apr`es le lemme 6.4.8, T raceStatus(CheminBF S(p))=F∗_R+_.

– Supposons que Status_q= R. Alors, T raceStatus(CheminBF S(p)) = R+_{et p n’est}

pas activable tant que Status_Pp= F . Or, ∀p
∈ CheminBF S(p), p
= r ∧ Statusp
= F et r est le seul processeur capable de g´en´erer une valeur F . Donc, p n’ex´ecute plus

jamais de r`egle autre que les r`egles D ou Err.

– Supposons que Status_q = F . Alors, p n’est pas activable tant que Status_Pp = F .

Supposons que StatusPp finisse par ˆetre ´egale `a F . Alors, la r`egle F wd est la seule r`egle que p peut ex´ecuter. Si p ex´ecute la r`egle F wd, alors T

raceStatus(Chemin-BF S(p)) devient ´egal `a F+_{et nous retrouvons le cas 1.}

Ainsi, si Status_p = R, alors p peut ex´ecuter au plus deux r`egles avant d’ex´ecuter la r`egle

146 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee 3. Statusp = B. Alors, T raceStatus(CheminBF S(p)) ∈ F+_R∗_B+ ∪ R+_B+ _{d’apr`es le}

lemme 6.4.8.

– Supposons que T raceStatus(CheminBF S(p)) = F⁺R^∗B⁺. Si T

raceStatus(Che-minBF S(p)) = F+_R+_B+_{, alors les valeurs F et R descendent dans CheminBF S(p)}

par l’ex´ecution de r`egles N ew et F wd jusqu’`a ce que Status_p = F . Apr`es que p

ait ex´ecut´e ces deux r`egles, Statusp = F et nous retrouvons le cas 1. Si T

race-Status(CheminBF S(p)) = F⁺B⁺, alors p n’est plus activable tant que Status_Pp = R. Or, ∀p
∈ CheminBF S(p), p
= r ∧ Statusp
= R et r est le seul processeur

capable de g´en´erer une valeur R. Donc, p n’ex´ecute plus de r`egle avant d’ex´ecuter la r`egle D ou la r`egle Err.

– Supposons que T raceStatus(CheminBF S(p)) = R⁺B⁺. Dans ce cas, la valeur R descend dans CheminBF S(p) jusqu’`a ce que Statusp = R. Donc, p ex´ecute au plus

une r`egle N ew avant de v´erifier le cas 2.

Ainsi, si Status_p = B alors, p peut au plus ex´ecuter trois r`egles avant d’ex´ecuter la r`egle

D ou la r`egle Err.

D’o`u, si q= r, alors p peut au plus ex´ecuter trois r`egles avant d’ex´ecuter la r`egle D ou la r`egle Err.

b) q = r. Dans ce cas, d’apr`es la d´efinition 6.4.3, p ∈ ArbreBF Sr. Or, nous savons que

ArbreBF Srest contruit par phases.

– Si p = q = r (i.e., CheminBF S(p) contient un seul processeur), alors, dans le pire des cas, p participe `a toutes les phases. Or, pour chaque phase r ex´ecute une r`egle N ew et une r`egle F wd. De plus le nombre de phases ex´ecut´ees est born´e par D. Donc, si p = r, alors p ex´ecute O(D) r`egles avant d’ex´ecuter Statusp := D par la r`egle D.

– Sinon, p= r et, dans le pire des cas, p participe `a D−k phases compl`etes o`u k est la distance

de p `a r dans ArbreBF Sr. Or, `a chaque phase compl`ete o`u p participe, p ex´ecute une r`egle

N ew, une r`egle F wd et une r`egle Bck. Donc, si p = r, alors p ex´ecute O(D) r`egles avant

d’ex´ecuter Status_p := D par la r`egle D.

Ainsi, si q = r, alors p ex´ecute O(D) r`egles avant d’ex´ecuter Status<sub>p</sub> := D par la r`egle D.

D’o`u, ∀p ∈ V tel que Statusp ∈ {R,F ,B}, p ex´ecute O(D) r`egles avant d’ex´ecuter Statusp := D

(par la r`egle D ou Err) et le lemme est v´erifi´e. 

Lemme 6.4.10 Dans toute configuration terminale deBFS, r v´erifie BFS.End(r).

Preuve. Supposons, par contradiction, qu’il existe une configuration γ terminale o`uBFS.End(r)

n’est pas v´erifi´e. Par contradiction, Statusr = D dans γ (cf. d´efinition de BFS.End(r) dans

l’algo-rithme 6.4.21) et∀p ∈ V , p v´erifie ¬Error(p) (sinon, la r`egle Err de p est activable). Nous ´etudions

alors la configuration γ en fonction de ces deux cas :

1. Status_r = C dans γ. Comme nous avons ¬Error(r), r v´erifie Start(r) et la r`egle F wd de r

est activable. Donc, γ n’est pas une configuration terminale, contradiction.

2. Status_r = C dans γ. Dans ce cas, d’apr`es le lemme 6.4.8, ∀p ∈ ArbreBF Sr, T

race-Status(CheminBF S(p)) ∈ F+_R∗_B∗_D∗ ∪ R+_B∗_D∗∪ D∗_{. Soit p}∈ ArbreBF Sr.

a) Supposons que p = r, Statusp = B, et StatusPp = R dans γ. Alors, ∀q ∈ Childrenp,

Status_q ∈ {B,D} car q = r ∧ ¬Error(q) et la r`egle New de p est activable. Ainsi, γ

n’est pas une configuration terminale, contradiction.

b) Supposons que p = r, Statusp = R, et StatusPp = F dans γ. Alors, ∀q ∈ Childrenp,

Status_q ∈ {R,B,D} car q = r ∧ ¬Error(q).

– Si∃q ∈ Childrenp, Status_q = B alors, d’apr`es a), la r`egle New de q est activable et

6.4 Applications 147 – Sinon,∀q ∈ Childrenp, Statusq ∈ {R,D} et la r`egle F wd de p est activable. D’o`u, γ

n’est pas une configuration terminale, contradiction.

c) Supposons que Statusp = F dans γ. Sans perte de g´en´eralit´e, nous supposons que p

v´erifie Level_p = max({Levelq :: q ∈ ArbreBF Sr ∧ Statusq = F }). Alors, ∀q ∈

Childrenp, Statusq ∈ {R,B,D} car q = r∧¬Error(q). Si ∃q ∈ Childrenp, Statusq =

R, alors, d’apr`es b), q est activable dans γ et γ n’est pas une configuration terminale,

contradiction. Donc,∀q ∈ Childrenp, Status_q ∈ {B,D}.

– Supposons que ∀p
∈ Neigp, Statusp
= C. Si p = r, alors la r`egle New ou la r`egle D de p est activable, contradiction. Sinon (p = r), la r`egle Bck ou la r`egle D de p est

activable. Ainsi, γ n’est pas une configuration terminale, contradiction.

– Supposons que ∃p
∈ Neigp tel que Statusp
= C. Comme, ∀p

∈ Neigp
, (p

= r) ⇒ ¬Error(p

), p
_{v´erifie Leaf (p}
) et sa r`egle Hk est activable. Ainsi, γ n’est pas une

configuration terminale, contradiction.

D’o`u, par contradiction, a), b) et c) implique que∀p ∈ ArbreBF Sr, T

raceStatus(Chemin-BF S(p)) ∈ R+_D∗∪ D∗ _{dans γ. Or, comme nous avons suppos´e que Status}

r ∈ {C,D}, ∀p ∈/ ArbreBF S_r, T raceStatus(CheminBF S(p)) ∈ R+_D∗ _{avec, en particulier, Status}

r = R.

Comme∀p ∈ Childrenr, Status_p ∈ {R,D} (n.b. ∀p ∈ Childrenr, p = r ∧ ¬Error(p)), r

v´erifie aussi ROk(r) et la r`egle F wd de r est activable dans γ. Ainsi, γ n’est pas une configu-ration terminale, contradiction.

Ainsi, dans tous les cas, si Status_r = D i.e., si BFS.End(r) n’est pas satisfait, alors γ n’est pas une

configuration terminale et le lemme est v´erifi´e. 

D’apr`es les lemmes 6.4.9 et 6.4.10, le pr´edicatBFS.End(r) v´erifie les points 1 et 4 de la d´efinition

de BreakingIn (d´efinition 6.1.2, page 119) sous un d´emon distribu´e in´equitable. De plus, il est ´evident qu’`a partir de γ_α, BFS.End(r) est v´erifi´e seulement si un arbre couvrant en largeur est disponible

dans le r´eseau (point 2 de la d´efinition de BreakingIn, page 119). Finalement, d’apr`es les r`egles des algorithmes 6.4.21 et 6.4.22, nous pouvons d´eduire que BFS.End(r) v´erifie le point 3 de la

d´efinition de BreakingIn (d´efinition 6.1.2, page 119). D’o`u, le lemme suivant :

Lemme 6.4.11 BFS.End(r) v´erifie BreakingIn(DUF ).

D’apr`es les r`egles des algorithmes 6.4.21 et 6.4.22, nous pouvons d´eduire queBFS v´erifie le point

3 de la d´efinition de la propri´et´e SSBB-F riendly (d´efinition 6.1.3, page 121). D’o`u, d’apr`es les lemmes 6.4.7 et 6.4.11, nous avons :

Lemme 6.4.12 BFS v´erifie SSBB-F riendly(BF ST C,DUF ).

D’apr`es le lemme 6.4.12 et le th´eor`eme 6.3.4, nous avons :

Th´eor`eme 6.4.2 SSBB(BFS) est un protocole `a vague de construction d’arbre couvrant en largeur

instantan´ement stabilisant sous un d ´emon distribu´e in´equitable.

Nous pouvons remarquer que le code du protocoleBFS est tr`es similaire au code de la solution

non-tol´erante aux fautes de Awerbuch et Gallagher ([AG85]) et est plus simple que le code du protocole `a vague auto-stabilisant de Johnen ([Joh97]). L’analyse de complexit´e pr´esent´ee ci-dessous va montrer qu’en plusSSBB(BFS) est efficace.

148 De l’algorithmique non tol´erante aux fautes vers la stabilisation instantan´ee Analyse de complexit´e de SSBB(BFS). Nous commenc¸ons l’analyse de complexit´e avec le lemme suivant. Il permet d’´evaluer sera utilis´e la complexit´e du protocole SSBB(BFS) en nombre de

rondes.

Lemme 6.4.13 `A partir de n’importe quelle configuration initiale,BFS atteint une configuration

terminale en O(D²) rondes.

Preuve. D’apr`es le lemme 6.4.7, nous savons qu’`a partir de γα, le syst`eme atteint une configuration terminale en O(D<sup>2</sup>) rondes. Maintenant si la configuration initiale est diff´erente de γα, les corrections effectu´ees par les r`egles Err se font en parall`ele et `a chaque correction, le processeur corrig´e ne peut plus jamais participer `a aucune phase. Les corrections permettant ainsi d’´ecourter les phases, le pire des cas pour atteindre une configuration terminale correspond en fait `a une ex´ecution commenc¸ant

dans γ_α. D’`u, le lemme est v´erifi´e. 

D’apr`es le code des algorithmes 6.4.21 et 6.4.22, nous pouvons d´eduire que l’occupation m´emoire de BFS est O(log n) bits par processeur. Donc, d’apr`es le lemme 6.3.5, SSBB(BFS) a besoin de O(log n) bits par processeur. Consid´erons maintenant la complexit´e en temps. Le d´elai pour d´emarrer

un calcul d’arbre couvrant en largeur demand´e, `a partir de n’importe quelle configuration, est en

O(D² + n) rondes (d’apr`es le th´eor`eme 6.3.6 et les lemmes 6.4.7 et 6.4.13) et O(∆ × D × n4₎

mouvements (d’apr`es le th´eor`eme 6.3.7 et le lemme 6.4.9). Finalement, `a partir de n’importe quelle configuration, un calcul d’arbre couvrant en largeur complet est ex´ecut´e en O(D<sup>2</sup>+n) rondes (d’apr`es

le corollaire 6.3.6 et les lemmes 6.4.7 et 6.4.13) et O(∆× D × n4_{) mouvements (d’apr`es le corollaire}

6.3.7 et le lemme 6.4.9). Il faut cependant noter que le pire des cas de la complexit´e en nombre de mouvements deSSBB(BFS) correspond en fait `a la premi`ere ex´ecution, pour les autres ex´ecutions,

la complexit´e chute `a O(D×n) mouvements (cf. th´eor`eme 6.3.8 et lemme 6.4.7). Enfin, en moyenne,

le temps d’ex´ecution deSSBB(BFS) est en O(D2_{) rondes (cf. th´eor`eme 6.3.9 et lemme 6.4.7), i.e.,}

la complexit´e de la solution non-tol´erante aux pannes classique de Awerbuch et Gallager ([AG85]).

Dans le document Quelques Contributions à la Stabilisation Instantanée (Page 147-155)