Efficient Self-Stabilizing Asynchronous Spanning Tree Algorithm

1. Time Optimal AsynchronousSelf-Stabilizing Spanning Tree Janna Burman and Shay Kutten Technion

2. Talk Overview • Model and Definitions • Contribution • The algorithm • Ideas adopted from [AKMPV-93] • Revising the algorithm

3. Node Fine-GrainedAsynchronousMessage Passing Modelrepresented by Graph = (V,E); |V| = n Arbitrary delivery time a c FIFO b Unique ID Bounded bandwidth BB = 1 packet (for simplicity) Time1only for time analysis Time=0 • Dynamic • Uniform • Decentralized

4. Definitions • Self-stabilizing algorithm • starting from arbitrary state, it reaches (and remains in) a legal global state (if there are no additional faults for “long enough”):Predicate(statea , stateb , statec …) • Stabilization time • maximum # of time units until the stabilization • Bound D • a known upper bound on the diameter of the network (used to bound the memory space;the time complexity of the alg. does not depend on D) • depth(v)- Maximum shortest path from v (“radius(v)”) • vmin - minimum ID node

5. Talk Overview • Model and Definitions • Contribution • The algorithm • Ideas adopted from [AKMPV-93] • Revising the algorithm

6. Contribution[this paper] Previous results [AKMPV-93] For the long list of the related work, please, refer the paper.

7. Talk Overview • Model and Definitions • Contribution • The algorithm • Ideas adopted from [AKMPV-93] • Revising the algorithm

8. Periodically exchanging message Base and Image Variables Previous work does not require this granularity varv varu[v] v u varv[u] varu

9. Talk Overview • Model and Definitions • Contribution • The algorithm • Ideas adopted from [AKMPV-93] • Revising the algorithm

10. The algorithm usesBellman-Ford’s algorithm distance estimate to r minimal ID seen so far Stabilization in O(D) r, d neighbor Bellman-Fordwithbound D[Arora, Gouda] at v u r minu{ ID, r[u] }: d[u]<D 1+minu{ d[u]: r = r[u]} , if r  ID 0 , if r = ID d  v

11. 1+min{di[u]: ri = ri[u]}, if ri ID 0 , if ri= ID di The algorithm runs logD+1versionsof Bellman-Ford’s algorithm node v refuses to assign todi a value larger than 2i r0, d0 r1, d1 logD+1 r2, d2 neighbor u Bellman-Ford version i ri, di rimin { ID,ri[u] }: di[u]<2i v rlogD, dlogD

12. Higher version 2i depth(vmin) Lower version 2i < depth(vmin) Version i stabilization vmin vmin in O(2i) time in (n) time

13. A lower version detects:tree does not yet span all nodes up_coverroot2 =0 up_cover bits up_coverroot1 = 0 0 0 0 Not one stab. tree 1 0 0 1 0 0 1 0 0 1 down_coverroot1 =0 down_coverroot2 =0 down_cover bits

14. Algorithm Output=minihigher (2i depth(vmin))version Higher versions 1 2i = D 1 2i> O(diam) 1 tree edges of min{ i }version such that down_coveri=1 v 1 2i~ O(diam) 1 output 1 2i< O(diam) 0 2i = 8 0 2i = 4 0 2i = 2 0 Stabilization in O(diameter) Lowerversions 2i = 0 0 down_coveri

15. Talk Overview • Model and Definitions • Contribution • The algorithm • Ideas adopted from [AKMPV-93] • Revising the algorithm

16. Definitions: In lower versionsfv exists for each node v Legal branchof v via u Shortest path (from u to v) with minimal ID parents foreign tov a v fv w u rfvv z Root var. Legal branchof v via fv

17. more Definitions: SPRIGs - exist in lower versions till (n) rv=x sprigs of v rv=v v r=v r=v r=v r=y r=v r=v Problem:Tree structure and up_cover values in sprigs are unstable  this can destabilize up_cover bits of adjacent trees and sprigs r=v r=v r=v r=v

18. We want the lower versionsdown_cover bits to stabilize to 0 in O(diameter)(to disqualify them)

19. Assume: • Lower version • Non-stabilized Tree X • The time is after the claimed stabilization time. Intuition: Why previous solution is too coarse grained Tree X sprig of v 0 down_coverv= 1 up_coverv=0 up_coverv=1 up_coverv=1 r v 1 dw = 3 down_coverbits instability u r=v w r=v v w1 r=v fv 1due to sprig 0 Root of X 1 1 Legal branch of v via fv Parent pointers in X

20. “Non-Stabilization Detector” down_coverv= 0 sprig of v up_coverv=0 u detects wunstable–the path from w to vis shorter through u(or u<w1) dw = 3 r v r=v u w r=v w1 r=v v fv Root of X 0 Legal branch of v via fv Parent pointers in X

21. Other problems fixed with: • Strict communication discipline • Strict communication discipline • Before a node v may change any of its base variables, all its neighbors “know ” the value of v’s base variables change “know ” • Local reset r[v] = x d[v] = y … rv = x dv = y … rv = z dv = w … v v r[v] = x d[v] = y … r[v] = x d[v] = y …

22. Other problems fixed with: • Local resetarmed with the discipline ensures • Whenever a node v changes its tree variables, no neighbor u considers v as its parent(so u does not mislead v’s up_cover) v u u u1 u1

23. Important algorithm properties • each time a node joins a tree or a sprig, it joins without any offspring • each node w that joins a tree rooted at v on a “legal branch of v via fv”, joins with up_cover = 0 Legal branch of v via fv Not one stab. tree up_coverw=0 fv v w

24. Time Complexity Analysis(intuition only)

25. Lower versions: down_cover = 0 stabilization on TREE s (a) TREE Legal branch of v via fv 0 foreign to v fv v w r v 0 0 up_coverw =0 in O(2i)time Not one stab. tree down_cover = 0 in O(2i)time

26. Old sprigs (and those split from old ones) Newly created sprigs Lower versions: down_cover = 0 stabilization on SPRIGs (b) Let us consider the time after the stabilization at trees v For each node:eitherdd+1at least each 2 time step, or it leaves the sprig r=v 0 r=vd 0 1 rv=u rv=v r=v r=v d 0 0 r=v 0 r=v d 1 r=v d r=v r=v 0 dd[parent]+1 0 down_cover=0 Disappear in at most 2*2i +1 time

27. Time Complexity Summary Lower version 2i < depth(vmin) • Trees: inO(2i) time, down_cover=0 • Sprigs: +(2*2i+1) time, down_cover=0 Higher version 2i depth(vmin) • InO(2i), down_cover=1 • And inO(diameter)in version with the minimum i O(diameter) stabilization time

28. Thank you!