A hardware self-managing heap memory (RCM) for languages like LISP, SMALLTALK, and JAVA has been designed, built, tested and benchmarked. On every pointer write from the processor, reference-counting transactions are performed in real time within this memory, and garbage cells are reused without processor cycles. A processor allocates new nodes simply by reading from a distinguished location in its address space. The memory hardware also incorporates support for off-line, multiprocessing, mark-sweep garbage collection. Performance statistics are presented from a partial implementation of SCHEME over five different memory models and two garbage collection strategies, from main memory (no access to RCM) to a fully operational RCM installed on an external bus. The performance of the RCM memory is more than competitive with main memory.

A reference counting garbage collector cannot reclaim unreachable cyclic structures of objects. Therefore, reference counting collectors either use a backup tracing collector seldom, or employ a cycle collector to reclaim cyclic structures. Recently, the first on-the-fly cycle collector, that may run concurrently with program threads, was presented by Bacon and Rajan [3]. This demonstrated the ability to run on-the-fly reference counting without resorting to an auxiliary tracing collector. In this paper

Language Support and Compilation Techniques for Regions Region-based memory management systems structures memory by grouping objects in regions under program control. Memory is reclaimed by deleting regions, freeing all objects stored therein. Our compiler for C with regions, RC, prevents unsafe region deletions by keeping a count of references to each region. RC is compiled to C. Using type annotations that make the structure of a program’s regions more explicit and a reference counting scheme that optimises reference count operations on local variables, we reduce the overhead of reference counting from a maximum of 27 % to a maximum of 18 % on our benchmarks. We generalise these annotations in a region type system whose main novelty is the use of existentially quantified abstract regions to represent pointers to objects whose region is partially or totally unknown. 1

We present a garbage collection scheme based on reference counting and region inference which, unlike the standard reference counting algorithm, handles cycles correctly. In our algorithm, the fundamental operations of region inference are performed dynamically. No assistance is required from the programmer or the compiler, making our algorithm particularly well-suited for use in dynamically-typed languages such as scripting languages. We provide a detailed algorithm and demonstrate how it can be implemented efficiently.

Distributed systems present a new challenge to garbage collection design. Garbage collection schemes for linked, heterogeneous data-structures distributed over a network are reviewed for the first time. As distributed garbage collectors evolved from single address space collectors, these are classified first. The classification is extended to distributed collectors taking into account the additional issues of distribution: locality; latency and synchronisation. Categories and Subject Descriptors: C.2.4 [Computer-Communications Networks]: Distributed Systems; D.1.3 [Programming Techniques]: Concurrent Programming, Distributed programming, parallel programming; D.4.2 [Operating Systems]: Storage management; D.4.3: File systems management. Additional key words and phrases: memory management, automatic storage reclamation, garbage collection, reference counting, distributed systems, distributed memories, distributed file systems, network communication. Contents 1 Introduction 3 2 Taxonom...

We present a distributed cyclic reference counting algorithm which incorporates both, the correct management of cyclic data structures and the improvement of lazy mark-scan. The algorithm allows processors to run local mark-scan simultaneously without any need of synchronisation between phases of different local mark-scans either on the same processor or on different processors. 1 Introduction In distributed memory multiprocessors, each processor is responsible for reclaiming unused structures residing in its local memory (distributed garbage collection). As in the case of uni-processors, the algorithms are usually based on (global) mark-scan or on reference counting [5]. A number of algorithms use (global) mark-scan in distributed architectures [11, 1, 12]. The major disadvantage of these methods is that, as in the sequential case, the application is suspended during the garbage collection phase. One attempt [21] to improve this uses dual processors on each local memory and transfers...

Printed on QMS- PS-810 turbo PostScript printer. Bibliography made by BibTEX. Illustration made by idraw. D.I.K.U. / Dist. Lab.

A reference counting garbage collector cannot reclaim unreachable cyclic structures of objects. Therefore, reference counting collectors either use a backup tracing collector seldom, or employ a cycle collectors to reclaim cyclic structures. Recently, the first on-the-fly cycle collector, that may run concurrently with program threads, was presented by Bacon and Rajan [3]. This demonstrated the ability to run on-the-fly reference counting without resorting to an auxiliary tracing collector.

Concurrent Scheme extends the Scheme programming language, providing parallel program execution on a distributed network. The Concurrent Scheme environment requires a garbage collector to reclaim global objects; objects that exist in a portion of the global heap located on the node that created them. Because a global object may be referenced by several nodes, traditional garbage collection algorithms cannot be used. The garbage collector used must be able to reclaim global objects with minimal disturbance to the user program, and without the use of global state information. It must operate asynchronously, have a low network overhead, and be able to handle out-of-order messages. This thesis describes a distributed reference counting garbage collector appropriate for the reclamation of global objects in the Concurrent Scheme environment. A DISTRIBUTED GARBAGE COLLECTION ALGORITHM by Terence J. Critchlow A thesis submitted to the faculty of The University of Utah in partial fulfillment ...

A hardware self-managing heap memory (RCM) for languages like LISP, SMALLTALK, and JAVA has been designed, built, tested and benchmarked. On every pointer write from the processor, reference-counting transactions are performed in real time within this memory, and garbage cells are reused without processor cycles. A processor allocates new nodes simply by reading from a distinguished location in its address space. The memory hardware also incorporates support for off-line, multiprocessing, mark-sweep garbage collection. Performance statistics are presented from a partial implementation of SCHEME over five different memory models and two garbage collection strategies, from main memory (no access to RCM) to a fully operational RCM installed on an external bus. The performance of the RCM memory is more than competitive with main memory. CR categories and Subject Descriptors: E.2 [Data Storage Representations]: Linked representations; D.4.2 [Storage Management]: Allocation/Deallocation st...