/*

 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import com.sun.management.HotSpotDiagnosticMXBean;

import com.sun.management.VMOption;

import sun.hotspot.WhiteBox;

import sun.management.ManagementFactoryHelper;

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

 */

public abstract class CompilerWhiteBoxTest {

    /** {@code CompLevel::CompLevel_none} -- Interpreter */

    protected static int COMP_LEVEL_NONE = 0;

    /** {@code CompLevel::CompLevel_any}, {@code CompLevel::CompLevel_all} */

    protected static int COMP_LEVEL_ANY = -1;

    /** {@code CompLevel::CompLevel_simple} -- C1 */

    protected static int COMP_LEVEL_SIMPLE = 1;

    /** {@code CompLevel::CompLevel_limited_profile} -- C1, invocation & backedge counters */

    protected static int COMP_LEVEL_LIMITED_PROFILE = 2;

    /** {@code CompLevel::CompLevel_full_profile} -- C1, invocation & 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 */

    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} */

    protected static final int COMPILE_THRESHOLD

            = Integer.parseInt(getVMOption("CompileThreshold", "10000"));

    /** Value of {@code -XX:BackgroundCompilation} */

    protected static final boolean BACKGROUND_COMPILATION

            = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));

    /** Value of {@code -XX:TieredCompilation} */

    protected static final boolean TIERED_COMPILATION

            = Boolean.valueOf(getVMOption("TieredCompilation", "false"));

    /** Value of {@code -XX:TieredStopAtLevel} */

    protected static final int TIERED_STOP_AT_LEVEL

            = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));

    /** Flag for verbose output, true if {@code -Dverbose} specified */

    protected static final boolean IS_VERBOSE

            = System.getProperty("verbose") != null;

    /** 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 = System.getProperty("java.vm.info");

    static {

        if (TIERED_COMPILATION) {

            BACKEDGE_THRESHOLD = THRESHOLD = 150000;

        } else {

            THRESHOLD = COMPILE_THRESHOLD;

            BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(

                    "OnStackReplacePercentage"));

        }

    }

    /**

     * Returns value of VM option.

     *

     * @param name option's name

     * @return value of option or {@code null}, if option doesn't exist

     * @throws NullPointerException if name is null

     */

    protected static String getVMOption(String name) {

        Objects.requireNonNull(name);

        HotSpotDiagnosticMXBean diagnostic

                = ManagementFactoryHelper.getDiagnosticMXBean();

        VMOption tmp;

        try {

            tmp = diagnostic.getVMOption(name);

        } catch (IllegalArgumentException e) {

            tmp = null;

        }

        return (tmp == null ? null : tmp.getValue());

    }

    /**

     * Returns value of VM option or default value.

     *

     * @param name         option's name

     * @param defaultValue default value

     * @return value of option or {@code defaultValue}, if option doesn't exist

     * @throws NullPointerException if name is null

     * @see #getVMOption(String)

     */

    protected static String getVMOption(String name, String defaultValue) {

        String result = getVMOption(name);

        return result == null ? defaultValue : result;

    }

    /** copy of is_c1_compile(int) from utilities/globalDefinitions.hpp */

    protected static boolean isC1Compile(int compLevel) {

        return (compLevel > COMP_LEVEL_NONE)

                && (compLevel < COMP_LEVEL_FULL_OPTIMIZATION);

    }

    /** 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;

    /**

     * Constructor.

     *

     * @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.getExecutable();

        this.testCase = testCase;

    }

    /**

     * Template method for testing. Prints tested method's info before

     * {@linkplain #test()} and after {@linkplain #test()} or on thrown

     * exception.

     *

     * @throws RuntimeException if method {@linkplain #test()} throws any

     *                          exception

     * @see #test()

     */

    protected final void runTest() {

        if (ManagementFactoryHelper.getCompilationMXBean() == null) {

            System.err.println(

                    "Warning: test is not applicable in interpreted mode");

            return;

        }

        System.out.println("at test's start:");

        printInfo();

        try {

            test();

        } catch (Exception e) {

            System.out.printf("on exception '%s':", e.getMessage());

            printInfo();

            e.printStackTrace();

            if (e instanceof RuntimeException) {

                throw (RuntimeException) e;

            }

            throw new RuntimeException(e);

        }

        System.out.println("at test's end:");

        printInfo();

    }

    /**

     * Checks, that {@linkplain #method} is not compiled.

     *

     * @throws RuntimeException if {@linkplain #method} is in compiler queue or

     *                          is compiled, or if {@linkplain #method} has zero

     *                          compilation level.

     */

    protected final void checkNotCompiled() {

        if (WHITE_BOX.isMethodQueuedForCompilation(method)) {

            throw new RuntimeException(method + " must not be in queue");

        }

        if (WHITE_BOX.isMethodCompiled(method, false)) {

            throw new RuntimeException(method + " must be not compiled");

        }

        if (WHITE_BOX.getMethodCompilationLevel(method, false) != 0) {

            throw new RuntimeException(method + " comp_level must be == 0");

        }

        if (WHITE_BOX.isMethodCompiled(method, true)) {

            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

     *                          and isn't compiled, or if {@linkplain #method}

     *                          has nonzero compilation level

     */

    protected final void checkCompiled() {

        final long start = System.currentTimeMillis();

        waitBackgroundCompilation();

        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())) {

            throw new RuntimeException(method + " must be "

                    + (testCase.isOsr() ? "osr_" : "") + "compiled");

        }

        if (WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr())

                == 0) {

            throw new RuntimeException(method

                    + (testCase.isOsr() ? " osr_" : " ")

                    + "comp_level must be != 0");

        }

    }

    protected final void deoptimize() {

        WHITE_BOX.deoptimizeMethod(method, testCase.isOsr());

        if (testCase.isOsr()) {

            WHITE_BOX.deoptimizeMethod(method, false);

        }

    }

    protected final int getCompLevel() {

        return WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr());

    }

    protected final boolean isCompilable() {

        return WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY,

                testCase.isOsr());

    }

    protected final boolean isCompilable(int compLevel) {

        return WHITE_BOX

                .isMethodCompilable(method, compLevel, testCase.isOsr());

    }

    protected final void makeNotCompilable() {

        WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,

                testCase.isOsr());

    }

    protected final void makeNotCompilable(int compLevel) {

        WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());

    }

    /**

     * Waits for completion of background compilation of {@linkplain #method}.

     */

    protected final void waitBackgroundCompilation() {

        if (!BACKGROUND_COMPILATION) {

            return;

        }

        final Object obj = new Object();

        for (int i = 0; i < 10

                && WHITE_BOX.isMethodQueuedForCompilation(method); ++i) {

            synchronized (obj) {

                try {

                    obj.wait(1000);

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

            }

        }

    }

    /**

     * Prints information about {@linkplain #method}.

     */

    protected final void printInfo() {

        System.out.printf("%n%s:%n", method);

        System.out.printf("\tcompilable:\t%b%n",

                WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));

        System.out.printf("\tcompiled:\t%b%n",

                WHITE_BOX.isMethodCompiled(method, false));

        System.out.printf("\tcomp_level:\t%d%n",

                WHITE_BOX.getMethodCompilationLevel(method, false));

        System.out.printf("\tosr_compilable:\t%b%n",

                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());

    }

    /**

     * Executes testing.

     */

    protected abstract void test() throws Exception;

    /**

     * Tries to trigger compilation of {@linkplain #method} by call

     * {@linkplain TestCase#getCallable()} enough times.

     *

     * @return accumulated result

     * @see #compile(int)

     */

    protected final int compile() {

        if (testCase.isOsr()) {

            return compile(1);

        } else {

            return compile(THRESHOLD);

        }

    }

    /**

     * Tries to trigger compilation of {@linkplain #method} by call

     * {@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.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 {

    /** 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);

    private final Executable executable;

    private final Callable<Integer> callable;

    private final boolean isOsr;

    private SimpleTestCase(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

                = new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                return new Helper(1337).hashCode();

            }

        };

        private static final Callable<Integer> METHOD_CALLABLE

                = new Callable<Integer>() {

            private final Helper helper = new Helper();

            @Override

            public Integer call() throws Exception {

                return helper.method();

            }

        };

        private static final Callable<Integer> STATIC_CALLABLE

                = new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                return staticMethod();

            }

        };

        private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE

                = new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                return new Helper(null).hashCode();

            }

        };

        private static final Callable<Integer> OSR_METHOD_CALLABLE

                = new Callable<Integer>() {

            private final Helper helper = new Helper();

            @Override

            public Integer call() throws Exception {

                return helper.osrMethod();