Self-stabilizing Protocol Research Articles

Resource efficient stabilization for local tasks despite unknown capacity links

Self-stabilizing protocols enable distributed systems to recover correct behavior starting from any arbitrary configuration. In particular, when processors communicate by message passing and the communication links are unbounded, fake messages may be placed in communication links by an adversary. When the number of such fake messages is unknown, self-stabilization may require huge resources:•generic solutions (a.k.a. data link protocols) require unbounded resources, which makes them unrealistic to deploy,•specific solutions (e.g., census or tree construction) require O(nlog⁡n) or O(Δlog⁡n) bits of memory per node, where n denotes the network size and Δ its maximum degree, which may prevent scalability.We investigate the possibility of resource-efficient self-stabilizing protocols in this context.Specifically, we present self-stabilizing protocols for (Δ+1)-coloring and maximal independent set construction in any n-node graph, under the asynchronous message-passing model. The problems of (Δ+1)-coloring and maximal independent set construction are widely regarded as benchmark problems for evaluating local algorithms. Our protocols offer many desirable features. They are deterministic, converge in O(kΔn2log⁡n) message exchanges, where k is the (unknown) initial number of (possibly corrupted) messages in a communication link. They use messages of O(log⁡log⁡n+log⁡Δ) bits with a memory of O(Δlog⁡Δ+log⁡log⁡n) bits at each node. The resource consumption of our protocols is thus almost oblivious to the number of nodes, enabling scalability. Moreover, a striking property of our protocols is that the nodes do not need to know the number, or any bound on the number of messages initially present in each communication link of the initial (potentially corrupted) network configuration. This permits our protocols to handle any future network with unknown message capacity communication links.A key building block of our coloring and maximal independent set schemes is an algorithm to obtain an acyclic orientation of graph edges, that is of independent interest, and can serve as a useful tool for solving other tasks in this challenging setting.

Regular Abstractions for Array Systems

Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last two decades or so (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra's self-stabilizing protocol and the Chang-Roberts leader election protocol.

A combinatorial characterization of self-stabilizing population protocols

We characterize self-stabilizing functions in population protocols for complete interaction graphs. In particular, we investigate self-stabilization in systems of N finite state agents in which a malicious scheduler selects an arbitrary sequence of pairwise interactions under a global fairness condition. We show a necessary and sufficient condition for self-stabilization. Specifically we show that functions without certain set-theoretic conditions are impossible to compute in a self-stabilizing manner. Our main contribution is in the converse, where we construct a self-stabilizing protocol for all other functions that meet this characterization. Our positive construction uses Dickson's Lemma to develop the notion of the root set, a concept that turns out to fundamentally characterize self-stabilization in this model. We believe it may lend to characterizing self-stabilization in more general models as well.

Self-Stabilizing Population Protocols With Global Knowledge

In the population protocol model, many problems cannot be solved in a self-stabilizing manner. However, global knowledge, such as the number of nodes in a network, sometimes enables the design of a self-stabilizing protocol for such problems. For example, it is known that we can solve the self-stabilizing leader election in complete graphs if and only if every node knows the exact number of nodes. In this article, we investigate the effect of global knowledge on the possibility of self-stabilizing population protocols in arbitrary graphs. Specifically, we clarify the solvability of the leader election problem, the ranking problem, the degree recognition problem, and the neighbor recognition problem by self-stabilizing population protocols with knowledge of the number of nodes and/or the number of edges in a network.

A self-stabilizing Hashed Patricia Trie

While many research in distributed computing has covered solutions for self-stabilizing computing and topologies, there is far less work on self-stabilization for distributed data structures. However, when peers in peer-to-peer networks crash, a distributed data structure may not remain intact. We present a self-stabilizing protocol for a distributed data structure called the Hashed Patricia Trie (Kniesburges and Scheideler WALCOM'11) that enables efficient prefix search on a set of keys. The data structure has many applications while offering low overhead and efficient operations when embedded on top of a Distributed Hash Table. Especially, longest prefix matching for x can be done in O(log⁡|x|) hash table read accesses. We show how to maintain the structure in a self-stabilizing way, while assuring a low overhead in a legal state and an asymptotically optimal memory demand of Θ(d) bits, where d is the number of bits needed for storing all keys.

Parameterized synthesis of self-stabilizing protocols in symmetric networks

Self-stabilization in distributed systems is a technique to guarantee convergence to a set of legitimate states without external intervention when a transient fault or bad initialization occurs. Recently, there has been a surge of efforts in designing techniques for automated synthesis of self-stabilizing algorithms that are correct by construction. Most of these techniques, however, are not parameterized, meaning that they can only synthesize a solution for a fixed and predetermined number of processes. In this paper, we report a breakthrough in parameterized synthesis of self-stabilizing algorithms in symmetric networks, including ring, line, mesh, and torus. First, we develop cutoffs that guarantee (1) closure in legitimate states, and (2) deadlock-freedom outside the legitimate states. We also develop a sufficient condition for convergence in self-stabilizing systems. Since some of our cutoffs grow with the size of the local state space of processes, scalability of the synthesis procedure is still a problem. We address this problem by introducing a novel SMT-based technique for counterexample-guided synthesis of self-stabilizing algorithms in symmetric networks. We have fully implemented our technique and successfully synthesized solutions to maximal matching, three coloring, and maximal independent set problems for ring and line topologies.

Minimizing message size in stochastic communication patterns: fast self-stabilizing protocols with 3 bits

This paper considers the basic $${\mathcal {PULL}}$$ model of communication, in which in each round, each agent extracts information from few randomly chosen agents. We seek to identify the smallest amount of information revealed in each interaction (message size) that nevertheless allows for efficient and robust computations of fundamental information dissemination tasks. We focus on the Majority Bit Dissemination problem that considers a population of n agents, with a designated subset of source agents. Each source agent holds an input bit and each agent holds an output bit. The goal is to let all agents converge their output bits on the most frequent input bit of the sources (the majority bit). Note that the particular case of a single source agent corresponds to the classical problem of Broadcast (also termed Rumor Spreading). We concentrate on the severe fault-tolerant context of self-stabilization, in which a correct configuration must be reached eventually, despite all agents starting the execution with arbitrary initial states. In particular, the specification of who is a source and what is its initial input bit may be set by an adversary. We first design a general compiler which can essentially transform any self-stabilizing algorithm with a certain property (called “the bitwise-independence property”) that uses $$\ell $$ -bits messages to one that uses only $$\log \ell $$ -bits messages, while paying only a small penalty in the running time. By applying this compiler recursively we then obtain a self-stabilizing Clock Synchronization protocol, in which agents synchronize their clocks modulo some given integer T, within $$\tilde{\mathcal {O}}(\log n\log T)$$ rounds w.h.p., and using messages that contain 3 bits only. We then employ the new Clock Synchronization tool to obtain a self-stabilizing Majority Bit Dissemination protocol which converges in $$\tilde{\mathcal {O}}(\log n)$$ time, w.h.p., on every initial configuration, provided that the ratio of sources supporting the minority opinion is bounded away from half. Moreover, this protocol also uses only 3 bits per interaction.

Self-Stabilizing Byzantine Clock Synchronization with Optimal Precision

In the Byzantine-tolerant clock synchronization problem, the goal is to synchronize the clocks of n fully connected nodes. The clocks run at rates between 1 and \U0001d717 > 1, and messages have a delay (including computation) between d − U and d. Moreover, up to f < n/3 of the nodes can fail by deviating arbitrarily from the protocol, i.e., are Byzantine. Despite this interference, correct nodes need to generate distinguished events (or pulses) almost simultaneously and periodically. The quality of the solution is measured by the skew, which is the maximum real time difference between corresponding pulses. In the self-stabilizing setting, in addition we allow for transient failures, possibly of all nodes. Once transient faults have ceased and at most f nodes remain faulty, the system should start generating synchronized pulses again. We design a self-stabilizing solution to this problem with asymptotically optimal skew. We achieve our goal by refining and extending the protocol of Lynch and Welch and make the following contributions in the process.We give a simple analysis of the Lynch and Welch protocol with improved bounds on skew and tolerable difference in clock rates by rebuilding upon the main ingredient of their protocol, called approximate agreement.We give a modified version of the protocol so that the frequency and amount of communication between the nodes is reduced. The modification adds a step to adjust the clock rates by another application of approximate agreement. The skew bound achieved is asymptotically optimal for suitable choices of parameters.We present a method to add self-stabilization to the above protocols while preserving their skew bounds. The heart of the method is a coupling scheme that leverages a self-stabilizing protocol with a larger skew.

Compact deterministic self-stabilizing leader election on a ring: the exponential advantage of being talkative

This paper focuses on compact deterministic self-stabilizing solutions for the leader election problem. When the solution is required to be silent (i.e., when the state of each process remains fixed from some point in time during any execution), there exists a lower bound of \(\varOmega (\log n)\) bits of memory per participating node , where n denotes the number of nodes in the system. This lower bound holds even in rings. We present a new deterministic (non-silent) self-stabilizing protocol for n-node rings that uses only \(O(\log \log n)\) memory bits per node, and stabilizes in \(O(n\log ^2 n)\) rounds. Our protocol has several attractive features that make it suitable for practical purposes. First, it assumes an execution model that is used by existing compilers for real networks. Second, the size of the ring (or any upper bound on this size) does not need to be known by any node. Third, the node identifiers can be of various sizes. Finally, no synchrony assumption, besides weak fairness, is assumed. Our result shows that, perhaps surprisingly, silence can be traded for an exponential decrease in memory space without significantly increasing stabilization time or introducing restrictive assumptions.

Towards a universal approach for the finite departure problem in overlay networks

A fundamental problem for overlay networks is to safely exclude leaving nodes, i.e., nodes requesting to leave the network are excluded without affecting connectivity. There are numerous studies for safe node exclusion if the overlay is in a well-defined state, but almost no formal results for the self-stabilizing case. We study this problem in two variants: the Finite Departure Problem (FDP) and the Finite Sleep Problem (FSP). In the FDP leaving nodes have to irrevocably decide when it is safe to leave the network, whereas in the FSP, this leaving decision does not have to be final: the nodes may resume computation when woken up by an incoming message. We present self-stabilizing protocols for both problems that can be combined with a large class of overlay networks in order to guarantee safe exclusion for leaving nodes from any initial state while operating normal for staying nodes. 1

Shadow/Puppet Synthesis: A Stepwise Method for the Design of Self-Stabilization

This paper presents a novel two-step method for automated design of self-stabilization. The first step enables the specification of legitimate states and an intuitive (but imprecise) specification of the desired functional behaviors in the set of legitimate states (hence the term “shadow”). After creating the shadow specifications, we systematically introduce the main variables and the topology of the desired self-stabilizing system. Subsequently, we devise a parallel and complete backtracking search towards finding a self-stabilizing solution that implements a precise version of the shadow behaviors, and guarantees recovery to legitimate states from any state. To the best of our knowledge, the shadow/puppet synthesis is the first sound and complete method that exploits parallelism and randomization along with the expansion of the state space towards generating self-stabilizing systems that cannot be synthesized with existing methods. We have validated the proposed method by creating both a sequential and a parallel implementation in the context of a software tool, called Protocon. Moreover, we have used Protocon to automatically design three new self-stabilizing protocols that we conjecture to require the minimal number of states per process to achieve stabilization (when processes are deterministic): 2-state maximal matching on bidirectional rings, 5-state token passing on unidirectional rings, and 3-state token passing on bidirectional chains.

SMT-Based Synthesis of Distributed Self-Stabilizing Systems

A self-stabilizing system is one that guarantees reaching a set of legitimate states from any arbitrary initial state. Designing distributed self-stabilizing protocols is often a complex task and developing their proof of correctness is known to be significantly more tedious. In this article, we propose an SMT-based method that automatically synthesizes a self-stabilizing protocol, given the network topology of distributed processes and description of the set of legitimate states. Our method can synthesize synchronous, asynchronous, symmetric, and asymmetric protocols for two types of stabilization, namely weak and strong . We also report on successful automated synthesis of a set of well-known distributed stabilizing protocols such as Dijkstra’s token ring, distributed maximal matching, graph coloring, and mutual exclusion in anonymous networks.

SA-MAC: Self-Stabilizing Adaptive MAC Protocol for Wireless Sensor Networks

A common method of prolonging the lifetime of wireless sensor networks is to use low power duty cycling protocol. Existing protocols consist of two categories: sender-initiated and receiver-initiated. In this paper, we present SAMAC, a self-stabilizing adaptive MAC protocol for wireless sensor networks. SA-MAC dynamically adjusts the transmission time-slot, waking up time-slot, and packet detection pattern according to current network working condition, such as packet length and wake-up patterns of neighboring nodes. In the long run, every sensor node will find its own transmission phase so that the network will enter a stable stage when the network load and qualities are static. We conduct extensive experiments to evaluate the energy consumption, packet reception rate of SA-MAC in real sensor networking systems. Our results indicate that SA-MAC outperforms other existing protocols.

Fast, silent self-stabilizing distance-k independent dominating set construction

We propose a fast, silent self-stabilizing protocol building a distance-k independent dominating set, named FID. The convergence of the protocol FID is established for any computation under the unfair distributed scheduler. The protocol FID reaches a terminal (also legitimate) configuration in at most 4n+k rounds, where n is the network size; it requires (k+1)log(n+1) bits per node.

Self-stabilizing with service guarantee construction of 1-hop weight-based bounded size clusters

This paper makes contributions in two areas. First, we introduce an extended approach of self-stabilization, called self-stabilization with service guarantee. A self-stabilizing system tolerates transient faults: it automatically recovers to a correct behavior after a stabilization period. However, during stabilization periods, no property on the system behavior is guaranteed. A self-stabilizing protocol with service guarantee quickly provides a useful minimal service, and it maintains the minimal service during stabilization despite the occurrence of some disruptions. To illustrate our approach, we propose a clustering protocol (called SG-BSC), that builds 1-hop, bounded size and weight based clusters. SG-BSC protocol is self-stabilizing with service guarantee: it quickly reaches, in 4 rounds, a safe configuration from any arbitrary one. In a safe configuration, the following useful minimal service is provided: “each node belongs to a cluster, and each cluster has a leader and at most SizeBound ordinary nodes that are at most at distance 1 from their cluster-head”. The convergence to a legitimate configuration (optimum service) is done in at most 7∗N2+4 rounds, where N is the number of nodes. We prove that any self-stabilizing protocol building weight-based clusters requires O(N) rounds to stabilize. Once the optimum service is reached, any cluster-head has the highest weight in its cluster, and the number of clusters is locally optimal. During the stabilization period, the minimal service is preserved; so, the hierarchical organization stays available throughout the entire network. Simulation results show the interest of self-stabilization with service guarantee compared to self-stabilization.

Building self-stabilizing overlay networks with the transitive closure framework

Overlay networks are expected to operate in hostile environments where node and link failures are commonplace. One way to make overlay networks robust is to design self-stabilizing overlay networks, i.e., overlay networks that can handle node and link failures without any external supervision. In this paper, we first describe a simple framework, which we call the Transitive Closure Framework (TCF), for the self-stabilizing construction of an extensive class of overlay networks. Like previous self-stabilizing algorithms for overlay networks, TCF permits intermediate node degrees to grow to Ω(n), independent of the maximum degree of the target overlay network. However, TCF has several advantages over previous work in this area: (i) it is a “framework” and can be used for the construction of a variety of overlay networks (e.g. Linear, Skip+), not just a particular network, (ii) it runs in an optimal number of rounds for a variety of overlay networks, and (iii) it can easily be composed with other non-self-stabilizing protocols that can recover from specific bad initial states in a memory-efficient fashion. We demonstrate the power of our framework by deriving from TCF a simple self-stabilizing protocol for constructing Skip+ graphs [R. Jacob, A. Richa, C. Scheideler, S. Schmid, H. Täubig, A distributed polylogarithmic time algorithm for self-stabilizing skip graphs, in: PODC ’09: Proceedings of the 28th ACM symposium on Principles of distributed computing, ACM, New York, NY, USA, 2009, pp. 131–140] that guarantees optimal convergence time from any configuration.

A Lightweight Method for Automated Design of Convergence in Network Protocols

Design and verification of Self-Stabilizing (SS) network protocols are difficult tasks in part because of the convergence property that requires an SS protocol to recover to a set of legitimate states from any state in its state space. Once an SS protocol reaches a legitimate state, it remains in the set of legitimate states as long as there are no faults, called the closure property. Distribution issues exacerbate the design complexity of SS protocols as processes should collaborate and take local actions that result in global convergence. Most existing design techniques are manual, and mainly focus on protocols whose global state can be corrected if the local states of all processes are corrected, called the locally correctable protocols. After manual design, an SS protocol has to be verified for closure and convergence. Previous work observes that verifying SS protocols is a harder problem than designing them as developers have to ensure the correctness of closure and convergence functionalities and their noninterference. An algorithmic method for the design of convergence generates protocols that are correct by construction, thereby eliminating the need for verification. In order to facilitate the design of SS protocols, this article presents a lightweight method for algorithmic addition of convergence to finite-state nonstabilizing protocols, including nonlocally correctable protocols. The proposed method enables the reuse of design efforts in the development of different self-stabilizing protocols. Moreover, for the first time (to the best of our knowledge), this article presents an algorithmic method for the addition of convergence to symmetric protocols that consist of structurally similar processes. The proposed approach is supported by a software tool that automatically adds convergence to nonstabilizing protocols. We have used the proposed method/tool to automatically generate several self-stabilizing protocols with up to 40 processes (and 3 40 states) in a few minutes on a regular PC. Surprisingly, our tool has synthesized both protocols that are the same as their manually designed versions as well as alternative solutions for well-known problems in the literature (e.g., Dijkstra’s token ring, maximal matching, graph coloring, agreement and leader election in a ring). Moreover, the proposed method has helped us detect a design flaw in a manually designed self-stabilizing protocol.

On space complexity of self-stabilizing leader election in mediated population protocol

Chatzigiannakis et al. (Lect Notes Comput Sci 5734:56–76, 2009) extended the Population Protocol (PP) of Angluin et al. (2004) and introduced the Mediated Population Protocol (MPP) by introducing an extra memory on every agent-to-agent communication link (i.e., edge), in order to model more powerful networks of mobile agents with limited resources. For a general distributed system of autonomous agents, Leader Election (LE) plays a key role in their efficient coordination. A Self-Stabilizing (SS) protocol has ideal properties required for distributed systems of huge numbers of not highly reliable agents typically modeled by PP or MPP; it does not require any initialization and tolerates a finite number of transient failures. Cai et al. (2009) showed that for a system of \(n\) agents, any PP for SS-LE requires at least \(n\) agent-states, and gave a PP with \(n\) agent-states for SS-LE. In this paper, we show, for a system of \(n\) agents, any MPP for SS-LE with 2 edge-states (i.e., 1 bit memory) on every edge requires at least \((1/2) \lg {n}\) agent-states, and give an MPP for SS-LE with \((2/3)n\) agent-states and 2 edge-states on every edge. Furthermore, we show that a constant number of edge-states on every edge do not help in designing an MPP for SS-LE with a constant number of agent-states, and that there is no MPP for SS-LE with 2 agent-states, regardless of the number of edge-states; the edge-state is not a complete alternative of the agent-state, although it can help in reducing the number of agent-states, when solving SS-LE.

Loosely-stabilizing leader election in a population protocol model

A self-stabilizing protocol guarantees that starting from any arbitrary initial configuration, a system eventually comes to satisfy its specification and keeps the specification forever. Although self-stabilizing protocols show excellent fault-tolerance against any transient faults (e.g. memory crash), designing self-stabilizing protocols is difficult and, what is worse, might be impossible due to the severe requirements. To circumvent the difficulty and impossibility, we introduce a novel notion of loose-stabilization, that relaxes the closure requirement of self-stabilization; starting from any arbitrary configuration, a system comes to satisfy its specification in a relatively short time, and it keeps the specification not forever but for a long time. To show the effectiveness and feasibility of this new concept, we present a probabilistic loosely-stabilizing leader election protocol in the Probabilistic Population Protocol (PPP) model of complete networks. Starting from any configuration, the protocol elects a unique leader within O(nNlogn) expected steps and keeps the unique leader for Ω(NeN) expected steps, where n is the network size (not known to the protocol) and N is a known upper bound of n. This result proves that introduction of the loose-stabilization circumvents the already-known impossibility result; the self-stabilizing leader election problem in the PPP model of complete networks cannot be solved without the knowledge of the exact network size.

A self-stabilizing 3-approximation for the maximum leaf spanning tree problem in arbitrary networks

The maximum leaf spanning tree (MLST) is a good candidate for constructing a virtual backbone in self-organized multihop wireless networks, but is practically intractable (NP-complete). Self-stabilization is a general technique that permits to recover from catastrophic transient failures in self-organized networks without human intervention. We propose a fully distributed self-stabilizing approximation algorithm for the MLST problem in arbitrary topology networks. Our algorithm is the first self-stabilizing protocol that is specifically designed to approximate an MLST. It builds a solution whose number of leaves is at least 1/3 of the maximum possible in arbitrary graphs. The time complexity of our algorithm is O(n 2) rounds.