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

@inproceedings{Attiya2021ImpossibilityOS,
  title={Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers},
  author={Hagit Attiya and Constantin Enea and Jennifer L. Welch},
  booktitle={DISC},
  year={2021}
}
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… Expand

Figures from this paper

An Impossibility Result on Strong Linearizability in Message-Passing Systems
TLDR
It is proved that there is no 1-resilient strongly linearizable implementation of a weak object in asynchronous message-passing systems, and this weak object can be directly implemented by a single-writer single-reader (SWSR) register. Expand

References

SHOWING 1-10 OF 28 REFERENCES
An Impossibility Result on Strong Linearizability in Message-Passing Systems
TLDR
It is proved that there is no 1-resilient strongly linearizable implementation of a weak object in asynchronous message-passing systems, and this weak object can be directly implemented by a single-writer single-reader (SWSR) register. Expand
Strongly Linearizable Implementations of Snapshots and Other Types
TLDR
This work gives the first strongly linearizable lock-free snapshot implementation that uses bounded space, and proves that all types in this class have aLock-free stronglylinearizable implementation from atomic registers. Expand
Strongly linearizable implementations: possibilities and impossibilities
TLDR
For several objects including multi-writer registers, max-registers, snapshots, and counters there is no strongly linearizable, non-blocking implementation from multi-reader/single-writer atomic registers, even though each of these objects has a linearizable implementation meeting the stronger wait-free progress requirement. Expand
Wait-Freedom is Harder Than Lock-Freedom Under Strong Linearizability
TLDR
This paper proves the impossibility of wait-free strongly linearizable implementations for a number of standard objects, including snapshots, counters, and max-registers, and introduces a new notion of group valency that is useful to analyze stronglylinearizable implementations from registers. Expand
Sharing memory robustly in message-passing systems
Emulators that translate algorithms from the shared-memory model to two different message-passing models are presented. Both are achieved by implementing a wait-free, atomic, single-writerExpand
Wait-free data structures in the asynchronous PRAM model
TLDR
This paper gives an algebraic characterization of a large class of objects that do have wait-free implementations in asynchronous PRAM, as well as a general algorithm for implementing them. Expand
Linearizable Implementations Suffice for Termination of Randomized Concurrent Programs
TLDR
A simple modification of some existing linearizable implementations is proposed with the property that if a concurrent program has non-zero termination probability when used with atomic objects, then it also hasnon-zerotermination probability when it is used with the modifiedlinearizable implementations. Expand
Robust emulation of shared memory using dynamic quorum-acknowledged broadcasts
TLDR
A robust emulation of multi-writer/multireader registers in message-passing systems using dynamic quorum configurations is presented, i.e., on-line replacements of one quorum system consisting of read and write quorums with another such system. Expand
On Linearizability and the Termination of Randomized Algorithms
TLDR
Every randomized algorithm A has a corresponding algorithm A' that solves the same problem if the registers that it uses are atomic or strongly-linearizable, but does not terminate if these registers are replaced with "merely" linearizable ones: with a strong adversary the resulting algorithm may not terminate. Expand
Linearizable implementations do not suffice for randomized distributed computation
TLDR
It is proved that a strong adversary (i.e., one that sees the outcome of each coin flip immediately) gains no additional power when atomic objects are replaced by strongly linearizable implementations, and that strong linearizability is a local and composable property. Expand
...
1
2
3
...