21 research outputs found
Relaxed Queues and Stacks from Read/Write Operations
Considering asynchronous shared memory systems in which any number of processes may crash, this work identifies and formally defines relaxations of queues and stacks that can be non-blocking or wait-free while being implemented using only read/write operations. Set-linearizability and Interval-linearizability are used to specify the relaxations formally, and precisely identify the subset of executions which preserve the original sequential behavior. The relaxations allow for an item to be returned more than once by different operations, but only in case of concurrency; we call such a property multiplicity. The stack implementation is wait-free, while the queue implementation is non-blocking. Interval-linearizability is used to describe a queue with multiplicity, with the additional relaxation that a dequeue operation can return weak-empty, which means that the queue might be empty. We present a read/write wait-free interval-linearizable algorithm of a concurrent queue. As far as we know, this work is the first that provides formalizations of the notions of multiplicity and weak-emptiness, which can be implemented on top of read/write registers only
Concurrent Specifications Beyond Linearizability
With the advent of parallel architectures, distributed programs are used intensively and the question of how to formally specify the behaviors expected from such programs becomes crucial. A very general way to specify concurrent objects is to simply give the set of all the execution traces that we consider correct for the object. In many cases, one is only interested in studying a subclass of these concurrent specifications, and more convenient tools such as linearizability can be used to describe them.
In this paper, what we call a concurrent specification will be a set of execution traces that moreover satisfies a number of axioms. As we argue, these are actually the only concurrent specifications of interest: we prove that, in a reasonable computational model, every program satisfies all of our axioms. Restricting to this class of concurrent specifications allows us to formally relate our concurrent specifications with the ones obtained by linearizability, as well as its more recent variants (set- and interval-linearizability)
Brief Announcement: On the Impossibility of Detecting Concurrency
We identify a general principle of distributed computing: one cannot force two processes running in parallel to see each other. This principle is formally stated in the context of asynchronous processes communicating through shared objects, using trace-based semantics. We prove that it holds in a reasonable computational model, and then study the class of concurrent specifications which satisfy this property. This allows us to derive a Galois connection theorem for different variants of linearizability
Efficient Wait-Free Queue Algorithms with Multiple Enqueuers and Multiple Dequeuers
Despite the widespread usage of FIFO queues in distributed applications, designing efficient wait-free implementations of queues remains a challenge. The majority of wait-free queue implementations restrict either the number of dequeuers or the number of enqueuers that can operate on the queue, even when they use strong synchronization primitives, like the Compare&Swap. If we do not limit the number of processes that can perform enqueue and dequeue operations, the best-known upper bound on the worst case step complexity for a wait-free queue is given by [Khanchandani and Wattenhofer, 2018]. In particular, they present an implementation of a multiple dequeuer multiple enqueuer wait-free queue whose worst case step complexity is in O(?n), where n is the number of processes. In this work, we investigate whether it is possible to improve this bound. In particular, we present a wait-free FIFO queue implementation that supports n enqueuers and k dequeuers where the worst case step complexity of an Enqueue operation is in O(log n) and of a Dequeue operation is in O(k log n).
Then, we show that if the semantics of the queue can be relaxed, by allowing concurrent Dequeue operations to retrieve the same element, then we can achieve O(log n) worst-case step complexity for both the Enqueue and Dequeue operations
On Deterministic Linearizable Set Agreement Objects
A recent work showed that, for all n and k, there is a linearizable (n,k)-set agreement object O_L that is equivalent to the (n,k)-set agreement task [David Yu Cheng Chan et al., 2017]: given O_L, it is possible to solve the (n,k)-set agreement task, and given any algorithm that solves the (n,k)-set agreement task (and registers), it is possible to implement O_L. This linearizable object O_L, however, is not deterministic. It turns out that there is also a deterministic (n,k)-set agreement object O_D that is equivalent to the (n,k)-set agreement task, but this deterministic object O_D is not linearizable. This raises the question whether there exists a deterministic and linearizable (n,k)-set agreement object that is equivalent to the (n,k)-set agreement task. Here we show that in general the answer is no: specifically, we prove that for all n ? 4, every deterministic linearizable (n,2)-set agreement object is strictly stronger than the (n,2)-set agreement task. We prove this by showing that, for all n ? 4, every deterministic and linearizable (n,2)-set agreement object (together with registers) can be used to solve 2-consensus, whereas it is known that the (n,2)-set agreement task cannot do so. For a natural subset of (n,2)-set agreement objects, we prove that this result holds even for n = 3
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
Linearizability of Saturated Polynomials
Brjuno and R\"ussmann proved that every irrationally indifferent fixed point
of an analytic function with a Brjuno rotation number is linearizable, and
Yoccoz proved that this is sharp for quadratic polynomials. Douady conjectured
that this is sharp for all rational functions of degree at least 2, i.e., that
non-M\"obius rational functions cannot have Siegel disks with non-Brjuno
rotation numbers. We prove that Douady's conjecture holds for the class of
polynomials for which the number of infinite tails of critical orbits in the
Julia set equals the number of irrationally indifferent cycles. As a corollary,
Douady's conjecture holds for the polynomials for all
and all complex .Comment: 28 pages, major revisions and additions following referee comment