We propose a general scheme, called Algorithm Scheme, to compute spanning-tree-like data structures on arbitrary networks. Scheme is self-stabilizing and silent and, despite its generality, is also efficient. It is written in the locally shared memory model with composite atomicity assuming the distributed unfair daemon, the weakest scheduling assumption of the model. Its stabilization time is in O(nmaxCC) rounds, where nmaxCC is the maximum number of processes in a connected component. We also

more »

... exhibit polynomial upper bounds on its stabilization time in steps and process moves holding for large classes of instantiations of Algorithm Scheme. We illustrate the versatility of our approach by proposing several such instantiations that efficiently solve classical problems. A self-stabilizing algorithm [1] is able to recover a correct behavior in finite time, regardless of the arbitrary initial configuration of the system, and therefore also after a finite number of transient faults, provided that those faults do not alter the code of the processes. Among the vast self-stabilizing literature, many works (see [2] for a survey) focus on spanning-tree-like constructions, i.e. constructions of specific distributed spanning tree-or forest-shaped data structures. Most of these constructions achieve an additional property called silence [3]: a silent self-stabilizing algorithm converges within finite time to a configuration from which the values of the communication registers used by the algorithm remain fixed. Silence is a desirable property. Indeed, as noted in [3], the silent property usually implies more simplicity in the algorithm design. Moreover, a silent algorithm may utilize less communication operations and communication bandwidth. Self-stabilizing spanning-tree-like constructions are widely used as a basic building block of more complex self-stabilizing solutions. Indeed, composition is a natural way to design self-stabilizing algorithms [4] since it allows to simplify both the design and proofs of self-stabilizing algorithms. Various composition techniques have been introduced so far, e.g., collateral composition [5], fair composition [6], cross-over composition [7] , and conditional composition [8]; and many self-stabilizing algorithms are actually made as a composition of a silent spanning-tree-like construction and another algorithm designed for tree/forest topologies, e.g., [9, 10, 11] . Notably, the silence property is not mandatory in such designs, however it allows to write simpler proofs [12] . Finally, notice that silent spanning-tree-like constructions have also been used to build very general results, e.g., the self-stabilizing proof-labeling scheme constructions proposed in [13] . We consider the locally shared memory model with composite atomicity introduced by Dijkstra [1], which is the most commonly used model in self-stabilization. In this model, executions proceed in (atomic) steps and the asynchrony of the system is captured by the notion of daemon. The weakest (i.e., the most general) daemon is the distributed unfair daemon. Hence, solutions stabilizing under such an assumption are highly desirable, because they work under any other daemon assumption. Moreover, the stabilization * This study has been partially supported by the anr projects Descartes (ANR-16-CE40-0023) and Estate (ANR-16-CE25-0009). This study has been carried out in the frame of "the Investments for the future" Programme IdEx Bordeauxcpu (ANR-10-IDEX-03-02). 13 Move complexity of Scheme Lemma 11. Let GC be a connected component of G, u ∈ GC, and seg be a GC-segment. If the size of SI seg,v is bounded by X for any process v ∈ GC, then the number of R U moves done by u in seg is bounded by X · (n maxCC − 1) + 1. Proof. First, assume that R U (u) is executed in some step γ → γ of seg and later in some other step γ → γ of seg. By Corollary 2, any sequence of R U (u) executions in seg makes the value of d u decrease. Therefore, all the values of d u obtained by the R U executions done by u are different. By definitions 10 and 11, all these values belong to the set v∈GC\{u} SI seg,v ∪ {distRoot(u)}, which has size at most X · (n maxCC − 1) + 1. By Theorem 2 and Lemma 11, we obtain the following result. Corollary 3. If the size of SI seg,v is bounded by X for any connected component GC, any process v ∈ GC, and any GC-segment seg, then the total number of moves during any execution, is bounded by (X · (n maxCC − 1) + 5) · (n maxCC + 1) · n. Combined with Lemma 10, this corollary already allows us to prove that Scheme always terminates and has a bounded move complexity. Corollary 4. Algorithm Scheme is silent self-stabilizing under the distributed unfair daemon and has a bounded move (and step) complexity. If all weights are strictly positive integers and ⊕ is the addition operator, then the size of any SI seg,u is bounded by W max (n maxCC −1) for all connected component GC, all GC-segment seg and all process u ∈ GC because S seg,u ⊆ [ds seg,u + 1, ds seg,u + W max (n cc − 1)], where n cc ≤ n maxCC is the number of processes in GC, and ds seg,u is the common (by Lemma 9) initiating value of the maximal causal chains of seg rooted at u. Hence, we deduce the following theorem from Lemma 1, Theorem 1, and Corollary 3. Theorem 3. Algorithm Scheme is silent self-stabilizing under the distributed unfair daemon and, when all weights are strictly positive integers and ⊕ is the addition operator, its stabilization time in moves (and steps) is at most (W max · (n maxCC − 1) 2 + 5) · (n maxCC + 1) · n. Lemma 12. Let GC be a connected component of G, v ∈ GC, and seg be GC-segment. If all edges have the same weight, then |SI seg,v | < n maxCC . Proof. Assume that all edges have the same weight w. According to Observation 4 and Lemma 8, we have SI seg,v ⊂ {ds seg,v ⊕ i.w | 1 ≤ i ≤ n maxCC − 1}, with ds seg,v being the common (by Lemma 9) initiating value of the maximal causal chains of seg rooted at v. By Corollary 3 and Lemma 12, we obtain the following result. Corollary 5. If all edges have the same weight, then the total number of moves (and steps) during any execution, is bounded by ((n maxCC − 1) 2 + 4) · (n maxCC + 1) · n.