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.
How to share an object: A fast timing-based solution
  • R. Alur, G. Taubenfeld
  • Computer Science, Mathematics
    Proceedings of 1993 5th IEEE Symposium on Parallel and Distributed Processing
  • 1993
TLDR
This work considers the problem of transforming a given sequential implementation of a data structure into a wait-free concurrent implementation and assumes that there is a known upper bound on the time taken by the slowest process to execute a statement involving an access to the shared memory.
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.
...
...

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.
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.
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.
A Protocol for Wait-Free, Atomic, Multi-Reader Shared Variables
TLDR
A wait-free solution to the atomic (r,1kCRWW problem) that uses (r+2)(Sr-2+6)-I safe, multi-reader bits to implement a &bit variable shared among t readers and 1 writer closes a gap in the simulation of systems of shared variables for single writers.
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.
...
...