Pseudo Read-Modify-Write Operations: Bounded Wait-Free Implementations (Extended Abstract)

We define a class of operations called pseudo read- modify- write (PRMW) operations, and show that nontrivial shared data objects with such operations can be implemented in a bounded, wait-free manner from atomic registers. A PRMW operation is similar to a “true” read-modify-write (RMW) operation in that it modifies sthe value of a shared variable based upon the original value of that variable. However, unlike an RMW operation, a PRMW operation does not return the value of the variable that it modifies. We consider a class of shared data objects that can either be read, written, or modified by a commutative PRMW operation, and show that any object in this class can be implemented without waiting from atomic registers. The implementations that we present are polynomial in both space and time and thus are an improvement over previously published ones, all of which have unbounded space complexity.

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

[2]  John Tromp,et al.  How to construct an atomic variable , 1989 .

[3]  James H. Anderson.  Composite Registers , 1990, PODC.

[4]  Evangelos Kranakis,et al.  Atomic Multireader Register , 1987, WDAG.

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

[6]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

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

[8]  Martín Abadi,et al.  The existence of refinement mappings , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[9]  Amos Israeli,et al.  Bounded time-stamps , 1987, 28th Annual Symposium on Foundations of Computer Science (sfcs 1987).

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

[11]  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).

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

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

[14]  David Lorge Parnas,et al.  Concurrent control with “readers” and “writers” , 1971, CACM.

[15]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[16]  K. Mani Chandy.  Parallel program design , 1989 .

[17]  Baruch Awerbuch,et al.  On proving register atomicity , 1987 .

[18]  Richard Newman-Wolfe,et al.  A protocol for wait-free, atomic, multi-reader shared variables , 1987, PODC '87.

[19]  Bard Bloom.  Constructing Two-Writer Atomic Registers , 1988, IEEE Trans. Computers.

[20]  Maurice Herlihy,et al.  Wait-free data structures in the asynchronous PRAM model , 1990, SPAA '90.

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

[22]  Nir Shavit,et al.  Atomic snapshots of shared memory , 1990, JACM.