Automatic storage management, or garbage collection, is a feature usually associated with languages oriented toward ‘‘symbolic processing,’’ such as Lisp or Prolog; it is seldom associated with ‘‘systems’’ languages, such as C and C++. This report surveys techniques for performing garbage collection for languages such as C and C++, and presents an implementation of a concurrent copying collector for C++. The report includes performance measurements on both a uniprocessor and a multiprocessor.

Memory management is a critical issue for many large object-oriented applications, but in C++ only explicit memory reclamation through the delete operator is generally available. We analyse different possibilities for memory management in C++ and present a dynamic memory management framework which can be customised to the need of specific applications. The framework allows full integration and coexistence of different memory management techniques. The Customisable Memory Management (CMM) is based on a primary collector which exploits an evolution of Bartlett's mostly copying garbage collector. Specialised collectors can be built for separate memory heaps. A Heap class encapsulates the allocation strategy for each heap. We show how to emulate different garbage collection styles or user-specific memory management techniques. The CMM is implemented in C++ without any special support in the language or the compiler. The techniques used in the CMM are general enough to be applicable also to...

We describe a concurrent, atomic garbage collection algorithm for transaction-based languages, a class of languages intended to support reliable distributed systems. A garbage collection algorithm for reliable distributed systems must be atomic: a crash during a garbage collection should result in no loss of data. A concurrent collector allows programs to continue operating as their heaps are collected, minimizing delays imposed by collection. A concurrent collector can be used in reliable distributed systems that must service interactive requests. We introduce concurrency into an atomic collector by breaking collection into a series of garbage collection segments, which are similar to transactions, but satisfy weaker properties than are required by transaction semantics. These weaker properties allow better performance. Thus, our collection algorithm enhances the reliability of programs written in transaction-based languages, without necessarily imposing severe performance penalties. ...

This paper proposes the use of "smart pointer" template classes as an interface for the use of garbage collection in C++ . Template classes and operator overloading are techniques allowing language extension at the level of user code; I claim that using these techniques to create smart pointer classes provides a syntax for manipulating garbage-collected storage safely and conveniently. Further, the use of a smart-pointer template class offers the possibility of implementing the collector at the user-level, without requiring support from the compiler. If such a compiler-independent implementation is possible with adequate performance, then programmers can start to write code using garbage collection without waiting for language and compiler modifications. If the use of such a garbage-collection interface becomes widespread, then C++ compilation systems can be built to specially support the garbage collection interface, thereby allowing the use of collection algorithms with enhanced performance.

. Automatic garbage collection relieves programmers from the burden of managing memory themselves and several techniques have been developed that make garbage collection feasible in many situations, including real time applications or within traditional programming languages. However optimal performance cannot always be achieved by a uniform general purpose solution. Sometimes an algorithm exhibits a predictable pattern of memory usage that could be better handled specifically, delaying as much as possible the intervention of the general purpose collector. This leads to the requirement for algorithm specific customisation of the collector strategies. We present a dynamic memory management framework which can be customised to the needs of an algorithm, while preserving the convenience of automatic collection in the normal case. The Customisable Memory Management (CMM) organizes memory in multiple heaps. Each heap is defined as a C++ class which encapsulates a particular storage discipli...

this memory can be freed at the end of this step. The only data to be preserved is the simplified polynomial which must be inserted into the final basis. 2 In many cases simplify returns a zero polynomial. In these cases no memory must be preserved. 3 Since the complexity of the algorithm is exponential, the amount of memory allocated by simplify also grows exponentially with the size of the ideal. We can tune the memory management for this algorithm by means of the CMM, adopting two different heaps: the default one (CmmHeap::heap) and a special one for this algorithm (tempHeap), an instance of the HeapStack class sketched below. 12 G. Attardi and T. Flagella Memory is usually allocated inside the default heap, but before calling simplify the heap is switched to the tempHeap. All the memory allocated during simplify is therefore obtained from the tempHeap heap. Notice that this does not require any changes to any of the remaining functions in the PoSSo library: the algebraic operations on polynomials, coefficients etc. are unmodified and use the standard new operator to allocate objects. After returning from simplify we switch back to the default heap, and the polynomial returned by simplify is copied into the default heap. At this point the tempHeap contains no live data and can be freed with a single operation without involving a garbage collection. Here again is the code augmented with instructions for CMM memory management. CmmHeap *previousHeap = CmmHeap::heap; // Save the current heap

In this paper we introduce Prop, a multiparadigm extension of C++ with Standard ML-style algebraic datatypes and pattern matching, tree rewriting, DATALOG-style forward chaining inference, and constraint logical programming. Applications written in Prop can utilize various cooperating formalisms, integrated into the object oriented paradigm of the base language. We use efficient automata-based and semantics based algorithms to generate various pattern matching constructs into efficient and lightweight C++ programs. Interoperability with the base language is achieved transparently since all high level data structures in Prop are mapped into classes. Furthermore, we use conservative garbage collection schemes to minimize interaction with existing code by eliminating the need for manual storage management. Typical Prop program sources are 2--10 times more compact than equivalent programs written in C++. Our benchmarks also show that programs written in Prop's high level formalis...

This reference manual provides an introduction to Prop, release 2.3.4. Prop is a multiparadigm extension of C++, and is designed for building high performance compiler and language transformation systems, using pattern matching and rewriting. This guide describes the syntax and semantics of the Prop language and describes how to develop programs using the Prop to C++ translator. The author will neither assume responsibility for any damages caused by the use of this product, nor accept warranty or update claims. This product is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. This product is in the public domain, and may be freely distributed. Prop is a research prototype. The information contained in this document is subject to change without notice. 1 Contents 1 Introduction 4 1.1 Availability : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ...

Exact garbage collection for the strongly-typed Java language may seem straightforward. Unfortunately, a single pair of bytecodes in the Java Virtual Machine instruction set greatly presents an obstacle that has thus far not been discussed in the literature. We explain the problem, outline the space of possible solutions, and present a solution utilizing bytecode-preprocessing to enable exact garbage collection while maintaining compatibility with existing compiled Java class files.