< prev index next >

test/hotspot/jtreg/runtime/cds/appcds/aotCache/ExcludedClasses.java

Print this page

 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 
< prev index next >