Failure Detector Class Research Articles

Uniform reliable broadcast in anonymous distributed systems with fair lossy channels

Uniform reliable broadcast (URB) is an important abstraction in distributed systems, offering delivery guarantee when spreading messages between processes. Informally, URB guarantees that if a process (correct or not) delivers a message m, then all correct processes deliver m. This abstraction has been extensively investigated in distributed systems where all processes have unique identifiers. Furthermore, the majority of papers in the literature usually assume that the communication channels of the system are reliable, which is not always the case in real systems. In this paper, the URB abstraction is investigated in anonymous asynchronous message passing distributed systems with process crash failures and fair lossy channels. For that, we assume the availability of a random number generator that generates unique global values with very high probability. Firstly, a simple URB algorithm is given assuming a majority of correct processes. Then, we prove the impossibility of solving URB without a majority of correct processes if no failure detector is used. Subsequently, a new failure detector class $$A{\varTheta }$$ is proposed, which can be used to implement URB with any number of correct processes. However, the two previous URB algorithms are non-quiescent because every correct process, to offset the loss of messages caused by fair lossy channels, has to broadcast all URB $$\_$$ delivered messages forever. Hence, a perfect anonymous failure detector $$AP^*$$ is proposed, together with $$A{\varTheta }$$ , to make the URB algorithm quiescent. Finally, we discuss an alternative failure detector $$A{\varTheta }P^*$$ , which combines the properties of $$A{\varTheta }$$ and $$AP^*$$ .

Eventual election of multiple leaders for solving consensus in anonymous systems

In classical distributed systems, each process has a unique identity. Today, new distributed systems have emerged where a unique identity is not always possible to be assigned to each process. For example, in many sensor networks a unique identity is not possible to be included in each device due to its small storage capacity, reduced computational power, or the huge number of devices to be identified. In these cases, we have to work with anonymous distributed systems where processes cannot be identified. Consensus cannot be solved in classical and anonymous asynchronous distributed systems where processes can crash. To bypass this impossibility result, failure detectors are added to these systems. It is known that $$\varOmega $$Ω is the weakest failure detector class for solving consensus in classical asynchronous systems when a majority of processes never crashes. Although $${ A }\varOmega $$AΩ was introduced as an anonymous version of $$\varOmega ,$$Ω, to find the weakest failure detector in anonymous systems to solve consensus when a majority of processes never crashes is nowadays an open question. Furthermore, $${ A }\varOmega $$AΩ has the important drawback that it is not implementable. Very recently, $${ A }\varOmega '$$AΩ? has been introduced as a counterpart of $$\varOmega $$Ω for anonymous systems. In this paper, we show that the $${ A }\varOmega '$$AΩ? failure detector class is strictly weaker than $${ A }\varOmega $$AΩ (i.e., $${ A }\varOmega '$$AΩ? provides less information about process crashes than $${ A }\varOmega $$AΩ). We also present in this paper the first implementation of $${ A }\varOmega '$$AΩ? (hence, we also show that $${ A }\varOmega '$$AΩ? is implementable), and, finally, we include the first implementation of consensus in anonymous asynchronous systems augmented with $${ A }\varOmega '$$AΩ? and where a majority of processes does not crash.

Failure detectors in homonymous distributed systems (with an application to consensus)

This paper is on homonymous distributed systems where processes are prone to crash failures and have no initial knowledge of the system membership (“homonymous” means that several processes may have the same identifier). New classes of failure detectors suited to these systems are first defined. Among them, the classes HΩ and HΣ are introduced that are the homonymous counterparts of the classes Ω and Σ, respectively. (Recall that the pair 〈Ω,Σ〉 defines the weakest failure detector to solve consensus.) Then, the paper shows how HΩ and HΣ can be implemented in homonymous systems without membership knowledge (under different synchrony requirements). Finally, two algorithms are presented that use these failure detectors to solve consensus in homonymous asynchronous systems where there is no initial knowledge of the membership. One algorithm solves consensus with 〈HΩ,HΣ〉, while the other uses only HΩ, but needs a majority of correct processes.Observe that the systems with unique identifiers and anonymous systems are extreme cases of homonymous systems from which follows that all these results also apply to these systems. Interestingly, the new failure detector class HΩ can be implemented with partial synchrony (i.e., all messages sent after some bounded time GST will be received after at most an unknown bounded latency δ), while the analogous class AΩ defined for anonymous systems cannot be implemented (even in synchronous systems). Hence, the paper provides the first consensus algorithm for anonymous systems with this model of partial synchrony and a majority of correct processes.

Renaming and the weakest family of failure detectors

We address the question of the weakest failure detector to circumvent the impossibility of $$(2n-2)$$ -renaming in a system of up to $$n$$ participating processes. We derive that in a restricted class of eventual failure detectors there does not exist a single weakest oracle, but a weakest family of oracles $$\zeta _n$$ : every two oracles in $$\zeta _n$$ are incomparable, and every oracle that allows for solving renaming provides at least as much information about failures as one of the oracles in $$\zeta _n$$ . As a by product, we obtain one more evidence that renaming is strictly easier to solve than set agreement.

The Price of Anonymity

This article addresses the consensus problem in asynchronous systems prone to process crashes, where additionally the processes are anonymous (they cannot be distinguished one from the other: they have no name and execute the same code). To circumvent the three computational adversaries (asynchrony, failures, and anonymity) each process is provided with a failure detector of a class denoted ψ , that gives it an upper bound on the number of processes that are currently alive (in a nonanonymous system, the classes ψ and P ---the class of perfect failure detectors---are equivalent). The article first presents a simple ψ -based consensus algorithm where the processes decide in 2 t + 1 asynchronous rounds (where t is an upper bound on the number of faulty processes). It then shows one of its main results, namely 2 t + 1 is a lower bound for consensus in the anonymous systems equipped with ψ . The second contribution addresses early-decision. The article presents and proves correct an early-deciding algorithm where the processes decide in min(2 f + 2, 2 t + 1) asynchronous rounds (where f is the actual number of process failures). This leads us to think that anonymity doubles the cost (with respect to synchronous systems) and it is conjectured that min(2 f + 2, 2 t + 1) is the corresponding lower bound. The article finally considers the k -set agreement problem in anonymous systems. It first shows that the previous ψ -based consensus algorithm solves the k -set agreement problem in Rt = 2⌊t k⌋ + 1 asynchronous rounds. Then, considering a family of failure detector classes { ψℓ }0 ≤ ℓ < k that generalizes the class ψ (= ψ 0 ), the article presents an algorithm that solves the k -set agreement in Rt,ℓ = 2 ⌊ t k − ℓ ⌋ + 1 asynchronous rounds. This last formula relates the cost ( Rt,ℓ ) the coordination degree of the problem ( k ), the maximum number of failures ( t ), and the the strength ( ℓ ) of the underlying failure detector. Finally the article concludes by presenting problems that remain open.

Communication-efficient leader election in crash–recovery systems

Abstract This work addresses the leader election problem in partially synchronous distributed systems where processes can crash and recover. More precisely, it focuses on implementing the Omega failure detector class, which provides a leader election functionality, in the crash–recovery failure model. The concepts of communication efficiency and near-efficiency for an algorithm implementing Omega are defined. Depending on the use or not of stable storage, the property satisfied by unstable processes, i.e., those that crash and recover infinitely often, varies. Two algorithms implementing Omega are presented. In the first algorithm, which is communication-efficient and uses stable storage, eventually and permanently unstable processes agree on the leader with correct processes. In the second algorithm, which is near-communication-efficient and does not use stable storage, processes start their execution with no leader in order to avoid the disagreement among unstable processes, that will agree on the leader with correct processes after receiving a first message from the leader.

Communication-efficient failure detection and consensus in omission environments

Failure detectors have been shown to be a very useful mechanism to solve the consensus problem in the crash failure model, for which a number of communication-efficient algorithms have been proposed. In this paper we deal with the definition, implementation and use of communication-efficient failure detectors in the general omission failure model, where processes can fail by crashing and by omitting messages when sending and/or receiving. We first define a new failure detector class for this model in terms of completeness and accuracy properties. Then we propose an algorithm that implements a failure detector of the proposed class in a communication-efficient way, in the sense that only a linear number of links are used to send messages forever. We also explain how the well-known consensus algorithm of Chandra and Toueg can be adapted in order to use the proposed failure detector.

Communication-efficient and crash-quiescent Omega with unknown membership

The failure detector class Omega ( Ω) provides an eventual leader election functionality, i.e., eventually all correct processes permanently trust the same correct process. An algorithm is communication-efficient if the number of links that carry messages forever is bounded by n, being n the number of processes in the system. It has been defined that an algorithm is crash-quiescent if it eventually stops sending messages to crashed processes. In this regard, it has been recently shown the impossibility of implementing Ω crash quiescently without a majority of correct processes. We say that the membership is unknown if each process p i only knows its own identity and the number of processes in the system (that is, i and n), but p i does not know the identity of the rest of processes of the system. There is a type of link (denoted by ADD link) in which a bounded (but unknown) number of consecutive messages can be delayed or lost. In this work we present the first implementation (to our knowledge) of Ω in partially synchronous systems with ADD links and with unknown membership. Furthermore, it is the first implementation of Ω that combines two very interesting properties: communication-efficiency and crash-quiescence when the majority of processes are correct. Finally, we also obtain with the same algorithm a failure detector ( ◇ P ¯ ) such that every correct process eventually and permanently outputs the set of all correct processes.

On the road to the weakest failure detector for [formula omitted]-set agreement in message-passing systems

In the k -set agreement problem, each process (in a set of n processes) proposes a value and has to decide a proposed value in such a way that at most k different values are decided. While this problem can easily be solved in asynchronous systems prone to t process crashes when k > t , it cannot be solved when k ≤ t . For several years, the failure-detector-based approach has been investigated to circumvent this impossibility. While the weakest failure detector class to solve the k -set agreement problem in read/write shared memory systems has recently been discovered (PODC 2009), the situation is different in message-passing systems where the weakest failure detector classes are known only for the extreme cases k = 1 (consensus) and k = n − 1 (set agreement). This paper presents four contributions whose aim is to help pave the way to discover the weakest failure detector class for k -set agreement in message-passing systems. These contributions are the following. (a) The first is a new failure detector class, denoted Π k , that is such that Π 1 = Σ × Ω (the weakest class for k = 1 ), and Π n − 1 = L (the weakest class for k = n − 1 ). (b) The second is an investigation of the structure of Π k that shows that Π k is the combination of two failure detector classes Σ k (that is new) and Ω k (they generalize the previous “quorums” and “eventual leaders” failure detector classes, respectively). (c) The third contribution concerns Σ k that is shown to be a necessary requirement (as far as information on failure is concerned) to solve the k -set agreement problem in message-passing systems. (d) Finally, the last contribution is a Π n − 1 -based algorithm that solves the ( n − 1 ) -set agreement problem. This algorithm provides us with a new algorithmic insight on the way the ( n − 1 ) -set agreement problem can be solved in asynchronous message-passing systems. It is hoped that these contributions will help discover the weakest failure detector class for k -set agreement in message-passing systems.

A simple proof of the necessity of the failure detector Σ to implement an atomic register in asynchronous message-passing systems

This paper presents a simple proof that shows that the quorum failure detector class (denoted Σ) is the weakest failure detector class required to implement an atomic read/write register in an asynchronous message-passing system prone to an arbitrary number of process crashes. This proof is based on a new reduction algorithm in which all the variables are bounded.

On the computability power and the robustness of set agreement-oriented failure detector classes

Solving agreement problems deterministically, such as consensus and k-set agreement, in asynchronous distributed systems prone to an unbounded number of process failures has been shown to be impossible. To circumvent this impossibility, unreliable failure detectors for the crash failure model have been widely studied. These are oracles that provide information on failures. The exact nature of such information is defined by a set of abstract properties that a particular class of failure detectors satisfy. The weakest class of such failure detectors that allow to solve consensus is Ω. This paper considers failure detector classes from the literature that solve k-set agreement in the crash failure model, and studies their relative power. It shows that the family of failure detector classes $${\diamond\mathcal{S}_x}$$ (1 ≤ x ≤ n), and $${\diamond \psi^y}$$ (0 ≤ y ≤ n), can be “added” to provide a failure detector of the class Ω z (1 ≤ z ≤ n, a generalization of Ω). It also characterizes the power of such an “addition”, namely, $${\diamond {\mathcal S}_x +\diamond \psi^y\rightsquigarrow\Omega^z \Leftrightarrow x+y+z > t+1}$$ , $${\diamond \psi^y}$$ can construct Ω z iff y + z > t, and $${\diamond {\mathcal S}_x}$$ can construct Ω z iff x + z > t + 1, where t is the maximum number of processes that can crash in a run. As an example, the paper shows that, while $${\diamond {\mathcal S}_{t}}$$ allows solving 2-set agreement (but not consensus) and $${\diamond \psi^{1}}$$ allows solving t-set agreement (but not (t − 1)-set agreement), a system with failure detectors of both classes can solve consensus for any value of t. More generally, the paper studies the failure detector classes $${\diamond {\mathcal S}_x}$$ , $${\diamond \psi^y}$$ and Ω z , and shows which reductions among these classes are possible and which are not. The paper also presents a message-passing Ω k -based k-set agreement protocol and shows that Ω k is not enough to solve (k − 1)-set agreement. In that sense, it can be seen as a step toward the characterization of the weakest failure detector class that allows solving the k-set agreement problem.

Distributed Consensus, revisited

We provide a novel model to formalize a well-known algorithm, by Chandra and Toueg, that solves Consensus among asynchronous distributed processes in the presence of a particular class of failure detectors (◇S or, equivalently, Ω), under the hypothesis that only a minority of processes may crash. The model is defined as a global transition system that is unambigously generated by local transition rules. The model is syntax-free in that it does not refer to any form of programming language or pseudo code. We use our model to formally prove that the algorithm is correct.

On the Respective Power of /spl Lozenge/P and /spl Lozenge/S to Solve One-Shot Agreement Problems

Unreliable failure detectors are abstract devices that, when added to asynchronous distributed systems, enable solving distributed computing problems (e.g., consensus) that otherwise would be impossible to solve in these systems. This paper focuses on two classes of failure detectors defined by Chandra and Toueg, namely, the classes denoted diamP (eventually perfect) and diamS (eventually strong). Both classes include failure detectors that eventually detect permanently all process crashes, but while the failure detectors of diamP eventually make no erroneous suspicions, the failure detectors of diamS are only required to eventually not suspect a single correct process. Informally, in a one-shot agreement problem, a new problem instance is created each time the processes propose new values to be decided on (e.g., consensus is one-shot). In such a context, this paper addresses the following question related to the comparative power of these classes, namely: "Are there one-shot agreement problems that can be solved in asynchronous distributed systems with reliable links but prone to process crash failures augmented with op, but cannot be solved when those systems are augmented with diamS?" Surprisingly, the paper shows that the answer to this question is "no." An important consequence of this result is that diamP cannot be the weakest class of failure detectors that enables solving one-shot agreement problems in unreliable asynchronous distributed systems

On the Respective Power of /spl Lozenge/P and /spl Lozenge/S to Solve One-Shot Agreement Problems

Unreliable failure detectors are abstract devices that, when added to asynchronous distributed systems, enable solving distributed computing problems (e.g., consensus) that otherwise would be impossible to solve in these systems. This paper focuses on two classes of failure detectors defined by Chandra and Toueg, namely, the classes denoted diamP (eventually perfect) and diamS (eventually strong). Both classes include failure detectors that eventually detect permanently all process crashes, but while the failure detectors of diamP eventually make no erroneous suspicions, the failure detectors of diamS are only required to eventually not suspect a single correct process. Informally, in a one-shot agreement problem, a new problem instance is created each time the processes propose new values to be decided on (e.g., consensus is one-shot). In such a context, this paper addresses the following question related to the comparative power of these classes, namely: "Are there one-shot agreement problems that can be solved in asynchronous distributed systems with reliable links but prone to process crash failures augmented with op, but cannot be solved when those systems are augmented with diamS?" Surprisingly, the paper shows that the answer to this question is "no." An important consequence of this result is that diamP cannot be the weakest class of failure detectors that enables solving one-shot agreement problems in unreliable asynchronous distributed systems

Designing Efficient Algorithms for the Eventually Perfect Failure Detector Class

This paper focuses on the design of unreliable failure detectors of the Eventually Perfect class (◊P) in crash-prone partially synchronous systems. We adopt a monitoring mechanism based on heartbeats over a logical ring arrangement of processes as the common design feature. This provides good communication efficiency, a performance parameter which refers to the number of links that carry messages forever. We follow two different approaches that result in two families of failure detectors: a nearly communication-efficient family, which uses n + C links forever, being C the number of correct processes out of the n processes in the system, and a communication efficient family, which uses only n links forever. Besides communication efficiency, we evaluate the algorithms in terms of QoS parameters, which include the capability of the failure detector to provide right answers as well as its reaction time.

Managed Agreement: Generalizing two fundamental distributed agreement problems

This paper presents a family of agreement problems called Managed Agreement, which is parameterized by the number of aristocrat nodes in the system; NBAC is a special case of this family when all nodes are aristocrats while Consensus is a special case of this family when there are no aristocrats. The paper also presents a parameterized family of failure detectors F ( A ) such that F ( A ) is the weakest failure detector class that enables solving Managed Agreement with a set A of aristocrats in an asynchronous environment.

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.

Asynchronous bounded lifetime failure detectors

A failure detector provides processes with a single primitive that, each time it is invoked, returns to the invoking process information related to failures. This research note extends failure detectors by allowing processes to invoke an additional primitive whose effect is to limit the time scope of some properties offered by the failure detector. This simple addition makes possible to weaken the definition of failure detector classes without weakening their power. Two distributed computing problems are used to illustrate the benefit of such an approach, namely the consensus problem and the construction of an atomic register.

Eventually consistent failure detectors

The concept of unreliable failure detector was introduced by Chandra and Toueg as a mechanism that provides information about process failures. This mechanism has been used to solve different problems in asynchronous systems, in particular the Consensus problem. In this paper, we present a new class of unreliable failure detectors, which we call Eventually Consistent and denote by ♢ C . This class combines the failure detection capabilities of class ♢ S with the eventual leader election capability of class Ω . This capability allows all correct processes to eventually choose the same correct process as leader. We study the relationship between ♢ C and other classes of failure detectors. We also propose an efficient algorithm to transform ♢ C into ♢ P in models of partial synchrony. Finally, to show the power of this new class of failure detectors, we present a Consensus algorithm based on ♢ C . This algorithm successfully exploits both the leader election and the failure detection capabilities of the failure detector, and performs better in number of rounds than all the previously proposed algorithms for ♢ S .

On the implementation of unreliable failure detectors in partially synchronous systems

Unreliable failure detectors were proposed by Chandra and Toueg as mechanisms that provide information about process failures. Chandra and Toueg defined eight classes of failure detectors, depending on how accurate this information is, and presented an algorithm implementing a failure detector of one of these classes in a partially synchronous system. This algorithm is based on all-to-all communication and periodically exchanges a number of messages that is quadratic on the number of processes. We study the implementability of different classes of failure detectors in several models of partial synchrony. We first show that no failure detector with perpetual accuracy (namely, P, Q, S, and W) can be implemented in these models in systems with even a single failure. We also show that, in these models of partial synchrony, it is necessary a majority of correct processes to implement a failure detector of the class /spl theta/ proposed by Aguilera et al. Then, we present a family of distributed algorithms that implement the four classes of unreliable failure detectors with eventual accuracy (namely, /spl diams/P, /spl diams/Q, /spl diams/S, and /spl diams/W). Our algorithms are based on a logical ring arrangement of the processes, which defines the monitoring and failure information propagation pattern. The resulting algorithms periodically exchange at most a linear number of messages.