11971291
A hybrid approach for building eventually accurate failure detectors
Unreliable failure detectors introduced by Chandra and Toueg are abstract mechanisms that provide information about process crashes. On the one hand, failure detectors allow a statement of the minimal requirements on process failures that allow solutions to problems that cannot otherwise be solved in purely asynchronous systems. However, on the other hand, they cannot be implemented in such systems: their implementation requires that the underlying distributed system be enriched with additional assumptions. Classic failure detector implementations rely on additional synchrony assumptions such as partial synchrony. More recently, a new approach for implementing failure detectors has been proposed: it relies on behavioral properties on the flow of messages exchanged. This shows that these approaches are not antagonistic and can be advantageously combined. A hybrid protocol (the first to our knowledge) implementing failure detectors with eventual accuracy properties is presented. Interestingly, this protocol benefits from the best of both worlds in the sense that it converges (i.e., provides the required failure detector) as soon as either the system behaves synchronously or the required message exchange pattern is satisfied. This shows that, to expedite convergence, it can be interesting to consider that the underlying system can satisfy several alternative assumptions.
38731127
The Synchronous Condition-Based Consensus Hierarchy
In the context of a system made up of n processes where at most t can crash, the condition-based approach studies restrictions on the inputs of a distributed problem, called conditions, that make it solvable, or easier to solve (in case it is solvable without restricting its inputs). Previous work studied conditions for consensus and other agreement problems, mostly for asynchronous systems. This paper considers the condition-based approach for consensus in synchronous systems, and establishes a bridge between the asynchronous and synchronous models, with a hierarchy \( {\cal S}_t^{[-t]}\subset\cdots\subset {\cal S}_t^{[0]}\subset\cdots\subset {\cal S}_t^{[t]} \) where \({\cal S}_t^{[t]}\) includes all conditions (and in particular the trivial one made up of all possible input vectors). For a condition \(C \in{\cal S}_t^{[d]}\), –t ≤ d ≤ t, we have:
6481763
Decision optimal early-stopping k-set agreement in synchronous systems prone to send omission failures
The k-set agreement problem is a generalization of the consensus problem: each process proposes a value, and each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided. This paper focuses on the k-set agreement problem in the context of synchronous systems where up to t < n processes can experience crash or send omission failures (n being the total number of processes). The paper presents a k-set agreement protocol for this failure model (the first to our knowledge) which has two main outstanding features. (1) It provides the following early deciding and stopping property: no process decides or halts after the round min(/spl lfloor/f/k/spl rfloor/ + 2, /spl lfloor/t/k/spl rfloor/ + 1) where f is the number of actual crashes (0 /spl les/ f /spl les/ t). (2) It is decision-optimal. This new optimality criterion, suited to the omission failure model, concerns the number of processes that decide, namely, the protocol forces all the processes that do not crash to decide (regardless of whether they commit omission faults or not). It is noteworthy that each of these properties (early deciding/stopping vs decision-optimality) is not obtained at the detriment of the other. Last but not least, the protocol enjoys another first-class property, namely, simplicity.
35647117
Early-Stopping k-Set Agreement in Synchronous Systems Prone to Any Number of Process Crashes
The k-set agreement problem is a generalization of the consensus problem: each process proposes a value, and each non-faulty process has to decide a value such that a decided value is a proposed value, and no more than k different values are decided.

This paper presents a surprisingly simple protocol that solves the k-set agreement problem in synchronous systems prone to up to t<n processes can crash (where n is the total number of processes). The proposed protocol is the first early stopping k-set agreement protocol that does not impose a constraint on t. It allows the processes to decide and stop by min $(\lfloor f/k \rfloor +2,\lfloor t/k \rfloor+1)$ rounds where f is the number of actual crashes (0≤ f ≤ t). In addition to its conceptual simplicity, the protocol has an additional noteworthy feature, namely, it is particularly efficient in common case scenarios. This comes from the fact that it is based on a mechanism that allows the processes to take into account the actual pattern of failures and not only their number, thereby allowing the processes to decide in much less than ${\lfloor f/k \rfloor +2}$ coding from an InlineMediaObject here! rounds in a lot of cases.
17868570
Condition-Based Protocols for Set Agreement Problems
A condition C is a set of input vectors to a problem. A class of conditions that allow to solve k-set agreement in spite of f crashes in an asynchronous system is identified. A k-set agreement protocol that is always safe is described: it is guaranteed to terminate when the input vector belongs to C and it always decides on at most k different values, even if the input vector does not belong to C. While there are simple solutions when f < k, it is known that the k-set agreement problem has no solution when f ? k. Thus, the paper identifies classes of conditions that allow to solve this problem even when f ? k. The paper gives evidence that these are the only conditions that allow to solve set agreement, by proving the wait-free case. Two natural concrete conditions that belong to such a class are described. Finally, a more efficient k-set agreement protocol with only linear complexity (does not use snapshots), for any C that allows to solve consensus, when k ? f/(n - f) + 1 is presented. This shows how to trade fault-tolerance for agreement precision using the condition based approach.
10131958
An optimal atomic broadcast protocol and an implementation framework
Atomic broadcast (where all processes deliver broadcast messages in the same order) is a very useful group communication primitive for building fault-tolerant distributed systems. This paper presents an atomic broadcast protocol that can be claimed to be optimal in terms of failure detection, resilience, and latency. The protocol requires only the weakest of the useful failure detectors for liveness, and permits up to (n-1)/2 processes to crash in a system of n processes; at most two communication steps and n broadcasts are needed in a run during which process crashes and failure-suspicions do not occur. We also introduce the notion of notifying broadcast which can reduce the message overhead further in 'nice' runs in which all processes are operational and communication delays do not exceed the bound assumed. If nice runs persist, the average message overhead is just one broadcast. That is, the protocol extracts no message overhead for providing crash-tolerance if process failures and unanticipated fluctuations in communication delays do not occur. We are currently implementing our protocol as a CORBA (Common Object Request Broker Architecture) component. All known ORBs use IIOP as the standard protocol for inter-process communication, which in turn uses TCP/IP (transmission control protocol/Internet protocol) as the common transport protocol. It turns out that the notifying broadcast is easy to implement on top of the TCP transport layer.
39476661
The Committee Decision Problem
We introduce the (b,n)-Committee Decision Problem (CD) – a generalization of the consensus problem. While set agreement generalizes consensus in terms of the number of decisions allowed, the CD problem generalizes consensus in the sense of considering many instances of consensus and requiring a processor to decide in at least one instance. In more detail, in the CD problem each one of a set of n processes has a (possibly distinct) value to propose to each one of a set of b consensus problems, which we call committees. Yet a process has to decide a value for at least one of these committees, such that all processes deciding for the same committee decide the same value. We study the CD problem in the context of a wait-free distributed system and analyze it using a combination of distributed algorithmic and topological techniques, introducing a novel reduction technique. 
 
We use the reduction technique to obtain the following results. We show that the (2,3)-CD problem is equivalent to the musical benches problem introduced by Gafni and Rajsbaum in [10], and both are equivalent to (2,3)-set agreement, closing an open question left there. Thus, all three problems are wait-free unsolvable in a read/write shared memory system, and they are all solvable if the system is enriched with objects capable of solving (2,3)-set agreement. While the previous proof of the impossibility of musical benches was based on the Borsuk-Ulam (BU) Theorem, it now relies on Sperner's Lemma, opening intriguing questions about the relation between BU and distributed computing tasks.
12635880
Token-based sequential consistency in asynchronous distributed systems
A concurrent object is an object that can be concurrently accessed by several processes. Sequential consistency is a consistency criterion for such objects. It informally states that a multiprocess program executes correctly if its results could have been produced by executing that program on a single processor system. (Sequential consistency is weaker than atomic consistency-the usual consistency criterion-as it does not refer to real-time.) The paper proposes a new, surprisingly simple protocol that ensures sequential consistency when the shared memory abstraction is supported by the local memories of nodes that can communicate only by exchanging messages through reliable channels. The protocol nicely combines, in a simple way, the use a of token with cached values. It has the noteworthy property to never invalidate cached values, thereby providing fast read operations (i.e., a process has never to wait to get a correct value of a shared object). Additionally, The paper presents a simple token navigation protocol.
14128423
Elastic vector time
In recent years there has been an increasing demand to build "soft" real-time applications on top of asynchronous distributed systems. Designing and implementing such applications is a non-trivial task and application designers are often faced with the need to circumvent impossibility results. In this paper we discuss how to ensure that actions are executed in the correct order even in the face of failures. We propose a novel time base and a new synchronization mechanism for the design of distributed "soft" real-time applications. We demonstrate (1) how this time base can be used to enforce an externally consistent ordering, and (2) how it permits to circumvent impossibility results by sketching how to solve the leader election and perfect failure detection problem.
32842522
A generic framework for indulgent consensus
Consensus is a fundamental distributed agreement problem that has to be solved when one has to design or implement reliable applications. As consensus cannot be solved in pure asynchronous distributed systems, those systems have to be equipped with appropriate oracles to circumvent the impossibility. Several oracles (unreliable failure detector leader capability, random number generator) have been proposed, and consensus protocols based on such ad hoc oracles have been designed This paper presents a generic consensus framework that can be instantiated with any oracle, or combination of oracles, that satisfies a set of properties. This generic framework provides indulgent consensus protocols that are particularly simple and efficient both in well-behaved runs (i.e., when there are no failures), and in stable runs (i.e., when there is no failure during the execution although some processes can be initially crashed). In those runs, the protocols terminate in two communication steps (which is optimal). Indulgence means that the resulting protocol never violates its safety property even when the underlying oracle behaves arbitrarily. Interestingly, the protocol can also allow processes to decide in one communication step in some specific configurations.