Wait-Freedom is Harder Than Lock-Freedom Under Strong Linearizability

@inproceedings{Denysyuk2015WaitFreedomIH,
  title={Wait-Freedom is Harder Than Lock-Freedom Under Strong Linearizability},
  author={Oksana Denysyuk and Philipp Woelfel},
  booktitle={DISC},
  year={2015}
}
In randomized algorithms, replacing atomic shared objects with linearizable [1] implementations may affect probability distributions over outcomes [2]. To avoid this problem in the adaptive adversary model, it is necessary and sufficient that implemented objects satisfy strong linearizability [2]. In this paper we study the existence of strongly linearizable implementations from multi-writer registers. We prove the impossibility of wait-free strongly linearizable implementations for a number of… 
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.
Blunting an Adversary Against Randomized Concurrent Programs with Linearizable Implementations
TLDR
It is proved that the probability of a bad outcome decreases with the number of repetitions, approaching the probability attained when using atomic objects.
Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers
TLDR
There are no strongly-linearizable fault-tolerant message-passing implementations of multi-writer registers, max-registers, snapshots or counters, and 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.
Strongly Linearizable Linked List and Queue
TLDR
The algorithms described are the first instances of non-trivial, strongly linearizable data structures of their type not derived by a universal construction.
Separating Lock-Freedom from Wait-Freedom
TLDR
This paper proves that there are objects with lock-free implementations, but without wait- free implementations-using objects of any finite power, by proving an object called n-process long-lived approximate agreement (n-LLAA).
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.
On Register Linearizability and Termination
TLDR
This paper first shows that a randomized algorithm can indeed lose its termination property if the authors replace the atomic registers that it uses with linearizable ones, and proposes a new type of register linearizability, called write strong-linearizable, that is strictly stronger than (plain)linearizability but strictly weaker than strong linearIZability.
Are Shared Objects Composable under an Oblivious Adversary?
TLDR
The fundamental question of what property makes implementations composable under an oblivious adversary is asked and it turns out that the property depends on the entire collection of objects used in the algorithm, which shows that it is much harder to implement reusable object types than previously believed.
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.
...
...

References

SHOWING 1-10 OF 10 REFERENCES
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.
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.
Impossibility results for asynchronous PRAM (extended abstract)
TLDR
This papers shows that the extent to which asynchronous PRAM permits long-lived, highly concurrent data structures is no and there is a strict infinite hierarchy among objects that do not solve consensus.
Wait-free synchronization
TLDR
A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.
Linearizability: a correctness condition for concurrent objects
TLDR
This paper defines linearizability, compares it to other correctness conditions, presents and demonstrates a method for proving the correctness of implementations, and shows how to reason about concurrent objects, given they are linearizable.
Max registers, counters, and monotone circuits
TLDR
It is shown how a max register can be used to transform any monotone circuit into a wait-free concurrent data structure that provides write operations setting the inputs to the circuit and a read operation that returns the value of the circuit on the largest input values previously supplied.
Atomic snapshots of shared memory
TLDR
A general formulation of atonuc wzap~hot rnenzory, a shared memory partitioned into words written (apduted) by individual processes, or instantaneously read (scanned) in its entirety is introduced.
Impossibility of distributed consensus with one faulty process
TLDR
In this paper, it is shown that every protocol for this problem has the possibility of nontermination, even with only one faulty process.
Distributed Algorithms
  • Seif Haridi
  • Computer Science
    Lecture Notes in Computer Science
  • 1992
Memory requirements for agreement among unreliable asynchronous processes
  • Advances in Computing Research
  • 1987