Bernd J. W. Mathiske

Heap compression for memory-constrained Java environments

Java is becoming the main software platform for consumer and embedded devices such as mobile phones, PDAs, TV set-top boxes, and in-vehicle systems. Since many of these systems are memory constrained, it is extremely important to keep the memory footprint of Java applications under control.The goal of this work is to enable the execution of Java applications using a smaller heap footprint than that possible using current embedded JVMs. We propose a set of memory management strategies to reduce heap footprint of embedded Java applications that execute under severe memory constraints. Our first contribution is a new garbage collector, referred to as the Mark-Compact-Compress (MCC) collector, that allows an application to run with a heap smaller than its footprint. An important characteristic of this collector is that it compresses objects when heap compaction is not sufficient for creating space for the current allocation request. In addition to employing compression, we also consider a heap management strategy and associated garbage collector, called MCL (Mark-Compact-Lazy Allocate), based on lazy allocation of object portions. This new collector operates like the conventional Mark-Compact (MC) collector, but takes advantage of the observation that many Java applications create large objects, of which only a small portion is actually used. In addition, we also combine MCC and MCL, and present MCCL (Mark-Compact-Compress-Lazy Al-locate), which outperforms both MCC and MCL.We have implemented these collectors using KVM, and performed extensive experiments using a set of ten embedded Java applications. We have found our new garbage collection strategies to be useful in two main aspects. First, they reduce the minimum heap size necessary to execute an application without out-of-memory exception. Second, our strategies reduce the heap occupancy. That is, at a given time, they reduce the heap memory requirement of the application being executed. We have also conducted experiments with a more aggressive object compression strategy and discussed its main advantages.

Architecture of the PEVM: A High-Performance Orthogonally Persistent Java[tm] Virtual Machine

This paper describes the design and implementation of the PEVM, a new scalable, high-performance implementation of orthogonal persistence for the Java[tm] platform (OPJ). The PEVM is based on the Sun Microsystems Laboratories Virtual Machine for Research (ResearchVM), which features an optimizing Just-In-Time compiler, exact generational garbage collection, and fast thread synchronization. It also uses a new, scalable persistent object store designed to manage more than 80GB of objects. The PEVM is approximately ten times faster than previous OPJ implementations and can run significantly larger programs. It is faster than or comparable in performance to several commercial persistence solutions for the Java platform. Despite the PEVMs speed and scalability, its implementation is simpler than our previous OPJ implementation (e.g., just 43% of the VM source patches needed by our previous OPJ implementation). Its speed and simplicity are largely due to our pointer swizzling strategy, the ResearchVM s exact memory management, and a few simple but effective mechanisms. For example, we implement some key data structures in the Java[tm] programming language since this automatically makes them persistent.