ParparVM performance: parity with warmed Java 25 (geomean 1.00x)

.github/workflows/linux-build-run.yml

@@ -207,6 +207,9 @@ jobs:
         working-directory: vm
         env:
           CN1_SHOT_OUTPUT_DIR: ${{ github.workspace }}/artifacts/linux-port/raw
+          # Full app stdout/stderr -- the only evidence when the suite wedges
+          # mid-run (uploaded with the screenshot artifact below).
+          CN1_APP_LOG_TEE: ${{ github.workspace }}/artifacts/linux-port/raw/app-output.log
           # Build the native ELF (and the demo) against an old glibc for portability.
           CN1_CC: /usr/local/bin/cn1-zig-cc
           # After the suite runs, the capture test relinks the same objects into a
@@ -215,13 +218,50 @@ jobs:
           LIBGL_ALWAYS_SOFTWARE: '1'
         run: |
           set -e
+          sudo apt-get install -y --no-install-recommends gdb >/dev/null 2>&1 || true
           Xvfb :99 -screen 0 1200x1600x24 >/tmp/xvfb-run.log 2>&1 &
           export DISPLAY=:99
           sleep 2
+          # The suite intermittently DIES mid-run with no output (gdb-attach
+          # watchdog found the pid already gone -- a silent crash, not a hang).
+          # Enable core dumps and post-mortem them into the artifact.
+          ulimit -c unlimited
+          echo '/tmp/cn1-cores/core.%e.%p' | sudo tee /proc/sys/kernel/core_pattern >/dev/null
+          mkdir -p /tmp/cn1-cores
+          rc=0
           mvn -B clean package -pl JavaAPI -am -DskipTests
           mvn -B test -pl tests -am \
             '-Dtest=CleanTargetLinuxIntegrationTest#capturesHelloSuiteOverWebSocketLinux' \
-            '-Dsurefire.failIfNoSpecifiedTests=false'
+            '-Dsurefire.failIfNoSpecifiedTests=false' || rc=$?
+          for core in /tmp/cn1-cores/core.*; do
+            [ -f "$core" ] || continue
+            elf="$(/usr/bin/find /tmp -maxdepth 4 -name LinuxHelloMain -type f 2>/dev/null | head -1)"
+            mkdir -p "$(dirname "$CN1_APP_LOG_TEE")"
+            {
+              echo "=== post-mortem of $core (elf=$elf) ==="
+              gdb "$elf" "$core" -batch -ex 'set pagination off' \
+                -ex 'thread apply all bt' \
+                -ex 'thread 1' -ex 'bt full' \
+                -ex 'frame 0' -ex 'info args' \
+                -ex 'frame 1' -ex 'info locals' -ex 'info args' \
+                -ex 'p gcMarkWorklistTop' -ex 'p currentGcMarkValue' \
+                2>&1
+            } >> "$(dirname "$CN1_APP_LOG_TEE")/crash-stacks.txt" || true
+          done
+          # Resolve the CN1 FAULT/ABORT backtrace addresses (LinuxHelloMain[0x...]) that the
+          # SA_ONSTACK handler dumped to app-output.log into function names -- the faulting
+          # frames (e.g. a stack overflow's recursion / the caller that ran CN1 on a small
+          # native stack). The suite binary is not stripped, so addr2line resolves them.
+          elf="$(/usr/bin/find /tmp -maxdepth 4 -name LinuxHelloMain -type f 2>/dev/null | head -1)"
+          if [ -n "$elf" ] && [ -f "$CN1_APP_LOG_TEE" ]; then
+            {
+              echo "=== addr2line of CN1 backtrace addresses (from app log) ==="
+              grep -oE "LinuxHelloMain\[0x[0-9a-f]+\]" "$CN1_APP_LOG_TEE" | grep -oE "0x[0-9a-f]+" | while read a; do
+                echo "$a -> $(addr2line -f -C -e "$elf" "$a" 2>/dev/null | tr '\n' ' ')"
+              done
+            } >> "$(dirname "$CN1_APP_LOG_TEE")/crash-stacks.txt" 2>&1 || true
+          fi
+          exit $rc
 
       - name: Upload screenshot artifact (${{ matrix.arch }})
         if: always()
@@ -268,6 +308,7 @@ jobs:
           docker run --rm \
             -v "$GITHUB_WORKSPACE":/cn1 -w /cn1 \
             -e CN1_SHOT_OUTPUT_DIR=/cn1/artifacts/linux-port/raw-musl \
+            -e CN1_APP_LOG_TEE=/cn1/artifacts/linux-port/raw-musl/app-output.log \
             -e LIBGL_ALWAYS_SOFTWARE=1 \
             docker.io/library/alpine:3.20 sh -ec '
               sed -i "s|^#\(.*/community\)|\1|" /etc/apk/repositories

.github/workflows/parparvm-tests-windows.yml

@@ -366,6 +366,22 @@ jobs:
           mvn -B clean package -pl JavaAPI -am -DskipTests
           mvn -B test -pl tests -am '-Dtest=CleanTargetIntegrationTest#capturesHelloSuiteOverWebSocket' '-Dsurefire.failIfNoSpecifiedTests=false'
 
+      # Preserve the native cn1WindowsLog output so the offscreen-capture path is
+      # confirmable on the green x64 gate too (compare against the arm64 leg).
+      - name: Collect native windows log (x64)
+        if: always()
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path artifacts/windows-port/raw | Out-Null
+          $log = Join-Path $env:TEMP 'cn1windows.log'
+          if (Test-Path $log) {
+            Copy-Item $log artifacts/windows-port/raw/cn1windows-native.log -Force
+            Write-Host "collected native log ($((Get-Item $log).Length) bytes)"
+          } else {
+            "no native cn1windows.log found at $log" | Out-File artifacts/windows-port/raw/cn1windows-native.log
+            Write-Host "no native log at $log"
+          }
+
       - name: Upload screenshot artifact (x64)
         if: always()
         uses: actions/upload-artifact@v4
@@ -474,6 +490,24 @@ jobs:
           mvn -B clean package -pl JavaAPI -am -DskipTests
           mvn -B test -pl tests -am '-Dtest=CleanTargetIntegrationTest#capturesHelloSuiteOverWebSocket' '-Dsurefire.failIfNoSpecifiedTests=false'
 
+      # Preserve the native cn1WindowsLog output (%TEMP%\cn1windows.log) so an
+      # offscreen-target / capture failure is diagnosable from the artifact, and
+      # so the raw dir is never empty (the arm64 artifact would otherwise not be
+      # produced when the suite stalls before writing any PNG).
+      - name: Collect native windows log (arm64)
+        if: always()
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path artifacts/windows-port/raw | Out-Null
+          $log = Join-Path $env:TEMP 'cn1windows.log'
+          if (Test-Path $log) {
+            Copy-Item $log artifacts/windows-port/raw/cn1windows-native.log -Force
+            Write-Host "collected native log ($((Get-Item $log).Length) bytes)"
+          } else {
+            "no native cn1windows.log found at $log" | Out-File artifacts/windows-port/raw/cn1windows-native.log
+            Write-Host "no native log at $log"
+          }
+
       - name: Upload screenshot artifact (arm64)
         if: always()
         uses: actions/upload-artifact@v4
@@ -538,11 +572,29 @@ jobs:
           source scripts/lib/cn1ss.sh
           cn1ss_setup "$JAVA_HOME/bin/java" "$(pwd)/scripts/common/java"
           REF_DIR="$(pwd)/scripts/windows/screenshots"
+          # Gate the Windows port like the Linux one: fail on any mismatch/error or
+          # a new screenshot with no committed golden (missing_expected). Without
+          # this the comparison only posted a PR comment and stale goldens slipped
+          # through green CI (the picker case-conversion refresh was missed here).
+          export CN1SS_FAIL_ON_MISMATCH=1
+          export CN1SS_ALLOWED_MISSING=0
+          set +e
           cn1ss_process_and_report \
             "Native Windows port (x64)" \
             "$ART/compare.json" "$ART/summary.txt" "$ART/comment.md" \
             "$REF_DIR" "$ART/previews" "$ART" \
             "${entries[@]}"
+          gate_rc=$?
+          set -e
+          fail=0
+          if [ "$gate_rc" -ne 0 ]; then
+            echo "[windows-native-port x64] FATAL: screenshot gate failed (rc=$gate_rc)"; fail=1
+          fi
+          if [ -f "$ART/summary.txt" ] && grep -q "^missing_expected|" "$ART/summary.txt"; then
+            me="$(grep -c "^missing_expected|" "$ART/summary.txt" || echo 0)"
+            echo "[windows-native-port x64] FATAL: $me screenshot(s) streamed with no stored golden (missing_expected) -- add them to $REF_DIR."; fail=1
+          fi
+          if [ "$fail" -ne 0 ]; then echo "Windows x64 screenshot gate failed."; exit 1; fi
 
   windows-port-screenshot-comment-arm64:
     name: screenshot-comment (arm64)
@@ -594,8 +646,25 @@ jobs:
           source scripts/lib/cn1ss.sh
           cn1ss_setup "$JAVA_HOME/bin/java" "$(pwd)/scripts/common/java"
           REF_DIR="$(pwd)/scripts/windows/screenshots"
+          # Same gate as the x64 leg. The job itself is continue-on-error
+          # (experimental arm64 runner), so this reports red without blocking
+          # the PR -- but the mismatch is no longer silent.
+          export CN1SS_FAIL_ON_MISMATCH=1
+          export CN1SS_ALLOWED_MISSING=0
+          set +e
           cn1ss_process_and_report \
             "Native Windows port (arm64)" \
             "$ART/compare.json" "$ART/summary.txt" "$ART/comment.md" \
             "$REF_DIR" "$ART/previews" "$ART" \
             "${entries[@]}"
+          gate_rc=$?
+          set -e
+          fail=0
+          if [ "$gate_rc" -ne 0 ]; then
+            echo "[windows-native-port arm64] FATAL: screenshot gate failed (rc=$gate_rc)"; fail=1
+          fi
+          if [ -f "$ART/summary.txt" ] && grep -q "^missing_expected|" "$ART/summary.txt"; then
+            me="$(grep -c "^missing_expected|" "$ART/summary.txt" || echo 0)"
+            echo "[windows-native-port arm64] FATAL: $me screenshot(s) streamed with no stored golden (missing_expected) -- add them to $REF_DIR."; fail=1
+          fi
+          if [ "$fail" -ne 0 ]; then echo "Windows arm64 screenshot gate failed."; exit 1; fi

.github/workflows/purchase-e2e.yml

@@ -272,17 +272,37 @@ jobs:
           echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
           sudo udevadm control --reload-rules
           sudo udevadm trigger --name-match=kvm
+      # The emulator boot on GitHub-hosted runners intermittently dies before the
+      # device ever appears ("device 'emulator-5554' not found" -> the runner
+      # action's own boot timeout). One explicit retry recovers the infra lottery;
+      # a genuine test failure fails both attempts. emulator-boot-timeout is
+      # raised over the action's default for the slow-runner case where the boot
+      # is merely late rather than dead.
       - name: Run Android purchase instrumentation test (targeted)
+        id: purchase-emu-attempt1
+        continue-on-error: true
         uses: reactivecircus/android-emulator-runner@v2
         with:
           api-level: 36
           arch: x86_64
           target: google_apis
           disk-size: 2048M
+          emulator-boot-timeout: 900
           # android-emulator-runner runs each script line in its own shell, so
           # cd + gradlew must be a single `&&` line. Runs ONLY the purchase test
           # (it self-asserts by scraping logcat for CN1SS:IAP:SUBMITTED).
           script: cd "${{ steps.build-android-app.outputs.gradle_project_dir }}" && ./gradlew --no-daemon --stacktrace connectedDebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.codenameone.examples.purchasetest.PurchaseBillingInstrumentationTest
+      - name: Run Android purchase instrumentation test (retry after emulator-boot failure)
+        if: steps.purchase-emu-attempt1.outcome == 'failure'
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 36
+          arch: x86_64
+          target: google_apis
+          disk-size: 2048M
+          emulator-boot-timeout: 900
+          force-avd-creation: true
+          script: cd "${{ steps.build-android-app.outputs.gradle_project_dir }}" && ./gradlew --no-daemon --stacktrace connectedDebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.codenameone.examples.purchasetest.PurchaseBillingInstrumentationTest
       - name: Upload Android purchase test report
         if: always()
         uses: actions/upload-artifact@v7

.github/workflows/windows-cross-build-run.yml

@@ -312,8 +312,26 @@ jobs:
           source scripts/lib/cn1ss.sh
           cn1ss_setup "$JAVA_HOME/bin/java" "$(pwd)/scripts/common/java"
           REF_DIR="$(pwd)/scripts/windows/screenshots"
+          # Gate like the Linux port: fail on any mismatch/error or a new
+          # screenshot with no committed golden. Previously this job only
+          # posted the comparison as a PR comment, so stale goldens sailed
+          # through green CI.
+          export CN1SS_FAIL_ON_MISMATCH=1
+          export CN1SS_ALLOWED_MISSING=0
+          set +e
           cn1ss_process_and_report \
             "Native Windows port (cross-compiled)" \
             "$ART/compare.json" "$ART/summary.txt" "$ART/comment.md" \
             "$REF_DIR" "$ART/previews" "$ART" \
             "${entries[@]}"
+          gate_rc=$?
+          set -e
+          fail=0
+          if [ "$gate_rc" -ne 0 ]; then
+            echo "[windows-cross] FATAL: screenshot gate failed (rc=$gate_rc)"; fail=1
+          fi
+          if [ -f "$ART/summary.txt" ] && grep -q "^missing_expected|" "$ART/summary.txt"; then
+            me="$(grep -c "^missing_expected|" "$ART/summary.txt" || echo 0)"
+            echo "[windows-cross] FATAL: $me screenshot(s) streamed with no stored golden (missing_expected) -- add them to $REF_DIR."; fail=1
+          fi
+          if [ "$fail" -ne 0 ]; then echo "Windows cross screenshot gate failed."; exit 1; fi

CodenameOne/src/com/codename1/annotations/Fused.java

@@ -0,0 +1,36 @@
+package com.codename1.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Marks a class whose constructor-created primitive-array fields are fully
+/// ENCAPSULATED, letting ParparVM allocate each instance TOGETHER with those
+/// arrays as a single heap block ("fused object"): one allocation instead of
+/// several, one object for the garbage collector instead of several, and the
+/// arrays share the owner's cache lines. A fused array keeps a completely
+/// ordinary header -- all reading code, `System.arraycopy`, iteration and
+/// bounds checks work unchanged -- but it has no independent GC identity: it
+/// is never separately tracked, marked for reclamation, or swept; it simply
+/// lives and dies with its owner.
+///
+/// The translator fuses a constructor-assigned field when the constructor
+/// contains an unconditional `this.f = new T[n]` where `T` is a primitive type
+/// and `n` is a constructor parameter or constant (bounds-check guards that
+/// throw are fine before it). Constructors keep chaining normally, and every
+/// other instantiation path -- reflection, deserialization, oversized arrays
+/// that do not fit a fused block -- transparently falls back to ordinary
+/// separate allocations with identical semantics.
+///
+/// THE CONTRACT: the marked class must never let a fused array reference
+/// escape into another object's field, an array element, or a static that can
+/// outlive the instance. Holding it in locals, passing it as a call argument,
+/// or copying its contents out is always safe (the VM keeps the whole block
+/// alive through any reference into it held on a thread stack). Typical
+/// candidates: string/buffer classes owning their `char[]`, image types owning
+/// their pixel `int[]`/`byte[]` data.
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface Fused {
+}

Ports/LinuxPort/nativeSources/cn1_linux_crash_protection.c

@@ -203,6 +203,34 @@ static void cn1_cp_write_dec(int fd, long v) {
 }
 
 static void cn1_cp_signal_handler(int sig, siginfo_t *info, void *ctx) {
+    /* Always dump the faulting thread's backtrace to stderr (fd 2 -> the app-output tee),
+     * not just to the BuildCloud pending file. This is how a STACK-OVERFLOW crash becomes
+     * legible: with the per-thread alt signal stack this handler now runs even on overflow,
+     * and the repeating ADDR/off= lines below are the recursion. Addresses only (async-
+     * signal-safe writes; no -rdynamic, so no codegen perturbation). off= is the address
+     * minus the load base = the binary's static address (matches addr2line / gdb symbols). */
+#if CN1_CP_HAVE_BACKTRACE
+    {
+        void *bt[96];
+        int bn = backtrace(bt, 96);
+        CN1_CP_W_STR(2, "\n===CN1CRASH sig=");
+        cn1_cp_write_dec(2, (long)sig);
+        CN1_CP_W_STR(2, " frames=");
+        cn1_cp_write_dec(2, (long)bn);
+        CN1_CP_W_STR(2, " base=");
+        cn1_cp_write_hex(2, cn1_cp_load_base);
+        if (info != NULL) { CN1_CP_W_STR(2, " fault="); cn1_cp_write_hex(2, (uintptr_t)info->si_addr); }
+        CN1_CP_W_STR(2, "===\n");
+        for (int i = 0; i < bn; i++) {
+            CN1_CP_W_STR(2, "CN1BT off=");
+            cn1_cp_write_hex(2, (uintptr_t)bt[i] - cn1_cp_load_base);
+            CN1_CP_W_STR(2, " abs=");
+            cn1_cp_write_hex(2, (uintptr_t)bt[i]);
+            CN1_CP_W_STR(2, "\n");
+        }
+        CN1_CP_W_STR(2, "===CN1CRASH END===\n");
+    }
+#endif
     if (cn1_cp_pending_path_set) {
         int fd = open(cn1_cp_pending_path,
                       O_WRONLY | O_CREAT | O_TRUNC, 0600);
@@ -285,6 +313,19 @@ void cn1_crash_protection_install(void) {
     cn1_cp_resolve_pending_path();
     cn1_cp_log_install();
     cn1_cp_install_signal_handlers();
+    /* Alternate signal stack for THIS (main) thread, so the SA_ONSTACK handler runs even
+     * on a stack-overflow SIGSEGV when the main stack is exhausted. Per-thread; the CN1
+     * worker/EDT/GC threads register their own in threadRunner/gcMarkWorkerMain. Without
+     * it a stack overflow dies silently instead of dumping the recursion backtrace. */
+    {
+        stack_t ss;
+        ss.ss_sp = malloc(512 * 1024);
+        if (ss.ss_sp != NULL) {
+            ss.ss_size = 512 * 1024;
+            ss.ss_flags = 0;
+            sigaltstack(&ss, NULL);
+        }
+    }
 }
 
 /* ----------------------------------------------------------------------

Ports/LinuxPort/nativeSources/cn1_linux_socket.c

@@ -46,6 +46,10 @@
 extern JAVA_OBJECT newStringFromCString(CODENAME_ONE_THREAD_STATE, const char* str);
 extern const char* stringToUTF8(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT str);
 
+/* Sink that forces a socket buffer object to stay live across a parked blocking read
+ * so the conservative GC cannot sweep it mid-I/O (see socketRead). */
+static volatile void* cn1SocketReadKeepAlive;
+
 typedef struct {
     int fd;
     int lastError;
@@ -111,6 +115,11 @@ JAVA_INT com_codename1_impl_linux_LinuxNative_socketRead___long_byte_1ARRAY_int_
     CN1_YIELD_THREAD;
     n = read(s->fd, data + offset, (size_t) length);
     CN1_RESUME_THREAD;
+    /* Keep the buffer array object reachable across the parked read: only `data` (an
+     * interior pointer) is used, so the optimizer may drop `buffer` and the concurrent GC
+     * -- scanning this parked thread -- can sweep it mid-read (a use-after-free; see the
+     * Windows port where this manifested on the cn1ss WebSocket reader). Force liveness. */
+    cn1SocketReadKeepAlive = (volatile void*) buffer;
     if (n <= 0) {
         s->lastError = n < 0 ? errno : 0;
         if (n == 0) {