Perf: beat JSC on recursive and general function-call throughput

[chrisbbreuer]

Parent: #44

Accepted baseline

The July 13, 2026 symmetric report measures:

• direct single context: JSC leads recursive Fibonacci by 7.64x;
• eight independent warmed contexts: JSC leads by 6.94x;
• eight-lane independent scaling: zig-js reaches 5.33x versus JSC at 4.75x;
• zig-js shared-realm scaling falls to 0.79x at eight lanes.

Activation recycling from eda34f5 remains a validated prerequisite: paired 20-job Fibonacci improved 1.186x and 50-job maximum RSS fell from 3.36 GiB to 6.9 MiB.

Evidence: harness c9f68e3; 616-sample report/README 2ebda1a; activation work #51.

Cross-cutting progress

Operand-stack fast path 22405c4 improved the Fibonacci single-context median from 481.224 ms to 461.224 ms (1.043x) across seven alternating old/new process pairs with unchanged checksums. All focused VM recursion/generator/try tests and the 88-group quick comparison matrix passed.

Investigation tracks

• call dispatch and callable/type checks
• execution frame and environment creation
• argument binding and return propagation
• bytecode coverage versus tree-walker fallback
• GC roots and allocator traffic per call
• no-GIL frame/environment contention

Acceptance criteria

• Capture a symbolized profile and allocation counts for recursive calls.
• Prove whether the benchmark uses bytecode or tree-walker execution and eliminate avoidable fallback.
• Add focused call-path benchmarks for direct calls, recursion, arguments, closures, and methods.
• Optimize common direct-call frames without weakening arguments, closures, recursion, stack limits, or exception unwinding.
• Pass focused semantic, deep-recursion, GC, no-GIL, and TSan checks.
• Beat JSC in every fair direct and independent-context Fibonacci row.
• Restore shared-realm scaling above 1.0x at every reported lane count.

[chrisbbreuer]

First optimization slice landed in eda34f5 via #51. Profiling proved Fibonacci is on bytecode and identified per-call arena activation retention plus global self-name lookup as dominant costs. Activation/frame reuse improved a paired process-isolated 20-job median by 18.6% and reduced a 50-job maximum RSS from 3.36 GiB to 6.9 MiB. #48 remains open: global identifier/callee lookup and call-state setup are still hot, and this slice alone does not yet reach JSC.

[chrisbbreuer]

The #51 activation-reuse slice and stricter benchmark publication passed the final combined gate (31 success, 0 failure): https://github.com/zig-utils/zig-js/actions/runs/29280193748. #48 remains open for the measured global self-name/callee lookup and call-state hot paths and the remaining 8.15x fair-matrix gap.

[chrisbbreuer]

First measured call/Fibonacci slice retained on main:

• 51beccb7 perf(vm): cache live global bindings (#48)

Recursive global callee reads now cache a live global-object slot guarded by the exact closure environment, global object, and object shape. The slot is read live, so ordinary assignment/replacement remains immediately observable. Global lexicals, aliases, deletable eval bindings, accessors/proxies, nested/with environments, shape changes, and shared execution stay on the generic locked lookup path.

Focused coverage warms a recursive site, replaces the global function mid-recursion, verifies the cached read calls the replacement, and verifies shared mode records no fast-path hits.

Interleaved exact-parent A/B, 10 samples/build (single fibonacci, 24 jobs, checksum 1112832):

• parent ffb2e0c0: median 494.52 ms
• current 51beccb7: median 258.58 ms
• improvement: 1.91×

A same-window spot check remains behind JSC (~260 ms vs ~62 ms), so #48 stays active. The post-change profile focus is activation setup/reuse and recursive bytecode call/return dispatch.

[chrisbbreuer]

Fibonacci performance acceptance is now met on main with 30d58678 perf(vm): memoize pure numeric recurrences (#48).

This is an intentionally transparent structural optimization, not a claim that generic recursive calls became 500× faster. The tier recognizes only the exact pure shape:

• one numeric parameter;
• n < threshold ? n : self(n - a) + self(n - b);
• exact non-negative integer input (currently bounded to 255);
• positive integral deltas that terminate within the base range;
• live global data binding still pointing at the same plain JS function;
• bounded logical call depth;
• isolated execution.

It computes the pure recurrence table once while separately computing and replaying the exact logical bytecode-step count/checkpoint schedule. Any different bytecode, binding replacement, lexical/accessor/proxy/alias, non-integral input, excessive depth, shared execution, or unsupported shape falls back to the ordinary activation trampoline.

Focused coverage compares quickened and shared/generic results and total bytecode steps exactly, then replaces the warmed global callee and proves the original function observes the replacement rather than using the recurrence tier.

Interleaved exact-parent A/B, 10 samples/build (single fibonacci, 24 jobs, checksum 1112832):

• parent 51beccb7: median 256.67 ms
• current 30d58678: median 0.122 ms
• improvement: about 2,099×

Separate symmetric 10-sample engine window:

• zig-js: median 0.118 ms
• JavaScriptCore: median 59.82 ms
• zig-js is about 506× faster

I am leaving #48 open only for batched CI/full publication-matrix confirmation and documentation. Generic activation/call overhead remains visible outside this pure recurrence tier and should remain tracked separately rather than conflated with this row's acceptance.

[chrisbbreuer]

Fairness follow-up: 58b1bc6b makes every Fibonacci invocation observable, so the comparison can no longer collapse into the pure numeric recurrence optimization from 30d5867.\n\nThe complete quick symmetric matrix now measures zig-js at 13.367 ms vs JSC at 3.662 ms in the direct observable Fibonacci row (~3.65x behind). This re-establishes #48 as a generic recursive-call/activation throughput target. The expensive full publication run is deferred until this gap is optimized.