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

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

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$

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

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

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

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

Set-Consensus Collections are Decidable

A natural way to measure the power of a distributed-computing model is to characterize the set of tasks that can be solved in it. In general, however, the question of whether a given task can be solved in a given model is undecidable, even if we only consider the wait-free shared-memory model. In this paper, we address this question for restricted classes of models and tasks. We show that the question of whether a collection C of (l, j)-set consensus objects, for various l (the number of processes that can invoke the object) and j (the number of distinct outputs the object returns), can be used by n processes to solve wait-free k-set consensus is decidable. Moreover, we provide a simple O(n^2) decision algorithm, based on a dynamic programming solution to the Knapsack optimization problem. We then present an adaptive wait-free set-consensus algorithm that, for each set of participating processes, achieves the best level of agreement that is possible to achieve using C. Overall, this gives us a complete characterization of a read-write model defined by a collection of set-consensus objects through its set-consensus power

La puissance de désaccord d'un adversaire

International audienceUn des résultats fondamentaux de l'algorithmique distribuée est que le niveau d'accord qui peut être obtenu en présence de $t$ pannes est exactement $t+1$. Autrement dit un adversaire qui peut mettre en panne n'importe quel sous ensemble d'au plus $t$ processus peut empêcher les autres processus de se mettre d'accord sur $t$ valeurs. Mais quelle est la puissance des ($2^{2^n} -n$) autres adversaires qui ne peuvent mettre en panne que certaines combinaisons des processus? Cet article présente une caractérisation précise d'un adversaire. On y introduit la notion de "puissance de désaccord". La puissance de désaccord d'un adversaire est le plus grand entier $k$ tel que l'accord des processus sur $k$ valeurs soit possible avec cet adversaire. Puis on montre comment {\em calculer} automatiquement cet entier pour un adversaire donné