This paper describes an empirical study of the SPECjvm98 benchmarks, using the Jalape~no virtual machine. The study employs two compilers, a nonoptimizing compiler that is initially used to compile all application methods, and an optimizing compiler that is selectively used to recompile a parameterized set of hot methods based on past profiling. We view this study as a step in examining the feasibility of adaptive optimization in this environment. The results show promise for adaptive optimization. In particular, they show that the combined time (execution and compilation) of selective opt-compilation can be less than the execution time of no opt-compilation and the combined time of full opt-compilation. The results also show that the combined time of selective opt-compilation can be competitive with static compilation (full opt-compilation not counting compilation time) for the SPECjvm98 benchmarks with input size 100. 1 Introduction One technique for increasing the efficie...

: We are building an infrastructure for the platform-independent distribution and execution of high-performance mobile code as a future Internet technology to complement and perhaps eventually succeed Java. Key to our architecture is a representation for mobile code that is based on adaptive compression of syntax trees. Not only is this representation more than twice as dense as Java byte-codes, but it also encodes semantic information on a much higher level. Unlike linear abstract-machine representations such as p-code and Java byte-codes, our format preserves structural information that is directly beneficial for advanced code optimizations. Our architecture provides fast on-the-fly native-code generation at load time. To increase performance further, a low-priority compilation thread continually re-optimizes the already executing software base in the background. Since this is strictly a re-compilation of already existing code, and since it occurs completely in the backgro...

The unit of compilation for traditional just-in-time compilers is the method. We have explored trace-based compilation, in which the unit of compilation is a loop, potentially spanning multiple methods and even library code. Using a new intermediate representation that is discovered and updated lazily on-demand while the program is being executed, our compiler generates code that is competitive with traditional dynamic compilers, but that uses only a fraction of the compile time and memory footprint. Categories and Subject Descriptors D.3.4 [Programming Languages]: Processors—Incremental compilers; optimization

Abstract not found

The dynamic nature of the Java programming language presents a number of challenges for Java Virtual Machine (JVM) implementations. Constructs such as dynamic class load-ing and reflection make traditional whole program analysis and optimization difficult, or even impossible; however, Java’s dynamic execution environment also presents a potential performance advantage over the traditional static compilation model: the ability to per-form feedback-directed optimizations, where profiling information is collected at runtime and used to tailor the optimization decisions that are made. Although previous work has shown that feedback-directed optimizations can substan-tially improve program performance, most of these systems used offline profiles collected using a separate training run. Performing profiling and optimization online during the same run is an attractive approach because it avoids the need for a separate training run. Unfortunately, the overhead of collecting online profiles is often a problem, and is one of the main reasons why today’s JVM’s perform only limited forms of feedback-directed optimizations. The first contribution of this thesis is a new technique called an instrumentation sam-

Abstract. Trace-based compilers operate by dynamically discovering loop headers and then recording and compiling all paths through a loop that are executed with sufficient frequency. The different paths through each loop form a tree, with the loop header at the root, in which common code is shared up-stream. Such trace-trees can be serialized in a specific manner that allows us to organize the compiler pipeline as a series of filters. We have implemented such a compiler pipeline that has completely linear runtime behavior. Further, it has only two write barriers, meaning that substantial parts of the compilation effort could potentially be parallelized on future multi-core platforms. 1

. We present a technique to measure and detect changes in the behavioral patterns of applications. In a continually dynamically optimizing system, such information is useful not only to decide which program parts to optimize, but also which previously optimized program parts to re-optimize. This leads to a system that is better tailored towards users' needs than statically optimized systems. 1 Introduction Lately, several systems have been proposed for dynamic program optimization. These systems no longer optimize applications at compile time but rather perform optimizations incrementally while the code is being executed. Besides being able to optimize portable applications (e.g., Java binaries), these systems have additional uncontested advantages: they enable intermodular optimizations and allow optimizations to take into account "up-to-the-minute" profiling data, which often enhances the code quality beyond what is commonly achievable with static compilation. One of the key issues...

. Despite the apparent success of the Java Virtual Machine, its lackluster performance makes it ill-suited for many speed-critical applications. Although the latest just-in-time compilers and dedicated Java processors try to remedy this situation, optimized code compiled directly from a C program source is still considerably faster than software transported via Java byte-codes. This is true even if the Java byte-codes are subsequently further translated into native code. In this paper, we claim that these performance penalties are not a necessary consequence of machine-independence, but related to Java's particular intermediate representation and runtime architecture. We have constructed a prototype and are further developing a software transportability scheme founded on a tree-based alternative to Java bytecodes. This tree-based intermediate representation is not only twice as compact as Java byte-codes, but also contains more high-level information, some of which is cri...

. We present a technique to measure and detect changes in the behavioral patterns of applications. In a continually dynamically optimizing system, such information is useful not only to decide which program parts to optimize, but also which previously optimized program parts to re-optimize. This leads to a system that is better tailored towards users' needs than statically optimized systems. 1 Introduction Lately, several systems have been proposed for dynamic program optimization. These systems no longer optimize applications at compile time but rather perform optimizations incrementally while the code is being executed. Besides being able to optimize portable applications (e.g., Java binaries), these systems have additional uncontested advantages: they enable intermodular optimizations and allow optimizations to take into account "up-to-the-minute" profiling data, which often enhances the code quality beyond what is commonly achievable with static compilation. One of the key ...