A study of exception handling and its dynamic optimization in Java

Optimizing exception handling is critical for programs that frequently throw exceptions. We observed that there are many such exception-intensive programs iin various categories of Java programs. There are two commonly used exception handling techniques, stack unwinding optimizes the normal path, while stack cutting optimizes the exception handling path. However, there has been no single exception handling technique to optimize both paths.

[1]  Simon L. Peyton Jones,et al.  A single intermediate language that supports multiple implementations of exceptions , 2000, PLDI '00.

[2]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[3]  Dennis Gannon,et al.  Proceedings of the ACM 2000 conference on Java Grande , 2000 .

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

[5]  Robecca J. Wirfs-Brock.  Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applications , 1995, OOPSLA 1995.

[6]  Toshio Nakatani,et al.  Effective null pointer check elimination utilizing hardware trap , 2000, SIGP.

[7]  Theodore P. Baker,et al.  Implementing Ada Exceptions , 1986, IEEE Software.

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

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

[10]  John L. Hennessy,et al.  Program optimization and exception handling , 1981, POPL '81.

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

[12]  KawahitoMotohiro,et al.  Effective null pointer check elimination utilizing hardware trap , 2000 .

[13]  David Grove,et al.  Profile-guided receiver class prediction , 1995, OOPSLA.

[14]  ChoiJong-Deok,et al.  Efficient and precise modeling of exceptions for the analysis of Java programs , 1999 .

[15]  Saurabh Sinha,et al.  Analysis and Testing of Programs with Exception Handling Constructs , 2000, IEEE Trans. Software Eng..

[16]  John Whaley,et al.  A portable sampling-based profiler for Java virtual machines , 2000, JAVA '00.

[17]  Narain H. Gehani,et al.  Exceptional C or C with exceptions , 1992, Softw. Pract. Exp..

[18]  Toshiaki Yasue,et al.  A study of devirtualization techniques for a Java Just-In-Time compiler , 2000, OOPSLA '00.

[19]  Andreas Paepcke,et al.  Conference proceedings on Object-oriented programming systems, languages, and applications , 1991, Conference on Object-Oriented Programming Systems, Languages, and Applications.

[20]  Christophe de Dinechin.  C++ exception handling , 2000, IEEE Concurr..

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

[22]  Urs Hölzle,et al.  Type feedback vs. concrete type inference: a comparison of optimization techniques for object-oriented languages , 1995, OOPSLA.

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

[24]  P. Carini.  ReportFlow-Sensitive Type Analysis for C + + , 1995 .

[25]  Thomas M. Conte,et al.  The Effect of Code Expanding Optimizations on Instruction Cache Design , 1993, IEEE Trans. Computers.

[26]  Andrew Ayers,et al.  Aggressive inlining , 1997, PLDI '97.

[27]  Laurie J. Hendren,et al.  Efficient Inference of Static Types for Java Bytecode , 2000, SAS.

[28]  Bjarne Stroustrup,et al.  Exception handling for c++ (revised) , 1990 .

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

[30]  Jens Palsberg,et al.  Object-oriented type inference , 1991, OOPSLA '91.

[31]  Steven J. Drew,et al.  Implementing Zero Overhead Exception Handling , 1995 .

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

[33]  Seungil Lee,et al.  On-Demand Translation of Java Exception Handlers in the LaTTe JVM Just-in-Time Compiler , 1999 .

[34]  Toshiaki Yasue,et al.  Design, implementation, and evaluation of optimizations in a JavaTM Just-In-Time compiler , 2000 .

[35]  Craig Chambers,et al.  Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches , 1991, ECOOP.

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

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

[38]  Barbara G. Ryder,et al.  Complexity of Concrete Type-Inference in the Presence of Exceptions , 1998, ESOP.

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

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

[41]  Alan Snyder,et al.  Exception Handling in CLU , 1979, IEEE Transactions on Software Engineering.

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

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

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

[45]  Cliff Click,et al.  The java hotspot TM server compiler , 2001 .

[46]  Dirk Grunwald,et al.  Reducing indirect function call overhead in C++ programs , 1994, POPL '94.

[47]  Dmitry Lenkov,et al.  A Portable implementation of C++ Exception Handling , 1992, C++ Conference.

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

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

[50]  Jonathan L. Schilling.  Optimizing away C++ exception handling , 1998, SIGP.

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

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

[53]  Urs Hölzle,et al.  Eliminating Virtual Function Calls in C++ Programs , 1996, ECOOP.

[54]  David B. Stewart,et al.  A study of the applicability of existing exception-handling techniques to component-based real-time software technology , 1998, TOPL.

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

[56]  Erik R. Altman,et al.  Efficient Java exception handling in just-in-time compilation , 2000, JAVA '00.

[57]  Matthew Arnold,et al.  Adaptive optimization in the Jalapeño JVM , 2000, OOPSLA '00.