1 /* 2 * Copyright (c) 2023, 2025, 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 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"); 67 } 68 69 static class Tester extends CDSAppTester { 70 public Tester() { 71 super(mainClass); 72 } 73 74 @Override 75 public String classpath(RunMode runMode) { 76 return appJar; 77 } 78 79 @Override 80 public String[] vmArgs(RunMode runMode) { 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()); 121 } 122 123 static Object initFromCustomLoader() throws Exception { 124 String path = "cust.jar"; 125 URL url = new File(path).toURI().toURL(); 126 URL[] urls = new URL[] {url}; 127 URLClassLoader urlClassLoader = 128 new URLClassLoader("MyLoader", urls, null); 129 Class c = Class.forName("CustyWithLoop", true, urlClassLoader); 130 return c.newInstance(); 131 } 132 133 static class MyInvocationHandler implements InvocationHandler { 134 volatile static int cnt; 135 136 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 137 long start = System.currentTimeMillis(); 138 while (System.currentTimeMillis() - start < 20) { 139 cnt += 2; 140 for (int i = 0; i < 1000; i++) { 141 int n = cnt - 2; 142 if (n < 2) { 143 n = 2; 144 } 145 cnt += (i + cnt) % n + cnt % 2; 146 } 147 } 148 return Integer.valueOf(cnt); 149 } 150 } 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 } 191 } 192 193 return counter + s.m() + s.f + b.m() + b.f; 194 } 195 196 static void f() { 197 if (counter % 2 == 1) { 198 counter ++; 199 } 200 } 201 202 // Generated Lambda classes should be excluded from CDS preimage. 203 static void lambdaHotSpot() { 204 long start = System.currentTimeMillis(); 205 while (System.currentTimeMillis() - start < 20) { 206 doit(() -> counter ++ ); 207 } 208 } 209 210 static void doit(Runnable r) { 211 r.run(); 212 } 213 214 // All subclasses of jdk.jfr.Event are excluded from the CDS archive. 215 static class ShouldBeExcluded extends jdk.jfr.Event { 216 int f = (int)(System.currentTimeMillis()) + 123; 217 int m() { 218 return f + 456; 219 } 220 221 void hotSpot2() { 222 long start = System.currentTimeMillis(); 223 while (System.currentTimeMillis() - start < 20) { 224 for (int i = 0; i < 50000; i++) { 225 counter += i; 226 } 227 f(); 228 } 229 } 230 int func() { 231 return 1; 232 } 233 } 234 235 static class ShouldBeExcludedChild extends ShouldBeExcluded { 236 @Override 237 int func() { 238 return 2; 239 } 240 } 241 242 static class Bar { 243 int f = (int)(System.currentTimeMillis()) + 123; 244 int m() { 245 return f + 456; 246 } 247 248 void hotSpot3() { 249 long start = System.currentTimeMillis(); 250 while (System.currentTimeMillis() - start < 20) { 251 for (int i = 0; i < 50000; i++) { 252 counter += i; 253 } 254 f(); 255 } 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