Wait-free synchronization

@article{Herlihy1991WaitfreeS,
  title={Wait-free synchronization},
  author={Maurice Herlihy},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1991},
  volume={13},
  pages={124-149}
}
  • M. Herlihy
  • Published 1991
  • Computer Science
  • ACM Trans. Program. Lang. Syst.
A wait-free implementation of a concurrent data object is one that guarantees that any process can complete any operation in a finite number of steps, regardless of the execution speeds of the other processes. The problem of constructing a wait-free implementation of one data object from another lies at the heart of much recent work in concurrent algorithms, concurrent data structures, and multiprocessor architectures. First, we introduce a simple and general technique, based on reduction to a… 

Figures from this paper

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.
Efficient and Practical Composition of Lock-~Free Data Structures
TLDR
This thesis considers a simple yet fundamental problem of combining two stacks to create a queue in a lock-free concurrent setting and simulates the enqueue and dequeue operations of queues using the push and pop operations of stacks.
Competitive Freshness Algorithms for Wait-Free Data Objects
TLDR
A freshness measure for wait-free concurrent data objects is proposed and two algorithms for it are presented, including a deterministic algorithm with asymptotically optimal competitive ratio and a competitive randomized algorithm.
A Universal Construction for Concurrent Objects
  • R. Guerraoui, M. Raynal
  • Computer Science
    The Second International Conference on Availability, Reliability and Security (ARES'07)
  • 2007
TLDR
The design of the construction presented here is based on the simple and well-known state machine replication paradigm and consequently allows to better understand not only the power of consensus objects but also the subtleties of wait-free computations and the way the consensus objects allow coping with both process failures and non-determinism.
A methodology for implementing highly concurrent data objects
TLDR
This paper proposes a new methodology for constructing lock-free and wait-free implementations of concurrent objects that are presented for a multiple instruction/multiple data (MIMD) architecture in which n processes communicate by applying atomic read, write, load_linked, and store_conditional operations to a shared memory.
On the complexity of implementing certain classes of shared objects
TLDR
This thesis believes that this is the first implementation of a class of types (as opposed to a specific type) to achieve a sub-linear time complexity, and proves time and space lower bounds on wait-free linearizable implementations of another class of object types, called perturbable types.
Looking for Efficient Implementations of Concurrent Objects
TLDR
The paper, that presents the algorithms in an incremental way, visits also a family of liveness conditions and important concurrency-related concepts such as the notion of an abortable object.
A methodology for implementing highly concurrent data structures
TLDR
This paper proposes a new methodology for constructing non-blocking and wait-free implementations of concurrent objects, whose representation and operations are written as stylized sequential programs, with no explicit synchronization.
How to share a data structure: A fast timing-based solution∗
TLDR
This work considers the problem of transforming a given sequential implementation of a data structure into a wait-free concurrent implementation that works correctly in a concurrent environment where it may be accessed by many processes, and assumes a shared memory model with atomic registers.
On the space complexity of randomized synchronization
TLDR
It is shown that, using historyless objects, V(=n) object instances are necessary to solve n-process consensus, and this lower bound holds even if the objects have unbounded size and the termination requirement is nondeterministic solo termination, a property strictly weaker than randomized wait-freedom.
...
...

References

SHOWING 1-10 OF 42 REFERENCES
Impossibility and universality results for 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 are at the bottom of the hierarchy: they cannot be used to constructWait-free implementations of many simple and familiar data types.
A methodology for implementing highly concurrent data structures
TLDR
This paper proposes a new methodology for constructing non-blocking and wait-free implementations of concurrent objects, whose representation and operations are written as stylized sequential programs, with no explicit synchronization.
Sticky bits and universality of consensus
TLDR
A new primitive object, the “Sticky-Bit”, is introduced, and its universality is shown by proving that any safe implementation of a sequential object can be transformed into a wait-free atomic one using only Sticky Bits and safe registers.
Database Applications of the FETCH-AND-ADD Instruction
  • H. Stone
  • Computer Science
    IEEE Transactions on Computers
  • 1984
TLDR
The use of FETCH-AND-ADD in the context of database systems is explored, showing how to enqueue locks, detect lock conflicts, and release locks without resorts to critical program sections that require mutual exclusion during execution.
Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors
In this paper we implement several basic operating system primitives by using a "replace-add" operation, which can supersede the standard "test and set" and which appears to be a universal primitive
The serializability of concurrent database updates
TLDR
Several efficiently recognizable subclasses of the class of senahzable histories are introduced and it is shown how these results can be extended to far more general transaction models, to transactions with partly interpreted functions, and to distributed database systems.
Efficient synchronization of multiprocessors with shared memory
A new formalism is given for read-modify-write (RMW) synchronization operations. This formalism is used to extend the memory reference combining mechanism introduced in the NYU Ultracomputer, to
Axioms for concurrent objects
TLDR
This paper defines and discusses linearizability, and gives examples of how to reason about concurrent objects and verify their implementations based on their (sequential) axiomatic specifications.
Concurrent reading and writing
TLDR
Two general theorems are proved, and some algorithms are presented to illustrate their use, including a solution to the general problem in which a read is repeated if it might have obtained an incorrect result, and two techniques for transmitting messages between processes.
On the minimal synchronism needed for distributed consensus
TLDR
The proofs expose general heuristic principles that explain why consensus is possible in certain models but not possible in others, and several critical system parameters, including various synchronicity conditions, are identified.
...
...