[hadd67] B.K. Haddon and W.M. Waite. A compaction procedure for variable length storage elements. Computer Journal, 10:162-165, August 1967.
[haga96] Tom Hagan. Not just a stopgap. Information Week, January 1996.
[hagg01] Daniel Häggander, Per Lidén, and Lars Lundberg. A method for automatic optimization of dynamic memory management in C++. In ICPP 2001 [ICPP01], 2001. Available here.
[hagg98] Daniel Häggander and Lars Lundberg. Optimizing dynamic memory management in a multithreaded application executing on a multiprocessor. In ICPP 1998 [ICPP98], 1998. Available here.
[hagg99] Daniel Häggander and Lars Lundberg. Memory allocation prevented telecommunication application to be parallelized for better database utilization. In 6th International Australasian Conference on Parallel and Real-Time Systems (PART), Melbourne, November 1999. Available here.
[hagg00] Daniel Häggander and Lars Lundberg. Attacking the dynamic memory problem for SMPs. In 13th International Conference on Parallel and Distributed Computing System (PDCS), 2000.
[haib05] Bruno Haible. Weak datastructures. This talk at the European Common Lisp meeting o2 24 April 2005 explains the benefits and drawbacks of weak references. It generalizes the data types of weak pointer, weak list and weak hash-table. It explains how to implement these data types correctly and efficiently., April 2005. Available here.
[hall02] Niels Hallenberg, Martin Elsman, and Mads Tofte. Combining region inference and garbage collection. In PLDI 2002 [PLDI02], 2002, pages 141-152. Available here.
[hall96] Niels Hallenberg. A region profiler for a Standard ML compiler based on region inference. Student Project 96-5-7, Department of Computer Science (DIKU), University of Copenhagen, June 1996.
[hall99] N. Hallenberg. Combining garbage collection and region inference in the ML Kit. Master's thesis, Department of Computer Science (DIKU), University of Copenhagen, June 1999.
[halp84] Joseph Y. Halpern, Albert R. Meyer, and B.A. Trakhtenbrot. The semantics of local storage, or what makes the free-list free?. In POPL 1984 [POPL84], 1984, pages 245-257. Available here.
[hals78] Robert H. Halstead. Multiple-processor implementations of message passing systems. Technical Report TR-198, MIT Laboratory for Computer Science, April 1978.
[hals84] Robert H. Halstead. Implementation of Multilisp: Lisp on a multiprocessor. In Steele [LFP84], 1984, pages 9-17. Available here.
[hals85] Robert H. Halstead. Multilisp: A language for concurrent symbolic computation. ACM Transactions on Programming Languages and Systems, 7(4):501-538, October 1985. Available here.
[hama17] Shintaro Hamanaka, Shun Kurihara, Shoki Fukuda, Ryusuke Mori, Masato Oguchi, and Saneyasu Yamaguchi. Object lifetime trend of modern Android applications for GC performance improvement. In Proceedings of the 11th International Conference on Ubiquitous Information Management and Communication, page 6, Beppu, Japan, 2017. ACM Press. Available here.
[hami92] T. Hamid and M.K. Crowe. Garbage collection in large scale distributed object stores. In Objects in Large Distributed Applications (OLDA II) - OOPSLA'92, 1992.
[hami90a] G.W. Hamilton and Simon B. Jones. Compile-time garbage collection by necessity analysis. Technical Report 67, Department of Computer Science and Mathematics, University of Stirling, 1990.
[hami90] G.W. Hamilton and Simon B. Jones. Compile-time garbage collection by necessity analysis. In Peyton Jones et al. [glasgow90], 1991, pages 66-70.
[hami93] G.W. Hamilton. Compile-Time Optimisation of Store Usage in Lazy Funtional Programs. PhD thesis, University of Stirling, 1993.
[hami95] G.W. Hamilton. Compile-time garbage collection for lazy functional languages. In Baker [IWMM95], 1995, pages 119-144. Available here.
[hami97] Craig Hamilton. Measuring the performance of disk garbage collectors: Garbage collecting persistent Java stores. Master's thesis, University of Glasgow, 1997.
[hamm08] Matthew Hammer and Umut Acar. Memory management for self-adjusting computation. In Jones and Blackburn [ISMM08], 2008, pages 51-60. Available here.
[hamm94] Kevin Hammond, Geoff L. Burn, and D.B. Howe. Spiking your caches. Glasgow University, 1994.
[hamp03] Matthew Hampton. Using contaminated garbage collection and reference counting garbage collection to provide automatic reclamation for real-time systems. Master's thesis, Washington University, 2003. Available here.
[hamz10] H. Hamza and Steve Counsell. The impact of varying memory region numbers and nesting on RTSJ execution time. In Proceedings of the 3rd International Conference on Computer and Electrical Engineering (ICCEE 2010), 2010.
[hamz10a] H. Hamza and Steve Counsell. Improving the performance of scoped memory in RTSJ applications. In Proceedings of the 36th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA 2010), 2010.
[hamz11] H. Hamza and Steve Counsell. Using scoped memory in RTSJ applications: Dynamic analysis of memory consumption. In Proceedings of the 37th EUROMICRO Conference on Software Engineering and Advanced Applications, 2011.
[hamz13] H. Hamza and Steve Counsell. Exploiting slicing and patterns for RTSJ immortal memory optimization. In PPPJ 2013 [PPPJ13], 2013. Available here.
[han06a] Longzhe Han, Yeonseung Ryu, and Keunsoo Yim. CATA: A garbage collection scheme for flash memory file systems. In Ubiquitous Intelligence and Computing, volume 4159 of Lecture Notes in Computer Science. Springer-Verlag, 2006. Available here.
[hann95] J. Hannon. A type-based analysis for stack allocation in functional languages. In 2nd International Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science, pages 172-188. Springer, September 1995.
[hans02] Lars Thomas Hansen and William D. Clinger. An experimental study of renewal-older-first garbage collection. In ICFP 2002 [ICFP02], 2002, pages 247-258. Available here.
[hans69] Wilfred J. Hansen. Compact list representation: Definition, garbage collection, and system implementation. Communications of the ACM, 12(9):499-507, September 1969.
[hans92] Lars Thomas Hansen. The impact of programming style on the performance of Scheme programs. Master's thesis, University of Oregon, August 1992. Available here.
[hans00] Lars Thomas Hansen. Older-first Garbage Collection in Practice. PhD thesis, Northeastern University, November 2000.
[hans77] David R. Hanson. Storage management for an implementation of SNOBOL4. Software: Practice and Experience, 7(2):179-192, 1977. Available here.
[hans90] David R. Hanson. Fast allocation and deallocation of memory based on object lifetimes. Software: Practice and Experience, 20(1):5-12, January 1990.
[hao11] Wu Hao and Ji Zhen-Zhou. Design and evaluation of an efficient semispace-based memory reclamation scheme. In 2011 First International Conference on Instrumentation, Measurement, Computer, Communication and Control, pages 212-215, 2011. Available here.
[harl87] David M. Harland and Brune Beloff. OBJEKT - a persistent object store with an integrated garbage collector. ACM SIGPLAN Notices, 22(4):70-79, 1987.
[harm89] Douglas E. Harms. Efficient initialization and finalization of data structures: Why and how. Technical Report OSU-CISRC-3/89-TR11, Ohio State University, Computer and Information Science Research Center, February 1989.
[harr02] Timothy L. Harris, Keir Fraser, and Ian A. Pratt. A practical multi-word compare-and-swap operation. In Dahlia Malkhi, editor, International Conference on Distributed Computing, volume 2508 of Lecture Notes in Computer Science, pages 265-279, Toulouse, France, October 2002. Available here.
[harr03] Tim Harris and Keir Fraser. Language support for lightweight transactions. In OOPSLA 2003 [OOPSLA03], 2003, pages 388-402. Available here.
[harr98] Warren Harris. Applet lifecycle in Netscape Communicator. Technical Report TN-JAVA-05-9707, Netscape Communications Corporation, 1998.
[harr98a] Warren Harris. The design and implementation of the Sport Model garbage collector. Technical report, Netscape Communications Corporation, January 19 1998.
[harr99] Timothy Harris. Early storage reclamation in a tracing garbage collector. ACM SIGPLAN Notices, 34(4):46-53, April 1999. Available here.
[harr00] Timothy Harris. Dynamic adaptive pre-tenuring. In Chambers and Hosking [ISMM2000], 2000, pages 127-136. Available here.
[harr06] Tim Harris. Leaky regions: Linking reclamation hints to program structure. Technical Report MSR-TR-2006-84, Microsoft Research, June 2006. Available here.
[hart07] Thomas E. Hart, Paul E. McKenney, Angela Demke Brown, and Jonathan Walpole. Performance of memory reclamation for lockless synchronization. Journal of Parallel Distributed Computing, 67(12):1270-1285, 2007. Available here.
[hart64] Timothy P. Hart and Thomas G. Evans. Notes on implementing LISP for the M-460 computer. In Berkeley and Bobrow [berk74], 1974, pages 191-203. Available here.
[hart94] Pieter H. Hartel, Marc Feeley, Martin Alt, Lennart Augustsson, Peter Baumann, Marcel Beemster, Emmanuel Chailloux, Christine H. Flood, Wolfgang Grieskamp, John H.G. van Groningen, Kevin Hammond, Bogumil Hausman, Melody Y. Ivory, Peter Lee, Xavier Leroy, Sandra Loosemore, Niklas Röjemo, Manuel Serrano, Jean-Pierre Talpin, Jon Thackray, Pierre Weis, and Peter Wentworth. Pseudoknot: A float-intensive benchmark for functional compilers. In J.R.W. Glauert, editor, 6th Implementation of Functional Languages, pages 13.1-13.34. School of Information Systems, University of East Anglia, Norwich, UK, September 1994. Available here.
[hart96] Pieter H. Hartel, Marc Feeley, Martin Alt, Lennart Augustsson, Peter Baumann, Marcel Beemster, Emmanuel Chailloux, Christine H. Flood, Wolfgang Grieskamp, John H.G. van Groningen, Kevin Hammond, Bogumil Hausman, Melody Y. Ivory, Richard Jones, Peter Lee, Xavier Leroy, Rafael Lins, Sandra Loosemore, Niklas Röjemo, Manuel Serrano, Jean-Pierre Talpin, Jon Thackray, Stephen P. Thomas, Pierre Weis, and Peter Wentworth. Benchmarking implementations of functional languages with `Pseudoknot', a float-intensive benchmark. Journal of Functional Programming, 6(4), 1996.
[hart88] Pieter H. Hartel. Performance Analysis of Storage Management in Combinator Graph Reduction. PhD thesis, Department of Computer Systems, University of Amsterdam, Amsterdam, 1988.
[hart90] Pieter H. Hartel. A comparison of 3 garbage collection algorithms. Structured Programming, 11(3):117-127, 1990.
[hasa03] Yusuf Hasan and J. Morris Chang. A hybrid allocator. In ISPASS 2003 [ISPASS03], 2003.
[hass16] Wessam Hassanein. Understanding and improving JVM GC work stealing at the data center scale. In Zhang and Flood [ISMM16], 2016, pages 46-54. Available here.
[hast92] Reed Hastings and Bob Joyce. Fast detection of memory leaks and access errors. In Winter USENIX Conference, pages 125-136. USENIX Association, 1992. Available here.
[hat] Sun Microsystems. Java Heap Analysis Tool (HAT). http://java.sun.com/people/billf/heap/. Available here.
[hatt87] A. Hattori, H. Masuzawa, and H. Hayashi. AI machine. Fujitsu Scientific and Technical Journal, 23(4):369-378, 1987.
[haug99] Scott Haug. Automatic storage optimization via garbage collection. Master's thesis, Washington University, St Louis, 1999.
[chil04] Mattias Hauswirth and Trishul M. Chilimbi. Low-overhead memory leak detection using adaptive statistical profiling. In Mukherjee and McKinley [ASPLOS04], 2004, pages 156-164. Available here.
[have97] Klaus Havelund and Natarajan Shankar. A mechanized refinement proof for a garbage collector. Technical report, Aalborg University, 1997. Submitted to Formal Aspects of Computing. Available here.
[have99] Klaus Havelund. Mechanical verification of a garbage collector. In Parallel and Distributed Processing, volume 1586 of Lecture Notes in Computer Science, pages 1258-1283, San Juan, Puerto Rico, April 1999. 11th IPPS/SPDP'99 Workshops held in conjunction with the 13th International Parallel Processing Symposium and 10th Symposium on Parallel and Distributed Processing. Available here.
[hawb04] Chris Hawblitzel, Edward Wei, Heng Huang, Eric Krupski, and Lea Wittie. Low-level linear memory management. In SPACE 2004 [SPACE04], 2004.
[hawb07] Chris Hawblitzel, Heng Huang, Lea Wittie, and Juan Chen. A garbage-collecting typed assembly language. In ACM SIGPLAN Workshop on Types in Language Design and Implementation, Nice, France, January 2007. Available here.
[hawb15] Chris Hawblitzel, , Shaz Qadeer, and Serdar Tasiran. Automated and modular refinement reasoning for concurrent programs. In Computer Aided Verification (CAV'15), volume 9207 of Lecture Notes in Computer Science. Springer-Verlag, July 2015. Available here.
[hawb09] Chris Hawblitzel and Erez Petrank. Automated verification of practical garbage collectors. In POPL 2009 [POPL09], 2009, pages 441-453. Available here.
[hawb06] Chris Hawblitzel. Linear types for aliased resources. In SPACE 2006 [SPACE06], 2006, pages 105-107. Available here.
[haya] H. Hayashi, A. Hattori, and H. Akimoto. ALPHA: High-performance Lisp machine equipped with a new stack structure and real-time garbage collection system. Draft report, Fujitsu Laboratories.
[haye90] Barry Hayes. Open systems require conservative garbage collectors. In Jul and Juul [OOPSLA90-gc], 1990. Available here.
[haye91] Barry Hayes. Using key object opportunism to collect old objects. In OOPSLA 1991 [OOPSLA91], 1991, pages 33-46. Available here.
[haye92] Barry Hayes. Finalization in the collector interface. In Bekkers and Cohen [IWMM92], 1992, pages 277-298. Available here.
[haye93] Barry Hayes. Key Objects in Garbage Collection. PhD thesis, Stanford University, March 1993.
[haye97] Barry Hayes. Ephemerons: A new finalization mechanism. In OOPSLA 1997 [OOPSLA97], 1997, pages 176-183. Available here.
[haze09] Kim Hazelwood, Greg Lueck, and Robert Cohn. Scalable support for multithreaded applications on dynamic binary instrumentation systems. In Kolodner and Steele [ISMM09], 2009, pages 20-29. Available here.
[heck92] Brian C. Heck and David S. Wise. An implementation of an applicative file system. In Bekkers and Cohen [IWMM92], 1992, pages 248-263. Available here.
[hede88] Lucy Hederman. Compile-time garbage collection using reference count analysis. Master's thesis, Rice University, August 1988. Also Rice University Technical Report TR88-75 but, according to Rice University's technical report list, this report is no longer available for distribution. Available here.
[heeb91] Beat Heeb and Cuno Pfister. Oberon technical notes: An integrated heap allocator/garbage collector. ETH Technical Report 156, ETHZ, March 1991.
[heil00] Timothy Heil and James E. Smith. Concurrent garbage collection using hardware assisted profiling. In Chambers and Hosking [ISMM2000], 2000, pages 80-93. Available here.
[hein01] Nevin Heintze and Olivier Tardieu. Demand-driven pointer analysis. In PLDI 2001 [PLDI01], 2001, pages 24-34. Available here.
[hein01a] Nevin Heintze and Olivier Tardieu. Ultra-fast aliasing analysis using CLA: A million lines of C code in a second. In PLDI 2001 [PLDI01], 2001, pages 254-263. Available here.
[hell10] Laurence Hellyer, Richard Jones, and Antony L. Hosking. The locality of concurrent write barriers. In Vitek and Lea [ISMM10], 2010, pages 83-92. Available here.
[hels01] Simon Helsen. Syntactic type soundness for the imperative region calculus. In SPACE 2001 [SPACE01], 2001. Available here.
[hend95] Fergus Henderson, Thomas Conway, and Zoltan Somogyi. Compiling logic programs to C using GNU C as a portable assembler. In ILPS'95 Post-conference Workshop on Sequential Implementation Technologies for Logic Programming, pages 1-15, Portland, Or, 1995. Available here.
[hend02] Fergus Henderson. Accurate garbage collection in an uncooperative environment. In Boehm and Detlefs [ISMM02], 2002, pages 150-156. Available here.
[hend90] Laurie J. Hendren. Parallelizing Programs with Recursive Data Structures. PhD thesis, Cornell University, April 1990.
[heng88] Seng-Lai Heng. Performance evaluation of numerous garbage collections by real-time simulation. Master's thesis, University of Texasat Austin, 1988.
[heng01] Fritz Henglein, Henning Makholm, and H. Niss. A direct approach to control-flow sensitive region-based memory management. In International Conference on Principles and Practice of Declarative Programming (PPDP), pages 175-186, 2001.
[henn93] Wade Hennessey. Real-time garbage collection in a multimedia programming language. In Moss et al. [OOPSLA93-gc], 1993. Available here.
[henn96] John L. Hennessy and David A. Patterson. Computer Architecture: A Quantitative Approach. Morgan Kaufman, second edition, 1996.
[henni98] Michi Henning. Binding, migration and scalability in CORBA. Communications of the ACM, 41(10):62-71, October 1998.
[henr94] Roger Henriksson. Scheduling real-time garbage collection. In Proceedings of NWPER'94, Lund, Sweden, 1994. Available here.
[henr96a] Roger Henriksson. Adaptive scheduling of incremental copying garbage collection for interactive applications. Technical Report 96-174, Lund University, Sweden, 1996. Available here.
[henr96] Roger Henriksson. Scheduling real-time garbage collection. Licentiate thesis, Department of Computer Science, Lund University, 1996. Lund technical report LU-CS-TR:96-161 (abstract only). Available here.
[henr97] Roger Henriksson. Predictable automatic memory management for embedded systems. In Dickman and Wilson [OOPSLA97-gc], 1997. Available here.
[henr98] Roger Henriksson. Scheduling Garbage Collection in Embedded Systems. PhD thesis, Lund Institute of Technology, July 1998. Available here.
[herh10] Stephan Herhut, Carl Joslin, Sven-Bodo Scholz, Raphael Poss, and Clemens Grelck. Concurrent non-deferred reference counting on the Microgrid: First experiences. In Haage and Morazán [IFL10], 2011, pages 185-202. Revised Selected Papers. Available here.
[herl02] Maurice P. Herlihy, Victor Luchangco, and Mark Moir. The repeat offender problem: A mechanism for supporting dynamic-sized lock-free data structures. In 16th International Symposium on Distributed Computing, volume 2508 of Lecture Notes in Computer Science, pages 339-353, Toulouse, France, October 2002. Springer-Verlag. Available here.
[herl02a] Maurice P. Herlihy, Paul Martin, Victor Luchangco, and Mark Moir. Dynamic-sized and lock-free data structures. Technical Report TR-2002-110, Sun Microsystems Laboratories, June 2002. Available here.
[herl90] Maurice Herlihy and J. Eliot B Moss. Non-blocking garbage collection for multiprocessors. Technical Report CRL 90/9, DEC Cambridge Research Laboratory, 1990.
[moss91] Maurice P. Herlihy and J. Eliot B. Moss. Lock-free garbage collection for multiprocessors. In Parallel Algorithms and Architectures, pages 229-236. ACM Press, July 1991.
[herl92] Maurice Herlihy and J. Eliot B Moss. Lock-free garbage collection for multiprocessors. IEEE Transactions on Parallel and Distributed Systems, 3(3):304-311, May 1992. Available here.
[herl93] Maurice P. Herlihy and J. Eliot B. Moss. Transactional memory: Architectural support for lock-free data structures. In ISCA 1993 [ISCA93], 1993, pages 289-300. Available here.
[herl08] Maurice Herlihy and Nir Shavit. The Art of Multiprocessor Programming. Morgan Kaufman, April 2008.
[herl90a] Maurice Herlihy and Jeannette M. Wing. Linearizability: A correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems, 12(3):463-492, 1990. Available here.
[hert02] Matthew Hertz, Steve M. Blackburn, K.S. McKinley, J. Eliot B. Moss, and Darko Stefanović. Error-free garbage collection traces: How to cheat and not get caught. In ACM SIGMETRICS International Conference on Measurement and Modeling of Computer Systems, Marina Del Rey, CA, June 2002. Available here.
[hert02a] Matthew Hertz, N. Immerman, and J. Eliot B. Moss. Framework for analyzing garbage collection. In 2nd IFIP Theoretical Computer Science Congress, pages 230-242. Springer-Verlag, 2002. Available here.
[hert04] Matthew Hertz, Yi Feng, and Emery Berger. Page-level cooperative garbage collection. Technical Report CS TR-04-16, University of Massachusetts, 2004. Available here.
[hert05] Matthew Hertz, Yi Feng, and Emery D. Berger. Garbage collection without paging. In Sarkar and Hall [PLDI05], 2005, pages 143-153. Available here.
[hert06] Matthew Hertz, Stephen M. Blackburn, J. Eliot B. Moss, Kathryn McKinley, and Darko Stefanović. Generating object lifetime traces with Merlin. ACM Transactions on Programming Languages and Systems, 28(3):476-516, May 2006. Available here.
[hert09] Matthew Hertz, Jonathan Bard, Stephen Kane, Elizabeth Keudel, Tongxin Bai, Kirk Kelsey, and Chen Ding. Waste not, want not - resource-based garbage collection in a shared environment. Technical Report TR-951, The University of Rochester, December 2009. Available here.
[hert11] Matthew Hertz, Stephen Kane, Elizabeth Keudel, Tongxin Bai, Chen Ding, Xiaoming Gu, and Jonathan E. Bard. Waste not, want not: Resource-based garbage collection in a shared environment. In Boehm and Bacon [ISMM11], 2011, pages 65-76. Available here.
[hert04a] Matthew Hertz and Emery Berger. Automatic vs. explicit memory management: Settling the performance debate. Technical Report CS TR-04-17, University of Massachusetts, 2004. Available here.
[hert05a] Matthew Hertz and Emery Berger. Quantifying the performance of garbage collection vs.\ explicit memory management. In OOPSLA 2005 [OOPSLA05], 2005, pages 313-326. Available here.
[hert06b] Matthew Hertz. Quantifying and Improving the Performance of Garbage Collection. PhD thesis, University of Massachusetts, September 2006. Available here.
[hess01] Wim H. Hesselink and Jan Friso Groote. Wait-free concurrent memory management by create and read until deletion (CaRuD). Distributed Computing, 14(1):31-39, 2001.
[hess10] Wim H. Hesselink and M.I. Lali. Simple concurrent garbage collection almost without synchronization. Formal Methods of System Design, 36(2):148-166, 2010. Available here.
[hewi77] Carl Hewitt. Viewing control structures as patterns of passing messages. Journal of Artificial Intelligence, 8(3):323-364, June 1977.
[heym91] J. Heymann. A comprehensive analytical model for garbage collection algorithms. ACM SIGPLAN Notices, 26(8):50-59, 1991.
[hibi80] Y. Hibino. A practical parallel garbage collection algorithm and its implementation. In ISCA 1980 [ISCA80], 1980, pages 113-120.
[hick84] Tim Hickey and Jacques Cohen. Performance analysis of on-the-fly garbage collection. Communications of the ACM, 27(11):1143-1154, November 1984.
[hick97] Michael W. Hicks, Jonathan T. Moore, and Scott M. Nettles. The measured cost of copying garbage collection mechanisms. In ICFP 1997 [ICFP97], 1997, pages 292-305. Available here.
[hick98] Michael Hicks, Luke Hornof, Jonathan T. Moore, and Scott Nettles. A study of Large Object Spaces. In Peyton~Jones and Jones [ISMM98], 1998, pages 138-145. Available here.
[hick04] Michael Hicks, Dan Grossman, and Trevor Jim. Combining garbage collection and safe manual memory management. In SPACE 2004 [SPACE04], 2004.
[hick04a] Michael Hicks, Greg Morrisett, Dan Grossman, and Trevor Jim. Experience with safe manual memory-management in Cyclone. In Bacon and Diwan [ISMM04], 2004, pages 73-84. Available here.
[hick93] James Hicks. Experiences with compiler-directed storage reclamation. In Hughes [FPCA93], 1993. Available here.
[hieb90] R. Hieb, R.K. Dybvig, and C. Bruggeman. Representing control in the presence of first-class continuations. ACM SIGPLAN Notices, 25(6):66-77, 1990.
[hiep91] Van Nguyen Hiep. Compilation et Environment d'Execution d'un Langage à; Base d'Objects. PhD thesis, Institut National Polytechnique de Grenoble, February 1991.
[higu02] Maria Teresa Higuera, Valerie Issarny, Michel Banatre, Gilbert Cabillic, Jean-Philippe Lesot, and Frederic Parain. Memory management for real-time Java: an efficient solution using hardware support. Real-Time Systems Journal, 2002. Available here.
[higu05] M. Teresa Higuera and Valerie Issarny. Improving the memory management performance of RTSJ. Concurrency and Computation: Practice and Experience, 17(5-6), 2005. Available here.
[higu04] M. Teresa Higuera-Toledano, Valerie Issarny, Michel Banatre, Gilbert Cabillic, Jean-Philippe Lesot, and Frederic Parain. Memory management for real-time Java: an efficient solution using hardware support. Real-Time Systems Journal, 26(1):63-87, 2004. Available here.
[higu01a] Maria Teresa Higuera Toledano and Valerie Issarny. Analyzing the performance of memory management in RTSJ. In ISORC 2001 [ISORC01], 2001. Available here.
[higu02a] Maria Teresa Higuera Toledano. Solutions à; la Gestion Mémoire pour Systè;mes Java Temps Réel. PhD thesis, L'Université de Rennes, 2002. Available here.
[higu06a] M. Teresa Higuera-Toledano. Analyzing the memory management semantic and requirements of the Real-Time specification of Java JSR-0000001. In ISORC 2006 [ISORC06], 2006, pages 419-423. Available here.
[higu06] M. Teresa Higuera-Toledano. Towards an analysis of garbage collection techniques for embedded real-time Java systems. In 12th international Conference on Embedded and Real-Time Computing Systems and Applications, pages 97-100. IEEE Press, 2006. Available here.
[higu06b] Maria Teresa Higuera Toledano. The indeterministic behaviour of scoped memory in Real-Time Java. In 4th ACS/IEEE International Conference on Computer Systems and Applications (AICCSA-06), pages 656-664. IEEE Press, 2006. Available here.
[higu07a] Maria Teresa Higuera Toledano. Allowing cycles references among scoped memory areas in the Real-Time Specification for Java. In ISORC 2007 [ISORC07], 2007, pages 110-114. Available here.
[higu07] Maria Teresa Higuera Toledano. Name-based write barriers in real-time Java. In IEEE international Conference on Computer and Information Technology (CIT-07), pages 781-786. IEEE Press, 2007. Available here.
[higu08] Maria Teresa Higuera Toledano. Allowing cycle references by introducing controlled violations of the assignment rules in real-time Java. In ISORC 2008 [ISORC08], 2008, pages 463-467. Available here.
[higu11] Maria Teresa Higuera Toledano. Using transactional memory to synchronize an adaptive garbage collector in real-time Java. In 14th IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing Workshops, pages 152-161, Newport Beach, CA, March 2011. Available here.
[higu14] Maria Teresa Higuera Toledano. Building the Java heap with bricks in an embedded real-time environment. In Proceedings of the 2014 IEEE/ACM 18th International Symposium on Distributed Simulation and Real Time Applications (DS-RT'14), pages 57-66. IEEE Computer Society Press, 2014. Available here.
[higu03] Maria Teresa Higuera. Memory management design to the concurrent execution of RTSJ applications. In JTRES 2003 [JTRES03], 2003, pages 479-489. Available here.
[hill89] Mark D. Hill and Alan Jay Smith. Evaluating associativity in CPU caches. IEEE Transactions on Computers, 38(12):1612-1629, December 1989.
[hill87] Mark D. Hill. Aspects of Cache Memory and Instruction Buffer Performance. PhD thesis, University of California, Berkeley, November 1987. Also UCB/CSD Technical report 87/381.
[hill88] Mark D. Hill. A case for direct-mapped caches. IEEE Computer, 21(12):25-40, December 1988.
[hind01] Michael Hind. Pointer analysis: Haven't we solved this problem yet?. In PASTE 2001 [PASTE01], 2001, pages 54-61. Available here.
[hind75] J.A. Hinds. An algorithm for locating adjacent storage blocks in the buddy system. Communications of the ACM, 18(4):221-222, April 1975.
[hirs73] D.S. Hirschberg. A class of dynamic memory allocation algorithms. Communications of the ACM, 16(10):615-618, October 1973. Available here.
[hirz01] Martin Hirzel, Amer Diwan, and Antony L. Hosking. On the usefulness of liveness for garbage collection and leak detection. In Knudsen [ECOOP01], 2001. Available here.
[hirz02a] Martin Hirzel, Amer Diwan, and Johannes Henkel. On the usefulness of type and liveness for garbage collection and leak detection. ACM Transactions on Programming Languages and Systems, 24(6):593-624, November 2002.
[hirz02] Martin Hirzel, Johannes Henkel, Amer Diwan, and Michael Hind. Understanding the connectivity of heap objects. In Boehm and Detlefs [ISMM02], 2002, pages 36-49. Available here.
[hirz03] Martin Hirzel, Amer Diwan, and Matthew Hertz. Connectivity-based garbage collection. In OOPSLA 2003 [OOPSLA03], 2003, pages 359-373. Available here.
[hirz03a] Martin Hirzel, Harold N. Gabow, and Amer Diwan. Choosing a set of partitions to collect in a connectivity-based garbage collector. Technical Report CU-CS-958-03, University of Colorado, August 2003. Available here.
[hirz04] Martin Hirzel, Amer Diwan, and Michael Hind. Pointer analysis in the presence of dynamic class loading. In Odersky [ECOOP04], 2004. Available here.
[hirz07a] Martin Hirzel, Daniel von Dincklage, Amer Diwan, and Michael Hind. Fast online pointer analysis. ACM Transactions on Programming Languages and Systems, April 2007. Available here.
[hirz00] Martin Hirzel and Amer Diwan. On the type accuracy of garbage collection. In Chambers and Hosking [ISMM2000], 2000, pages 1-11. Available here.
[hirz00a] Martin Hirzel. Effectiveness of garbage collection and explicit deallocation. Master's thesis, University of Colorado, 2000. Available here.
[hirz04a] Martin Hirzel. Connectivity-Based Garbage Collection. PhD thesis, University of Colorado at Boulder, July 2004. Available here.
[hirz07] Martin Hirzel. Data layouts for object-oriented programs. In ACM SIGMETRICS International Conference on Measurement and Modeling of Computer Systems, June 2007. This paper plus a 2-page appendix is available as IBM Research Report RC24218, Watson. Available here.
[hoar69] C.A.R. Hoare. An axiomatic basis for computer programming. Communications of the ACM, 12, October 1969.
[hoar74] C.A.R. Hoare. Optimisation of store size for garbage collection. Information Processing Letters, 2(6):165-166, April 1974.
[hoar09] C.A.R. Hoare. Null references: The billion dollar mistake. In Proceedings of QCon, Historically Bad Ideas, London, UK, March 2009.
[hofm03] Martin Hofman and Steffen Jost. Static prediction of heap usage for first-order functional programs. In POPL 2003 [POPL03], 2003. Available here.
[hofm01] Martin Hofmann. A type system for controlling heap space and its translation to JavaCard. In SPACE 2001 [SPACE01], 2001. Available here.
[hoge93] Guido Hogen and Rita Loogen. A new stack technique for the management of runtime structures in distributed implementations. {Aachener Informatik-Berichte 93-3, RWTH Aachen, Ahornstr. 55, 52056 Aachen, Germany, 1993. Available here.
[hoge94] Guido Hogen and Rita Loogen. Efficient organization of control structures in distributed implementations. In Peter A. Fritzson, editor, Compiler Construction, volume 786 of Lecture Notes in Computer Science, pages 98-112. Springer-Verlag, 1994.
[hoge94a] Guido Hogen and Rita Loogen. Parallel functional implementations: Graphbased vs. stackbased reductions. Technical report, RWTH Aachen, ghogen@zesu.informatik.rwth-aachen.de, lllgen@informatik.uni-marburg.de, 1994.
[holl15] J. Hollmann, R. Titos-Gil, and P. Stenstrom. Enhancing garbage collection synchronization using explicit bit barriers. In ICPP 2015 [ICPP15], 2015, pages 769-778. Available here.
[holl80] Jack Holloway, Guy L. Steele, Gerald Jay Sussman, and Alan Bell. The SCHEME-79 chip. AI Memo 559, MIT AI Laboratory, January 1980.
[holm83] S. Holmström. A simple and efficient way to handle large datastructures in applicative languages. In Joint SERC/Chalmers Workshop on Declarative Programming, University College, London, 1983.
[holt61] Anatol W. Holt. Program organization and record keeping for dynamic storage allocaton. Communications of the ACM, 4(10), October 1961.
[holz95] Urs Hölzle and David Ungar. Do object-oriented languages need special hardware support?. In Nierstrasz [ECOOP95], 1995. Available here.
[holz91] Urs Hölzle. The myth of high object creation rates. In Wilson and Hayes [OOPSLA91-gc], 1991. Available here.
[holz93] Urs Hölzle. A fast write barrier for generational garbage collectors. In Moss et al. [OOPSLA93-gc], 1993. Available here.
[hori18] Michihiro Horie, Hiroshi Horii, Kazunori Ogata, and Tamiya Onodera. Balanced double queues for GC work-stealing on weak memory models. In Payer and Sartor [ISMM18], 2018, pages 109-119. Available here.
[hori19] Michihiro Horie, Kazunori Ogata, Mikio Takeuchi, and Hiroshi Horii. Scaling up parallel GC work-stealing in many-core environments. In Xu and Singer [ISMM19], 2019, pages 27-40. Available here.
[horo77] E. Horowitz and S. Sahni. Fundamentals of Data Structures. Computer Science Press, Woodland Hills, CA, 1977.
[hors87] R. Nigel Horspool and Ronald M. Huberman. Analysis and development of demand prepaging policies. Journal of Systems and Software, 7:183-194, 1987.
[horw89] Susan Horwitz, Phil Pfeiffer, and Thomas W. Reps. Dependence analysis for pointer variables. In PLDI 1989 [PLDI89], 1989, pages 28-40. Available here.
[hose21] Morteza Hoseinzadeh and Steven Swanson. Corundum: statically-enforced persistent memory safety. In Sherwood et al. [ASPLOS21], 2021, pages 429-442. {ASPLOS 2021 was a virtual event. Available here.
[hosk92] Antony L. Hosking, J. Eliot B. Moss, and Darko Stefanović. A comparative performance evaluation of write barrier implementations. In OOPSLA 1992 [OOPSLA92], 1992, pages 92-109. Available here.
[hosk98] Antony L. Hosking, Nathaniel Nystrom, Quintin Cutts, and Kumar Brahnmath. Optimizing the read and write barrier for orthogonal persistence. In Morrison et al. [POS98], 1999, pages 149-159. Available here.
[MSPC06] Antony L. Hosking and Ali-Reza Adl-Tabatabai, editors. Workshop on Memory System Performance and Correctness, San Jose, CA, October 2006. Available here.
[hosk99] Antony L. Hosking and Jiawan Chen. Mostly-copying reachability-based orthogonal persistence. In OOPSLA 1999 [OOPSLA99], 1999, pages 382-398. Available here.
[hosk99b] Antony L. Hosking and Jiawan Chen. PM3: An orthogonally persistent systems programming language. In International Conference on Very Large Data Bases, pages 587-598, Edinburgh, Scotland, September 1999. Available here.
[hosk93] Antony L. Hosking and Richard L. Hudson. Remembered sets can also play cards. In Moss et al. [OOPSLA93-gc], 1993. Available here.
[hosk93a] Antony L. Hosking and J. Eliot B. Moss. Object fault handling for persistent programming languages: A performance evaluation. In OOPSLA 1993 [OOPSLA93], 1993. Available here.
[hosk93b] Antony L. Hosking and J. Eliot B. Moss. Protection traps and alternatives for memory management of an object-oriented language. In SOSP 1993 [SOSP93], 1993, pages 106-119. Available here.
[hosk95] Antony L. Hosking and J. Eliot B. Moss. Lightweight write detection and checkpointing for fine-grained persistence. Technical Report 95-084, Purdue University, 1995.
[hosk97] Antony L. Hosking and Aria P. Novianto. Reachability-based orthogonal persistence for C, C++ and other intransigents. In Dickman and Wilson [OOPSLA97-gc], 1997. Available here.
[hosk91] Antony L. Hosking. Main memory management for persistence. In Wilson and Hayes [OOPSLA91-gc], 1991. Available here.
[hosk06] Antony L Hosking. Portable, mostly-concurrent, mostly-copying garbage collection for multi-processors. In Petrank and Moss [ISMM06], 2006, pages 40-51. Available here.
[hoso98] Haruo Hosoya and Akinori Yonezawa. Garbage collection via dynamic type inference - a formal treatment. In 2nd Workshop on Types in Compilation, volume 1473 of Lecture Notes in Computer Science, pages 215-239, 1998. Available here.
[hsie97] Cheng-Hsueh A. Hsieh, Marie T. Conte, Teresa L. Johnson, John C. Gyllenhaal, and Wen-mei W. Hwu. Compilers for improved Java performance. Computer, 30:67-75, June 1997. Available here.
[hu03] Y. Charlie Hu, Weimin Yu, Alan Cox, Dan Wallach, and Willy Zwaenepoel. Run-time support for distributed sharing in safe languages. ACM Transactions on Computer Systems, 21:1-35, February 2003. Available here.
[huan03] Xianlong Huang, J. Eliot B. Moss, Kathryn S. McKinley, Stephen M. Blackburn, and D. Burger. Dynamic SimpleScalar: Simulating Java virtual machines. Technical Report TR-03-03, University of Texas at Austin, February 2003.
[huan04b] Wei Huang, Y. Qian, Witiwas Srisa-an, and J. Morris Chang. Object allocation and memory contention study of Java multithreaded application. In IEEE International Performance Computing and Communications Conference (IPCCC), Phoenix, AZ, April 2004.
[huan04a] Wei Huang, Witiwas Srisa-an, and J. Morris Chang. Adaptive pretenuring for generational garbage collection. In ISPASS 2004 [ISPASS04], 2004, pages 133-140.
[huan04] Xianlong Huang, Stephen M. Blackburn, Kathryn S. McKinley, J. Eliot B. Moss, Z. Wang, and Perry Cheng. The garbage collection advantage: Improving program locality. In OOPSLA 2004 [OOPSLA04], 2004, pages 69-80. Available here.
[huan06] Xianglong Huang, Stephen M Blackburn, David Grove, and Kathryn S McKinley. Fast and efficient partial code reordering: Taking advantage of dynamic recompilation. In Petrank and Moss [ISMM06], 2006, pages 184-192. Available here.
[huan23] Claire Huang, Stephen M. Blackburn, and Zixian Cai. Improving garbage collection observability with performance tracing. In Moss [MPLR23], 2023.
[huan13] Jipeng Huang and Michael D. Bond. Efficient context sensitivity for dynamic analyses via calling context uptrees and customized memory management. In OOPSLA 2013 [OOPSLA13], 2013, pages 53-72. Available here.
[huda92] Paul Hudak, Simon L. Peyton Jones, and Phillip Wadler. Report on the programming language Haskell, a non-strict purely functional language (version 1.2). ACM SIGPLAN Notices, 27(5), May 1992.
[huda84] Paul Hudak and Adrienne Bloss. The aggregate update problem in functional programming systems. In POPL 1984 [POPL84], 1985, pages 300-314. Available here.
[huda82] Paul R. Hudak and R.M. Keller. Garbage collection and task deletion in distributed applicative processing systems. In LFP 1982 [LFP82], 1982, pages 168-178. Available here.
[huda81] Paul R. Hudak. Call-graph reclamation: an alternative storage reclamation scheme. {AMPS Technical Memorandum 4, University of Utah, August 1981.
[huda82a] Paul R. Hudak. Object and Task Reclamation in Distributed Applicative Processing Systems. PhD thesis, University of Utah, Salt Lake City, Utah, 1982.
[huda83] Paul R. Hudak. Distributed graph marking. Departmental Research Report 268, University of Yale, 1983.
[huda83a] Paul R. Hudak. Distributed task and memory management. In PODC 1983 [PODC83], 1983, pages 277-89.
[huda86] Paul R. Hudak. A semantic model of reference counting and its abstraction (detailed summary). In LFP 1986 [LFP86], 1986, pages 351-363. Available here.
[huda87] Paul R. Hudak. A semantic model of reference counting and its abstraction. In Samson Abramsky and Chris Hankin, editors, Abstract Interpretation of Declarative Languages, pages 45-62. Ellis Horward, 1987.
[huds91] Richard L. Hudson, J. Eliot B. Moss, Amer Diwan, and Christopher F. Weight. A language-independent garbage collector toolkit. Technical Report COINS 91-47, University of Massachusetts, September 1991. Available here.
[huds97] Richard L. Hudson, Ron Morrison, J. Eliot B. Moss, and David S. Munro. Garbage collecting the world: One car at a time. In OOPSLA 1997 [OOPSLA97], 1997. Available here.
[huds97a] Richard L. Hudson, Ron Morrison, J. Eliot B. Moss, and David S. Munro. Training distributed garbage: The DMOS collector. Technical report, University of St Andrews, 1997. Available here.
[huds98] Richard L. Hudson, Ron Morrison, J. Eliot B. Moss, and David S. Munro. Where have all the pointers gone?. In 21st Australasian Computer Science Conference (ACSC), pages 107-119, Perth, 1998. Available here.
[huds00] Richard L. Hudson, J. Eliot B. Moss, Sreenivas Subramoney, and Weldon Washburn. Cycles to recycle: Garbage collection on the IA-64. In Chambers and Hosking [ISMM2000], 2000, pages 101-110. Available here.
[huds06] Richard L. Hudson, Bratin Saha, Ali-Reza Adl-Tabatabai, and Benjamin Hertzberg. McRT-malloc - a scalable transactional memory allocator. In Petrank and Moss [ISMM06], 2006, pages 74-83. Available here.
[huds90] Richard L. Hudson and Amer Diwan. Adaptive garbage collection for Modula-3 and Smalltalk. In Jul and Juul [OOPSLA90-gc], 1990. Available here.
[huds92a] S. Hudson and J.M. Hannah. Structured knowledge manipulation system for real-time engineering applications. IEE Proceedings, Part E: Computers and Digital Techniques, 139(1):59-63, January 1992.
[huds92] Richard L. Hudson and J. Eliot B. Moss. Incremental collection of mature objects. In Bekkers and Cohen [IWMM92], 1992, pages 388-403. Available here.
[huds01] Richard L. Hudson and J. Eliot B. Moss. Sapphire: Copying GC without stopping the world. In Joint ACM-ISCOPE Conference on Java Grande, pages 48-57, Palo Alto, CA, June 2001. ACM Press. Available here.
[huds03] Richard L. Hudson and J. Eliot B. Moss. Sapphire: Copying garbage collection without stopping the world. Concurrency and Computation: Practice and Experience, 15(3-5):223-261, 2003. Available here.
[huds91a] Richard L. Hudson. Finalization in a garbage collected world. In Wilson and Hayes [OOPSLA91-gc], 1991. Available here.
[huel93] Lorenz Huelsbergen and James R. Larus. A concurrent copying garbage collector for languages that distinguish (im)mutable data. In PPOPP 1993 [PPoPP93], 1993, pages 73-82.
[huel98] Lorenz Huelsbergen and Phil Winterbottom. Very concurrent mark-&-sweep garbage collection without fine-grain synchronization. In Peyton~Jones and Jones [ISMM98], 1998, pages 166-175. Available here.
[hugh82a] R. John M. Hughes. A semi-incremental garbage collection algorithm. Software: Practice and Experience, 12(11):1081-1082, November 1982. Available here.
[hugh83] R. John M. Hughes. Reference counting with circular structures in virtual memory applicative systems. Internal paper, Programming Research Group, Oxford, 1983.
[hugh85] R. John M. Hughes. A distributed garbage collection algorithm. In Jouannaud [FPCA85], 1985, pages 256-272. Available here.
[hugh87] R. John M. Hughes. Managing reduction graphs with reference counts. Departmental Research Report CSC/87/R2, University of Glasgow, March 1987.
[hugh91] Simon Hughes. Static Analysis of Store Use in Functional Programs. PhD thesis, Imperial College, University of London, 1991.
[hugh92] Simon Hughes. Compile-time garbage collection for higher-order functional languages. Journal of Logic and Computation, 2(4):483-509, August 1992. Special Issue on Abstract Interpretation.
[hump97] Thorna O. Humphries, Alexander L. Wolf, and Benjamin G. Zorn. A framework for storage management evaluation in persistent object systems. In Dickman and Wilson [OOPSLA97-gc], 1997. Available here.
[hump00] Thorna O. Humphries, Artur W. Klauser, Alexander L. Wolf, and Benjamin G. Zorn. POSSE trace format, version 1.0. Technical Report CU-CS-897-00, University of Colorado, Boulder, CO, January 2000.
[hund11] Robert Hundt. Loop recognition in C++/Java/Go/Scala. In Proceedings of the 2nd Scala Workshop (ScalaDays), 2011.
[hunt21] A.H. Hunter, Chris Kennelly, Paul Turner, Darryl Gove, Tipp Moseley, and Parthasarathy Ranganathan. Beyond malloc efficiency to fleet efficiency: a hugepage-aware memory allocator. In 15th USENIX Symposium on Operating Systems Design and Implementation (OSDI 21), pages 257-273. USENIX Association, July 2021. Available here.
[hunt03] Rob Hunter and Shriram Krishnamurthi. A model of garbage collection for OO languages. In 10th International Workshop on Foundations of Object-Oriented Languages (FOOL), 2003.
[hur11] Chung-Kil Hur, Derek Dreyer, and Viktor Vafeiadis. Separation logic in the presence of garbage collection. In IEEE Symposium on Logic in Computer Science (LICS), pages 247-256, 2011.
[huss15a] Ahmed Hussein, Antony L. Hosking, Mathias Payer, and Christopher A. Vick. Don’t race the memory bus: Taming the GC leadfoot. In Bond and Hosking [ISMM15], 2015. Available here.
[huss15] Ahmed Hussein, Mathias Payer, Antony L. Hosking, and Christopher A. Vick. Impact of GC design on power and performance for Android. In ACM International Systems and Storage Conference, SYSTOR, Haifa, Israel, May 2015. Available here.
[huss17] Ahmed Hussein, Mathias Payer, Antony L. Hosking, and Chris Vick. One process to reap them all: Garbage collection as-a-Service. In Petrank et al. [VEE17], 2017, pages 171-186. Available here.
[hutc87b] Norman Hutchinson, R.K. Raj, Andrew P. Black, Henry M. Levy, and Eric Jul. The Emerald programming language report. Technical Report 87-10-07, University of Washington, October 1987.
[hutc87a] Norman Hutchinson. Emerald: An Object-Based Language for Distributed Programming. PhD thesis, University of Washington, January 1987.