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 * @summary Test how various AOT optimizations handle classes that are excluded from the AOT cache.
28 * @requires vm.cds.write.archived.java.heap
29 * @library /test/jdk/lib/testlibrary /test/lib
30 * /test/hotspot/jtreg/runtime/cds/appcds/aotCache/test-classes
31 * @build ExcludedClasses CustyWithLoop
32 * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar app.jar
33 * TestApp
34 * TestApp$Foo
35 * TestApp$Foo$Bar
36 * TestApp$Foo$ShouldBeExcluded
37 * TestApp$Foo$ShouldBeExcludedChild
38 * TestApp$Foo$Taz
39 * TestApp$MyInvocationHandler
40 * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar cust.jar
41 * CustyWithLoop
42 * @run driver ExcludedClasses
43 */
44
45 import java.io.File;
46 import java.lang.reflect.Array;
47 import java.lang.reflect.InvocationHandler;
48 import java.lang.reflect.Method;
49 import java.lang.reflect.Proxy;
50 import java.net.URL;
51 import java.net.URLClassLoader;
52 import java.security.ProtectionDomain;
53 import java.util.Map;
54
55 import jdk.jfr.Event;
56 import jdk.test.lib.cds.CDSAppTester;
57 import jdk.test.lib.helpers.ClassFileInstaller;
58 import jdk.test.lib.process.OutputAnalyzer;
59
60 public class ExcludedClasses {
61 static final String appJar = ClassFileInstaller.getJarPath("app.jar");
62 static final String mainClass = "TestApp";
63
64 public static void main(String[] args) throws Exception {
65 Tester tester = new Tester();
66 tester.runAOTWorkflow("AOT", "--two-step-training");
81 return new String[] {
82 "-Xlog:aot=debug",
83 "-Xlog:aot+class=debug",
84 "-Xlog:aot+resolve=trace",
85 "-Xlog:aot+verification=trace",
86 "-Xlog:class+load",
87 };
88 }
89
90 @Override
91 public String[] appCommandLine(RunMode runMode) {
92 return new String[] {
93 mainClass, runMode.name()
94 };
95 }
96
97 @Override
98 public void checkExecution(OutputAnalyzer out, RunMode runMode) {
99 if (runMode == RunMode.ASSEMBLY) {
100 out.shouldNotMatch("aot,resolve.*archived field.*TestApp.Foo => TestApp.Foo.ShouldBeExcluded.f:I");
101 } else if (runMode == RunMode.PRODUCTION) {
102 out.shouldContain("jdk.jfr.Event source: jrt:/jdk.jfr");
103 out.shouldMatch("TestApp[$]Foo[$]ShouldBeExcluded source: .*/app.jar");
104 out.shouldMatch("TestApp[$]Foo[$]ShouldBeExcludedChild source: .*/app.jar");
105 }
106 }
107 }
108 }
109
110 class TestApp {
111 static volatile Object custInstance;
112 static volatile Object custArrayInstance;
113
114 public static void main(String args[]) throws Exception {
115 // In AOT workflow, classes from custom loaders are passed from the preimage
116 // to the final image. See FinalImageRecipes::record_all_classes().
117 custInstance = initFromCustomLoader();
118 custArrayInstance = Array.newInstance(custInstance.getClass(), 0);
119 System.out.println(custArrayInstance);
120 System.out.println("Counter = " + Foo.hotSpot());
151
152 static class Foo {
153 volatile static int counter;
154 static Class c = ShouldBeExcluded.class;
155
156 static Map mapProxy = (Map) Proxy.newProxyInstance(
157 Foo.class.getClassLoader(),
158 new Class[] { Map.class },
159 new MyInvocationHandler());
160
161 static int hotSpot() {
162 ShouldBeExcluded s = new ShouldBeExcluded();
163 Bar b = new Bar();
164
165 long start = System.currentTimeMillis();
166 while (System.currentTimeMillis() - start < 1000) {
167 lambdaHotSpot();
168 s.hotSpot2();
169 b.hotSpot3();
170 Taz.hotSpot4();
171
172 // In JDK mainline, generated proxy classes are excluded from the AOT cache.
173 // In Leyden/premain, generated proxy classes included. The following code should
174 // work with either repos.
175 Integer i = (Integer)mapProxy.get(null);
176 counter += i.intValue();
177
178 if (custInstance != null) {
179 // Classes loaded by custom loaders are included in the AOT cache
180 // but their array classes are excluded.
181 counter += custInstance.equals(null) ? 1 : 2;
182 }
183
184 if (custArrayInstance != null) {
185 if ((counter % 3) == 0) {
186 counter += (custArrayInstance instanceof String) ? 0 : 1;
187 } else {
188 counter += (custArrayInstance instanceof Object) ? 0 : 1;
189 }
190 }
256 }
257 }
258
259 static class Taz {
260 static ShouldBeExcluded m() {
261 // Taz should be excluded from the AOT cache because it has a verification constraint that
262 // "ShouldBeExcludedChild must be a subtype of ShouldBeExcluded", but ShouldBeExcluded is
263 // excluded from the AOT cache.
264 return new ShouldBeExcludedChild();
265 }
266 static void hotSpot4() {
267 long start = System.currentTimeMillis();
268 while (System.currentTimeMillis() - start < 20) {
269 for (int i = 0; i < 50000; i++) {
270 counter += i;
271 }
272 f();
273 }
274 }
275 }
276 }
277 }
278
|
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 * @summary Test how various AOT optimizations handle classes that are excluded from the AOT cache.
28 * @requires vm.cds.write.archived.java.heap
29 * @library /test/jdk/lib/testlibrary /test/lib
30 * /test/hotspot/jtreg/runtime/cds/appcds/aotCache/test-classes
31 * @build ExcludedClasses CustyWithLoop
32 * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar app.jar
33 * TestApp
34 * TestApp$Foo
35 * TestApp$Foo$BadFieldSig
36 * TestApp$Foo$BadMethodSig
37 * TestApp$Foo$Bar
38 * TestApp$Foo$GoodSig1
39 * TestApp$Foo$GoodSig2
40 * TestApp$Foo$ShouldBeExcluded
41 * TestApp$Foo$ShouldBeExcludedChild
42 * TestApp$Foo$Taz
43 * TestApp$MyInvocationHandler
44 * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar cust.jar
45 * CustyWithLoop
46 * @run driver ExcludedClasses
47 */
48
49 import java.io.File;
50 import java.lang.reflect.Array;
51 import java.lang.reflect.Field;
52 import java.lang.reflect.InvocationHandler;
53 import java.lang.reflect.Method;
54 import java.lang.reflect.Proxy;
55 import java.net.URL;
56 import java.net.URLClassLoader;
57 import java.security.ProtectionDomain;
58 import java.util.Map;
59
60 import jdk.jfr.Event;
61 import jdk.test.lib.cds.CDSAppTester;
62 import jdk.test.lib.helpers.ClassFileInstaller;
63 import jdk.test.lib.process.OutputAnalyzer;
64
65 public class ExcludedClasses {
66 static final String appJar = ClassFileInstaller.getJarPath("app.jar");
67 static final String mainClass = "TestApp";
68
69 public static void main(String[] args) throws Exception {
70 Tester tester = new Tester();
71 tester.runAOTWorkflow("AOT", "--two-step-training");
86 return new String[] {
87 "-Xlog:aot=debug",
88 "-Xlog:aot+class=debug",
89 "-Xlog:aot+resolve=trace",
90 "-Xlog:aot+verification=trace",
91 "-Xlog:class+load",
92 };
93 }
94
95 @Override
96 public String[] appCommandLine(RunMode runMode) {
97 return new String[] {
98 mainClass, runMode.name()
99 };
100 }
101
102 @Override
103 public void checkExecution(OutputAnalyzer out, RunMode runMode) {
104 if (runMode == RunMode.ASSEMBLY) {
105 out.shouldNotMatch("aot,resolve.*archived field.*TestApp.Foo => TestApp.Foo.ShouldBeExcluded.f:I");
106 out.shouldContain("Archived reflection data in TestApp$Foo$GoodSig1");
107 out.shouldContain("Archived reflection data in TestApp$Foo$GoodSig2");
108 out.shouldContain("Cannot archive reflection data in TestApp$Foo$BadMethodSig");
109 out.shouldContain("Cannot archive reflection data in TestApp$Foo$BadFieldSig");
110 } else if (runMode == RunMode.PRODUCTION) {
111 out.shouldContain("jdk.jfr.Event source: jrt:/jdk.jfr");
112 out.shouldMatch("TestApp[$]Foo[$]ShouldBeExcluded source: .*/app.jar");
113 out.shouldMatch("TestApp[$]Foo[$]ShouldBeExcludedChild source: .*/app.jar");
114 }
115 }
116 }
117 }
118
119 class TestApp {
120 static volatile Object custInstance;
121 static volatile Object custArrayInstance;
122
123 public static void main(String args[]) throws Exception {
124 // In AOT workflow, classes from custom loaders are passed from the preimage
125 // to the final image. See FinalImageRecipes::record_all_classes().
126 custInstance = initFromCustomLoader();
127 custArrayInstance = Array.newInstance(custInstance.getClass(), 0);
128 System.out.println(custArrayInstance);
129 System.out.println("Counter = " + Foo.hotSpot());
160
161 static class Foo {
162 volatile static int counter;
163 static Class c = ShouldBeExcluded.class;
164
165 static Map mapProxy = (Map) Proxy.newProxyInstance(
166 Foo.class.getClassLoader(),
167 new Class[] { Map.class },
168 new MyInvocationHandler());
169
170 static int hotSpot() {
171 ShouldBeExcluded s = new ShouldBeExcluded();
172 Bar b = new Bar();
173
174 long start = System.currentTimeMillis();
175 while (System.currentTimeMillis() - start < 1000) {
176 lambdaHotSpot();
177 s.hotSpot2();
178 b.hotSpot3();
179 Taz.hotSpot4();
180 reflectHotSpots();
181
182 // In JDK mainline, generated proxy classes are excluded from the AOT cache.
183 // In Leyden/premain, generated proxy classes included. The following code should
184 // work with either repos.
185 Integer i = (Integer)mapProxy.get(null);
186 counter += i.intValue();
187
188 if (custInstance != null) {
189 // Classes loaded by custom loaders are included in the AOT cache
190 // but their array classes are excluded.
191 counter += custInstance.equals(null) ? 1 : 2;
192 }
193
194 if (custArrayInstance != null) {
195 if ((counter % 3) == 0) {
196 counter += (custArrayInstance instanceof String) ? 0 : 1;
197 } else {
198 counter += (custArrayInstance instanceof Object) ? 0 : 1;
199 }
200 }
266 }
267 }
268
269 static class Taz {
270 static ShouldBeExcluded m() {
271 // Taz should be excluded from the AOT cache because it has a verification constraint that
272 // "ShouldBeExcludedChild must be a subtype of ShouldBeExcluded", but ShouldBeExcluded is
273 // excluded from the AOT cache.
274 return new ShouldBeExcludedChild();
275 }
276 static void hotSpot4() {
277 long start = System.currentTimeMillis();
278 while (System.currentTimeMillis() - start < 20) {
279 for (int i = 0; i < 50000; i++) {
280 counter += i;
281 }
282 f();
283 }
284 }
285 }
286
287 static volatile Object dummyObj;
288
289 static void reflectHotSpots() {
290 try {
291 // f.clazz points to an excluded class, so we should not archive any fields in
292 // the BadFieldSig
293 Field f = BadFieldSig.class.getDeclaredField("myField");
294 Method m = BadMethodSig.class.getDeclaredMethod("myMethod", Object.class, ShouldBeExcluded.class);
295
296 // It's OK to archive the reflection data of this class even if its method signatures
297 // refers to a class that's not loaded at all during the assembly phase.
298 // Note: because the app did not reflect on the methods of GoodSig1, we don't
299 // AOT-generate method reflection data for GoodSig.
300 Field f2 = GoodSig1.class.getDeclaredField("myField");
301
302 // Opposite case as GoodSig1. We should archive its reflection data
303 Method m2 = GoodSig2.class.getDeclaredMethod("myMethod", Object.class, Object.class);
304
305 long start = System.currentTimeMillis();
306 while (System.currentTimeMillis() - start < 50) {
307 for (int i = 0; i < 50000; i++) {
308 dummyObj = f.get(null);
309 dummyObj = m.invoke(null, null, null);
310 dummyObj = f2.get(null);
311 dummyObj = m2.invoke(null, null, null);
312 }
313 }
314 } catch (Throwable t) {
315 throw new RuntimeException("Unexpected exception", t);
316 }
317 }
318
319 static class BadFieldSig {
320 static ShouldBeExcluded myField = new ShouldBeExcluded();
321 }
322
323 static class BadMethodSig {
324 static String myMethod(Object o, ShouldBeExcluded s) {
325 return "Foofoo";
326 }
327 }
328
329 static class GoodSig1 {
330 static Object myField = new Object();
331 static void method(UnavailableClass1 arg) {}
332 static void method(UnavailableClass2[] arg) {}
333 }
334
335 static class GoodSig2 {
336 static String myMethod(Object o, Object o2) {
337 return "Foofoo";
338 }
339
340 UnavailableClass2[] unusedField;
341
342 // This field has never been reflected up or resolved during the training run, so the
343 // array type GoodSig2[][][][] is not resolved during either the training run or the
344 // assembly phase.
345 GoodSig2[][][][] unusedField2;
346 }
347 }
348 }
349
350 // These classes are NOT part of app.jar, so they cannot be resolved by the app.
351 class UnavailableClass1 {}
352 class UnavailableClass2 {}
353
|