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,37 @@ 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
+          exit $rc
 
       - name: Upload screenshot artifact (${{ matrix.arch }})
         if: always()
@@ -268,6 +295,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/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

Ports/WindowsPort/nativeSources/cn1_windows_screenshot.cpp

@@ -260,7 +260,19 @@ JAVA_OBJECT com_codename1_impl_windows_WindowsNative_captureWindowToPngBytes___R
         CODENAME_ONE_THREAD_STATE) {
     CN1Graphics* g = cn1Win.windowGraphics;
     if (g == NULL || g->wicBitmap == NULL) {
-        cn1WindowsLog("captureWindowToPngBytes: window target is not WIC-backed");
+        /* Detailed reason so a capture miss is diagnosable from the log rather
+         * than a bare "not WIC-backed" (which read as an every-run condition in
+         * the old windowed WebSocket path). */
+        if (g == NULL) {
+            cn1WindowsLog("captureWindowToPngBytes: windowGraphics is NULL "
+                    "(initDisplay never created a target)");
+        } else {
+            cn1WindowsLog(cn1Win.offscreenCapture
+                    ? "captureWindowToPngBytes: offscreen capture requested but wicBitmap is NULL "
+                      "(offscreen target creation failed at initDisplay)"
+                    : "captureWindowToPngBytes: window target is not WIC-backed "
+                      "(HWND target -- caller falls back to mutable-image capture)");
+        }
         return JAVA_NULL;
     }
     cn1WinEndFrame(g);
@@ -284,6 +296,21 @@ JAVA_VOID com_codename1_impl_windows_WindowsNative_enableHeadlessScreenshot___ja
     cn1Win.headless = 1;
 }
 
+/*
+ * Enables offscreen-capture mode for the long-running cn1ss WebSocket screenshot
+ * suite (call before initDisplay). A hidden window is still created -- so the
+ * message pump, DPI and exact client size match a normal run -- but the EDT
+ * paints into an offscreen WIC bitmap of that client size, so
+ * captureWindowToPngBytes returns a real rendered frame every time instead of
+ * falling back to a per-screenshot mutable-image repaint. Unlike
+ * enableHeadlessScreenshot there is no shotPath and no single-shot auto-exit; the
+ * process stays alive for the whole suite.
+ */
+JAVA_VOID com_codename1_impl_windows_WindowsNative_enableOffscreenCapture__(
+        CODENAME_ONE_THREAD_STATE) {
+    cn1Win.offscreenCapture = 1;
+}
+
 } /* extern "C" */
 
 #endif /* _WIN32 */

Ports/WindowsPort/nativeSources/cn1_windows_window.cpp

@@ -753,16 +753,31 @@ JAVA_VOID com_codename1_impl_windows_WindowsNative_initDisplay___java_lang_Strin
         return;
     }
     cn1WindowsLog("initDisplay: render target created");
-    cn1Win.windowGraphics = cn1WinCreateGraphics((ID2D1RenderTarget*) g_hwndTarget);
+    if (cn1Win.offscreenCapture) {
+        /* Render into an offscreen WIC bitmap sized to the real client area, so
+         * captureWindowToPngBytes reads back the proven WIC frame instead of a
+         * per-screenshot mutable-image repaint. The HWND target stays created
+         * (the window is valid, just never shown or drawn to). */
+        cn1Win.windowGraphics = cn1WinCreateOffscreenGraphics(cn1Win.width, cn1Win.height);
+        cn1WindowsLog(cn1Win.windowGraphics != NULL
+                ? "initDisplay: offscreen capture target created"
+                : "initDisplay: offscreen capture target FAILED");
+    } else {
+        cn1Win.windowGraphics = cn1WinCreateGraphics((ID2D1RenderTarget*) g_hwndTarget);
+    }
 
     /* WIC factory for the image layer. The DirectWrite factory is created lazily
      * inside the C++ text layer (cn1_windows_dwrite.cpp), not here. */
     CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
             IID_IWICImagingFactory, (void**) &cn1Win.wicFactory);
 
-    ShowWindow(cn1Win.hwnd, SW_SHOW);
-    UpdateWindow(cn1Win.hwnd);
-    cn1WindowsLog("initDisplay: window shown");
+    if (!cn1Win.offscreenCapture) {
+        ShowWindow(cn1Win.hwnd, SW_SHOW);
+        UpdateWindow(cn1Win.hwnd);
+        cn1WindowsLog("initDisplay: window shown");
+    } else {
+        cn1WindowsLog("initDisplay: offscreen capture -- window kept hidden");
+    }
 }
 
 JAVA_INT com_codename1_impl_windows_WindowsNative_getDisplayWidth___R_int(CODENAME_ONE_THREAD_STATE) {

Ports/WindowsPort/src/com/codename1/impl/windows/WindowsNative.java

@@ -199,6 +199,18 @@ public static native void setTransform(long graphics, float m00, float m10, floa
      */
     public static native void enableHeadlessScreenshot(String path, int width, int height);
 
+    /**
+     * Enables offscreen-capture mode for the long-running cn1ss WebSocket
+     * screenshot suite (call before {@code initDisplay}). A hidden window is
+     * still created -- so the message pump, DPI and exact client size match a
+     * normal run -- but the EDT paints into an offscreen WIC bitmap of that
+     * client size, so {@link #captureWindowToPngBytes()} returns a real rendered
+     * frame every time instead of falling back to a per-screenshot mutable-image
+     * repaint (the expensive step that stalled the slow windows-11-arm runner
+     * mid-suite). Unlike {@link #enableHeadlessScreenshot} there is no auto-exit.
+     */
+    public static native void enableOffscreenCapture();
+
     /**
      * Encodes a {@code width*height} block of straight-alpha ARGB pixels (CN1
      * getRGB layout) to PNG and returns the bytes. Backs the port's ImageIO.

Ports/iOSPort/nativeSources/IOSNative.m

@@ -8534,6 +8534,9 @@ JAVA_OBJECT com_codename1_impl_ios_IOSNative_sqlCursorValueAtColumnString___long
     JAVA_OBJECT str = __NEW_INSTANCE_java_lang_String(threadStateData);
     struct obj__java_lang_String* ss = (struct obj__java_lang_String*)str;
     ss->java_lang_String_nsString = (JAVA_LONG)ns;
+    // String has no finalizer anymore: the peer is released by the VM reclaim
+    // path, which needs the page flagged (see cn1BibopNoteNativePeer).
+    cn1BibopNoteNativePeer(str);
 
     NSUInteger len = [ns length];
     JAVA_OBJECT destArr = __NEW_ARRAY_JAVA_CHAR(threadStateData, len);
@@ -12975,10 +12978,11 @@ JAVA_INT drawLabelText(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT __cn1ThisObject, J
                 if ((!isTickerRunning) && endsWith3Points) {
                     if(threePoints == JAVA_NULL) {
                         threePoints = newStringFromCString(threadStateData, "...");
-                        removeObjectFromHeapCollection(threadStateData, threePoints);
-                        removeObjectFromHeapCollection(threadStateData, ((struct obj__java_lang_String*)threePoints)->java_lang_String_value);
-                        ((struct obj__java_lang_String*)threePoints)->java_lang_String_value->__codenameOneReferenceCount = 999999;
-                        threePoints->__codenameOneReferenceCount = 999999;
+                        // permanent cache: the old removeObjectFromHeapCollection +
+                        // refcount=999999 pin is gone (the header field was relocated
+                        // off-object and BiBOP objects are page-swept); the immortal
+                        // root registry marks it and its value array every cycle
+                        cn1AddImmortalRoot(threePoints);
                         threePointsWidth = com_codename1_impl_ios_IOSImplementation_stringWidth___java_lang_Object_java_lang_String_R_int(threadStateData, __cn1ThisObject, nativeFont, threePoints);
                     }
 
@@ -12990,10 +12994,8 @@ JAVA_INT drawLabelText(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT __cn1ThisObject, J
             } else if (endsWith3Points) {
                 if(threePoints == JAVA_NULL) {
                     threePoints = newStringFromCString(threadStateData, "...");
-                    removeObjectFromHeapCollection(threadStateData, threePoints);
-                    removeObjectFromHeapCollection(threadStateData, ((struct obj__java_lang_String*)threePoints)->java_lang_String_value);
-                    ((struct obj__java_lang_String*)threePoints)->java_lang_String_value->__codenameOneReferenceCount = 999999;
-                    threePoints->__codenameOneReferenceCount = 999999;
+                    // permanent cache: see the RTL branch above
+                    cn1AddImmortalRoot(threePoints);
                     threePointsWidth = com_codename1_impl_ios_IOSImplementation_stringWidth___java_lang_Object_java_lang_String_R_int(threadStateData, __cn1ThisObject, nativeFont, threePoints);
                 }
                 JAVA_INT index = 1;

docs/developer-guide/languagetool-accept.txt

@@ -669,3 +669,4 @@ foldables?
 bitmask
 DeX
 Siri
+devirtualization