1,647 research outputs found
The Weakest Failure Detector for Message Passing Set-Agreement
In the set-agreement problem, n processes seek to agree on at most nâ1 different values. This paper determines the weakest failure detector to solve this problem in a message-passing system where processes may fail by crashing. This failure detector, called the Loneliness detector and denoted L, outputs one of two values, âtrueâ or âfalseâ such that: (1) there is at least one process where L outputs always âfalseâ, and (2) if only one process is correct, L eventually outputs âtrueâ at this process
Looking for the Weakest Failure Detector for -Set Agreement in Message-passing Systems: Is the End of the Road?
In the -set agreement problem, each process (in a set of processes) proposes a value and has to decide a proposed value in such a way that at most different values are decided. While this problem can easily be solved in asynchronous systems prone to process crashes when , it cannot be solved when . Since several years, the failure detector-based approach has been investigated to circumvent this impossibility. While the weakest failure detector class to solve the -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 (consensus) and (set agreement). This paper introduces a candidate for the general case. It presents a new failure detector class, denoted , and shows (the weakest class for ), and (the weakest class for ). Then, the paper investigates the structure of and shows it is the combination of two failures detector classes denoted and (that generalize the previous ``quorums'' and ``eventual leaders'' failure detectors classes). Finally, the paper proves that is a necessary requirement (as far as information on failure is concerned) to solve the -set agreement problem in message-passing systems. The paper presents also a -based algorithm that solves the -set agreement problem. This algorithm provides us with a new algorithmic insight on the way the -set agreeement problem can be solved in asynchronous message-passing systems (insight from the point of view of the non-partitioning constraint defined by )
Chasing the Weakest Failure Detector for k-Set Agreement in Message-passing Systems
This paper continues our quest for the weakest failure detector which allows the k-set agreement problem to be solved in asynchronous message-passing systems prone to any number of process failures. It has two main contributions which (we hope) will be instrumental to complete this quest. The first contribution is a new failure detector (denoted ââx,y). This failure detector has several noteworthy properties. (a) It is stronger than âx which has been shown to be necessary. (b) It is equivalent to the pair (â, Ω) when x = y = 1 (from which it follows that ââ1,1 is optimal to solve consensus). (c) It is equivalent to the pair (ânâ1, Ωnâ1) when x = y = n â 1 (from which it follows that âânâ1, nâ1) is optimal for (n â 1)-set agreement). (d) It is strictly weaker than the pair (âx,Ωy) (which has been investigated in previous works) for the pairs (x, y) such that 1 < y < x < n. (e) It is operational: the paper presents a ââx,y-based algorithm that solves k-set agreement for k â©Ÿ xy. The second contribution of the paper is a proof that, for 1 < k < n â 1, the eventual leaders failure detector k (which eventually provides each process with the same set of k process identities, this set including at least one correct process) is not necessary to solve k-set agreement problem. More precisely, the paper shows that the weakest failure detector for k-set agreement and k cannot be compared
The Weakest Failure Detector for Eventual Consistency
In its classical form, a consistent replicated service requires all replicas
to witness the same evolution of the service state. Assuming a message-passing
environment with a majority of correct processes, the necessary and sufficient
information about failures for implementing a general state machine replication
scheme ensuring consistency is captured by the {\Omega} failure detector. This
paper shows that in such a message-passing environment, {\Omega} is also the
weakest failure detector to implement an eventually consistent replicated
service, where replicas are expected to agree on the evolution of the service
state only after some (a priori unknown) time. In fact, we show that {\Omega}
is the weakest to implement eventual consistency in any message-passing
environment, i.e., under any assumption on when and where failures might occur.
Ensuring (strong) consistency in any environment requires, in addition to
{\Omega}, the quorum failure detector {\Sigma}. Our paper thus captures, for
the first time, an exact computational difference be- tween building a
replicated state machine that ensures consistency and one that only ensures
eventual consistency
Fault-Tolerant Consensus in Unknown and Anonymous Networks
This paper investigates under which conditions information can be reliably
shared and consensus can be solved in unknown and anonymous message-passing
networks that suffer from crash-failures. We provide algorithms to emulate
registers and solve consensus under different synchrony assumptions. For this,
we introduce a novel pseudo leader-election approach which allows a
leader-based consensus implementation without breaking symmetry
Algorithms For Extracting Timeliness Graphs
We consider asynchronous message-passing systems in which some links are
timely and processes may crash. Each run defines a timeliness graph among
correct processes: (p; q) is an edge of the timeliness graph if the link from p
to q is timely (that is, there is bound on communication delays from p to q).
The main goal of this paper is to approximate this timeliness graph by graphs
having some properties (such as being trees, rings, ...). Given a family S of
graphs, for runs such that the timeliness graph contains at least one graph in
S then using an extraction algorithm, each correct process has to converge to
the same graph in S that is, in a precise sense, an approximation of the
timeliness graph of the run. For example, if the timeliness graph contains a
ring, then using an extraction algorithm, all correct processes eventually
converge to the same ring and in this ring all nodes will be correct processes
and all links will be timely. We first present a general extraction algorithm
and then a more specific extraction algorithm that is communication efficient
(i.e., eventually all the messages of the extraction algorithm use only links
of the extracted graph)
Set agreement and the loneliness failure detector in crash-recovery systems
The set agreement problem states that from n proposed values at most n-1 can be decided. Traditionally, this problem is solved using a failure detector in asynchronous systems where processes may crash but not recover, where processes have different identities, and where all processes initially know the membership. In this paper we study the set agreement problem and the weakest failure detector L used to solve it in asynchronous message passing systems where processes may crash and recover, with homonyms (i.e., processes may have equal identities) and without a complete initial knowledge of the membership
Agreement in wider environments with weaker assumptions.
The set agreement problem states that from n proposed values at most n?1 can be decided. Traditionally, this problem is solved using a failure detector in asynchronous systems where processes may crash but do not recover, where processes have different identities, and where all processes initially know the membership. In this paper we study the set agreement problem and the weakest failure detector L used to solve it in asynchronous message passing systems where processes may crash and recover, with homonyms (i.e., processes may have equal identities) and without a complete initial knowledge of the membership
- âŠ