Linearizable implementations do not suffice for randomized distributed computation

@article{Golab2011LinearizableID,
  title={Linearizable implementations do not suffice for randomized distributed computation},
  author={Wojciech M. Golab and Lisa Higham and Philipp Woelfel},
  journal={ArXiv},
  year={2011},
  volume={abs/1103.4690}
}
Linearizability is the gold standard among algorithm designers for deducing the correctness of a distributed algorithm using implemented shared objects from the correctness of the corresponding algorithm using atomic versions of the same objects. We show that linearizability does not suffice for this purpose when processes can exploit randomization, and we discuss the existence of alternative correctness conditions. This paper makes the following contributions: 1. Various examples demonstrate… 
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.
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.
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.
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.
Correctness Conditions for Randomized Shared Memory Algorithms
TLDR
In order to be able to employ the power of randomization in shared memory algorithms, the state of the art of finding new correctness conditions that eliminate the deficiencies of linearizability is presented.
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.
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.
Towards a Theory of Randomized Shared Memory Algorithms
TLDR
This talk will give an overview of recent progress towards developing a theory of randomized shared memory algorithms, and present a correctness condition that is suitable for randomized algorithms in certain settings, and why in other settings no such correctness condition exists.
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.
The correctness proof of Ben-Or’s randomized consensus algorithm
TLDR
This paper presents a correctness proof for Ben-Or’s randomized consensus algorithm for the case that f < n/2 process crashes and the adversary is strong (i.e., it can see the process states and message contents, and schedule the process steps and message receipts accordingly).
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 24 REFERENCES
Distributed Algorithms
  • N. Lynch
  • Computer Science
    Lecture Notes in Computer Science
  • 1994
TLDR
This book familiarizes readers with important problems, algorithms, and impossibility results in the area, and teaches readers how to reason carefully about distributed algorithms-to model them formally, devise precise specifications for their required behavior, prove their correctness, and evaluate their performance with realistic measures.
Randomized protocols for asynchronous consensus
  • J. Aspnes
  • Computer Science
    Distributed Computing
  • 2003
TLDR
This work illustrates the history and structure of randomized asynchronous consensus protocols by giving detailed descriptions of several such protocols.
On processor coordination using asynchronous hardware
TLDR
It is shown that the coordination problem cannot be solved by means of a deterministic protocol even if the system consists of only two processors, and the impossibility result holds for the most powerful type of shared atomic registers and does not assume symmetric protocols.
Obstruction-free synchronization: double-ended queues as an example
We introduce obstruction-freedom, a new nonblocking property for shared data structure implementations. This property is strong enough to avoid the problems associated with locks, but it is weaker
A fast, scalable mutual exclusion algorithm
TLDR
A new algorithm forN-process mutual exclusion that requires only read and write operations and that hasO(logN) time complexity, where “time” is measured by counting remote memory references.
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.
On achieving consensus using a shared memory
TLDR
This paper develops randomized algorithms for a model in which the only atomic operations on the shared memory are reads and writes.
Constant-RMR implementations of CAS and other synchronization primitives using read and write operations
TLDR
This work shows how to implement consensus, all comparison primitives (such as CAS and TAS), and load-linked/store-conditional using only a constant number of remote memory references (RMRs), in both the cache-coherent and the distributed-shared-memory models of such multiprocessors.
Atomic shared register access by asynchronous hardware
  • P. Vitányi, B. Awerbuch
  • Computer Science
    27th Annual Symposium on Foundations of Computer Science (sfcs 1986)
  • 1986
TLDR
This paper describes two ways to construct multivalued atomic n-writer n-reader registers and applies the method to prove atomicity of the two implementations for atomic multiwriter multireader registers.
...
1
2
3
...