1 /*
2 * Copyright (c) 2013, 2016, 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 package compiler.whitebox;
25
26 import jdk.test.lib.Platform;
27 import sun.hotspot.WhiteBox;
28 import sun.hotspot.code.NMethod;
29
30 import java.lang.reflect.Executable;
31 import java.util.Objects;
32 import java.util.concurrent.Callable;
33 import java.util.function.Function;
34
35 /**
36 * Abstract class for WhiteBox testing of JIT.
37 * Depends on jdk.test.lib.Platform from testlibrary.
38 *
39 * @author igor.ignatyev@oracle.com
40 */
41 public abstract class CompilerWhiteBoxTest {
42 /** {@code CompLevel::CompLevel_none} -- Interpreter */
43 public static final int COMP_LEVEL_NONE = 0;
44 /** {@code CompLevel::CompLevel_any}, {@code CompLevel::CompLevel_all} */
45 public static final int COMP_LEVEL_ANY = -2;
46 /** {@code CompLevel::CompLevel_aot} -- AOT */
47 public static final int COMP_LEVEL_AOT = -1;
48 /** {@code CompLevel::CompLevel_simple} -- C1 */
49 public static final int COMP_LEVEL_SIMPLE = 1;
50 /** {@code CompLevel::CompLevel_limited_profile} -- C1, invocation & backedge counters */
51 public static final int COMP_LEVEL_LIMITED_PROFILE = 2;
52 /** {@code CompLevel::CompLevel_full_profile} -- C1, invocation & backedge counters + mdo */
53 public static final int COMP_LEVEL_FULL_PROFILE = 3;
54 /** {@code CompLevel::CompLevel_full_optimization} -- C2 or Shark */
55 public static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
56 /** Maximal value for CompLevel */
57 public static final int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
58
59 /** Instance of WhiteBox */
60 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
61 /** Value of {@code -XX:CompileThreshold} */
62 protected static final int COMPILE_THRESHOLD
63 = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
64 /** Value of {@code -XX:BackgroundCompilation} */
65 protected static final boolean BACKGROUND_COMPILATION
66 = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
67 protected static final boolean USE_COUNTER_DECAY
68 = Boolean.valueOf(getVMOption("UseCounterDecay", "true"));
69 /** Value of {@code -XX:TieredCompilation} */
70 protected static final boolean TIERED_COMPILATION
71 = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
72 /** Value of {@code -XX:TieredStopAtLevel} */
73 protected static final int TIERED_STOP_AT_LEVEL
74 = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
75 /** Flag for verbose output, true if {@code -Dverbose} specified */
76 protected static final boolean IS_VERBOSE
77 = System.getProperty("verbose") != null;
78 /** invocation count to trigger compilation */
79 public static final int THRESHOLD;
80 /** invocation count to trigger OSR compilation */
81 protected static final long BACKEDGE_THRESHOLD;
82
83 static {
84 if (TIERED_COMPILATION) {
85 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
86 } else {
87 THRESHOLD = COMPILE_THRESHOLD;
88 BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
89 "OnStackReplacePercentage"));
90 }
91 }
92
93 /**
94 * Returns value of VM option.
95 *
96 * @param name option's name
97 * @return value of option or {@code null}, if option doesn't exist
98 * @throws NullPointerException if name is null
99 */
100 protected static String getVMOption(String name) {
101 Objects.requireNonNull(name);
102 return Objects.toString(WHITE_BOX.getVMFlag(name), null);
103 }
104
105 /**
106 * Returns value of VM option or default value.
107 *
108 * @param name option's name
109 * @param defaultValue default value
110 * @return value of option or {@code defaultValue}, if option doesn't exist
111 * @throws NullPointerException if name is null
112 * @see #getVMOption(String)
113 */
114 protected static String getVMOption(String name, String defaultValue) {
115 String result = getVMOption(name);
116 return result == null ? defaultValue : result;
117 }
118
119 /** copy of is_c1_compile(int) from utilities/globalDefinitions.hpp */
120 protected static boolean isC1Compile(int compLevel) {
121 return (compLevel > COMP_LEVEL_NONE)
122 && (compLevel < COMP_LEVEL_FULL_OPTIMIZATION);
123 }
124
125 /** copy of is_c2_compile(int) from utilities/globalDefinitions.hpp */
126 protected static boolean isC2Compile(int compLevel) {
127 return compLevel == COMP_LEVEL_FULL_OPTIMIZATION;
128 }
129
130 protected static void main(
131 Function<TestCase, CompilerWhiteBoxTest> constructor,
132 String[] args) {
133 if (args.length == 0) {
134 for (TestCase test : SimpleTestCase.values()) {
135 constructor.apply(test).runTest();
136 }
137 } else {
138 for (String name : args) {
139 constructor.apply(SimpleTestCase.valueOf(name)).runTest();
140 }
141 }
142 }
143
144 /** tested method */
145 protected final Executable method;
146 protected final TestCase testCase;
147
148 /**
149 * Constructor.
150 *
151 * @param testCase object, that contains tested method and way to invoke it.
152 */
153 protected CompilerWhiteBoxTest(TestCase testCase) {
154 Objects.requireNonNull(testCase);
155 System.out.println("TEST CASE:" + testCase.name());
156 method = testCase.getExecutable();
157 this.testCase = testCase;
158 }
159
160 /**
161 * Template method for testing. Prints tested method's info before
162 * {@linkplain #test()} and after {@linkplain #test()} or on thrown
163 * exception.
164 *
165 * @throws RuntimeException if method {@linkplain #test()} throws any
166 * exception
167 * @see #test()
168 */
169 protected final void runTest() {
170 if (Platform.isInt()) {
171 throw new Error("TESTBUG: test can not be run in interpreter");
172 }
173 System.out.println("at test's start:");
174 printInfo();
175 try {
176 test();
177 } catch (Exception e) {
178 System.out.printf("on exception '%s':", e.getMessage());
179 printInfo();
180 e.printStackTrace();
181 if (e instanceof RuntimeException) {
182 throw (RuntimeException) e;
183 }
184 throw new RuntimeException(e);
185 }
186 System.out.println("at test's end:");
187 printInfo();
188 }
189
190 /**
191 * Checks, that {@linkplain #method} is not compiled at the given compilation
192 * level or above.
193 *
194 * @param compLevel
195 *
196 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
197 * is compiled, or if {@linkplain #method} has zero
198 * compilation level.
199 */
200 protected final void checkNotCompiled(int compLevel) {
201 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
202 throw new RuntimeException(method + " must not be in queue");
203 }
204 if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
205 throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
206 }
207 if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
208 throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
209 }
210 }
211
212 /**
213 * Checks, that {@linkplain #method} is not compiled.
214 *
215 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
216 * is compiled, or if {@linkplain #method} has zero
217 * compilation level.
218 */
219 protected final void checkNotCompiled() {
220 waitBackgroundCompilation();
221 checkNotCompiled(true);
222 checkNotCompiled(false);
223 }
224
225 /**
226 * Checks, that {@linkplain #method} is not (OSR-)compiled.
227 *
228 * @param isOsr Check for OSR compilation if true
229 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
230 * is compiled, or if {@linkplain #method} has zero
231 * compilation level.
232 */
233 protected final void checkNotCompiled(boolean isOsr) {
234 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
235 throw new RuntimeException(method + " must not be in queue");
236 }
237 if (WHITE_BOX.isMethodCompiled(method, isOsr)) {
238 throw new RuntimeException(method + " must not be " +
239 (isOsr ? "osr_" : "") + "compiled");
240 }
241 if (WHITE_BOX.getMethodCompilationLevel(method, isOsr) != 0) {
242 throw new RuntimeException(method + (isOsr ? " osr_" : " ") +
243 "comp_level must be == 0");
244 }
245 }
246
247 /**
248 * Checks, that {@linkplain #method} is compiled.
249 *
250 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
251 * and isn't compiled, or if {@linkplain #method}
252 * has nonzero compilation level
253 */
254 protected final void checkCompiled() {
255 final long start = System.currentTimeMillis();
256 waitBackgroundCompilation();
257 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
258 System.err.printf("Warning: %s is still in queue after %dms%n",
259 method, System.currentTimeMillis() - start);
260 return;
261 }
262 if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr())) {
263 throw new RuntimeException(method + " must be "
264 + (testCase.isOsr() ? "osr_" : "") + "compiled");
265 }
266 if (WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr())
267 == 0) {
268 throw new RuntimeException(method
269 + (testCase.isOsr() ? " osr_" : " ")
270 + "comp_level must be != 0");
271 }
272 }
273
274 protected final void deoptimize() {
275 WHITE_BOX.deoptimizeMethod(method, testCase.isOsr());
276 if (testCase.isOsr()) {
277 WHITE_BOX.deoptimizeMethod(method, false);
278 }
279 }
280
281 protected final int getCompLevel() {
282 NMethod nm = NMethod.get(method, testCase.isOsr());
283 return nm == null ? COMP_LEVEL_NONE : nm.comp_level;
284 }
285
286 protected final boolean isCompilable() {
287 return WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY,
288 testCase.isOsr());
289 }
290
291 protected final boolean isCompilable(int compLevel) {
292 return WHITE_BOX
293 .isMethodCompilable(method, compLevel, testCase.isOsr());
294 }
295
296 protected final void makeNotCompilable() {
297 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
298 testCase.isOsr());
299 }
300
301 protected final void makeNotCompilable(int compLevel) {
302 WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
303 }
304
305 /**
306 * Waits for completion of background compilation of {@linkplain #method}.
307 */
308 protected final void waitBackgroundCompilation() {
309 waitBackgroundCompilation(method);
310 }
311
312 /**
313 * Waits for completion of background compilation of the given executable.
314 *
315 * @param executable Executable
316 */
317 public static final void waitBackgroundCompilation(Executable executable) {
318 if (!BACKGROUND_COMPILATION) {
319 return;
320 }
321 final Object obj = new Object();
322 for (int i = 0; i < 100
323 && WHITE_BOX.isMethodQueuedForCompilation(executable); ++i) {
324 synchronized (obj) {
325 try {
326 obj.wait(100);
327 } catch (InterruptedException e) {
328 Thread.currentThread().interrupt();
329 }
330 }
331 }
332 }
333
334 /**
335 * Prints information about {@linkplain #method}.
336 */
337 protected final void printInfo() {
338 System.out.printf("%n%s:%n", method);
339 System.out.printf("\tcompilable:\t%b%n",
340 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
341 boolean isCompiled = WHITE_BOX.isMethodCompiled(method, false);
342 System.out.printf("\tcompiled:\t%b%n", isCompiled);
343 if (isCompiled) {
344 System.out.printf("\tcompile_id:\t%d%n",
345 NMethod.get(method, false).compile_id);
346 }
347 System.out.printf("\tcomp_level:\t%d%n",
348 WHITE_BOX.getMethodCompilationLevel(method, false));
349 System.out.printf("\tosr_compilable:\t%b%n",
350 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, true));
351 isCompiled = WHITE_BOX.isMethodCompiled(method, true);
352 System.out.printf("\tosr_compiled:\t%b%n", isCompiled);
353 if (isCompiled) {
354 System.out.printf("\tosr_compile_id:\t%d%n",
355 NMethod.get(method, true).compile_id);
356 }
357 System.out.printf("\tosr_comp_level:\t%d%n",
358 WHITE_BOX.getMethodCompilationLevel(method, true));
359 System.out.printf("\tin_queue:\t%b%n",
360 WHITE_BOX.isMethodQueuedForCompilation(method));
361 System.out.printf("compile_queues_size:\t%d%n%n",
362 WHITE_BOX.getCompileQueuesSize());
363 }
364
365 /**
366 * Executes testing.
367 */
368 protected abstract void test() throws Exception;
369
370 /**
371 * Tries to trigger compilation of {@linkplain #method} by call
372 * {@linkplain TestCase#getCallable()} enough times.
373 *
374 * @return accumulated result
375 * @see #compile(int)
376 */
377 protected final int compile() throws Exception {
378 if (USE_COUNTER_DECAY) {
379 throw new Exception("Tests using compile method must turn off counter decay for reliability");
380 }
381 if (testCase.isOsr()) {
382 return compile(1);
383 } else {
384 return compile(THRESHOLD);
385 }
386 }
387
388 /**
389 * Tries to trigger compilation of {@linkplain #method} by call
390 * {@linkplain TestCase#getCallable()} specified times.
391 *
392 * @param count invocation count
393 * @return accumulated result
394 */
395 protected final int compile(int count) {
396 int result = 0;
397 Integer tmp;
398 for (int i = 0; i < count; ++i) {
399 try {
400 tmp = testCase.getCallable().call();
401 } catch (Exception e) {
402 tmp = null;
403 }
404 result += tmp == null ? 0 : tmp;
405 }
406 if (IS_VERBOSE) {
407 System.out.println("method was invoked " + count + " times");
408 }
409 return result;
410 }
411
412 /**
413 * Utility interface provides tested method and object to invoke it.
414 */
415 public interface TestCase {
416 /** the name of test case */
417 String name();
418
419 /** tested method */
420 Executable getExecutable();
421
422 /** object to invoke {@linkplain #getExecutable()} */
423 Callable<Integer> getCallable();
424
425 /** flag for OSR test case */
426 boolean isOsr();
427 }
428
429 /**
430 * @return {@code true} if the current test case is OSR and the mode is
431 * Xcomp, otherwise {@code false}
432 */
433 protected boolean skipXcompOSR() {
434 boolean result = testCase.isOsr() && Platform.isComp();
435 if (result && IS_VERBOSE) {
436 System.err.printf("Warning: %s is not applicable in %s%n",
437 testCase.name(), Platform.vmInfo);
438 }
439 return result;
440 }
441
442 /**
443 * Skip the test for the specified value of Tiered Compilation
444 * @param value of TieredCompilation the test should not run with
445 * @return {@code true} if the test should be skipped,
446 * {@code false} otherwise
447 */
448 public static boolean skipOnTieredCompilation(boolean value) {
449 if (value == CompilerWhiteBoxTest.TIERED_COMPILATION) {
450 System.err.println("Test isn't applicable w/ "
451 + (value ? "enabled" : "disabled")
452 + "TieredCompilation. Skip test.");
453 return true;
454 }
455 return false;
456 }
457 }
458