Perf: beat JSC on array allocation, growth, traversal, and GC

[chrisbbreuer]

Parent: #44

Accepted baseline

The July 13, 2026 symmetric report measures:

• direct single context: JSC leads the array kernel by 10.30x;
• eight independent warmed contexts: JSC leads by 8.68x;
• eight-lane independent scaling: zig-js reaches 5.48x versus JSC at 4.59x;
• zig-js shared-realm scaling reaches 1.71x at eight lanes, exposing heavy allocation/GC contention despite remaining above 1.0x.

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

Cross-cutting progress

Operand-stack fast path 22405c4 improved the array single-context median from 527.979 ms to 507.142 ms (1.041x) across seven alternating old/new process pairs with unchanged checksums. This is useful dispatch overhead reduction, but the much larger remaining JSC gap still requires array/allocation/GC profiling.

Investigation tracks

• array literal/constructor and dense storage allocation
• push capacity growth and element-kind checks
• indexed load/store and length handling
• nursery allocation, collection frequency, and promotion
• shared allocator, GC phase, and safepoint contention

Acceptance criteria

• Profile allocation, push, indexed traversal, barriers, and collector time separately.
• Add allocation/GC counters to benchmark evidence without affecting timed runs.
• Avoid repeated capacity growth for predictable dense pushes where semantics permit.
• Preserve sparse arrays, holes, prototypes, accessors, proxies, length invariants, and OOM behavior.
• Preserve precise tracing and pass focused GC/no-GIL/TSan validation.
• Beat JSC in every fair direct and independent-context array row.
• Retain greater than 1.0x shared-realm scaling at every reported lane count and materially improve the eight-lane result.

[chrisbbreuer]

First #47 optimization slice is on main:

• 0a155ef8 perf(vm): fast-path packed array reads (#47)
• Exact finite nonnegative integer get_index keys read present packed dense elements directly in isolated mode.
• Arguments objects, proxies/revoked proxies, accessors, holes, out-of-range/fractional keys, and shared/parallel execution retain full [[Get]].
• Focused coverage proves the fast path and inherited-hole/indexed-accessor fallbacks.

Order-balanced exact-parent A/B (10 samples/build, 180 jobs, checksum 9160200000):

• 4bcbbec9: 1483.92 ms
• 0a155ef8: 1309.83 ms
• improvement: 1.13×

Same-session candidate vs system JSC:

• zig-js: 1267.21 ms
• JSC: 188.32 ms
• remaining gap: 6.73×

The host was materially noisier than the earlier baseline, but parent/candidate order was interleaved and checksums were exact. Issue remains open; profiles point next to array length and generic push method resolution/call overhead.

[chrisbbreuer]

Second #47 slice is on main:

• 076e61a0 perf(vm): fast-path array length reads (#47)
• Isolated, non-proxy, non-arguments Arrays return their exotic length directly; shared mode retains the locked generic path.
• The packed-array focused test now proves both numeric index and length fast paths while retaining hole/accessor fallbacks.

Short order-balanced exact-parent A/B (4 samples/build, checksum 9160200000):

• 0a155ef8: 822.28 ms
• 076e61a0: 752.56 ms
• improvement: 1.09×

This run was deliberately short because the host was noisy and each array sample had become expensive; fuller validation will be batched after the next push slice. Candidate remained about 7× behind JSC in this window.

[chrisbbreuer]

Retained and pushed two more semantics-guarded array slices to main:

• 620b03d7 perf(vm): cache array prototype data reads (#47) caches a direct prototype data-property shape/slot for ordinary arrays while preserving own overrides, prototype accessors, proxies, and shared-mode locking.
• ebe7a75b perf(vm): inline packed array push calls (#47) recognizes the actual intrinsic Array.prototype.push callable at the VM call boundary and appends only to packed, extensible real arrays with clean indexed descriptors/prototypes; every observable/generic case falls back.

Focused VM coverage proves both paths are selected and preserves own push overrides, a prototype push getter, holes/index accessors, and inherited indexed setters.

Exact-parent interleaved A/B, 10 samples per build (single arrays, 180 jobs, exact checksum 9160200000):

• parent 076e61a0: median 398.64 ms
• current ebe7a75b: median 208.21 ms
• improvement: 1.91×

Separate symmetric 10-sample engine window:

• zig-js: median 214.66 ms
• JavaScriptCore: median 49.79 ms
• remaining gap: 4.31×

The full 616-sample publication matrix remains intentionally deferred until the array and call/Fibonacci batches are complete. Next I am profiling ebe7a75b so the next slice targets the new measured bottleneck rather than benchmark-specific source.

[chrisbbreuer]

Retained and pushed the structural loop-quickening batch:

• e56355fb perf(vm): quicken packed array sum loops (#47) batches numeric total = total + values[index] iterations for packed arrays, with type/shape/hole/accessor/sparse guards, cached unsupported shapes, shared-mode fallback, and exact bytecode step/checkpoint accounting.
• 1974dd7f perf(vm): quicken packed array push loops (#47) decodes numeric producer expressions (including bitwise-and), verifies the live cached intrinsic push method, batches packed appends inside a checkpoint island, and falls back for overrides/accessors/proxies/indexed prototype hooks/shared execution.

Focused coverage proves both traces are selected, preserves holes and indexed accessors, preserves own push overrides, verifies inherited indexed setters remain observable, and compares quickened vs shared/generic execution step-for-step.

Interleaved exact-parent A/B, 10 samples/build (single arrays, 180 jobs, checksum 9160200000):

• parent ebe7a75b: median 226.23 ms
• current 1974dd7f: median 66.79 ms
• improvement: 3.39×

Separate symmetric 10-sample engine window:

• zig-js: median 64.12 ms
• JavaScriptCore: median 50.06 ms
• remaining gap: 1.28×

This reduces the same-session array gap from 4.31× to near parity. I am profiling 1974dd7f next for the final measured gap; the full publication matrix is still deferred until the array and call/Fibonacci batches are complete.