Generational garbage collection for Haskell

This paper examines the use of generational garbage collection techniques for a lazy implementation of a non-strict functional language. Detailed measurements which demonstrate that a generational garbage collector can substantially out-perform non-generational collectors, despite the frequency of write operations in the underlying implementation, are presented. Our measurements are taken from a state-of-the-art compiled implementation for Haskell, running substantial benchmark programs. We make measurements of dynamic properties (such as object lifetimes) which a ect generational collectors, study their interaction with a simple generational scheme, make direct performance comparisons with simpler collectors, and quantify the interaction with a paging system. The generational collector is demonstrably superior. At least for our benchmarks, it reduces the net storage management overhead, and it allows larger programs to be run on a given machine before thrashing ensues.

[1]  Niklas Röjemo A Concurrent Generational Garbage Collector for a Parallel Graph Reducer , 1992, IWMM.

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

[3]  H. B. M. Jonkers,et al.  A Fast Garbage Compaction Algorithm , 1979, Inf. Process. Lett..

[4]  Thomas Johnsson,et al.  The Chalmers Lazy-ML Compiler , 1989, Computer/law journal.

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

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

[7]  Simon L. Peyton Jones,et al.  Avoiding Unnecessary Updates , 1992, Functional Programming.

[8]  Jürgen Heymann A comprehensive analytical model for garbage collection algorithms , 1991, SIGP.

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

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

[11]  Eric Cooper,et al.  Improving the performance of SML garbage collection using application-specific virtual memory management , 1992, LFP '92.

[12]  Simon L. Peyton Jones,et al.  The Implementation of Functional Programming Languages , 1987 .

[13]  Patrick M. Sansom Combining Single-Space and Two-Space Compacting Garbage Collectors , 1991, Functional Programming.

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

[15]  Philip Wadler,et al.  The Glasgow Haskell Compiler: a technical overview , 1993 .

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

[17]  Pieter H. Hartel,et al.  Statistics on storage management in a lazy functional language implementation , 1991 .

[18]  Paul R. Wilson,et al.  Design of the opportunistic garbage collector , 1989, OOPSLA '89.

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

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

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

[22]  Simon L. Peyton Jones,et al.  Imperative functional programming , 1993, POPL '93.

[23]  Simon L. Peyton Jones,et al.  Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine , 1992, Journal of Functional Programming.

[24]  Julian Seward,et al.  Generational Garbage Collection for Lazy Graph Reduction , 1992, IWMM.

[25]  Simon Peyton Jones,et al.  The Implementation of Functional Programming Languages (Prentice-hall International Series in Computer Science) , 1987 .

[26]  Alexandru Nicolau,et al.  Comparison of Compacting Algorithms for Garbage Collection , 1983, TOPL.

[27]  Jacques Cohen,et al.  Garbage Collection of Linked Data Structures , 1981, CSUR.

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

[29]  Douglas W. Clark,et al.  An empirical study of list structure in Lisp , 1977, CACM.

[30]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

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

[32]  J. McKnight Fy69] R. Fenichel and J. Yochelson. a Lisp Garbage-collector for Virtual-memory Systems , 2008 .