Marmot: an optimizing compiler for Java

Abstract

The Marmot system is a research platform for studying the implementation of high level programming languages. It currently comprises an optimizing native-code compiler, runtime system, and libraries for a large subset of Java. Marmot integrates well-known representation, optimization, code generation, and runtime techniques with a few Java-specific features to achieve competitive performance. This paper contains a description of the Marmot system design, along with highlights of our experience applying and adapting traditional implementation techniques to Java. A detailed performance evaluation assesses both Marmot's overall performance relative to other Java and C++ implementations, and the relative costs of various Java language features in Marmot-compiled code. Our experience with Marmot has demonstrated that well-known compilation techniques can produce very good performance for static Java applicationscomparable or superior to other Java systems, and approaching that of C++ in some cases.We seek to bring the benefits of Java's high level features to larger programs while minimizing the associated performance penalty. Our approach is to adapt well-known implementation techniques from existing language implementations to Java, integrating them with new Java-specific technology where necessary. We have constructed a system, Marmot, that includes a static optimizing compiler, runtime system, and libraries for a large subset of Java. The native-code compiler implements standard scalar optimizations of the sort found in Fortran, C and C++ compilers [2] and basic object-oriented optimizations such as call binding based on class hierarchy analysis [3,4]. It uses modern representation techniques such as SSA form and type-based compilation [5,6] to improve optimization and to support precise garbage collection. The runtime system supports multithreading, efficient synchronization and exception mechanisms, and several garbage collectors, including a precise generational collector. Marmot is implemented almost entirely in Java, and is one of its own most demanding test cases.Our experience with Marmot demonstrates that well-known compilation techniques can produce very good performance for static Java applications -comparable or superior to other Java systems, and approaching that of C++ in some cases. Marmot reduces the costs of safety checks in many programs to a modest 5-10 per cent of execution time. Synchronization costs can be quite significant, and optimization techniques to reduce these costs are worth pursuing. Recognizing single threaded programs and optimizing them accordingly can be an important special case. Although Marmot includes a quality generational collector and further reduces the cost of storage by allocating objects with appropriately bounded lifetimes and statically known sizes on the stack, storage management costs can still be significant.We begin this paper by describing and motivating the subset of Java supported by Marmot. Sections 3-5 describe the design and implementation of the native-cod...

Law-governed interaction

“…The development of good Java compilers is underway in many places, and is expected to achieve near native performance [15]. This factor alone should reduce t eval by a factor of 3 or 4 [12].…”

Effective Enhancement of Loop Versioning in Java

“…Organization of the framework is similar to those of other known compilers, e.g. Marmot [9], HPJC [10]. The main advantage of static compilation is that it is performed only once, on a developer's machine and typically, the majority of classes is known at Fig.…”

“…5. The Excelsior's compiler construction framework compile-time 9 . Thus, the compiler is free to employ any time-and memoryexpensive optimization technique, resulting in much better code quality than in the case of dynamic (just-in-time) compilation.…”

“…We find the optimization very useful even for single-processor architectures 12 and plan to implement it in future releases of Excelsior JET. Fitzgerald et al at Microsoft Research, the authors of the Marmot ahead-of-time compiler for Java [9] do not regard the loop versioning optimization. The work [5] describing the architecture of the IBM Just-In-Time compiler for Java, most directly relates to ours.…”

Optimizing Java-Specific Overheads: Java at the Speed of C?

“…Modern JVMs come with a just-in-time compiler (JIT) that combines Java's platform independence with improved application speed [4]. A more radical approach is to completely avoid byte-code interpretation by statically compiling byte code to executable programs [1,7,12]. Combinations of JIT and static compilation are also possible [11].…”