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.
Work supported in part by an award from the General Research Board, University of Maryland, and by an NSF Research Initiation Award.
On leave from: The Center for Advanced Computer Studies, University of Southwestern Louisiana, Lafayette, Louisiana 70504.
This is a preview of subscription content, log in via an institution to check access.
Preview
Unable to display preview. Download preview PDF.
References
M. Abadi and L. Lamport, “The Existence of Refinement Mappings,” Theoretical Computer Science, Vol. 82, No. 2, May 1990, pp. 253–284.
Y. Afek, H. Attiya, D. Dolev, E. Gafni, M. Merritt, and N. Shavit, “Atomic Snapshots of Shared Memory,” Proceedings of the Ninth Annual Symposium on Principles of Distributed Computing, 1990, pp. 1–14.
J. Anderson, “Multiple-Writer Composite Registers,” Technical Report TR.89.26, Department of Computer Sciences, University of Texas at Austin, September 1989.
J. Anderson, “Composite Registers,” Proceedings of the Ninth Annual Symposium on Principles of Distributed Computing, 1990, pp. 15–30.
J. Anderson and M. Gouda, “The Virtue of Patience: Concurrent Programming With and Without Waiting,” Technical Report TR.90.23, Department of Computer Sciences, University of Texas at Austin, July 1990.
J. Anderson and M. Gouda, “A Criterion for Atomicity,” Formal Aspects of Computing: The International Journal of Formal Methods, scheduled to appear in 1992.
J. Aspnes and M. Herlihy, “Wait-Free Data Structures in the Asynchronous PRAM Model,” Proceedings of the Second Annual ACM Symposium on Parallel Architectures and Algorithms, July, 1990.
B. Awerbuch, L. Kirousis, E. Kranakis, P. Vitanyi, “On Proving Register Atomicity,” Report CS-R8707, Centre for Mathematics and Computer Science, Amsterdam, 1987.
B. Bloom, “Constructing Two-Writer Atomic Registers,” IEEE Transactions on Computers, Vol. 37, No. 12, December 1988, pp. 1506–1514. Also appeared in Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing, 1987, pp. 249–259.
J. Burns and G. Peterson, “Constructing Multi-Reader Atomic Values from Non-Atomic Values,” Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing, 1987, pp. 222–231.
K. Chandy and J. Misra, Parallel Program Design: A Foundation, Addison Wesley, 1988.
M. Clint, “Program Proving: Coroutines,” Acta Informatica, Vol. 2, p. 50–63, 1973.
P. Courtois, F. Heymans, and D. Parnas, “Concurrent Control with Readers and Writers,” Communications of the ACM, Vol. 14, No. 10, October 1971, pp. 667–668.
M. Herlihy, “Impossibility and Universality Results for Wait-Free Synchronization,” Proceedings of the Seventh Annual Symposium on Principles of Distributed Computing, 1988, pp. 276–290.
M. Herlihy and J. Wing, “Linearizability: A Correctness Condition for Concurrent Objects,” ACM Transactions on Programming Languages and Systems, Vol. 12, No. 3, 1990, pp. 463–492.
A. Israeli and M. Li, “Bounded time-stamps,” Proceedings of the 28th IEEE Symposium on Foundations of Computer Science, 1987, pp. 371–382.
L. Kirousis, E. Kranakis, and P. Vitanyi, “Atomic Multireader Register,” Proceedings of the Second International Workshop on Distributed Computing, Springer Verlag Lecture Notes in Computer Science 312, 1987, pp. 278–296.
C. Kruskal, L. Rudolph, M. Snir, “Efficient Synchronization on Multiprocessors with Shared Memory,” ACM Transactions on Programming Languages and Systems, Vol. 10, No. 4, October 1988, pp. 579–601.
S. Lam and A. Shankar, “Specifying Modules to Satisfy Interfaces: A State Transition System Approach,” Technical Report CS-TR-2082.3, University of Maryland at College Park, 1988.
L. Lamport, “On Interprocess Communication, Parts I and II,” Distributed Computing, Vol. 1, pp. 77–101, 1986.
M. Li, J. Tromp, and P. Vitanyi, “How to Construct Wait-Free Variables,” unpublished manuscript, Centrum voor Wiskunde en Informatica, Amsterdam, The Netherlands, 1989.
R. Newman-Wolfe, “A Protocol for Wait-Free, Atomic, Multi-Reader Shared Variables, Proceedings of ike Sixth Annual Symposium on Principles of Distributed Computing, 1987, pp. 232–248.
S. Owicki and D. Gries, “An Axiomatic Proof Technique for Parallel Programs I,” Acta Informatica, Vol. 6, pp. 319–340, 1976.
G. Peterson, “Concurrent Reading While Writing,” ACM Transactions on Programming Languages and Systems, Vol. 5, 1983, pp. 46–55.
G. Peterson and J. Burns, “Concurrent Reading While Writing II: The Multi-Writer Case,” Proceedings of the 28th Annual Symposium on Foundations of Computer Science, 1987.
A. Singh, J. Anderson, and M. Gouda, “The Elusive Atomic Register, Revisited,” Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing, 1987, pp. 206–221.
J. Tromp, “How to Construct an Atomic Variable,” unpublished manuscript, Centrum voor Wiskunde en Informatica, Amsterdam, The Netherlands, 1989.
P. Vitanyi and B. Awerbuch, “Atomic Shared Register Access by Asynchronous Hardware,” Proceedings of the 27th IEEE Symposium on the Foundations of Computer Science, 1986, pp. 233–243.
Author information
Authors and Affiliations
Editor information
Rights and permissions
Copyright information
© 1992 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Anderson, J.H., Grošelj, B. (1992). Pseudo read-modify-write operations: Bounded wait-free implementations. In: Toueg, S., Spirakis, P.G., Kirousis, L. (eds) Distributed Algorithms. WDAG 1991. Lecture Notes in Computer Science, vol 579. Springer, Berlin, Heidelberg. https://doi.org/10.1007/BFb0022437
Download citation
DOI: https://doi.org/10.1007/BFb0022437
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-55236-9
Online ISBN: 978-3-540-46789-2
eBook Packages: Springer Book Archive