9 research outputs found
Compositional competitiveness for distributed algorithms
We define a measure of competitive performance for distributed algorithms
based on throughput, the number of tasks that an algorithm can carry out in a
fixed amount of work. This new measure complements the latency measure of Ajtai
et al., which measures how quickly an algorithm can finish tasks that start at
specified times. The novel feature of the throughput measure, which
distinguishes it from the latency measure, is that it is compositional: it
supports a notion of algorithms that are competitive relative to a class of
subroutines, with the property that an algorithm that is k-competitive relative
to a class of subroutines, combined with an l-competitive member of that class,
gives a combined algorithm that is kl-competitive.
In particular, we prove the throughput-competitiveness of a class of
algorithms for collect operations, in which each of a group of n processes
obtains all values stored in an array of n registers. Collects are a
fundamental building block of a wide variety of shared-memory distributed
algorithms, and we show that several such algorithms are competitive relative
to collects. Inserting a competitive collect in these algorithms gives the
first examples of competitive distributed algorithms obtained by composition
using a general construction.Comment: 33 pages, 2 figures; full version of STOC 96 paper titled "Modular
competitiveness for distributed algorithms.
The Committee Decision Problem
We introduce the (b,n)-Committee Decision Problem (CD) - a generalization of the consensus problem. While set agreement generalizes consensus in terms of the number of decisions allowed, the CD problem generalizes consensus in the sense of considering many instances of consensus and requiring a processor to decide in at least one instance. In more detail, in the CD problem each one of a set of n processes has a (possibly distinct) value to propose to each one of a set of b consensus problems, which we call committees. Yet a process has to such that all processes deciding for the same committee decide the same value. We study the CD problem in the context of a wait-free distributed system and analyze it using a combination of distributed algorithmic and topological techniques, introducing a novel reduction technique. We use the reduction technique to obtain the following results. We show that the (2,3)-CD problem is equivalent to the musical benches problem of Gafni and Rajsbaum (DISC 2005), and both are equivalent to (2,3)-set agreement, closing an open question left there. Thus, all three problems are wait-free unsolvable in a read/write shared memory system, and they are all solvable if the system is enriched with objects capable of solving (2,3)-set agreement. While the previous proof of the impossibility of musical benches was based on the Borsuk-Ulam (BU) Theorem, it now relies on Sperner's Lemma, opening intriguing questions about the relation between BU and distributed computing tasks. // Ce rapport présente un problème de prise de décisionsmultiples (qui généralise le problème du consensus) et étudie sa calculabilité (à l'aide de techniques de réductions)
The Computational Power of Distributed Shared-Memory Models with Bounded-Size Registers
The celebrated Asynchronous Computability Theorem of Herlihy and Shavit (STOC
1993 and STOC 1994) provided a topological characterization of the tasks that
are solvable in a distributed system where processes are communicating by
writing and reading shared registers, and where any number of processes can
fail by crashing. However, this characterization assumes the use of
full-information protocols, that is, protocols in which each time any of the
processes writes in the shared memory, it communicates everything it learned
since the beginning of the execution. Thus, the characterization implicitly
assumes that each register in the shared memory is of unbounded size. Whether
unbounded size registers are unavoidable for the model of computation to be
universal is the central question studied in this paper. Specifically, is any
task that is solvable using unbounded registers solvable using registers of
bounded size? More generally, when at most processes can crash, is the
model with bounded size registers universal? These are the questions answered
in this paper