Fault-Tolerant Consensus in Unknown and Anonymous Networks

This paper investigates under which conditions information can be reliably shared and consensus can be solved in unknown and anonymous message-passing networks that suffer from crash-failures. We provide algorithms to emulate registers and solve consensus under different synchrony assumptions. For this, we introduce a novel pseudo leader-election approach which allows a leader-based consensus implementation without breaking symmetry

On the Space Complexity of Set Agreement

The $k$-set agreement problem is a generalization of the classical consensus problem in which processes are permitted to output up to $k$ different input values. In a system of $n$ processes, an $m$-obstruction-free solution to the problem requires termination only in executions where the number of processes taking steps is eventually bounded by $m$. This family of progress conditions generalizes wait-freedom ($m=n$) and obstruction-freedom ($m=1$). In this paper, we prove upper and lower bounds on the number of registers required to solve $m$-obstruction-free $k$-set agreement, considering both one-shot and repeated formulations. In particular, we show that repeated $k$ set agreement can be solved using $n+2m-k$ registers and establish a nearly matching lower bound of $n+m-k$

Wait-Freedom with Advice

We motivate and propose a new way of thinking about failure detectors which allows us to define, quite surprisingly, what it means to solve a distributed task \emph{wait-free} \emph{using a failure detector}. In our model, the system is composed of \emph{computation} processes that obtain inputs and are supposed to output in a finite number of steps and \emph{synchronization} processes that are subject to failures and can query a failure detector. We assume that, under the condition that \emph{correct} synchronization processes take sufficiently many steps, they provide the computation processes with enough \emph{advice} to solve the given task wait-free: every computation process outputs in a finite number of its own steps, regardless of the behavior of other computation processes. Every task can thus be characterized by the \emph{weakest} failure detector that allows for solving it, and we show that every such failure detector captures a form of set agreement. We then obtain a complete classification of tasks, including ones that evaded comprehensible characterization so far, such as renaming or weak symmetry breaking

Syntax directed analysis of liveness properties of while programs

A syntax directed proof system which allows to prove liveness properties of while-programs is introduced. The proof system is proved to be arithmetically sound and complete in the sense of Harel (“Lecture Notes in Comput. Sci. Vol. 68,” Springer-Verlag, Berlin/New York, 1979). The results of the paper generalize a corresponding result Pneuli (“Prc. 18th Sympos. FOCS” IEEE, Providence, R. I., 1977) proves for unstructured programs. The proof system decomposes into two parts. The first part allows to prove simple safety properties. These properties are used as axioms in the second proof system which deals with liveness properties. The completeness proof is constructive and provides a heuristic for proving specific liveness properties

A separation of (n -1)-consensus and n-consensus in read-write shared-memory systems

A fundamental research theme in distributed computing is the comparison of systems in terms of their ability to solve basic problems such as consensus that cannot be solved in completely asynchronous systems. In particular, in a seminal work [14], Herlihy compares shared-memory systems in terms of the shared objects that they have: he proved that there are shared objects that are powerful enough to solve consensus among n processes, but are too weak to solve consensus among n + 1 processes; such objects are placed at level n of a wait-free hierarchy. The importance of this hierarchy comes from Herlihy's universality result: intuitively, every object at level n of this hierarchy can be used to implement any object shared by n processes in a wait-free manner. As in [14], we compare shared-memory systems with respect to their ability to solve consensus among n processes. But instead of comparing systems defined by the shared objects that they have, we compare readwrite systems defined by the process schedules that they allow. These systems capture a large set of systems, e.g., systems whose synchrony ranges from fully synchronous to completely asynchronous, several systems with failure detectors, and "obstruction-free" systems. In this paper, we consider read-write systems defined in terms of process schedules, and investigate the following natural question: For every n, is there a system of n processes that is strong enough to solve consensus among every subset of n -1 processes in the system, but not enough to solve consensus among all the n processes of the system? We show that the answer to the above question is "yes", and so these systems can be classified into hierarchy akin to Herlihy's hierarchy

Some New Results With k-set agreement

In this article, we investigate the solvability of $k$-set agreement among $n$ processes in distributed systems prone to different types of process failures. Specifically, we explore two scenarios: synchronous message-passing systems prone to up to $t$ Byzantine failures of processes. And asynchronous shared memory systems prone to up to $t$ crash failures of processes. Our goal is to address the gaps left by previous works\cite{SSS,AsynchKset} in these areas. For Byzantine failures case we consider systems with authentication where processes have unforgeable signatures. For synchronous message-passing systems, we present an authenticated algorithm that achieves $k$-set agreement in only two rounds, with no constraints on the number of faults $t$, with $k$ determined as $k \geq \lfloor \frac{n}{n-t} \rfloor + 1$. In fact the lower bound for $k$ is $k \geq \lfloor \frac{n}{n-t} \rfloor$ that is obtained by an algorithm based on traditional consensus with $t+1$ rounds. In asynchronous shared memory systems, we introduce an algorithm that accomplishes $k$-set agreement for values of $k$ greater than $\lfloor \frac{n-t}{n-2t} \rfloor +1$. This algorithm uses a snapshot primitive to handle crash failures and enable effective set agreement

Using Failure Detection and Consensus in the General Omission Failure Model to Solve Security Problems

It has recently been shown that fair exchange, a security problem in distributed systems, can be reduced to a fault tolerance problem, namely a special form of distributed consensus. The reduction uses the concept of security modules which reduce the type and nature of adversarial behavior to two standard fault-assumptions: message omission and process crash. In this paper, we investigate the feasibility of solving consensus in asynchronous systems in which crash and message omission faults may occur. Due to the impossibility result of consensus in such systems, following the lines of unreliable failure detectors of Chandra and Toueg, we add to the system a distributed device that gives information about the failure of other processes. Then we give an algorithm using this device to solve the consensus problem. Finally, we show how to implement such a device in a asynchronous untrusted environment using security modules and some weak timing assumptions

Accord et cohérence sans connaître le nombre de participants

On étudie ici trois problèmes classiques de la tolérance aux défaillances dans le cas où l'ensemble des processus est inconnu. Ces trois problèmes sont : le problème du consensus, l'implémentation de registres atomiques et l'élection ultime de leader. Pour cela on considère différents modèles. Dans le premier, la communication et les processus sont asynchrones, ces trois problèmes ne peuvent alors être résolus, mais on définit quels sont les détecteurs de défaillances minimaux pour ces problèmes. On considère ensuite un modèle où les processus et la communication sont synchrones, ce qui permet de réaliser des rondes synchronisées. Ici, les processus sont créés dynamiquement et peuvent avoir de défaillances de type “crash”. On montre que si que pour toute ronde r au moins un processus est vivant dans la ronde r et la suivante, le problème du consensus et de l'implémentation de registres peuvent être résolus. Le problème de l'élection de leader, qui est ici moins intéressant peut aussi être résolu. Entre ces deux extrêmes on s'intéresse au cas où les communications sont asynchrones, mais où un processus une fois créé est vivant pour toujours. Dans ce cas, si l'élection de leader est aisée, le consensus et l'implémentation de registres est impossible sauf à supposer l'existence d'un détecteur de défaillances () qui permet de réaliser un quorum. On considère enfin des modèles partiellement synchrones et on montre que le problème du consensus et de l'implémentation de registres peuvent être résolus s'il existe un processus tel que toutes les communications issues de ce processus sont synchrone

Asynchronous Consensus with Bounded Memory.

International audienceWe present here a bounded memory size Obstruction-Free consensus algorithm for the asynchronous shared memory model. More precisely for a set of n processes, this algorithm uses n+2n+2 multi-writer multi-reader registers, each of these registers being of size O(log(n))O(log⁡(n)) bits. From this, we get a bounded memory size space complexity consensus algorithm with single-writer multi-reader registers and a bounded memory size space complexity consensus algorithm in the asynchronous message passing model with a majority of correct processes. As it is easy to ensure the Obstruction-Free assumption with randomization (or with leader election failure detector ΩΩ) we obtain a bounded memory size randomized consensus algorithm and a bounded memory size consensus algorithm with failure detector

Asynchronous Consensus with Bounded Memory

We present here a bounded memory consensus Obstruction-Free algorithm for the asynchronous shared memory model. More precisely for a set of n processes, this algorithm uses n + 1 multi-writer multi-reader (MWMR) registers, each of these registers being of size O(log(n)) bits. Then we get a O(n log(n))-bits size complexity consensus algorithm with single-writer multi-reader (SWMR) registers and a O(n log(n))-bits complexity consensus algorithm in the asynchronous message passing model with a majority of correct processes. As it is easy to ensure the Obstruction-Free assumption with randomization (or with leader election failure detector) we obtain a bounded memory size randomized consensus algorithm and a bounded memory size consensus algorithm with failure detector