7,644 research outputs found
The Weakest Failure Detector for Solving Wait-Free, Eventually Bounded-Fair Dining Philosophers
This dissertation explores the necessary and sufficient conditions to solve a variant
of the dining philosophers problem. This dining variant is defined by three properties:
wait-freedom, eventual weak exclusion, and eventual bounded fairness. Wait-freedom
guarantees that every correct hungry process eventually enters its critical
section, regardless of process crashes. Eventual weak exclusion guarantees that every
execution has an infinite suffix during which no two live neighbors execute overlapping
critical sections. Eventual bounded fairness guarantees that there exists a
fairness bound k such that every execution has an infinite suffix during which no
correct hungry process is overtaken more than k times by any neighbor. This dining
variant (WF-EBF dining for short) is important for synchronization tasks where eventual
safety (i.e., eventual weak exclusion) is sufficient for correctness (e.g., duty-cycle
scheduling, self-stabilizing daemons, and contention managers).
Unfortunately, it is known that wait-free dining is unsolvable in asynchronous
message-passing systems subject to crash faults. To circumvent this impossibility
result, it is necessary to assume the existence of bounds on timing properties, such
as relative process speeds and message delivery time. As such, it is of interest to
characterize the necessary and sufficient timing assumptions to solve WF-EBF dining.
We focus on implicit timing assumptions, which can be encapsulated by failure detectors. Failure detectors can be viewed as distributed oracles that can be queried
for potentially unreliable information about crash faults. The weakest detector D for
WF-EBF dining means that D is both necessary and sufficient. Necessity means that
every failure detector that solves WF-EBF dining is at least as strong as D. Sufficiency
means that there exists at least one algorithm that solves WF-EBF dining using D.
As such, our research goal is to characterize the weakest failure detector to solve
WF-EBF dining.
We prove that the eventually perfect failure detector 3P is the weakest failure
detector for solving WF-EBF dining. 3P eventually suspects crashed processes permanently,
but may make mistakes by wrongfully suspecting correct processes finitely
many times during any execution. As such, 3P eventually stops suspecting correct
processes
Anonymous Asynchronous Systems: The Case of Failure Detectors
Due the multiplicity of loci of control, a main issue distributed systems have to cope with lies in the uncertainty on the system state created by the adversaries that are asynchrony, failures, dynamicity, mobility, etc. Considering message-passing systems, this paper considers the uncertainty created by the net effect of three of these adversaries, namely, asynchrony, failures, and anonymity. This means that, in addition to be asynchronous and crash-prone, the processes have no identity. Trivially, agreement problems (e.g., consensus) that cannot be solved in presence of asynchrony and failures cannot be solved either when adding anonymity. The paper consequently proposes anonymous failure detectors to circumvent these impossibilities. It has several contributions. First it presents three classes of failure detectors (denoted AP, Aâ© and Aâ) and show that they are the anonymous counterparts of the classes of perfect failure detectors, eventual leader failure detectors and quorum failure detectors, respectively. The class Aâ is new and showing it is the anonymous counterpart of the class â is not trivial. Then, the paper presents and proves correct a genuinely anonymous consensus algorithm based on the pair of anonymous failure detector classes (Aâ©, Aâ) (âgenuinelyâ means that, not only processes have no identity, but no process is aware of the total number of processes). This new algorithm is not a âstraightforward extensionâ of an algorithm designed for non-anonymous systems. To benefit from Aâ, it uses a novel message exchange pattern where each phase of every round is made up of sub-rounds in which appropriate control information is exchanged. Finally, the paper discusses the notions of failure detector class hierarchy and weakest failure detector class for a given problem in the context of anonymous systems
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
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
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
- âŠ