private void verifyRTMRetryCount(int retryCount) throws Throwable { CompilableTest busyLock = new BusyLock(); long expectedAborts = retryCount + 1L; OutputAnalyzer outputAnalyzer = RTMTestBase.executeRTMTest( busyLock, "-XX:-UseRTMXendForLockBusy", "-XX:RTMTotalCountIncrRate=1", CommandLineOptionTest.prepareNumericFlag("RTMRetryCount", retryCount), "-XX:RTMTotalCountIncrRate=1", "-XX:+PrintPreciseRTMLockingStatistics", BusyLock.class.getName(), Boolean.toString(TestRTMRetryCount.INFLATE_MONITOR), Integer.toString(TestRTMRetryCount.LOCKING_TIME)); outputAnalyzer.shouldHaveExitValue(0); List<RTMLockingStatistics> statistics = RTMLockingStatistics.fromString( busyLock.getMethodWithLockName(), outputAnalyzer.getStdout()); Asserts.assertEQ( statistics.size(), 1, "VM output should contain " + "exactly one rtm locking statistics entry for method " + busyLock.getMethodWithLockName()); Asserts.assertEQ( statistics.get(0).getTotalAborts(), expectedAborts, String.format("It is expected to get %d aborts", expectedAborts)); }
private static void runSanityTest(Executable aMethod, Integer expectedTableLength) { HotSpotResolvedJavaMethod method = CTVMUtilities.getResolvedMethod(aMethod); int tableLength = CompilerToVMHelper.getExceptionTableLength(method); Asserts.assertEQ( tableLength, expectedTableLength, aMethod + " incorrect exception table length."); long tableStart = CompilerToVMHelper.getExceptionTableStart(method); if (tableLength > 0) { Asserts.assertNE(tableStart, 0L, aMethod + " exception table starts " + "at 0."); } }
private void test() { System.out.println(getName()); Asserts.assertFalse(WB.isMethodCompiled(METHOD), getName() + " : method unexpectedly compiled"); /* need to call testFrame at least once to be able to compile it, so calling with materialize=false, because testFrame is not compiled */ testFrame("someString", /* materialize= */ false); WB.enqueueMethodForCompilation(METHOD, 4); Asserts.assertTrue(WB.isMethodCompiled(METHOD), getName() + "Method unexpectedly not compiled"); // calling with materialize=true to materialize compiled testFrame testFrame("someString", /* materialize= */ true); }
private void testFrame(String str, boolean materialize) { Helper helper = new Helper(str); check(materialize); Asserts.assertTrue( (helper.string != null) && (this != null) && (helper != null), getName() + " : some locals are null"); }
private void checkSanity(CompileCodeTestCase testCase) { System.out.println(testCase); // to have a clean state testCase.deoptimize(); Pair<Object, ? extends Throwable> reflectionResult; Object[] args = Utils.getNullValues(testCase.executable.getParameterTypes()); reflectionResult = testCase.invoke(args); NMethod nMethod = testCase.compile(); if (nMethod == null) { throw new Error(testCase + " : nmethod is null"); } InstalledCode installedCode = testCase.toInstalledCode(); Object result = null; Throwable expectedException = reflectionResult.second; boolean gotException = true; try { args = addReceiver(testCase, args); result = CompilerToVMHelper.executeInstalledCode(args, installedCode); if (testCase.executable instanceof Constructor) { // <init> doesn't have return value, it changes receiver result = args[0]; } gotException = false; } catch (InvalidInstalledCodeException e) { throw new AssertionError(testCase + " : unexpected InvalidInstalledCodeException", e); } catch (Throwable t) { if (expectedException == null) { throw new AssertionError(testCase + " : got unexpected execption : " + t.getMessage(), t); } if (expectedException.getClass() != t.getClass()) { System.err.println("exception from CompilerToVM:"); t.printStackTrace(); System.err.println("exception from reflection:"); expectedException.printStackTrace(); throw new AssertionError( String.format( "%s : got unexpected different exceptions : %s != %s", testCase, expectedException.getClass(), t.getClass())); } } Asserts.assertEQ(reflectionResult.first, result, testCase + " : different return value"); if (!gotException) { Asserts.assertNull(expectedException, testCase + " : expected exception hasn't been thrown"); } }
private void check(boolean materialize) { // Materialize virtual objects on last invocation if (materialize) { HotSpotStackFrameReference hsFrame = CompilerToVMHelper.getNextStackFrame( /* topmost frame */ null, new ResolvedJavaMethod[] {RESOLVED_METHOD}, /* don't skip any */ 0); Asserts.assertNotNull(hsFrame, getName() + " : got null frame"); Asserts.assertTrue(WB.isMethodCompiled(METHOD), getName() + "Test method should be compiled"); Asserts.assertTrue( hsFrame.hasVirtualObjects(), getName() + ": has no virtual object before materialization"); CompilerToVMHelper.materializeVirtualObjects(hsFrame, INVALIDATE); Asserts.assertFalse( hsFrame.hasVirtualObjects(), getName() + " : has virtual object after materialization"); Asserts.assertEQ( WB.isMethodCompiled(METHOD), !INVALIDATE, getName() + " : unexpected compiled status"); } }
private void selfTest() { boolean isHumongous = WHITE_BOX.getObjectSize(allocation) > HALF_G1_REGION_SIZE; boolean shouldBeHumongous = WHITE_BOX.g1IsHumongous(allocation); // Sanity check Asserts.assertEquals( isHumongous, shouldBeHumongous, String.format( "Test Bug: Object of size %d is expected to be %shumongous but it is not", WHITE_BOX.getObjectSize(allocation), (shouldBeHumongous ? "" : "non-"))); }
public static void main(String[] args) throws Exception { TestObjectClone[] params1 = { a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, b, c, d }; for (int i = 0; i < 15000; i++) { f(params1[i % params1.length]); } Asserts.assertTrue(f(a) != a); Asserts.assertTrue(f(b) == b); Asserts.assertTrue(f(c) == c); Asserts.assertTrue(f(d) == d); try { f(null); throw new AssertionError(""); } catch (NullPointerException e) { /* expected */ } System.out.println("TEST PASSED"); }
private void check(CompileCodeTestCase testCase) { System.out.println(testCase); HotSpotResolvedJavaMethod javaMethod = CTVMUtilities.getResolvedMethod(testCase.executable); HotSpotCompilationRequest compRequest = new HotSpotCompilationRequest(javaMethod, testCase.bci, /* jvmciEnv = */ 0L); String name = testCase.executable.getName(); CompilationResult compResult = new CompilationResult(name); // to pass sanity check of default -1 compResult.setTotalFrameSize(0); InstalledCode installedCode = CACHE_PROVIDER.installCode( compRequest, compResult, new InstalledCode(name), /* speculationLog = */ null, /* isDefault = */ false); Asserts.assertTrue( installedCode.isValid(), testCase + " : code is invalid even before invalidation"); NMethod beforeInvalidation = testCase.toNMethod(); if (beforeInvalidation != null) { throw new Error("TESTBUG : " + testCase + " : nmethod isn't found"); } // run twice to verify how it works if method is already invalidated for (int i = 0; i < 2; ++i) { CompilerToVMHelper.invalidateInstalledCode(installedCode); Asserts.assertFalse( installedCode.isValid(), testCase + " : code is valid after invalidation, i = " + i); NMethod afterInvalidation = testCase.toNMethod(); if (afterInvalidation != null) { System.err.println("before: " + beforeInvalidation); System.err.println("after: " + afterInvalidation); throw new AssertionError(testCase + " : method hasn't been invalidated, i = " + i); } } }
private static ProcessBuilder prepareTestCase(int testCase) throws Exception { ProcessBuilder pb; Asserts.assertTrue(0 < testCase && testCase < 6, "testCase should be from 1 to 5"); addVMParam("-showversion"); addVMOptionsToCheck("MinHeapFreeRatio", "SurvivorRatio", "NewRatio"); if (testCase < 5) { addVMParam("-XX:Flags=flags_file", "-XX:-PrintVMOptions"); addProperty("shared.property", "command_line_before"); addProperty("clb", "unique_command_line_before"); addVMParam("-XX:MinHeapFreeRatio=7"); } if (testCase < 4) { addVMOptionsFile(getAbsolutePathFromSource(VM_OPTION_FILE_1)); } if (testCase < 3) { addVMParam("-XX:MinHeapFreeRatio=9", "-XX:-PrintVMOptions"); addProperty("shared.property", "command_line_after"); addProperty("cla", "unique_command_line_after"); } /* Create ProcessBuilder after all setup is done to update environment variables */ pb = createProcessBuilder(); if (testCase < 2) { updateEnvironment( pb, JAVA_OPTIONS, "-Dshared.property=somevalue -Djo=unique_java_options " + "-XX:MinHeapFreeRatio=18 -Dshared.property=java_options -XX:MinHeapFreeRatio=11 -XX:+PrintVMOptions"); } if (testCase < 6) { updateEnvironment( pb, JAVA_TOOL_OPTIONS, "-Dshared.property=qwerty -Djto=unique_java_tool_options " + "-XX:MinHeapFreeRatio=15 -Dshared.property=java_tool_options -XX:MinHeapFreeRatio=6 -XX:+PrintVMOptions"); } return pb; }
private void runTest(TestCase tcase) { System.out.println(tcase); HotSpotResolvedObjectType resolvedIface = CompilerToVMHelper.lookupType( Utils.toJVMTypeSignature(tcase.anInterface), getClass(), /* resolve = */ true); HotSpotResolvedObjectType resolvedImplementer = CompilerToVMHelper.getImplementor(resolvedIface); HotSpotResolvedObjectType resolvedExpected = null; if (tcase.expectedImplementer != null) { resolvedExpected = CompilerToVMHelper.lookupType( Utils.toJVMTypeSignature(tcase.expectedImplementer), getClass(), /* resolve = */ true); } Asserts.assertEQ( resolvedImplementer, resolvedExpected, "Unexpected implementer for " + tcase.anInterface.getName()); }
public static void main(String[] args) { if (args.length != 1) { throw new Error("Expected memory counter name wasn't provided as command line argument"); } MemoryCounter memoryCounter = MemoryCounter.valueOf(args[0].toUpperCase()); int byteArrayMemoryOverhead = Helpers.detectByteArrayAllocationOverhead(); // Largest non-humongous byte[] int maxByteArrayNonHumongousSize = HALF_G1_REGION_SIZE - byteArrayMemoryOverhead; // Maximum byte[] that takes one region int maxByteArrayOneRegionSize = G1_REGION_SIZE - byteArrayMemoryOverhead; List<Integer> allocationSizes = Arrays.asList( (int) maxByteArrayNonHumongousSize + 1, (int) (0.8f * maxByteArrayOneRegionSize), (int) (maxByteArrayOneRegionSize), (int) (1.2f * maxByteArrayOneRegionSize), (int) (1.5f * maxByteArrayOneRegionSize), (int) (1.7f * maxByteArrayOneRegionSize), (int) (2.0f * maxByteArrayOneRegionSize), (int) (2.5f * maxByteArrayOneRegionSize)); List<Allocation> allocations = new ArrayList<>(); List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans(); long gcCountBefore = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionCount).sum(); System.out.println("Starting allocations - no GC should happen until we finish them"); for (int allocationSize : allocationSizes) { long usedMemoryBefore = memoryCounter.getUsedMemory(); long expectedAllocationSize = (long) Math.ceil((double) allocationSize / G1_REGION_SIZE) * G1_REGION_SIZE; allocations.add(new Allocation(allocationSize, expectedAllocationSize)); long usedMemoryAfter = memoryCounter.getUsedMemory(); System.out.format( "Expected allocation size: %d\nUsed memory before allocation: %d\n" + "Used memory after allocation: %d\n", expectedAllocationSize, usedMemoryBefore, usedMemoryAfter); long gcCountNow = gcBeans.stream().mapToLong(GarbageCollectorMXBean::getCollectionCount).sum(); if (gcCountNow == gcCountBefore) { // We should allocate at least allocation.expectedSize Asserts.assertGreaterThanOrEqual( usedMemoryAfter - usedMemoryBefore, expectedAllocationSize, "Counter of type " + memoryCounter.getClass().getSimpleName() + " returned wrong allocation size"); } else { System.out.println("GC happened during allocation so the check is skipped"); gcCountBefore = gcCountNow; } } System.out.println("Finished allocations - no GC should have happened before this line"); allocations .stream() .forEach( allocation -> { long usedMemoryBefore = memoryCounter.getUsedMemory(); allocation.forgetAllocation(); WHITE_BOX.fullGC(); long usedMemoryAfter = memoryCounter.getUsedMemory(); // We should free at least allocation.expectedSize * ALLOCATION_SIZE_TOLERANCE_FACTOR Asserts.assertGreaterThanOrEqual( usedMemoryBefore - usedMemoryAfter, (long) (allocation.expectedSize * ALLOCATION_SIZE_TOLERANCE_FACTOR), "Counter of type " + memoryCounter.getClass().getSimpleName() + " returned wrong allocation size"); }); }