Garbage collection in an uncooperative environment
Software—Practice & Experience
Mostly parallel garbage collection
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Space efficient conservative garbage collection
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Memory allocation costs in large C and C++ programs
Software—Practice & Experience
Simple garbage-collector-safety
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Understanding memory allocation of scheme programs
ICFP '00 Proceedings of the fifth ACM SIGPLAN international conference on Functional programming
On the type accuracy of garbage collection
Proceedings of the 2nd international symposium on Memory management
Reducing garbage collector cache misses
Proceedings of the 2nd international symposium on Memory management
Conservative garbage collection for general memory allocators
Proceedings of the 2nd international symposium on Memory management
Bounding space usage of conservative garbage collectors
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Destructors, finalizers, and synchronization
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The space cost of lazy reference counting
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels
Compacting garbage collection with ambiguous roots
ACM SIGPLAN Lisp Pointers
Queue - The Concurrency Problem
Efficiency of subtype test in object oriented languages with generics
Proceedings of the 8th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems
Ironclad C++: a library-augmented type-safe subset of c++
Proceedings of the 2013 ACM SIGPLAN international conference on Object oriented programming systems languages & applications
Hi-index | 0.00 |
C++ has traditionally relied on manual memory management. Sometimes this has been augmented by limited reference counting, implemented in libraries, and requiring use of separate pointer types. In spite of the fact that conservative garbage collectors have been used with C for decades, and with C++ for almost as long, they have not been well-supported by language standards. This in turn has limited their use. We have led an effort to change this by supporting optional "transparent" garbage collection in the next C++ standard. This is designed to either garbage collect or detect leaks in code using normal unadorned C++ pointers. We initially describe an ambitious effort that would have allowed programmers to explicitly request garbage collection. It faced a number of challenges, primarily in correct interaction with existing libraries relying on explicit destructor invocation. This effort was eventually postponed to the next round of standardization. This initial effort was then temporarily replaced by minimal support in the language that officially allows garbage collected implementations. Such minimal support is included in the current committee draft for the next C++ standard. It imposes an additional language restriction that makes it safe to garbage collect C++ programs. Stating this restriction proved subtle. We also provide narrow interfaces that make it easy to both correct code violating this new restriction, and to supply hints to a conservative garbage collector to improve its performance. These provide interesting implementation challenges. We discuss partial solutions.