24,788 research outputs found
Generating Fast Indulgent Algorithms
Synchronous distributed algorithms are easier to design and prove correct than algorithms that tolerate asynchrony. Yet, in the real world, networks experience asynchrony and other timing anomalies. In this paper, we address the question of how to efficiently transform an algorithm that relies on synchronous timing into an algorithm that tolerates asynchronous executions. We introduce a transformation technique from synchronous algorithms to indulgent algorithms (Guerraoui, in PODC, pp. 289-297, 2000), which induces only a constant overhead in terms of time complexity in well-behaved executions. Our technique is based on a new abstraction we call an asynchrony detector, which the participating processes implement collectively. The resulting transformation works for the class of colorless distributed tasks, including consensus and set agreement. Interestingly, we also show that our technique is relevant for colored tasks, by applying it to the renaming problem, to obtain the first indulgent renaming algorith
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 Universe of Symmetry Breaking Tasks
Processes in a concurrent system need to coordinate using a shared memory or a message-passing subsystem in order to solve agreement tasks such as, for example, consensus or set agreement. However, often coordination is needed to âbreak the symmetryâ of processes that are initially in the same state, for example, to get exclusive access to a shared resource, to get distinct names or to elect a leader. This paper introduces and studies the family of generalized symmetry breaking (GSB) tasks, that includes election, renaming and many other symmetry breaking tasks. Differently from agreement tasks, a GSB task is âinputlessâ, in the sense that processes do not propose values; the task specifies only the symmetry breaking requirement, independently of the system's initial state (where processes differ only on their identifiers). Among many various characterizing the family of GSB tasks, it is shown that (non adaptive) perfect renaming is universal for all GSB tasks
On Redundancy Elimination Tolerant Scheduling Rules
In (Ferrucci, Pacini and Sessa, 1995) an extended form of resolution, called
Reduced SLD resolution (RSLD), is introduced. In essence, an RSLD derivation is
an SLD derivation such that redundancy elimination from resolvents is performed
after each rewriting step. It is intuitive that redundancy elimination may have
positive effects on derivation process. However, undesiderable effects are also
possible. In particular, as shown in this paper, program termination as well as
completeness of loop checking mechanisms via a given selection rule may be
lost. The study of such effects has led us to an analysis of selection rule
basic concepts, so that we have found convenient to move the attention from
rules of atom selection to rules of atom scheduling. A priority mechanism for
atom scheduling is built, where a priority is assigned to each atom in a
resolvent, and primary importance is given to the event of arrival of new atoms
from the body of the applied clause at rewriting time. This new computational
model proves able to address the study of redundancy elimination effects,
giving at the same time interesting insights into general properties of
selection rules. As a matter of fact, a class of scheduling rules, namely the
specialisation independent ones, is defined in the paper by using not trivial
semantic arguments. As a quite surprising result, specialisation independent
scheduling rules turn out to coincide with a class of rules which have an
immediate structural characterisation (named stack-queue rules). Then we prove
that such scheduling rules are tolerant to redundancy elimination, in the sense
that neither program termination nor completeness of equality loop check is
lost passing from SLD to RSLD.Comment: 53 pages, to appear on TPL
Commutative positive varieties of languages
We study the commutative positive varieties of languages closed under various
operations: shuffle, renaming and product over one-letter alphabets
- âŠ