8381968: Extend cds/appcds/aotCode/AOTCodeFlags.java to run test with different flags in assembly and prod run

Reviewed-by: kvn, adinn

Author: Ashutosh Mehra

test/hotspot/jtreg/TEST.groups

@@ -587,7 +587,8 @@ hotspot_metaspace = \
 tier1_runtime_appcds = \
   runtime/cds/appcds/aotCache/HelloAOTCache.java \
   runtime/cds/appcds/aotCode \
-  runtime/cds/appcds/HelloTest.java
+  runtime/cds/appcds/HelloTest.java \
+  -runtime/cds/appcds/aotCode/AOTCodeFlags.java
 
 tier1_runtime_appcds_exclude = \
   runtime/cds/appcds/ \

test/hotspot/jtreg/runtime/cds/appcds/aotCode/AOTCodeCPUFeatureIncompatibilityTest.java

@@ -31,13 +31,9 @@
  * @comment The test verifies AOT checks during VM startup and not code generation.
  *          No need to run it with -Xcomp.
  * @library /test/lib /test/setup_aot
- * @build AOTCodeCPUFeatureIncompatibilityTest JavacBenchApp
+ * @build AOTCodeCPUFeatureIncompatibilityTest HelloWorld
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
- * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar app.jar
- *             JavacBenchApp
- *             JavacBenchApp$ClassFile
- *             JavacBenchApp$FileManager
- *             JavacBenchApp$SourceFile
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar app.jar HelloWorld
  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI AOTCodeCPUFeatureIncompatibilityTest
  */
 
@@ -98,9 +94,7 @@ public String classpath(RunMode runMode) {
             }
             @Override
             public String[] appCommandLine(RunMode runMode) {
-                return new String[] {
-                    "JavacBenchApp", "10"
-                };
+                return new String[] { "HelloWorld" };
             }
         }.runAOTWorkflow("--two-step-training");
     }

test/hotspot/jtreg/runtime/cds/appcds/aotCode/AOTCodeCompressedOopsTest.java

@@ -33,12 +33,8 @@
  *          No need to run it with -Xcomp. It takes a lot of time to complete all
  *          subtests with this flag.
  * @library /test/lib /test/setup_aot
- * @build AOTCodeCompressedOopsTest JavacBenchApp
- * @run driver/timeout=480 jdk.test.lib.helpers.ClassFileInstaller -jar app.jar
- *             JavacBenchApp
- *             JavacBenchApp$ClassFile
- *             JavacBenchApp$FileManager
- *             JavacBenchApp$SourceFile
+ * @build AOTCodeCompressedOopsTest HelloWorld
+ * @run driver/timeout=480 jdk.test.lib.helpers.ClassFileInstaller -jar app.jar HelloWorld
  * @run driver/timeout=480 AOTCodeCompressedOopsTest
  */
 
@@ -149,9 +145,7 @@ public String[] vmArgs(RunMode runMode) {
 
         @Override
         public String[] appCommandLine(RunMode runMode) {
-            return new String[] {
-                "JavacBenchApp", "10"
-            };
+            return new String[] { "HelloWorld" };
         }
 
         @Override

test/hotspot/jtreg/runtime/cds/appcds/aotCode/AOTCodeFlags.java

@@ -109,39 +109,44 @@ public class AOTCodeFlags {
     private static String gcName = null;
     public static void main(String... args) throws Exception {
         Tester t = new Tester(args.length == 0 ? null : args[0]);
-        // Run only 2 modes (0 - no AOT code, 1 - AOT adapters) until JDK-8357398 is fixed
-        for (int mode = 0; mode < 4; mode++) {
-            t.setTestMode(mode);
-            t.run(new String[] {"AOT", "--two-step-training"});
+        // mode bits 0 and 1 encode AOTAdapterCaching and AOTStubCaching settings
+        // aMode is used for assembly run, pMode for production run
+        for (int aMode = 0; aMode < 4; aMode++) {
+            for (int pMode = 0; pMode < 4; pMode++) {
+                t.setTestMode(aMode, pMode);
+                t.run(new String[] {"AOT", "--two-step-training"});
+            }
         }
     }
     static class Tester extends CDSAppTester {
-        private int testMode;
+        private int aMode, pMode;
         private String gcName;
 
         public Tester(String name) {
             super("AOTCodeFlags");
-            testMode = 0;
+            aMode = 0;
+            pMode = 0;
             gcName = name;
         }
 
-        boolean isAdapterCachingOn() {
-            return (testMode & 0x1) != 0;
+        boolean isAdapterCachingOn(int mode) {
+            return (mode & 0x1) != 0;
         }
 
-        boolean isStubCachingOn() {
-            return (testMode & 0x2) != 0;
+        boolean isStubCachingOn(int mode) {
+            return (mode & 0x2) != 0;
         }
 
-        public void setTestMode(int mode) {
-            testMode = mode;
+        public void setTestMode(int aMode, int pMode) {
+            this.aMode = aMode;
+            this.pMode = pMode;
         }
 
-        public List<String> getVMArgsForTestMode() {
+        public List<String> getVMArgsForTestMode(int mode) {
             List<String> list = new ArrayList<String>();
             list.add("-XX:+UnlockDiagnosticVMOptions");
-            list.add(isAdapterCachingOn() ? "-XX:+AOTAdapterCaching" : "-XX:-AOTAdapterCaching");
-            list.add(isStubCachingOn() ? "-XX:+AOTStubCaching" : "-XX:-AOTStubCaching");
+            list.add(isAdapterCachingOn(mode) ? "-XX:+AOTAdapterCaching" : "-XX:-AOTAdapterCaching");
+            list.add(isStubCachingOn(mode) ? "-XX:+AOTStubCaching" : "-XX:-AOTStubCaching");
             return list;
         }
 
@@ -170,79 +175,91 @@ public String classpath(RunMode runMode) {
 
         @Override
         public String[] vmArgs(RunMode runMode) {
+            List<String> args = getGCArgs();
+            args.addAll(List.of("-Xlog:aot+codecache+init=debug",
+                                "-Xlog:aot+codecache+exit=debug",
+                                "-Xlog:aot+codecache+stubs=debug"));
             switch (runMode) {
             case RunMode.ASSEMBLY:
-            case RunMode.PRODUCTION: {
-                    List<String> args = getVMArgsForTestMode();
-                    args.addAll(List.of("-Xlog:aot+codecache+init=debug",
-                                        "-Xlog:aot+codecache+exit=debug"));
-                    args.addAll(getGCArgs());
-                    return args.toArray(new String[0]);
-                }
+                args.addAll(getVMArgsForTestMode(aMode));
+                break;
+            case RunMode.PRODUCTION:
+                args.addAll(getVMArgsForTestMode(pMode));
+                break;
+            default:
+                break;
             }
-            List<String> args = getGCArgs();
             return args.toArray(new String[args.size()]);
         }
 
         @Override
         public String[] appCommandLine(RunMode runMode) {
-            return new String[] {
-                "JavacBenchApp", "10"
-            };
+            return new String[] { "JavacBenchApp", "10" };
         }
 
         @Override
         public void checkExecution(OutputAnalyzer out, RunMode runMode) throws Exception {
-            if (!isAdapterCachingOn() && !isStubCachingOn()) { // this is equivalent to completely disable AOT code cache
-                switch (runMode) {
-                case RunMode.ASSEMBLY:
-                case RunMode.PRODUCTION:
+            if (runMode == RunMode.ASSEMBLY) {
+                if (!isAdapterCachingOn(aMode) && !isStubCachingOn(aMode)) { // this is equivalent to completely disable AOT code cache
                     out.shouldNotMatch("Adapters:\\s+total");
                     out.shouldNotMatch("Shared Blobs:\\s+total");
                     out.shouldNotMatch("C1 Blobs:\\s+total");
                     out.shouldNotMatch("C2 Blobs:\\s+total");
-                    break;
-                }
-            } else {
-                if (isAdapterCachingOn()) {
-                    switch (runMode) {
-                    case RunMode.ASSEMBLY:
-                    case RunMode.PRODUCTION:
-                        // AOTAdapterCaching is on, non-zero adapters should be stored/loaded
-                        out.shouldMatch("Adapters:\\s+total=[1-9][0-9]+");
-                        break;
-                    }
                 } else {
-                    switch (runMode) {
-                    case RunMode.ASSEMBLY:
-                    case RunMode.PRODUCTION:
-                        // AOTAdapterCaching is off, no adapters should be stored/loaded
+                    if (isAdapterCachingOn(aMode)) {
+                        // AOTAdapterCaching is on, non-zero adapters should be stored
+                        out.shouldMatch("Adapters:\\s+total=[1-9][0-9]+");
+                    } else {
+                        // AOTAdapterCaching is off, no adapters should be stored
                         out.shouldMatch("Adapters:\\s+total=0");
-                        break;
                     }
-                }
-                if (isStubCachingOn()) {
-                    switch (runMode) {
-                    case RunMode.ASSEMBLY:
-                    case RunMode.PRODUCTION:
-                        // AOTStubCaching is on, non-zero stubs should be stored/loaded
+                    if (isStubCachingOn(aMode)) {
+                        // AOTStubCaching is on, non-zero stubs should be stored
                         out.shouldMatch("Shared Blobs:\\s+total=[1-9][0-9]+");
                         out.shouldMatch("C1 Blobs:\\s+total=[1-9][0-9]+");
                         // we do not currently load or store C2 stubs
                         // because we are seeing weird memory errors
                         // when loading them -- see JDK-8357593
                         out.shouldMatch("C2 Blobs:\\s+total=0");
-                        break;
-                    }
-                } else {
-                    switch (runMode) {
-                    case RunMode.ASSEMBLY:
-                    case RunMode.PRODUCTION:
-                        // AOTStubCaching is off, no stubs should be stored/loaded
+                    } else {
+                        // AOTStubCaching is off, no stubs should be stored
                         out.shouldMatch("Shared Blobs:\\s+total=0");
                         out.shouldMatch("C1 Blobs:\\s+total=0");
                         out.shouldMatch("C2 Blobs:\\s+total=0");
-                        break;
+                    }
+                }
+            } else if (runMode == RunMode.PRODUCTION) {
+                // Irrespective of assembly run mode, if both adapter and stub caching is disabled
+                // in production run, then it is equivalent to completely disabling AOT code cache
+                if (!isAdapterCachingOn(pMode) && !isStubCachingOn(pMode)) {
+                    out.shouldNotMatch("Adapters:\\s+total");
+                    out.shouldNotMatch("Shared Blobs:\\s+total");
+                    out.shouldNotMatch("C1 Blobs:\\s+total");
+                    out.shouldNotMatch("C2 Blobs:\\s+total");
+                } else {
+                    // If AOT code cache is effectively disabled in the assembly run, then production run
+                    // would emit empty code cache message.
+                    if (!isAdapterCachingOn(aMode) && !isStubCachingOn(aMode)) {
+                        if (isAdapterCachingOn(pMode) || isStubCachingOn(pMode)) {
+                            out.shouldMatch("AOT Code Cache is empty");
+                        }
+                    } else {
+                        if (isAdapterCachingOn(aMode)) {
+                            if (isAdapterCachingOn(pMode)) {
+                                out.shouldMatch("Read blob.*kind=Adapter.*");
+                            } else {
+                                out.shouldNotMatch("Read blob.*kind=Adapter.*");
+                            }
+                        }
+                        if (isStubCachingOn(aMode)) {
+                            if (isStubCachingOn(pMode)) {
+                                out.shouldMatch("Read blob.*kind=SharedBlob.*");
+                                out.shouldMatch("Read blob.*kind=C1Blob.*");
+                            } else {
+                                out.shouldNotMatch("Read blob.*kind=SharedBlob.*");
+                                out.shouldNotMatch("Read blob.*kind=C1Blob.*");
+                            }
+                        }
                     }
                 }
             }