Abstract models of memory management

Abstract : Most specifications of garbage collectors concentrate on the low-level algorithmic details of how to find and preserve accessible objects. Often, they focus on bit-level manipulations such as 'scanning stack frames,' 'marking objects,' 'tagging data,' etc. While these details are important in some contexts, they often obscure the more fundamental aspects of memory management: what objects are garbage and why? We develop a series of calculi that are just low-level enough that we can express allocation and garbage collection, yet are sufficiently abstract that we may formally prove the correctness of various memory management strategies. By making the heap of a program syntactically apparent, we can specify memory actions as rewriting rules that allocate values on the heap and automatically dereference pointers to such objects when needed. This formulation permits the specification of garbage collection as a relation that removes portions of the heap without affecting the outcome of the evaluation.

[1]  John C. Mitchell,et al.  Type Systems for Programming Languages , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[2]  J. A. Robinson,et al.  A Machine-Oriented Logic Based on the Resolution Principle , 1965, JACM.

[3]  Pierre Wodon,et al.  Methods of Garbage Collection for Algol 68 , 1970, ALGOL 68 Implementation.

[4]  Robert Hieb,et al.  The Revised Report on the Syntactic Theories of Sequential Control and State , 1992, Theor. Comput. Sci..

[5]  Peter Steenkiste,et al.  Tags and type checking in LISP: hardware and software approaches , 1987, ASPLOS.

[6]  Richard C. H. Connor,et al.  An ad hoc approach to the implementation of polymorphism , 1991, TOPL.

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

[8]  Erik Barendsen,et al.  Conventional and Uniqueness Typing in Graph Rewrite Systems , 1993, FSTTCS.

[9]  Andrew W. Appel,et al.  Runtime tags aren't necessary , 1989, LISP Symb. Comput..

[10]  Benjamin Goldberg,et al.  Polymorphic type reconstruction for garbage collection without tags , 1992, LFP '92.

[11]  S. Purushothaman Iyer,et al.  An Adequate Operational Semantics for Sharing in Lazy Evaluation , 1992, ESOP.

[12]  MasonStanford,et al.  Reasoning about programs with e ectsIan , 1990 .

[13]  Paul Hudak A semantic model of reference counting and its abstraction (detailed summary) , 1986, LFP '86.

[14]  Andrew P. Tolmach Tag-free garbage collection using explicit type parameters , 1994, LFP '94.

[15]  Carolyn L. Talcott,et al.  1 Equivalence in Functional Languages with E ectsIan , 2007 .

[16]  Robert Harper,et al.  Compiling polymorphism using intensional type analysis , 1995, POPL '95.

[17]  Henry G. Baker,et al.  Unify and conquer , 1990, LISP and Functional Programming.

[18]  P. Wadler,et al.  The Call-by-Need Lambda Calculus ( Unabridged ) , 1994 .

[19]  Jill Seaman An operational semantics of lazy evaluation for analysis , 1993 .

[20]  Carolyn L. Talcott,et al.  Reasoning about Programs With Effects , 1990, US-Brazil Joint Workshops on the Formal Foundations of Software Systems.

[21]  Matthias Felleisen,et al.  A call-by-need lambda calculus , 1995, POPL '95.

[22]  Scott Nettles,et al.  A Larch Specification of Copying Garbage Collection , 1992 .

[23]  Peter Steenkiste,et al.  Tags and type checking in LISP: hardware and software approaches , 1987, International Conference on Architectural Support for Programming Languages and Operating Systems.

[24]  Pascal Fradet,et al.  Collecting more garbage , 1994, LFP '94.

[25]  John C. Reynolds,et al.  Types, Abstraction and Parametric Polymorphism , 1983, IFIP Congress.

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

[27]  Benjamin Goldberg,et al.  Tag-free garbage collection for strongly typed programming languages , 1991, PLDI '91.

[28]  Dianne Ellen Britton,et al.  Heap storage management for the programming language Pascal , 1975 .

[29]  Robert D. Tennent,et al.  Semantics of programming languages , 1991, Prentice Hall International Series in Computer Science.

[30]  James E. Hicks,et al.  Garbage collection for strongly-typed languages using run-time type reconstruction , 1994, LFP '94.

[31]  Robert Harper,et al.  A Simplified Account of Polymorphic References , 1994, Inf. Process. Lett..

[32]  J. Girard Une Extension De ĽInterpretation De Gödel a ĽAnalyse, Et Son Application a ĽElimination Des Coupures Dans ĽAnalyse Et La Theorie Des Types , 1971 .

[33]  Alejandro Caro,et al.  Compiler-directed type reconstruction for polymorphic languages , 1993, FPCA '93.

[34]  John Launchbury,et al.  A natural semantics for lazy evaluation , 1993, POPL '93.

[35]  John C. Reynolds,et al.  Towards a theory of type structure , 1974, Symposium on Programming.

[36]  Johan Lewi,et al.  A Scheme of Storage Allocation and Garbage Collection for Algol 68 , 1970, ALGOL 68 Implementation.

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

[38]  Carl A. Gunter,et al.  Proving memory management invariants for a language based on linear logic , 1992, LFP '92.

[39]  Matthias Felleisen,et al.  A Syntactic Approach to Type Soundness , 1994, Inf. Comput..