Tracking: structural interpreter work to reach CRuby-interp parity (B1–B4)

[linyiru]

Part of #378. Each item gets its own issue, and B2 its own ADR, before implementation. The ordering will be re-ranked after the A items land and the per-request census is re-run.

• B1: kwargs without a Hash.
  • Today every kwargs call does op_new_hash, then hash-literal dedup, then SipHash, then intern, and only then unpacks. That costs 370 ns versus 19 ns on CRuby.
  • CRuby passes keywords positionally via the call-info kw_arg list and allocates only for **opts.
• B2: 8-byte Copy Value.
  • Value is a 16-byte enum holding Rc (Str, Class), so even an Int push/pop runs the clone/drop glue.
  • In the empty-loop profile, drop_glue, Value::clone and Vec::push account for about 25% and the Vm::run dispatch for about 20%. This is the root of the ~4× base step cost.
  • Candidates are NaN-boxing or a tagged pointer, with Str/Class moved behind heap ids. Needs an ADR; co-design with the C value representation.
• B3: call-site cache holding the resolved method plus a call handler.
  • Skip the do_call cascade on a hit, along the lines of CRuby's vm_call_handler.
  • Replace &*name == "..." string compares and runtime intern on hot paths with precomputed SymIds.
• B4: Proc-free yield and frame elision.
  • yield costs 224 ns versus 27 ns on CRuby.
  • ADR 0037 measured −21..34% per call for the frameless zero-arg tier; extend that approach.

Target: the Rails hello world bench within 1.5× of CRuby interp.

[linyiru]

Census after A (master 7f7152f, measured 2026-09-25, Mac Studio M2 Max)

Rails 8.1 hello world, Rack::MockRequest, steady state (3 runs, median req/s):

config	req/s	µs/request
CRuby 3.4.8 interp	3304–3511	~290
CRuby 3.4.8 +YJIT	4589–5721	~175
rubyrs interp	811–871	~1190
rubyrs +tier-2	756–808	~1270

The machine was loaded (load average 6–17), so treat absolute numbers as ±10%. rubyrs interp is ~4.1× CRuby interp (was ~5.2× before A).

Where a request goes (macOS sample, 15 s, 11439 samples)

bucket	share	note
step self	20%	base dispatch cost (B2)
do_call self + cascade helpers	~10%	B3
Value drop/clone + Vec::push	~7%	B2
uncached method lookup (lookup_method_uncached + lookup_class_singleton_method)	7.5%	~5% of the total is the walk_module visited FxHashSet insert/rehash. Callers: try_serve_collection_block_fast probes, lookup_method_cached misses, class intrinsics, responds_to
GC (gc_now / collect)	4.5%	allocation volume
regex compile (regex::Regex::new via engine_build_slow)	3.7%	caller_locations (preamble/thread.rb) builds Regexp.new(...) per frame per call; ActiveSupport::EventReporter calls it once per request. CRuby compiles no regex per request
Dir[] glob + stat	~5%	RoutesReloader's FileUpdateChecker; CRuby does the same glob per request (measured 37 µs there), so this is shared cost, not a gap

Shape rows vs CRuby × per-request counts

CRuby TracePoint per request: 1425 Ruby calls, 1670 C calls, 229 block calls, and 28 calls into methods that declare keywords.

item	shape gap	× count	≈ µs/request
B4 yield / blocks	440 ns (yield 461 vs 15)	229	~100
B3 calls	~50 ns (0-arg 61 vs 10)	~1425 (+C calls)	~70–150
B1 kwargs	~365 ns	28	~10
B2	broad (step/drop/clone ~27% of samples)	—	~250+

The yield row in the #378 table (224 ns) doesn't reproduce: every binary back to before A measures 415–465 ns. So B4 is bigger than the table suggested.

Re-ranked

1. Global method cache in front of lookup_method_uncached / lookup_class_singleton_method, keyed (class, name) and validated by method_gen (CRuby: the vm_method.c global method cache). Small and local, ~7%. Filed as the first B3 step.
2. caller_locations regex: hoist the pattern out of the per-frame loop, ~3%. A-style one-liner PR.
3. B4 Proc-free yield, ~8%.
4. B3 call handler / cascade skip.
5. B2 8-byte Value (ADR first). Largest, but touches everything.
6. B1 kwargs: only 28 keyword calls per request, ~1%. Last.