Showing papers on "Consensus published in 2000"

Wait-Free k -Set Agreement is Impossible: The Topology of Public Knowledge

Abstract: In the classical consensus problem, each of n processors receives a private input value and produces a decision value which is one of the original input values, with the requirement that all processors decide the same value. A central result in distributed computing is that, in several standard models including the asynchronous shared-memory model, this problem has no deterministic solution. The k-set agreement problem is a generalization of the classical consensus proposed by Chaudhuri [ Inform. and Comput., 105 (1993), pp. 132--158], where the agreement condition is weakened so that the decision values produced may be different, as long as the number of distinct values is at most k. For $n>k\geq 2$ it was not known whether this problem is solvable deterministically in the asynchronous shared memory model. In this paper, we resolve this question by showing that for any k < n, there is no deterministic wait-free protocol for n processors that solves the k-set agreement problem. The proof technique is new: it is based on the development of a topological structure on the set of possible processor schedules of a protocol. This topological structure has a natural interpretation in terms of the knowledge of the processors of the state of the system. This structure reveals a close analogy between the impossibility of wait-free k-set agreement and the Brouwer fixed point theorem for the k-dimensional ball.

Optimal implementation of the weakest failure detector for solving consensus

Abstract: 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.

An architecture for survivable coordination in large distributed systems

Abstract: Coordination among processes in a distributed system can be rendered very complex in a large-scale system where messages may be delayed or lost and when processes may participate only transiently or behave arbitrarily, e.g. after suffering a security breach. In this paper, we propose a scalable architecture to support coordination in such extreme conditions. Our architecture consists of a collection of persistent data servers that implement simple shared data abstractions for clients, without trusting the clients or even the servers themselves. We show that, by interacting with these untrusted servers, clients can solve distributed consensus, a powerful and fundamental coordination primitive. Our architecture is very practical, and we describe the implementation of its main components in a system called Fleet.

k-set agreement with limited accuracy failure detectors

Abstract: Let the scope of the accuracy property of an unreliable failure detector be the number x of processes that may not suspect a correct process. The scope notion gives rise to new classes of failure detectors among which we consider Sx and dSx in this paper (Usual failure detectors consider an implicit scope equal to n, the total number of processes).The k-set agreement problem generalizes the consensus problem: each correct process has to decide a value in such a way that a decided value is a proposed value, and the number of decided values is bounded by k. There exist protocols that solve this problem in asynchronous distributed systems when ƒ

Modeling fault-tolerant mobile agent execution as a sequence of agreement problems

Abstract: Fault tolerance is fundamental to the further development of mobile agent applications. In the context of mobile agents, fault tolerance prevents a partial or complete loss of the agent, i.e. ensures that the agent arrives at its destination. Simple approaches such as checkpointing are prone to blocking. Replication can in principle improve solutions based on checkpointing. However existing solutions in this context either assume a perfect failure detection mechanism (which is not realistic in an environment such as the Internet), or rely on complex solutions based on leader election and distributed transactions, where only a subset of solutions prevents blocking. The paper proposes a novel approach to fault tolerant mobile agent execution, which is based on modeling agent execution as a sequence of agreement problems. Each agreement problem is one instance of the well understood consensus problem. Our solution does not require a perfect failure detection mechanism, while preventing blocking and ensuring that the agent is executed exactly once.

Synchronous Byzantine quorum systems

Abstract: Quorum systems have been used to implement many coordination problems in distributed systems such as mutual exclusion, data replication, distributed consensus, and commit protocols. Malkhi and Reiter recently proposed quorum systems that can tolerate Byzantine failures; they called these systems Byzantine quorum systems and gave some examples of such quorum systems. In this paper, we propose a new definition of Byzantine quorums that is appropriate for synchronous systems. We show how these quorums can be used for data replication and propose a general construction of synchronous Byzantine quorums using standard quorum systems. We prove tight lower bounds on the load of synchronous Byzantine quorums for various patterns of failures and we present synchronous Byzantine quorums that have optimal loads that match the lower bounds for two failure patterns.

The best of both worlds: A hybrid approach to solve consensus

Abstract: It is now well recognized that the consensus problem is a fundamental problem when one has to implement fault-tolerant distributed services in asynchronous distributed systems prone to process crash failures. This paper considers the binary consensus problem in such a system. Following an approach investigated by Aguilera and Toueg, it proposes a simple binary consensus protocol that combines failure detection and randomization. This protocol terminates deterministically when the failure detection mechanism works correctly; it terminates with probability 1, otherwise. A performance evaluation of the protocol is also provided. Last but not least, it is important to note that the proposed protocol is both efficient and simple. Additionally it can be simplified to give rise either to a deterministic failure detector-based consensus protocol or to a randomized consensus protocol.

Using Consensus Methods for Solving Conflicts of Data in Distributed Systems

Abstract: By a data conflict in distributed systems we understand a situation (or a state of the system) in which the system sites generate and store different versions of data which refer to the same matter (problem solution, event scenario etc.). Thus in purpose to solve this problem the management system should determine one proper version for the data. The final data version is called a consensus of given versions. In this paper for given conflict situation we propose to solve a consensus problem by determining a consensus function. We present a consensus model, the postulates for consensus choice functions, their analysis and some numerical example.

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

Abstract: Unreliable failure detectors 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 Eventually Strong (dS), is the weakest class allowing to solve Consensus1.This brief announcement presents a new algorithm implementing dS. 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 n processes, p1, …, pn. Initially, process p1 starts sending messages periodically to the rest of processes. The rest of processes initially trust p1, 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 pi such that pi precedes its trusted process, then it will trust pi again, increasing the value of its timeout period with respect to pi.With this algorithm, eventually all the correct processes will permanently trust the same correct process. This provides the eventual weak accuracy property required by dS. By simply suspecting the rest of processes, we obtain the strong completeness property required by dS.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 eventual monitoring degree. 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 C denotes the number of correct processes and LFA denotes the proposed algorithm.

Fast deterministic consensus in a noisy environment

Abstract: It is well known that the consensus problem cannot be solved deterministically in an asynchronous environment, but that randomized solutions are possible. We propose a new model, called noisy scheduling, in which an adversarial schedule is perturbed randomly, and show that in this model randomness in the environment can substitute for randomness in the algorithm. In particular, we show that a simplified, deterministic version of Chandra's wait-free shared-memory consensus algorithm [16] solves consensus in time at most logarithmic in the number of active processes. The proof of termination is based on showing that a race between independent delayed renewal processes produces a winner quickly. In addition, we show that the protocol finishes in constant time using quantum and priority-based scheduling on a uniprocessor, suggesting that it is robust against the choice of model over a wide range.

Using Consensus Methods for Determining the Representation of Expert Information in Distributed Systems

Abstract: By the expert information we mean the information given by a man-expert of a field of science and technology, or by some intelligent program (for example intelligent agents) in solving of some task. We assume that in an intelligent distributed system for the same task the system sites may generate different solutions, and the problem is for the management system to determine a proper one solution for the task. In this paper we propose solving above problem by determining consensus of given solutions and treat it as the final solution. We present a general consensus problem, the postulates for consensus choice and their analysis. This analysis shows that the final solution being the consensus of given solutions should be the most credible solution in the uncertain situation.

Consensus based on failure detectors with a perpetual accuracy property

Abstract: This paper is on the Consensus problem, in the context of asynchronous distributed systems made of n processes, at most f of them may crash. A family of failure detector classes satisfying a Perpetual Accuracy property is first defined. This family includes the failure detector class S (the class of Strong failure detectors defined by Chandra and Toueg) central to the definition of a class (S/sub x/) where x is the minimum number (x/spl ges/1) of correct processes that can never be suspected to have crashed Then, a protocol that solves the Consensus problem is given. This protocol works with any failure detector class (S/sub x/) of this family. It is particularly simple and uses a Reliable Broadcast protocol as a skeleton. It requires n-x+1 communication steps, and its communication bit complexity is (n-x+1)(n-1)|/spl nu/| (where |/spl nu/| is the maximal size of an initial value a process can propose).

On building blocks for distributed systems

Abstract: In this thesis we have investigated two building blocks for distributed systems: group communication services and distributed consensus services. Using group communication services is a successful approach in developing fault tolerant distributed applications. Such services provide communication tools that greatly facilitate the development of applications. Though many existing systems are used in real world applications, there is still the need of providing formal specifications for the group communication services offered by these systems. Great efforts are being made by many researchers to provide such specifications. In this thesis we have tackled this problem and have provided specifications for group communication services. One of our specifications considers the notion of primary view; another one generalizes this notion to that of primary configurations (views with quorums). Both specifications are shown to be implementable. The usefulness of both specifications is demonstrated by applications running on top of them. Our specifications are tailored to dynamic systems, where processes join and leave the system even permanently. We also showed how the approach used to develop the specifications can be applied to transform known algorithms, designed for stating settings, in order to make them adaptable to dynamic systems. Distributed consensus is the abstraction of many coordination problems, which are of fundamental importance in distributed systems. Distributed consensus has been thoroughly studied and one important result showed that it is not possible to solve consensus in asynchronous systems if failures are allowed. However in such systems it is possible to solve the k-set consensus problem, which is a relaxed version of the consensus problem: each participating process begins the protocol with an input value and by the end of the protocol it must decide on one value so that at most k total values are decided by all correct processes (the classical consensus problem requires that there be a unique value decided by all correct processes). In this thesis we have investigated the k-set consensus problem in asynchronous distributed systems. We extended previous work by exploring several variations of the problem definition and model, including for the first time investigation of Byzantine failures. We showed that the precise definition of the validity requirement, which characterizes what decision values are allowed as a function of the input values and whether failures occur, is crucial to the solvability of the problem. We introduced six validity conditions for this problem (all considered in various contexts in the literature), and we demarcated the line between possible and impossible for each case. In many cases this line is different from the one of the originally studied k-set consensus problem. (Copies available exclusively from MIT Libraries, Rm. 14-0551, Cambridge, MA 02139-4307. Ph. 617-253-5668; Fax 617-253-1690.)

Internet protocols for distributed consensus : the DiCons language

Abstract: In this paper a new speciication language DiCons (Distributed Consensus) is introduced to specify Internet protocols for distributed consensus. Major characteristic of this class of protocols is that a number of users strive to reach a common goal (e.g. make an appointment, evaluate a paper, select a \winner"). The problem is that the users do not want to physically meet to solve their goal, nor will there be any synchronized communications between the users. A central system, viz. an Internet application, must be used to collect and distribute all relevant information. Our goal is to develop a language in which the aforementioned protocols can easily be speciied. The language must both be expressive enough and concrete. In order to be applicable to an appropriate range of problems, it must have the right expressive power. The language must be concrete enough, such that automatic generation of an executable is feasible.

Efficient Algorithms to Implement Failure Detectors and Solve Consensus in Distributed Systems

Abstract: The consensus problem is a fundamental paradigm for fault-tolerant distributed computing. It abstracts a family of problems known as agreement problems, e.g., atomic broadcast, atomic commitment, group membership, and leader election. Any solution to Consensus can serve as a basic building block for solving such problems. It is well known that Consensus cannot be solved deterministically in an asynchronous system that is subject to even a single process crash. This impossibility result stems from the lack of reliable failure detection in such a system. To circumvent such impossibility results, Chandra and Toueg introduced the concept of unreliable failure detectors, and show how to use them to solve Consensus. Instead of giving specific implementations, they characterized failure detectors in terms of abstract properties. This thesis focuses on the design of algorithms implementing failure detectors and its use to solve Consensus. We consider a partially synchronous system in which Consensus has been proven to be solvable. We first show that no one of the failure detector classes satisfying perpetual accuracy can be implemented in such a system. We then propose efficient algorithms implementing all the failure detector classes satisfying eventual accuracy. We also propose an optimal algorithm implementing diamond S, the weakest failure detector class for solving Consensus. We also propose a new class of failure detectors, the Eventually Consistent class, denoted diamond C. This class adds an eventual leader election capability to the failure detection capability of other classes. We show that diamond C is equivalent to diamond S. We also show that diamond C can be implemented as efficiently as diamond S. We propose a Consensus algorithm that successfully exploits the leader election capability of diamond C and performs better that all the previously proposed algorithms, which shows the potential of this new class of failure detectors.

Consensus in asynchronous distributed systems

Abstract: The distributed consensus problem arises when several processes need to reach a common decision despite failures. The importance of this problem is due to its omnipresence in distributed computation: we need consensus to implement reliable communications, atomic commitment, consistency checks, resources allocations etc. The solvability of this problem is strictly related to the nature of the system it is conceived in. When an asynchronous system is considered, a research result states the impossibility of deterministically reaching consensus when even one single fault occurs. In this paper we will focus our attention on the models proposed to overcome this result and the research originated from them. Key-words: Fault-tolerance, distributed systems, distributed consensus, failure detectors, partial synchrony, quasi-synchronous systems, timed asynchronous systems.

Average Consensus in Numerical Taxonomy and Some Generalizations

Abstract: This paper is devoted to the notion of average consensus together with some generalizations involving L p -norms.

Quorum-Based Replication in Asynchronous Crash-Recovery Distributed Systems (Research Note)

Abstract: This paper describes a solution to the replica management problem in asynchronous distributed systems in which processes can crash and recover. Our solution is based on an Atomic Broadcast primitive which, in turn, is based on an underlying Consensus algorithm. The proposed technique makes a bridge between established results on Weighted Voting and recent results on the Consensus problem.

Quorum-Based Replication in Asynchronous Crash-Recovery Distributed Systems

Abstract: This paper describes a solution to the replica management problem in asynchronous distributed systems in which processes can crash and recover. Our solution is based on an Atomic Broadcast primitive which, in turn, is based on an underlying Consensus algorithm. The proposed technique makes a bridge between established results on Weighted Voting and recent results on the Consensus problem.

The consensus power of shared-memory distributed systems

Abstract: In many asynchronous distributed systems, processes communicate by accessing objects in a shared memory. The ability of systems to solve problems in a fault-tolerant manner depends on the types of objects provided. Here, the wait-free model of fault-tolerance is used: non-faulty processes must run correctly even if other processes experience halting failures. The consensus problem, where processes begin with private inputs and must agree on one of them, has played a central role in analysing the power of distributed systems. This thesis studies the ability of different types of objects to solve consensus. An object type has consensus number n if it can be used (with read/writeregist ers to solve consensus among n processes but not among n+1 processes. Conditions are given that are necessary and sufficient for an object type to have consensus number n. This characterization applies to two large classes of objects: readable objects and read-modify-write (RMW) objects. An object is readable if processes can read its state without changing the state. For a RMW object, all operations update the state and then return the previous state of the object. When the type is of bounded size, the characterization may be used to decide the question “Does the type T have consensus number n?”, which is undecidable for arbitrary types. The characterization is also used to show that different readable and RMW types with consensus number n cannot be used in combination to solve consensus for n +1 processes. Ordinarily, processes may access only one object in shared memory at a time. This thesis also studies how much the consensus number of a type increases in the multi-object and transactional models, where processes can perform operations on up to m of the objects in a single atomic action. These models are much more convenient for programmers to use, since they guarantee that certain blocks of operations will be executed without interruptions from other processes. This thesis establishes bounds on the consensus numbers of multi-objects and transactional objects as a function of m and the consensus numbers of the corresponding single-access types.

Randomized Multivalued Consensus

Abstract: The consensus problem is a fundamental problem one has to solve to implement reliable services or applications on top of asynchronous distributed systems prone to failures. Unfortunately, this problem cannot be solved in those systems as soon as one process crashes (Fischer-Lynch-Paterson's impossibility result). Two approaches have been investigated to circumvent this impossibility result. Both consist in enriching the underlying system with appropriate "oracles". The unreliable failure detector concept proposed by Chandra and Toueg (1996) constitutes one family of such oracles. Since it has been proposed the failure detector based approach has given rise to several failure detector-based consensus protocols. The other family of oracles consists in allowing each process to use a random number generator. In that case, protocol termination is only probabilistic. A few randomized consensus protocols for message-passing asynchronous distributed systems have been proposed. Moreover, they consider that processes can only propose values from a binary set. This paper proposes a new randomized consensus protocol that allows processes to propose arbitrary values. Contrary to other randomized consensus protocols, the proposed protocol does not require the a priori knowledge of the set of values that can be proposed by processes. It relies on a relatively simple combination of randomization and reliable broadcast.

Agreement-related problems

Abstract: Agreement problems constitute a fundamental class of problems in the context of distributed systems. All agreement problems follow a common pattern: all processes must agree on some common decision, the nature of which depends on the specific problem. This dissertation mainly focuses on three important agreements problems: Replication, Total Order Broadcast, and Consensus. Replication is a common means to introduce redundancy in a system, in order to improve its availability. A replicated server is a server that is composed of multiple copies so that, if one copy fails, the other copies can still provide the service. Each copy of the server is called a replica. The replicas must all evolve in manner that is consistent with the other replicas. Hence, updating the replicated server requires that every replica agrees on the set of modifications to carry over. There are two principal replication schemes to ensure this consistency: active replication and passive replication. In Total Order Broadcast, processes broadcast messages to all processes. However, all messages must be delivered in the same order. Also, if one process delivers a message m, then all correct processes must eventually deliver m. The problem of Consensus gives an abstraction to most other agreement problems. All processes initiate a Consensus by proposing a value. Then, all processes must eventually decide the same value v that must be one of the proposed values. These agreement problems are closely related to each other. For instance, Chandra and Toueg [CT96] show that Total Order Broadcast and Consensus are equivalent problems. In addition, Lamport [Lam78] and Schneider [Sch90] show that active replication needs Total Order Broadcast. As a result, active replication is also closely related to the Consensus problem. The first contribution of this dissertation is the definition of the semi-passive replication technique. Semi-passive replication is a passive replication scheme based on a variant of Consensus (called Lazy Consensus and also defined here). From a conceptual point of view, the result is important as it helps to clarify the relation between passive replication and the Consensus problem. In practice, this makes it possible to design systems that react more quickly to failures. The problem of Total Order Broadcast is well-known in the field of distributed systems and algorithms. In fact, there have been already more than fifty algorithms published on the problem so far. Although quite similar, it is difficult to compare these algorithms as they often differ with respect to their actual properties, assumptions, and objectives. The second main contribution of this dissertation is to define five classes of total order broadcast algorithms, and to relate existing algorithms to those classes. The third contribution of this dissertation is to compare the expected performance of the various classes of total order broadcast algorithms. To achieve this goal, we define a set of metrics to predict the performance of distributed algorithms.