The GC bibliography

the Garbage Collection Bibliography

The bibliography is available in BibTeX format (including abstracts for many entries), or as PDF or in a series of web pages

I would be most grateful to receive additions, corrections and URLs of electronically available papers.

Last updated 1 October 2024.

L

[ladi92] Rivka Ladin and Barbara Liskov. Garbage collection of a distributed heap. In International Conference on Distributed Computing Systems, Yokohama, June 1992.

[ladi89] Rivka Ladin. A Method for Constructing Highly Available Services and a Technique for Distributed Garbage Collection. PhD thesis, MIT Press, 1989.

[lai07] Chunrong Lai, Volosyuk Ivan, and Xiao-Feng Li. Behavior characterization and performance study on compacting garbage collectors with Apache Harmony. In The 10th Workshop on Computer Architecture Evaluation using Commercial Workloads (CAECW), Phoenix, AZ, February 2007. Held with HPCA-13. Available here.

[lakh00] M.K. Lakhamraju, R. Rastoji, S. Seshadri, and S. Sundarshan. On-line reorganization in object databases. In ACM SIGMOD International Conference on Management of Data, Dallas, TX, May 2000. ACM Press.

[lal09] Akash Lal and Ganesh Ramalingam. Reference count analysis with shallow aliasing. Technical Report MSR-TR-2009-61, Microsoft Research, May 2009. Available here.

[lal10] Akash Lal and Ganesh Ramalingam. Reference count analysis with shallow aliasing. Information Processing Letters, 111(2):57-63, 2010. Available here.

[lam91] Monica S. Lam, Edward E. Rothberg, and Michael E. Wolf. The cache performance and optimizations of blocked algorithms. In ASPLOS 1991 [ASPLOS91], 1991, pages 63-74. Available here.

[lam92] Michael S. Lam, Paul R. Wilson, and Thomas G. Moher. Object type directed garbage collection to improve locality. In Bekkers and Cohen [IWMM92], 1992, pages 404-425. Available here.

[lam92a] Michael S. Lam. Improving Locality via Garbage Collection. PhD thesis, University of Illinois at Chicago, 1992.

[lamb91] Charles Lamb, Gordon Landis, Jack Orenstein, and Dan Weinreb. The ObjectStore database system. Communications of the ACM, 34(10):50-63, October 1991.

[lamo00] Myriam Lamolle, Thierry Millan, Pierre Bazex, and Marc Gonzalez. Garbage collection in object oriented databases - optimisation of unreachable objects detection. In 2nd International Workshop on Computer Science and Information Technologies, pages 38-46, Ufa, Russia, September 2000. Computer Science and Information Technologies. Available here.

[lamp76a] Leslie Lamport. Garbage collection with multiple processes: an exercise in co-operation. Technical Report CA-7602-2511, Computer Associates, Wakefield, MA, August 1976.

[lamp76] Leslie Lamport. Garbage collection with multiple processes: an exercise in parallelism. In ICPP 1976 [ICPP76], 1976, pages 50-54.

[lamp77] Leslie Lamport. Concurrent reading and writing. Communications of the ACM, 20(11):806-811, November 1977. Available here.

[lamp79] Leslie Lamport. A new approach to proving the correctness of multiprocess programs. ACM Transactions on Programming Languages and Systems, 1(1):84-97, July 1979.

[lamp91] Leslie Lamport. The temporal logic of actions. Research Report 79, DEC Systems Research Center, Palo Alto, CA, 1991.

[lamp23] Christos Lamprakos, Sotirios Xydis, Peter Kourzanov, Manu Perumkunnil, Francky Catthoor, and Dimitrios Soudris. Beyond RSS: Towards intelligent dynamic memory management. In Moss [MPLR23], 2023.

[lamp83] Butler W. Lampson. A description of the Cedar language: A Cedar language reference manual. Technical Report CLS-83-15, Xerox PARC, Palo Alto, CA, 1983.

[lang92a] Bernard Lang, Christian Quenniac, and José Piquer. Garbage collecting the world. In POPL 1992 [POPL92], 1992, pages 39-50. Available here.

[lang87a] Bernard Lang and B. Dupont. Incremental incrementally compacting garbage collection. In Programing Of Future Generation Computers II, Proceedings of the Second Franco-Japanese Symposium, pages 163-182. North Holland, November 1987. Extended version of [lang87].

[lang87] Bernard Lang and Francis Dupont. Incremental incrementally compacting garbage collection. In SIGPLAN 1987 [PLDI87], 1987, pages 253-263. Available here.

[lang72] Bernard Lang and B. Wegbreit. Fast compactification. Technical Report 25-72, Harvard University, Cambridge, MA, November 1972. Available here.

[lang92] Koen G. Langendoen, H.L. Muller, and Willem G. Vree. Memory management for parallel tasks in shared memory. In Bekkers and Cohen [IWMM92], 1992, pages 165-178. Available here.

[lang91] Koen G. Langendoen and Willem G. Vree. FRATS: A parallel reduction strategy for shared memory. In M. Wirsing and J. Maluszynski, editors, 3rd international Symposium on Programming Language Implementation ans Logic Programming, Passau, Germany, volume 528 of Lecture Notes in Computer Science, pages 99-110. Springer-Verlag, August 1991.

[laro98] Martin Larose and Marc Feeley. A compacting incremental collector and its performance in a production quality compiler. In Peyton~Jones and Jones [ISMM98], 1998, pages 1-9. Available here.

[lars77] Richard G. Larson. Minimizing garbage collection as a function of region size. SIAM Journal of Computing, 6(4):663-668, December 1977.

[laru88] James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In PLDI 1988 [PLDI88], 1988, pages 21-34. Available here.

[latt02] Chris Lattner and Vikram Adve. Automatic pool allocation for disjoint data structures. In MSP 2002 [MSP02], 2002. Available here.

[latt05] Chris Lattner and Vikram S. Adve. Automatic pool allocation: Improving performance by controlling data structure layout in the heap. In Sarkar and Hall [PLDI05], 2005, pages 129-142. Available here.

[laye91] D.K. Layer and C. Richardson. Lisp systems in the 1990s. Communications of the ACM, 34(9):48-57, 1991.

[LCPC01] 14th Workshop on Languages and Compilers for Parallel Computing, volume 2624 of Lecture Notes in Computer Science, Cumberland Falls, KT, August 2001. Springer-Verlag.

[LCPC07] 20th Workshop on Languages and Compilers for Parallel Computing, Urbana, IL, October 2007.

[LCPC08] 21st Workshop on Languages and Compilers for Parallel Computing, University of Alberta, 2008.

[LCTES94] PLDI Workshop on Language, Compiler, and Tool Support for Real-Time Systems, Orlando, FL, June 1994. ACM Press.

[LCTES95] ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Real-Time Systems (LCT-RTS), ACM SIGPLAN Notices 30(11), La Jolla, CA, June 1995. ACM Press. Available here.

[LCTES99] ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Embedded Systems (LCTES), ACM SIGPLAN Notices 34(7), Atlanta, GA, May 1999. ACM Press. Available here.

[LCTES00] ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Embedded Systems (LCTES), volume 1985 of Lecture Notes in Computer Science, Vancouver, Canada, June 2000. Springer. Available here.

[LCTES01] ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Embedded Systems (LCTES), ACM SIGPLAN Notices 36(8), Snowbird, UT, June 2001. ACM Press. Available here.

[LCTES03] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 38(7), San Diego, CA, June 2003. ACM Press. Available here.

[LCTES04] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 39(7), Washington, DC, June 2004. ACM Press. Available here.

[LCTES05] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 40(7), Chicago, IL, June 2005. ACM Press. Available here.

[LCTES06] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 41(7), Ottawa, Canada, June 2006. ACM Press. Available here.

[LCTES07] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 42(7), San Diego, CA, June 2007. ACM Press. Available here.

[LCTES08] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 43(7), Tucson, AZ, June 2008. ACM Press. Available here.

[LCTES09] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 44(7), Dublin, Ireland, June 2009. ACM Press. Available here.

[LCTES10] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, ACM SIGPLAN Notices 45(4), Stockholm, Sweden, April 2010. ACM Press. Available here.

[LCTES11] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, Chicago, IL, April 2011. ACM Press. Available here.

[LCTES14] ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems, Edinburgh, UK, 2014. ACM Press.

[LCTES02] Joint Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES) and Software and Compilers for Embedded Systems (SCOPES), ACM SIGPLAN Notices 37(7), Berlin, Germany, June 2002. ACM Press. Available here.

[le19] Tung D. Le, Haruki Imai, Yasushi Negishi, and Kiyokuni Kawachiya. Automatic GPU memory management for large neural models in TensorFlow. In Xu and Singer [ISMM19], 2019, pages 1-13. Available here.

[le15] Matthew Le and Matthew Fluet. Partial aborts for transactions via first-class continuations. In ICFP 2015 [ICFP15], 2016, pages 230–-242. Available here.

[fess97] Fabrice Le Fessant, Ian Piumarta, and Marc Shapiro. A detection algorithm for distributed cycles of garbage. In Dickman and Wilson [OOPSLA97-gc], 1997. Available here.

[fess98] Fabrice Le Fessant, Ian Piumarta, and Marc Shapiro. An implementation for complete, asynchronous, distributed, garbage collection. In PLDI 1998 [PLDI98], 1998, pages 152-161. Available here.

[fess99] Fabrice Le Fessant. Detection of free distributed cycles in large-scale networks. Technical report, INRIA Rocquencourt, January 1999. Available here.

[fess01] Fabrice Le Fessant. Detecting distributed cycles of garbage in large-scale systems. In PODC 2001 [PODC01], 2001, pages 200-209. Available here.

[lehu88] Serge Le Huitouze. Mise en Oeuvre de PrologII/MALI. PhD thesis, Université de Rennes I, 1988.

[huit90] S. Le Huitouze. A new data structure for implementing extensions to Prolog. In P. Deransart and J. Maluszyński, editors, International Workshop on Programming Languages Implementation and Logic Programming, volume 456 of Lecture Notes in Computer Science. Springer-Verlag, 1990.

[lehu90] Serge Le Huitouze. A new data structure for implementing extensions to Prolog. In International Symposium on Programming Language Implementati on and Logic Programming, pages 136-150, Linköping, Sweden, 1990.

[lese92] Thierry Le Sergent and Bernard Barthomieu. Incremental multi-threaded garbage collection on virtually shared memory architectures. In Bekkers and Cohen [IWMM92], 1992, pages 179-199. Available here.

[lea93] Doug Lea. The GNU C++ library. The C++ Report, 1993. Available here.

[lea97] Doug Lea. A memory allocator. Technical report, Oswego State University of New York, 1997. Available here.

[lebs05] Carl S. Lebsack and J. Morris Chang. Using scratchpad to exploit object locality in Java. In International Conference on Computer Design, San Jose, CA, October 2005. IEEE Computer Society Press. Available here.

[lee79] S. Lee, W.P. De Roever, and S. Gerhart. The evolution of list copying algorithms. In 6th ACM Symposium on Principles of Programming Languages, pages 53-56, San Antonio, TX, January 1979. ACM Press.

[lee87] S. Lee, Heonshik Shin, and Miroslaw Malek. Parallel garbage collection with associative tag. In International Conference on Computers and Applications, Beijing, June 1987.

[lee00] Woo Hyong Lee, J. Morris Chang, and Yusuf Hasan. Dynamic memory measuring tool for C++ programs. In 3rd IEEE Symposium on Application-Specific Systems and Software Engineering Technology (ASSET), Richardson, TX, March 2000.

[lee00a] Woo Hyong Lee, J. Morris Chang, and Yusuf Hasan. Evaluation of a high-performance object reuse dynamic memory allocation policy for C++ programs. In 4th IEEE International Conference on High Performance Computing in Asia-Pacific Region, pages 386-391, Beijing, China, May 2000.

[lee05] Oukseh Lee, Hongseok Yang, and Kwangkeun Yi. Static insertion of safe and effective memory reuse commands into ML-like programs. Science of Computer Programming, 58(1-2):141-178, October 2005. Available here.

[lee15] J. Lee, C.G. Park, Y. Chuh, J. Noh, and M. Muehle. Version garbage collection using snapshot lists. US Patent 13/750,204, 2015.

[lee16] Juchang Lee, Hyungyu Shin, Chang Gyoo Park, Seongyun Ko, Jaeyun Noh, Yongjae Chuh, Wolfgang Stephan, and Wook-Shin Han. Hybrid garbage collection for multi-version concurrency control in SAP HANA. In SIGMOD 1916 [SIGMOD16], 2016, pages 1307-1318. Available here.

[lee20] Dokeun Lee, Youjip Won, Yongjun Park, and Seongjin Lee. Two-tier garbage collection for persistent object. In Proceedings of the 35th Annual ACM Symposium on Applied Computing, pages 1246-1255, New York, NY, USA, March 2020. ACM Press. Available here.

[lee89] T. Paul Lee and R.E. Barkley. Design and evaluation of a watermark-based lazy buddy system. Performance Evaluation Review, 17(1), May 1989.

[lee02] Woo Hyong Lee and J. Morris Chang. A study of dynamic memory management in C++ programs. International Journal of Computer Languages, 28:237-272, 2002.

[lee03] Woo Hyong Lee and J. Morris Chang. A garbage collection policy based on empirical behavior. International Journal of Information Sciences, 2003. To appear.

[lee03a] Woo Hyong Lee and J. Morris Chang. An integrated dynamic memory tracing tool for C++ programs. International Journal of Information Sciences, 151:27-49, May 2003.

[lee04] Oukseh Lee and Kwangkeun Yi. Experiments on the effectiveness of an automatic insertion of memory reuses into ML-like programs. In SPACE 2004 [SPACE04], 2004.

[lee04a] Oukseh Lee and Kwangkeun Yi. Experiments on the effectiveness of an automatic insertion of memory reuses into ML-like programs. In Bacon and Diwan [ISMM04], 2004, pages 97-107. Available here.

[lee97] Han Bok Lee and Benjamin G. Zorn. Bytecode instrumentation as an aid in understanding the behaviour of Java persistent stores. In Dickman and Wilson [OOPSLA97-gc], 1997. Available here.

[lee80] K.P. Lee. A linear algorithm for copying binary trees using bounded workspace. Communications of the ACM, 23(3):159-162, March 1980.

[lee88] Elgin Hoe-Sing Lee. Object storage and inheritance for SELF, a prototype-based object-oriented programming language. Engineer's thesis, Stanford University, Palo Alto, CA, December 1988.

[lei19] Daan Leijen, Benjamin Zorn, and Leonardo de Moura. Mimalloc: Free list sharding in action. In Anthony Widjaja Lin, editor, Programming Languages and Systems, volume 11893 of Lecture Notes in Computer Science, pages 244-265. Springer International Publishing, 2019.

[leng15] Philipp Lengauer, Verena Bitto, and Hanspeter Mössenböck. Accurate and efficient object tracing for Java applications. In Sachs and Llad'o [ICPE15], 2015. Available here.

[leng17] Philipp Lengauer, Verena Bitto, Hanspeter Mössenböck, and Markus Weninger. A comprehensive Java benchmark study on memory and garbage collection behavior of DaCapo, DaCapo Scala, and SPECjvm2008. In Koziolek et al. [ICPE17], 2017, pages 3-14. Available here.

[leng14] Philipp Lengauer and Hanspeter Mössenböck. The Taming of the Shrew: Increasing performance by automatic parameter tuning for Java garbage collectors. In Binder and Merseguer [ICPE14], 2014, pages 111-122. Available here.

[lerm86] C.-W. Lermen and Dieter Maurer. A protocol for distributed reference counting. In LFP 1986 [LFP86], 1986, pages 343-350. Available here.

[lamp75] Lamport Leslie. On-the-fly garbage collection: Once more with rigor. Technical Report CA-7508-1611, Computer Associates, Wakefield, MA, August 1975.

[lest89] David Lester. An efficient distributed garbage collection algorithm. In Odijk et al. [PARLE89], 1989, pages 207-203. Available here.

[lest92] David Lester. Distributed garbage collection of cyclic structures. In 4th International Workshop on the Parallel Implementation of Functional Languages, Aachen, September 1992. Available from Herbert Kuchen, Lehrstuhl Informatik II, RWTH Aachen, Ahornstr. 55, W-51000 Aachen. Also Glasgow Functional Programming Workshop 1993.

[leun97] Ho-Fung Leung and Hing-Fung Ting. An optimal algorithm for global termination detection in shared-memory asynchronous multiprocessor systems. IEEE Transactions on Parallel and Distributed Systems, 8(5):538-543, May 1997. Available here.

[leva99] Yossi Levanoni and Erez Petrank. A scalable reference counting garbage collector. Technical Report CS-0967, Technion - Israel Institute of Technology, Haifa, Israel, November 1999.

[leva01] Yossi Levanoni and Erez Petrank. An on-the-fly reference counting garbage collector for Java. In OOPSLA 2001 [OOPSLA01], 2001, pages 367-380. Available here.

[leva06] Yossi Levanoni and Erez Petrank. An on-the-fly reference counting garbage collector for Java. ACM Transactions on Programming Languages and Systems, 28(1):1-69, January 2006. Available here.

[leve92] Willem G. Levelt, M. Frans Kaashoek, Henri E. Bal, and Andrew Tanenbaum. A comparison of two paradigms for distributed shared memory. Software: Practice and Experience, 22(11):985-1010, November 1992.

[leve82] B.W. Leverett and P.G. Hibbard. An adaptive system for dynamic storage allocation. Software: Practice and Experience, 12(6):543-556, June 1982.

[lewi74] T.G. Lewis, B.J. Smith, and M.Z. Smith. Dynamic memory allocation systems for minimizing internal fragmentation. In ACM Annual Conference, pages 725-728. ACM Press, November 1974.

[emacs98] Bill Lewis, Dan LaLiberte, Richard Stallman, and the GNU Manual Group. GNU Emacs Lisp Reference Manual. {GNU Project, May 1998.

[lext92] Vincent Lextrait. Generation de Serveurs de Vues. PhD thesis, University of Nice, lextrait@hotmail.com, December 1992. (In french).

[LFP80] LISP Conference, Stanford University, CA, August 1980. ACM Press. Available here.

[LFP82] ACM Symposium on LISP and Functional Programming, Pittsburgh, PA, August 1982. ACM Press. Available here.

[LFP84] Guy L. Steele, editor. ACM Conference on LISP and Functional Programming, Austin, TX, August 1984. ACM Press. Available here.

[LFP86] ACM Conference on LISP and Functional Programming, Cambridge, MA, August 1986. ACM Press. Available here.

[LFP88] ACM Conference on LISP and Functional Programming, Snowbird, UT, July 1988. ACM Press. Available here.

[LFP90] ACM Conference on LISP and Functional Programming, Nice, France, June 1990. ACM Press. Available here.

[LFP92] ACM Conference on LISP and Functional Programming, San Francisco, CA, June 1992. ACM Press. Available here.

[LFP94] ACM Conference on LISP and Functional Programming, Orlando, FL, June 1994. ACM Press. Available here.

[lhot02] Ondrej Lhoták and Laurie Hendren. Run-time evaluation of opportuniites for object inlining in Java. In Joint ACM Java Grande - ISCOPE Conference, pages 175-184, Seattle, WA, 2002. ACM Press. Available here.

[li08] Xiao-Feng Li, L. Wang, and C. Yang. A fully parallel LISP2 compactor with preservation of the sliding properties. In LCPC 2008 [LCPC08], 2008.

[li14] Pengcheng Li, Chen Ding, and Hao Luo. Modeling heap data growth using average liveness. In Guyer and Grove [ISMM14], 2014, pages 71-82. Available here.

[li85] Kai Li and Paul Hudak. A new list compaction method. Research Report 362, Yale University, February 1985.

[li86] Kai Li and Paul Hudak. A new list compaction method. Software: Practice and Experience, 16(2):145-163, February 1986.

[li89] Kai Li and Paul Hudak. Memory coherence in shared virtual memory systems. ACM Transactions on Computer Systems, 7(4):321-359, November 1989.

[li14a] Siliang Li and Gang Tan. Finding reference-counting errors in Python/C programs with affine analysis. In Jones [ECOOP14], 2014, pages 80-104. Available here.

[li86a] Kai Li. Shared Virtual Memory on Loosely Coupled Multiprocessors. PhD thesis, Yale University, 1986.

[li90] Kai Li. Real-time concurrent collection in user mode. In Jul and Juul [OOPSLA90-gc], 1990. Available here.

[li09] Xiao-Feng Li. Tick: Concurrent gc in Apache Harmony. Slides on Harmony's Tick GCs, 2009. Available here.

[lian12] Hongjin Liang, Xinyu Feng, and Ming Fu. A rely-guarantee-based simulation for verifying concurrent program transformations. In POPL 2012 [POPL12], 2012. Available here.

[lian14] H. Liang, X. Feng, , and M. Fu. Rely-Guarantee-based simulation for compositional verification of concurrent program transformations. ACM Transactions on Programming Languages and Systems, 2014.

[libi14] Peter Libic, Lubomír Bulej, Vojtech Horky, and Petr Tuma.On the limits of modeling generational garbage collector performance. In Proceedings of the 5th ACM/SPEC International Conference on Performance Engineering (ICPE'14), pages 15-26, Dublin, Ireland, 2014. ACM Press. Available here.

[libi15] Peter Libic, Lubom\'}r Bulej, Vojtech Horky, and Petr Tuma.Estimating the impact of code additions on garbage collection overhead. In 12th European Workshop on Computer Performance Engineering (EPEW'15), volume 9272 of Lecture Notes in Computer Science, pages 130-145, Madrid, Spain, 2015. Springer. Available here.

[lide18] Per Lidén and Stefan Karlsson. JEP 333: ZGC: A scalable low-latency garbage collector (experimental). Technical report, OpenJDK, 2018. Available here.

[lide18a] Per Lidén and Stefan Karlsson. The Z garbage collector. In FOSDEM, 2018. Available here.

[lide18b] Per Lidén. JEP 377: ZGC: A scalable low-latency garbage collector (production). Technical report, OpenJDK, 2018. Available here.

[lide20] Per Lidén. ZGC | what's new in JDK 14. https://malloc.se/blog/zgc-jdk14, March 2020. Available here.

[lide20a] Per Lidén. ZGC | what's new in JDK 15. https://malloc.se/blog/zgc-jdk15, September 2020. Available here.

[lide21] Per Lidén. ZGC | what's new in JDK 16. https://malloc.se/blog/zgc-jdk16, March 2021. Available here.

[lide21a] Per Lidén. ZGC | what's new in JDK 17. https://malloc.se/blog/zgc-jdk17, October 2021. Available here.

[lide22] Per Lidén. ZGC | what's new in JDK 18. https://malloc.se/blog/zgc-jdk18, April 2022. Available here.

[lieb81] Henry Lieberman and Carl E. Hewitt. A real-time garbage collector based on the lifetimes of objects. {AI Memo 569a, MIT, April 1981. Available here.

[lieb83] Henry Lieberman and Carl E. Hewitt. A real-time garbage collector based on the lifetimes of objects. Communications of the ACM, 26(6):419-429, June 1983. Also report TM-184, Laboratory for Computer Science, MIT, Cambridge, MA, July 1980 and AI Lab Memo 569, 1981. Available here.

[liec06] Florian Liekweg. Compiler-directed automatic memory management. In SPACE 2006 [SPACE06], 2006, pages 23-34. Available here.

[lim98] Tian F. Lim, Przemyslaw Pardyak, and Brian N. Bershad. A memory-efficient real-time non-copying garbage collector. In Peyton~Jones and Jones [ISMM98], 1998, pages 118-129. Available here.

[lin07a] Chunxiao Lin, Andrew McCreight, Zhong Shao, Yiyun Chen, and Yu Guo. Foundational typed assembly language with certified garbage collection. In 1st IEEE IFIP International Symposium on Theoretical Aspects of Software Engineering (TASE 2007), pages 326-–335, Shanghai, China, June 2007. IEEE Computer Society Press.

[lin09] C. Lin, Y. Chen, and B. Hua. Verification of an incremental garbage collector in Hoare-style logic. International Journal of Software and Informatics, 3(1):67-–88, March 2009.

[lin12] Yi Lin, Stephen M. Blackburn, and Daniel Frampton. Unpicking the knot: Teasing apart VM/application interdependencies. In Hand and da Silva [VEE12], 2012, pages 181-190. Available here.

[lin15] Yi Lin, Kunshan Wang, Stephen M. Blackburn, Antony L. Hosking, and Michael Norrish. Stop and go: Understanding yieldpoint behavior. In Bond and Hosking [ISMM15], 2015. Available here.

[lin16] Yi Lin, Stephen M. Blackburn, Antony L. Hosking, and Michael Norrish. Rust as a language for high performance GC implementation. In Zhang and Flood [ISMM16], 2016, pages 89-98. Available here.

[lin00] Chi-Min Lin and Tien-Fu Chen. Dynamic memory management for real-time embedded Java chips. In RTCSA 2000 [RTCSA00], 2000. Available here.

[lin06] Chin-Yang Lin and Ting-Wei Hou. A lightweight cyclic reference counting algorithm. In International Conference on Grid and Pervasive Computing, number 3947 in Lecture Notes in Computer Science, pages 246-359. Springer-Verlag, 2006.

[lin07] Chin-Yang Lin and Ting-Wei Hou. A simple and efficient algorithm for cycle collection. ACM SIGPLAN Notices, 42(3):7-13, March 2007. Available here.

[lin10] Chin-Yang Lin and Ting-Wei Hou. An efficient approach to cyclic reference counting based on a coarse-grained search. Information Processing Letters, 111(1):1-10, December 2010.

[lin92] Sheng-Lien Lin. Performance evaluation of a generation scavenging algorithm. 1992.

[linc92] Patrick Lincoln and John Mitchell. Operational aspects of linear lambda calculus. In 7th Annual IEEE Symposium on Logic in Computer Science (LICS), pages 235-246, Santa Cruz, CA, June 1992. IEEE Press.

[lind12] Tim Lindholm, Frank Yellin, Gilad Bracha, and Alex Buckley. Java Virtual Machine Specification. Oracle America, Inc., Java 7 SE edition, 2012.

[lind87] T.G. Lindholm and R.A. O'Keefe. Efficient implementation of a defensible semantics for dynamic Prolog code. In Lassez [ICLP87], 1987.

[lind99] Tim Lindholm and Frank Yellin. Java Virtual Machine Specification. Addison-Wesley Longman Publishing Co., Inc., 1999.

[lind94] Anders Lindstrom, Alan Dearle, Rex di Bona, J. Matthew Farrow, Frans Henskens, John Rosenberg, and Francis Vaughan. A model for user-level memory management in a distributed, persistent environment. In Gopal Gupta, editor, 17th Annual Australasian Computer Science Conference (ACSC), Part B, pages 343-354, Christchurch, New Zealnad, January 1994. Available here.

[lind81] Gary Lindstrom and Mary Lou Soffa. Referencing and retention in block-structured coroutines. ACM Transactions on Programming Languages and Systems, 3(3):263-292, July 1981.

[lind73] Gary Lindstrom. Scaning list structures without stacks or tag bits. Information Processing Letters, 2(2):47-51, June 1973.

[lind74] Gary Lindstrom. Copying list structures using bounded workspace. Communications of the ACM, 17(4):199-202, April 1974.

[lins07] R.D. Lins, F. Heron de Carvalho Junior, and Z.D. Lins. Cyclic reference counting with permanent objects. Journal of Universal Computer Science, 13(6):830-838, 2007.

[lins94] Rafael D. Lins and Frank Dehne. Distributed reference counting. In 1994 Canada-France Conference on Parallel Computing, number 805 in Lecture Notes in Computer Science, pages 95-100. Springer-Verlag, May 1994.

[lins91c] Rafael D. Lins and Richard E. Jones. Cyclic weighted reference counting. In K. Boyanov, editor, Procedings of WP & DP'93 Workshop on Parallel and Distributed Processing, pages 369-382, Sofia, Bulgaria, May 1993. North Holland. Also Computing Laboratory Technical Report 95, University of Kent, December 1991.

[lins91a] Rafael D. Lins and Márcio A. Vasques. A comparative study of algorithms for cyclic reference counting. Technical Report 92, Computing Laboratory, The University of Kent at Canterbury, August 1991.

[lins91b] Rafael D. Lins. A shared memory architecture for parallel cyclic reference counting. Microprocessing and Microprogramming, 32:53-58, September 1991.

[lins90a] Rafael D. Lins. Cyclic reference counting with lazy mark-scan. Information Processing Letters, 44(4):215-220, 1992. Also Computing Laboratory Technical Report 75, University of Kent, July 1990. Available here.

[lins92c] Rafael D Lins. Generational cyclic reference counting. Technical Report 22-92, Computing Laboratory, University of Kent, September 1992.

[lins92] Rafael D. Lins. A multi-processor shared memory architecture for parallel cyclic reference counting. Microprocessing and Microprogramming, 35:563-568, September 1992.

[lins02] Rafael D. Lins. An efficient algorithm for cyclic reference counting. Information Processing Letters, 83:145-150, 2002.

[lins05] R. Lins. A new multiprocessor architecture for parallel lazy cyclic reference counting. In 17th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD). IEEE Press, 2005.

[lisk86] Barbara Liskov and Rivka Ladin. Highly available distributed services and fault-tolerant distributed garbage collection. In Halpern [PODC86], 1986, pages 29-39.

[list12] Michael List and David Car. A polymorphic reference counting implementation in Fortran 2003. SIGPLAN Fortran Forum, 30(2):4–-27, March 2011. Available here.

[liu09] Shaoshan Liu, Ligang Wang, Xiao-Feng Li, and Jean-Luc Gaudiot. Space-and-time efficient garbage collectors for parallel systems. In Proceedings of the 6th ACM conference on Computing Frontiers (CF’09), pages 21-–30, Ischia, Italy, May 2009. Available here.

[liu12] Shaoshan Liu, Jie Tang, Ligang Wang, Xiao-Feng Li, and Jean-Luc Gaudiot. Packer: Parallel garbage collection based on virtual spaces. IEEE Transactions on Computers, 61(11):1611-1623, November 2012. Available here.

[llam91] Rene Lim Llames. Performance Analysis of Garbage Collection and Dynamic Reordering in a Lisp System. PhD thesis, University of Illinois at Urbana-Champaign, 1991.

[lo98] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. Boundary analysis for buddy systems. In International Computer Symposium (Computer Architecture Track), pages 96-103, Tainan, Taiwan, December 1998.

[lo00] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. Page replacement performance in garbage collection systems. In 13th International Conference on Parallel and Distributed Computing Systems, pages 374-379, Las Vegas, NA, August 2000.

[lo00a] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. A quantitative simulator for dynamic memory managers. In ISPASS 2000 [ISPASS00], 2000, pages 64-69. Available here.

[lo01] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. A study of page replacement performance in garbage collection heap. Journal of Systems and Software, 58(3):235-245, September 2001.

[lo02c] Chia-Tien Dan Lo, J. Morris Chang, Ophir Frieder, and David Grossman. The object behaviour of Java object-oriented database management systems. In International Conference on Information Technology: Coding and Computing (ITCC). IEEE Press, 2002.

[lo02] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. A high performance garbage collector for Java. In Proceeding of the 2002 International Computer Symposium, ICS 2002, National Dong Hwa University, Hualien, Taiwan, December 2002.

[lo02a] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. A multithreaded concurrent garbage collector which parallelizes the new instruction in Java. In International Parallel and Distributed Processing Symposium, pages 59-64, Fort Lauderdale, FL, April 2002.

[lo02b] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. A performance comparison between stop-the-world and multithreaded concurrent garbage collection for Java. In 21st IEEE International Performance, Computing, And Communications Conference (IPCCC 2002), pages 301-308, Phoenix, AZ, April 2002.

[lo03] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. Who is collecting your Java garbage?. IEEE IT Professional, 5(2):44-50, April 2003.

[lo04] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. The design and analysis of a quantitative simulator for dynamic memory management. Journal of Systems and Software, 72(3):443-453, August 2004. Available here.

[lo05] Chia-Tien Dan Lo, Witiwas Srisa-an, and J. Morris Chang. Security issues in garbage collection. CrossTalk: The Journal of Defense Software Engineering, October 2005. Available here.

[lo01a] Chia-Tien Dan Lo and J. Morris Chang. A multithreaded concurrent generational garbage collector for Java. In OOPSLA 2001 [OOPSLA01], 2001, pages 7-9. Doctoral Symposium. Available here.

[loid00] H-W. Loidl. Investigating the memory management in a parallel graph reducer. In M. Mohnen and P. Koopman, editors, 12th International Workshop on Implementation of Functional Languages, number AIB-00-7 in Aachener Informatik Berichte, pages 185-200. RWTH Aachen, 2000.

[lome75] D.B. Lomet. Scheme for invalidating references to freed storage. IBM Journal of Research and Development, pages 26-35, January 1975.

[lore22] Anton Lorenzen and Daan Leijen. Reference counting with frame limited reuse. In ICFP 2022 [ICFP22], 2022.

[loub95b] Sylvain Louboutin and Vinny Cahill. A lazy log-keeping mechanism for comprehensive global garbage detection on Amadeus. In OOIS (Object-Oriented Information Systems) '95, pages 118-132, London, December 1995. Springer-Verlag. Technical report TCD-CS-95-11. Available here.

[loub95a] Sylvain Louboutin and Vinny Cahill. Lazy, per cluster log-keeping mechanism for global garbage detection on Amadeus. Technical Report TCD-CS-95-13, Department of Computer Science, Trinity College, May 1995. Available here.

[loub95] Sylvain Louboutin and Vinny Cahill. On comprehensive global garbage detection. In Proceeding of the European Research Seminar on Advances in Distributed Systems (ERSADS '95), pages 208-213, Alpes d'Huez, France, April 1995. INRIA/IMAG. Also technical report TCD-CS-95-11, Department of Computer Science, Trinity College Dublin. Available here.

[loub97] Sylvain R.Y. Louboutin and Vinny Cahill. Comprehensive distributed garbage collection by tracking causal dependencies of relevant mutator events. In International Conference on Distributed Computing Systems (ICDCS). IEEE Press, 1997. Available here.

[loub98] Sylvain R.Y. Louboutin. A Reactive Approach to Comprehensive Global Garbage Detection. PhD thesis, Trinity College, Dublin, 1998.

[lowr02] M.C. Lowry and David S. Munro. Safe and complete distributed garbage with the Train algorithm. In International Conference on Parallel and Distributed Systems (ICPADS), pages 651-658, Taiwan, December 2002.

[lowr04] M.C. Lowry. A New Approach to the Train Algorithm for Distributed Garbage Collection. PhD thesis, University of Adelaide, December 2004.

[lu16] Lu Lu, Xuanhua Shi, Yongluan Zhou, Xiong Zhang, Hai Jin, Cheng Pei, Ligang He, and Yuanzhen Geng. Lifetime-based memory management for distributed data processing systems. https://arxiv.org/abs/1602.01959, May 2016.

[limb97] Lucent Technologies Inc. The Limbo Programming Language, 1997. Available here.

[luk96] Chi-Keung Luk and Todd C. Mowry. Compiler-based prefetching for recursive data structures. In ASPLOS 1996 [ASPLOS96], 1996, pages 222-233. Available here.

[lyb12] Spyros Lyberis, Polyvios Pratikakis, Dimitrios S. Nikolopoulos, Martin Schulz, Todd Gamblin, and Bronis R. de Supinski. The Myrmics memory allocator: Hierarchical, message-passing allocation for global address spaces. In McKinley and Vechev [ISMM12], 2012, pages 15-24. Available here.

[lync90] N.A. Lynch. Multivalued possibilities mappings. Technical Memo MIT/LCS/TM-422, MIT Laboratory for Computer Science, August 1990. Available here.

[lyon88] G. Lyon. Tagless marking that is linear over subtrees. Information Processing Letters, 27(1):23-28, 1988.