1 /*
2 * Copyright (c) 2015, 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 java.lang.reflect.Constructor;
27 import java.lang.reflect.Executable;
28 import java.lang.reflect.Method;
29 import java.util.concurrent.Callable;
30 import sun.hotspot.WhiteBox;
31
32 public enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
33 /** constructor test case */
34 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
35 /** method test case */
36 METHOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
37 /** static method test case */
38 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
39 /** OSR constructor test case */
40 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
41 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
42 /** OSR method test case */
43 OSR_METHOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
44 /** OSR static method test case */
45 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
46
47 private final Executable executable;
48 private final Callable<Integer> callable;
49 private final boolean isOsr;
50
51 private SimpleTestCase(Executable executable, Callable<Integer> callable,
52 boolean isOsr) {
53 this.executable = executable;
54 this.callable = callable;
55 this.isOsr = isOsr;
56 }
57
58 @Override
59 public Executable getExecutable() {
60 return executable;
61 }
62
63 @Override
64 public Callable<Integer> getCallable() {
65 return callable;
66 }
67
68 @Override
69 public boolean isOsr() {
70 return isOsr;
71 }
72
73 private static class Helper {
74
75 private static final Callable<Integer> CONSTRUCTOR_CALLABLE
76 = new Callable<Integer>() {
77 @Override
78 public Integer call() throws Exception {
79 return new Helper(1337).hashCode();
80 }
81 };
82
83 private static final Callable<Integer> METHOD_CALLABLE
84 = new Callable<Integer>() {
85 private final Helper helper = new Helper();
86
87 @Override
88 public Integer call() throws Exception {
89 return helper.method();
90 }
91 };
92
93 private static final Callable<Integer> STATIC_CALLABLE
94 = new Callable<Integer>() {
95 @Override
96 public Integer call() throws Exception {
97 return staticMethod();
98 }
99 };
100
101 private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
102 = new Callable<Integer>() {
103 @Override
104 public Integer call() throws Exception {
105 return new Helper(null, CompilerWhiteBoxTest.BACKEDGE_THRESHOLD).hashCode();
106 }
107 };
108
109 private static final Callable<Integer> OSR_METHOD_CALLABLE
110 = new Callable<Integer>() {
111 private final Helper helper = new Helper();
112
113 @Override
114 public Integer call() throws Exception {
115 return helper.osrMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
116 }
117 };
118
119 private static final Callable<Integer> OSR_STATIC_CALLABLE
120 = new Callable<Integer>() {
121 @Override
122 public Integer call() throws Exception {
123 return osrStaticMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
124 }
125 };
126
127 private static final Constructor CONSTRUCTOR;
128 private static final Constructor OSR_CONSTRUCTOR;
129 private static final Method METHOD;
130 private static final Method STATIC;
131 private static final Method OSR_METHOD;
132 private static final Method OSR_STATIC;
133
134 static {
135 try {
136 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
137 } catch (NoSuchMethodException | SecurityException e) {
138 throw new RuntimeException(
139 "exception on getting method Helper.<init>(int)", e);
140 }
141 try {
142 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
143 Object.class, long.class);
144 } catch (NoSuchMethodException | SecurityException e) {
145 throw new RuntimeException(
146 "exception on getting method Helper.<init>(Object, long)", e);
147 }
148 METHOD = getMethod("method");
149 STATIC = getMethod("staticMethod");
150 OSR_METHOD = getMethod("osrMethod", long.class);
151 OSR_STATIC = getMethod("osrStaticMethod", long.class);
152 }
153
154 private static Method getMethod(String name, Class<?>... parameterTypes) {
155 try {
156 return Helper.class.getDeclaredMethod(name, parameterTypes);
157 } catch (NoSuchMethodException | SecurityException e) {
158 throw new RuntimeException(
159 "exception on getting method Helper." + name, e);
160 }
161 }
162
163 private static int staticMethod() {
164 return 1138;
165 }
166
167 private int method() {
168 return 42;
169 }
170
171 /**
172 * Deoptimizes all non-osr versions of the given executable after
173 * compilation finished.
174 *
175 * @param e Executable
176 * @throws Exception
177 */
178 private static void waitAndDeoptimize(Executable e) {
179 CompilerWhiteBoxTest.waitBackgroundCompilation(e);
180 if (WhiteBox.getWhiteBox().isMethodQueuedForCompilation(e)) {
181 throw new RuntimeException(e + " must not be in queue");
182 }
183 // Deoptimize non-osr versions of executable
184 WhiteBox.getWhiteBox().deoptimizeMethod(e, false);
185 }
186
187 /**
188 * Executes the method multiple times to make sure we have
189 * enough profiling information before triggering an OSR
190 * compilation. Otherwise the C2 compiler may add uncommon traps.
191 *
192 * @param m Method to be executed
193 * @return Number of times the method was executed
194 * @throws Exception
195 */
196 private static int warmup(Method m) throws Exception {
197 waitAndDeoptimize(m);
198 Helper helper = new Helper();
199 int result = 0;
200 for (long i = 0; i < CompilerWhiteBoxTest.THRESHOLD; ++i) {
201 result += (int)m.invoke(helper, 1);
202 }
203 // Wait to make sure OSR compilation is not blocked by
204 // non-OSR compilation in the compile queue
205 CompilerWhiteBoxTest.waitBackgroundCompilation(m);
206 return result;
207 }
208
209 /**
210 * Executes the constructor multiple times to make sure we
211 * have enough profiling information before triggering an OSR
212 * compilation. Otherwise the C2 compiler may add uncommon traps.
213 *
214 * @param c Constructor to be executed
215 * @return Number of times the constructor was executed
216 * @throws Exception
217 */
218 private static int warmup(Constructor c) throws Exception {
219 waitAndDeoptimize(c);
220 int result = 0;
221 for (long i = 0; i < CompilerWhiteBoxTest.THRESHOLD; ++i) {
222 result += c.newInstance(null, 1).hashCode();
223 }
224 // Wait to make sure OSR compilation is not blocked by
225 // non-OSR compilation in the compile queue
226 CompilerWhiteBoxTest.waitBackgroundCompilation(c);
227 return result;
228 }
229
230 private static int osrStaticMethod(long limit) throws Exception {
231 int result = 0;
232 if (limit != 1) {
233 result = warmup(OSR_STATIC);
234 }
235 // Trigger osr compilation
236 for (long i = 0; i < limit; ++i) {
237 result += staticMethod();
238 }
239 return result;
240 }
241
242 private int osrMethod(long limit) throws Exception {
243 int result = 0;
244 if (limit != 1) {
245 result = warmup(OSR_METHOD);
246 }
247 // Trigger osr compilation
248 for (long i = 0; i < limit; ++i) {
249 result += method();
250 }
251 return result;
252 }
253
254 private final int x;
255
256 // for method and OSR method test case
257 public Helper() {
258 x = 0;
259 }
260
261 // for OSR constructor test case
262 private Helper(Object o, long limit) throws Exception {
263 int result = 0;
264 if (limit != 1) {
265 result = warmup(OSR_CONSTRUCTOR);
266 }
267 // Trigger osr compilation
268 for (long i = 0; i < limit; ++i) {
269 result += method();
270 }
271 x = result;
272 }
273
274 // for constructor test case
275 private Helper(int x) {
276 this.x = x;
277 }
278
279 @Override
280 public int hashCode() {
281 return x;
282 }
283 }
284 }