/* * Copyright (C) 2017 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ public class Main { public static void main(String[] args) throws Exception { System.loadLibrary(args[0]); if (isAotCompiled(Main.class, "hasJit")) { throw new Error("This test must be run with --no-prebuild!"); } if (!hasJit()) { return; } testCompilationUseAndCollection(); testMixedFramesOnStack(); } public static void testCompilationUseAndCollection() { // Test that callThrough() can be JIT-compiled. assertFalse(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertFalse(hasJitCompiledCode(Main.class, "callThrough")); ensureCompiledCallThroughEntrypoint(/* call */ true); assertTrue(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertTrue(hasJitCompiledCode(Main.class, "callThrough")); // Use callThrough() once again now that the method has a JIT-compiled stub. callThrough(Main.class, "doNothing"); // Test that GC with the JIT-compiled stub on the stack does not collect it. // Also tests stack walk over the JIT-compiled stub. callThrough(Main.class, "testGcWithCallThroughStubOnStack"); // Test that, when marking used methods before a full JIT GC, a single execution // of the GenericJNI trampoline can save the compiled stub from being collected. testSingleInvocationTriggersRecompilation(); // Test that the JNI compiled stub can actually be collected. testStubCanBeCollected(); } public static void testGcWithCallThroughStubOnStack() { // Check that this method was called via JIT-compiled callThrough() stub. assertTrue(hasJitCompiledEntrypoint(Main.class, "callThrough")); // This assertion also exercises stack walk over the JIT-compiled callThrough() stub. assertTrue(new Throwable().getStackTrace()[1].getMethodName().equals("callThrough")); doJitGcsUntilFullJitGcIsScheduled(); // The callThrough() on the stack above this method is using the compiled stub, // so the JIT GC should not remove the compiled code. jitGc(); assertTrue(hasJitCompiledCode(Main.class, "callThrough")); } public static void testSingleInvocationTriggersRecompilation() { // After scheduling a full JIT GC, single call through the GenericJNI // trampoline should ensure that the compiled stub is used again. doJitGcsUntilFullJitGcIsScheduled(); callThrough(Main.class, "doNothing"); ensureCompiledCallThroughEntrypoint(/* call */ false); // Wait for the compilation task to run. assertTrue(hasJitCompiledEntrypoint(Main.class, "callThrough")); jitGc(); // This JIT GC should not collect the callThrough() stub. assertTrue(hasJitCompiledCode(Main.class, "callThrough")); } public static void testMixedFramesOnStack() { // Starts without a compiled JNI stub for callThrough(). assertFalse(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertFalse(hasJitCompiledCode(Main.class, "callThrough")); callThrough(Main.class, "testMixedFramesOnStackStage2"); // We have just returned through the JIT-compiled JNI stub, so it must still // be compiled (though not necessarily with the entrypoint pointing to it). assertTrue(hasJitCompiledCode(Main.class, "callThrough")); // Though the callThrough() is on the stack, that frame is using the GenericJNI // and does not prevent the collection of the JNI stub. testStubCanBeCollected(); } public static void testMixedFramesOnStackStage2() { // We cannot assert that callThrough() has no JIT compiled stub as that check // may race against the compilation task. Just check the caller. assertTrue(new Throwable().getStackTrace()[1].getMethodName().equals("callThrough")); // Now ensure that the JNI stub is compiled and used. ensureCompiledCallThroughEntrypoint(/* call */ true); callThrough(Main.class, "testMixedFramesOnStackStage3"); } public static void testMixedFramesOnStackStage3() { // Check that this method was called via JIT-compiled callThrough() stub. assertTrue(hasJitCompiledEntrypoint(Main.class, "callThrough")); // This assertion also exercises stack walk over the JIT-compiled callThrough() stub. assertTrue(new Throwable().getStackTrace()[1].getMethodName().equals("callThrough")); // For a good measure, try a JIT GC. jitGc(); } public static void testStubCanBeCollected() { assertTrue(hasJitCompiledCode(Main.class, "callThrough")); doJitGcsUntilFullJitGcIsScheduled(); assertFalse(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertTrue(hasJitCompiledCode(Main.class, "callThrough")); jitGc(); // JIT GC without callThrough() on the stack should collect the callThrough() stub. assertFalse(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertFalse(hasJitCompiledCode(Main.class, "callThrough")); } public static void doJitGcsUntilFullJitGcIsScheduled() { // We enter with a compiled stub for callThrough() but we also need the entrypoint to be set. assertTrue(hasJitCompiledCode(Main.class, "callThrough")); ensureCompiledCallThroughEntrypoint(/* call */ true); // Perform JIT GC until the next GC is marked to do full collection. do { assertTrue(hasJitCompiledEntrypoint(Main.class, "callThrough")); callThrough(Main.class, "jitGc"); // JIT GC with callThrough() safely on the stack. } while (!isNextJitGcFull()); // The JIT GC before the full collection resets entrypoints and waits to see // if the methods are still in use. assertFalse(hasJitCompiledEntrypoint(Main.class, "callThrough")); assertTrue(hasJitCompiledCode(Main.class, "callThrough")); } public static void ensureCompiledCallThroughEntrypoint(boolean call) { int count = 0; while (!hasJitCompiledEntrypoint(Main.class, "callThrough")) { // If `call` is true, also exercise the `callThrough()` method to increase hotness. // Ramp-up the number of calls we do up to 1 << 12. final int rampUpCutOff = 12; int limit = call ? 1 << Math.min(count, rampUpCutOff) : 0; for (int i = 0; i < limit; ++i) { callThrough(Main.class, "doNothing"); } try { // Sleep to give a chance for the JIT to compile `callThrough` stub. // After the ramp-up phase, give the JIT even more time to compile. Thread.sleep(count >= rampUpCutOff ? 200 : 100); } catch (Exception e) { // Ignore } if (++count == 50) { throw new Error("TIMEOUT"); } }; } public static void assertTrue(boolean value) { if (!value) { throw new AssertionError("Expected true!"); } } public static void assertFalse(boolean value) { if (value) { throw new AssertionError("Expected false!"); } } public static void doNothing() { } public static void throwError() { throw new Error(); } // Note that the callThrough()'s shorty differs from shorties of the other // native methods used in this test because of the return type `void.` public native static void callThrough(Class<?> cls, String methodName); public native static void jitGc(); public native static boolean isNextJitGcFull(); public native static boolean isAotCompiled(Class<?> cls, String methodName); public native static boolean hasJitCompiledEntrypoint(Class<?> cls, String methodName); public native static boolean hasJitCompiledCode(Class<?> cls, String methodName); private native static boolean hasJit(); }