Maurice Herlihy
Abstract
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 ANDERSON, J. H., AND GOUDA, M.G. The virtue of patience: Concurrent programming with and without waiting. Private communication.Google Scholar
- 2 ASPNES, J., AND HERLIHY, M.P. Fast randomized consensus using shared memory. J. Algorlth. 1I (1990), 441-461. Google Scholar
- 3 BAR-NOY, A., AND DOLEV, D. Shared memory vs. message-passing in an asynchronous distnbuted environment. In Proceed~n~s of the 8th ACM SIGACT-SIGcPS OEYmpos~um on Principles of Distributed Cornputing (Aug. 1989), pp. 307 318. Google Scholar
- 4 BLOOM, B. Constructing two-wnter atomic registers. In Proceedings of the 6tb ACM OEYmpostum on Princ~ples of Dtstr~buted Computing (1987), pp. 249-259. Google Scholar
- 5 BURNS, J. E., AND PETERSON, G.L. Constructing multi-reader atomic values from non-atomic values. In Proceedings of the 6th A CM Symposium on Prmciples of D~str~buted Compuhng (1987), pp. 222-231. Google Scholar
- 6 CHOR, B., ISRAELI, A., AND LI, M. On processor coordination using asynchronous hardware. In ProceedinAEs of the 6th ACM Symposium on Princtples of D~stributed Computing (1987), pp. 86 97. Google Scholar
- 7 DOLEV, D., DWORK, C., AND STOCKMEYER, L. On the minimal synchronism needed for distributed consensus. J. ACM 34, I (Jan. 1987), 77 97. Google Scholar
- 8 PFISTER, G. H., ET AL. The IBM research parallel processor prototype (rp3): Introduction and architecture. Presented at the International Conference on Parallel Processmg, 1985.Google Scholar
- 9 FISCHER, M. J., LYNCH, N. A., AND PATERSON, M.S. Impossibility of distnbuted consensus with one faulty process. J ACM32, 2 (April 1985), 374 382. Google Scholar
- 10 GOTTL~EB, A., GRIS~{MAN, R., KRUSKAL, C. P. MCAULIFFE, K. P., RUDOLPH, L., AND SNIR, M. The NYU ultracomputer--Designing an mimd parallel computer. IEEE Trans. Comput. C-32, 2 (Feb. 1984) 175-189.Google Scholar
- 11 GOTTLIEB, A., LUBACHEVSKY, B. D., AND RUDOLPH, L. Basic techniques for the efficient coordination of very large numbers of cooperating sequential processors. ACM Trans. Program. Lang. Syst. 5, 2 (April 1983). 164-189. Google Scholar
- 12 HERLIHY, M.P. A methodology for implementing highly concurrent data structures. In ProceedmBs of the 2nd ACM SIGPLAN OEymposi~rn on Principles and Practtce of Parallel Programming (Match 1990). Google Scholar
- 13 HERLIHY, M.P. Impossibihty and universality results for wait-free synchronization. In Pro ceedmgs of the 7th ACM SIGACT-SIGOPS Symposium on Principles of D~stributed Computmg (Aug. 1988), pp. 276-290. Google Scholar
- 14 HE}~HHY, M. P., AND WING, J.M. Axioms for concurrent objects. In Proceedings of the 14th ACM Symposium on Prmciples of Programrn~n~ Languages (Jan. 1987), pp. 13-26. Google Scholar
- 15 KRUSKAL, C. P., RUDOLPH, L, AND SNIR, M. Efficient synchromzation on multiprocessors with shared memory. In Proceedmgs of the 5th ACM SfGACT~SIGcPS Symposium on Pr~nc~ples of Distributed Computmg (Aug. 1986). Google Scholar
- 16 LAMPORT, L. Concurrent reading and writing. Commun. ACM 20, 11 (Nov. 1977), 806-811. Google Scholar
- 17 LAMPORT, L. How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Trans. Comput. C-28, 9 (Sept. 1979), 690.Google Scholar
- 18 LAMPORT, L. On interprocess communication, parts i and il. Distributed Comput. I (1986), 77-101.Google Scholar
- 19 LAMPORT, L. Specifying concurrent program modules. ACM Trans. Program Lang. Syst. 5, 2 (April 1983), 190-222. Google Scholar
- 20 LANIN, V., AND SHASHA, D. Concurrent set manipulation without locking. In Proceedings of the 7th ACM Symposium on Principles o{ Database Systems (Match 1988), pp. 211-220. Google Scholar
- 21 LOUI, M. C., AND ABU-AMARA, H.H. Memo~, Requirements for Agreement Among Unreliable Asynchronous Processes, vol. 4. Jai Press, Greenwich, Conn., 1987, pp. 163-183.Google Scholar
- 22 LYNCH, N. A., AND TUTTLE, M. R. An introduction to input/output automata. Tech. Rep. MIT/LCS/TM-373, MIT Laboratory for Computer Science, Nov. 1988.Google Scholar
- 23 NEWMAN-WOLFE, R. A protocol for wait-free, atomic, multi-reader shared variables. In Proceedings of the 6th ACM OEvmposium on Principles o{ Distributed Computing (1987) pp. 232 249. Google Scholar
- 24 PAPADIMITRIOU, C. H. The serializability of concurrent database updates. J. ACM 26, 4 (Oct. 1979), 631 653. Google Scholar
- 25 PETERSON, G.L. Concurrent reading while writing. ACM Trans. Program. Lang. Syst 5, 1 (Jan. 1983), 46-55. Google Scholar
- 26 PETERSON, G. L., AND BURNS, J.E. Concurrent reading while writing Ih The multi-writer case. Tech. Rep. GIT-ICS-86/26, Georgia Institute of Technology, Dec. 1986.Google Scholar
- 27 PLOTKIN, S. A. Sticky bits and universality of consensus. In Proceedings of the 8th ACM Symposium on Principles o{ Distributed Computing (1989), pp. 159 176. Google Scholar
- 28 SELTZ, C.L. The cosmic cube. Commun. ACM28, 1 (Jan. 1985). Google Scholar
- 29 alNGH, A. K., ANDERSON, J. H., AND GOUDA, M. G. The elusive atomic register revisited. In Proceedings o{ the 6th ACM Symposium on Principles o{ Distributed Computing, (1987), pp. 206-221. Google Scholar
- 30 aTONE, H. S. Database applications of the fetch-and-add instruction. IEEE Trans. Comput C-33, 7 (July 1984), 604-612.Google Scholar
- 31 VITANYI, P., AND AWERBUCH, B. Atomic shared register access by asynchronous hardware. In Proceedings o{ the 27th IEEE OEvmposium on Foundations o{ Computer Sczence, (1986), pp. 223-243. Sec also SIGACT News 18, 4 (Summer, 1987), errata.Google Scholar
Index Terms
- Wait-free synchronization
Recommendations
Highly-Efficient Wait-Free Synchronization
We study a simple technique, originally presented by Herlihy (ACM Trans. Program. Lang. Syst. 15(5):745---770, 1993 ), for executing concurrently, in a wait-free manner, blocks of code that have been programmed for sequential execution and require ...
Wait-n-GoTM: improving HTM performance by serializing cyclic dependencies
ASPLOS '13Transactional memory (TM) has been proposed to alleviate some key programmability problems in chip multiprocessors. Most TMs optimistically allow concurrent transactions, detecting read-write or write-write conflicts. Upon conflicts, existing hardware ...
Wait-free computing: an introductory lecture
Special issue: Parallel computing technologiesThis paper is a short introduction to wait-free computing. ''Wait-free'' means that the progress of a process depends only on it, regardless of the other processes (that can progress slowly or even crash). To illustrate wait-free computing, the paper ...
Reviews
Peter N. van den Bosch
A set of concurrent processes sharing a data object form a fault-tolerant system only if nonfaulty processes can complete their operations in a finite number of steps even if the system contains arbitrarily slow, including halted, processes provided that, except for sharing the object, these slow processes are independent of the nonfaulty processes. An implementation of a data object that guarantees this is called wait-free . Wait-free implementations have a clear advantage, which has led to considerable interest in such implementations of objects. This paper develops a proof technique for statements of the form “X cannot provide a wait-free implementation of Y.” This technique is then used to derive a hierarchy of objects such that no object can provide a wait-free implementation of any object at a higher level. Herlihy goes on to show that several classical synchronization primitives are unable to provide wait-free implementations of all sequential objects shared by a finite set of processes, but that objects do exist that can. Considering its length, the paper is elegant, thorough, and well-motivated throughout. It is also highly self-contained in the sense that any computer scientist should be able to read it without needing to dig up a multi-link chain of prior references to get the background. As such, I commend this paper as a model for anyone contemplating writing a paper with more than one theorem in it: considering the wide acceptance of programming disciplines such as top-down refinement in our field, it is amazing how many technical papers insist on throwing theorem after theorem at the reader without once pausing to suggest a plausible reason for doing so; in contrast, the technical content of this paper follows naturally from the discussion in which it is embedded.
Access critical reviews of Computing literature here
Become a reviewer for Computing Reviews.
Comments