Nontrivial and universal helping for wait-free queues and stacks

Attiya, Hagit; Castañeda, Armando; Hendler, Danny

doi:10.1016/j.jpdc.2018.06.004

Cited by 13 publications

(16 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Val[i]: register written by p i , holding a proposal, initially ⊥; 0 ≤ i < m Id[i]: register written by p i , holding its own id; initially ⊥; 0 ≤ i < m Set[i]: register written by p i , holding a set of process ids, initially ∅; 0 ≤ i < m there is no wait-free strongly-linearizable implementation of a monotonic counter [8], and, by reduction, neither of snapshots nor of max-registers. Queues and stacks do not have an n-process nonblocking strongly-linearizable implementation from objects whose readable versions have consensus number less than n [4].…”

Section: An Implementation Of Safe Agreementmentioning

confidence: 99%

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Attiya¹,

Constantin²,

Welch³

2021

Preprint

Self Cite

View full text Add to dashboard Cite

A key way to construct complex distributed systems is through modular composition of linearizable concurrent objects. A prominent example is shared registers, which have crash-tolerant implementations on top of message-passing systems, allowing the advantages of shared memory to carry over to message-passing. Yet linearizable registers do not always behave properly when used inside randomized programs. A strengthening of linearizability, called strong linearizability, has been shown to preserve probabilistic behavior, as well as other "hypersafety" properties. In order to exploit composition and abstraction in message-passing systems, it is crucial to know whether there exist strongly-linearizable implementations of registers in message-passing. This paper answers the question in the negative: there are no strongly-linearizable fault-tolerant message-passing implementations of multi-writer registers, max-registers, snapshots or counters. This result is proved by reduction from the corresponding result by Helmi et al. The reduction is a novel extension of the BG simulation that connects shared-memory and message-passing, supports long-lived objects, and preserves strong linearizability. The main technical challenge arises from the discrepancy between the potentially miniscule fraction of failures to be tolerated in the simulated message-passing algorithm and the large fraction of failures that can afflict the simulating shared-memory system. The reduction is general and can be viewed as the reverse of the ABD simulation of shared memory in message-passing.

show abstract

Section: An Implementation Of Safe Agreementmentioning

confidence: 99%

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Attiya¹,

Constantin²,

Welch³

2021

Preprint

Self Cite

View full text Add to dashboard Cite

show abstract

“…We then consider how data structures use helping in the crash-stop model by adopting the definitions of linearization-helping [9] and universal-helping [5]. When considering an execution with two concurrent operations, the linearization of these operations dictates which operation take effect first.…”

Section: Contributionsmentioning

confidence: 99%

“…Censor-Hillel et al [9] formalized linearization-helping and showed that without it, certain objects called exact-order types lack wait-free linearizable implementations (assuming only read, write, compare-and-swap, fetch-and-add primitives) in the standard crash-stop shared memory model. Universal-helping and valency-helping were defined by Attiya et al [5]. Informally, it was shown in [5] that a non-blocking n-process linearizable implementation of a queue or a stack with universal-helping can be used to solve n-process consensus.…”

Section: Related Workmentioning

confidence: 99%

Separation and Equivalence results for the Crash-stop and Crash-recovery Shared Memory Models

Ben-Baruch,

Ravi

2020

Preprint

View full text Add to dashboard Cite

Linearizability, the traditional correctness condition for concurrent data structures is considered insufficient for the non-volatile shared memory model where processes recover following a crash. For this crash-recovery shared memory model, strict-linearizability is considered appropriate since, unlike linearizability, it ensures operations that crash take effect prior to the crash or not at all. This work formalizes and answers the question of whether an implementation of a data type derived for the crash-stop shared memory model is also strict-linearizable in the crash-recovery model.This work presents a rigorous study to prove how helping mechanisms, typically employed by non-blocking implementations, is the algorithmic abstraction that delineates linearizability from strict-linearizability. Our first contribution formalizes the crash-recovery model and how explicit process crashes and recovery introduces further dimensionalities over the standard crash-stop shared memory model. We make the following technical contributions that answer the question of whether a help-free linearizable implementation is strict-linearizable in the crash-recovery model: (i) we prove surprisingly that there exist linearizable implementations of object types that are help-free, yet not strict-linearizable; (ii) we then present a natural definition of help-freedom to prove that any obstruction-free, linearizable and help-free implementation of a total object type is also strict-linearizable. The next technical contribution addresses the question of whether a strict-linearizable implementation in the crash-recovery model is also help-free linearizable in the crash-stop model. To that end, we prove that for a large class of object types, a non-blocking strict-linearizable implementation cannot have helping. Viewed holistically, this work provides the first precise characterization of the intricacies in applying a concurrent implementation designed for the crash-stop (and resp. crash-recovery) model to the crash-recovery (and resp. crash-stop) model.

show abstract

“…Therefore, there exists a strongly linearizable implementation of any type using atomic compare-and-swap objects, for example. On the other hand, Attiya, Castañeda, and Hendler [11] have shown that any wait-free strongly linearizable implementation of a queue or a stack for n processes along with atomic registers can solve n-process consensus. Hence, any n-process wait-free strongly linearizable implementation of a queue or stack cannot be implemented from base objects with consensus number less than n.…”

Section: Related Workmentioning

confidence: 99%

Strongly Linearizable Implementations of Snapshots and Other Types

Ovens

Woelfel

2019

Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

Linearizability is the gold standard of correctness conditions for shared memory algorithms, and historically has been considered the practical equivalent of atomicity. However, it has been shown [1] that replacing atomic objects with linearizable implementations can affect the probability distribution of execution outcomes in randomized algorithms. Thus, linearizable objects are not always suitable replacements for atomic objects. A stricter correctness condition called strong linearizability has been developed and shown to be appropriate for randomized algorithms in a strong adaptive adversary model [1].We devise several new lock-free strongly linearizable implementations from atomic registers. In particular, we give the first strongly linearizable lock-free snapshot implementation that uses bounded space. This improves on the unbounded space solution of Denysyuk and Woelfel [2]. As a building block, our algorithm uses a lock-free strongly linearizable ABA-detecting register. We obtain this object by modifying the wait-free linearizable ABA-detecting register of Aghazadeh and Woelfel [3], which, as we show, is not strongly linearizable.Aspnes and Herlihy [4] identified a wide class types that have wait-free linearizable implementations from atomic registers. These types require that any pair of operations either commute, or one overwrites the other. Aspnes and Herlihy gave a general wait-free linearizable implementation of such types, employing a wait-free linearizable snapshot object. Replacing that snapshot object with our lock-free strongly linearizable one, we prove that all types in this class have a lock-free strongly linearizable implementation from atomic registers.

show abstract

Nontrivial and universal helping for wait-free queues and stacks

Cited by 13 publications

References 16 publications

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Separation and Equivalence results for the Crash-stop and Crash-recovery Shared Memory Models

Strongly Linearizable Implementations of Snapshots and Other Types

Contact Info

Product

Resources

About