Now that the use of garbage collection in languages like Java is becoming widely accepted due to the safety and software engineering benefits it provides, there is significant interest in applying garbage collection to hard real-time systems. Past approaches have generally suffered from one of two major flaws: either they were not provably real-time, or they imposed large space overheads to meet the real-time bounds. We present a mostly non-moving, dynamically defragmenting collector that overcomes both of these limitations: by avoiding copying in most cases, space requirements are kept low; and by fully incrementalizing the collector we are able to meet real-time bounds. We implemented our algorithm in the Jikes RVM and show that at real-time resolution we are able to obtain mutator utilization rates of 45% with only 1.6--2.5 times the actual space required by the application, a factor of 4 improvement in utilization over the best previously published results. Defragmentation causes no more than 4% of the traced data to be copied.

Much prior work has shown that the performance enabled by garbage collection (GC) systems is highly dependent upon the behavior of the application as well as on the available resources. That is, no single GC enables the best performance for all programs and all heap sizes. To address this limitation, we present the design, implementation, and empirical evaluation of a novel Java Virtual Machine (JVM) extension that facilitates dynamic switching between a number of very different and popular garbage collectors. We also show how to exploit this functionality using annotation-guided GC selection and evaluate the system using a large number of benchmarks. In addition, we implement and evaluate a simple heuristic to investigate the efficacy of switching automatically. Our results show that, on average, our annotation-guided system introduces less than 4% overhead and improves performance by 24% over the worstperforming GC (across heap sizes) and by 7% over always using the popular Generational/Mark-Sweep hybrid.

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

Security concerns on embedded devices like cellular phones make Java an extremely attractive technology for providing third-party and user-downloadable functionality. However, garbage collectors have typically required several times the maximum live data set size (which is the minimum possible heap size) in order to run well. In addition, the size of the virtual machine (ROM) image and the size of the collector’s data structures (metadata) have not been a concern for server- or workstation-oriented collectors. We have implemented two different collectors specifically designed to operate well on small embedded devices. We have also developed a number of algorithmic improvements and compression techniques that allow us to eliminate almost all of the per-object overhead that the virtual machine and the garbage collector require. We describe these optimizations and present measurements of the Java embedded benchmarks (EEMBC) of our implementations on both an IA32 laptop and an ARM-based PDA. For applications with low to moderate allocation rates, our optimized collector running on the ARM is able to achieve 85 % of peak performance with only 1.05 to 1.3 times the absolute minimum heap size. For applications with high allocation rates, the collector achieves 85 % of peak performance with 1.75 to 2.5 times the minimum heap size. The collector code takes up 40 KB of ROM, and collector metadata overhead has been almost completely eliminated, consuming only 0.4 % of the heap.

In this paper, we describe a novel execution environment that can dynamically switch between garbage collection systems. As such, it enables selection of the most appropriate allocator and collector for a given application and underlying resource availability. Our system is novel in that it is able to switch between a wide range of diverse collection systems. It uses program annotations to guide selection of the collection system. In addition, it can automatically identify when to switch collectors when program execution behavior warrants it, i.e., it is adaptive. Our system introduces little overhead and accurately identifies the best collector for a wide range of benchmarks and heap sizes.

INTRODUCTION This work is only five years old. It owes its influence to the explosive growth of the internet and the Java programming language over that period. In 1997 the adoption of Java for use in production commercial applications was widely viewed as risky, and one of the primary barriers to acceptance was its poor performance. Aside from being interpreted, Java also incorporated a number of features not previously seen in a mainstream programming language: garbage collection, dynamic loading, and concurrency. These features created various sorts of performance challenges. We could tell that Java was spending about half its time in synchronization, even for single-threaded benchmarks, which would surely form a large portion of Java programs. This led us to begin thinking about how to make a single-threaded Java program fast, even if it used thread-safe libraries that used synchronization extensively. Previous experience with Hermes [12], a programming language developed at IBM

In this paper, we describe a novel execution environment that can dynamically switch between garbage collection (GC) systems. As such, it enables application-specific GC selection. In addition, the system can switch between different GC systems while the program is executing. Our system is novel in that it is able to switch between a wide range of diverse collection systems. To empirically evaluate our system, we implemented annotation-guided GC selection and we show its efficacy for a wide range of benchmarks and heap sizes. In addition, we implemented a simple heuristic that automatically identifies when to switch collectors when program execution behavior warrants it. Our system introduces an average overhead of 4% for both annotation-guided and automatic switching. Perhaps more importantly however, we significantly improve performance over selecting the wrong collection system (by 19% using annotation-guided selection and by 16% using automatic switching, on average).

Virtual machine technology will continue to increase in importance, eventually spanning from motes to supercomputers. In this position paper, I describe my personal vision for the virtual machine of the future: a virtual machine that dynamically modifies all portions of itself, rather than just the compiled code, and that dynamically reconfigures the underlying hardware as well. 1.

Memory performance is an important design issue for contemporary computer systems given the huge processor-memory speed gap. This paper proposes a space-efficient Java object model for reducing the memory consumption of 64-bit Java virtual machines. We completely eliminate the object header through Typed Virtual Addressing (TVA) or implicit typing. TVA encodes the object type in the object’s virtual address by allocating all objects of a given type in a contiguous memory segment. This allows for removing the type information as well as the status field from the object header. Whenever type and status information is needed, masking is applied to the object’s virtual address for obtaining an offset into type and status information structures. Unlike previous work on implicit typing, we apply TVA to a selected number of frequently allocated object types, hence the name Selective TVA (STVA); this limits the amount of memory fragmentation. In addition to applying STVA, we also compress the Type Information Block (TIB) pointers for all objects that do not fall under TVA. We implement the space-efficient Java object model in the 64-bit version of the Jikes RVM on an AIX IBM platform and compare its performance against the traditionally used Java object model using a multitude of Java benchmarks. We conclude that the space-efficient Java object model reduces memory consumption by on average 15 % (and up to 45 % for some benchmarks). About half the reduction comes from TIB pointer compression; the other half comes from STVA. In terms of performance, the space-efficient object model generally does not affect performance, however for some benchmarks we observe statistically significant performance speedups, up to