608 research outputs found
Consensus with Max Registers
We consider the problem of implementing randomized wait-free consensus from max registers under the assumption of an oblivious adversary. We show that max registers solve m-valued consensus for arbitrary m in expected O(log^* n) steps per process, beating the Omega(log m/log log m) lower bound for ordinary registers when m is large and the best previously known O(log log n) upper bound when m is small. A simple max-register implementation based on double-collect snapshots translates this result into an O(n log n) expected step implementation of m-valued consensus from n single-writer registers, improving on the best previously-known bound of O(n log^2 n) for single-writer registers
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 Space Complexity of Scannable Objects with Bounded Components
A fundamental task in the asynchronous shared memory model is obtaining a consistent view of a collection of shared objects while they are being modified concurrently by other processes. A scannable object addresses this problem. A scannable object is a sequence of readable objects called components, each of which can be accessed independently. It also supports the Scan operation, which simultaneously reads all of the components of the object. In this paper, we consider the space complexity of an n-process, k-component scannable object implementation from objects with bounded domain sizes. If the value of each component can change only a finite number of times, then there is a simple lock-free implementation from k objects. However, more objects are needed if each component is fully reusable, i.e. for every pair of values v, v\u27, there is a sequence of operations that changes the value of the component from v to v\u27.
We considered the special case of scannable binary objects, where each component has domain {0, 1}, in PODC 2021. Here, we present upper and lower bounds on the space complexity of any n-process implementation of a scannable object O with k fully reusable components from an arbitrary set of objects with bounded domain sizes. We construct a lock-free implementation from k objects of the same types as the components of O along with ?n/b? objects with domain size 2^b. By weakening the progress condition to obstruction-freedom, we construct an implementation from k objects of the same types as the components of O along with ?n/(b-1)? objects with domain size b.
When the domain size of each component and each object used to implement O is equal to b and n ? b^k - bk + k, we prove that 1/2? (k + (n-1)/b - log_b n) objects are required. This asymptotically matches our obstruction-free upper bound. When n > b^k - bk + k, we prove that 1/2? (b^{k-1} - {(b-1)k + 1}/b) objects are required. We also present a lower bound on the number of objects needed when the domain sizes of the components and the objects used by the implementation are arbitrary and finite
How hard is it to take a snapshot
Abstract. The snapshot object is an important and well-studied primitive in distributed computing. This paper will present some implementations of snapshots from registers, in both asycnhronous and synchronous systems, and discuss known lower bounds on the time and space complexity of this problem
Progress-Space Tradeoffs in Single-Writer Memory Implementations
Many algorithms designed for shared-memory distributed systems assume the single-writer multi- reader (SWMR) setting where each process is provided with a unique register that can only be written by the process and read by all. In a system where computation is performed by a bounded number n of processes coming from a large (possibly unbounded) set of potential participants, the assumption of an SWMR memory is no longer reasonable. If only a bounded number of multi- writer multi-reader (MWMR) registers are provided, we cannot rely on an a priori assignment of processes to registers. In this setting, implementing an SWMR memory, or equivalently, ensuring stable writes (i.e., every written value persists in the memory), is desirable.
In this paper, we propose an SWMR implementation that adapts the number of MWMR registers used to the desired progress condition. For any given k from 1 to n, we present an algorithm that uses n + k ? 1 registers to implement a k-lock-free SWMR memory. In the special case of 2-lock-freedom, we also give a matching lower bound of n + 1 registers, which supports our conjecture that the algorithm is space-optimal. Our lower bound holds for the strictly weaker progress condition of 2-obstruction-freedom, which suggests that the space complexity for k-obstruction-free and k-lock-free SWMR implementations might coincide
Intermediate Value Linearizability: A Quantitative Correctness Criterion
Big data processing systems often employ batched updates and data sketches to
estimate certain properties of large data. For example, a CountMin sketch
approximates the frequencies at which elements occur in a data stream, and a
batched counter counts events in batches. This paper focuses on the correctness
of concurrent implementations of such objects. Specifically, we consider
quantitative objects, whose return values are from a totally ordered domain,
with an emphasis on -bounded objects that estimate a quantity with an
error of at most with probability at least .
The de facto correctness criterion for concurrent objects is linearizability.
Under linearizability, when a read overlaps an update, it must return the
object's value either before the update or after it. Consider, for example, a
single batched increment operation that counts three new events, bumping a
batched counter's value from to . In a linearizable implementation of
the counter, an overlapping read must return one of these. We observe, however,
that in typical use cases, any intermediate value would also be acceptable. To
capture this degree of freedom, we propose Intermediate Value Linearizability
(IVL), a new correctness criterion that relaxes linearizability to allow
returning intermediate values, for instance in the example above. Roughly
speaking, IVL allows reads to return any value that is bounded between two
return values that are legal under linearizability. A key feature of IVL is
that concurrent IVL implementations of -bounded objects remain
-bounded. To illustrate the power of this result, we give a
straightforward and efficient concurrent implementation of an -bounded
CountMin sketch, which is IVL (albeit not linearizable). Finally, we show that
IVL allows for inherently cheaper implementations than linearizable ones
Optimal Resilience in Systems That Mix Shared Memory and Message Passing
We investigate the minimal number of failures that can partition a system where processes communicate both through shared memory and by message passing. We prove that this number precisely captures the resilience that can be achieved by algorithms that implement a variety of shared objects, like registers and atomic snapshots, and solve common tasks, like randomized consensus, approximate agreement and renaming. This has implications for the m&m-model of [Aguilera et al., 2018] and for the hybrid, cluster-based model of [Damien Imbs and Michel Raynal, 2013; Michel Raynal and Jiannong Cao, 2019]
Anonymous Obstruction-free -Set Agreement with Atomic Read/Write Registers
The -set agreement problem is a generalization of the consensus problem.
Namely, assuming each process proposes a value, each non-faulty process has to
decide a value such that each decided value was proposed, and no more than
different values are decided. This is a hard problem in the sense that it
cannot be solved in asynchronous systems as soon as or more processes may
crash. One way to circumvent this impossibility consists in weakening its
termination property, requiring that a process terminates (decides) only if it
executes alone during a long enough period. This is the well-known
obstruction-freedom progress condition. Considering a system of {\it
anonymous asynchronous} processes, which communicate through atomic {\it
read/write registers only}, and where {\it any number of processes may crash},
this paper addresses and solves the challenging open problem of designing an
obstruction-free -set agreement algorithm with atomic registers
only. From a shared memory cost point of view, this algorithm is the best
algorithm known so far, thereby establishing a new upper bound on the number of
registers needed to solve the problem (its gain is with respect to the
previous upper bound). The algorithm is then extended to address the repeated
version of -set agreement. As it is optimal in the number of atomic
read/write registers, this algorithm closes the gap on previously established
lower/upper bounds for both the anonymous and non-anonymous versions of the
repeated -set agreement problem. Finally, for 1 \leq x\leq k
\textless{} n, a generalization suited to -obstruction-freedom is also
described, which requires atomic registers only
- …