Exploring the Interaction between Java's Implicitly Thrown Exceptions and Instruction Scheduling

The frequent occurrence of implicitly thrown exceptions poses one of the challenges present in a Java compiler. Not only do these implicitly thrown exceptions directly affect the performance by requiring explicit checks, they also indirectly impact the performance by restricting code movement in order to satisfy the precise exception model in Java. In particular, instruction scheduling is one transformation that is restricted by implicitly thrown exceptions due to the heavy reliance on reordering instructions to exploit maximum hardware performance. The goal of this study is two-fold: first, investigate the degree to which implicitly thrown exceptions in Java hinder instruction scheduling, and second, find new techniques for allowing more efficient execution of Java programs containing implicitly thrown exceptions. Experimental results show that with aggressive scheduling techniques, such as superblock scheduling, the negative performance impact can be greatly reduced.

[1]  Joseph A. Fisher,et al.  Trace Scheduling: A Technique for Global Microcode Compaction , 1981, IEEE Transactions on Computers.

[2]  Jong-Deok Choi,et al.  Efficient and precise modeling of exceptions for the analysis of Java programs , 1999, PASTE '99.

[3]  Ken Arnold,et al.  The Java Programming Language, Second Edition , 1999 .

[4]  Erik R. Altman,et al.  Daisy: Dynamic Compilation For 10o?40 Architectural Compatibility , 1997, Conference Proceedings. The 24th Annual International Symposium on Computer Architecture.

[5]  James M. Stichnoth,et al.  Practicing JUDO: Java under dynamic optimizations , 2000, PLDI '00.

[6]  Barbara G. Ryder,et al.  A Static Study of Java Exceptions Using JESP , 2000, CC.

[7]  Scott A. Mahlke,et al.  Integrated predicated and speculative execution in the IMPACT EPIC architecture , 1998, ISCA.

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

[9]  Simon L. Peyton Jones,et al.  A semantics for imprecise exceptions , 1999, PLDI '99.

[10]  Jong-Deok Choi,et al.  Optimizing Java Programs in the Presence of Exceptions , 2000, ECOOP.

[11]  Andrew Gelsey,et al.  A search space toolkit: SST , 1996, Decis. Support Syst..

[12]  Scott A. Mahlke,et al.  The superblock: An effective technique for VLIW and superscalar compilation , 1993, The Journal of Supercomputing.

[13]  Bich C. Le,et al.  An out-of-order execution technique for runtime binary translators , 1998, ASPLOS VIII.

[14]  Thomas Ellman,et al.  Knowledge-based re-engineering of legacy programs for robustness in automated design , 1996, Proceedings of the 11th Knowledge-Based Software Engineering Conference.

[15]  David I. August,et al.  Sentinel Scheduling with Recovery Blocks , 1995 .

[16]  Martin P. Robillard,et al.  Analyzing exception flow in Java programs , 1999, ESEC/FSE-7.

[17]  David A. Patterson,et al.  Computer Architecture: A Quantitative Approach , 1969 .

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

[19]  Scott Mahlke,et al.  Sentinel scheduling: a model for compiler-controlled speculative execution , 1993 .

[20]  Vivek Sarkar,et al.  ABCD: eliminating array bounds checks on demand , 2000, PLDI '00.

[21]  이승일 Efficient Java exception handling in Just-in-Time compilation , 2000 .

[22]  K. Ebcioglu,et al.  Daisy: Dynamic Compilation For 10o?40 Architectural Compatibility , 1997, Conference Proceedings. The 24th Annual International Symposium on Computer Architecture.

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

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

[25]  Stephen J. Fink,et al.  The Jalapeño virtual machine , 2000, IBM Syst. J..

[26]  Scott Mahlke,et al.  Speculative execution exception recovery using write-back suppression , 1993, MICRO 1993.

[27]  Vivek Sarkar,et al.  Dependence Analysis for Java , 1999, LCPC.

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

[29]  Samuel P. Midkiff,et al.  From Flop to MegaFlops: Java for Technical Computing , 1998, LCPC.

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

[31]  D. Smith,et al.  A Search Space Toolkit , 1995, Proceedings the 11th Conference on Artificial Intelligence for Applications.