Techniques for obtaining high performance in Java programs

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 bytecode 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 basis 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.

[1]  Charles Consel,et al.  Harissa: A Flexible and Efficient Java Environment Mixing Bytecode and Compiled Code , 1997, COOTS.

[2]  Mike O'Connor,et al.  PicoJava: A Direct Execution Engine For Java Bytecode , 1998, Computer.

[3]  Samuel P. Midkiff,et al.  Java programming for high-performance numerical computing , 2000, IBM Syst. J..

[4]  Satoshi Matsuoka,et al.  OpenJIT—A Reflective Java JIT Compiler , 2000 .

[5]  Scott A. Mahlke,et al.  IMPACT: an architectural framework for multiple-instruction-issue processors , 1991, ISCA '91.

[6]  Wei Li,et al.  Optimizing Java bytecodes , 1997, Concurr. Pract. Exp..

[7]  John H. Hartman,et al.  Toba: Java for Applications - A Way Ahead of Time (WAT) Compiler , 1997, COOTS.

[8]  Michael Philippsen,et al.  JavaParty - Transparent Remote Objects in Java , 1997, Concurr. Pract. Exp..

[9]  James Gosling,et al.  The Feel of Java , 1997, Computer.

[10]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[11]  Frank Tip,et al.  Class hierarchy specialization , 1997, OOPSLA '97.

[12]  Frank Tip,et al.  Practical experience with an application extractor for Java , 1999, OOPSLA '99.

[13]  Chandra Krintz,et al.  Reducing transfer delay using Java class file splitting and prefetching , 1999, OOPSLA '99.

[14]  David Grove,et al.  Vortex: an optimizing compiler for object-oriented languages , 1996, OOPSLA '96.

[15]  Erik R. Altman,et al.  A JAVA ILP Machine Based on Fast Dynamic Compilation , 1997 .

[16]  David Grove,et al.  Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis , 1995, ECOOP.

[17]  Laxmikant V. Kalé,et al.  Design and Implementation of Parallel Java with Global Object Space , 1997, PDPTA.

[18]  David J. Lilja,et al.  JavaSpMT: A speculative thread pipelining parallelization model for Java programs , 2000, Proceedings 14th International Parallel and Distributed Processing Symposium. IPDPS 2000.

[19]  Andreas Krall,et al.  CACAO - A 64-bit JavaVM Just-in-Time Compiler , 1997, Concurr. Pract. Exp..

[20]  Narayanan Vijaykrishnan,et al.  Object-Oriented Architectural Support for a Java Processor , 1998, ECOOP.

[21]  Andreas Krall,et al.  Monitors and Exceptions: How to Implement Java Efficiently , 1998, Concurr. Pract. Exp..

[22]  Ali-Reza Adl-Tabatabai,et al.  Fast, effective code generation in a just-in-time Java compiler , 1998, PLDI.

[23]  Michael Wolfe,et al.  High performance compilers for parallel computing , 1995 .

[24]  Scott A. Mahlke,et al.  IMPACT: An Architectural Framework for Multiple-Instruction-Issue Processors , 1998, 25 Years ISCA: Retrospectives and Reprints.

[25]  Todd A. Proebsting Simple and efficient BURS table generation , 1992, PLDI '92.

[26]  Wei Li,et al.  Optimizing Java bytecodes , 1997 .

[27]  Wei Li,et al.  Just‐in‐time optimizations for high‐performance Java programs , 1997 .

[28]  Denis Caromel,et al.  Towards Seamless Computing and Metacomputing in Java , 1998, Concurr. Pract. Exp..

[29]  Toshiaki Yasue,et al.  Design, implementation, and evaluation of optimizations in a just-in-time compiler , 1999, JAVA '99.

[30]  Jean-Louis Pazat,et al.  A Framework for Parallel Programming in JAVA , 1998, HPCN Europe.

[31]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[32]  Ken Arnold,et al.  The Java Programming Language , 1996 .

[33]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[34]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[35]  Ken Arnold,et al.  The Java programming language (2nd ed.) , 1998 .

[36]  Geoffrey C. Fox,et al.  HPJava: Data Parallel Extensions to Java , 1998, Concurr. Pract. Exp..

[37]  J. Michael O'Connor,et al.  picoJava-I: the Java virtual machine in hardware , 1997, IEEE Micro.

[38]  Toshiaki Yasue,et al.  Overview of the IBM Java Just-in-Time Compiler , 2000, IBM Syst. J..

[39]  Andreas Krall,et al.  Monitors and exceptions: how to implement Java efficiently , 1998 .

[40]  David J. Lilja,et al.  Measuring computer performance : A practitioner's guide , 2000 .

[41]  Aart J. C. Bik,et al.  Automatically exploiting implicit parallelism , 2001 .

[42]  Aart J. C. Bik,et al.  Automatically exploiting implicit parallelism in Java , 1997, Concurr. Pract. Exp..

[43]  John C. Gyllenhaal,et al.  Java bytecode to native code translation: the Caffeine prototype and preliminary results , 1996, Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture. MICRO 29.

[44]  John C. Gyllenhaal,et al.  Optimizing NET Compilers for Improved Java Performance , 1997, Computer.

[45]  Aart J. C. Bik,et al.  Automatically exploiting implicit parallelism in Java , 1997 .

[46]  Alexandru Nicolau,et al.  Java annotation-aware just-in-time (AJIT) complilation system , 1999, JAVA '99.

[47]  Yves Roudier,et al.  Integrating data-parallel and reactive constructs into Java , 1997 .

[48]  Aart J. C. Bik,et al.  A prototype bytecode parallelization tool , 1998 .

[49]  Frank Yellin,et al.  The Java Virtual Machine Specification , 1996 .

[50]  Troy Downing,et al.  Java Virtual Machine , 1997 .