1 /*
2 * Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package com.sun.hotspot.tools.compiler;
26
27 import java.io.PrintStream;
28 import java.util.ArrayDeque;
29 import java.util.ArrayList;
30 import java.util.List;
31
32 /**
33 * Representation of a compilation scope in a compilation log. This class is a
34 * hybrid: its instances can represent original scopes of methods being
35 * compiled, but are also used to represent call sites in given methods.
36 */
37 public class CallSite {
38
39 /**
40 * The index of the call in the caller. This will be 0 if this instance
41 * represents a compilation root.
42 */
43 private int bci;
44
45 /**
46 * The method that is called at this call site. This will be {@code null}
47 * if this instance represents a compilation root.
48 */
49 private Method method;
50
51 /**
52 * The invocation count for this call site.
53 */
54 private int count;
55
56 /**
57 * The receiver type of the call represented by this instance, if known.
58 */
59 private String receiver;
60
61 /**
62 * In case the {@linkplain receiver receiver type} of the call represented
63 * by this instance is known, this is how often the type was encountered.
64 */
65 private int receiver_count;
66
67 /**
68 * The reason for a success or failure of an inlining operation at this
69 * call site.
70 */
71 private String reason;
72
73 /**
74 * A list of all calls in this compilation scope.
75 */
76 private List<CallSite> calls;
77
78 /**
79 * Number of nodes in the graph at the end of parsing this compilation
80 * scope.
81 */
82 private int endNodes;
83
84 /**
85 * Number of live nodes in the graph at the end of parsing this compilation
86 * scope.
87 */
88 private int endLiveNodes;
89
90 /**
91 * Time in seconds since VM startup at which parsing this compilation scope
92 * ended.
93 */
94 private double timeStamp;
95
96 /**
97 * The inline ID in case the call represented by this instance is inlined,
98 * 0 otherwise.
99 */
100 private long inlineId;
101
102 /**
103 * List of uncommon traps in this compilation scope.
104 */
105 private List<UncommonTrap> traps;
106
107 /**
108 * Default constructor: used to create an instance that represents the top
109 * scope of a compilation.
110 */
111 CallSite() {}
112
113 /**
114 * Constructor to create an instance that represents an actual method call.
115 */
116 CallSite(int bci, Method m) {
117 this.bci = bci;
118 this.method = m;
119 }
120
121 /**
122 * Add a call site to the compilation scope represented by this instance.
123 */
124 void add(CallSite site) {
125 if (getCalls() == null) {
126 calls = new ArrayList<>();
127 }
128 getCalls().add(site);
129 }
130
131 /**
132 * Return the last of the {@linkplain #getCalls() call sites} in this
133 * compilation scope.
134 */
135 CallSite last() {
136 return getCalls().get(getCalls().size() - 1);
137 }
138
139 /**
140 * Return the last-but-one of the {@linkplain #getCalls() call sites} in
141 * this compilation scope.
142 */
143 CallSite lastButOne() {
144 return getCalls().get(getCalls().size() - 2);
145 }
146
147 public String toString() {
148 StringBuilder sb = new StringBuilder();
149 if (getReason() == null) {
150 sb.append(" @ " + getBci() + " " + getMethod());
151 } else {
152 sb.append("- @ " + getBci() + " " + getMethod() + " " + getReason());
153 }
154 sb.append("\n");
155 if (getCalls() != null) {
156 for (CallSite site : getCalls()) {
157 sb.append(site);
158 sb.append("\n");
159 }
160 }
161 return sb.toString();
162 }
163
164 public void print(PrintStream stream) {
165 print(stream, 0, true, false);
166 }
167
168 void emit(PrintStream stream, int indent) {
169 for (int i = 0; i < indent; i++) {
170 stream.print(' ');
171 }
172 }
173
174 public void print(PrintStream stream, int indent, boolean printInlining, boolean printUncommonTraps) {
175 emit(stream, indent);
176 String m = getMethod().getHolder() + "::" + getMethod().getName();
177 if (getReason() == null) {
178 stream.print(" @ " + getBci() + " " + m + " (" + getMethod().getBytes() + " bytes)");
179 } else {
180 stream.print(" @ " + getBci() + " " + m + " " + getReason());
181 }
182 stream.printf(" (end time: %6.4f", getTimeStamp());
183 if (getEndNodes() > 0) {
184 stream.printf(" nodes: %d live: %d", getEndNodes(), getEndLiveNodes());
185 }
186 stream.println(")");
187
188 if (getReceiver() != null) {
189 emit(stream, indent + 4);
190 stream.println("type profile " + getMethod().getHolder() + " -> " + getReceiver() + " (" +
191 (getReceiverCount() * 100 / getCount()) + "%)");
192 }
193 if (printInlining && getCalls() != null) {
194 for (CallSite site : getCalls()) {
195 site.print(stream, indent + 2, printInlining, printUncommonTraps);
196 }
197 }
198 if (printUncommonTraps && getTraps() != null) {
199 for (UncommonTrap site : getTraps()) {
200 site.print(stream, indent + 2);
201 }
202 }
203 }
204
205 public int getBci() {
206 return bci;
207 }
208
209 public void setBci(int bci) {
210 this.bci = bci;
211 }
212
213 public Method getMethod() {
214 return method;
215 }
216
217 public void setMethod(Method method) {
218 this.method = method;
219 }
220
221 public int getCount() {
222 return count;
223 }
224
225 public void setCount(int count) {
226 this.count = count;
227 }
228
229 public String getReceiver() {
230 return receiver;
231 }
232
233 public void setReceiver(String receiver) {
234 this.receiver = receiver;
235 }
236
237 public int getReceiverCount() {
238 return receiver_count;
239 }
240
241 public void setReceiver_count(int receiver_count) {
242 this.receiver_count = receiver_count;
243 }
244
245 public String getReason() {
246 return reason;
247 }
248
249 public void setReason(String reason) {
250 this.reason = reason;
251 }
252
253 public List<CallSite> getCalls() {
254 return calls;
255 }
256
257 public List<UncommonTrap> getTraps() {
258 return traps;
259 }
260
261 void add(UncommonTrap e) {
262 if (traps == null) {
263 traps = new ArrayList<UncommonTrap>();
264 }
265 traps.add(e);
266 }
267
268 void setEndNodes(int n) {
269 endNodes = n;
270 }
271
272 public int getEndNodes() {
273 return endNodes;
274 }
275
276 void setEndLiveNodes(int n) {
277 endLiveNodes = n;
278 }
279
280 public int getEndLiveNodes() {
281 return endLiveNodes;
282 }
283
284 void setTimeStamp(double time) {
285 timeStamp = time;
286 }
287
288 public double getTimeStamp() {
289 return timeStamp;
290 }
291
292 /**
293 * Check whether this call site matches another. Every late inline call
294 * site has a unique inline ID. If the call site we're looking for has one,
295 * then use it; otherwise rely on method name and byte code index.
296 */
297 private boolean matches(CallSite other) {
298 if (other.inlineId != 0) {
299 return inlineId == other.inlineId;
300 }
301 return method.equals(other.method) && bci == other.bci;
302 }
303
304 /**
305 * Locate a late inline call site: find, in this instance's
306 * {@linkplain #calls call sites}, the one furthest down the given call
307 * stack.
308 *
309 * Multiple chains of identical call sites with the same method name / bci
310 * combination are possible, so we have to try them all until we find the
311 * late inline call site that has a matching inline ID.
312 *
313 * @return a matching call site, or {@code null} if none was found.
314 */
315 public CallSite findCallSite(ArrayDeque<CallSite> sites) {
316 if (calls == null) {
317 return null;
318 }
319 CallSite site = sites.pop();
320 for (CallSite c : calls) {
321 if (c.matches(site)) {
322 if (!sites.isEmpty()) {
323 CallSite res = c.findCallSite(sites);
324 if (res != null) {
325 sites.push(site);
326 return res;
327 }
328 } else {
329 sites.push(site);
330 return c;
331 }
332 }
333 }
334 sites.push(site);
335 return null;
336 }
337
338 /**
339 * Locate a late inline call site in the tree spanned by all this instance's
340 * {@linkplain #calls call sites}, and return the sequence of call sites
341 * (scopes) leading to that late inline call site.
342 */
343 public ArrayDeque<CallSite> findCallSite2(CallSite site) {
344 if (calls == null) {
345 return null;
346 }
347
348 for (CallSite c : calls) {
349 if (c.matches(site)) {
350 ArrayDeque<CallSite> stack = new ArrayDeque<>();
351 stack.push(c);
352 return stack;
353 } else {
354 ArrayDeque<CallSite> stack = c.findCallSite2(site);
355 if (stack != null) {
356 stack.push(c);
357 return stack;
358 }
359 }
360 }
361 return null;
362 }
363
364 public long getInlineId() {
365 return inlineId;
366 }
367
368 public void setInlineId(long inlineId) {
369 this.inlineId = inlineId;
370 }
371 }