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

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_window.c

@@ -36,11 +36,15 @@
  * host -- see Ports/LinuxPort/status.md.
  */
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE   /* pthread_getattr_np + ucontext REG_* gregs; before any libc include */
+#endif
 #include "cn1_linux_gfx.h"
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>
 #include <signal.h>
+#include <ucontext.h>
 #ifdef __GLIBC__
 #include <execinfo.h> /* backtrace() -- glibc only; musl has no execinfo.h */
 #endif
@@ -428,15 +432,80 @@ static gboolean cn1OnDelete(GtkWidget* widget, GdkEvent* e, gpointer data) {
  * the fault first-chance). It is a release/CI resilience mechanism, not a debug
  * aid -- set CN1_LINUX_NO_FAULT_HANDLER=1 to disable it when debugging under gdb.
  */
+/* Dump the faulting thread's native backtrace to stderr (the app-output tee). Async-
+ * signal-safe (write + backtrace). With the per-thread alternate signal stack this runs
+ * even on a STACK OVERFLOW; the repeating frames are the recursion. Called from both the
+ * SIGABRT path and the wild-address SIGSEGV path (stack-overflow guard-page faults land
+ * there), so an overflow is finally legible instead of a bare, corrupt-unwind core. */
+/* async-signal-safe "KEY=0xHEX\n" */
+static void cn1LinuxWriteHexKV(const char* key, unsigned long v) {
+    char buf[64]; int i = 0;
+    while (key[i]) { buf[i] = key[i]; i++; }
+    buf[i++] = '='; buf[i++] = '0'; buf[i++] = 'x';
+    char hx[16]; int h = 0;
+    if (v == 0) hx[h++] = '0';
+    while (v) { int d = v & 0xf; hx[h++] = (char)(d < 10 ? '0' + d : 'a' + d - 10); v >>= 4; }
+    while (h > 0) buf[i++] = hx[--h];
+    buf[i++] = '\n';
+    write(2, buf, i);
+}
+
+static void cn1LinuxDumpNativeBacktrace(const char* label, siginfo_t* si, void* ucv) {
+    signal(SIGSEGV, SIG_DFL);
+    signal(SIGBUS, SIG_DFL);
+    write(2, "\n=====CN1 ", 10);
+    write(2, label, strlen(label));
+    write(2, " BACKTRACE=====\n", 16);
+    if (si != NULL) cn1LinuxWriteHexKV("faultAddr", (unsigned long)(uintptr_t)si->si_addr);
+    /* faulting PC + SP from the ucontext, and this thread's real stack bounds -- if the
+     * used span (top - sp) is a fraction of a MB, this is a SMALL-STACK thread overflow
+     * (e.g. CN1 rendering on a WebKit/Gallium/GLib worker thread), not deep recursion. */
+    if (ucv != NULL) {
+        ucontext_t* uc = (ucontext_t*)ucv;
+        unsigned long sp = 0, pc = 0;
+#if defined(__aarch64__)
+        sp = (unsigned long)uc->uc_mcontext.sp;
+        pc = (unsigned long)uc->uc_mcontext.pc;
+#elif defined(__x86_64__)
+        sp = (unsigned long)uc->uc_mcontext.gregs[REG_RSP];
+        pc = (unsigned long)uc->uc_mcontext.gregs[REG_RIP];
+#endif
+        if (pc) cn1LinuxWriteHexKV("faultPC", pc);
+        if (sp) cn1LinuxWriteHexKV("faultSP", sp);
+        pthread_attr_t at;
+        if (pthread_getattr_np(pthread_self(), &at) == 0) {
+            void* base = 0; size_t sz = 0;
+            if (pthread_attr_getstack(&at, &base, &sz) == 0) {
+                cn1LinuxWriteHexKV("stackLo", (unsigned long)(uintptr_t)base);
+                cn1LinuxWriteHexKV("stackSz", (unsigned long)sz);
+                if (sp) cn1LinuxWriteHexKV("stackUsed", (unsigned long)(((uintptr_t)base + sz) - sp));
+            }
+            pthread_attr_destroy(&at);
+        }
+    }
+#ifdef __GLIBC__
+    void* bt[96];
+    int n = backtrace(bt, 96);
+    backtrace_symbols_fd(bt, n, 2);
+#else
+    const char* na = "(native backtrace unavailable on this libc)\n";
+    write(2, na, strlen(na));
+#endif
+    const char* ftr = "=====END CN1 BACKTRACE=====\n";
+    write(2, ftr, strlen(ftr));
+}
+
 static void cn1LinuxFaultToException(int sig, siginfo_t* si, void* ucv) {
     (void) ucv;
     /* Only a genuine null-ish deref (null + a small field/vtable/array offset)
-     * is converted to an NPE. A wild faulting address is real memory corruption:
-     * restore the default disposition and return so the re-executed instruction
-     * faults again into a core dump that stays diagnosable, instead of being
-     * masked as a recoverable NPE that silently corrupts further state. */
+     * is converted to an NPE. A wild faulting address is real memory corruption OR a
+     * stack overflow (the guard-page address is high): dump a backtrace so the failing
+     * frame / recursion is identifiable from the CI log, then restore the default
+     * disposition and return so the re-executed instruction faults again into a core
+     * dump, instead of being masked as a recoverable NPE that silently corrupts state. */
     if ((sig == SIGSEGV || sig == SIGBUS) && si != NULL &&
             (uintptr_t) si->si_addr >= 0x10000) {
+        cn1LinuxDumpNativeBacktrace("FAULT", si, ucv);
         signal(sig, SIG_DFL);
         return;
     }
@@ -453,23 +522,7 @@ static void cn1LinuxFaultToException(int sig, siginfo_t* si, void* ucv) {
  * even where an interactive debugger is unavailable (CI containers). Enabled only
  * when CN1_LINUX_ABORT_BACKTRACE is set so it never interferes with normal runs. */
 static void cn1LinuxAbortBacktrace(int sig) {
-    /* Restore default SIGSEGV/SIGBUS so a fault while walking a corrupted stack
-     * just dies here instead of longjmp-ing out via the NPE handler. */
-    signal(SIGSEGV, SIG_DFL);
-    signal(SIGBUS, SIG_DFL);
-    const char* hdr = "\n=====CN1 ABORT BACKTRACE=====\n";
-    write(2, hdr, strlen(hdr));
-#ifdef __GLIBC__
-    void* bt[80];
-    int n = backtrace(bt, 80);
-    backtrace_symbols_fd(bt, n, 2);
-#else
-    /* musl has no execinfo.h/backtrace(); fall through with just the markers. */
-    const char* na = "(native backtrace unavailable on this libc)\n";
-    write(2, na, strlen(na));
-#endif
-    const char* ftr = "=====END CN1 ABORT BACKTRACE=====\n";
-    write(2, ftr, strlen(ftr));
+    cn1LinuxDumpNativeBacktrace("ABORT", NULL, NULL);
     signal(sig, SIG_DFL);
     raise(sig);
 }
@@ -480,10 +533,21 @@ static void cn1LinuxInstallFaultHandlers() {
         return;
     }
     installed = 1;
+    /* Alternate signal stack for THIS (main) thread so SA_ONSTACK works here too. The CN1
+     * worker/EDT/GC threads register their own in threadRunner/gcMarkWorkerMain. */
+    {
+        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); }
+    }
     struct sigaction sa;
     memset(&sa, 0, sizeof(sa));
     sa.sa_sigaction = cn1LinuxFaultToException;
-    sa.sa_flags = SA_SIGINFO | SA_NODEFER;
+    /* SA_ONSTACK: run the handler on the per-thread alternate signal stack (registered in
+     * threadRunner / gcMarkWorkerMain / crash-protection install) so it can execute even
+     * on a STACK OVERFLOW, when the faulting thread's own stack is exhausted -- otherwise
+     * the handler re-faults and the process dies silently with no backtrace. */
+    sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_ONSTACK;
     sigemptyset(&sa.sa_mask);
     sigaction(SIGSEGV, &sa, NULL);
     sigaction(SIGBUS, &sa, NULL);

Ports/WindowsPort/nativeSources/cn1_windows.h

@@ -217,6 +217,16 @@ typedef struct {
     JAVA_INT shotW;
     JAVA_INT shotH;
 
+    /* Offscreen-capture mode (the cn1ss WebSocket screenshot suite): a real
+     * (hidden) window is still created so the message pump, DPI and exact client
+     * size are identical to a normal run, but windowGraphics is pointed at an
+     * offscreen WIC bitmap of that same client size instead of the HWND target.
+     * That makes captureWindowToPngBytes read back real frames (the proven WIC
+     * path) instead of falling back to a fresh per-screenshot mutable-image
+     * repaint -- which is the expensive step that stalled the slow windows-11-arm
+     * runner mid-suite. Unlike `headless` there is no single-shot auto-exit. */
+    volatile LONG offscreenCapture;
+
     /* Pending window resize. WM_SIZE (main thread) records the new size here and
      * the EDT applies the Direct2D Resize between its own frames -- resizing the
      * HWND render target from another thread while the EDT is mid-BeginDraw is