Perf: remove no-GIL scaling bottlenecks in the comparison workloads

[chrisbbreuer]

Parent: #44
Related: #47, #48

Goal

Make shared-realm parallel execution scale predictably without hiding contention behind comparisons to isolated JSC contexts. The fair matrix now uses independent-context rows to separate engine-local throughput from shared-GC/runtime contention.

Accepted baseline

At eight lanes the July 13, 2026 shared-realm scaling is:

• arithmetic: 4.91x
• properties: 4.78x
• arrays: 1.71x
• recursive Fibonacci: 0.79x

The independent zig-js steady-state geometric-mean scaling is 5.16x, while the shared-realm result is 2.37x. This isolates shared runtime/GC/call-path contention as a major target.

Evidence: harness c9f68e3; 616-sample report/README 2ebda1a.

Acceptance criteria

• Add per-run counters for mutator time, GC phases, safepoint waits, allocator contention, thread startup, and join time.
• Profile arithmetic, properties, arrays, and recursion at 1/2/4/8 lanes.
• Attribute every sub-1.0x or materially flattening scaling row to measured contention.
• Reduce global locks and shared allocator traffic only with explicit ownership and tracing invariants.
• Keep semantic no-GIL, lifecycle, mid-GC, broad-fuzz, and suppression-free TSan coverage green.
• Shared-realm scaling exceeds 1.0x at every reported lane count for every workload.
• Shared-realm throughput beats the independent JSC throughput row wherever the README makes that claim.

[chrisbbreuer]

Fairness follow-up from 58b1bc6b: the invocation-local observable Fibonacci workload passed the complete quick symmetric matrix, but shared-realm scaling is only 0.93x at 8 lanes (while arithmetic is 5.20x, properties 4.45x, and arrays 1.74x).\n\nKeeping #49 open for the observable recursive-call scaling bottleneck before regenerating the full publication report.

[chrisbbreuer]

Call-path update 9edcb646 deliberately restricts bounded native-stack call inlining to isolated execution. An initial shared attempt regressed the 8-lane observable Fibonacci row, so the final patch leaves shared mode on the synchronized heap driver. Paired parent/current 8-lane medians were effectively unchanged at ~3.34 s after that guard.

[chrisbbreuer]

Pushed synchronized observable recurrence support as baf5ed98.

The shared tier is limited to immutable named-function-expression self bindings. Mutable global recursion still falls back. Recurrence plans publish atomically, each observable property read/write retains synchronized object semantics, generic accessors and nonnumeric addition remain available, and exact VM checkpoints/steps are preserved. The focused test proves shared activation only for the immutable self binding; mutable replacement and accessor cases retain fallback behavior.

Publication-sized 100-job Fibonacci medians:

• zig-js shared 1 lane: ~205 ms
• zig-js shared 2 lanes: ~213 ms
• zig-js shared 4 lanes: ~200 ms
• zig-js shared 8 lanes: ~273 ms
• JSC independent steady 1 lane: ~377 ms
• JSC independent steady 8 lanes: ~573 ms

That is about 6.0x zig-js shared scaling at 8 lanes versus about 5.3x for JSC, and zig-js is roughly 2.1x faster in 8-lane wall time. The complete quick symmetric matrix passed every mode and checksum. #49 remains open for the still-weaker shared array scaling and full publication run.

[chrisbbreuer]

Shared-array progress: 80ff72fd reduces generic synchronized property/index overhead and improves the 8-lane shared arrays 80 median from ~1.01 s to ~0.400 s at identical work/checksum. One-lane improves similarly, so absolute throughput is fixed but scaling remains the next target; profile evidence points to the common Array-prototype lock on every push. Tracking the checkpoint-bounded packed-loop follow-up in #47.

[chrisbbreuer]

960bedc8 moves synchronized packed-array loops into race-safe, checkpoint-bounded batches. At full jobs=450, the shared 8-lane median is now ~205.8 ms versus ~206.7 ms for JSC independent steady 8 lanes, while zig-js independent steady is ~120.3 ms. Shared effective scaling is ~2.43x from its ~62.5 ms one-lane baseline, so absolute throughput now reaches the comparison target but scaling/allocator contention remains open in #47/#49.

[chrisbbreuer]

3c4e0e43 adds atomic, checkpoint-bounded synchronized property kernels. Shared properties jobs=80 now measure ~30.8 ms at one lane and ~44.6 ms at eight lanes (7-sample medians), an effective ~5.52x scaling factor and ~8.9x lower 8-lane wall time than the parent. Arithmetic/Fibonacci shared checks were neutral. Along with 960bedc8 for arrays, every shared workload now has a guarded batched path where the benchmark structure permits it.

[chrisbbreuer]

The accepted full report at ccee8842 measures shared 8-lane scaling of 6.32x arithmetic, 5.66x properties, 2.43x arrays, and 4.98x observable Fibonacci (4.56x geometric mean). Every workload is above 1.0x and the prior property/Fibonacci collapse is gone. Keeping #49 open for the remaining array scaling ceiling and broader no-GIL contention work.

[chrisbbreuer]

The new fair closure row (844efa1f, #60) exposes a distinct shared-realm allocation bottleneck: one lane takes 7.957 ms for 10,000 fresh capturing closures, while eight lanes take 243.642 ms for 8x work, only 0.26x effective scaling. Independent eight-lane contexts take 55.962 ms, so the collapse is specific to shared capture/function/frame allocation rather than CPU saturation alone.

The first fix will scalar-replace provably non-escaping closure identities (#48), which should remove avoidable shared allocation entirely. Any residual general escaping-closure allocator contention remains in this issue.