--- /dev/null 2014-09-08 10:40:15.076620215 +0400 +++ new/test/compiler/codecache/cli/TestSegmentedCodeCacheOption.java 2014-12-05 20:56:33.949932255 +0400 @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2014, 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.oracle.java.testlibrary.ExitCode; +import com.oracle.java.testlibrary.Platform; +import com.oracle.java.testlibrary.cli.CommandLineOptionTest; +import common.CodeCacheOptions; +import sun.hotspot.code.BlobType; + +/** + * @test + * @summary Verify SegmentedCodeCache option's processing + * @library /testlibrary /testlibrary/whitebox + * @build TestSegmentedCodeCacheOption com.oracle.java.testlibrary.* + * @run main TestSegmentedCodeCacheOption + */ +public class TestSegmentedCodeCacheOption { + private static final String INT_MODE = "-Xint"; + private static final String TIERED_COMPILATION = "TieredCompilation"; + private static final String SEGMENTED_CODE_CACHE = "SegmentedCodeCache"; + private static final String USE_SEGMENTED_CODE_CACHE + = CommandLineOptionTest.prepareBooleanFlag(SEGMENTED_CODE_CACHE, + true); + private static final long THRESHOLD_CC_SIZE_VALUE + = CodeCacheOptions.mB(240); + private static final long BELOW_THRESHOLD_CC_SIZE + = THRESHOLD_CC_SIZE_VALUE - CodeCacheOptions.mB(1); + private static final String[] UNEXPECTED_MESSAGES = new String[] { + ".*" + SEGMENTED_CODE_CACHE + ".*" + }; + + + private static enum TestCase { + JVM_STARTUP { + @Override + public void run() throws Throwable { + // There should be no errors when we're trying to enable SCC ... + String testCaseWarningMessage = "JVM output should not contain " + + "any warnings related to " + SEGMENTED_CODE_CACHE; + String testCaseExitCodeMessage = "JVM should start without any " + + "issues with " + USE_SEGMENTED_CODE_CACHE; + + CommandLineOptionTest.verifySameJVMStartup( + /* expectedMessages */ null, UNEXPECTED_MESSAGES, + testCaseExitCodeMessage, testCaseWarningMessage, + ExitCode.OK, USE_SEGMENTED_CODE_CACHE); + // ... and when we're trying to enable it w/o TieredCompilation + testCaseExitCodeMessage = "Disabled tiered compilation should " + + "not cause startup failure w/ " + + USE_SEGMENTED_CODE_CACHE; + + CommandLineOptionTest.verifySameJVMStartup( + /* expectedMessages */ null, UNEXPECTED_MESSAGES, + testCaseExitCodeMessage, testCaseWarningMessage, + ExitCode.OK, USE_SEGMENTED_CODE_CACHE, + CommandLineOptionTest.prepareBooleanFlag( + TIERED_COMPILATION, false)); + // ... and even w/ Xint. + testCaseExitCodeMessage = "It should be possible to use " + + USE_SEGMENTED_CODE_CACHE + " in interpreted mode " + + "without any errors."; + + CommandLineOptionTest.verifyJVMStartup( + /* expected messages */ null, UNEXPECTED_MESSAGES, + ExitCode.OK, testCaseExitCodeMessage, + testCaseWarningMessage, false, INT_MODE, + USE_SEGMENTED_CODE_CACHE); + } + }, + OPTION_VALUES_GENERIC { + @Override + public void run() throws Throwable { + // SCC is disabled w/o TieredCompilation by default + String errorMessage = SEGMENTED_CODE_CACHE + + " should be disabled by default when tiered " + + "compilation is disabled"; + + CommandLineOptionTest.verifyOptionValueForSameVM( + SEGMENTED_CODE_CACHE, "false", errorMessage, + CommandLineOptionTest.prepareBooleanFlag( + TIERED_COMPILATION, false)); + // SCC is disabled by default when ReservedCodeCacheSize is too + // small + errorMessage = String.format("%s should be disabled bu default " + + "when %s value is too small.", SEGMENTED_CODE_CACHE, + BlobType.All.sizeOptionName); + + CommandLineOptionTest.verifyOptionValueForSameVM( + SEGMENTED_CODE_CACHE, "false", errorMessage, + CommandLineOptionTest.prepareNumericFlag( + BlobType.All.sizeOptionName, + BELOW_THRESHOLD_CC_SIZE)); + // SCC could be explicitly enabled w/ Xint + errorMessage = String.format("It should be possible to " + + "explicitly enable %s in interpreted mode.", + SEGMENTED_CODE_CACHE); + + CommandLineOptionTest.verifyOptionValue(SEGMENTED_CODE_CACHE, + "true", errorMessage, false, INT_MODE, + USE_SEGMENTED_CODE_CACHE); + // SCC could be explicitly enabled w/o TieredCompilation and w/ + // small ReservedCodeCacheSize value + errorMessage = String.format("It should be possible to " + + "explicitly enable %s with small %s and " + + "disabled tiered comp.", SEGMENTED_CODE_CACHE, + BlobType.All.sizeOptionName); + + CommandLineOptionTest.verifyOptionValueForSameVM( + SEGMENTED_CODE_CACHE, "true", errorMessage, + CommandLineOptionTest.prepareBooleanFlag( + TIERED_COMPILATION, false), + CommandLineOptionTest.prepareNumericFlag( + BlobType.All.sizeOptionName, + BELOW_THRESHOLD_CC_SIZE), + USE_SEGMENTED_CODE_CACHE); + } + }, + OPTION_VALUES_SERVER_SPECIFIC { + @Override + public boolean isApplicable() { + return Platform.isServer(); + } + + @Override + public void run() throws Throwable { + // SCC is enabled by default when TieredCompilation is on and + // ReservedCodeCacheSize is large enough + String errorMessage = String.format("Large enough %s and " + + "enabled tiered compilation should enable %s " + + "by default.", BlobType.All.sizeOptionName, + SEGMENTED_CODE_CACHE); + + CommandLineOptionTest.verifyOptionValueForSameVM( + SEGMENTED_CODE_CACHE, "true", errorMessage, + CommandLineOptionTest.prepareNumericFlag( + BlobType.All.sizeOptionName, + THRESHOLD_CC_SIZE_VALUE), + CommandLineOptionTest.prepareBooleanFlag( + TIERED_COMPILATION, true)); + } + }; + + TestCase() { + } + + public boolean isApplicable() { + return true; + } + + public abstract void run() throws Throwable; + } + + public static void main(String args[]) throws Throwable { + for (TestCase testCase : TestCase.values()) { + if (testCase.isApplicable()) { + System.out.println("Running test case: " + testCase.name()); + testCase.run(); + } else { + System.out.println("Test case skipped: " + testCase.name()); + } + } + } +}