We survey basic garbage collection algorithms, and variations such as incremental and generational collection; we then discuss low-level implementation considerations and the relationships between storage management systems, languages, and compilers. Throughout, we attempt to present a uni ed view based on abstract traversal strategies, addressing issues of conservatism, opportunism, and immediacy of reclamation; we also point outavariety of implementation details that are likely to have a significant impact on performance.

: PANDA is a run-time package based on a very small operating system kernel which supports distributed applications written in C++. It provides powerful abstractions such as very efficient user-level threads, a uniform global address space, object and thread mobility, garbage collection, and persistent objects. The paper discusses the design rationales underlying the PANDA system. The fundamental features of PANDA are surveyed, and their implementation in the current prototype environment is outlined. 1. Introduction Systems for parallel and distributed object-oriented programming can be classified into two basic categories. Firstly, there is a variety of programming languages developed especially to serve experimental purposes. Different object models for parallel and distributed programming can be investigated by designing and working with such systems. Some examples of languages in this area are Emerald [Jul el al. 88], Pool [America and van der Linden 90], Sloop [Lucco 87], and Or...

Garbage collection is an extremely useful programming language feature that is currently absent from C++. The benefits from garbage collection include convenience and safety because the programmer is not responsible for freeing dynamically allocated storage. Many reclamation schemes improve efficiency by compacting objects in memory improving locality and reducing paging. Some reclamation techniques are more efficient than manual reclamation for important classes of data structures. This paper presents a copying collector for C++ that supports polymorphism and does not require indirection through an "object table." This memory reclamation scheme is one of few that is philosophically consistent with the design goals of the C++ programming language: one must not be penalized for features that are not used. This report includes performance measurements from a prototype implementation. Introduction Garbage collection (GC) is a programming environment feature that removes the programmer 's...

Previous attempts at garbage collection in uncooperative environments have generally used conservative or mostly conservative approaches. We describe a technique for doing fully type-accurate garbage collection in an uncooperative environment, using a "shadow stack" to link structs of pointer-containing variables, together with the data or code needed to trace them. We have implemented this in the Mercury compiler, which generates C code, and present preliminary performance data on the overheads of this technique. We also show how this technique can be extended to handle multithreaded applications.

Introduction C++ represents an imperative based hybrid Object-Oriented Programming Language [ES90]. It integrates low-level and high-level programming language features in an attempt to benefit from both. The low-level features allow the programmer to write run-time efficient code. The high-level features support code-reuse through inheritance, and the development of large, maintainable codes through encapsulation. The base language C is a well designed system implementation language, and as such is easily compilable for most traditional architectures into highly efficient run-time object code. The OOP features are derived from SIMULA67 [B + 73]. They allow the programmer to design modules that in the Platonic sense capture the characteristics of the abstraction to be programmed about [Poh91,Str90]. Garbage Collection is a technique for automatically identifying and deallocating inaccessible dynamically allocated memory. It is so useful, and perhaps, so diff