Cache performance of garbage-collected programs

As processor speeds continue to improve relative to main-memory access times, cache performance is becoming an increasingly important component of program performance. Prior work on the cache performance of garbage-collected programs either argues or assumes that conventional garbage-collection methods will yield poor performance, and has therefore concentrated on new collection algorithms designed specifically to improve cache-level reference locality. This paper argues to the contrary: Many programs written in garbage-collected languages are naturally well-suited to the direct-mapped caches typically found in modern computer systems. Garbage-collected programs written in a mostly-functional style should perform well when simple linear storage allocation and an infrequently-run generational compacting collector are employed; sophisticated collectors intended to improve cache performance are unlikely to be necessary. As locality becomes ever more important to program performance, programs of this kind may turn out to have a significant performance advantage over programs written in traditional languages.

[1]  Lawrence Charles Paulson,et al.  ML for the working programmer , 1991 .

[2]  Robin Milner,et al.  Definition of standard ML , 1990 .

[3]  Amer Diwan,et al.  Memory subsystem performance of programs using copying garbage collection , 1994, POPL '94.

[4]  Paul Hudak,et al.  ORBIT: an optimizing compiler for scheme , 1986, SIGPLAN '86.

[5]  Steven A. Przybylski,et al.  Cache and memory hierarchy design: a performance-directed approach , 1990 .

[6]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

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

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

[9]  Craig Schaffert,et al.  CLU Reference Manual , 1984, Lecture Notes in Computer Science.

[10]  Gerry Kane,et al.  MIPS RISC Architecture , 1987 .

[11]  M. B. Reinhold.  TYPECHECKING IS UNDECIDABLE WHEN ''TYPE'' IS A TYPE , 1989 .

[12]  David A. Patterson,et al.  Computer Architecture: A Quantitative Approach , 1969 .

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

[14]  Peter Lee,et al.  Cache behavior of combinator graph reduction , 1992, TOPL.

[15]  Jonathan Rees,et al.  T: a dialect of Lisp or LAMBDA: The ultimate software tool , 1982, LFP '82.

[16]  Marc Feeley,et al.  A parallel virtual machine for efficient scheme compilation , 1990, LISP and Functional Programming.

[17]  Feng Zhao.  An O(N) Algorithm for Three-dimensional N-body Simulations , 2022 .

[18]  J. White,et al.  Address/memory management for a gigantic LISP environment or, GC considered harmful , 1987, LIPO.

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

[20]  Norman P. Jouppi,et al.  Computer technology and architecture: an evolving interaction , 1991, Computer.

[21]  D LamMonica,et al.  The cache performance and optimizations of blocked algorithms , 1991 .

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

[23]  David Ungar.  Generation scavenging: a nondisruptive high performance storage reclamation algorithm , 1984 .

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

[25]  D. H. Bartley,et al.  Revised4 report on the algorithmic language scheme , 1991, LIPO.

[26]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[27]  Alan Jay Smith,et al.  Aspects of cache memory and instruction buffer performance , 1987 .

[28]  Norman P. Jouppi.  Cache write policies and performance , 1993, ISCA '93.

[29]  Luigia Carlucci Aiello,et al.  An Efficient Interpreter for the Lambda-Calculus , 1981, J. Comput. Syst. Sci..

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

[31]  R. Acevedo,et al.  Research report , 1967, Revista odontologica de Puerto Rico.

[32]  William D. Clinger,et al.  Revised3 report on the algorithmic language scheme , 1986, SIGP.

[33]  Mark Baldwin Reinhold.  CACHE PERFORMANCE OF GARBAGE-COLLECTED PROGRAMMING LANGUAGES , 1993 .

[34]  Amer Diwan,et al.  Memory system performance of programs with intensive heap allocation , 1995, TOCS.

[35]  Monica S. Lam,et al.  The cache performance and optimizations of blocked algorithms , 1991, ASPLOS IV.

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

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

[38]  Benjamin G. Zorn.  The Effect of Garbage Collection on Cache Performance , 1991 .

[39]  Paul R. Wilson,et al.  Caching considerations for generational garbage collection , 1992, LFP '92.