3,559 research outputs found
Wait-Freedom with Advice
We motivate and propose a new way of thinking about failure detectors which
allows us to define, quite surprisingly, what it means to solve a distributed
task \emph{wait-free} \emph{using a failure detector}. In our model, the system
is composed of \emph{computation} processes that obtain inputs and are supposed
to output in a finite number of steps and \emph{synchronization} processes that
are subject to failures and can query a failure detector. We assume that, under
the condition that \emph{correct} synchronization processes take sufficiently
many steps, they provide the computation processes with enough \emph{advice} to
solve the given task wait-free: every computation process outputs in a finite
number of its own steps, regardless of the behavior of other computation
processes. Every task can thus be characterized by the \emph{weakest} failure
detector that allows for solving it, and we show that every such failure
detector captures a form of set agreement. We then obtain a complete
classification of tasks, including ones that evaded comprehensible
characterization so far, such as renaming or weak symmetry breaking
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
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)
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
Consensus using Asynchronous Failure Detectors
The FLP result shows that crash-tolerant consensus is impossible to solve in
asynchronous systems, and several solutions have been proposed for
crash-tolerant consensus under alternative (stronger) models. One popular
approach is to augment the asynchronous system with appropriate failure
detectors, which provide (potentially unreliable) information about process
crashes in the system, to circumvent the FLP impossibility.
In this paper, we demonstrate the exact mechanism by which (sufficiently
powerful) asynchronous failure detectors enable solving crash-tolerant
consensus. Our approach, which borrows arguments from the FLP impossibility
proof and the famous result from CHT, which shows that is a weakest
failure detector to solve consensus, also yields a natural proof to as
a weakest asynchronous failure detector to solve consensus. The use of I/O
automata theory in our approach enables us to model execution in a more
detailed fashion than CHT and also addresses the latent assumptions and
assertions in the original result in CHT
On the Hardness of the Strongly Dependent Decision Problem
We present necessary and sufficient conditions for solving the strongly
dependent decision (SDD) problem in various distributed systems. Our main
contribution is a novel characterization of the SDD problem based on point-set
topology. For partially synchronous systems, we show that any algorithm that
solves the SDD problem induces a set of executions that is closed with respect
to the point-set topology. We also show that the SDD problem is not solvable in
the asynchronous system augmented with any arbitrarily strong failure
detectors.Comment: Appeared in ICDCN 201
Solving k-Set Agreement with Stable Skeleton Graphs
In this paper we consider the k-set agreement problem in distributed
message-passing systems using a round-based approach: Both synchrony of
communication and failures are captured just by means of the messages that
arrive within a round, resulting in round-by-round communication graphs that
can be characterized by simple communication predicates. We introduce the weak
communication predicate PSources(k) and show that it is tight for k-set
agreement, in the following sense: We (i) prove that there is no algorithm for
solving (k-1)-set agreement in systems characterized by PSources(k), and (ii)
present a novel distributed algorithm that achieves k-set agreement in runs
where PSources(k) holds. Our algorithm uses local approximations of the stable
skeleton graph, which reflects the underlying perpetual synchrony of a run. We
prove that this approximation is correct in all runs, regardless of the
communication predicate, and show that graph-theoretic properties of the stable
skeleton graph can be used to solve k-set agreement if PSources(k) holds.Comment: to appear in 16th IEEE Workshop on Dependable Parallel, Distributed
and Network-Centric System
- …