JOHANNESKEPLER UNIVERSITYLINZ Research and teaching network Thomas Kotzmann Escape Analysis in the Context of Dynamic Compilation and Deoptimization A PhD thesis submitted in partial satisfaction of the requirements for the degree of Doctor of Technical Sciences Institute for System Software Johannes Kepler University Linz accepted on the recommendation of o.Univ.-Prof. Dipl.-Ing. Dr. Hanspeter MÄossenbÄock a.Univ.-Prof. Dipl.-Ing. Dr. Andreas Krall Linz, October 2005 Johannes Kepler University Linz 4040 Linz – Austria • Altenberger Straße 69 • Internet: http://www.jku.at • DVR 0093696 Sun, Sun Microsystems, Java, HotSpot and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. Other product and company names mentioned in this document may be the trademarks of their respective owners. Abstract Escape analysis is used in compilers to identify and optimize the allocation of objects that are accessible only within the allocating method or thread. This thesis presents a new intra- and interprocedural analysis for a dynamic compiler, which has to cope with dynamic class loading and deoptimization. The analysis was implemented for Sun Microsystems' Java HotSpot client com- piler. It operates on an intermediate representation in SSA form and introduces equi-escape sets for the e±cient propagation of escape information between re- lated objects. Analysis results are used for scalar replacement of ¯elds, stack allocation of objects and synchronization removal. The interprocedural analysis supports the compiler in inlining decisions and allows actual parameters to be al- located in the stack frame of the caller. A lightweight bytecode analysis produces interprocedural escape information for methods that have not been compiled yet. Dynamic class loading possibly invalidates the generated machine code. In this case, the execution of a method is continued in the interpreter. This is called deoptimization. Since the interpreter does not know about scalar replacement, stack allocation or synchronization removal, the deoptimization framework was extended to reallocate and relock objects on demand. Kurzfassung Escape-Analyse identi¯ziert und optimiert die Allokation von Objekten, auf die nur eine Methode oder ein Thread zugreifen kann. Diese Dissertation prÄasentiert eine neue intra- und interprozedurale Analyse fÄureinen Just-in-Time-Compiler, der dynamisches Laden von Klassen und Deoptimierung unterstÄutzt. Die Analyse wurde fÄurden Java HotSpot Client Compiler von Sun Microsystems implementiert. Sie arbeitet auf einer Zwischensprache in SSA-Form und verwaltet voneinander abhÄangigeObjekte e±zient in Mengen. Die Ergebnisse werden ver- wendet, um Felder durch skalare Variablen zu ersetzen, Objekte am Stack anzule- gen und Synchronisation zu entfernen. Die interprozedurale Analyse unterstÄutzt den Compiler bei Inline-Entscheidungen und identi¯ziert Methodenparameter, die am Stack angelegt werden kÄonnen. Eine schnelle Bytecode-Analyse liefert Informationen fÄurMethoden, die noch nicht compiliert wurden. Dynamisches Laden von Klassen kann bestehenden Maschinencode invalidieren. In diesem Fall wird die AusfÄuhrungder Methode im Interpreter fortgesetzt. Dies nennt man Deoptimierung. Da der Interpreter die Optimierungen des Compilers nicht kennt, wurde das Framework zur Deoptimierung so erweitert, dass es Ob- jekte nachtrÄaglich am Heap anlegt und sperrt. Contents 1 Introduction 1 1.1 Java ................................. 1 1.2 Java HotSpot VM .......................... 2 1.2.1 Memory Management ................... 2 1.2.2 Interpretation and Hot Spot Detection .......... 3 1.2.3 Server Compiler ....................... 4 1.2.4 Client Compiler ....................... 5 1.3 Optimizations in Just-in-Time Compilers ............. 6 1.4 Problem Statement ......................... 6 1.5 Project History ........................... 7 1.6 Structure of the Thesis ....................... 8 2 The HotSpot Client Compiler 10 2.1 Java Bytecodes ........................... 10 2.2 Overall Compiler Architecture ................... 12 2.3 Front End .............................. 12 2.3.1 Control Flow Graph .................... 13 2.3.2 Static Single Assignment Form .............. 13 2.3.3 High-Level Intermediate Representation ......... 14 2.3.4 Optimizations ........................ 16 2.4 Back End .............................. 17 2.4.1 Low-Level Intermediate Representation .......... 17 2.4.2 Register Allocation ..................... 19 2.4.3 Code Generation ...................... 20 2.4.4 Focus on the Common Case ................ 22 2.4.5 Debugging Information ................... 22 3 Escape Analysis 24 3.1 Motivation .............................. 24 3.2 De¯nition of Terms ......................... 26 3.2.1 Escape States ........................ 26 3.2.2 Equi-Escape Sets ...................... 27 3.2.3 Referential Dependency .................. 29 ii Contents 3.3 Intraprocedural Analysis ...................... 31 3.4 Interprocedural Analysis ...................... 33 3.4.1 Escape of Parameters .................... 33 3.4.2 Analysis of Bytecodes ................... 35 3.5 Example ............................... 37 4 Scalar Replacement 41 4.1 Overview ............................... 41 4.2 Object-Related Costs ........................ 42 4.3 Analysis of Basic Blocks ...................... 45 4.4 Analysis of Control Flow ...................... 46 4.4.1 Phi Functions for Fields .................. 47 4.4.2 Alias E®ects ......................... 48 4.4.3 Method Inlining ....................... 49 4.4.4 Selective Creation of Phi Functions ............ 51 4.5 Adaptation of the Back End .................... 53 4.6 Veri¯cation Code .......................... 54 4.7 Example ............................... 55 5 Thread-Local Optimizations 58 5.1 Stack Allocation ........................... 58 5.1.1 Stack Layout ........................ 59 5.1.2 Allocation of Stack Objects ................ 60 5.1.3 Field Access ......................... 61 5.1.4 Write Barriers ........................ 63 5.2 Synchronization Removal ...................... 66 5.2.1 Object Locking ....................... 66 5.2.2 Synchronization on Thread-Local Objects ........ 67 5.2.3 Inlining of Synchronized Methods ............. 69 6 Run-Time Support 72 6.1 Debugging Information ....................... 72 6.1.1 Scope Entries ........................ 73 6.1.2 Object Entries ....................... 74 6.1.3 Monitor Entries ....................... 75 6.1.4 Oop Map .......................... 76 6.1.5 Serialization ......................... 77 6.2 Deoptimization ........................... 78 6.2.1 Motivation .......................... 78 6.2.2 Method Dependencies ................... 79 6.2.3 Basic Deoptimization Process ............... 80 6.2.4 Reallocation and Relocking ................ 81 6.2.5 Deoptimization of Stack Objects .............. 82 Contents iii 6.3 Garbage Collection ......................... 83 6.3.1 Wrapper Closure ...................... 84 6.3.2 Root Pointers for Stack Objects .............. 85 7 Evaluation 87 7.1 CompileTheWorld .......................... 87 7.2 SPECjvm98 ............................. 89 7.2.1 mtrt ............................. 90 7.2.2 db .............................. 92 7.2.3 jack ............................. 92 7.2.4 Overall Performance .................... 94 7.3 SciMark 2.0 ............................. 96 8 Related Work 99 8.1 Overview ............................... 99 8.1.1 History of Escape Analysis ................. 99 8.1.2 Pointer Analysis ...................... 100 8.1.3 Escape Analysis for Java .................. 101 8.2 Program Abstraction ........................ 104 8.2.1 Connection Graph ..................... 104 8.2.2 Points-To Escape Graph .................. 105 8.2.3 Escape Context ....................... 107 8.2.4 Alias Set ........................... 108 8.3 Interprocedural Analysis ...................... 109 8.3.1 Phantom Nodes ....................... 110 8.3.2 Incremental Escape Analysis ................ 111 8.3.3 Context Transformers ................... 112 8.4 Results ................................ 113 8.5 Write Barrier Removal ....................... 114 8.5.1 Kinds of Barriers ...................... 114 8.5.2 Removal of Generational Write Barriers .......... 116 8.5.3 Removal of SATB Write Barriers ............. 117 8.6 Debugging and Deoptimization .................. 118 8.6.1 Debugging Information ................... 118 8.6.2 Deoptimization ....................... 119 9 Summary 121 9.1 Contributions ............................ 121 9.2 The Big Picture ........................... 122 9.2.1 Intraprocedural Analysis .................. 123 9.2.2 Inlining of Synchronized Methods ............. 124 9.2.3 Interprocedural Analysis .................. 124 9.2.4 Optimizations ........................ 125 iv Contents 9.2.5 Debugging Information ................... 126 9.3 Future Work ............................. 126 9.3.1 More Aggressive Optimizations .............. 126 9.3.2 Escape Analysis in the Server Compiler .......... 127 9.3.3 Automatic Object Inlining ................. 128 9.4 Conclusions ............................. 129 Bibliography 130 Index 140 Acknowledgments A lot of people have contributed to this work. First and foremost, I thank my advisor Hanspeter MÄossenbÄock, without whose support and encouragement this thesis had not been possible. Likewise, I thank Andreas Krall from the Vienna University of Technology for the examination of my thesis. I want to thank