Blended analysis for performance understanding of framework-based applications

This paper defines a new analysis paradigm, blended program analysis, that enables practical, effective analysis of large framework-based Java applications for performance understanding. Blended analysis combines a dynamic representation of the program calling structure, with a static analysis applied to a region of that calling structure with observed performance problems. A blended escape analysis is presented which enables approximation of object effective lifetimes, to facilitate explanation of the usage of newly created objects in a program region. Performance bottlenecks stemming from overuse of temporary structures are common in framework-based applications. Metrics are introduced to expose how, in aggregate, these applications make use of new objects. Results of empirical experiments with the Trade benchmark are presented. A case study demonstrates how results from a blended escape analysis can help locate, in a region which calls 223 distinct methods, the single call path responsible for a performance problem involving objects created at 9 distinct sites and as far as 6 call levels away.

[1]  Urs Hölzle,et al.  Removing unnecessary synchronization in Java , 1999, OOPSLA '99.

[2]  Nick Mitchell,et al.  Modeling Runtime Behavior in Framework-Based Applications , 2006, ECOOP.

[3]  Kavitha Srinivas,et al.  Summarizing application performance from a components perspective , 2005, ESEC/FSE-13.

[4]  Rastislav Bodík,et al.  Jungloid mining: helping to navigate the API jungle , 2005, PLDI '05.

[5]  Nick Mitchell,et al.  Visualizing the Execution of Java Programs , 2001, Software Visualization.

[6]  Markus Mock,et al.  Improving program slicing with dynamic points-to data , 2002, SIGSOFT '02/FSE-10.

[7]  Kathryn S. McKinley,et al.  Generating object lifetime traces with Merlin , 2006, TOPL.

[8]  Robert F. Berry,et al.  A unifying approach to performance analysis in the Java environment , 2000, IBM Syst. J..

[9]  Neil D. Jones,et al.  Flow analysis and optimization of LISP-like structures , 1979, POPL.

[10]  John Howard,et al.  Hybrid slicing: integrating dynamic information with static analysis , 1997, TSEM.

[11]  David Gay,et al.  Fast Escape Analysis and Stack Allocation for Object-Based Programs , 2000, CC.

[12]  David Grove,et al.  A framework for call graph construction algorithms , 2001, TOPL.

[13]  Barbara G. Ryder Dimensions of Precision in Reference Analysis of Object-Oriented Programming Languages , 2003, CC.

[14]  Jong-Deok Choi,et al.  Finding and Removing Performance Bottlenecks in Large Systems , 2004, ECOOP.

[15]  Jong-Deok Choi,et al.  Stack allocation and synchronization optimizations for Java using escape analysis , 2003, TOPL.

[16]  Nick Mitchell,et al.  The Runtime Structure of Object Ownership , 2006, ECOOP.

[17]  Alex Groce,et al.  Exploiting Traces in Program Analysis , 2006, TACAS.

[18]  Michael Franz,et al.  Efficiently Verifiable Escape Analysis , 2004, ECOOP.

[19]  Nick Mitchell,et al.  LeakBot: An Automated and Lightweight Tool for Diagnosing Memory Leaks in Large Java Applications , 2003, ECOOP.

[20]  Martin C. Rinard,et al.  Compositional pointer and escape analysis for Java programs , 1999, OOPSLA '99.

[21]  Michael D. Ernst Static and dynamic analysis: synergy and duality , 2003 .

[22]  Jong-Deok Choi,et al.  Accurate, efficient, and adaptive calling context profiling , 2006, PLDI '06.

[23]  James R. Larus,et al.  Exploiting hardware performance counters with flow and context sensitive profiling , 1997, PLDI '97.

[24]  Mooly Sagiv,et al.  Estimating the impact of heap liveness information on space consumption in Java , 2002, ISMM '02.

[25]  Bruno Blanchet,et al.  Escape analysis for object-oriented languages: application to Java , 1999, OOPSLA '99.

[26]  David Glasser,et al.  Combined static and dynamic mutability analysis , 2007, ASE '07.

[27]  Neil D. Jones,et al.  Program Flow Analysis: Theory and Application , 1981 .