A generational mostly-concurrent garbage collector

This paper reports our experiences with a mostly-concurrent incremental garbage collector, implemented in the context of a high performance virtual machine for the Java#8482; programming language. The garbage collector is based on the “mostly parallel” collection algorithm of Boehm et al. and can be used as the old generation of a generational memory system. It overloads efficient write-barrier code already generated to support generational garbage collection to also identify objects that were modified during concurrent marking. These objects must be rescanned to ensure that the concurrent marking phase marks all live objects. This algorithm minimises maximum garbage collection pause times, while having only a small impact on the average garbage collection pause time and overall execution time. We support our claims with experimental results, for both a synthetic benchmark and real programs.

[1]  David M. Ungar,et al.  Generation Scavenging: A non-disruptive high performance storage reclamation algorithm , 1984, SDE 1.

[2]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[3]  Henry Lieberman,et al.  A real-time garbage collector based on the lifetimes of objects , 1983, CACM.

[4]  Darko Stefanovic,et al.  A comparative performance evaluation of write barrier implementation , 1992, OOPSLA.

[5]  Tony Printezis.  Analysing a Simple Disk Garbage Collector , 1996 .

[6]  Daniel G. Bobrow,et al.  Combining generational and conservative garbage collection: framework and implementations , 1989, POPL '90.

[7]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[8]  Damien Doligez,et al.  Portable, unobtrusive garbage collection for multiprocessor systems , 1994, POPL '94.

[9]  Hans-Juergen Boehm,et al.  Garbage collection in an uncooperative environment , 1988, Softw. Pract. Exp..

[10]  Andrew W. Appel,et al.  Garbage Collection can be Faster than Stack Allocation , 1987, Inf. Process. Lett..

[11]  Damien Doligez,et al.  A concurrent, generational garbage collector for a multithreaded implementation of ML , 1993, POPL '93.

[12]  Ben Zorn,et al.  Barrier Methods for Garbage Collection , 1990 .

[13]  David Detlefs,et al.  Inlining of Virtual Methods , 1999, ECOOP.

[14]  Urs Hölzle,et al.  A Fast Write Barrier for Generational Garbage Collectors , 1993 .

[15]  Alex Garthwaite,et al.  The GC Interface in the EVM 1 , 1998 .

[16]  David K. Gifford,et al.  Concurrent compacting garbage collection of a persistent heap , 1993, SOSP '93.

[17]  Paul R. Wilson,et al.  A “card-marking” scheme for controlling intergenerational references in generation-based garbage collection on stock hardware , 1989, SIGP.

[18]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[19]  Erez Petrank,et al.  A generational on-the-fly garbage collector for Java , 2000, PLDI '00.

[20]  Chris J. Cheney.  A nonrecursive list compacting algorithm , 1970, Commun. ACM.

[21]  David Detlefs,et al.  Finding References in Java TM Stacks , 1997 .

[22]  Leslie Lamport,et al.  On-the-fly garbage collection: an exercise in cooperation , 1975, CACM.

[23]  Steffen Grarup,et al.  Incremental Mature Garbage Collection Using the Train Algorithm , 1995, ECOOP.

[24]  Y. S. Ramakrishna,et al.  An efficient meta-lock for implementing ubiquitous synchronization , 1999, OOPSLA '99.

[25]  R WilsonPaul,et al.  The memory fragmentation problem , 1998 .

[26]  Antony L. Hosking,et al.  Protection traps and alternatives for memory management of an object-oriented language , 1994, SOSP '93.

[27]  Paul R. Wilson,et al.  Dynamic Storage Allocation: A Survey and Critical Review , 1995, IWMM.

[28]  S. L. Graham,et al.  List Processing in Real Time on a Serial Computer , 1978 .

[29]  Scott Shenker,et al.  Mostly parallel garbage collection , 1991, PLDI '91.

[30]  Henry G. Baker,et al.  The treadmill: real-time garbage collection without motion sickness , 1992, SIGP.

[31]  Herbert Stoyan.  Early LISP history (1956 - 1959) , 1984, LFP '84.

[32]  Carl H. Hauser,et al.  The portable common runtime approach to interoperability , 1989, SOSP '89.

[33]  A comparative performance evaluation of write barrier implementation , 1992, OOPSLA '92.

[34]  Paul R. Wilson,et al.  The memory fragmentation problem: solved? , 1998, ISMM '98.