Abstract. We present an analysis of the memory usage for six of the Java programs in the SPECjvm98 benchmark suite. Most of the programs are realworld applications with high demands on the memory system. For each program, we measured as much low level data as possible, including age and size distribution, type distribution, and the overhead of object alignment. Among other things, we found that non-pointer data usually represents more than 50 % of the allocated space for instance objects, that Java objects tend to live longer than objects in Smalltalk or ML, and that they are fairly small. 1

This article describes the design and implementation of CACAO, a just in time compiler for Java. The CACAO system translates Java byte code on demand into native code for the ALPHA processor. During this translation process the stack oriented Java byte code is transformed into a register oriented intermediate code. Local variables and stack locations are replaced by pseudo registers eliminating the 32 bit restriction on address types. A fast register allocation algorithm is applied to map the pseudo registers to machine registers. During code generation, field offsets are computed for proper alignment on 64 bit architectures. Even though the CACAO system has to incur loading and compilation time, it executes Java programs up to 85 times faster than the JDK interpreter, up to 7 times faster than the kaffe JIT compiler. It is slightly slower than equivalent C programs compiled at the highest optimization level. 1 Introduction Java's [AG96] success as a programming language results from ...

The deployment of Java as a concurrent programming language has created a critical need for high-performance, concurrent, and incremental multiprocessor garbage collection. We present the Recycler, a fully concurrent pure reference counting garbage collector that we have implemented in the Jalapeno Java virtual machine running on shared memory multiprocessors.

This paper describes a memory discipline that combines region-based memory management and copying garbage collection by extending Cheney's copying garbage collection algorithm to work with regions. The paper presents empirical evidence that region inference very significantly reduces the number of garbage collections; and evidence that the fastest execution is obtained by using regions alone, without garbage collection.

This paper describes a new data structure, difference decision diagrams (DDDs), for representing a Boolean logic over inequalities of the form ¡£¢¥¤§¦© ¨ and ¡�¢¥¤���¨ where the variables are integer or real-valued. We give algorithms for manipulating DDDs and for determining functional properties (tautology, satisfiability, and equivalence). DDDs enable an efficient verification of timed systems modeled as, for example, timed automata or timed Petri nets, since both the states and their associated timing information can be represented symbolically, similar to how ROB-DDs represent Boolean predicates.

Abstract. Automatic storage reclamation via reference counting has important advantages, but has always suffered from a major weakness due to its inability to reclaim cyclic data structures. We describe a novel cycle collection algorithm that is both concurrent — it is capable of collecting garbage even in the presence of simultaneous mutation — and localized — it never needs to perform a global search of the entire data space. We describe our algorithm in detail and present a proof of correctness. We have implemented our algorithm in the Jalapeño Java virtual machine as part of the Recycler, a concurrent multiprocessor reference counting garbage collector that achieves maximum mutator pause times of only 6 milliseconds. We present measurements of the behavior of the cycle collection algorithm over a set of eight benchmarks that demonstrate the effectiveness of the algorithm at finding garbage cycles, handling concurrent mutation, and eliminating global tracing. 1

ManyJava programmers believe they do not havetoworry about memory management because of automatic garbage collection. In fact, manyJava programs run out of memory unexpectedly after performing a number of operations. A memory leak in Java is caused when an object that is no longer needed cannot be reclaimed because another object is still referring to it. Memory leaks can be di#cult to solve, since the complexity of most programs prevents us from manually verifying the validityofevery reference.

Abstract. In recent years, large sectors of the software development industry have moved from the procedural style of software development to an object-oriented style. Safety-critical software developers have largely resisted this trend because of concerns about verifiability of object-oriented systems. This paper outlines the benefits offered by object technology and considers the key features of the object-oriented approach from a user’s perspective. We review the main issues affecting safety and propose a paradigm – Verified Design-by-Contract – that uses formal methods to facilitate the safe use of inheritance, polymorphism, dynamic binding and other features of the object-oriented approach. An outline of Perfect Developer – a tool supporting the Verified Design-by-Contract paradigm – is included. 1

We present CCount, a small extension to C that dynamically verifies the correctness of manual memory management using reference counting. CCount relies on a simple extension to the usual malloc/free memory management API, delayed free scopes during which otherwise dangling references can exist. Porting programs to CCount typically requires little effort (on average 0.56 % of lines change), adds an average 11 % time overhead (85 % in the worst case), and increases space usage by an average of 14%. These results are based on porting over half a million lines of C code, including perl where we found six previously unknown bugs. Many existing C programs continue to use unchecked manual memory management. One reason is that programmers fear that moving to garbage collection is too big a risk. We believe that CCount is a practical way to provide safe memory management for such programs. Since CCount checks existing memory management rather than changing it, programmers need not worry that CCount will introduce new bugs; and, since CCount does not manage memory itself, programmers can choose to deploy their programs without CCount if performance is critical (a simple header file allows CCount programs to compile and run with a regular C compiler). In contrast, we found that garbage collection, although faster, had much higher space overhead, and occasionally caused a space-usage explosion that made the program unusable. 1.

We report on our experience with designing, implementing, proving correct, and evaluating a region-based memory management system.