Evaluation and optimization of method calls in Java

Recent advances in Virtual Machine's technology have led to the diffusion of Java execution environments which provide performance levels comparable to those of traditional languages such as C/C++ and Fortran. This paper's focus is on method calls, a well researched area of compilers' optimization. In particular, we evaluate the impact on the performance of the Java virtual call mechanism and the advantages which can be obtained through the inlining optimization. Moreover, we propose a new heuristic methodology which allows us to consider whole sequences of methods for the inlining decision and not only simple couples of caller–callee methods.

[1]  Christian Lengauer,et al.  High-performance Java , 2001, CACM.

[2]  Toshiaki Yasue,et al.  A dynamic optimization framework for a Java just-in-time compiler , 2001, OOPSLA '01.

[3]  Cliff Click,et al.  The Java HotSpot Server Compiler , 2001, Java Virtual Machine Research and Technology Symposium.

[4]  Karel Driesen,et al.  The direct cost of virtual function calls in C++ , 1996, OOPSLA '96.

[5]  Dirk Grunwald,et al.  Quantifying Behavioral Differences Between C and C++ Programs , 1994 .

[6]  Bill Venners,et al.  Inside the Java Virtual Machine , 1997 .

[7]  Craig Chambers,et al.  Towards better inlining decisions using inlining trials , 1994, LFP '94.

[8]  David F. Bacon,et al.  Fast static analysis of C++ virtual function calls , 1996, OOPSLA '96.

[9]  Craig Chambers,et al.  Debugging optimized code with dynamic deoptimization , 1992, PLDI '92.

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

[11]  Robert Wilson,et al.  Compiling Java just in time , 1997, IEEE Micro.

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

[13]  Keith D. Cooper,et al.  An experiment with inline substitution , 1991, Softw. Pract. Exp..

[14]  Scott A. Mahlke,et al.  Profile‐guided automatic inline expansion for C programs , 1992, Softw. Pract. Exp..

[15]  Toshiaki Yasue,et al.  An Empirical Study of Method In-lining for a Java Just-in-Time Compiler , 2002, Java Virtual Machine Research and Technology Symposium.

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

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

[18]  Jack W. Davidson,et al.  A study of a C function inliner , 1988, Softw. Pract. Exp..

[19]  David J. Lilja,et al.  Techniques for obtaining high performance in Java programs , 2000, CSUR.

[20]  Olivier Zendra,et al.  Eecient Dynamic Dispatch without Virtual Function Tables. the Smalleiiel Compiler , 1998 .

[21]  Erik Ruf,et al.  Marmot: an optimizing compiler for Java , 2000 .

[22]  Erik Ruf,et al.  Marmot: an optimizing compiler for Java , 2000, Softw. Pract. Exp..

[23]  Grady Booch,et al.  Object-Oriented Design with Applications , 1990 .

[24]  Alessandro De Gloria,et al.  Invocation profile characterization of Java applications , 2000, 2000 IEEE International Symposium on Performance Analysis of Systems and Software. ISPASS (Cat. No.00EX422).

[25]  Vivek Sarkar,et al.  A comparative study of static and profile-based heuristics for inlining , 2000 .

[26]  Vivek Sarkar,et al.  The Jalape ~ no Dynamic Optimizing Compiler for Java TM , 1999 .

[27]  Michael Philippsen,et al.  Multiparadigm communications in Java for grid computing , 2001, CACM.

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

[29]  Andrew A. Chien,et al.  Precise concrete type inference for object-oriented languages , 1994, OOPSLA 1994.

[30]  Philip J. Hatcher,et al.  Enabling Java for high-performance computing , 2001, CACM.

[31]  Urs Hölzle,et al.  Optimizing dynamically-dispatched calls with run-time type feedback , 1994, PLDI '94.

[32]  Robert Scheifler,et al.  An analysis of inline substitution for a structured programming language , 1977, CACM.

[33]  James F. Power,et al.  Platform independent dynamic Java virtual machine analysis: the Java Grande Forum benchmark suite , 2001, JGI '01.

[34]  Karel Driesen Efficient Polymorphic Calls , 2001 .

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

[36]  Samuel P. Midkiff,et al.  The NINJA project: Making Java Work for High Performance Numerical Computing , 2001 .

[37]  Martin D. Westhead,et al.  A benchmark suite for high performance Java , 2000, Concurr. Pract. Exp..

[38]  Narayanan Vijaykrishnan,et al.  Java Runtime Systems: Characterization and Architectural Implications , 2001, IEEE Trans. Computers.

[39]  STEPHEN RICHARDSON,et al.  Interprocedural optimization: Experimental results , 1989, Softw. Pract. Exp..

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

[41]  David S. Johnson,et al.  Computers and Intractability: A Guide to the Theory of NP-Completeness , 1978 .

[42]  David Detlefs,et al.  Inlining of Virtual Methods , 1999, ECOOP.

[43]  Henri E. Bal,et al.  Optimizing Java-Specific Overheads: Java at the Speed of C? , 2001, HPCN Europe.

[44]  J. Mark Bull,et al.  Benchmarking Java against C and Fortran for scientific applications , 2001, JGI '01.

[45]  Thomas W. Reps,et al.  Interprocedural Path Profiling , 1999, CC.