We introduce a new family of connectivity-based garbage collectors (Cbgc) that are based on potential objectconnectivity properties. The key feature of these collectors is that the placement of objects into partitions is determined by performing one of several forms of connectivity analyses on the program. This enables partial garbage collections, as in generational collectors, but without the need for any write barrier.

Modern garbage collectors partition the set of heap objects to achieve the best performance. For example, generational garbage collectors partition objects by age and focus their efforts on the youngest objects. Partitioning by age works well for many programs because younger objects usually have short lifetimes and thus garbage collection of young objects is often able to free up many objects. However, generational garbage collectors are typically much less effcient for longer-lived objects, and thus prior work has proposed many enhancements to generational collection. Our work explores whether the connectivity of objects can yield useful partitions or improve existing partitioning schemes. We look at both direct (e.g., object A points to object B) and transitive (e.g., object A is reachable from object B) connectivity. Our results indicate that connectivity correlates strongly with object lifetimes and deathtimes and is therefore likely to be useful in partitioning objects.

Advances in operating systems and languages have brought the ideal of reasonably-bounded execution time closer to developers who need such assurances for real-time and embedded systems applications. Recently, extensions to the Java libraries and virtual machine have been proposed in an emerging standard, which provides for specification of release times, execution costs, and deadlines for a restricted class of threads. To use such features, the code executing in the thread must never reference storage that could be subject to garbage collection. The new standard provides for regionlike, stack-allocated areas (scopes) of storage that are ignored by garbage collection and deallocated en masse. It now falls to the developer to adapt ordinary Java code to use the real-time Java scoped memory regions. Unfortunately, it is difficult to determine manually how to map object instantiations to scopes. Moreover, if ordinary Java code is modified to effect instantiations in scopes, the resulting code is difficult to read, maintain, and reuse. Static analysis can yield scopes that are correct across all program executions, but such analysis is necessarily conservative in nature. If too many objects appear to live forever under such analysis, then developers cannot rely on static analysis alone to form reasonable scopes. In this paper we present an approach for automatically determining appropriate storage scopes for Java objects, based on dynamic analysis—observed object lifetimes and object referencing behavior. While such analysis is perhaps unsafe across all program executions, our analysis can be coupled with static analysis to bracket object lifetimes, with the truth lying somewhere in between. We provide experimental results that show the memory regions discovered by our technique.

We describe a new method for determining when an object can be garbage collected. The method does not require marking live objects. Instead, each object X is dynamically associated with a stack frame , such that is collectable when pops. Because could havebeendead earlier, our method is conservative. Our results demonstrate that the method nonetheless identifies a large percentage of collectable objects. The method has been implemented in Sun's Java tm Virtual Machine interpreter, and results are presented based on this implementation.

The effectiveness of garbage collectors and leak detectors in identifying dead objects depends on the accuracy of their reachability traversal. Accuracy has two orthogonal dimensions: (i) whether the reachability traversal can distinguish between pointers and nonpointers (type accuracy), and (ii) whether the reachability traversal can identify memory locations that will be dereferenced in the future (liveness accuracy). This article presents an experimental study of the importance of type and liveness accuracy for reachability traversals. We show that liveness accuracy reduces the reachable heap size by up to 62% for our benchmark programs. However, the simpler liveness schemes (e.g., intraprocedural analysis of local variables) are largely ineffective for our benchmark runs: one must analyze global variables using interprocedural analysis to obtain significant benefits. Type accuracy has an insignificant impact on a garbage collector s ability to find unreachable objects in our benchmark runs. We report results for programs written in C, C , and Eiffel.

This article presents a novel technique for allowing the early recovery of storage space occupied by garbage data. The idea is similar to that of generational garbage collection, except that heap is partitioned based on a static analysis of data type definitions rather than on the approximate age of allocated objects. A prototype implementation is presented, along with initial results and ideas for future work. 1 Introduction It has been widely acknowledged that the type information present in a program written in a high level language can provide valuable opportunities for improving run-time performance. Examples of this are pervasive. For instance, information gleaned from type analysis allows natural unboxed representations of primitive quantities like integers, even in the presence of polymorphism [Mor95, HU95]. The precision of pointer-aliasing analysis in an imperative language can be improved by considering the types of the pointers involved [App98]. Run-time feedback can help...

ABSTRACT Concurrent garbage collectors require write barriers to preserveconsistency, but these barriers impose significant direct and indirect costs. While there has been a lot of work on optimizing write barri-ers, we present the first study of their elision in a concurrent collector. We show conditions under which write barriers are redundant,and describe how these conditions can be applied to both incremental update or snapshot-at-the-beginning barriers. We then evaluatethe potential for write barrier elimination with a trace-based limit study, which shows that a significant percentage of write barriersare redundant. On average, 54 % of incremental barriers and 83 % of snapshot barriers are unnecessary.

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.

Real-time software is commonly written in low level languages such as C and assembler. Such software is often hard to test, maintain, and port to other platforms. To improve this situation, high level languages are introduced in the real-time domain. The Java programming language has many properties that are appealing to real-time system development, e.g. robustness and portability. However, it is difficult to estimate the worstcase execution time of Java code using current implementations. This is due to several properties of Java, e.g. dynamic binding of method calls and automatic memory management. This thesis discusses the problems of introducing automatic memory management in hard real-time environments and proposes a technique called RT-Reference Counting to solve the problems. This technique is being integrated in a native Java compiler called RT-Java, being implemented at the Programming Environments Laboratory (PELAB) at Linköping University. An automatic memory manager for hard real-time systems must be able to guarantee that memory is always available to the application and that all memory management operations are fast and execution time predictable. Software based automatic memory managers for real-time systems exist, but they have problems, e.g. always guaranteeing short deadlines and/or handling large objects. RT-Reference Counting aims at solving these problems. The technique is not yet fully developed, but results so far are promising.

This report describes the design and implementation work which has been undertaken using the Java Virtual Machine (JVM) over the Nemesis operating system. The aim is to provide a Java runtime system which is able to support a diverse mix of traditional and soft-real-time applications, just as the Nemesis operating system aims to provide this support to native applications. The report covers three aspects of this work: an interface between Java applications and native services, a run-time code generator that may operate safely under the control of the application and a garbage collector that enables the heap to be partitioned into separately-managed sections. It finally presents the design and prototype implementation of an eXtensible Virtual Machine (XVM) which provides fine-grained control of the primitive operations provided to the programmer.