Wait-free synchronization

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 concensus protocol, for proving statements of the form, “there is no wait-free implementation of X by Y.” We derive a hierarchy of objects such that no object at one level has a wait-free implementation in terms of objects at lower levels. In particular, we show that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy: thay cannot be used to construct wait-free implementations of many simple and familiar data types. Moreover, classical synchronization primitives such astest&set and fetch&add, while more powerful than read and write, are also computationally weak, as are the standard message-passing primitives. Second, nevertheless, we show that there do exist simple universal objects from which one can construct a wait-free implementation of any sequential object.

[1]  Leslie Lamport,et al.  Concurrent reading and writing , 1977, Commun. ACM.

[2]  Leslie Lamport,et al.  How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs , 2016, IEEE Transactions on Computers.

[3]  Christos H. Papadimitriou,et al.  The serializability of concurrent database updates , 1979, JACM.

[4]  Nancy A. Lynch,et al.  Impossibility of distributed consensus with one faulty process , 1983, PODS '83.

[5]  Larry Rudolph,et al.  Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors , 1983, TOPL.

[6]  Leslie Lamport,et al.  Specifying Concurrent Program Modules , 1983, TOPL.

[7]  Gary L. Peterson,et al.  Concurrent Reading While Writing , 1983, TOPL.

[8]  Danny Dolev,et al.  On the minimal synchronism needed for distributed consensus , 1983, 24th Annual Symposium on Foundations of Computer Science (sfcs 1983).

[9]  Harold S. Stone Database Applications of the FETCH-AND-ADD Instruction , 1984, IEEE Transactions on Computers.

[10]  Charles L. Seitz,et al.  The cosmic cube , 1985, CACM.

[11]  Kevin P. McAuliffe,et al.  The IBM Research Parallel Processor Prototype (RP3): Introduction and Architecture , 1985, ICPP.

[12]  Baruch Awerbuch,et al.  Atomic shared register access by asynchronous hardware , 1986, 27th Annual Symposium on Foundations of Computer Science (sfcs 1986).

[13]  Amos Israeli,et al.  On processor coordination using asynchronous hardware , 1987, PODC '87.

[14]  Gary L. Peterson,et al.  Concurrent reading while writing II: The multi-writer case , 1987, 28th Annual Symposium on Foundations of Computer Science (sfcs 1987).

[15]  Ambuj K. Singh,et al.  The elusive atomic register revisited , 1987, PODC '87.

[16]  Bard Bloom,et al.  Constructing two-writer atomic registers , 1987, PODC '87.

[17]  Maurice Herlihy,et al.  Axioms for concurrent objects , 1987, POPL '87.

[18]  Gary L. Peterson,et al.  Constructing multi-reader atomic values from non-atomic values , 1987, PODC '87.

[19]  Richard E. Newman A Protocol for Wait-Free, Atomic, Multi-Reader Shared Variables , 1987, PODC.

[20]  Dennis Shasha,et al.  Concurrent set manipulation without locking , 1988, PODS '88.

[21]  Larry Rudolph,et al.  Efficient synchronization of multiprocessors with shared memory , 1986, PODC '86.

[22]  Maurice Herlihy,et al.  Impossibility and universality results for wait-free synchronization , 1988, PODC '88.

[23]  Danny Dolev,et al.  Shared-memory vs. message-passing in an asynchronous distributed environment , 1989, PODC '89.

[24]  Nancy A. Lynch,et al.  An introduction to input/output automata , 1989 .

[25]  Serge A. Plotkin Sticky bits and universality of consensus , 1989, PODC '89.

[26]  Maurice Herlihy,et al.  Fast Randomized Consensus Using Shared Memory , 1990, J. Algorithms.

[27]  James H. Anderson,et al.  The Virtue of Patience: Concurrent Programming with and Without Waiting , 1990 .

[28]  Maurice Herlihy,et al.  A methodology for implementing highly concurrent data structures , 1990, PPOPP '90.