Bibliography

• Ole Agesen, David L. Detlefs. 1997. “Finding References in Java Stacks”. Sun Labs. OOPSLA97 Workshop on Garbage Collection and Memory Management.

• Ole Agesen, David L. Detlefs, J. Eliot B. Moss. 1998. “Garbage Collection and Local Variable Type-precision and Liveness in Java Virtual Machines”. ACM. Proceedings of the ACM SIGPLAN ‘98 conference on Programming language design and implementation, pp. 269–279.

• Andrew Appel, John R. Ellis, Kai Li. 1988. “Real-time Concurrent Collection on Stock Multiprocessors”. ACM, SIGPLAN. ACM PLDI 88, SIGPLAN Notices 23, 7 (July 88), pp. 11–20.

• Apple Computer, Inc. 1994. Inside Macintosh: Memory. Addison-Wesley. ISBN 0-201-63240-3.

• Giuseppe Attardi & Tito Flagella. 1994. “A Customisable Memory Management Framework”. TR-94-010.

• Giuseppe Attardi, Tito Flagella, Pietro Iglio. 1998. “A customisable memory management framework for C++”. Software – Practice and Experience. 28(11), 1143–1183.

• Alain Azagury, Elliot K. Kolodner, Erez Petrank, Zvi Yehudai. 1998. “Combining Card Marking with Remembered Sets: How to Save Scanning Time”. ACM. ISMM‘98 pp. 10–19.

• Henry G. Baker, Carl Hewitt. 1977. “The Incremental Garbage Collection of Processes”. ACM. SIGPLAN Notices 12, 8 (August 1977), pp. 55–59.

• Henry G. Baker. 1978. “List Processing in Real Time on a Serial Computer”. ACM. Communications of the ACM 21, 4 (April 1978), pp. 280–294.

• Henry G. Baker. 1979. “Optimizing Allocation and Garbage Collection of Spaces”. In Winston and Brown, eds. Artificial Intelligence: An MIT Perspective. MIT Press.

• Henry G. Baker. 1991. “Cache-Conscious Copying Collectors”. OOPSLA‘91/GC‘91 Workshop on Garbage Collection.

• Henry G. Baker. 1992. “Lively Linear Lisp – ‘Look Ma, No Garbage!’”. ACM. SIGPLAN Notices 27, 8 (August 1992), pp. 89–98.

• Henry G. Baker. 1992. “The Treadmill: Real-Time Garbage Collection Without Motion Sickness”. ACM. SIGPLAN Notices 27, 3 (March 1992), pp. 66–70.

• Henry G. Baker. 1992. “CONS Should not CONS its Arguments, or, a Lazy Alloc is a Smart Alloc”. ACM. SIGPLAN Notices 27, 3 (March 1992), 24–34.

• Henry G. Baker. 1992. “NREVERSAL of Fortune – The Thermodynamics of Garbage Collection”. Springer-Verlag. LNCS Vol. 637.

• Henry G. Baker. 1993. “‘Infant Mortality’ and Generational Garbage Collection”. ACM. SIGPLAN Notices 28, 4 (April 1993), pp. 55–57.

• Henry G. Baker. 1993. “Equal Rights for Functional Objects or, The More Things Change, The More They Are the Same”. ACM. OOPS Messenger 4, 4 (October 1993), pp. 2–27.

• Henry G. Baker. 1994. “Minimizing Reference Count Updating with Deferred and Anchored Pointers for Functional Data Structures”. ACM. SIGPLAN Notices 29, 9 (September 1994), pp. 38–43.

• Henry G. Baker. 1994. “Thermodynamics and Garbage Collection”. ACM. SIGPLAN Notices 29, 4 (April 1994), pp. 58–63.

• Henry G. Baker. 1995. “‘Use-Once’ Variables and Linear Objects – Storage Management, Reflection and Multi-Threading”. ACM. SIGPLAN Notices 30, 1 (January 1995), pp. 45–52.

• Henry G. Baker. 1995. Memory Management: International Workshop IWMM‘95. Springer-Verlag. ISBN 3-540-60368-9.

• Nick Barnes, Richard Brooksby, David Jones, Gavin Matthews, Pekka P. Pirinen, Nick Dalton, P. Tucker Withington. 1997. “A Proposal for a Standard Memory Management Interface”. OOPSLA97 Workshop on Garbage Collection and Memory Management.

• David A. Barrett, Benjamin Zorn. 1993. “Using Lifetime Predictors to Improve Memory Allocation Performance”. ACM. SIGPLAN‘93 Conference on Programming Language Design and Implementation, pp. 187–196.

• David A. Barrett, Benjamin Zorn. 1995. “Garbage Collection using a Dynamic Threatening Boundary”. ACM. SIGPLAN‘95 Conference on Programming Language Design and Implementation, pp. 301–314.

• Joel F. Bartlett. 1988. “Compacting Garbage Collection with Ambiguous Roots”. Digital Equipment Corporation.

• Joel F. Bartlett. 1989. “Mostly-Copying Garbage Collection Picks Up Generations and C++”. Digital Equipment Corporation.

• Yves Bekkers & Jacques Cohen. 1992. “Memory Management, International Workshop IWMM 92”. Springer-Verlag. LNCS Vol. 637, ISBN 3-540-55940-X.

• Emery D. Berger, Robert D. Blumofe. 1999. “Hoard: A Fast, Scalable, and Memory-Efficient Allocator for Shared-Memory Multiprocessors”. University of Texas at Austin. UTCS TR99-22.

• Emery D. Berger, Benjamin G. Zorn, Kathryn S. McKinley. 2001. “Composing high-performance memory allocators” ACM SIGPLAN Conference on Programming Language Design and Implementation 2001, pp. 114–124.

• Hans-J. Boehm, Mark Weiser. 1988. “Garbage collection in an uncooperative environment”. Software – Practice and Experience. 18(9):807–820.

• Hans-J. Boehm, Alan J. Demers, Scott Shenker. 1991. “Mostly Parallel Garbage Collection”. Xerox PARC. ACM PLDI 91, SIGPLAN Notices 26, 6 (June 1991), pp. 157–164.

• Hans-J. Boehm, David Chase. 1992. “A Proposal for Garbage-Collector-Safe C Compilation”. Journal of C Language Translation. vol. 4, 2 (December 1992), pp. 126–141.

• Hans-J. Boehm. 1993. “Space Efficient Conservative Garbage Collection”. ACM, SIGPLAN. Proceedings of the ACM SIGPLAN ‘91 Conference on Programming Language Design and Implementation, SIGPLAN Notices 28, 6, pp 197–206.

• Hans-J. Boehm. 2000. “Reducing Garbage Collector Cache Misses”. ACM. ISMM‘00 pp. 59–64.

• Hans-J. Boehm. 2002. “Destructors, Finalizers, and Synchronization”. HP Labs technical report HPL-2002-335.

• Robert S. Boyer and J. Strother Moore. 1977. “A Fast String Searching Algorithm”. Communications of the ACM 20(10):762–772.

• P. Branquart, J. Lewi. 1972. “A scheme of storage allocation and garbage collection for ALGOL 68”. Elsevier/North-Holland. ALGOL 68 Implementation – Proceedings of the IFIP Working Conference on ALGOL 68 Implementation, July 1970.

• Richard Brooksby. 2002. “The Memory Pool System: Thirty person-years of memory management development goes Open Source”. ISMM‘02.

• International Standard ISO/IEC 9899:1990. “Programming languages — C”.

• International Standard ISO/IEC 9899:1999. “Programming languages — C”.

• Brad Calder, Dirk Grunwald, Benjamin Zorn. 1994. “Quantifying Behavioral Differences Between C and C++ Programs”. Journal of Programming Languages. 2(4):313–351.

• Dante J. Cannarozzi, Michael P. Plezbert, Ron K. Cytron. 2000. “Contaminated garbage collection”. ACM. Proceedings of the ACM SIGPLAN ‘00 conference on on Programming language design and implementation, pp. 264–273.

• Patrick J. Caudill, Allen Wirfs-Brock. 1986. “A Third-Generation Smalltalk-80 Implementation”. ACM. SIGPLAN Notices. 21(11), OOPSLA‘86 ACM Conference on Object-Oriented Systems, Languages and Applications.

• C. J. Cheney. 1970. “A non-recursive list compacting algorithm”. CACM. 13-11 pp. 677–678.

• Perry Cheng, Robert Harper, Peter Lee. 1998. “Generational stack collection and profile-driven pretenuring”. ACM. Proceedings of SIGPLAN‘98 Conference on Programming Language Design and Implementation, pp. 162–173.

• Trishul M. Chilimbi, James R. Larus. 1998. “Using Generational Garbage Collection To Implement Cache-Conscious Data Placement”. ACM. ISMM‘98 pp. 37–48.

• William D Clinger & Lars T Hansen. 1997. “Generational Garbage Collection and the Radioactive Decay Model”. ACM. Proceedings of PLDI 1997.

• Jacques Cohen. 1981. “Garbage collection of linked data structures”. Computing Surveys. Vol. 13, no. 3.

• Dominique Colnet, Philippe Coucaud, Olivier Zendra. 1998. “Compiler Support to Customize the Mark and Sweep Algorithm”. ACM. ISMM‘98 pp. 154–165.

• Jonathan E. Cook, Alexander L. Wolf, Benjamin Zorn. 1994. “Partition Selection Policies in Object Database Garbage Collection”. ACM. SIGMOD. International Conference on the Management of Data (SIGMOD‘94), pp. 371–382.

• Jonathan E. Cook, Artur Klauser, Alexander L. Wolf, Benjamin Zorn. 1996. “Semi-automatic, Self-adaptive Control of Garbage Collection Rates in Object Databases”. ACM, SIGMOD. International Conference on the Management of Data (SIGMOD‘96), pp. 377–388.

• Eric Cooper, Scott Nettles, Indira Subramanian. 1992. “Improving the Performance of SML Garbage Collection using Application-Specific Virtual Memory Management”. ACM Conference on LISP and Functional Programming, pp. 43–52.

• Michael C. Daconta. 1993. C Pointers and Dynamic Memory Management. Wiley. ISBN 0-471-56152-5.

• Michael C. Daconta. 1995. C++ Pointers and Dynamic Memory Management. Wiley. ISBN 0-471-04998-0.

• O.-J. Dahl. 1963. “The SIMULA Storage Allocation Scheme”. Norsk Regnesentral. NCC Document no. 162.

• P. J. Denning. 1968. “Thrashing: Its Causes and Prevention”. Proceedings AFIPS,1968 Fall Joint Computer Conference, vol. 33, pp. 915–922.

• P. J. Denning. 1970. “Virtual Memory”. ACM. ACM Computing Surveys, vol. 2, no. 3, pp. 153–190, Sept. 1970.

• P. J. Denning, S. C. Schwartz. 1972. “Properties of the Working-set Model”. CACM. vol. 15, no. 3, pp. 191–198.

• David L. Detlefs. 1992. “Garbage collection and runtime typing as a C++ library”. USENIX C++ Conference.

• David L. Detlefs, Al Dosser, Benjamin Zorn. 1994. “Memory Allocation Costs in Large C and C++ Programs”. Software – Practice and Experience. 24(6):527–542.

• L. Peter Deutsch, Daniel G. Bobrow. 1976. “An Efficient, Incremental, Automatic Garbage Collector”. CACM. vol. 19, no. 9, pp. 522–526.

• E. W. Dijkstra, Leslie Lamport, A. J. Martin, C. S. Scholten, E. F. M. Steffens. 1976. “On-the-fly Garbage Collection: An Exercise in Cooperation”. Springer-Verlag. Lecture Notes in Computer Science, Vol. 46.

• Amer Diwan, Richard L. Hudson, J. Eliot B. Moss. 1992. “Compiler Support for Garbage Collection in a Statically Typed Language”. ACM. Proceedings of the 5th ACM SIGPLAN conference on Programming language design and implementation, pp. 273–282.

• Amer Diwan, David Tarditi, J. Eliot B. Moss. 1993. “Memory Subsystem Performance of Programs with Intensive Heap Allocation”. Carnegie Mellon University. CMU-CS-93-227.

• Amer Diwan, David Tarditi, J. Eliot B. Moss. 1994. “Memory Subsystem Performance of Programs Using Copying Garbage Collection”. ACM. CMU-CS-93-210, also in POPL ‘94.

• Damien Doligez & Xavier Leroy. 1993. “A concurrent, generational garbage collector for a multithreaded implementation of ML”. ACM. POPL ‘93, 113–123.

• Damien Doligez & Georges Gonthier. 1994. “Portable, unobtrusive garbage collection for multiprocessor systems”. ACM. POPL ‘94, 70–83.

• R. Kent Dybvig, Carl Bruggeman, David Eby. 1993. “Guardians in a Generation-Based Garbage Collector”. SIGPLAN. Proceedings of the ACM SIGPLAN ‘93 Conference on Programming Language Design and Implementation, June 1993.

• Daniel R. Edelson. 1992. “Smart pointers: They’re smart, but they’re not pointers”. USENIX C++ Conference.

• Daniel R. Edelson. 1992. “Comparing Two Garbage Collectors for C++”. University of California at Santa Cruz. Technical Report UCSC-CRL-93-20.

• Daniel J. Edwards. n.d. “Lisp II Garbage Collector”. MIT. AI Memo 19 (AIM-19).

• John R. Ellis, David L. Detlefs. 1993. “Safe, Efficient Garbage Collection for C++”. Xerox PARC.

• Paulo Ferreira. 1996. “Larchant: garbage collection in a cached distributed shared store with persistence by reachability”. Université Paris VI. Thése de doctorat.

• Paulo Ferreira & Marc Shapiro. 1998. “Modelling a Distributed Cached Store for Garbage Collection”. Springer-Verlag. Proceedings of 12th European Conference on Object-Oriented Programming, ECOOP98, LNCS 1445.

• Daniel P Friedman, David S. Wise. 1976. “Garbage collecting a heap which includes a scatter table”. Information Processing Letters. 5, 6 (December 1976): 161–164.

• Daniel P Friedman, David S. Wise. 1977. “The One Bit Reference Count”. BIT. (17)3: 351–359.

• Daniel P Friedman, David S. Wise. 1979. “Reference counting can manage the circular environments of mutual recursion”. Information Processing Letters. 8, 1 (January 1979): 41–45.

• Dirk Grunwald, Benjamin Zorn, R. Henderson. 1993. “Improving the Cache Locality of Memory Allocation”. SIGPLAN. SIGPLAN ‘93, Conference on PLDI, June 1993, Albuquerque, New Mexico.

• Dirk Grunwald & Benjamin Zorn. 1993. “CustoMalloc: Efficient Synthesized Memory Allocators”. Software – Practice and Experience. 23(8):851–869.

• David Gudeman. 1993. “Representing Type Information in Dynamically Typed Languages”. University of Arizona at Tucson. Technical Report TR 93-27.

• Timothy Harris. 1999. “Early storage reclamation in a tracing garbage collector”. ACM. ACM SIG-PLAN Notices 34:4, pp. 46–53.

• Roger Henriksson. 1994. “Scheduling Real Time Garbage Collection”. Department of Computer Science at Lund University. LU-CS-TR:94-129.

• Roger Henriksson. 1996. “Adaptive Scheduling of Incremental Copying Garbage Collection for Interactive Applications”. NWPER96.

• Roger Henriksson. 1998. “Scheduling Garbage Collection in Embedded Systems”. Department of Computer Science at Lund University. Ph.D. thesis.

• Antony L. Hosking. 1991. “Main memory management for persistence”. ACM. Proceedings of the ACM OOPSLA‘91 Workshop on Garbage Collection.

• Antony L. Hosking, J. Eliot B. Moss, Darko Stefanovic. 1992. “A comparative performance evaluation of write barrier implementations”. ACM. OOPSLA‘92 Conference Proceedings, ACM SIGPLAN Notices 27(10), pp 92–109.

• Antony L. Hosking, Richard L. Hudson. 1993. “Remembered sets can also play cards”. ACM. Proceedings of the ACM OOPSLA‘93 Workshop on Memory Management and Garbage Collection.

• Antony L. Hosking, J. Eliot B. Moss. 1993. “Protection traps and alternatives for memory management of an object-oriented language”. ACM. Proceedings of the Fourteenth ACM Symposium on Operating Systems Principles, ACM Operating Systems Review 27(5), pp 106–119.

• Richard L. Hudson, J. Eliot B. Moss, Amer Diwan, Christopher F. Weight. 1991. “A Language-Independent Garbage Collector Toolkit”. University of Massachusetts at Amherst. COINS Technical Report 91–47.

• Richard L. Hudson, J. Eliot B. Moss. 1992. “Incremental Collection of Mature Objects”. Springer-Verlag. LNCS #637 International Workshop on Memory Management, St. Malo, France, Sept. 1992, pp. 388–403.

• Richard L. Hudson, Ron Morrison, J. Eliot B. Moss, David S. Munro. 1997. “Garbage Collecting the World: One Car at a Time”. ACM. Proc. OOPSLA 97, pp. 162–175.

• “International Standard ISO/IEC 9899:1990 Programming languages — C”.

• Mark S. Johnstone. 1997. “Non-Compacting Memory Allocation and Real-Time Garbage Collection”. University of Texas at Austin.

• Mark S. Johnstone, Paul R. Wilson. 1998. “The Memory Fragmentation Problem: Solved?”. ACM. ISMM‘98 pp. 26–36.

• Richard E. Jones. 1992. “Tail recursion without space leaks”. Journal of Functional Programming. 2(1):73–79.

• Richard E. Jones, Rafael Lins. 1992. “Cyclic weighted reference counting without delay”. Computing Laboratory, The University of Kent at Canterbury. Technical Report 28-92.

• Richard E. Jones, Rafael Lins. 1996. “Garbage Collection: Algorithms for Automatic Dynamic Memory Management”. Wiley. ISBN 0-471-94148-4.

• Richard E. Jones. 1998. “ISMM‘98 International Symposium on Memory Management”. ACM. ISBN 1-58113-114-3.

• Richard E. Jones, Antony Hosking, and Eliot Moss. 2012. “The Garbage Collection Handbook”. Chapman & Hall.

• Ian Joyner. 1996. “C++??: A Critique of C++.”.

• Bob Kanefsky. 1989. “Recursive Memory Allocation”. Bob Kanefsky. Songworm 3, p.?.

• Jin-Soo Kim, Xiaohan Qin, Yarsun Hsu. 1998. “Memory Characterization of a Parallel Data Mining Workload”. IEEE. Proc. Workload Characterization: Methodology and Case Studies, pp. .

• Jin-Soo Kim & Yarsun Hsu. 2000. “Memory system behavior of Java programs: methodology and analysis”. ACM. Proc. International conference on measurements and modeling of computer systems, pp. 264–274.

• Elliot K. Kolodner. 1992. “Atomic Incremental Garbage Collection and Recovery for a Large Stable Heap”. Laboratory for Computer Science at MIT. MIT-LCS-TR-534.

• Per-Åke Larson & Murali Krishnan. 1998. “Memory Allocation for Long-Running Server Applications”. ACM. ISMM‘98 pp. 176–185.

• Henry Lieberman & Carl Hewitt. 1983. “A real-time garbage collector based on the lifetimes of objects”. ACM. 26(6):419–429.

• J. McCarthy, M. L. Minsky. 1959. “Artificial Intelligence, Quarterly Progress Report no. 53”. Research Laboratory of Electronics at MIT.

• J. McCarthy. 1960. “Recursive Functions of Symbolic Expressions and Their Computation by Machine”. CACM.

• John McCarthy. 1979. “History of Lisp”. In History of programming languages I, pp. 173–185. ACM.

• Veljko Milutinovic, Jelica Protic, Milo Tomasevic. 1997. “Distributed shared memory: concepts and systems”. IEEE Computer Society Press. ISBN 0-8186-7737-6.

• M. L. Minsky. 1963. “A LISP Garbage Collector Algorithm Using Serial Secondary Storage”. MIT. Memorandum MAC-M-129, Artificial Intelligence Project, Memo 58 (revised).

• David Moon. 1984. “Garbage Collection in a Large Lisp System”. ACM. Symposium on Lisp and Functional Programming, August 1984.

• David Moon. 1985. “Architecture of the Symbolics 3600”. IEEE. 12th International Symposium on Computer Architecture, pp. 76–83.

• David Moon. 1990. “Symbolics Architecture”. Wiley. Chapter 3 of Computers for Artificial Intelligence Processing, ISBN 0-471-84811-5.

• David Moon. 1991. “Genera Retrospective”. IEEE. 1991 International Workshop on Object Orientation in Operating Systems, order #2265.

• Ben-Ari Mordechai. 1984. “Algorithms for On-the-fly Garbage Collection”. TOPLAS 6(3): 333–344 (1984).

• Luc Moreau. 1998. “Hierarchical Distributed Reference Counting”. ACM. ISMM‘98 pp. 57–67.

• Greg Morrisett, Matthias Felleisen, Robert Harper. 1995. “Abstract Models of Memory Management”. Carnegie Mellon University. CMU-CS-FOX-95-01.

• David S. Munro, Alfred Brown, Ron Morrison, J. Eliot B. Moss. 1999. “Incremental Garbage Collection of a Persistent Object Store using PMOS”. Morgan Kaufmann. in Advances in Persistent Object Systems, pp. 78–91.

• Scott Nettles, James O’Toole, David Pierce, Nickolas Haines. 1992. “Replication-Based Incremental Copying Collection”. IWMM‘92.

• Scott Nettles. 1992. “A Larch Specification of Copying Garbage Collection”. Carnegie Mellon University. CMU-CS-92-219.

• Scott Nettles & James O’Toole. 1993. “Implementing Orthogonal Persistence: A Simple Optimization Using Replicating Collection”. USENIX. IWOOOS‘93.

• Scott Nettles & James O’Toole. 1993. “Real-Time Replication Garbage Collection”. ACM. PLDI‘93.

• Norman R. Nielsen. 1977. “Dynamic Memory Allocation in Computer Simulation”. ACM. CACM 20:11.

• James O’Toole. 1990. “Garbage Collecting Locally”.

• James O’Toole & Scott Nettles. 1994. “Concurrent Replicating Garbage Collection”. ACM. LFP‘94.

• Simon Peyton Jones, Norman Ramsey, Fermin Reig. 1999. “C–: a portable assembly language that supports garbage collection”. Springer-Verlag. International Conference on Principles and Practice of Declarative Programming 1999, LNCS 1702, pp. 1–28.

• John S. Pieper. 1993. “Compiler Techniques for Managing Data Motion”. Carnegie Mellon University. Technical report number CMU-CS-93-217.

• Pekka P. Pirinen. 1998. “Barrier techniques for incremental tracing”. ACM. ISMM‘98 pp. 20–25.

• Tony Printezis. 1996. “Disk Garbage Collection Strategies for Persistent Java”. Proceedings of the First International Workshop on Persistence and Java.

• Tony Printezis & Quentin Cutts. 1996. “Measuring the Allocation Rate of Napier88”. Department of Computing Science at University of Glasgow. TR ?.

• M. B. Reinhold. 1993. “Cache Performance of Garbage Collected Programming Languages”. Laboratory for Computer Science at MIT. MIT/LCS/TR-581.

• J. M. Robson. 1977. “Worst case fragmentation of first fit and best fit storage allocation strategies”. ACM. ACM Computer Journal, 20(3):242–244.

• Gustavo Rodriguez-Rivera & Vince Russo. 1997. “Non-intrusive Cloning Garbage Collection with Stock Operating System Support”. Software – Practice and Experience. 27:8.

• Niklas Röjemo. 1995. “Highlights from nhc – a space-efficient Haskell compiler”. Chalmers University of Technology.

• Niklas Röjemo. 1995. “Generational garbage collection for lazy functional languages without temporary space leaks”. Chalmers University of Technology.

• Niklas Röjemo & Colin Runciman. 1996. “Lag, drag, void and use – heap profiling and space-efficient compilation revisited”. ACM, SIGPLAN. ICFP‘96, ACM SIGPLAN Notices 31:6, ISBN 0-89791-770-7, pp. 34–41.

• David J. Roth, David S. Wise. 1999. “One-bit counts between unique and sticky”. ACM. ISMM‘98, pp. 49–56.

• Paul Rovner. 1985. “On Adding Garbage Collection and Runtime Types to a Strongly-Typed, Statically-Checked, Concurrent Language”. Xerox PARC. TR CSL-84-7.

• Colin Runciman & David Wakeling. 1992. “Heap Profiling of Lazy Functional Programs”. University of York.

• Colin Runciman & Niklas Röjemo. 1994. “New dimensions in heap profiling”. University of York.

• Colin Runciman & Niklas Röjemo. 1996. “Two-pass heap profiling: a matter of life and death”. Department of Computer Science, University of York.

• Jacob Seligmann & Steffen Grarup. 1995. “Incremental Mature Garbage Collection Using the Train Algorithm”. Springer-Verlag. ECOOP‘95, Lecture Notes in Computer Science, Vol. 952, pp. 235–252, ISBN 3-540-60160-0.

• Manuel Serrano, Hans-J. Boehm. 2000. “Understanding memory allocation of Scheme programs”. ACM. Proceedings of International Conference on Functional Programming 2000.

• Marc Shapiro & Paulo Ferreira. 1994. “Larchant-RDOSS: a distributed shared persistent memory and its garbage collector”. INRIA. INRIA Rapport de Recherche no. 2399; Cornell Computer Science TR94-1466.

• Robert A. Shaw. 1987. “Improving Garbage Collector Performance in Virtual Memory”. Stanford University. CSL-TR-87-323.

• Robert A. Shaw. 1988. “Empirical Analysis of a LISP System”. Stanford University. CSL-TR-88-351.

• Vivek Singhal, Sheetal V. Kakkad, Paul R. Wilson. 1992. “Texas: An Efficient, Portable Persistent Store”. University of Texas at Austin.

• P. G. Sobalvarro. 1988. “A Lifetime-based Garbage Collector for LISP Systems on General-Purpose Computers”. MIT. AITR-1417.

• Guy L. Steele. 1975. “Multiprocessing Compactifying Garbage Collection”. CACM. 18:9 pp. 495–508.

• Guy L. Steele. 1976. “Corrigendum: Multiprocessing Compactifying Garbage Collection”. CACM. 19:6 p.354.

• Guy L. Steele. 1977. “Data Representation in PDP-10 MACLISP”. MIT. AI Memo 421.

• James M. Stichnoth, Guei-Yuan Lueh, Michal Cierniak. 1999. “Support for Garbage Collection at Every Instruction in a Java Compiler”. SIGPLAN. Proceedings of the 1999 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). SIGPLAN Notices 34(5). pp. 118–127.

• Will R Stoye, T J W Clarke, Arthur C Norman. 1984. “Some Practical Methods for Rapid Combinator Reduction”. In LFP 1984, 159–166.

• David Tarditi & Amer Diwan. 1995. “Measuring the Cost of Storage Management”. Carnegie Mellon University. CMU-CS-94-201.

• Stephen Thomas, Richard E. Jones. 1994. “Garbage Collection for Shared Environment Closure Reducers”. Computing Laboratory, The University of Kent at Canterbury. Technical Report 31-94.

• Stephen Thomas. 1995. “Garbage Collection in Shared-Environment Closure Reducers: Space-Efficient Depth First Copying using a Tailored Approach”. Information Processing Letters. 56:1, pp. 1–7.

• Mads Tofte & Jean-Pierre Talpin. 1997. “Region-Based Memory Management”. Information and Computation 132(2), pp. 109–176.

• Dave Ungar. 1984. “Generation Scavenging: A Non-disruptive High Performance Storage Reclamation Algorithm”. ACM, SIGSOFT, SIGPLAN. Practical Programming Environments Conference.

• Dave Ungar & Frank Jackson. 1988. “Tenuring Policies for Generation-Based Storage Reclamation”. SIGPLAN. OOPSLA ‘88 Conference Proceedings, ACM SIGPLAN Notices, Vol. 23, No. 11, pp. 1–17.

• Kiem-Phong Vo. 1996. “Vmalloc: A General and Efficient Memory Allocator”. Software – Practice and Experience. 26(3): 357–374 (1996).

• Daniel C. Watson, David S. Wise. 1976. “Tuning Garwick’s algorithm for repacking sequential storage”. BIT. 16, 4 (December 1976): 442–450.

• Paul R. Wilson, Michael S. Lam, Thomas G. Moher. 1992. “Caching Considerations for Generational Garbage Collection”. ACM. L&FP 92.

• Paul R. Wilson, Sheetal V. Kakkad. 1992. “Pointer Swizzling at Page Fault Time”. University of Texas at Austin.

• Paul R. Wilson. 1994. “Uniprocessor Garbage Collection Techniques”. University of Texas.

• Paul R. Wilson, Mark S. Johnstone, Michael Neely, David Boles. 1995. “Dynamic Storage Allocation: A Survey and Critical Review”. University of Texas at Austin.

• David S. Wise. 1978. “The double buddy system”. Department of Computer Science at Indiana University. Technical Report 79.

• David S. Wise. 1979. “Morris’s garbage compaction algorithm restores reference counts”. TOPLAS. 1, 1 (July l979): 115–120.

• David S. Wise. 1985. “Design for a multiprocessing heap with on-board reference counting”. Springer-Verlag. In J.-P. Jouannaud (ed.), Functional Programming Languages and Computer Architecture, Lecture Notes in Computer Science 201: 289–304.

• David S. Wise. 1993. “Stop-and-copy and one-bit reference counting”. Information Processing Letters. 46, 5 (July 1993): 243–249.

• David S. Wise, Joshua Walgenbach. 1996. “Static and Dynamic Partitioning of Pointers as Links and Threads”. SIGPLAN. Proc. 1996 ACM SIGPLAN Intl. Conf. on Functional Programming, SIGPLAN Not. 31, 6 (June 1996), pp. 42–49.

• David S. Wise, Brian Heck, Caleb Hess, Willie Hunt, Eric Ost. 1997. “Uniprocessor Performance of a Reference-Counting Hardware Heap”. LISP and Symbolic Computation. 10, 2 (July 1997), pp. 159–181.

• P. Tucker Withington. 1991. “How Real is ‘Real-Time’ Garbage Collection?”. ACM. OOPSLA/ECOOP ‘91 Workshop on Garbage Collection in Object-Oriented Systems.

• G. May Yip. 1991. “Incremental, Generational Mostly-Copying Garbage Collection in Uncooperative Environments”. Digital Equipment Corporation.

• Taiichi Yuasa. 1990. “Real-Time Garbage Collection on General-Purpose Machines”. Journal of Software and Systems. 11:3 pp. 181–198.

• Benjamin Zorn & Paul Hilfinger. 1988. “A Memory Allocation Profiler for C and Lisp Programs”. USENIX. Proceedings for the Summer 1988 USENIX Conference, pp. 223–237.

• Benjamin Zorn. 1989. “Comparative Performance Evaluation of Garbage Collection Algorithms”. Computer Science Division (EECS) of University of California at Berkeley. Technical Report UCB/CSD 89/544 and PhD thesis.

• Benjamin Zorn. 1990. “Comparing Mark-and-sweep and Stop-and-copy Garbage Collection”. ACM. Conference on Lisp and Functional Programming, pp. 87–98.

• Benjamin Zorn. 1990. “Barrier Methods for Garbage Collection”. University of Colorado at Boulder. Technical Report CU-CS-494-90.

• Benjamin Zorn. 1991. “The Effect of Garbage Collection on Cache Performance”. University of Colorado at Boulder. Technical Report CU-CS-528-91.

• Benjamin Zorn & Dirk Grunwald. 1992. “Empirical Measurements of Six Allocation-intensive C Programs”. ACM, SIGPLAN. SIGPLAN notices, 27(12):71–80.

• Benjamin Zorn. 1993. “The Measured Cost of Conservative Garbage Collection”. Software – Practice and Experience. 23(7):733–756.

• Benjamin Zorn & Dirk Grunwald. 1994. “Evaluating Models of Memory Allocation”. ACM. Transactions on Modeling and Computer Simulation 4(1):107–131.