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

[chrisbbreuer]

Parent: #44
Related: #47, #48, #62, #97, #116, #118, #119, #120, #131

Goal

Make shared-realm parallel execution scale predictably without hiding contention behind comparisons to isolated JSC contexts. The fair matrix uses symmetric independent-context rows to separate engine-local throughput from shared-GC/runtime contention; shared-realm results remain a distinct zig-js capability panel with no invented public-JSC equivalent.

Completed baseline

The July 29, 2026 steady-shared matrix measures clean a7cf92c7 and is published by e4187c0f with 1,540 raw samples. Eight-lane shared scaling is:

• arithmetic 5.53x; properties 5.82x; polymorphic properties 5.38x;
• object churn 1.20x; arrays 5.54x;
• direct calls 4.55x; method calls 5.43x; closure calls 4.60x; arguments calls 5.84x;
• recursive Fibonacci 4.87x.

The shared geometric mean is 4.54x. The sole former blocker, #97, now has every lane above 1.0x with low-dispersion repeated evidence. Shared results remain correctly separate from JSC because its public API has no equivalent shared-object-graph mode.

• report
• raw 1,540 samples
• #97 causal A/B

Landed attribution and optimization

Dedicated thread/GC/mid-script-GC profiles report allocator, backing-slab, shape/binding/object/element locks, safepoint publication, collector attempts/aborts/sweeps, native wait attribution, task/waiter queues, and thread lifecycle/join behavior. General changes removed or amortized shared allocation and lock traffic with explicit ownership/tracing invariants, including lock-batched GC slabs, fixed-shape allocation, queue head cursors/capacity chunks, nursery collection, and the 128-byte ordinary-object layout.

Profiles and rejected exact-parent experiments now isolate #97 to remaining object allocation/backing/sweep serialization. In particular, merely enabling the abort-safe collector, polling nursery pressure at every checkpoint, widening the fixed-shape checkpoint batch, and a zig-gc owned-batch splice did not solve the eight-lane scaling contract. Continue through #97 with causal exact-parent evidence rather than broad speculative lock removal.

Acceptance criteria

• Add focused counters/profiles for GC phases, safepoint waits, allocator/backing contention, hot shared locks, native waits, thread startup, and join behavior.
• Profile arithmetic, properties, polymorphic properties, object churn, arrays, direct/method/closure/arguments calls, and recursion at 1/2/4/8 lanes.
• Attribute every remaining sub-1.0x scaling row to measured contention; Perf: remove shared-realm object-churn GC scaling collapse #97 owns object churn.
• Reduce global locks and shared allocator traffic only with explicit ownership and tracing invariants.
• Keep semantic no-GIL, lifecycle, mid-GC, broad-fuzz, full-unit, and suppression-free TSan coverage green.
• Keep shared-realm scaling at or above 1.0x at every reported lane count for every workload (Perf: remove shared-realm object-churn GC scaling collapse #97).
• Make no shared-realm-vs-JSC throughput claim without a semantically equivalent public JSC mode.

[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.