55 /** Maximal value for CompLevel */
56 protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
57
58 /** Instance of WhiteBox */
59 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
60 /** Value of {@code -XX:CompileThreshold} */
61 protected static final int COMPILE_THRESHOLD
62 = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
63 /** Value of {@code -XX:BackgroundCompilation} */
64 protected static final boolean BACKGROUND_COMPILATION
65 = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
66 /** Value of {@code -XX:TieredCompilation} */
67 protected static final boolean TIERED_COMPILATION
68 = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
69 /** Value of {@code -XX:TieredStopAtLevel} */
70 protected static final int TIERED_STOP_AT_LEVEL
71 = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
72 /** Flag for verbose output, true if {@code -Dverbose} specified */
73 protected static final boolean IS_VERBOSE
74 = System.getProperty("verbose") != null;
75 /** count of invocation to triger compilation */
76 protected static final int THRESHOLD;
77 /** count of invocation to triger OSR compilation */
78 protected static final long BACKEDGE_THRESHOLD;
79 /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
80 protected static final String MODE = System.getProperty("java.vm.info");
81
82 static {
83 if (TIERED_COMPILATION) {
84 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
85 } else {
86 THRESHOLD = COMPILE_THRESHOLD;
87 BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
88 "OnStackReplacePercentage"));
89 }
90 }
91
92 /**
93 * Returns value of VM option.
94 *
95 * @param name option's name
96 * @return value of option or {@code null}, if option doesn't exist
97 * @throws NullPointerException if name is null
189 e.printStackTrace();
190 if (e instanceof RuntimeException) {
191 throw (RuntimeException) e;
192 }
193 throw new RuntimeException(e);
194 }
195 System.out.println("at test's end:");
196 printInfo();
197 }
198
199 /**
200 * Checks, that {@linkplain #method} is not compiled at the given compilation
201 * level or above.
202 *
203 * @param compLevel
204 *
205 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
206 * is compiled, or if {@linkplain #method} has zero
207 * compilation level.
208 */
209
210 protected final void checkNotCompiled(int compLevel) {
211 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
212 throw new RuntimeException(method + " must not be in queue");
213 }
214 if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
215 throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
216 }
217 if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
218 throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
219 }
220 }
221
222 /**
223 * Checks, that {@linkplain #method} is not compiled.
224 *
225 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
226 * is compiled, or if {@linkplain #method} has zero
227 * compilation level.
228 */
229 protected final void checkNotCompiled() {
230 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
231 throw new RuntimeException(method + " must not be in queue");
232 }
233 if (WHITE_BOX.isMethodCompiled(method, false)) {
234 throw new RuntimeException(method + " must be not compiled");
235 }
236 if (WHITE_BOX.getMethodCompilationLevel(method, false) != 0) {
237 throw new RuntimeException(method + " comp_level must be == 0");
238 }
239 if (WHITE_BOX.isMethodCompiled(method, true)) {
240 throw new RuntimeException(method + " must be not osr_compiled");
241 }
242 if (WHITE_BOX.getMethodCompilationLevel(method, true) != 0) {
243 throw new RuntimeException(method + " osr_comp_level must be == 0");
244 }
245 }
246
247 /**
248 * Checks, that {@linkplain #method} is compiled.
249 *
250 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
251 * and isn't compiled, or if {@linkplain #method}
252 * has nonzero compilation level
253 */
254 protected final void checkCompiled() {
255 final long start = System.currentTimeMillis();
256 waitBackgroundCompilation();
257 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
258 System.err.printf("Warning: %s is still in queue after %dms%n",
259 method, System.currentTimeMillis() - start);
260 return;
261 }
262 if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr())) {
263 throw new RuntimeException(method + " must be "
289 }
290
291 protected final boolean isCompilable(int compLevel) {
292 return WHITE_BOX
293 .isMethodCompilable(method, compLevel, testCase.isOsr());
294 }
295
296 protected final void makeNotCompilable() {
297 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
298 testCase.isOsr());
299 }
300
301 protected final void makeNotCompilable(int compLevel) {
302 WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
303 }
304
305 /**
306 * Waits for completion of background compilation of {@linkplain #method}.
307 */
308 protected final void waitBackgroundCompilation() {
309 if (!BACKGROUND_COMPILATION) {
310 return;
311 }
312 final Object obj = new Object();
313 for (int i = 0; i < 10
314 && WHITE_BOX.isMethodQueuedForCompilation(method); ++i) {
315 synchronized (obj) {
316 try {
317 obj.wait(1000);
318 } catch (InterruptedException e) {
319 Thread.currentThread().interrupt();
320 }
321 }
322 }
323 }
324
325 /**
326 * Prints information about {@linkplain #method}.
327 */
328 protected final void printInfo() {
329 System.out.printf("%n%s:%n", method);
330 System.out.printf("\tcompilable:\t%b%n",
331 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
332 System.out.printf("\tcompiled:\t%b%n",
333 WHITE_BOX.isMethodCompiled(method, false));
334 System.out.printf("\tcomp_level:\t%d%n",
408
409 /**
410 * @return {@code true} if the current test case is OSR and the mode is
411 * Xcomp, otherwise {@code false}
412 */
413 protected boolean skipXcompOSR() {
414 boolean result = testCase.isOsr()
415 && CompilerWhiteBoxTest.MODE.startsWith("compiled ");
416 if (result && IS_VERBOSE) {
417 System.err.printf("Warning: %s is not applicable in %s%n",
418 testCase.name(), CompilerWhiteBoxTest.MODE);
419 }
420 return result;
421 }
422 }
423
424 enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
425 /** constructor test case */
426 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
427 /** method test case */
428 METOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
429 /** static method test case */
430 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
431 /** OSR constructor test case */
432 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
433 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
434 /** OSR method test case */
435 OSR_METOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
436 /** OSR static method test case */
437 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
438
439 private final Executable executable;
440 private final Callable<Integer> callable;
441 private final boolean isOsr;
442
443 private SimpleTestCase(Executable executable, Callable<Integer> callable,
444 boolean isOsr) {
445 this.executable = executable;
446 this.callable = callable;
447 this.isOsr = isOsr;
448 }
449
450 @Override
451 public Executable getExecutable() {
452 return executable;
453 }
454
455 @Override
477 private final Helper helper = new Helper();
478
479 @Override
480 public Integer call() throws Exception {
481 return helper.method();
482 }
483 };
484
485 private static final Callable<Integer> STATIC_CALLABLE
486 = new Callable<Integer>() {
487 @Override
488 public Integer call() throws Exception {
489 return staticMethod();
490 }
491 };
492
493 private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
494 = new Callable<Integer>() {
495 @Override
496 public Integer call() throws Exception {
497 return new Helper(null).hashCode();
498 }
499 };
500
501 private static final Callable<Integer> OSR_METHOD_CALLABLE
502 = new Callable<Integer>() {
503 private final Helper helper = new Helper();
504
505 @Override
506 public Integer call() throws Exception {
507 return helper.osrMethod();
508 }
509 };
510
511 private static final Callable<Integer> OSR_STATIC_CALLABLE
512 = new Callable<Integer>() {
513 @Override
514 public Integer call() throws Exception {
515 return osrStaticMethod();
516 }
517 };
518
519 private static final Constructor CONSTRUCTOR;
520 private static final Constructor OSR_CONSTRUCTOR;
521 private static final Method METHOD;
522 private static final Method STATIC;
523 private static final Method OSR_METHOD;
524 private static final Method OSR_STATIC;
525
526 static {
527 try {
528 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
529 } catch (NoSuchMethodException | SecurityException e) {
530 throw new RuntimeException(
531 "exception on getting method Helper.<init>(int)", e);
532 }
533 try {
534 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
535 Object.class);
536 } catch (NoSuchMethodException | SecurityException e) {
537 throw new RuntimeException(
538 "exception on getting method Helper.<init>(Object)", e);
539 }
540 METHOD = getMethod("method");
541 STATIC = getMethod("staticMethod");
542 OSR_METHOD = getMethod("osrMethod");
543 OSR_STATIC = getMethod("osrStaticMethod");
544 }
545
546 private static Method getMethod(String name) {
547 try {
548 return Helper.class.getDeclaredMethod(name);
549 } catch (NoSuchMethodException | SecurityException e) {
550 throw new RuntimeException(
551 "exception on getting method Helper." + name, e);
552 }
553
554 }
555
556 private static int staticMethod() {
557 return 1138;
558 }
559
560 private int method() {
561 return 42;
562 }
563
564 private static int osrStaticMethod() {
565 int result = 0;
566 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
567 result += staticMethod();
568 }
569 return result;
570 }
571
572 private int osrMethod() {
573 int result = 0;
574 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
575 result += method();
576 }
577 return result;
578 }
579
580 private final int x;
581
582 // for method and OSR method test case
583 public Helper() {
584 x = 0;
585 }
586
587 // for OSR constructor test case
588 private Helper(Object o) {
589 int result = 0;
590 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
591 result += method();
592 }
593 x = result;
594 }
595
596 // for constructor test case
597 private Helper(int x) {
598 this.x = x;
599 }
600
601 @Override
602 public int hashCode() {
603 return x;
604 }
605 }
606 }
|
55 /** Maximal value for CompLevel */
56 protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
57
58 /** Instance of WhiteBox */
59 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
60 /** Value of {@code -XX:CompileThreshold} */
61 protected static final int COMPILE_THRESHOLD
62 = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
63 /** Value of {@code -XX:BackgroundCompilation} */
64 protected static final boolean BACKGROUND_COMPILATION
65 = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
66 /** Value of {@code -XX:TieredCompilation} */
67 protected static final boolean TIERED_COMPILATION
68 = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
69 /** Value of {@code -XX:TieredStopAtLevel} */
70 protected static final int TIERED_STOP_AT_LEVEL
71 = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
72 /** Flag for verbose output, true if {@code -Dverbose} specified */
73 protected static final boolean IS_VERBOSE
74 = System.getProperty("verbose") != null;
75 /** invocation count to trigger compilation */
76 protected static final int THRESHOLD;
77 /** invocation count to trigger OSR compilation */
78 protected static final long BACKEDGE_THRESHOLD;
79 /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
80 protected static final String MODE = System.getProperty("java.vm.info");
81
82 static {
83 if (TIERED_COMPILATION) {
84 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
85 } else {
86 THRESHOLD = COMPILE_THRESHOLD;
87 BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
88 "OnStackReplacePercentage"));
89 }
90 }
91
92 /**
93 * Returns value of VM option.
94 *
95 * @param name option's name
96 * @return value of option or {@code null}, if option doesn't exist
97 * @throws NullPointerException if name is null
189 e.printStackTrace();
190 if (e instanceof RuntimeException) {
191 throw (RuntimeException) e;
192 }
193 throw new RuntimeException(e);
194 }
195 System.out.println("at test's end:");
196 printInfo();
197 }
198
199 /**
200 * Checks, that {@linkplain #method} is not compiled at the given compilation
201 * level or above.
202 *
203 * @param compLevel
204 *
205 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
206 * is compiled, or if {@linkplain #method} has zero
207 * compilation level.
208 */
209 protected final void checkNotCompiled(int compLevel) {
210 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
211 throw new RuntimeException(method + " must not be in queue");
212 }
213 if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
214 throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
215 }
216 if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
217 throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
218 }
219 }
220
221 /**
222 * Checks, that {@linkplain #method} is not compiled.
223 *
224 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
225 * is compiled, or if {@linkplain #method} has zero
226 * compilation level.
227 */
228 protected final void checkNotCompiled() {
229 checkNotCompiled(true);
230 checkNotCompiled(false);
231 }
232
233 /**
234 * Checks, that {@linkplain #method} is not (OSR-)compiled.
235 *
236 * @param isOsr Check for OSR compilation if true
237 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
238 * is compiled, or if {@linkplain #method} has zero
239 * compilation level.
240 */
241 protected final void checkNotCompiled(boolean isOsr) {
242 waitBackgroundCompilation();
243 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
244 throw new RuntimeException(method + " must not be in queue");
245 }
246 if (WHITE_BOX.isMethodCompiled(method, isOsr)) {
247 throw new RuntimeException(method + " must not be " +
248 (isOsr ? "osr_" : "") + "compiled");
249 }
250 if (WHITE_BOX.getMethodCompilationLevel(method, isOsr) != 0) {
251 throw new RuntimeException(method + (isOsr ? " osr_" : " ") +
252 "comp_level must be == 0");
253 }
254 }
255
256 /**
257 * Checks, that {@linkplain #method} is compiled.
258 *
259 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
260 * and isn't compiled, or if {@linkplain #method}
261 * has nonzero compilation level
262 */
263 protected final void checkCompiled() {
264 final long start = System.currentTimeMillis();
265 waitBackgroundCompilation();
266 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
267 System.err.printf("Warning: %s is still in queue after %dms%n",
268 method, System.currentTimeMillis() - start);
269 return;
270 }
271 if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr())) {
272 throw new RuntimeException(method + " must be "
298 }
299
300 protected final boolean isCompilable(int compLevel) {
301 return WHITE_BOX
302 .isMethodCompilable(method, compLevel, testCase.isOsr());
303 }
304
305 protected final void makeNotCompilable() {
306 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
307 testCase.isOsr());
308 }
309
310 protected final void makeNotCompilable(int compLevel) {
311 WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
312 }
313
314 /**
315 * Waits for completion of background compilation of {@linkplain #method}.
316 */
317 protected final void waitBackgroundCompilation() {
318 waitBackgroundCompilation(method);
319 }
320
321 /**
322 * Waits for completion of background compilation of the given executable.
323 *
324 * @param executable Executable
325 */
326 protected static final void waitBackgroundCompilation(Executable executable) {
327 if (!BACKGROUND_COMPILATION) {
328 return;
329 }
330 final Object obj = new Object();
331 for (int i = 0; i < 10
332 && WHITE_BOX.isMethodQueuedForCompilation(executable); ++i) {
333 synchronized (obj) {
334 try {
335 obj.wait(1000);
336 } catch (InterruptedException e) {
337 Thread.currentThread().interrupt();
338 }
339 }
340 }
341 }
342
343 /**
344 * Prints information about {@linkplain #method}.
345 */
346 protected final void printInfo() {
347 System.out.printf("%n%s:%n", method);
348 System.out.printf("\tcompilable:\t%b%n",
349 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
350 System.out.printf("\tcompiled:\t%b%n",
351 WHITE_BOX.isMethodCompiled(method, false));
352 System.out.printf("\tcomp_level:\t%d%n",
426
427 /**
428 * @return {@code true} if the current test case is OSR and the mode is
429 * Xcomp, otherwise {@code false}
430 */
431 protected boolean skipXcompOSR() {
432 boolean result = testCase.isOsr()
433 && CompilerWhiteBoxTest.MODE.startsWith("compiled ");
434 if (result && IS_VERBOSE) {
435 System.err.printf("Warning: %s is not applicable in %s%n",
436 testCase.name(), CompilerWhiteBoxTest.MODE);
437 }
438 return result;
439 }
440 }
441
442 enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
443 /** constructor test case */
444 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
445 /** method test case */
446 METHOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
447 /** static method test case */
448 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
449 /** OSR constructor test case */
450 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
451 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
452 /** OSR method test case */
453 OSR_METHOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
454 /** OSR static method test case */
455 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
456
457 private final Executable executable;
458 private final Callable<Integer> callable;
459 private final boolean isOsr;
460
461 private SimpleTestCase(Executable executable, Callable<Integer> callable,
462 boolean isOsr) {
463 this.executable = executable;
464 this.callable = callable;
465 this.isOsr = isOsr;
466 }
467
468 @Override
469 public Executable getExecutable() {
470 return executable;
471 }
472
473 @Override
495 private final Helper helper = new Helper();
496
497 @Override
498 public Integer call() throws Exception {
499 return helper.method();
500 }
501 };
502
503 private static final Callable<Integer> STATIC_CALLABLE
504 = new Callable<Integer>() {
505 @Override
506 public Integer call() throws Exception {
507 return staticMethod();
508 }
509 };
510
511 private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
512 = new Callable<Integer>() {
513 @Override
514 public Integer call() throws Exception {
515 return new Helper(null, CompilerWhiteBoxTest.BACKEDGE_THRESHOLD).hashCode();
516 }
517 };
518
519 private static final Callable<Integer> OSR_METHOD_CALLABLE
520 = new Callable<Integer>() {
521 private final Helper helper = new Helper();
522
523 @Override
524 public Integer call() throws Exception {
525 return helper.osrMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
526 }
527 };
528
529 private static final Callable<Integer> OSR_STATIC_CALLABLE
530 = new Callable<Integer>() {
531 @Override
532 public Integer call() throws Exception {
533 return osrStaticMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
534 }
535 };
536
537 private static final Constructor CONSTRUCTOR;
538 private static final Constructor OSR_CONSTRUCTOR;
539 private static final Method METHOD;
540 private static final Method STATIC;
541 private static final Method OSR_METHOD;
542 private static final Method OSR_STATIC;
543
544 static {
545 try {
546 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
547 } catch (NoSuchMethodException | SecurityException e) {
548 throw new RuntimeException(
549 "exception on getting method Helper.<init>(int)", e);
550 }
551 try {
552 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
553 Object.class, long.class);
554 } catch (NoSuchMethodException | SecurityException e) {
555 throw new RuntimeException(
556 "exception on getting method Helper.<init>(Object, long)", e);
557 }
558 METHOD = getMethod("method");
559 STATIC = getMethod("staticMethod");
560 OSR_METHOD = getMethod("osrMethod", long.class);
561 OSR_STATIC = getMethod("osrStaticMethod", long.class);
562 }
563
564 private static Method getMethod(String name, Class<?>... parameterTypes) {
565 try {
566 return Helper.class.getDeclaredMethod(name, parameterTypes);
567 } catch (NoSuchMethodException | SecurityException e) {
568 throw new RuntimeException(
569 "exception on getting method Helper." + name, e);
570 }
571 }
572
573 private static int staticMethod() {
574 return 1138;
575 }
576
577 private int method() {
578 return 42;
579 }
580
581 /**
582 * Deoptimizes all non-osr versions of the given executable after
583 * compilation finished.
584 *
585 * @param e Executable
586 * @throws Exception
587 */
588 private static void waitAndDeoptimize(Executable e) {
589 CompilerWhiteBoxTest.waitBackgroundCompilation(e);
590 if (WhiteBox.getWhiteBox().isMethodQueuedForCompilation(e)) {
591 throw new RuntimeException(e + " must not be in queue");
592 }
593 // Deoptimize non-osr versions of executable
594 WhiteBox.getWhiteBox().deoptimizeMethod(e, false);
595 }
596
597 /**
598 * Executes the method multiple times to make sure we have
599 * enough profiling information before triggering an OSR
600 * compilation. Otherwise the C2 compiler may add uncommon traps.
601 *
602 * @param m Method to be executed
603 * @return Number of times the method was executed
604 * @throws Exception
605 */
606 private static int warmup(Method m) throws Exception {
607 waitAndDeoptimize(m);
608 Helper helper = new Helper();
609 int result = 0;
610 for (long i = 0; i < CompilerWhiteBoxTest.THRESHOLD; ++i) {
611 result += (int)m.invoke(helper, 1);
612 }
613 // Wait to make sure OSR compilation is not blocked by
614 // non-OSR compilation in the compile queue
615 CompilerWhiteBoxTest.waitBackgroundCompilation(m);
616 return result;
617 }
618
619 /**
620 * Executes the constructor multiple times to make sure we
621 * have enough profiling information before triggering an OSR
622 * compilation. Otherwise the C2 compiler may add uncommon traps.
623 *
624 * @param c Constructor to be executed
625 * @return Number of times the constructor was executed
626 * @throws Exception
627 */
628 private static int warmup(Constructor c) throws Exception {
629 waitAndDeoptimize(c);
630 int result = 0;
631 for (long i = 0; i < CompilerWhiteBoxTest.THRESHOLD; ++i) {
632 result += c.newInstance(null, 1).hashCode();
633 }
634 // Wait to make sure OSR compilation is not blocked by
635 // non-OSR compilation in the compile queue
636 CompilerWhiteBoxTest.waitBackgroundCompilation(c);
637 return result;
638 }
639
640 private static int osrStaticMethod(long limit) throws Exception {
641 int result = 0;
642 if (limit != 1) {
643 result = warmup(OSR_STATIC);
644 }
645 // Trigger osr compilation
646 for (long i = 0; i < limit; ++i) {
647 result += staticMethod();
648 }
649 return result;
650 }
651
652 private int osrMethod(long limit) throws Exception {
653 int result = 0;
654 if (limit != 1) {
655 result = warmup(OSR_METHOD);
656 }
657 // Trigger osr compilation
658 for (long i = 0; i < limit; ++i) {
659 result += method();
660 }
661 return result;
662 }
663
664 private final int x;
665
666 // for method and OSR method test case
667 public Helper() {
668 x = 0;
669 }
670
671 // for OSR constructor test case
672 private Helper(Object o, long limit) throws Exception {
673 int result = 0;
674 if (limit != 1) {
675 result = warmup(OSR_CONSTRUCTOR);
676 }
677 // Trigger osr compilation
678 for (long i = 0; i < limit; ++i) {
679 result += method();
680 }
681 x = result;
682 }
683
684 // for constructor test case
685 private Helper(int x) {
686 this.x = x;
687 }
688
689 @Override
690 public int hashCode() {
691 return x;
692 }
693 }
694 }
|