Barrier Methods for Garbage Collection

Garbage collection algorithms have been enhanced in recent years with two methods: generation-based collection and Baker incremental copying collection. Generation-based collection requires special actions during certain store operations to implement the \write barrier." Incremental collection requires special actions on certain load operations to implement the \read barrier." This paper evaluates the performance of diierent implementations of the read and write barriers and reaches several important conclusions. First, the inlining of barrier checks results in surprisingly low overheads, both for the write barrier (2{6%) and the read barrier (< 20%). Contrary to previous belief, these results suggest that a Baker-style read barrier can be implemented eeciently without hardware support. Second, the use of operating system traps to implement garbage collection methods results in extremely high overheads because the cost of trap handling is so high. Since this large overhead is completely unnecessary, operating system memory protection traps should be reimplemented to be as fast as possible. Finally, the performance of these approaches on several machine architectures is compared to show that the results are generally applicable.

[1]  Andrew W. Appel,et al.  Simple generational garbage collection and fast allocation , 1989, Softw. Pract. Exp..

[2]  Brian N. Bershad,et al.  The interaction of architecture and operating system design , 1991, ASPLOS IV.

[3]  Rodney A. Brooks,et al.  Trading data space for reduced time and code space in real-time garbage collection on stock hardware , 1984, LFP '84.

[4]  Luca Cardelli,et al.  Modula-3 Report. , 1988 .

[5]  Robert Allen Shaw,et al.  Empirical analysis of a LISP system , 1988 .

[6]  Douglas Johnson,et al.  Trap architectures for Lisp systems , 1990, LISP and Functional Programming.

[7]  David A. Moon,et al.  Architecture of the Symbolics 3600 , 1985, ISCA '85.

[8]  Douglas Johnson The case for a read barrier , 1991, ASPLOS IV.

[9]  James R. Larus,et al.  SPUR: A VLSI Multiprocessor Workstation , 1985 .

[10]  Benjamin G. Zorn,et al.  SPUR Lisp: Design and Implementation , 1987 .

[11]  Frank Jackson,et al.  Tenuring policies for generation-based storage reclamation , 1988, OOPSLA '88.

[12]  Benjamin G. Zorn,et al.  Comparing mark-and sweep and stop-and-copy garbage collection , 1990, LISP and Functional Programming.

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

[14]  Benjamin G. Zorn,et al.  Comparative performance evaluation of garbage collection algorithms , 1989 .

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

[16]  David A. Moon,et al.  Garbage collection in a large LISP system , 1984, LFP '84.

[17]  Robert Fenichel,et al.  A LISP garbage-collector for virtual-memory computer systems , 1969, CACM.

[18]  Robert Courts,et al.  Improving locality of reference in a garbage-collecting memory management system , 1988, CACM.

[19]  P. Steenkiste The impact of code density on instruction cache performance , 1989, ISCA '89.

[20]  Patrick Sobalvarro,et al.  A Lifetime-based Garbage Collector for LISP Systems on General- Purpose Computers , 1988 .

[21]  Ifor Williams,et al.  The design and evaluation of a high-performance smalltalk system , 1988 .

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

[23]  Uwe F. Pleban,et al.  The runtime environment for Scheme, a Scheme implementation on the 88000 , 1989, ASPLOS III.

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