author | thartmann |
Mon, 05 Feb 2018 07:14:24 +0100 | |
changeset 48862 | e13c8c5d9eb3 |
parent 47216 | 71c04702a3d5 |
permissions | -rw-r--r-- |
28499 | 1 |
/* |
43467 | 2 |
* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved. |
28499 | 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 |
* @test |
|
26 |
* @bug 8030976 8059226 |
|
48862
e13c8c5d9eb3
8196608: [Graal] compiler/uncommontrap/TestUnstableIfTrap.java fails in Graal JIT mode
thartmann
parents:
47216
diff
changeset
|
27 |
* @requires !vm.graal.enabled |
40631
ed82623d7831
8157957: ClassNotFoundException: jdk.test.lib.JDKToolFinder
ctornqvi
parents:
40059
diff
changeset
|
28 |
* @library /test/lib / |
29678
dd2f3932c21e
8075586: Add @modules as needed to the open hotspot tests
ykantser
parents:
28499
diff
changeset
|
29 |
* @modules java.base/jdk.internal.org.objectweb.asm |
36851 | 30 |
* java.base/jdk.internal.misc |
29678
dd2f3932c21e
8075586: Add @modules as needed to the open hotspot tests
ykantser
parents:
28499
diff
changeset
|
31 |
* java.compiler |
dd2f3932c21e
8075586: Add @modules as needed to the open hotspot tests
ykantser
parents:
28499
diff
changeset
|
32 |
* java.management |
43467 | 33 |
* jdk.internal.jvmstat/sun.jvmstat.monitor |
40059 | 34 |
* |
40631
ed82623d7831
8157957: ClassNotFoundException: jdk.test.lib.JDKToolFinder
ctornqvi
parents:
40059
diff
changeset
|
35 |
* @build sun.hotspot.WhiteBox |
39438 | 36 |
* @run driver ClassFileInstaller sun.hotspot.WhiteBox |
37 |
* sun.hotspot.WhiteBox$WhiteBoxPermission |
|
28499 | 38 |
* @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions |
39 |
* -XX:+WhiteBoxAPI -XX:+LogCompilation |
|
40 |
* -XX:CompileCommand=compileonly,UnstableIfExecutable.test |
|
41 |
* -XX:LogFile=always_taken_not_fired.xml |
|
40059 | 42 |
* compiler.uncommontrap.TestUnstableIfTrap ALWAYS_TAKEN false |
28499 | 43 |
* @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions |
44 |
* -XX:+WhiteBoxAPI -XX:+LogCompilation |
|
45 |
* -XX:CompileCommand=compileonly,UnstableIfExecutable.test |
|
46 |
* -XX:LogFile=always_taken_fired.xml |
|
40059 | 47 |
* compiler.uncommontrap.TestUnstableIfTrap ALWAYS_TAKEN true |
28499 | 48 |
* @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions |
49 |
* -XX:+WhiteBoxAPI -XX:+LogCompilation |
|
50 |
* -XX:CompileCommand=compileonly,UnstableIfExecutable.test |
|
51 |
* -XX:LogFile=never_taken_not_fired.xml |
|
40059 | 52 |
* compiler.uncommontrap.TestUnstableIfTrap NEVER_TAKEN false |
28499 | 53 |
* @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions |
54 |
* -XX:+WhiteBoxAPI -XX:+LogCompilation |
|
55 |
* -XX:CompileCommand=compileonly,UnstableIfExecutable.test |
|
56 |
* -XX:LogFile=never_taken_fired.xml |
|
40059 | 57 |
* compiler.uncommontrap.TestUnstableIfTrap NEVER_TAKEN true |
39438 | 58 |
* @run driver compiler.testlibrary.uncommontrap.Verifier always_taken_not_fired.xml |
59 |
* always_taken_fired.xml |
|
60 |
* never_taken_not_fired.xml |
|
61 |
* never_taken_fired.xml |
|
28499 | 62 |
*/ |
39438 | 63 |
|
40059 | 64 |
package compiler.uncommontrap; |
65 |
||
66 |
import compiler.testlibrary.uncommontrap.Verifier; |
|
67 |
import jdk.internal.org.objectweb.asm.ClassVisitor; |
|
68 |
import jdk.internal.org.objectweb.asm.ClassWriter; |
|
69 |
import jdk.internal.org.objectweb.asm.Label; |
|
70 |
import jdk.internal.org.objectweb.asm.MethodVisitor; |
|
71 |
import jdk.test.lib.ByteCodeLoader; |
|
72 |
import jdk.test.lib.Platform; |
|
73 |
import sun.hotspot.WhiteBox; |
|
74 |
||
39438 | 75 |
import java.io.File; |
76 |
import java.io.FileWriter; |
|
77 |
import java.io.IOException; |
|
78 |
import java.lang.reflect.Method; |
|
79 |
import java.util.Properties; |
|
80 |
||
40059 | 81 |
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_ABSTRACT; |
82 |
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC; |
|
83 |
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC; |
|
84 |
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_VOLATILE; |
|
85 |
import static jdk.internal.org.objectweb.asm.Opcodes.GETSTATIC; |
|
86 |
import static jdk.internal.org.objectweb.asm.Opcodes.GOTO; |
|
87 |
import static jdk.internal.org.objectweb.asm.Opcodes.IADD; |
|
88 |
import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_1; |
|
89 |
import static jdk.internal.org.objectweb.asm.Opcodes.IFEQ; |
|
90 |
import static jdk.internal.org.objectweb.asm.Opcodes.ILOAD; |
|
91 |
import static jdk.internal.org.objectweb.asm.Opcodes.ISUB; |
|
92 |
import static jdk.internal.org.objectweb.asm.Opcodes.RETURN; |
|
39438 | 93 |
|
28499 | 94 |
public class TestUnstableIfTrap { |
95 |
private static final WhiteBox WB = WhiteBox.getWhiteBox(); |
|
96 |
private static final String CLASS_NAME = "UnstableIfExecutable"; |
|
97 |
private static final String METHOD_NAME = "test"; |
|
98 |
private static final String FIELD_NAME = "field"; |
|
99 |
private static final int ITERATIONS = 1_000_000; |
|
100 |
// There is no dependency on particular class file version, so it could be |
|
101 |
// set to any version (if you're updating this test for Java 42). |
|
102 |
private static final int CLASS_FILE_VERSION = 49; |
|
103 |
private static final int MAX_TIER = 4; |
|
104 |
// This test aimed to verify that uncommon trap with reason "unstable_if" |
|
105 |
// is emitted when method that contain control-flow divergence such that |
|
106 |
// one of two branches is never taken (and other one is taken always). |
|
107 |
// C2 will made a decision whether or not the branch was ever taken |
|
108 |
// depending on method's profile. |
|
109 |
// If profile was collected for a few method's invocations, then C2 will not |
|
110 |
// trust in branches' probabilities and the tested trap won't be emitted. |
|
111 |
// In fact, a method has to be invoked at least 40 time at the day when this |
|
112 |
// comment was written (see Parse::dynamic_branch_prediction for an actual |
|
113 |
// value). It would be to implementation dependent to use "40" as |
|
114 |
// a threshold value in the test, so in order to improve test's robustness |
|
115 |
// the threshold value is 1000: if the tested method was compiled by C2 |
|
116 |
// before it was invoked 1000 times, then we won't verify that trap was |
|
117 |
// emitted and fired. |
|
118 |
private static final int MIN_INVOCATIONS_BEFORE_C2_COMPILATION = 1000; |
|
119 |
/** |
|
120 |
* Description of test case parameters and uncommon trap that will |
|
121 |
* be emitted during tested method compilation. |
|
122 |
*/ |
|
123 |
private static enum TestCaseName { |
|
124 |
ALWAYS_TAKEN(false, "taken always"), |
|
125 |
NEVER_TAKEN(true, "taken never"); |
|
126 |
TestCaseName(boolean predicate, String comment) { |
|
127 |
this.predicate = predicate; |
|
128 |
this.comment = comment; |
|
129 |
} |
|
130 |
||
131 |
public final boolean predicate; |
|
132 |
public final String name = "unstable_if"; |
|
133 |
public final String comment; |
|
134 |
} |
|
135 |
||
136 |
public static void main(String args[]) { |
|
137 |
if (args.length != 2) { |
|
138 |
throw new Error("Expected two arguments: test case name and a " |
|
139 |
+ "boolean determining if uncommon trap should be fired."); |
|
140 |
} |
|
141 |
test(TestCaseName.valueOf(args[0]), Boolean.valueOf(args[1])); |
|
142 |
} |
|
143 |
||
144 |
private static void test(TestCaseName testCase, boolean shouldBeFired) { |
|
145 |
Method testMethod; |
|
146 |
Label unstableIfLocation = new Label(); |
|
147 |
boolean shouldBeEmitted; |
|
148 |
boolean compiledToEarly = false; |
|
149 |
||
150 |
try { |
|
151 |
Class testClass = ByteCodeLoader.load(CLASS_NAME, |
|
152 |
generateTest(unstableIfLocation)); |
|
153 |
testMethod = testClass.getDeclaredMethod(METHOD_NAME, |
|
154 |
boolean.class); |
|
155 |
for (int i = 0; i < ITERATIONS; i++) { |
|
156 |
testMethod.invoke(null, testCase.predicate); |
|
157 |
if (i < MIN_INVOCATIONS_BEFORE_C2_COMPILATION |
|
158 |
&& isMethodCompiledByC2(testMethod)) { |
|
159 |
compiledToEarly = true; |
|
160 |
// There is no sense in further invocations: we already |
|
161 |
// decided to avoid verification. |
|
162 |
break; |
|
163 |
} |
|
164 |
} |
|
165 |
// We're checking that trap should be emitted (i.e. it was compiled |
|
166 |
// by C2) before the trap is fired, because otherwise the nmethod |
|
167 |
// will be deoptimized and isMethodCompiledByC2 will return false. |
|
168 |
shouldBeEmitted = isMethodCompiledByC2(testMethod) |
|
169 |
&& !compiledToEarly; |
|
170 |
if (shouldBeFired) { |
|
171 |
testMethod.invoke(null, !testCase.predicate); |
|
172 |
} |
|
173 |
} catch (ReflectiveOperationException e) { |
|
174 |
throw new Error("Test case should be generated, loaded and executed" |
|
175 |
+ " without any issues.", e); |
|
176 |
} |
|
177 |
||
178 |
shouldBeFired &= shouldBeEmitted; |
|
179 |
||
180 |
Properties properties = new Properties(); |
|
181 |
properties.setProperty(Verifier.VERIFICATION_SHOULD_BE_SKIPPED, |
|
182 |
Boolean.toString(compiledToEarly)); |
|
183 |
properties.setProperty(Verifier.UNCOMMON_TRAP_SHOULD_EMITTED, |
|
184 |
Boolean.toString(shouldBeEmitted)); |
|
185 |
properties.setProperty(Verifier.UNCOMMON_TRAP_SHOULD_FIRED, |
|
186 |
Boolean.toString(shouldBeFired)); |
|
187 |
properties.setProperty(Verifier.UNCOMMON_TRAP_NAME, testCase.name); |
|
188 |
properties.setProperty(Verifier.UNCOMMON_TRAP_COMMENT, |
|
189 |
testCase.comment); |
|
190 |
properties.setProperty(Verifier.UNCOMMON_TRAP_BCI, |
|
191 |
Integer.toString(unstableIfLocation.getOffset())); |
|
192 |
||
193 |
properties.list(System.out); |
|
194 |
||
195 |
File f = new File(WB.getStringVMFlag("LogFile") + |
|
196 |
Verifier.PROPERTIES_FILE_SUFFIX); |
|
197 |
try (FileWriter wr = new FileWriter(f)) { |
|
198 |
properties.store(wr, ""); |
|
199 |
} catch (IOException e) { |
|
200 |
throw new Error("Unable to store test properties.", e); |
|
201 |
} |
|
202 |
} |
|
203 |
||
204 |
private static boolean isMethodCompiledByC2(Method m) { |
|
205 |
boolean isTiered = WB.getBooleanVMFlag("TieredCompilation"); |
|
206 |
boolean isMethodCompiled = WB.isMethodCompiled(m); |
|
207 |
boolean isMethodCompiledAtMaxTier |
|
208 |
= WB.getMethodCompilationLevel(m) == MAX_TIER; |
|
209 |
||
43455
96560cffef4d
8166002: Emulate client build on platforms with reduced virtual address space
jcm
parents:
40631
diff
changeset
|
210 |
return Platform.isServer() && !Platform.isEmulatedClient() && isMethodCompiled |
28499 | 211 |
&& (!isTiered || isMethodCompiledAtMaxTier); |
212 |
} |
|
213 |
||
214 |
/** |
|
215 |
* Generates class with name {@code CLASS_NAME}, which will contain a |
|
216 |
* static method {@code METHOD_NAME}: |
|
217 |
* |
|
218 |
* <pre>{@code |
|
219 |
* public abstract class UnstableIfExecutable { |
|
220 |
* private static int field = 0; |
|
221 |
* |
|
222 |
* public static void test(boolean alwaysTrue) { |
|
223 |
* if (alwaysTrue) { |
|
224 |
* field++; |
|
225 |
* } else { |
|
226 |
* field--; |
|
227 |
* } |
|
228 |
* } |
|
229 |
* } |
|
230 |
* }</pre> |
|
231 |
* |
|
232 |
* @return generated bytecode. |
|
233 |
*/ |
|
234 |
private static byte[] generateTest(Label unstableIfLocation) { |
|
235 |
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); |
|
236 |
||
237 |
cw.visit(CLASS_FILE_VERSION, ACC_PUBLIC | ACC_ABSTRACT, CLASS_NAME, |
|
238 |
null, "java/lang/Object", null); |
|
239 |
||
240 |
cw.visitField(ACC_PUBLIC | ACC_STATIC | ACC_VOLATILE, FIELD_NAME, |
|
241 |
"I", null, Integer.valueOf(0)); |
|
242 |
||
243 |
generateTestMethod(cw, unstableIfLocation); |
|
244 |
||
245 |
return cw.toByteArray(); |
|
246 |
} |
|
247 |
||
248 |
private static void generateTestMethod(ClassVisitor cv, |
|
249 |
Label unstableIfLocation) { |
|
250 |
MethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, METHOD_NAME, |
|
251 |
"(Z)V", null, null); |
|
252 |
mv.visitCode(); |
|
253 |
||
254 |
Label end = new Label(); |
|
255 |
Label falseBranch = new Label(); |
|
256 |
||
257 |
// push "field" field's value and 1 to stack |
|
258 |
mv.visitFieldInsn(GETSTATIC, CLASS_NAME, FIELD_NAME, "I"); |
|
259 |
mv.visitInsn(ICONST_1); |
|
260 |
// load argument's value |
|
261 |
mv.visitVarInsn(ILOAD, 0); // alwaysTrue |
|
262 |
// here is our unstable if |
|
263 |
mv.visitLabel(unstableIfLocation); |
|
264 |
mv.visitJumpInsn(IFEQ, falseBranch); |
|
265 |
// increment on "true" |
|
266 |
mv.visitInsn(IADD); |
|
267 |
mv.visitJumpInsn(GOTO, end); |
|
268 |
// decrement on "false" |
|
269 |
mv.visitLabel(falseBranch); |
|
270 |
mv.visitInsn(ISUB); |
|
271 |
mv.visitLabel(end); |
|
272 |
// bye bye |
|
273 |
mv.visitInsn(RETURN); |
|
274 |
||
275 |
mv.visitMaxs(0, 0); |
|
276 |
mv.visitEnd(); |
|
277 |
} |
|
278 |
} |
|
279 |