Sergio Arévalo

Optimal implementation of the weakest failure detector for solving consensus

The concept of unreliable failure detector was introduced by T.D. Chandra and S. Toueg (1996) as a mechanism that provides information about process failures. Depending on the properties which the failure detectors guarantee, they proposed a taxonomy of failure detectors. It has been shown that one of the classes of this taxonomy, namely Eventually Strong (/spl nabla/S), is the weakest class allowing a solution of the Consensus problem. The authors present a new algorithm implementing /spl nabla/S. Our algorithm guarantees that eventually all the correct processes agree on a common correct process. This property trivially allows us to provide the accuracy and completeness properties required by /spl nabla/S. We show then that our algorithm is better than any other proposed implementation of /spl nabla/S in terms of the number of messages and the total amount of information periodically sent. In particular, previous algorithms require periodic exchange of at least a quadratic amount of information, while ours only requires O(n log n) (where n is the number of processes). However, we also propose a new measure to evaluate the efficiency of this kind of algorithm, the eventual monitoring degree, which does not rely on a periodic behavior and expresses the degree of processing required by the algorithms better. We show that the runs of our algorithm have optimal eventual monitoring degree.

Efficient Algorithms to Implement Unreliable Failure Detectors in Partially Synchronous Systems

Unreliable failure detectors, proposed by Chandra and Toueg [2], are mechanisms that provide information about process failures. In [2], eight classes of failure detectors were defined, depending on how accurate this information is, and an algorithm implementing a failure detector of one of these classes in a partially synchronous system was presented. This algorithm is based on all-to-all communication, and periodically exchanges a number of messages that is quadratic on the number of processes. To our knowledge, no other algorithm implementing these classes of unreliable failure detectors has been proposed. In this paper, we present a family of distributed algorithms that implement four classes of unreliable failure detectors in partially synchronous systems. 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.

Implementing unreliable failure detectors with unknown membership

Unreliable failure detectors [3] are useful devices to solve several fundamental problems in fault-tolerant distributed computing, like consensus or atomic broadcast. In their original work [3], Chandra and Toueg proposed 8 different classes of unreliable failure detectors, and showed that all of them can be used to solve consensus in a crash-prone asynchronous system with reliable links. All these detectors have at least a property called Weak Completeness: eventually, every process that fails is permanently suspected by some correct process. In a follow up work with Hadzilacos [2], they proposed another type of failure detector, Ω , which guarantees that eventually all correct processes permanently choose the same correct process as leader. They show in [2] that Ω is the weakest detector that can be used for solving consensus in this type of systems. When the membership is known, an Ω failure detector trivially also implements a S failure detector ( S is one of the 8 original classes).

A Low-Latency Non-blocking Commit Service

Atomic commitment is one of the key functionalities of modern information systems. Conventional distributed databases, transaction processing monitors, or distributed object platforms are examples of complex systems built around atomic commitment. The vast majority of such products implement atomic commitment using some variation of 2 Phase Commit (2PC) although 2PC may block under certain conditions. The alternative would be to use non-blocking protocols but these are seen as too heavy and slow. In this paper we propose a nonblocking distributed commit protocol that exhibits the same latency as 2PC. The protocol combines several ideas (optimism and replication) to implement a scalable solution that can be used in a wide range of applications.

Drago: An Ada Extension to Program Fault-Tolerant Distributed Applications

This paper describes Drago, an experimental language designed to support the implementation of fault-tolerant distributed applications. The language is the result of an effort to impose discipline and give linguistic support to the main concepts of Isis, as well as to experiment with the group communication paradigm. Drago has been designed and implemented as an extension to Ada 83. In this paper we introduce Drago, give some simple examples of its use, and briefly discuss its implementation. Drago is also compared with the Distributed Annex of Ada 95.

Integrating Groups and Transactions: A Fault-Tolerant Extension of Ada

We present Transactional Drago a language that implements Group Transactions, a new transaction model we have developed. This model integrates the group communication paradigm with the nested transaction model. Transactional Drago extends Drago, a distributed fault-tolerant extension of Ada implementing the group paradigm. In this paper we describe the linguistic features added to Drago to support group transactions and how they are integrated with the existing mechanisms in Drago, particularly with group communication.

Batching: A Design Pattern for Efficient and Flexible Client-Server Interaction

The Batching design pattern consists of a common piece of design and implementation that is shared by a wide variety of well-known techniques in Computing such as gather/scatter for input/output, code downloading for system extension, message batching, mobile agents, and deferred calls for disconnected operation. All techniques mentioned above are designed for applications running across multiple domains (e.g., multiple processes or multiple nodes in a network). In these techniques, multiple operations are bundled together and then sent to a different domain, where they are executed. In some cases, the objective is to reduce the number of domain-crossings. In other cases, it is to enable dynamic server extension. In this article, we present the Batching pattern, discuss the circumstances in which the pattern should and should not be used, and identify eight classes of existing techniques that instantiate it.

Optimal implementation of the weakest failure detector for solving consensus (brief announcement)

<italic>Unreliable failure detectors</italic> were introduced by Chandra and Toueg [2] as a mechanism that provides (possibly incorrect) information about process failures. They showed how unreliable failure detectors can be used to solve the Consensus problem in asynchronous systems. They also showed in [1] that one of the classes of failure detectors they defined, namely <italic>Eventually Strong</italic> (⋄<italic>S</italic>), is the weakest class allowing to solve Consensus<supscrpt>1</supscrpt>. This brief announcement presents a new algorithm implementing ⋄<italic>S</italic>. Due to space limitation, the reader is referred to [4] for an in-depth presentation of the algorithm (system model, correctness proof, and performance analysis). Here, we present the general idea of the algorithm and compare it with other algorithms implementing unreliable failure detectors. The algorithm works as follows. We have <italic>n</italic> processes, <italic>p</italic><subscrpt>1</subscrpt>, …, <italic>p<subscrpt>n</subscrpt></italic>. Initially, process <italic>p</italic><subscrpt>1</subscrpt> starts sending messages periodically to the rest of processes. The rest of processes initially <italic>trust p</italic><subscrpt>1</subscrpt>, and wait for its messages. If a process does not receive a message within some timeout period from its trusted process, then it suspects its trusted process and takes the next process as its new trusted process. If a process trusts itself, then it starts sending messages periodically to its successors. Otherwise, it just waits for periodical messages from its trusted process. If, at some point, a process receives a message from a process <italic>p<subscrpt>i</subscrpt></italic> such that <italic>p<subscrpt>i</subscrpt></italic> precedes its trusted process, then it will trust <italic>p<subscrpt>i</subscrpt></italic> again, increasing the value of its timeout period with respect to <italic>p<subscrpt>i</subscrpt></italic>. With this algorithm, eventually all the correct processes will permanently trust the same correct process. This provides the eventual weak accuracy property required by ⋄<italic>S</italic>. By simply suspecting the rest of processes, we obtain the strong completeness property required by ⋄<italic>S</italic>. Our algorithm compares favorably with the algorithms proposed in [2] and [3] in terms of the number and size of the messages periodically sent and the total amount of information periodically exchanged. Since algorithms implementing failure detectors need not necessarily be periodic, we propose a new and (we believe) more adequate performance measure, which we call <italic>eventual monitoring degree</italic>. Informally, this measure counts the number of pairs of correct processes that will infinitely often communicate. We show that the proposed algorithm is optimal with respect to this measure. Table 1 summarizes the comparison, where <italic>C</italic> denotes the number of correct processes and LFA denotes the proposed algorithm.

Minimal System Conditions to Implement Unreliable Failure Detectors

In this paper we explore the minimal system requirements to implement unreliable failure detectors. We first consider systems formed by lossy asynchronous and eventually timely links. On these systems we define two properties, the weak property and the strong property, depending on whether all correct processes can be reached with links that are not lossy asynchronous from one or from all correct processes, respectively. We present necessary conditions based on these properties. We show that there is no algorithm that implements diamS, Omega, nor S (resp. diamP nor P) if we allow one single failure in a system that, when all processes are correct, does not satisfy the weak (resp. strong) property. Then, we propose an algorithm that implements diamP if the strong property is satisfied, and diamS (and Omega with an additional assumption) if only the weak property is satisfied. For systems formed by synchronous and lossy asynchronous links only, we propose another algorithm that implements detector class P4 if the strong property is satisfied, and implements a new detector class S1 (and Omega with an additional assumption) if only the weak property is satisfied

Eventually consistent failure detectors

The concept of unreliable failure detecto was introduced by Chandra and Toueg [2] as a mechanism that provides (possibly incorrect) information about process failures. This mechanism has been used to solve different problems in async hronous 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 adds to the failure detection capabilities of other classes an eventual leader election capability. We study the relationship between ♦C and other classes of failure detectors. We also propose an efficient algorithm to transform ♦C into ♦P. Finally, to show the power of this new class of failure detectors, we present an efficient Consensus algorithm based on ♦C. Due to space limitation, the reader is referred to [4] for an in-depth presentation of the algorithms. Here, we only present their general idea.