Abstract. A unidirectional heap is a heap where all pointers go in one direction, e.g. from newer to older objects. For a strict functional language, such as Erlang, the heap may be arranged so that it is unidirectional. We here present a compacting garbage collection algorithm which utilizes the fact that a heap is unidirectional. Only one memory space is used in our algorithm. In fact, no extra memory is used at all, not even any reserved bits within the cells. The algorithm is quite easy to extend to a variant of generational garbage collection. 1

Development of highly intelligent computers requires a conceptual foun- dation that will overcome the limitations of the yon Neumann architecture.

We present a new approach to parallel copying garbage collection on symmetric multiprocessor (SMP) machines appropriate for Java and other object-oriented languages. Parallel, in this setting, means that the collector runs in several parallel threads. Our collector

In this paper, a garbage collection scheme to work in an object oriented, distributed, persistent environment is described. An experimental prototype has been implemented to demonstrate the feasibility of such a scheme. The scheme can be considered incremental. The garbage identification and collection processes at the different processing nodes are totally autonomous and independant, without a need for communication or synchronization between nodes. The scheme is considered as part of the more general object reorganization in the system to achieve stronger locality of reference at the different nodes 1 . 1 ntroduction In object oriented environments the problem of storage reclamation is more serious than in traditional systems. Object oriented programming encourages building dynamic complex structures with large number of connections among the components of these structures which makes it difficult to determine the nonreachable(garbage) objects manually. Automatic storage r...

This paper presents the main logging techniques issues through a study of four existing logging systems implemented as independent storage systems: Clio, Camelot DLF, K i t L o g and Sprite LFS. It aims to provide a clear view of problems and actual solutions. Key words and phrases: Logging techniques, compaction, log end, quick data lookup. Introduction

. We present a new algorithm for garbage collection of the term stack in David H. D. Warren's abstract Prolog machine (WAM). The algorithm exploits the possibilities of using a large address space, with special attention paid to virtual memory behaviour. The time required for the algorithm depends linearly on the size of the areas in which garbage is collected. Pseudo-code is given for the whole algorithm. It has been fully implemented in Tricia, a Prolog developed at UPMAIL for the DEC-2060 computer. The research reported herein was supported by the National Swedish Board for Technical Development (STU). 1. PROBLEM In languages with dynamic memory allocation it often happens that an instance of a data structure is not needed for the rest of the computation. Assuming that virtual memory is a limited resource (although it may be very large) it is desirable to be able to re-use such garbage structures. Placing the responsibility of returning garbage on the programmer is a too heavy bu...

Arrays are the ubiquitous organization for indexed data. Throughout programming language evolution, implementations have laid out arrays contiguously in memory. This layout is problematic in space and time. It causes heap fragmentation, garbage collection pauses in proportion to array size, and wasted memory for sparse and over-provisioned arrays. Because of array virtualization in managed languages, an array layout that consists of indirection pointers to fixed-size discontiguous memory blocks can mitigate these problems transparently. This design however incurs significant overhead, but is justified when real-time deadlines and space constraints trump performance. This paper proposes z-rays, a discontiguous array design with flexibility and efficiency. A z-ray has a spine with indirection pointers to fixed-size memory blocks called arraylets, and uses five optimizations: (1) inlining the first N array bytes into the spine, (2) lazy allocation, (3) zero compression, (4) fast array copy, and (5) arraylet copy-on-write. Whereas discontiguous arrays in prior work improve responsiveness and space efficiency, z-rays combine time efficiency and flexibility. On average, the best z-ray configuration performs within 12.7 % of an unmodified Java Virtual Machine on 19 benchmarks, whereas previous designs have two to three times higher overheads. Furthermore, language implementers can configure z-ray optimizations for various design goals. This combination of performance and flexibility creates a better building block for past and future array optimization.

This paper presents the main logging techniques issues through a study of four existing logging systems implemented as independent storage systems: Clio, Camelot DLF, K I T

Object oriented programming environments frequently suffer serious performance degradation because of a high level of paging activity when implemented using a conventional virtual memory system. Although the fine-grained, persistent nature of objects in such environments is not conducive to efficient paging, the performance degradation can be limited by careful grouping of objects within pages. Such object placement schemes can be classified into four categories --- the grouping mechanism may be either static or dynamic and may use information acquired from static or dynamic properties. This paper investigates the effectiveness of a simple dynamic grouping strategy based on dynamic behaviour and compares it with a static grouping scheme based on static properties. These schemes are also compared with near-optimal and random cases. 1 Introduction Virtual memory enables programs much larger than primary memory to be implemented without the need for explicit management of primary memory...

We consider the combination of card marking with remembered sets for generational garbage collection as suggested by Hosking and Hudson [3]. When more than two generations are used, a naive implementation may cause excessive and wasteful scanning of the cards and thus increase the collection time. We offer a simple data structure and a corresponding algorithm to keep track of which cards need be scanned for which generation. We then extend these ideas for the Train Algorithm of [4]. Here, the solution is more involved, and allows tracking of which card should be scanned for which carcollection in the train.