perf(jit): compile Thread.current / Thread#[] / Mutex intrinsics inline #389

Part of #385, following #381.

Can rubyrs beat CRuby on Thread.current / Thread.current[:k] / Mutex?

Not in the interpreter. In JIT-compiled code, yes.

Measured 2026-09-24 on a Mac Studio M2 Max, in ns/op with the empty-loop cost subtracted. The machine was loaded while these ran, so the ratios are more reliable than the absolute numbers.

• The perf: fast paths for Thread.current, Fiber.current, Mutex#synchronize #381 fast paths already sit on the interpreter's generic floor, which is one constant load plus one call plus a hash read. Only B-work (Tracking: structural interpreter work to reach CRuby-interp parity (B1–B4) #384) moves that floor.
• The native JIT compiles the empty loop to 1.4 ns, but every call inside the loop bails to the interpreter, so these shapes get slower under it.
• tier-2 runs these call sites through step() and gains nothing.
• YJIT does not help here either; these are C functions in CRuby.

The floor if the JIT emits the serve inline

A Rust probe drove the native work directly: one method_gen guard, no operand stack, and ivars read and written through pre-resolved slots.

Adding the 1.4 ns compiled loop, the JIT path would run about 2–4× faster than CRuby on these shapes.

Proposal

1. JIT admission. Teach the native/tier-2 JIT to recognize call sites that resolve to the captured intrinsics in Vm::thread_intr, following the same identity rule as try_thread_class_intrinsic and try_mutex_*.
   • Emit a method_gen guard plus inline code (or a thin helper) with no interpreter frame or operand stack.
   • Deopt to the interpreter on a guard failure, or on any case where the serve would decline: a non-Symbol key, contention, waiters present, a subclass or singleton receiver, or execution inside a fiber.
2. Slot-cached Mutex ivars (also an interpreter win). Cache the slots of @owner, @depth and @waiters in ThreadIntrinsics, verified with Class::ivar_shape_name_at as in ADR 0035. This drops lock_native + unlock_native from ~43 ns to ~14 ns. It is independent of (1) and can land first.
3. Hash lookup. Thread.current[:k] only beats CRuby by a real margin when the small-hash lookup is cheap; that is perf(hash): small-table linear lookup for Symbol/immediate keys #388.
4. Mutex#synchronize. This also needs the block inlined at the call site (perf: interpreter block invocation from native iterators #382 / B4). Today it costs the same as one bare yield.

Watch for one trap. Once a Mutex is promoted to the old generation, every ivar write pushes it onto heap.remembered, and there is no dedupe. The probe ran on a young Mutex, so a compiled lock/unlock would pay that cost too. It is worth deduping, for example with a per-object remembered bit.

An ADR is required first, per #385.