POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Reference escape analysis: optimizing reference counting based on the lifetime of references
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Compiler support for garbage collection in a statically typed language
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
TIL: a type-directed optimizing compiler for ML
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Garbage collection: algorithms for automatic dynamic memory management
Garbage collection: algorithms for automatic dynamic memory management
Garbage collection and local variable type-precision and liveness in Java virtual machines
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Advanced compiler design and implementation
Advanced compiler design and implementation
Support for garbage collection at every instruction in a Java compiler
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Efficient and precise modeling of exceptions for the analysis of Java programs
Proceedings of the 1999 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
A semantic model of reference counting and its abstraction (detailed summary)
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
A Fortran-Compiled List-Processing Language
Journal of the ACM (JACM)
Shifting garbage collection overhead to compile time
Communications of the ACM
An efficient, incremental, automatic garbage collector
Communications of the ACM
A method for overlapping and erasure of lists
Communications of the ACM
Java Virtual Machine Specification
Java Virtual Machine Specification
Essential .NET: The Common Language Runtime
Essential .NET: The Common Language Runtime
On the usefulness of type and liveness accuracy for garbage collection and leak detection
ACM Transactions on Programming Languages and Systems (TOPLAS)
IBM Systems Journal
A unified theory of garbage collection
OOPSLA '04 Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compiler optimizations for nondeferred reference: counting garbage collection
Proceedings of the 5th international symposium on Memory management
Overlooking roots: a framework for making nondeferred reference-counting garbage collection fast
Proceedings of the 6th international symposium on Memory management
Online reorganization of databases
ACM Computing Surveys (CSUR)
Allocation wall: a limiting factor of Java applications on emerging multi-core platforms
Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
Efficient interpretation using quickening
Proceedings of the 6th symposium on Dynamic languages
Concurrent non-deferred reference counting on the Microgrid: first experiences
IFL'10 Proceedings of the 22nd international conference on Implementation and application of functional languages
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Resurrector: a tunable object lifetime profiling technique for optimizing real-world programs
Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications
| Hi-index | 0.00 |
Nondeferred reference-counting (RC) garbage collection is among the oldest memory-management methods. Despite offering unique advantages, little attention has been paid on how to correctly implement it for modern programming languages. This paper revisits this collection method and describes how to implement it for a modern object-oriented language in an optimizing compiler. The main contribution is a general algorithm that realizes one form of nondeferred RC collection for an object-oriented language having features such as exceptions, interior pointers, and object pinning. The algorithm abstracts the pertinent characteristics of instructions using concepts from data-flow analysis, such as def/use information, so that instructions are handled in a uniform manner, instead of in an ad hoc or special-case way. The abstracted information is used to systematically compute what increments and decrements to do, even in the presence of subtle conditions such as exceptional control flow. These techniques enabled us to compile a large suite of programs to use nondeferred RC collection. The paper also discusses the modifications that were necessary in the compiler for supporting the inserted RC operations, and reports measurements from a reference implementation.