perf(parparvm-tests): diagonal JDK matrix, cache JavaAPI, parallel forks (#5198)

The vm/tests suite ran ~60 min serially. Three changes cut that without
losing test coverage:

1. Diagonal compiler matrix. BytecodeInstructionIntegrationTest#provide-
   CompilerConfigs (the shared @MethodSource for RuntimeSemantics, Target,
   Bytecode, CleanTarget, Smoke, NativeAudit, FileClass, ...) built the full
   triangular (compiler-JDK x target-bytecode) cross-product: 15 combos, so
   every parameterized method ran 15x. The translator consumes bytecode, which
   is governed by the *target* level, so compiling a given target with five
   different JDKs mostly re-tested identical bytecode shapes. New
   CompilerHelper.getDiagonalCompilers() keeps each target exercised by its
   matching JDK (8->8, 11->11, 17->17, 21->21, 25->25) = 5 combos. The biggest
   class (JavascriptRuntimeSemanticsTest, ~24 min) scales directly with this.

2. Cache the compiled JavaAPI. compileJavaAPI() re-ran a ~259-source javac on
   every parameterized invocation (hundreds of times); its output depends only
   on (jdkVersion, targetVersion). It is now compiled once per combo and copied
   into each caller's dir. Coverage-neutral.

3. Parallel surefire forks. forkCount=1C, reuseForks=true. Parallelism is
   process-level by necessity: Parser holds static mutable translator state, so
   in-JVM thread parallelism would corrupt it; separate forks each run classes
   sequentially. Tests use unique temp dirs and the only shared path
   (target/benchmark-dependencies) is populated by maven before the test phase
   and only read, so forks do not collide. jacoco now writes one exec file per
   fork (${surefire.forkNumber}) and merges them before the report so the
   ByteCodeTranslator quality/coverage report is unchanged.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

vm/tests/pom.xml

@@ -106,6 +106,15 @@
                 <version>3.2.5</version>
                 <configuration>
                     <useModulePath>false</useModulePath>
+                    <!-- Run test classes across parallel JVM forks. Parallelism MUST be
+                         process-level: the translator (Parser) keeps static mutable state,
+                         so in-JVM thread parallelism would corrupt it. Each test writes to
+                         unique createTempDirectory paths and the only shared path
+                         (target/benchmark-dependencies) is populated by maven-dependency-plugin
+                         before the test phase and only read here, so forks never collide.
+                         1C = one fork per available CPU core. -->
+                    <forkCount>1C</forkCount>
+                    <reuseForks>true</reuseForks>
                 </configuration>
             </plugin>
             <plugin>
@@ -117,6 +126,34 @@
                         <goals>
                             <goal>prepare-agent</goal>
                         </goals>
+                        <configuration>
+                            <!-- One exec file per surefire fork. surefire substitutes
+                                 ${surefire.forkNumber} in the agent argLine per forked JVM;
+                                 without this, parallel forks would clobber a single
+                                 jacoco.exec and the coverage report would be corrupt/empty. -->
+                            <destFile>${project.build.directory}/jacoco-fork-${surefire.forkNumber}.exec</destFile>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <!-- Merge the per-fork exec files back into one before the report.
+                             Declared before the report execution so it runs first in the
+                             test phase. -->
+                        <id>merge-forks</id>
+                        <phase>test</phase>
+                        <goals>
+                            <goal>merge</goal>
+                        </goals>
+                        <configuration>
+                            <fileSets>
+                                <fileSet>
+                                    <directory>${project.build.directory}</directory>
+                                    <includes>
+                                        <include>jacoco-fork-*.exec</include>
+                                    </includes>
+                                </fileSet>
+                            </fileSets>
+                            <destFile>${project.build.directory}/jacoco.exec</destFile>
+                        </configuration>
                     </execution>
                     <execution>
                         <id>report</id>

vm/tests/src/test/java/com/codename1/tools/translator/BytecodeInstructionIntegrationTest.java

@@ -39,14 +39,13 @@
 
 class BytecodeInstructionIntegrationTest {
 
+    // Shared @MethodSource for the integration suites (RuntimeSemantics, Target,
+    // Bytecode, CleanTarget, Smoke, NativeAudit, FileClass, ...). Uses the
+    // diagonal compiler set -- each bytecode target compiled by its matching JDK
+    // (8->8 .. 25->25) -- rather than the full (compiler x target) cross-product,
+    // which re-tested the same bytecode shapes. See CompilerHelper.getDiagonalCompilers.
     static Stream<CompilerHelper.CompilerConfig> provideCompilerConfigs() {
-        List<CompilerHelper.CompilerConfig> configs = new ArrayList<>();
-        configs.addAll(CompilerHelper.getAvailableCompilers("1.8"));
-        configs.addAll(CompilerHelper.getAvailableCompilers("11"));
-        configs.addAll(CompilerHelper.getAvailableCompilers("17"));
-        configs.addAll(CompilerHelper.getAvailableCompilers("21"));
-        configs.addAll(CompilerHelper.getAvailableCompilers("25"));
-        return configs.stream();
+        return CompilerHelper.getDiagonalCompilers().stream();
     }
 
     @ParameterizedTest

vm/tests/src/test/java/com/codename1/tools/translator/CompilerHelper.java

@@ -190,6 +190,29 @@ public static List<CompilerConfig> getAvailableCompilers(String targetVersion) {
         return compilers;
     }
 
+    // Diagonal compiler set: each supported bytecode target compiled only by the
+    // JDK whose major version matches that target (8->8, 11->11, 17->17, 21->21,
+    // 25->25). The translator consumes bytecode, which is governed by the target
+    // level, so the full (compiler x target) cross-product mostly re-tests the
+    // same bytecode shapes. Restricting to the diagonal keeps every target level
+    // exercised while cutting the per-method parameter count from up to 15 to 5.
+    // A target whose matching JDK is not installed locally is simply skipped
+    // (CI installs all five). Pairs use {target, jdkMajor}; "1.8" maps to JDK 8.
+    public static List<CompilerConfig> getDiagonalCompilers() {
+        String[][] pairs = { {"1.8", "8"}, {"11", "11"}, {"17", "17"}, {"21", "21"}, {"25", "25"} };
+        List<CompilerConfig> out = new ArrayList<>();
+        for (String[] pair : pairs) {
+            int wantMajor = parseJavaMajor(pair[1]);
+            for (CompilerConfig config : getAvailableCompilers(pair[0])) {
+                if (getJdkMajor(config) == wantMajor) {
+                    out.add(config);
+                    break;
+                }
+            }
+        }
+        return out;
+    }
+
     private static boolean canCompile(String compilerVersion, String targetVersion) {
         int compilerMajor = parseJavaMajor(compilerVersion);
         int targetMajor = parseJavaMajor(targetVersion);
@@ -385,7 +408,35 @@ public static boolean compileAndRun(String code, String expectedOutput) throws E
         }
     }
 
+    // The compiled JavaAPI is identical for a given (jdkVersion, targetVersion),
+    // yet it was previously re-compiled (a ~259-source javac run) on every
+    // parameterized test invocation -- hundreds of times across the suite. Cache
+    // the compiled output per combo and copy it into each caller's outputDir
+    // instead. This removes the dominant repeated cost with zero change to what
+    // is tested. Within a surefire fork tests run sequentially, so the only
+    // contention is the compile-once guard below.
+    private static final java.util.Map<String, Path> JAVA_API_CACHE =
+            new java.util.concurrent.ConcurrentHashMap<>();
+
     public static void compileJavaAPI(Path outputDir, CompilerConfig config) throws IOException, InterruptedException {
+        Files.createDirectories(outputDir);
+        copyDirectory(getCachedJavaApi(config), outputDir);
+    }
+
+    private static synchronized Path getCachedJavaApi(CompilerConfig config) throws IOException, InterruptedException {
+        String key = config.jdkVersion + "->" + config.targetVersion;
+        Path cached = JAVA_API_CACHE.get(key);
+        if (cached != null && Files.isDirectory(cached)) {
+            return cached;
+        }
+        Path cacheDir = Files.createTempDirectory(
+                "java-api-cache-" + config.jdkVersion + "-" + config.targetVersion.replaceAll("[^A-Za-z0-9]", "_") + "-");
+        compileJavaApiInto(cacheDir, config);
+        JAVA_API_CACHE.put(key, cacheDir);
+        return cacheDir;
+    }
+
+    private static void compileJavaApiInto(Path outputDir, CompilerConfig config) throws IOException, InterruptedException {
         Files.createDirectories(outputDir);
         Path javaApiRoot = Paths.get("..", "JavaAPI", "src").normalize().toAbsolutePath();
         List<String> sources = new ArrayList<>();