Real-time Concurrent Collection on Stock Multiprocessors

Transcription

1 RETROSPECTIVE: Real-time Concurrent Collection on Stock Multiprocessors Andrew W. Appel Princeton University 1. INTRODUCTION In 1987, Kai Li of Princeton University was working with John Ellis of Digital Equipment Corp. s Systems Research Center on concurrent garbage-collection for DEC s experimental shared-memory multiprocessor, the Firefly; their idea was to use virtual-memory page-faults in some way to do the synchronization with no overhead in the common case. At the same time, I was working on a similar problem: trying to adapt Baker s 1978 incremental copying garbage-collection algorithm [3] to use virtual-memory page faults. Obvious ideas such as write-protecting the from-space didn t seem to work well. By the summer, we had joined forces and we had also hit upon the trick: read-protecting the to-space. By the end of the summer the concurrent collector was implemented on the Firefly and measured. We believe this was the first truly concurrent (not just incremental) collector on a shared-memory multiprocessor. Surely, we thought, this is how to do garbage collection. The garbage collection literature is remarkable in computer science: McCarthy s mark-sweep algorithm for LISP [10] was published in 1960, showing that garbage collection is basically just a graph traversal depth-first or breadth-first search. But Cohen s 1981 survey paper [4] cites 111 articles, the excellent and comprehensive 1996 book by Jones and Lins [8] cites almost 500 articles, and the conferences and workshops on memory management are still going strong. Anyone at any time in the past 40 years who has thought, this is how to do garbage collection has probably missed something. John DeTreville at DEC SRC implemented and compared several concurrent collectors (including our algorithm) and described the results in 1990 [5]. He found that our algorithm didn t perform particularly well, and he suggested that for it to achieve good performance one should really implement a generational version. Our algorithm like Baker s earlier one is easily compatible with generations, and DeTreville was probably right in is recommendation. VM-based algorithms (such as ours) depend on efficient fault handling, usually by a user-mode process; the operating system must handle the fault and then forward it back to the user-mode collector. Kai Li and I were disappointed by the performance of our algorithm, and in 1991 we published measurements [1] of our VM-PUP (Virtual Memory Primitives for User Programs) benchmarks [2] on several operating systems. They ranged from slow to very slow; clearly, most operating systems designers did not have user-mode VM-based garbage collection algorithms in mind. Of course, if we had paid proper attention to John Ousterhout in Years of the ACM/SIGPLAN Conference on Programming Language Design and Implementation ( ): A Selection, Copyright 2003 ACM $5.00. [11] we could have predicted such problems. Part of the impact of our 1988 paper is that it helped to stimulate a lot of good research in the 1990 s on how to implement read barriers and write barriers. In previous decade, Dijkstra et al. [6], Baker [3], Ungar [12], and Lieberman and Hewitt [9] had described different ad-hoc garbage-collection tricks, but by the 1990 s the community had a common framework and terminology. Concurrent and generational collector design could be decomposed into two separate subproblems: (1) design an algorithm that uses read barriers and write barriers, (2) devise tricks for implementing the barriers. We cannot claim credit for this decomposition, but perhaps we made an incremental contribution. Partly because the Moore s Law increase in instruction execution speeds has outpaced the speedup of trap-handling and system calls, I believe VM-based read and write barriers are not widely used today; many research papers in the 1990s describe clever use of ordinary machine instructions to do the job. Also because of processors are so much faster these days, one can executing a lot more instructions than in 1987 in the 0.1 seconds that is the typical desired latency for human interaction. We carefully engineered our algorithm to collect only a page at a time to get this latency; but now one can collect many pages in a tenth of a second. Therefore, algorithms such as Hudson s Train algorithm [7], which are incremental at a coarser grain (collecting an entire batch of pages at a time), have become attractive. REFERENCES [1] Andrew W. Appel and Kai Li. Virtual memory primitives for user programs. In Fourth Int l Conf. on Architectural Support for Programming Languages and Operating Systems (ASPLOS IV), volume 26, pages ACM Press, April [2] Andrew W. Appel and Kai Li. VM-PUP benchmark program. appel/papers/vmpup.c, [3] H. G. Baker. List processing in real time on a serial computer. Communications of the ACM, 21(4): , [4] Jacques Cohen. Garbage collection of linked data structures. Computing Surveys, 13(3): , [5] John DeTreville. Experience with concurrent garbage collectors for Modula-2+. Technical Report 64, Systems Research Center, Digital Equipment Corp., August [6] Edsger W. Dijkstra, Leslie Lamport, A. J. Martin, C. S. Scholten, and E. F. M. Steffens. On-the-fly garbage collection: An exercise in cooperation. Communications of the ACM, 21(11): , [7] Richard L. Hudson and J. Eliot B. Moss. Incremental ACM SIGPLAN 205 Best of PLDI

2 collection of mature objects. In Proceedings of the International Workshop on Memory Management, pages , September [8] Richard Jones and Rafael Lins. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. John Wiley & Sons, Chichester, England, [9] Henry Lieberman and Carl Hewitt. A real-time garbage collector based on the lifetimes of objects. Communications of the ACM, 26(6): , [10] John McCarthy. Recursive functions of symbolic expressions and their computation by machine I. Communications of the ACM, 3(1): , [11] John Ousterhout. Why aren t operating systems getting faster as fast as hardware? In Proc. Summer 1990 USENIX Conf., pages , [12] David Ungar. Generation scavenging: a non-disruptive high performance storage reclamation algorithm. SIGPLAN Notices (Proc. ACM SIGSOFT/SIGPLAN Software Eng. Symp. on Practical Software Development Environments), 19(5):157 67, ACM SIGPLAN 206 Best of PLDI

3 ACM SIGPLAN 207 Best of PLDI

4 ACM SIGPLAN 208 Best of PLDI

5 ACM SIGPLAN 209 Best of PLDI

6 ACM SIGPLAN 210 Best of PLDI

7 ACM SIGPLAN 211 Best of PLDI

8 ACM SIGPLAN 212 Best of PLDI

9 ACM SIGPLAN 213 Best of PLDI

10 ACM SIGPLAN 214 Best of PLDI

11 ACM SIGPLAN 215 Best of PLDI

12 ACM SIGPLAN 216 Best of PLDI