Asynchronous Message-passing Model 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.

Characterization and Derivation of Heard-Of Predicates for Asynchronous Message-Passing Models

In distributed computing, multiple processes interact to solve a problem together. The main model of interaction is the message-passing model, where processes communicate by exchanging messages. Nevertheless, there are several models varying along important dimensions: degree of synchrony, kinds of faults, number of faults... This variety is compounded by the lack of a general formalism in which to abstract these models. One way to bring order is to constrain these models to communicate in rounds. This is the setting of the Heard-Of model, which captures many models through predicates on the messages sent in a round and received on time. Yet, it is not easy to define the predicate that captures a given operational model. The question is even harder for the asynchronous case, as unbounded message delay means the implementation of rounds must depend on details of the model. This paper shows that characterising asynchronous models by heard-of predicates is indeed meaningful. This characterization relies on delivered predicates, an intermediate abstraction between the informal operational model and the heard-of predicates. Our approach splits the problem into two steps: first extract the delivered model capturing the informal model, and then characterize the heard-of predicates that are generated by this delivered model. For the first part, we provide examples of delivered predicates, and an approach to derive more. It uses the intuition that complex models are a composition of simpler models. We define operations like union, succession or repetition that make it easier to derive complex delivered predicates from simple ones while retaining expressivity. For the second part, we formalize and study strategies for when to change rounds. Intuitively, the characterizing predicate of a model is the one generated by a strategy that waits for as much messages as possible, without blocking forever.

Asynchronous message-passing distributed algorithm for the global critical section problem

This paper considers the global $(l,k)$-CS problem which is the problem of controlling the system in such a way that, at least $l$ and at most $k$ processes must be in the CS at a time in the network. In this paper, a distributed solution is proposed in the asynchronous message-passing model. Our solution is a versatile composition method of algorithms for $l$-mutual inclusion and $k$-mutual exclusion. Its message complexity is $O(|Q|)$, where $|Q|$ is the maximum size for the quorum of a coterie used by the algorithm, which is typically $|Q| = \sqrt{n}$.

Communication-efficient randomized consensus

We consider the problem of consensus in the challenging classic model. In this model, the adversary is adaptive; it can choose which processors crash at any point during the course of the algorithm. Further, communication is via asynchronous message passing: there is no known upper bound on the time to send a message from one processor to another, and all messages and coin flips are seen by the adversary. We describe a new randomized consensus protocol with expected message complexity O( n^2 log ^2 n ) when fewer than n / 2 processes may fail by crashing. This is an almost-linear improvement over the best previously known protocol, and within logarithmic factors of a known Omega ( n^2 ) message lower bound. The protocol further ensures that no process sends more than O( n log ^3 n ) messages in expectation, which is again within logarithmic factors of optimal. We also present a generalization of the algorithm to an arbitrary number of failures t, which uses expected O( n t + t^2 log ^{2} t ) total messages. Our approach is to build a message-efficient, resilient mechanism for aggregating individual processor votes, implementing the message-passing equivalent of a weak shared coin. Roughly, in our protocol, a processor first announces its votes to small groups, then propagates them to increasingly larger groups as it generates more and more votes. To bound the number of messages that an individual process might have to send or receive, the protocol progressively increases the weight of generated votes. The main technical challenge is bounding the impact of votes that are still “in flight” (generated, but not fully propagated) on the final outcome of the shared coin, especially since such votes might have different weights. We achieve this by leveraging the structure of the algorithm, and a technical argument based on martingale concentration bounds. Overall, we show that it is possible to build an efficient message-passing implementation of a shared coin, and in the process (almost-optimally) solve the classic consensus problem in the asynchronous message-passing model.

Mutual inclusion in asynchronous message-passing distributed systems

In the mutual inclusion problem, at least one process is in the critical section. However, only a solution for two processes with semaphores has been reported previously. In this study, a generalized problem setting is formalized and two distributed solutions are proposed based on an asynchronous message-passing model. In the local problem setting (the local mutual inclusion problem), for each process P, at least one of P and its neighbors must be in the critical section. For the local problem setting, a solution is proposed with O(Δ) message complexity, where Δ is the maximum degree (number of neighboring processes) of a network. In a global setting (the global mutual inclusion problem), at least one of the processes must be in the critical section. For the global problem setting, a solution is proposed with O(|Q|) message complexity, where |Q| is the maximum size for the quorum of a coterie used by the algorithm, which is typically |Q|=n, where n is the number of processes in a network.

Ramos: Concurrent writing and reconfiguration for collaborative systems

Collaborative systems, with specific distributed systems allow multiple participants to work in a common virtual space, while reproducing the different ways to interact in a group. Such systems have to manage not only the sharing of context and particularly the context consistency, but also at the same time the fault tolerance. No system in the literature combines these two requirements.In this paper, we are proposing the new protocol Ramos which implements a fault-tolerant, and a context consistency (ensuring a total order of write operations) based on an asynchronous message-passing model. Communication takes place via gossip messages, which are sent at any frequency between a dynamic set of nodes. Ramos is based on the Rambo III algorithm for replicated data services. Rambo III provides two functions: reconfiguration of a dynamic set of nodes and reading/writing of a replicated object. In Ramos the reconfiguration process from Rambo III is adapted to the needs of collaborative systems and Paxos is used to execute concurrent write operations. It is assumed that from a total set of 2f+1 nodes, at most a subset of f nodes is allowed to fail simultaneously. Furthermore, it is assumed that the application using Ramos provides a leader-election method. Ramos, the algorithm proposed here, provides one significant feature: all write operations are totally ordered.

An Axiomatic Approach to Computing the Connectivity of Synchronous and Asynchronous Systems

We present a unified, axiomatic approach to proving lower bounds for the k-set agreement problem in both synchronous and asynchronous message-passing models. The proof involves constructing the set of reachable states, proving that these states are highly connected, and then appealing to a well-known topological result that high connectivity implies that set agreement is impossible. We construct the set of reachable states in an iterative fashion using a round operator that we define, and our proof of connectivity is an inductive proof based on this iterative construction and simple properties of the round operator.

Tight bounds for k-set agreement with limited-scope failure detectors

In a system with limited-scope failure detectors, there are q disjoint clusters of processes such that some correct process in each cluster is never suspected by any process in that cluster. The failure detector class Sx,q satisfies this property all the time, while ♦Sx,q satisfies it eventually. This paper gives the first tight bounds for the k-set agreement task in asynchronous message-passing models augmented with failure detectors from either the Sx,q or ♦Sx,q classes. For Sx,q, we show that any k-set agreement protocol that tolerates f failures must satisfy f < k+x-q if q < k and f < x otherwise, where x is the combined size of the q disjoint clusters if q < k (or the k largest, otherwise). This result establishes for the first time that the protocol of Mostefaoui and Raynal for the Sx = Sx,1 failure detector is optimal.For ♦Sx,q, we show that any k-set agreement protocol that tolerates f failures must satisfy f < min(n+1/2, k+x-q) if q < k and f < min(n+1/2,x) otherwise, where n + 1 is the total number of processes. We give a novel protocol that matches our lower bound, disproving a conjecture of Mostefaoui and Raynal for the ♦Sx = ♦Sx,1 failure detector.Our lower bounds exploit techniques borrowed from Combinatorial Topology, demonstrating for the first time that this approach is applicable to models that encompass failure detectors.

A Quorum-Based Self-Stabilizing Distributed Mutual Exclusion Algorithm

In this paper, we present a self-stabilizing quorum-based distributed mutual exclusion algorithm. Our algorithm is designed for an asynchronous message-passing model. The algorithm scales well since it has constant synchronization delay and its message complexity is proportional to the square root of the number of processes in the system. The algorithm tolerates message loss. The algorithm places few assumptions on timeouts needed for its implementation. All this allows for a ready implementation of the algorithm on practical distributed architectures.

Fundamentals of fault-tolerant distributed computing in asynchronous environments

Fault tolerance in distributed computing is a wide area with a significant body of literature that is vastly diverse in methodology and terminology. This paper aims at structuring the area and thus guiding readers into this interesting field. We use a formal approach to define important terms like fault, fault tolerance , and redundancy . This leads to four distinct forms of fault tolerance and to two main phases in achieving them: detection and correction . We show that this can help to reveal inherently fundamental structures that contribute to understanding and unifying methods and terminology. By doing this, we survey many existing methodologies and discuss their relations. The underlying system model is the close-to-reality asynchronous message-passing model of distributed computing.