Fair and reliable self-stabilizing communication

Journal of Parallel and Distributed Computing, 2002

We define a finite-state message-passing model using guarded commands. This model is particularly appropriate for defining and reasoning about self-stabilizing protocols, due to the well-known result that self-stabilizing protocols on unbounded-channel models must have infinitely many legitimate states. We argue that our model is more realistic than other models, and demonstrate its use with a simple example. We conclude by discussing how self-stabilizing protocols defined on this model might be implemented directly on actual networks.

2009 29th IEEE International Conference on Distributed Computing Systems, 2009

Self-stabilization is a general paradigm to provide forward recovery capabilities to distributed systems and networks. Intuitively, a protocol is selfstabilizing if it is able to recover without external intervention from any catastrophic transient failure. In this paper, our focus is to lower the communication complexity of self-stabilizing protocols below the need of checking every neighbor forever. In more details, the contribution of the paper is threefold: (i) We provide new complexity measures for communication efficiency of self-stabilizing protocols, especially in the stabilized phase or when there are no faults, (ii) On the negative side, we show that for non-trivial problems such as coloring, maximal matching, and maximal independent set, it is impossible to get (deterministic or probabilistic) self-stabilizing solutions where every participant communicates with less than every neighbor in the stabilized phase, and (iii) On the positive side, we present protocols for coloring, maximal matching, and maximal independent set such that a fraction of the participants communicates with exactly one neighbor in the stabilized phase.

Proceedings 20th IEEE International Parallel & Distributed Processing Symposium, 2006

A distributed system is commonly modelled by a graph where nodes represent processors and there is an edge between two processors if and only if they can communicate directly. In shared-registers versions of this general description, neighbouring processors communicate by reading or writing shared registers, where each read or write is one atomic step. Variants of shared register models occur in the literature. This paper dened two models of shared registers determined by selecting the register locations. In the atomic-state model each processor has a register; in the atomic-link model, each communication link has a register.

2010

Abstract An implementation of self-stabilizing multiple-reader single writer atomic register in message passing system is presented. The implementation is based on a new combinatorial structure for bounded time stamps for which there exists a time-stamp greater than any arbitrary set (of a particular size) of time-stamps.

Lecture Notes in Computer Science, 2004

Davies and Wakerly show that Byzantine fault tolerance can be achieved by a cascade of broadcasts and middle value select functions. We present an extension of the Davies and Wakerly protocol, the unified protocol, and its proof of correctness. We prove that it satisfies validity and agreement properties for communication of exact values. We then introduce bounded communication error into the model. Inexact communication is inherent for clock synchronization protocols. We prove that validity and agreement properties hold for inexact communication, and that exact communication is a special case. As a running example, we illustrate the unified protocol using the SPIDER family of fault-tolerant architectures. In particular we demonstrate that the SPIDER interactive consistency, distributed diagnosis, and clock synchronization protocols are instances of the unified protocol.

Dijkstra: it is the property f o r a system t o eventually recover by itself a legitimate state after any perturbation modifying the m e m o r y state. This paper proposes a dynamic automatic selfstabilizing protocol. This algorithm runs i n the fully asynchronous message-passing model in which messages can also be corrupted. The principle of the algorithm is t o compute regularly a global state and if necessary t o generate a global reset. W h e n the system is stabilized, the message complexity is O(max(6 * m,n2)) where 6 is the degree of the communication graph, m the number of links and n the number of processus. This complexity allows a possable implementation.

Journal of Universal Computer Science, 2005

Abstract: In an ideal world, where we could guarantee instantaneous, atomic data transfer—whatever the type of the data being transferred—shared memory communication between two concurrent processes could be implemented directly using single variables or ...

SIAM Journal on Computing, 1997

Self-stabilizing message driven protocols are de ned and discussed. The class weakexclusion that contains many natural tasks such as `-exclusion and token-passing is dened, and it is shown that in any execution of any self-stabilizing protocol for a task in this class, the con guration size must grow at least in a logarithmic rate. This last lower bound is valid even if the system is supported by a time-out mechanism that prevents communication deadlocks. Then we present three self-stabilizing message driven protocols for token-passing. The rate of growth of con guration size for all three protocols matches the aforementioned lower bound. Our protocols are presented for two processor systems but can be easily adapted to rings of arbitrary size. Our results have an interesting interpretation in terms of automata theory.

2005

Awareness of the need for robustness in distributed systems increases as distributed systems become integral parts of day-to-day systems. Self-stabilizing while tolerating ongoing Byzantine faults are wishful properties of a distributed system. Many distributed tasks (e.g. clock synchronization) possess ecient non-stabilizing solutions tolerating Byzantine faults or conversely non-Byzantine but self-stabilizing solutions. In contrast, designing algorithms that self-stabilize while at the same time tolerating an eventual fraction of permanent Byzantine failures present a special challenge due to the ambition of malicious nodes to hamper stabilization if the systems tries to recover from a corrupted state. This diculty might be indicated by the remarkably few algorithms that are resilient to both fault models. We present the rst scheme that takes a Byzantine distributed algorithm and produces its self-stabilizing Byzantine counterpart, while having a relatively low overhead of O(f ) communication rounds, where f is the number of actual faults. Our protocol is based on a tight Byzantine self-stabilizing pulse synchronization procedure. The synchronized pulses are used as events for initializing Byzantine agreement on every node's local state. The set of local states is used for global predicate detection. Should the global state represent an illegal system state then the target algorithm is reset.

Journal of Computer and System Sciences, 2018

The virtual synchrony abstraction was proven to be extremely useful for asynchronous, large-scale, message-passing distributed systems. Self-stabilizing systems can automatically regain consistency after the occurrence of transient faults. We present the first practically-self-stabilizing virtual synchrony algorithm that uses a new counter algorithm that establishes an efficient practically unbounded counter, which in turn can be directly used for emulating a self-stabilizing Multiple-Writer Multiple-Reader (MWMR). Other self-stabilizing services include membership, multicast, and replicated state machine (RSM) emulation. As we base the latter on virtual synchrony, rather than consensus, the system can progress in more extreme asynchronous executions than consensus-based RSM emulations.