## Summary

A*composite register* is an array-like shared data object that is partitioned into a number of components. An operation of such a register either writes a value to a single component, or reads the values of all components. A composite register reduces to an ordinary atomic register when there is only one component. In this paper, we show that a composite register with multiple writers per component can be implemented in a wait-free manner from a composite register with a single writer per component. It has been previously shown that registers of the latter kind can be implemented from atomic registers without waiting. Thus, our results establish that any composite register can be implemented in a wait-free manner from atomic registers. We show that our construction has comparable space compexity and better time complexity than other constructions that have been presented in the literature.

## Key words

Atomicity Atomic register Composite register Concurrency Interleaving semantics Linearizability Shared variable Snapshot## Preview

Unable to display preview. Download preview PDF.

## References

- 1.Afek Y, Attiya H, Dolev D, Gafni E, Merritt M, Shavit N: Atomic snapshots of shared memory. Proceedings of the Ninth Annual Symposium on Principles of Distributed Computing 1990, pp 1–14Google Scholar
- 2.Anderson J: Composite registers (extended abstract). Proceedings of the Ninth Annual Symposium on Principles of Distributed Computing 1990, pp 15–30Google Scholar
- 3.Anderson J: Composite Registers. Distrib Comput 6: 141–154 (1993). First appeared as Technical Report TR.89.25, Department of Computer Sciences, University of Texas at Austin 1989Google Scholar
- 4.Anderson J: Multi-writer composite registers. Technical Report, Department of Computer Science, The University of Maryland at College Park 1991. First appeared as Technical Report TR.89.26, Department of Computer Sciences, University of Texas at Austin 1989Google Scholar
- 5.Anderson J, Gouda M: The virtue of patience: concurrent programming with and without waiting. Technical Report TR.90.23, Department of Computer Sciences, The University of Texas at Austin 1990Google Scholar
- 6.Anderson J, Gouda M: A criterion for atomicity. Formal Asp Comput 4 (3): 273–298 (1992)Google Scholar
- 7.Anderson J, Grošelj B: Pseudo read-modify-write operations: bounded wait-free-implementations. Proceedings of the Fifth International Workshop on Distributed Algorithms, Lect Notes Comput Sci 579: 52–70 (1991)Google Scholar
- 8.Anderson J, Grošelj B: Beyond atomic registers: bounded waitfree implementations of non-trivial objects. Sci Comput Program 19 (3): 197–237 (1992)Google Scholar
- 9.Anderson J, Moir M: Towards a necessary and sufficient condition for wait-free synchronization. Proceedings of the Seventh International Workshop on Distributed Algorithms. Lect Notes Comput Sci 725: 39–53 (1993)Google Scholar
- 10.Aspnes J, Herlihy M: Wait-free data structures in the asynchronous PRAM model. Proceedings of the Second Annual ACM Symposium on Parallel Architectures and Algorithms 1990, pp 340–349Google Scholar
- 11.Attiya H, Rachman O: Atomic snapshots in
*O*(*n*log*n*) operations. Proceedings of the 12th Annual Symposium on Principles of Distributed Computing 1993, pp 29–40Google Scholar - 12.Awerbuch B, Kirousis L, Kranakis E, Vitanyi P: On proving register atomicity. Report CS-R8707, Centre for Mathematics and Computer Science, Amsterdam, 1987. A shorter version appeared as: A proof technique for register atomicity. Proceedings of the Eighth Conference on Foundations of Software Techniques and Theoretical Computer Science. Lect Notes Comput Sci 338: 286–303 (1988)Google Scholar
- 13.Bloom B: Construction two-writer atomic registers. IEEE Trans Comput 37 (12): 1506–1514 (1988)Google Scholar
- 14.Burns J, Peterson G: Construction multi-reader atomic values from non-atomic values. Proceedings of the Sixth Annual Symposium on Principle of Distributed Computing 1987, pp 222–231Google Scholar
- 15.Chandy K, Misra J: Parallel program design: a foundation. Addison-Wesley, New York 1988Google Scholar
- 16.Chor B, Israeli A, Li M: On Processor coordination using asynchronous hardware. Principles of the Sixth Annual Symposium on Principles of Distributed Computing 1987, pp 86–97Google Scholar
- 17.Courtois P, Heymans F, Parnas D: Concurrent control with readers and writers. Commun ACM 14 (10): 667–668 (1971)Google Scholar
- 18.Herlihy M: Wait-Free Synchronization. ACM Trans Program Lang Syst 13 (1): 124–149 (1991)Google Scholar
- 19.Herlihy M, Wing J: Linearizability: a correctness condition for concurrent objects. ACM Trans Program Lang Syst 12 (3): 463–492 (1990)Google Scholar
- 20.Israeli A, Li M: Bounded time-stamps. Proceedings of the 28th IEEE Symposium on Foundations of Computer Science 1987, pp 371–382Google Scholar
- 21.Kirousis L, Kranakis E, Vitanyi P: Atomic multireader register. Proceedings of the Second International Workshop on Distributed Computing. Lect Notes Comput Sci 312: 278–296 (1987)Google Scholar
- 22.Kirousis L, Spirakis P, Tsigas P: Simple atomic snapshots: a solution with unbounded time stamps. Proceedings of the International Conference on Computing and Information. Lect Notes Comput Sci 497: 582–587 (1991)Google Scholar
- 23.Kirousis L, Spirakis P, Tsigas P: Reading many variables in one atomic operation: solutions with linear or sublinear complexity. Proceedings of the Fifth International Workshop on Distributed Algorithms. Lect Notes Comput Sci 579: 229–241 (1991)Google Scholar
- 24.Lamport L: Concurrent reading and writing. Commun ACM 20 (11): 806–811 (1977)Google Scholar
- 25.Lamport L: On interprocess communication, Part I and II. Distrib Comput 1: 77–101 (1986)Google Scholar
- 26.Li M, Tromp J, Vitanyi P: How to construct wait-free variables. Proceedings of International Colloquium on Automata, Languages, and Programming. Lect Notes Comput Sci 372: 488–505 (1989)Google Scholar
- 27.Loui M, Abu-Amara H: Memory requirement for agreement among unreliable asynchronous processes. Adv Comput Res 4: 163–183 (1987)Google Scholar
- 28.Misra J: Axioms for memory access in asynchronous hardware systems. ACM Trans Program Lang Syst 8 (1): 142–153 (1986)Google Scholar
- 29.Newman-Wolfe R: A protocol for wait-free, atomic, multi-reader shared variables. Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing 1987, pp 232–248Google Scholar
- 30.Peterson G: Concurrent reading while writing. ACM Trans Program Lang Syst 5: 46–55 (1983)Google Scholar
- 31.Peterson G, Burns J: Concurrent reading while writing II: the multi-writer case. Proceedings of the 28th Annual Symposium on Foundations of Computer Science 1987, pp 383–392Google Scholar
- 32.Singh A, Anderson J, Gouda M: The elusive atomic register, revisited. Proceedings of the Sixth Annual Symposium on Principles of Distributed Computing 1987, pp 206–221. Expanded version to appear in Journal of the ACMGoogle Scholar
- 33.Tromp J: How to construct an atomic variable. Proceedings of the Third International Workshop on Distributed Algorithms. Lect Notes Comput Sci 392: 292–302 (1989)Google Scholar
- 34.Vitanyi P, Awerbuch B: Atomic shared register access by asynchronous hardware. Proceedings of the 27th IEEE Symposium on the Foundations of Computer Science 1986, pp 233–243Google Scholar