Mikel Larrea

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.

Non blocking atomic commitment with an unreliable failure detector

In a transactional system, an atomic commitment protocol ensures that for any transaction, all data manager processes agree on the same outcome (commit or abort). A non-blocking atomic commitment protocol enables an outcome to be decided at every correct process despite the failure of others. In this paper we apply, for the first time, the fundamental result of T. Chandra and S. Toueg (1991) on solving the abstract consensus problem, to non-blocking atomic commitment. More precisely, we present a non-blocking atomic commitment protocol in an asynchronous system augmented with an unreliable failure detector that can make an infinity of false failure suspicions. If no process is suspected to have failed, then our protocol is similar to a three phase commit protocol. In the case where processes are suspected, our protocol does not require any additional termination protocol: failure scenarios are handled within our regular protocol and are thus much simpler to manage.

Reducing the cost for non-blocking in atomic commitment

Non-blocking atomic commitment protocols enable a decision (commit or abort) to be reached at every correct participant, despite the failure of others. The cost for non-blocking implies however (1) a high number of messages and communication steps required to reach commit, and (2) a complicated termination protocol needed in the case of failure suspicions. In this paper, we present a non-blocking protocol, called MDSPC (Modular and Decentralized Three Phase Commit), which enables to trade resiliency against efficiency. As conveyed by our performance measures, MDSPC is faster than existing non-blocking protocols, and in the case of a broadcast network and a reasonable resiliency rate (e.g. 2 or 3) is almost as efficient as the classical (blocking) 2PC. The termination protocol of MDSPC is encapsulated inside a majority consensus protocol. This modularity leads to a simple structure of MDSPC and enables a precise characterization of its liveness in an asynchronous system with an unreliable failure detector.

Implementing the Omega failure detector in the crash-recovery failure model

Unreliable failure detectors are mechanisms providing information about process failures, that allow to solve several problems in asynchronous systems, e.g., Consensus. A particular failure detector, Omega, provides an eventual leader election functionality. This paper addresses the implementation of Omega in the crash-recovery failure model. We first propose an algorithm assuming that processes are reachable from the correct process that crashes and recovers a minimum number of times. Then, we propose two algorithms which assume only that processes are reachable from some correct process. Besides this, one of the algorithms requires the membership to be known a priori, while the other two do not.

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.

Fault-Tolerant Leader Election in Mobile Dynamic Distributed Systems

This paper addresses the leader election problem in dynamic distributed systems with mobile processes. To do so, it is assumed that the system alternates periods of good and bad behavior, in the line of the timed asynchronous model of Cristian and Fetzer. We extend the eventual leadership properties recently proposed by Larrea et al. for non-mobile dynamic systems, defining two new properties that take into account graph joins/fragmentations due to process mobility. We also propose a new leader election algorithm in a weak mobile dynamic distributed system model. Using a categorization framework, we compare our system model with a number of models proposed in the literature, showing that our leader election algorithm works in a model which is weaker than the rest.

Specifying and implementing an eventual leader service for dynamic systems

The election of an eventual leader in an asynchronous system prone to process crashes is an important problem of fault-tolerant distributed computing. This problem is known as the implementation of the failure detector Omega. Nearly all papers that propose algorithms implementing such an eventual leader service consider a static system. In contrast this paper considers a dynamic system, i.e., a system in which processes can enter and leave. The paper has three contributions. It first proposes a specification of

Hierarchical and fault-tolerant data aggregation in wireless sensor networks

\Omega

Eventually consistent failure detectors

suited to dynamic systems. Then, it presents and proves correct an algorithm implementing this specification. Finally, the paper discusses the notion of an eventual leader suited to dynamic systems. It introduces an additional property related to system stability. The design of an algorithm satisfying this last property remains an open challenging problem.