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

Dynamic storage allocation is used heavily in many application areas including interpreters, simulators, optimizers, and translators. We describe research that can improve all aspects of the performance of dynamic storage allocation by predicting the lifetimes of short-lived objects when they are allocated. Using five significant, allocation-intensive C programs, we show that a great fraction of all bytes allocated are short-lived (? 90% in all cases). Furthermore, we describe an algorithm for lifetime prediction that accurately predicts the lifetimes of 42--99% of all objects allocated. We describe and simulate a storage allocator that takes advantage of lifetime prediction of short-lived objects and show that it can significantly improve a program's memory overhead and reference locality, and even, at times, improve CPU performance as well.

Garbage collection is the automatic reclamation of computer storage [Knu73, Coh81, Wil92, Wil95]. While in many systems, programmers must explicitly reclaim heap memory at some point in their program by using a "free" or "dispose" statement, garbage collected systems free the programmer from this burden. In spite of its obvious attractiveness for many applications, garbage collection for real-time programs is not popular. This is largely due to the perceived cost and disruptiveness of garbage collection in general, and of incremental garbage collection in particular. Most existing "real-time" garbage collectors are not in fact usefully real-time, largely due to the use of a read barrier to trigger incremental copying of data structures being traversed by the running application. This may slow down running applications unpredictably, even though individual increments of garbage collection work are small and bounded. We have developed a hard real-time garbage collector which us...

Virtual machines face significant performance challenges beyond those confronted by traditional static optimizers. First, portable program representations and dynamic language features, such as dynamic class loading, force the deferral of most optimizations until runtime, inducing runtime optimization overhead. Second, modular

To date, the most commonly used criterion for invoking garbage collection (GC) is based on heap usage; that is garbage collection is invoked when the heap or an area inside the heap is full. This approach can suffer from two performance shortcomings, untimely garbage collection invocations and large volumes of surviving objects. In this work, we explore a new GC triggering approach called MicroPhase that exploits two observations, (i) allocation requests occur in phases and (ii) the phase boundaries coincide with times when most objects also die, to proactively invoke garbage collection yielding high efficiency. We extended the HotSpot virtual machine from Sun Microsystems to support MicroPhase and conducted experiments using 20 benchmarks. The experimental results indicate that our technique can reduce the GC times in 19 applications. The differences in GC overhead range from an increase of 1 % to a decrease of 26 % when the heap is set to be twice the maximum live-size. As a result, MicroPhase can improve the the overall performance of 13 benchmarks. The performance differences range from a degradation of 2.5 % to an improvement of 14%.

Factotum is a software system for implementing symbolic computing systems, such as BDDs and tuple sets, that critically rely on sharing of equivalent subterms. It provides an subterm sharing facility that is automatic and systematic, analogously to the way that automatic memory management is provided by a garbage collector. It also provides a high-level programming interface suitable for use in multithreaded applications. We describe both the theoretical underpinnings and practical aspects of Factotum, show some examples, and report on some recent experiments. 1 Introduction While automatic garbage collection[McC60, Wil95] has become an accepted practice for managing memory-intensive applications, automatic sharing management is significantly less developed. Sharing of equivalent data structures in memory is of course critical for reasonable performance in many otherwise exponential computations, and is well-developed from an algorithmic standpoint, just as explicit allocation and dea...

Generation-based garbage collectors must detect references from older generations into younger ones in order to allow the independent scavenging of the younger generations [Lille83]. On stock hardware, the most efficient approach is to record which locations in older generations may hold pointers into younger generations as heap data are modified by the running program [Unga84]. At scavenge time, the remembered locations of older generations are checked to find any references to data in the generation(s) being scavenged. This ensures that any objects that are live because of pointers from older generations are found by the scavenging process. Like Moon's Ephemeral Garbage Collector [Moon84] ours does not actually record which individual locations hold intergenerational pointers. Moon's system records which pages contain such pointers; ours uses a software analogue to pages, called cards [Soba88]. Since individual locations are not remembered, whole cards must be scanned at scavenge time to find pointers into younger generations. This lowered-resolution recording has two benefits, however: the space required for recording is greatly reduced, and the base cost of examining this information (at scavenge time) is similarly decreased. To minimize the continual run-time overhead, we record only whether a location is

We propose a profiling tool for experimental evaluation of garbage collection algorithms. Behaviour of the profiler is determined by some probability distributions on object size and life time etc. that are derived from the properties of certain languages or applications. A standard memory management interface allows precise, objective evaluation of several garbage collection algorithms under laboratory conditions using the same profiler parameters. The separation of memory management and language/application we thus achieve can be used for experimental determination of optimal garbage collection strategies for a given situation. Categories ffl Garbage collection (GC) ffl MM performance analysis and optimization tools 1 Introduction Garbage collector performance is one of the key determinants of functional and object-oriented programming systems. Numerous attempts at improvement of garbage collector performance have therefore been published; e.g. [Bak78, Bak93, NO93, ON94, Ung84, W...