This survey describes research directions in techniques to improve the performance of programs written in the Java programming language. The standard technique for Java execution is interpretation, which provides for extensive portability of programs. A Java interpreter dynamically executes Java bytecodes, which comprise the instruction set of the Java Virtual Machine (JVM). Execution time performance of Java programs can be improved through compilation, possibly at the expense of portability. Various types of Java compilers have been proposed, including Just-In-Time (JIT) compilers that compile bytecodes into native processor instructions on the fly; direct compilers that directly translate the Java source code into the target processor's native language; and bytecode-to-source translators that generate either native code or an intermediate language, such as C, from the bytecodes. Additional techniques, including bytecode optimization, dynamic compilation, and executing Java programs in parallel, attempt to improve Java run-time performance while maintaining Java's portability. Another alternative for executing Java programs is a Java processor that implements the JVM directly in hardware. In this survey, we discuss the basic features, and the advantages and disadvantages, of the various Java execution techniques. We also discuss the various Java benchmarks that are being used by the Java community for performance evaluation of the different techniques. Finally, we conclude with a comparison of the performance of the alternative Java execution techniques based on reported results.

This paper presents a new coarse-grained thread pipelining execution model for exploiting coarse-grained parallelism from general-purpose application programs in shared-memory multiprocessor systems. Based on the fine-grained thread pipelining model proposed for the superthreaded architecture [7], this new model allows concurrent execution of loop iterations with run-time data dependence checking and control speculation. These features allow the parallelization of a variety of program constructs that cannot be parallelized with existing run-time schemes. The pipelined execution of loop iterations results in lower parallelization overhead than in other existing techniques.The performance of this coarse-grained thread pipelining model was evaluated using some real applications and a synthetic benchmark. With a sufficiently large grain size compared to the parallelization overhead, significant speedups are possible. The synthetic benchmark provides a means for estimating the performance of application programs that will be parallelized with this model.

This paper presents a new approach to improve performance of Java programs by extending the superthreaded speculative execution model [14,15]

AbstractÐThis paper presents a new parallelization model, called coarse-grained thread pipelining, for exploiting speculative coarsegrained parallelism from general-purpose application programs in shared-memory multiprocessor systems. This parallelization model, which is based on the fine-grained thread pipelining model proposed for the superthreaded architecture [11], [12], allows concurrent execution of loop iterations in a pipelined fashion with runtime data-dependence checking and control speculation. The speculative execution combined with the runtime dependence checking allows the parallelization of a variety of program constructs that cannot be parallelized with existing runtime parallelization algorithms. The pipelined execution of loop iterations in this new technique results in lower parallelization overhead than in other existing techniques. We evaluated the performance of this new model using some real applications and a synthetic benchmark. These experiments show that programs with a sufficiently large grain size compared to the parallelization overhead obtain significant speedup using this model. The results from the synthetic benchmark provide a means for estimating the performance that can be obtained from application programs that will be parallelized with this model. The library routines developed for this thread pipelining model are also useful for evaluating the correctness of the codes generated by the superthreaded compiler and in debugging and verifying the simulator for the superthreaded processor.