1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 /**
26 * @test
27 * @bug 8031320
28 * @summary Verify that RTMLockingThreshold affects rtm state transition
29 * ProfileRTM => UseRTM.
30 * @library /testlibrary /testlibrary/whitebox /compiler/testlibrary
31 * @build TestRTMLockingThreshold
32 * @run main ClassFileInstaller sun.hotspot.WhiteBox
33 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
34 * -XX:+WhiteBoxAPI TestRTMLockingThreshold
35 */
36
37 import java.util.List;
38 import com.oracle.java.testlibrary.*;
39 import com.oracle.java.testlibrary.cli.CommandLineOptionTest;
40 import com.oracle.java.testlibrary.cli.predicate.AndPredicate;
41 import rtm.*;
42 import rtm.predicate.SupportedCPU;
43 import rtm.predicate.SupportedVM;
44 import sun.misc.Unsafe;
45
46 /**
47 * Test verifies that RTMLockingThreshold option actually affects how soon
48 * method will be deoptimized on low abort ratio.
49 */
50 public class TestRTMLockingThreshold extends CommandLineOptionTest {
51 private TestRTMLockingThreshold() {
52 super(new AndPredicate(new SupportedVM(), new SupportedCPU()));
53 }
54
55 /**
56 * We use non-zero abort threshold to avoid abort related to
57 * interrupts, VMM calls, etc. during first lock attempt.
58 *
59 */
60 private static final int ABORT_THRESHOLD = 10;
61
62 @Override
63 protected void runTestCases() throws Throwable {
64 verifyLockingThreshold(0, false);
65 verifyLockingThreshold(100, false);
66 verifyLockingThreshold(1000, false);
67
68 verifyLockingThreshold(0, true);
69 verifyLockingThreshold(100, true);
70 verifyLockingThreshold(1000, true);
71 }
72
73 private void verifyLockingThreshold(int lockingThreshold,
74 boolean useStackLock) throws Throwable {
75 CompilableTest test = new Test();
76
77 OutputAnalyzer outputAnalyzer = RTMTestBase.executeRTMTest(
78 test,
79 "-XX:CompileThreshold=1",
80 CommandLineOptionTest.prepareBooleanFlag("UseRTMForStackLocks",
81 useStackLock),
82 "-XX:+UseRTMDeopt",
83 "-XX:RTMTotalCountIncrRate=1",
84 "-XX:RTMRetryCount=0",
85 CommandLineOptionTest.prepareNumericFlag("RTMAbortThreshold",
86 TestRTMLockingThreshold.ABORT_THRESHOLD),
87 CommandLineOptionTest.prepareNumericFlag("RTMLockingThreshold",
88 lockingThreshold),
89 "-XX:RTMAbortRatio=100",
90 "-XX:+PrintPreciseRTMLockingStatistics",
91 Test.class.getName(),
92 Boolean.toString(!useStackLock),
93 Integer.toString(lockingThreshold)
94 );
95
96 outputAnalyzer.shouldHaveExitValue(0);
97
98 List<RTMLockingStatistics> statistics = RTMLockingStatistics.fromString(
99 test.getMethodWithLockName(), outputAnalyzer.getOutput());
100
101 Asserts.assertEQ(statistics.size(), 2, "VM output should contain two "
102 + "RTM locking statistics entries.");
103
104 /**
105 * We force abort on each odd iteration, so if RTMLockingThreshold==0,
106 * then we have to make 1 call without abort to avoid rtm state
107 * transition to NoRTM (otherwise actual abort ratio will be 100%),
108 * and after that make 1 call with abort to force deoptimization.
109 * This leads us to two locks for threshold 0.
110 * For other threshold values we have to make RTMLockingThreshold + 1
111 * locks if locking threshold is even, or + 0 if odd.
112 */
113 long expectedValue = lockingThreshold +
114 (lockingThreshold == 0L ? 2L : lockingThreshold % 2L);
115
116 RTMLockingStatistics statBeforeDeopt = null;
117 for (RTMLockingStatistics s : statistics) {
118 if (s.getTotalLocks() == expectedValue) {
119 Asserts.assertNull(statBeforeDeopt,
120 "Only one statistics entry should contain aborts");
121 statBeforeDeopt = s;
122 }
123 }
124
125 Asserts.assertNotNull(statBeforeDeopt, "There should be exactly one "
126 + "statistics entry corresponding to ProfileRTM state.");
127 }
128
129 public static class Test implements CompilableTest {
130 // Following field have to be static in order to avoid escape analysis.
131 @SuppressWarnings("UnsuedDeclaration")
132 private static int field = 0;
133 private static final int TOTAL_ITERATIONS = 10000;
134 private static final Unsafe UNSAFE = Utils.getUnsafe();
135 private final Object monitor = new Object();
136
137
138 @Override
139 public String getMethodWithLockName() {
140 return this.getClass().getName() + "::lock";
141 }
142
143 @Override
144 public String[] getMethodsToCompileNames() {
145 return new String[] {
146 getMethodWithLockName(),
147 sun.misc.Unsafe.class.getName() + "::addressSize"
148 };
149 }
150
151 public void lock(boolean abort) {
152 synchronized(monitor) {
153 if (abort) {
154 Test.field += Test.UNSAFE.addressSize();
155 }
156 }
157 }
158
159 /**
160 * Usage:
161 * Test <inflate monitor>
162 */
163 public static void main(String args[]) throws Throwable {
164 Asserts.assertGTE(args.length, 1, "One argument required.");
165 Test t = new Test();
166
167 if (Boolean.valueOf(args[0])) {
168 AbortProvoker.inflateMonitor(t.monitor);
169 }
170 for (int i = 0; i < Test.TOTAL_ITERATIONS; i++) {
171 t.lock(i % 2 == 1);
172 }
173 }
174 }
175
176 public static void main(String args[]) throws Throwable {
177 new TestRTMLockingThreshold().test();
178 }
179 }