1 /*
2 * Copyright (c) 2012, 2019, 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 package jdk.vm.ci.hotspot;
24
25 import static java.lang.String.format;
26 import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
27 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
28 import static jdk.vm.ci.hotspot.HotSpotVMConfig.config;
29 import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
30
31 import java.util.Arrays;
32
33 import jdk.vm.ci.common.NativeImageReinitialize;
34 import jdk.internal.misc.Unsafe;
35 import jdk.vm.ci.meta.DeoptimizationReason;
36 import jdk.vm.ci.meta.JavaMethodProfile;
37 import jdk.vm.ci.meta.JavaMethodProfile.ProfiledMethod;
38 import jdk.vm.ci.meta.JavaTypeProfile;
39 import jdk.vm.ci.meta.JavaTypeProfile.ProfiledType;
40 import jdk.vm.ci.meta.ResolvedJavaMethod;
41 import jdk.vm.ci.meta.ResolvedJavaType;
42 import jdk.vm.ci.meta.TriState;
43
44 /**
45 * Access to a HotSpot {@code MethodData} structure (defined in methodData.hpp).
46 */
47 final class HotSpotMethodData implements MetaspaceObject {
48
49 /**
50 * VM state that can be reset when building an AOT image.
51 */
52 static final class VMState {
53 final HotSpotVMConfig config = config();
54 final HotSpotMethodDataAccessor noDataNoExceptionAccessor = new NoMethodData(this, config.dataLayoutNoTag, TriState.FALSE);
55 final HotSpotMethodDataAccessor noDataExceptionPossiblyNotRecordedAccessor = new NoMethodData(this, config.dataLayoutNoTag, TriState.UNKNOWN);
56 final int noDataSize = cellIndexToOffset(0);
57 final int bitDataSize = cellIndexToOffset(0);
58 final int bitDataNullSeenFlag = 1 << config.bitDataNullSeenFlag;
59 final int counterDataSize = cellIndexToOffset(1);
60 final int counterDataCountOffset = cellIndexToOffset(config.methodDataCountOffset);
61 final int jumpDataSize = cellIndexToOffset(2);
62 final int takenCountOffset = cellIndexToOffset(config.jumpDataTakenOffset);
63 final int takenDisplacementOffset = cellIndexToOffset(config.jumpDataDisplacementOffset);
64 final int typeDataRowSize = cellsToBytes(config.receiverTypeDataReceiverTypeRowCellCount);
65
66 final int typeDataFirstTypeOffset = cellIndexToOffset(config.receiverTypeDataReceiver0Offset);
67 final int typeDataFirstTypeCountOffset = cellIndexToOffset(config.receiverTypeDataCount0Offset);
68
69 final int typeCheckDataSize = cellIndexToOffset(1) + typeDataRowSize * config.typeProfileWidth;
70 final int virtualCallDataSize = cellIndexToOffset(1) + typeDataRowSize * (config.typeProfileWidth + config.methodProfileWidth);
71 final int virtualCallDataFirstMethodOffset = typeDataFirstTypeOffset + typeDataRowSize * config.typeProfileWidth;
72 final int virtualCallDataFirstMethodCountOffset = typeDataFirstTypeCountOffset + typeDataRowSize * config.typeProfileWidth;
73
74 final int retDataRowSize = cellsToBytes(3);
75 final int retDataSize = cellIndexToOffset(1) + retDataRowSize * config.bciProfileWidth;
76
77 final int branchDataSize = cellIndexToOffset(3);
78 final int notTakenCountOffset = cellIndexToOffset(config.branchDataNotTakenOffset);
79
80 final int arrayDataLengthOffset = cellIndexToOffset(config.arrayDataArrayLenOffset);
81 final int arrayDataStartOffset = cellIndexToOffset(config.arrayDataArrayStartOffset);
82
83 final int multiBranchDataSize = cellIndexToOffset(1);
84 final int multiBranchDataRowSizeInCells = config.multiBranchDataPerCaseCellCount;
85 final int multiBranchDataRowSize = cellsToBytes(multiBranchDataRowSizeInCells);
86 final int multiBranchDataFirstCountOffset = arrayDataStartOffset + cellsToBytes(0);
87 final int multiBranchDataFirstDisplacementOffset = arrayDataStartOffset + cellsToBytes(1);
88
89 final int argInfoDataSize = cellIndexToOffset(1);
90
91 // sorted by tag
92 // @formatter:off
93 final HotSpotMethodDataAccessor[] profileDataAccessors = {
94 null,
95 new BitData(this, config.dataLayoutBitDataTag),
96 new CounterData(this, config.dataLayoutCounterDataTag),
97 new JumpData(this, config.dataLayoutJumpDataTag),
98 new ReceiverTypeData(this, config.dataLayoutReceiverTypeDataTag),
99 new VirtualCallData(this, config.dataLayoutVirtualCallDataTag),
100 new RetData(this, config.dataLayoutRetDataTag),
101 new BranchData(this, config.dataLayoutBranchDataTag),
102 new MultiBranchData(this, config.dataLayoutMultiBranchDataTag),
103 new ArgInfoData(this, config.dataLayoutArgInfoDataTag),
104 new UnknownProfileData(this, config.dataLayoutCallTypeDataTag),
105 new VirtualCallTypeData(this, config.dataLayoutVirtualCallTypeDataTag),
106 new UnknownProfileData(this, config.dataLayoutParametersTypeDataTag),
107 new UnknownProfileData(this, config.dataLayoutSpeculativeTrapDataTag),
108 };
109 // @formatter:on
110
111 private boolean checkAccessorTags() {
112 int expectedTag = 0;
113 for (HotSpotMethodDataAccessor accessor : profileDataAccessors) {
114 if (expectedTag == 0) {
115 assert accessor == null;
116 } else {
117 assert accessor.tag == expectedTag : expectedTag + " != " + accessor.tag + " " + accessor;
118 }
119 expectedTag++;
120 }
121 return true;
122 }
123
124 private VMState() {
125 assert checkAccessorTags();
126 }
127
128 private static int truncateLongToInt(long value) {
129 return value > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) value;
130 }
131
132 private int computeFullOffset(int position, int offsetInBytes) {
133 return config.methodDataOopDataOffset + position + offsetInBytes;
134 }
135
136 private int cellIndexToOffset(int cells) {
137 return config.dataLayoutHeaderSize + cellsToBytes(cells);
138 }
139
140 private int cellsToBytes(int cells) {
141 return cells * config.dataLayoutCellSize;
142 }
143
144 /**
145 * Singleton instance lazily initialized via double-checked locking.
146 */
147 @NativeImageReinitialize private static volatile VMState instance;
148
149 static VMState instance() {
150 VMState result = instance;
151 if (result == null) {
152 synchronized (VMState.class) {
153 result = instance;
154 if (result == null) {
155 instance = result = new VMState();
156 }
157 }
158 }
159 return result;
160 }
161 }
162
163 /**
164 * A {@code MethodData*} value.
165 */
166 final long methodDataPointer;
167 private final HotSpotResolvedJavaMethodImpl method;
168 private final VMState state;
169
170 HotSpotMethodData(long methodDataPointer, HotSpotResolvedJavaMethodImpl method) {
171 this.methodDataPointer = methodDataPointer;
172 this.method = method;
173 this.state = VMState.instance();
174 }
175
176 @Override
177 public long getMetaspacePointer() {
178 return methodDataPointer;
179 }
180
181 /**
182 * @return value of the MethodData::_data_size field
183 */
184 private int normalDataSize() {
185 return UNSAFE.getInt(methodDataPointer + state.config.methodDataDataSize);
186 }
187
188 /**
189 * Returns the size of the extra data records. This method does the same calculation as
190 * MethodData::extra_data_size().
191 *
192 * @return size of extra data records
193 */
194 private int extraDataSize() {
195 final int extraDataBase = state.config.methodDataOopDataOffset + normalDataSize();
196 final int extraDataLimit = UNSAFE.getInt(methodDataPointer + state.config.methodDataSize);
197 return extraDataLimit - extraDataBase;
198 }
199
200 public boolean hasNormalData() {
201 return normalDataSize() > 0;
202 }
203
204 /**
205 * Return true if there is an extra data section and the first tag is non-zero.
206 */
207 public boolean hasExtraData() {
208 return extraDataSize() > 0 && HotSpotMethodDataAccessor.readTag(state.config, this, getExtraDataBeginOffset()) != 0;
209 }
210
211 private int getExtraDataBeginOffset() {
212 return normalDataSize();
213 }
214
215 public boolean isWithin(int position) {
216 return position >= 0 && position < normalDataSize();
217 }
218
219 public int getDeoptimizationCount(DeoptimizationReason reason) {
220 HotSpotMetaAccessProvider metaAccess = (HotSpotMetaAccessProvider) runtime().getHostJVMCIBackend().getMetaAccess();
221 int reasonIndex = metaAccess.convertDeoptReason(reason);
222 return UNSAFE.getByte(methodDataPointer + state.config.methodDataOopTrapHistoryOffset + reasonIndex) & 0xFF;
223 }
224
225 public int getOSRDeoptimizationCount(DeoptimizationReason reason) {
226 HotSpotMetaAccessProvider metaAccess = (HotSpotMetaAccessProvider) runtime().getHostJVMCIBackend().getMetaAccess();
227 int reasonIndex = metaAccess.convertDeoptReason(reason);
228 return UNSAFE.getByte(methodDataPointer + state.config.methodDataOopTrapHistoryOffset + state.config.deoptReasonOSROffset + reasonIndex) & 0xFF;
229 }
230
231 public int getDecompileCount() {
232 return UNSAFE.getInt(methodDataPointer + state.config.methodDataDecompiles);
233 }
234
235 public int getOverflowRecompileCount() {
236 return UNSAFE.getInt(methodDataPointer + state.config.methodDataOverflowRecompiles);
237 }
238
239 public int getOverflowTrapCount() {
240 return UNSAFE.getInt(methodDataPointer + state.config.methodDataOverflowTraps);
241 }
242
243 public HotSpotMethodDataAccessor getNormalData(int position) {
244 if (position >= normalDataSize()) {
245 return null;
246 }
247
248 return getData(position);
249 }
250
251 public static HotSpotMethodDataAccessor getNoDataAccessor(boolean exceptionPossiblyNotRecorded) {
252 if (exceptionPossiblyNotRecorded) {
253 return VMState.instance().noDataExceptionPossiblyNotRecordedAccessor;
254 } else {
255 return VMState.instance().noDataNoExceptionAccessor;
256 }
257 }
258
259 private HotSpotMethodDataAccessor getData(int position) {
260 assert position >= 0 : "out of bounds";
261 final int tag = HotSpotMethodDataAccessor.readTag(state.config, this, position);
262 HotSpotMethodDataAccessor accessor = state.profileDataAccessors[tag];
263 assert accessor == null || accessor.getTag() == tag : "wrong data accessor " + accessor + " for tag " + tag;
264 return accessor;
265 }
266
267 int readUnsignedByte(int position, int offsetInBytes) {
268 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
269 return UNSAFE.getByte(methodDataPointer + fullOffsetInBytes) & 0xFF;
270 }
271
272 int readUnsignedShort(int position, int offsetInBytes) {
273 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
274 return UNSAFE.getShort(methodDataPointer + fullOffsetInBytes) & 0xFFFF;
275 }
276
277 /**
278 * Since the values are stored in cells (platform words) this method uses
279 * {@link Unsafe#getAddress} to read the right value on both little and big endian machines.
280 */
281 private long readUnsignedInt(int position, int offsetInBytes) {
282 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
283 return UNSAFE.getAddress(methodDataPointer + fullOffsetInBytes) & 0xFFFFFFFFL;
284 }
285
286 private int readUnsignedIntAsSignedInt(int position, int offsetInBytes) {
287 long value = readUnsignedInt(position, offsetInBytes);
288 return VMState.truncateLongToInt(value);
289 }
290
291 /**
292 * Since the values are stored in cells (platform words) this method uses
293 * {@link Unsafe#getAddress} to read the right value on both little and big endian machines.
294 */
295 private int readInt(int position, int offsetInBytes) {
296 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
297 return (int) UNSAFE.getAddress(methodDataPointer + fullOffsetInBytes);
298 }
299
300 private HotSpotResolvedJavaMethod readMethod(int position, int offsetInBytes) {
301 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
302 return compilerToVM().getResolvedJavaMethod(null, methodDataPointer + fullOffsetInBytes);
303 }
304
305 private HotSpotResolvedObjectTypeImpl readKlass(int position, int offsetInBytes) {
306 long fullOffsetInBytes = state.computeFullOffset(position, offsetInBytes);
307 return compilerToVM().getResolvedJavaType(this, fullOffsetInBytes);
308 }
309
310 /**
311 * Returns whether profiling ran long enough that the profile information is mature. Other
312 * informational data will still be valid even if the profile isn't mature.
313 */
314 public boolean isProfileMature() {
315 return runtime().getCompilerToVM().isMature(methodDataPointer);
316 }
317
318 @Override
319 public String toString() {
320 StringBuilder sb = new StringBuilder();
321 String nl = String.format("%n");
322 String nlIndent = String.format("%n%38s", "");
323 sb.append("Raw method data for ");
324 sb.append(method.format("%H.%n(%p)"));
325 sb.append(":");
326 sb.append(nl);
327 sb.append(String.format("nof_decompiles(%d) nof_overflow_recompiles(%d) nof_overflow_traps(%d)%n",
328 getDecompileCount(), getOverflowRecompileCount(), getOverflowTrapCount()));
329 if (hasNormalData()) {
330 int pos = 0;
331 HotSpotMethodDataAccessor data;
332 while ((data = getNormalData(pos)) != null) {
333 if (pos != 0) {
334 sb.append(nl);
335 }
336 int bci = data.getBCI(this, pos);
337 sb.append(String.format("%-6d bci: %-6d%-20s", pos, bci, data.getClass().getSimpleName()));
338 sb.append(data.appendTo(new StringBuilder(), this, pos).toString().replace(nl, nlIndent));
339 pos = pos + data.getSize(this, pos);
340 }
341 }
342
343 return sb.toString();
344 }
345
346 static class NoMethodData extends HotSpotMethodDataAccessor {
347
348 private final TriState exceptionSeen;
349
350 protected NoMethodData(VMState state, int tag, TriState exceptionSeen) {
351 super(state, tag, state.noDataSize);
352 this.exceptionSeen = exceptionSeen;
353 }
354
355 @Override
356 public int getBCI(HotSpotMethodData data, int position) {
357 return -1;
358 }
359
360 @Override
361 public TriState getExceptionSeen(HotSpotMethodData data, int position) {
362 return exceptionSeen;
363 }
364
365 @Override
366 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
367 return sb;
368 }
369 }
370
371 static class BitData extends HotSpotMethodDataAccessor {
372
373 private BitData(VMState state, int tag) {
374 super(state, tag, state.bitDataSize);
375 }
376
377 protected BitData(VMState state, int tag, int staticSize) {
378 super(state, tag, staticSize);
379 }
380
381 @Override
382 public TriState getNullSeen(HotSpotMethodData data, int position) {
383 return TriState.get((getFlags(data, position) & state.bitDataNullSeenFlag) != 0);
384 }
385
386 @Override
387 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
388 return sb.append(format("exception_seen(%s)", getExceptionSeen(data, pos)));
389 }
390 }
391
392 static class CounterData extends BitData {
393
394 CounterData(VMState state, int tag) {
395 super(state, tag, state.counterDataSize);
396 }
397
398 protected CounterData(VMState state, int tag, int staticSize) {
399 super(state, tag, staticSize);
400 }
401
402 @Override
403 public int getExecutionCount(HotSpotMethodData data, int position) {
404 return getCounterValue(data, position);
405 }
406
407 protected int getCounterValue(HotSpotMethodData data, int position) {
408 return data.readUnsignedIntAsSignedInt(position, state.counterDataCountOffset);
409 }
410
411 @Override
412 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
413 return sb.append(format("count(%d) null_seen(%s) exception_seen(%s)", getCounterValue(data, pos), getNullSeen(data, pos), getExceptionSeen(data, pos)));
414 }
415 }
416
417 static class JumpData extends HotSpotMethodDataAccessor {
418
419 JumpData(VMState state, int tag) {
420 super(state, tag, state.jumpDataSize);
421 }
422
423 protected JumpData(VMState state, int tag, int staticSize) {
424 super(state, tag, staticSize);
425 }
426
427 @Override
428 public double getBranchTakenProbability(HotSpotMethodData data, int position) {
429 return getExecutionCount(data, position) != 0 ? 1 : 0;
430 }
431
432 @Override
433 public int getExecutionCount(HotSpotMethodData data, int position) {
434 return data.readUnsignedIntAsSignedInt(position, state.takenCountOffset);
435 }
436
437 public int getTakenDisplacement(HotSpotMethodData data, int position) {
438 return data.readInt(position, state.takenDisplacementOffset);
439 }
440
441 @Override
442 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
443 return sb.append(format("taken(%d) displacement(%d)", getExecutionCount(data, pos), getTakenDisplacement(data, pos)));
444 }
445 }
446
447 static class RawItemProfile<T> {
448 final int entries;
449 final T[] items;
450 final long[] counts;
451 final long totalCount;
452
453 RawItemProfile(int entries, T[] items, long[] counts, long totalCount) {
454 this.entries = entries;
455 this.items = items;
456 this.counts = counts;
457 this.totalCount = totalCount;
458 }
459 }
460
461 abstract static class AbstractTypeData extends CounterData {
462
463 protected AbstractTypeData(VMState state, int tag, int staticSize) {
464 super(state, tag, staticSize);
465 }
466
467 @Override
468 public JavaTypeProfile getTypeProfile(HotSpotMethodData data, int position) {
469 return createTypeProfile(getNullSeen(data, position), getRawTypeProfile(data, position));
470 }
471
472 private RawItemProfile<ResolvedJavaType> getRawTypeProfile(HotSpotMethodData data, int position) {
473 int typeProfileWidth = config.typeProfileWidth;
474
475 ResolvedJavaType[] types = new ResolvedJavaType[typeProfileWidth];
476 long[] counts = new long[typeProfileWidth];
477 long totalCount = 0;
478 int entries = 0;
479
480 outer: for (int i = 0; i < typeProfileWidth; i++) {
481 HotSpotResolvedObjectTypeImpl receiverKlass = data.readKlass(position, getTypeOffset(i));
482 if (receiverKlass != null) {
483 HotSpotResolvedObjectTypeImpl klass = receiverKlass;
484 long count = data.readUnsignedInt(position, getTypeCountOffset(i));
485 /*
486 * Because of races in the profile collection machinery it's possible for a
487 * class to appear multiple times so merge them to make the profile look
488 * rational.
489 */
490 for (int j = 0; j < entries; j++) {
491 if (types[j].equals(klass)) {
492 totalCount += count;
493 counts[j] += count;
494 continue outer;
495 }
496 }
497 types[entries] = klass;
498 totalCount += count;
499 counts[entries] = count;
500 entries++;
501 }
502 }
503
504 totalCount += getCounterValue(data, position);
505 return new RawItemProfile<>(entries, types, counts, totalCount);
506 }
507
508 private JavaTypeProfile createTypeProfile(TriState nullSeen, RawItemProfile<ResolvedJavaType> profile) {
509 if (profile.entries <= 0 || profile.totalCount <= 0) {
510 return null;
511 }
512
513 ProfiledType[] ptypes = new ProfiledType[profile.entries];
514 double totalProbability = 0.0;
515 for (int i = 0; i < profile.entries; i++) {
516 double p = profile.counts[i];
517 p = p / profile.totalCount;
518 totalProbability += p;
519 ptypes[i] = new ProfiledType(profile.items[i], p);
520 }
521
522 Arrays.sort(ptypes);
523
524 double notRecordedTypeProbability = profile.entries < config.typeProfileWidth ? 0.0 : Math.min(1.0, Math.max(0.0, 1.0 - totalProbability));
525 assert notRecordedTypeProbability == 0 || profile.entries == config.typeProfileWidth;
526 return new JavaTypeProfile(nullSeen, notRecordedTypeProbability, ptypes);
527 }
528
529 private int getTypeOffset(int row) {
530 return state.typeDataFirstTypeOffset + row * state.typeDataRowSize;
531 }
532
533 protected int getTypeCountOffset(int row) {
534 return state.typeDataFirstTypeCountOffset + row * state.typeDataRowSize;
535 }
536
537 @Override
538 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
539 RawItemProfile<ResolvedJavaType> profile = getRawTypeProfile(data, pos);
540 TriState nullSeen = getNullSeen(data, pos);
541 TriState exceptionSeen = getExceptionSeen(data, pos);
542 sb.append(format("count(%d) null_seen(%s) exception_seen(%s) entries(%d)", getCounterValue(data, pos), nullSeen, exceptionSeen,
543 profile.entries));
544 for (int i = 0; i < profile.entries; i++) {
545 long count = profile.counts[i];
546 sb.append(format("%n %s (%d, %4.2f)", profile.items[i].toJavaName(), count, (double) count / profile.totalCount));
547 }
548 return sb;
549 }
550 }
551
552 static class ReceiverTypeData extends AbstractTypeData {
553
554 ReceiverTypeData(VMState state, int tag) {
555 super(state, tag, state.typeCheckDataSize);
556 }
557
558 protected ReceiverTypeData(VMState state, int tag, int staticSize) {
559 super(state, tag, staticSize);
560 }
561
562 @Override
563 public int getExecutionCount(HotSpotMethodData data, int position) {
564 return -1;
565 }
566 }
567
568 static class VirtualCallData extends ReceiverTypeData {
569
570 VirtualCallData(VMState state, int tag) {
571 super(state, tag, state.virtualCallDataSize);
572 }
573
574 protected VirtualCallData(VMState state, int tag, int staticSize) {
575 super(state, tag, staticSize);
576 }
577
578 @Override
579 public int getExecutionCount(HotSpotMethodData data, int position) {
580 final int typeProfileWidth = config.typeProfileWidth;
581
582 long total = 0;
583 for (int i = 0; i < typeProfileWidth; i++) {
584 total += data.readUnsignedInt(position, getTypeCountOffset(i));
585 }
586
587 total += getCounterValue(data, position);
588 return VMState.truncateLongToInt(total);
589 }
590
591 @Override
592 public JavaMethodProfile getMethodProfile(HotSpotMethodData data, int position) {
593 return createMethodProfile(getRawMethodProfile(data, position));
594 }
595
596 private RawItemProfile<ResolvedJavaMethod> getRawMethodProfile(HotSpotMethodData data, int position) {
597 int profileWidth = config.methodProfileWidth;
598
599 ResolvedJavaMethod[] methods = new ResolvedJavaMethod[profileWidth];
600 long[] counts = new long[profileWidth];
601 long totalCount = 0;
602 int entries = 0;
603
604 for (int i = 0; i < profileWidth; i++) {
605 HotSpotResolvedJavaMethod method = data.readMethod(position, getMethodOffset(i));
606 if (method != null) {
607 methods[entries] = method;
608 long count = data.readUnsignedInt(position, getMethodCountOffset(i));
609 totalCount += count;
610 counts[entries] = count;
611
612 entries++;
613 }
614 }
615
616 // Fixup the case of C1's inability to optimize profiling of a statically bindable call
617 // site. If it's a monomorphic call site, attribute all the counts to the first type (if
618 // any is recorded).
619 if (entries == 1) {
620 counts[0] = totalCount;
621 }
622
623 return new RawItemProfile<>(entries, methods, counts, totalCount);
624 }
625
626 private JavaMethodProfile createMethodProfile(RawItemProfile<ResolvedJavaMethod> profile) {
627 if (profile.entries <= 0 || profile.totalCount <= 0) {
628 return null;
629 }
630
631 ProfiledMethod[] pmethods = new ProfiledMethod[profile.entries];
632 double totalProbability = 0.0;
633 for (int i = 0; i < profile.entries; i++) {
634 double p = profile.counts[i];
635 p = p / profile.totalCount;
636 totalProbability += p;
637 pmethods[i] = new ProfiledMethod(profile.items[i], p);
638 }
639
640 Arrays.sort(pmethods);
641
642 double notRecordedMethodProbability = profile.entries < config.methodProfileWidth ? 0.0 : Math.min(1.0, Math.max(0.0, 1.0 - totalProbability));
643 assert notRecordedMethodProbability == 0 || profile.entries == config.methodProfileWidth;
644 return new JavaMethodProfile(notRecordedMethodProbability, pmethods);
645 }
646
647 private int getMethodOffset(int row) {
648 return state.virtualCallDataFirstMethodOffset + row * state.typeDataRowSize;
649 }
650
651 private int getMethodCountOffset(int row) {
652 return state.virtualCallDataFirstMethodCountOffset + row * state.typeDataRowSize;
653 }
654
655 @Override
656 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
657 RawItemProfile<ResolvedJavaMethod> profile = getRawMethodProfile(data, pos);
658 super.appendTo(sb.append(format("exception_seen(%s) ", getExceptionSeen(data, pos))), data, pos).append(format("%nmethod_entries(%d)", profile.entries));
659 for (int i = 0; i < profile.entries; i++) {
660 long count = profile.counts[i];
661 sb.append(format("%n %s (%d, %4.2f)", profile.items[i].format("%H.%n(%p)"), count, (double) count / profile.totalCount));
662 }
663 return sb;
664 }
665 }
666
667 static class VirtualCallTypeData extends VirtualCallData {
668
669 VirtualCallTypeData(VMState state, int tag) {
670 super(state, tag, 0);
671 }
672
673 @Override
674 protected int getDynamicSize(HotSpotMethodData data, int position) {
675 assert staticSize == 0;
676 return HotSpotJVMCIRuntime.runtime().compilerToVm.methodDataProfileDataSize(data.methodDataPointer, position);
677 }
678 }
679
680 static class RetData extends CounterData {
681
682 RetData(VMState state, int tag) {
683 super(state, tag, state.retDataSize);
684 }
685 }
686
687 static class BranchData extends JumpData {
688
689 BranchData(VMState state, int tag) {
690 super(state, tag, state.branchDataSize);
691 }
692
693 @Override
694 public double getBranchTakenProbability(HotSpotMethodData data, int position) {
695 long takenCount = data.readUnsignedInt(position, state.takenCountOffset);
696 long notTakenCount = data.readUnsignedInt(position, state.notTakenCountOffset);
697 long total = takenCount + notTakenCount;
698
699 return total <= 0 ? -1 : takenCount / (double) total;
700 }
701
702 @Override
703 public int getExecutionCount(HotSpotMethodData data, int position) {
704 long count = data.readUnsignedInt(position, state.takenCountOffset) + data.readUnsignedInt(position, state.notTakenCountOffset);
705 return VMState.truncateLongToInt(count);
706 }
707
708 @Override
709 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
710 long taken = data.readUnsignedInt(pos, state.takenCountOffset);
711 long notTaken = data.readUnsignedInt(pos, state.notTakenCountOffset);
712 double takenProbability = getBranchTakenProbability(data, pos);
713 return sb.append(format("taken(%d, %4.2f) not_taken(%d, %4.2f) displacement(%d)", taken, takenProbability, notTaken, 1.0D - takenProbability, getTakenDisplacement(data, pos)));
714 }
715 }
716
717 static class ArrayData extends HotSpotMethodDataAccessor {
718
719 ArrayData(VMState state, int tag, int staticSize) {
720 super(state, tag, staticSize);
721 }
722
723 @Override
724 protected int getDynamicSize(HotSpotMethodData data, int position) {
725 return state.cellsToBytes(getLength(data, position));
726 }
727
728 protected int getLength(HotSpotMethodData data, int position) {
729 return data.readInt(position, state.arrayDataLengthOffset);
730 }
731
732 @Override
733 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
734 return sb.append(format("length(%d)", getLength(data, pos)));
735 }
736 }
737
738 static class MultiBranchData extends ArrayData {
739
740 MultiBranchData(VMState state, int tag) {
741 super(state, tag, state.multiBranchDataSize);
742 }
743
744 @Override
745 public double[] getSwitchProbabilities(HotSpotMethodData data, int position) {
746 int arrayLength = getLength(data, position);
747 assert arrayLength > 0 : "switch must have at least the default case";
748 assert arrayLength % state.multiBranchDataRowSizeInCells == 0 : "array must have full rows";
749
750 int length = arrayLength / state.multiBranchDataRowSizeInCells;
751 long totalCount = 0;
752 double[] result = new double[length];
753
754 // default case is first in HotSpot but last for the compiler
755 long count = readCount(data, position, 0);
756 totalCount += count;
757 result[length - 1] = count;
758
759 for (int i = 1; i < length; i++) {
760 count = readCount(data, position, i);
761 totalCount += count;
762 result[i - 1] = count;
763 }
764
765 if (totalCount <= 0) {
766 return null;
767 } else {
768 for (int i = 0; i < length; i++) {
769 result[i] = result[i] / totalCount;
770 }
771 return result;
772 }
773 }
774
775 private long readCount(HotSpotMethodData data, int position, int i) {
776 int offset;
777 long count;
778 offset = getCountOffset(i);
779 count = data.readUnsignedInt(position, offset);
780 return count;
781 }
782
783 @Override
784 public int getExecutionCount(HotSpotMethodData data, int position) {
785 int arrayLength = getLength(data, position);
786 assert arrayLength > 0 : "switch must have at least the default case";
787 assert arrayLength % state.multiBranchDataRowSizeInCells == 0 : "array must have full rows";
788
789 int length = arrayLength / state.multiBranchDataRowSizeInCells;
790 long totalCount = 0;
791 for (int i = 0; i < length; i++) {
792 int offset = getCountOffset(i);
793 totalCount += data.readUnsignedInt(position, offset);
794 }
795
796 return VMState.truncateLongToInt(totalCount);
797 }
798
799 private int getCountOffset(int index) {
800 return state.multiBranchDataFirstCountOffset + index * state.multiBranchDataRowSize;
801 }
802
803 private int getDisplacementOffset(int index) {
804 return state.multiBranchDataFirstDisplacementOffset + index * state.multiBranchDataRowSize;
805 }
806
807 @Override
808 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
809 int entries = getLength(data, pos) / state.multiBranchDataRowSizeInCells;
810 sb.append(format("entries(%d)", entries));
811 for (int i = 0; i < entries; i++) {
812 sb.append(format("%n %d: count(%d) displacement(%d)", i, data.readUnsignedInt(pos, getCountOffset(i)), data.readUnsignedInt(pos, getDisplacementOffset(i))));
813 }
814 return sb;
815 }
816 }
817
818 static class ArgInfoData extends ArrayData {
819
820 ArgInfoData(VMState state, int tag) {
821 super(state, tag, state.argInfoDataSize);
822 }
823 }
824
825 static class UnknownProfileData extends HotSpotMethodDataAccessor {
826 UnknownProfileData(VMState state, int tag) {
827 super(state, tag, 0);
828 }
829
830 @Override
831 protected int getDynamicSize(HotSpotMethodData data, int position) {
832 assert staticSize == 0;
833 return HotSpotJVMCIRuntime.runtime().compilerToVm.methodDataProfileDataSize(data.methodDataPointer, position);
834 }
835
836 @Override
837 public StringBuilder appendTo(StringBuilder sb, HotSpotMethodData data, int pos) {
838 sb.append("unknown profile data with tag: " + tag);
839 return sb;
840 }
841 }
842
843 public void setCompiledIRSize(int size) {
844 UNSAFE.putInt(methodDataPointer + state.config.methodDataIRSizeOffset, size);
845 }
846
847 public int getCompiledIRSize() {
848 return UNSAFE.getInt(methodDataPointer + state.config.methodDataIRSizeOffset);
849 }
850 }