truffle: test/compiler/whitebox/CompilerWhiteBoxTest.java comparison

comparison test/compiler/whitebox/CompilerWhiteBoxTest.java @ 17616:d1760952ebdd

8028587: New tests development for intrisics for basic operators - add, neg, inc, dec, sub, mul Reviewed-by: twisti Contributed-by: anton.ivanov@oracle.com

author	iignatyev
date	Tue, 31 Dec 2013 19:26:57 +0400
parents	600c83f8e6a5
children	bbfe3ac1471d 4ca6dc0799b6 d559dbbded7a

comparison

equal deleted inserted replaced

-:6d2fe9c23878
+:d1760952ebdd
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.util.Objects;
 import java.util.concurrent.Callable;
+import java.util.function.Function;
 /**
 * Abstract class for WhiteBox testing of JIT.
 *
 * @author igor.ignatyev@oracle.com
 protected static int COMP_LEVEL_LIMITED_PROFILE = 2;
 /** {@code CompLevel::CompLevel_full_profile} -- C1, invocation &amp; backedge counters + mdo */
 protected static int COMP_LEVEL_FULL_PROFILE = 3;
 /** {@code CompLevel::CompLevel_full_optimization} -- C2 or Shark */
 protected static int COMP_LEVEL_FULL_OPTIMIZATION = 4;
-/** Maximal value for CompLeveL */
+/** Maximal value for CompLevel */
 protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
 /** Instance of WhiteBox */
 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
 /** Value of {@code -XX:CompileThreshold} */
 /** count of invocation to triger compilation */
 protected static final int THRESHOLD;
 /** count of invocation to triger OSR compilation */
 protected static final long BACKEDGE_THRESHOLD;
 /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
-protected static final String MODE
+protected static final String MODE = System.getProperty("java.vm.info");
-= System.getProperty("java.vm.info");
 static {
 if (TIERED_COMPILATION) {
 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
 } else {
 /** copy of is_c2_compile(int) from utilities/globalDefinitions.hpp */
 protected static boolean isC2Compile(int compLevel) {
 return compLevel == COMP_LEVEL_FULL_OPTIMIZATION;
 }
+protected static void main(
+Function<TestCase, CompilerWhiteBoxTest> constructor,
+String[] args) {
+if (args.length == 0) {
+for (TestCase test : SimpleTestCase.values()) {
+constructor.apply(test).runTest();
+}
+} else {
+for (String name : args) {
+constructor.apply(SimpleTestCase.valueOf(name)).runTest();
+}
+}
+}
 /** tested method */
 protected final Executable method;
 protected final TestCase testCase;
 /**
 * @param testCase object, that contains tested method and way to invoke it.
 */
 protected CompilerWhiteBoxTest(TestCase testCase) {
 Objects.requireNonNull(testCase);
 System.out.println("TEST CASE:" + testCase.name());
-method = testCase.executable;
+method = testCase.getExecutable();
 this.testCase = testCase;
 }
 /**
 * Template method for testing. Prints tested method's info before
 throw new RuntimeException(method + " must be not osr_compiled");
 }
 if (WHITE_BOX.getMethodCompilationLevel(method, true) != 0) {
 throw new RuntimeException(method + " osr_comp_level must be == 0");
 }
 }
 /**
 * Checks, that {@linkplain #method} is compiled.
 *
 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
 System.err.printf("Warning: %s is still in queue after %dms%n",
 method, System.currentTimeMillis() - start);
 return;
 }
-if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr)) {
+if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr())) {
 throw new RuntimeException(method + " must be "
-+ (testCase.isOsr ? "osr_" : "") + "compiled");
++ (testCase.isOsr() ? "osr_" : "") + "compiled");
 }
-if (WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr) == 0) {
+if (WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr())
+== 0) {
 throw new RuntimeException(method
-+ (testCase.isOsr ? " osr_" : " ")
++ (testCase.isOsr() ? " osr_" : " ")
 + "comp_level must be != 0");
 }
 }
 protected final void deoptimize() {
-WHITE_BOX.deoptimizeMethod(method, testCase.isOsr);
+WHITE_BOX.deoptimizeMethod(method, testCase.isOsr());
-if (testCase.isOsr) {
+if (testCase.isOsr()) {
 WHITE_BOX.deoptimizeMethod(method, false);
 }
 }
 protected final int getCompLevel() {
-return WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr);
+return WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr());
 }
 protected final boolean isCompilable() {
 return WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY,
-testCase.isOsr);
+testCase.isOsr());
 }
 protected final boolean isCompilable(int compLevel) {
-return WHITE_BOX.isMethodCompilable(method, compLevel, testCase.isOsr);
+return WHITE_BOX
+.isMethodCompilable(method, compLevel, testCase.isOsr());
 }
 protected final void makeNotCompilable() {
 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
-testCase.isOsr);
+testCase.isOsr());
 }
 protected final void makeNotCompilable(int compLevel) {
-WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr);
+WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
 }
 /**
 * Waits for completion of background compilation of {@linkplain #method}.
 */
 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, true));
 System.out.printf("\tosr_compiled:\t%b%n",
 WHITE_BOX.isMethodCompiled(method, true));
 System.out.printf("\tosr_comp_level:\t%d%n",
 WHITE_BOX.getMethodCompilationLevel(method, true));
 System.out.printf("\tin_queue:\t%b%n",
 WHITE_BOX.isMethodQueuedForCompilation(method));
 System.out.printf("compile_queues_size:\t%d%n%n",
 WHITE_BOX.getCompileQueuesSize());
 }
 */
 protected abstract void test() throws Exception;
 /**
 * Tries to trigger compilation of {@linkplain #method} by call
-* {@linkplain #testCase.callable} enough times.
+* {@linkplain TestCase#getCallable()} enough times.
 *
 * @return accumulated result
 * @see #compile(int)
 */
 protected final int compile() {
-if (testCase.isOsr) {
+if (testCase.isOsr()) {
 return compile(1);
 } else {
 return compile(THRESHOLD);
 }
 }
 /**
 * Tries to trigger compilation of {@linkplain #method} by call
-* {@linkplain #testCase.callable} specified times.
+* {@linkplain TestCase#getCallable()} specified times.
 *
 * @param count invocation count
 * @return accumulated result
 */
 protected final int compile(int count) {
 int result = 0;
 Integer tmp;
 for (int i = 0; i < count; ++i) {
 try {
-tmp = testCase.callable.call();
+tmp = testCase.getCallable().call();
 } catch (Exception e) {
 tmp = null;
 }
 result += tmp == null ? 0 : tmp;
 }
 if (IS_VERBOSE) {
 System.out.println("method was invoked " + count + " times");
 }
 return result;
 }
+/**
+* Utility interface provides tested method and object to invoke it.
+*/
+public interface TestCase {
+/** the name of test case */
+String name();
+/** tested method */
+Executable getExecutable();
+/** object to invoke {@linkplain #getExecutable()} */
+Callable<Integer> getCallable();
+/** flag for OSR test case */
+boolean isOsr();
+}
 }
-/**
+enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
-* Utility structure containing tested method and object to invoke it.
-*/
-enum TestCase {
 /** constructor test case */
 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
 /** method test case */
 METOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
 /** static method test case */
 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
 /** OSR constructor test case */
 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
 /** OSR method test case */
 OSR_METOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
 /** OSR static method test case */
 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
-/** tested method */
+private final Executable executable;
-final Executable executable;
+private final Callable<Integer> callable;
-/** object to invoke {@linkplain #executable} */
+private final boolean isOsr;
-final Callable<Integer> callable;
-/** flag for OSR test case */
+private SimpleTestCase(Executable executable, Callable<Integer> callable,
-final boolean isOsr;
-private TestCase(Executable executable, Callable<Integer> callable,
 boolean isOsr) {
 this.executable = executable;
 this.callable = callable;
 this.isOsr = isOsr;
+}
+@Override
+public Executable getExecutable() {
+return executable;
+}
+@Override
+public Callable<Integer> getCallable() {
+return callable;
+}
+@Override
+public boolean isOsr() {
+return isOsr;
 }
 private static class Helper {
 private static final Callable<Integer> CONSTRUCTOR_CALLABLE
 @Override
 public Integer call() throws Exception {
 return osrStaticMethod();
 }
 };
 private static final Constructor CONSTRUCTOR;
 private static final Constructor OSR_CONSTRUCTOR;
 private static final Method METHOD;
 private static final Method STATIC;

Mercurial > hg > truffle

comparison test/compiler/whitebox/CompilerWhiteBoxTest.java @ 17616:d1760952ebdd