Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/test/compiler/rtm/cli/TestRTMRetryCountOption.java	Mon Aug 11 11:43:22 2014 -0700
     1.2 +++ b/test/compiler/rtm/cli/TestRTMRetryCountOption.java	Mon Aug 11 19:19:47 2014 +0400
     1.3 @@ -35,7 +35,7 @@
     1.4      private static final String DEFAULT_VALUE = "5";
     1.5  
     1.6      private TestRTMRetryCountOption() {
     1.7 -        super(Boolean.TRUE::booleanValue, "RTMRetryCount", false, true,
     1.8 +        super(Boolean.TRUE::booleanValue, "RTMRetryCount", false, false,
     1.9                  TestRTMRetryCountOption.DEFAULT_VALUE,
    1.10                  "0", "10", "100", "1000");
    1.11      }

     2.1 --- a/test/compiler/rtm/cli/TestUseRTMDeoptOptionOnSupportedConfig.java	Mon Aug 11 11:43:22 2014 -0700
     2.2 +++ b/test/compiler/rtm/cli/TestUseRTMDeoptOptionOnSupportedConfig.java	Mon Aug 11 19:19:47 2014 +0400
     2.3 @@ -50,38 +50,25 @@
     2.4  
     2.5      @Override
     2.6      public void runTestCases() throws Throwable {
     2.7 -        String experimentalOptionError
     2.8 -                = CommandLineOptionTest.getExperimentalOptionErrorMessage(
     2.9 -                "UseRTMDeopt");
    2.10 -        // verify that option is experimental
    2.11 +        // verify that option could be turned on
    2.12          CommandLineOptionTest.verifySameJVMStartup(
    2.13 -                new String[] { experimentalOptionError }, null, ExitCode.FAIL,
    2.14 -                "-XX:+UseRTMDeopt");
    2.15 -        // verify that option could be turned on
    2.16 -        CommandLineOptionTest.verifySameJVMStartup(null, null, ExitCode.OK,
    2.17 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    2.18 -                "-XX:+UseRTMDeopt");
    2.19 +                null, null, ExitCode.OK, "-XX:+UseRTMDeopt");
    2.20          // verify that option could be turned off
    2.21 -        CommandLineOptionTest.verifySameJVMStartup(null, null, ExitCode.OK,
    2.22 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    2.23 -                "-XX:-UseRTMDeopt");
    2.24 +        CommandLineOptionTest.verifySameJVMStartup(
    2.25 +                null, null, ExitCode.OK, "-XX:-UseRTMDeopt");
    2.26 +        // verify default value
    2.27 +        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
    2.28 +                TestUseRTMDeoptOptionOnSupportedConfig.DEFAULT_VALUE);
    2.29          // verify default value
    2.30          CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
    2.31                  TestUseRTMDeoptOptionOnSupportedConfig.DEFAULT_VALUE,
    2.32 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
    2.33 -        // verify default value
    2.34 -        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
    2.35 -                TestUseRTMDeoptOptionOnSupportedConfig.DEFAULT_VALUE,
    2.36 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    2.37                  "-XX:+UseRTMLocking");
    2.38          // verify that option is off when UseRTMLocking is off
    2.39 -        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt", "false",
    2.40 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    2.41 -                "-XX:-UseRTMLocking", "-XX:+UseRTMDeopt");
    2.42 +        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
    2.43 +                "false", "-XX:-UseRTMLocking", "-XX:+UseRTMDeopt");
    2.44          // verify that option could be turned on
    2.45 -        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt", "true",
    2.46 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    2.47 -                "-XX:+UseRTMLocking", "-XX:+UseRTMDeopt");
    2.48 +        CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
    2.49 +                "true", "-XX:+UseRTMLocking", "-XX:+UseRTMDeopt");
    2.50      }
    2.51  
    2.52      public static void main(String args[]) throws Throwable {

     3.1 --- a/test/compiler/rtm/cli/TestUseRTMDeoptOptionOnUnsupportedConfig.java	Mon Aug 11 11:43:22 2014 -0700
     3.2 +++ b/test/compiler/rtm/cli/TestUseRTMDeoptOptionOnUnsupportedConfig.java	Mon Aug 11 19:19:47 2014 +0400
     3.3 @@ -48,7 +48,7 @@
     3.4      private TestUseRTMDeoptOptionOnUnsupportedConfig() {
     3.5          super(new NotPredicate(new AndPredicate(new SupportedCPU(),
     3.6                          new SupportedVM())),
     3.7 -                "UseRTMDeopt", true, true,
     3.8 +                "UseRTMDeopt", true, false,
     3.9                  TestUseRTMDeoptOptionOnUnsupportedConfig.DEFAULT_VALUE, "true");
    3.10      }
    3.11  
    3.12 @@ -57,14 +57,11 @@
    3.13          super.verifyJVMStartup();
    3.14          // verify default value
    3.15          CommandLineOptionTest.verifyOptionValueForSameVM(optionName,
    3.16 -                defaultValue,
    3.17 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
    3.18 +                defaultValue);
    3.19          // verify that until RTMLocking is not used, value
    3.20          // will be set to default false.
    3.21          CommandLineOptionTest.verifyOptionValueForSameVM(optionName,
    3.22 -                defaultValue,
    3.23 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    3.24 -                "-XX:+UseRTMDeopt");
    3.25 +                defaultValue, "-XX:+UseRTMDeopt");
    3.26      }
    3.27  
    3.28      public static void main(String args[]) throws Throwable {

     4.1 --- a/test/compiler/rtm/cli/TestUseRTMLockingOptionOnSupportedConfig.java	Mon Aug 11 11:43:22 2014 -0700
     4.2 +++ b/test/compiler/rtm/cli/TestUseRTMLockingOptionOnSupportedConfig.java	Mon Aug 11 19:19:47 2014 +0400
     4.3 @@ -51,43 +51,31 @@
     4.4      @Override
     4.5      public void runTestCases() throws Throwable {
     4.6          String unrecongnizedOption
     4.7 -                = CommandLineOptionTest.getUnrecognizedOptionErrorMessage(
     4.8 +                =  CommandLineOptionTest.getUnrecognizedOptionErrorMessage(
     4.9                  "UseRTMLocking");
    4.10 -        String experimentalOptionError
    4.11 -                = CommandLineOptionTest.getExperimentalOptionErrorMessage(
    4.12 -                "UseRTMLocking");
    4.13 -        // verify that options is experimental
    4.14 -        CommandLineOptionTest.verifySameJVMStartup(
    4.15 -                new String[] { experimentalOptionError }, null, ExitCode.FAIL,
    4.16 -                "-XX:+UseRTMLocking");
    4.17          // verify that there are no warning or error in VM output
    4.18          CommandLineOptionTest.verifySameJVMStartup(null,
    4.19                  new String[]{
    4.20                          RTMGenericCommandLineOptionTest.RTM_INSTR_ERROR,
    4.21                          unrecongnizedOption
    4.22 -                }, ExitCode.OK,
    4.23 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    4.24 -                "-XX:+UseRTMLocking");
    4.25 +                }, ExitCode.OK, "-XX:+UseRTMLocking"
    4.26 +        );
    4.27  
    4.28          CommandLineOptionTest.verifySameJVMStartup(null,
    4.29                  new String[]{
    4.30                          RTMGenericCommandLineOptionTest.RTM_INSTR_ERROR,
    4.31                          unrecongnizedOption
    4.32 -                }, ExitCode.OK,
    4.33 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    4.34 -                "-XX:-UseRTMLocking");
    4.35 +                }, ExitCode.OK, "-XX:-UseRTMLocking"
    4.36 +        );
    4.37          // verify that UseRTMLocking is of by default
    4.38          CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
    4.39 -                TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE,
    4.40 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
    4.41 +                TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE);
    4.42          // verify that we can change UseRTMLocking value
    4.43          CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
    4.44                  TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE,
    4.45 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    4.46                  "-XX:-UseRTMLocking");
    4.47          CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
    4.48 -                "true", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    4.49 -                "-XX:+UseRTMLocking");
    4.50 +                "true", "-XX:+UseRTMLocking");
    4.51      }
    4.52  
    4.53      public static void main(String args[]) throws Throwable {

     5.1 --- a/test/compiler/rtm/cli/TestUseRTMLockingOptionOnUnsupportedCPU.java	Mon Aug 11 11:43:22 2014 -0700
     5.2 +++ b/test/compiler/rtm/cli/TestUseRTMLockingOptionOnUnsupportedCPU.java	Mon Aug 11 19:19:47 2014 +0400
     5.3 @@ -63,9 +63,7 @@
     5.4              CommandLineOptionTest.verifySameJVMStartup(
     5.5                      new String[] { errorMessage },
     5.6                      new String[] { unrecongnizedOption },
     5.7 -                    ExitCode.FAIL,
     5.8 -                    CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
     5.9 -                    "-XX:+UseRTMLocking");
    5.10 +                    ExitCode.FAIL, "-XX:+UseRTMLocking");
    5.11              // verify that we can pass -UseRTMLocking without
    5.12              // getting any error messages
    5.13              CommandLineOptionTest.verifySameJVMStartup(
    5.14 @@ -73,27 +71,20 @@
    5.15                      new String[]{
    5.16                              errorMessage,
    5.17                              unrecongnizedOption
    5.18 -                    }, ExitCode.OK,
    5.19 -                    CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    5.20 -                    "-XX:-UseRTMLocking");
    5.21 +                    }, ExitCode.OK, "-XX:-UseRTMLocking");
    5.22  
    5.23              // verify that UseRTMLocking is false by default
    5.24              CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
    5.25 -                    TestUseRTMLockingOptionOnUnsupportedCPU.DEFAULT_VALUE,
    5.26 -                    CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
    5.27 +                    TestUseRTMLockingOptionOnUnsupportedCPU.DEFAULT_VALUE);
    5.28          } else {
    5.29              // verify that on non-x86 CPUs RTMLocking could not be used
    5.30              CommandLineOptionTest.verifySameJVMStartup(
    5.31                      new String[] { unrecongnizedOption },
    5.32 -                    null, ExitCode.FAIL,
    5.33 -                    CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    5.34 -                    "-XX:+UseRTMLocking");
    5.35 +                    null, ExitCode.FAIL, "-XX:+UseRTMLocking");
    5.36  
    5.37              CommandLineOptionTest.verifySameJVMStartup(
    5.38                      new String[] { unrecongnizedOption },
    5.39 -                    null, ExitCode.FAIL,
    5.40 -                    CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    5.41 -                    "-XX:-UseRTMLocking");
    5.42 +                    null, ExitCode.FAIL, "-XX:-UseRTMLocking");
    5.43          }
    5.44      }
    5.45  

     6.1 --- a/test/compiler/rtm/cli/TestUseRTMLockingOptionOnUnsupportedVM.java	Mon Aug 11 11:43:22 2014 -0700
     6.2 +++ b/test/compiler/rtm/cli/TestUseRTMLockingOptionOnUnsupportedVM.java	Mon Aug 11 19:19:47 2014 +0400
     6.3 @@ -53,27 +53,17 @@
     6.4      public void runTestCases() throws Throwable {
     6.5          String errorMessage
     6.6                  = RTMGenericCommandLineOptionTest.RTM_UNSUPPORTED_VM_ERROR;
     6.7 -        String experimentalOptionError
     6.8 -                = CommandLineOptionTest.getExperimentalOptionErrorMessage(
     6.9 -                "UseRTMLocking");
    6.10 -        // verify that options is experimental
    6.11 -        CommandLineOptionTest.verifySameJVMStartup(
    6.12 -                new String[] { experimentalOptionError }, null, ExitCode.FAIL,
    6.13 -                "-XX:+UseRTMLocking");
    6.14          // verify that we can't use +UseRTMLocking
    6.15          CommandLineOptionTest.verifySameJVMStartup(
    6.16                  new String[] { errorMessage }, null, ExitCode.FAIL,
    6.17 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    6.18                  "-XX:+UseRTMLocking");
    6.19          // verify that we can turn it off
    6.20          CommandLineOptionTest.verifySameJVMStartup(null,
    6.21                  new String[] { errorMessage }, ExitCode.OK,
    6.22 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    6.23                  "-XX:-UseRTMLocking");
    6.24          // verify that it is off by default
    6.25          CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
    6.26 -                TestUseRTMLockingOptionOnUnsupportedVM.DEFAULT_VALUE,
    6.27 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
    6.28 +                TestUseRTMLockingOptionOnUnsupportedVM.DEFAULT_VALUE);
    6.29      }
    6.30  
    6.31      public static void main(String args[]) throws Throwable {

     7.1 --- a/test/compiler/rtm/cli/TestUseRTMLockingOptionWithBiasedLocking.java	Mon Aug 11 11:43:22 2014 -0700
     7.2 +++ b/test/compiler/rtm/cli/TestUseRTMLockingOptionWithBiasedLocking.java	Mon Aug 11 19:19:47 2014 +0400
     7.3 @@ -53,22 +53,18 @@
     7.4          // verify that we will not get a warning
     7.5          CommandLineOptionTest.verifySameJVMStartup(null,
     7.6                  new String[] { warningMessage }, ExitCode.OK,
     7.7 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
     7.8                  "-XX:+UseRTMLocking", "-XX:-UseBiasedLocking");
     7.9          // verify that we will get a warning
    7.10          CommandLineOptionTest.verifySameJVMStartup(
    7.11                  new String[] { warningMessage }, null, ExitCode.OK,
    7.12 -                CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    7.13                  "-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
    7.14          // verify that UseBiasedLocking is false when we use rtm locking
    7.15          CommandLineOptionTest.verifyOptionValueForSameVM("UseBiasedLocking",
    7.16 -                "false", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    7.17 -                "-XX:+UseRTMLocking");
    7.18 +                "false", "-XX:+UseRTMLocking");
    7.19          // verify that we can't turn on biased locking when
    7.20          // using rtm locking
    7.21          CommandLineOptionTest.verifyOptionValueForSameVM("UseBiasedLocking",
    7.22 -                "false", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
    7.23 -                "-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
    7.24 +                "false", "-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
    7.25      }
    7.26  
    7.27      public static void main(String args[]) throws Throwable {