Lightning-Fast Method Calls with Ruby 4.1 ZJIT / RubyKaigi 2026

https://rubykaigi.org/2026

Transcript

1. Lightning-Fast Method Calls with Ruby 4.1 ZJIT @k0kubun / RubyKaigi 2026
2. @k0kubun
3. from “Ruby Committers and the World” session
4. Ruby JIT
5. ˒ Ruby 3.1+: ruby --yjit ˒ Production-ready JIT compiler ˒ Enabled by default on Rails 7.2+ YJIT
6. https://speed.ruby-lang.org/
7. https://railsatscale.com/2025-01-10-yjit-3-4-even-faster-and-more-memory-e ff i cient/
8. ˒ Ruby 4.0+: ruby --zjit ˒ Experimental JIT compiler ˒ To be productionized at Ruby 4.1 ˒ We call it “zee-jit”, not “zed-jit” ZJIT
9. ZJIT can make Ruby 10x faster https://rubybench.github.io/benchmarks/ruby-bench.html#getivar-module
10. ZJIT can make Ruby 15x faster https://rubybench.github.io/benchmarks/ruby-bench.html#getivar
11. ZJIT can make Ruby 40x faster https://rubybench.github.io/benchmarks/ruby-bench.html#structaset
12. But not as fast as YJIT on Rails (yet) https://rubybench.github.io/benchmarks/ruby-bench.html#railsbench
13. ˒ Some YJIT optimizations are not ported to ZJIT yet ˒ Method calls can be slower in ZJIT than in YJIT or the interpreter (for now) Why?
14. Why Ruby’s method calls are slow
21. Method call
22. Ruby VM stack Interpreter
23. Ruby VM stack Interpreter 
 Stack: six
24. 
 Stack: six Ruby VM stack Interpreter 3
25. 
 Stack: six Ruby VM stack Interpreter 3 <main> Memory writes: 1
26. 
 Stack: six Ruby VM stack Interpreter 3 <main> 2 Memory writes: 2
27. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 nil Memory writes: 3
28. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry Memory writes: 4 nil
29. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler Memory writes: 5 nil
30. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags Memory writes: 6 nil
31. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 7 nil
32. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 8 sp nil
33. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 9 sp iseq nil
34. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 10 sp iseq self nil
35. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 11 sp iseq self ep nil
36. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 12 sp iseq self ep block code nil
37. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 13 sp iseq self ep block code jit return nil
38. Ruby VM stack Interpreter 
 Stack: six 3 <main> Locals: add1 2 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc Memory writes: 14 sp iseq self ep block code jit return Ruby thread rb_execution_context_t vm_stack ... cfp nil
39. ˒ Method parameters are passed in memory ˒ A lot of memory writes for frame fi elds ˒ This is the bo tt leneck of method calls in Ruby Method calls on the interpreter
40. Method calls in YJIT
41. Ruby VM stack YJIT 
 Stack: six
42. 
 Stack: six Ruby VM stack YJIT CPU Reg1 Reg2 Reg3 3
43. 
 Stack: six Ruby VM stack YJIT CPU Reg1 Reg2 Reg3 3 <main> Register writes: 1
44. 
 Stack: six Ruby VM stack YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2
45. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 1
46. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 2 Locals: add1 nil
47. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 3 Locals: add1 nil Env: add1 method
 entry
48. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 4 Locals: add1 nil Env: add1 method
 entry block
 handler
49. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 5 Locals: add1 nil Env: add1 method
 entry block
 handler flags
50. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 6 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp
51. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 7 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq
52. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 8 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self
53. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 9 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self ep
54. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 10 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self ep block code
55. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 11 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self ep block code jit return
56. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 12 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self ep block code jit return Ruby thread rb_execution_context_t vm_stack ... cfp
57. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 12 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 sp iseq self ep block code jit return Ruby thread rb_execution_context_t vm_stack ... cfp = Memory writes: 14 - 1 Interpreter - PC
58. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 12 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc sp iseq self ep block code jit return Ruby thread rb_execution_context_t vm_stack ... cfp = + Register Allocation Register writes: 2 Memory writes: -2 Memory writes: 14 - 1 Interpreter - PC
59. Ruby VM stack 
 Stack: six 3 YJIT CPU Reg1 Reg2 Reg3 3 <main> 2 Register writes: 2 Memory writes: 12 Locals: add1 nil Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 pc sp iseq self ep block code jit return Ruby thread rb_execution_context_t vm_stack ... cfp = + Register Spill Memory writes: 1 + Register Allocation Register writes: 2 Memory writes: -2 Memory writes: 14 - 1 Interpreter - PC
60. ˒ Method parameters are passed in registers ˒ Most writes into frame fi elds (except PC) are not optimized ˒ This is still the bo tt leneck of method calls in Ruby Method calls in YJIT
61. Method calls in ZJIT (before Lightweight Frames)
62. Ruby VM stack ZJIT 
 Stack: six
63. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> ZJIT Arg1 Arg2
64. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> ZJIT 3 Arg2 Arg1
65. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 1 3 Arg2 Arg1
66. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 1 3 Arg2 Arg1 Locals: add1
67. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 2 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry
68. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 3 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler
69. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 4 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags
70. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 5 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq
71. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 6 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self
72. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 7 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep
73. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT Memory writes: 8 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep block code
74. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep block code <main> Register writes: 1 Memory writes: 8
75. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep block code <main> Register writes: 2 Memory writes: 8 2
76. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep block code <main> Register writes: 2 Memory writes: 9 2 C stack Stack: six 3
77. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 ZJIT 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler flags rb_control_frame_t: add1 iseq self ep block code <main> Register writes: 2 Memory writes: 10 2 C stack Stack: six 3 Ruby thread rb_execution_context_t vm_stack ... cfp
78. Interpreter vs YJIT vs ZJIT Interpreter YJIT ZJIT Memory writes 14 12 10 Register writes 0 2 2 Caller stack size: 1
79. Interpreter vs YJIT vs ZJIT Interpreter YJIT ZJIT Memory writes 14 15 16 Register writes 0 2 2 Caller stack size: 4
80. ˒ Method parameters are passed in C ABI registers ˒ Most writes into frame fi elds (except PC and jit_return) are not optimized ˒ ZJIT spills registers into both the VM stack and the C stack Method calls in ZJIT
81. Why are we writing method frames?
82. ˒ Backtraces need to reconstruct the full call chain at any point ˒ Even if most calls never raise, the metadata must always be there Backtraces
83. Backtraces
84. Backtraces This is based on the frame’s PC and iseq
85. ˒ The interpreter may suddenly take over JIT-compiled stack slots ˒ Frame layout must stay compatible with interpreter expectations Exception handling
86. Exception handling
87. Exception handling On raise, the interpreter takes over the stack: 3
88. ˒ Debuggers can access local variables outside the current frame ˒ Ruby must keep locals in a predictable location on the stack Local variables
89. Local variables
90. Local variables It overwrites the caller’s local variable
91. Lightweight Frames
92. https://github.com/Shopify/ruby/issues/909
93. ˒ Lightweight Frames reduce frame push to writing a single fi eld ˒ Everything still works: backtraces, exceptions, debugger access Writing only one fi eld on a method call
94. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> ZJIT: Lightweight Frames 3 Arg2 Arg1
95. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 ZJIT: Lightweight Frames
96. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 Env: add1 ZJIT: Lightweight Frames
97. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Memory writes: 1 Arg2 Arg1 Locals: add1 Env: add1 rb_control_frame_t: add1 ZJIT: Lightweight Frames jit return struct zjit_jit_frame method
 entry block
 handler iseq self ep block code JIT Frame pc sp flags
98. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 Env: add1 rb_control_frame_t: add1 ZJIT: Lightweight Frames jit return struct zjit_jit_frame method
 entry block
 handler iseq self ep block code JIT Frame pc sp flags Memory writes: 2 C stack Stack: six 3
99. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 Env: add1 rb_control_frame_t: add1 ZJIT: Lightweight Frames jit return struct zjit_jit_frame method
 entry block
 handler iseq self ep block code JIT Frame pc sp flags Register writes: 1 Memory writes: 2 C stack Stack: six 3 <main>
100. 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 Env: add1 rb_control_frame_t: add1 ZJIT: Lightweight Frames jit return struct zjit_jit_frame method
 entry block
 handler iseq self ep block code JIT Frame pc sp flags Register writes: 2 Memory writes: 2 C stack Stack: six 3 <main> 2
101. struct zjit_jit_frame 
 Stack: six Ruby VM stack CPU Reg1 Reg2 Reg3 <main> 3 Arg2 Arg1 Locals: add1 Env: add1 method
 entry block
 handler rb_control_frame_t: add1 iseq self ep block code <main> 2 C stack Stack: six 3 Ruby thread rb_execution_context_t vm_stack ... cfp Register writes: 2 Memory writes: 3 JIT Frame pc sp flags jit return ZJIT: Lightweight Frames
102. Interpreter vs YJIT vs ZJIT Interpreter YJIT ZJIT before ZJIT after Memory writes 14 12 10 3 Register writes 0 2 2 2
103. ˒ Materializing JIT frame is slow; we want to avoid writing them ˒ The register allocator needs to spill registers into locations that the interpreter can retrieve as needed ˒ For local variables, and longjmp for exceptions Challenges in Lightweight Frames
104. https://github.com/ruby/ruby/pull/16262
105. ˒ PC, ISEQ, and block_code are already optimized away ˒ They are mostly queried, not materialized in many cases ˒ Future work: ˒ SP, EP, self ˒ Env: method entry, block handler, fl ags ˒ Spills into the VM stack Lightweight Frames: Current State
109. 10% of JIT code is spent on method calls https://github.com/k0kubun/ruby/tree/zjit-perf-frames (before Lightweight Frames)
110. ˒ Method inlining can use Lightweight Frames to save contexts for pro fi lers and other features ˒ Lightweight Frames does not remove register spills into the C stack, but method inlining can Method inlining with Lightweight Frames
111. Conclusion ˒ Ruby’s method calls are slow because it needs to write many fi elds that are read out-of-frame ˒ ZJIT’s Lightweight Frames will make method calls faster by lazily writing metadata
112. In RubyKaigi 2024…
116. Let’s make Ruby faster together ˒ Anybody can understand and develop ZJIT by asking AI today ˒ Chat with us on Zulip: h tt ps://zjit.zulipchat.com/ ˒ See also: h tt ps://github.com/Shopify/ruby/issues