This paper presents the design and implementation of the Quicksilver 1 quasi-static compiler for Java. Quasi-static compilation is a new approach that combines the benefits of static and dynamic compilation, while maintaining compliance with the Java standard, including support of its dynamic features. A quasi-static compiler relies on the generation and reuse of persistent code images to reduce the overhead of compilation during program execution, and to provide identical, testable and reliable binaries over different program executions. At runtime, the quasi-static compiler adapts pre-compiled binaries to the current JVM instance, and uses dynamic compilation of the code when necessary to support dynamic Java features. Our system allows interprocedural program optimizations to be performed while maintaining binary compatibility. Experimental data obtained using a preliminary implementation of a quasi-static compiler in the Jalape~no JVM clearly demonstrates the benefits of our app...

This paper presents a compilation framework that enables efficient sharing of executable code across distinct Java Virtual Machine (JVM) instances. High-performance JVMs rely on run-time compilation, since static compilation cannot handle many dynamic features of Java. These JVMs suffer from large memory footprints and high startup costs, which are serious problems for embedded devices (such as hand held personal digital assistants and cellular phones) and scalable servers. A recently proposed approach called quasi-static compilation overcomes these difficulties by reusing precompiled binary images after performing validation checks and stitching on them (i.e., adapting them to a new execution context), falling back to interpretation or dynamic compilation whenever necessary. However, the requirement in our previous design to duplicate and modify the executable binary image for stitching is a major drawback when targeting embedded systems and scalable servers. In this paper, we describe a new approach that allows stitching to be done on an indirection table, leaving the executable code unmodified and therefore writable to readonly memory. On embedded devices, this saves precious space in writable memory. On scalable servers, this allows a single image of the executable to be shared among multiple JVMs, thus improving scalability. Furthermore, we describe a novel technique for dynamically linking classes that uses traps to detect when a class should be linked and initialized. Like back-patching, the technique allows all accesses after the first to proceed at full speed, but unlike back-patching, it avoids the modification of running code. We have implemented this approach in the Quicksilver quasi-static com-

This paper presents a compilation framework that allows executable code to be shared across different Java Virtual Machine (JVM) instances. All fully compliant JVMs that target servers rely on run-time compilation, since dynamic Java features prevent a static compiler from being fully Java compatible. These JVMs are burdened with large memory footprints (because of the size of the increasingly complicated compilers) and high startup costs. Fully compliant JVMs on handheld devices often rely on interpretation—since the overhead of an on-device compiler cannot be supported—and therefore suffer from slower execution speeds and increased energy costs. Quasi-static compilation was proposed as a solution to these difficulties by reusing precompiled binary images after performing validation checks and adapting them to a new execution context, falling back to interpretation or dynamic compilation only when necessary to maintain Java semantics. Our previous quasi-static system required that the executable binary be duplicated and modified during adaptation to the new execution context. This is a major burden both for scalable servers and embedded systems. In this paper, we describe a new approach that allows this adaptation to be done on an indirection table, leaving the executable code unmodified. On embedded devices, this allows the executable to be stored in ROM with only the much smaller indirection table being written to writable memory. On scalable servers, this allows a single image of the executable to be shared by multiple JVMs, improving scalability. Furthermore, we describe a technique for dynamically linking classes that uses traps to detect when a class should be linked and initialized, rather than explicit run-time tests and code modification. We ∗ This work was done while the authors were at the IBM T. J. Watson Research Center