Hello! 

Aaron Patterson @tenderlove 

Speeding up Class#new A new approach 

No content

I LOVE Ruby!! It’s a Fact 

Can Ruby be faster than C? Answer: Yes. But how? 

Can Class#new be Ruby? Answer: Yes. But is it fast enough? 

Study Class#new implementation We can’t speed it up if we don’t know how it works! 

Inline Caches What they are, how they work. 

Calling Conventions What they are, and impact on method calls. 

Class#new implementation Implement a new new in Ruby and performance test it 

Why Class#new? 

It’s implemented in C 

It’s very popular 

Examples of using Class#new Creating new objects User.new(name: "Aaron") # haha business YourBusinessObject.new(1, 2) 

100 Objects? 

100,000 objects? 

500 trillion objects!!! 

Nobody complains if it’s faster (স) 

Class#new implementation 

Allocate an instance Pass parameters to initialize Returns the instance 

class Class def new(...) allocate.initialize(...) end end class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => ??? :hello Possible Implementation First, buggy implementation 

Possible Implementation Second, less buggy implementation class Class def new(...) obj = allocate obj.initialize(...) obj end end class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # 

Possible Implementation Things we need to know about class Class def new(...) obj = allocate obj.initialize(...) obj end end class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # method call method call 2 inline caches Calling conventions 

Actual Implementation Class#new implementation in C VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Allocation happens here 

VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Actual Implementation Class#new implementation in C 

VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Actual Implementation Class#new implementation in C 

VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Actual Implementation Class#new implementation in C 

VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Actual Implementation Class#new implementation in C C Ruby Ruby 

Different Calling Conventions Crossing language border requires translation C Ruby Ruby Translate to C calling convention Translate back to Ruby calling convention 

Crossing Language Barrier Can Cost Language barrier means “translation” C Ruby Ruby Ruby Ruby Ruby 

Crossing Language Barrier Can Cost Language barrier means “translation” C Ruby Ruby Ruby Ruby Ruby Time Time Savings 

Where is time spent? Arrows are impacted by calling convention C Ruby Ruby Ruby Ruby Ruby Time Savings 

Where is time spent? Methods are impacted by VM speed / method lookup (inline caches) C Ruby Ruby Ruby Ruby Ruby Time Savings 

Inline Caches Making method lookups faster 

Where is “baz”? Methods must be located, and we can cache the location class Foo def bar self.baz end def baz end end Where is the baz method? 

Where is “baz”? Method lookup routine def find_method(receiver, method_name) # Loop through ancestors until we find the method while !receiver.method_defined?(method_name) receiver = receiver.superclass end # Return the method receiver.method(method_name) end def call_method(receiver, method_name) # Call the method find_method(receiver, method_name).call end 

Method lookup can be linear We have to scan ancestors looking for the method class A; def baz; end end class B < A; end class C < B; end class D < C; end class E < D; end class F < E; end # .... class Foo < Z def bar self.baz end end 😭 

Cache the Method! 

Receiver type is our cache key Create a cache entry where the key is the class, and the value is the method class A; def baz; end end class B < A; end class C < B; end class D < C; end class E < D; end class F < E; end # .... class Foo < Z def bar self.baz end end Cache key is the class of self: Foo Cache value is the method entry 

Cache: Stored inline with bytecode That’s why it’s called “inline” cache == disasm: # 0000 putself ( 12)[LiCa] 0001 opt_send_without_block 0003 leave ( 13)[Re] 

Cache: Stored inline with bytecode That’s why it’s called “inline” cache == disasm: # 0000 putself ( 12)[LiCa] 0001 opt_send_without_block 0003 leave ( 13)[Re] 

Inline Cache Object Graph bar method points at cache, cache points at method entry class A; def baz; end end class B < A; end class C < B; end class D < C; end class E < D; end class F < E; end # .... class Foo < Z def bar self.baz end end bar method A#baz inline cache A#baz method Weak Reference Ruby Objects class A 

Measure In line Cache Allocations Objects can be allocated on the fi rst call, but not subsequent def baz; end def bar # First time this is called, an object gets allocated self.baz end def measure x = GC.stat(:total_allocated_objects) yield GC.stat(:total_allocated_objects) - x end measure { } # heat p measure { bar } # => 2 p measure { bar } # => 0 First call allocates 

Warmups are important 🏋 

Inline Cache: Only holds one object Inline caches are “monomorphic”, they only cache one item class A; def baz; end end class B < A; end class C < B; end class D < C; end class E < D; end class F < E; end # .... class Foo < Z def bar self.baz end end bar method A#baz inline cache A#baz method Weak Reference class A 

Inline Cache: Only holds one object Inline caches are “monomorphic”, they only cache one item class A def bar; end end class B def bar; end end def run_it(obj); obj.bar; end run_it(A.new) run_it(B.new) run_it method A#bar inline cache A#bar method B#bar inline cache B#bar method 

Cache hit / miss examples Cache size is one, so we only hit when repeating types def run_it(obj); obj.bar; end run_it(A.new) # cache miss run_it(A.new) # cache hit run_it(A.new) # cache hit run_it(A.new) # cache hit run_it(B.new) # cache miss run_it(B.new) # cache hit run_it(B.new) # cache hit run_it(B.new) # cache hit run_it(A.new) # cache miss run_it(B.new) # cache miss run_it(A.new) # cache miss run_it(B.new) # cache miss run_it(A.new) # cache miss run_it(B.new) # cache miss 

Cache hit / miss comparison Compare always hitting to never hitting class A; def bar; end; end class B; def bar; end; end def run_it(obj); obj.bar; end a = A.new b = B.new Benchmark.ips { |x| x.report("always hit") { run_it(a); run_it(a); run_it(a); run_it(a) run_it(a); run_it(a); run_it(a); run_it(a) run_it(a); run_it(a); run_it(a); run_it(a) run_it(a); run_it(a); run_it(a); run_it(a) } x.report("never hit") { run_it(a); run_it(b); run_it(a); run_it(b) run_it(a); run_it(b); run_it(a); run_it(b) run_it(a); run_it(b); run_it(a); run_it(b) run_it(a); run_it(b); run_it(a); run_it(b) } x.compare! } always call with a alternate between a and b 

Benchmark Results Never hitting is about 40% slower $ ruby test.rb ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [arm64-darwin24] Warming up -------------------------------------- always hit 319.277k i/100ms never hit 224.288k i/100ms Calculating ------------------------------------- always hit 3.189M (± 2.4%) i/s (313.58 ns/i) - 15.964M in 5.008714s never hit 2.280M (± 1.8%) i/s (438.55 ns/i) - 11.439M in 5.018054s Comparison: always hit: 3188993.5 i/s never hit: 2280264.0 i/s - 1.40x slower $ ruby test.rb ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [arm64-darwin24] Warming up -------------------------------------- always hit 319.277k i/100ms never hit 224.288k i/100ms Calculating ------------------------------------- always hit 3.189M (± 2.4%) i/s (313.58 ns/i) - 15.964M in 5.008714s never hit 2.280M (± 1.8%) i/s (438.55 ns/i) - 11.439M in 5.018054s Comparison: always hit: 3188993.5 i/s never hit: 2280264.0 i/s - 1.40x slower 

Inline caches are important for performance 

Class#new is written in C! 

VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass) { VALUE obj; obj = rb_class_alloc(klass); rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS); return obj; } class Foo def initialize(a, b) :hello end end Foo.new(1, 2) # => # Initialize is called from C Class#new implementation in C 

rb_obj_call_init_kw Calls your initialize method void rb_obj_call_init_kw(VALUE obj, int argc, const VALUE *argv, int kw_splat) { PASS_PASSED_BLOCK_HANDLER(); rb_funcallv_kw(obj, idInitialize, argc, argv, kw_splat); } Call a m ethod O n this object M ethod nam e Param eters 

rb_funcallv_kw Calls any method VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat) { VM_ASSERT(ruby_thread_has_gvl_p()); return rb_call(recv, mid, argc, argv, kw_splat ? CALL_FCALL_KW : CALL_FCALL); } VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat) { VM_ASSERT(ruby_thread_has_gvl_p()); return rb_call(recv, mid, argc, argv, kw_splat ? CALL_FCALL_KW : CALL_FCALL); } 

rb_call Just passes everything to rb_call0 static inline VALUE rb_call(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope) { rb_execution_context_t *ec = GET_EC(); return rb_call0(ec, recv, mid, argc, argv, scope, ec->cfp->self); } static inline VALUE rb_call(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope) { rb_execution_context_t *ec = GET_EC(); return rb_call0(ec, recv, mid, argc, argv, scope, ec->cfp->self); } Why is it named rb_call0????? 😂 

rb_call0 Is actually complicated, and I’ve omitted some of it static inline VALUE rb_call0(rb_execution_context_t *ec, VALUE recv, ID mid, int argc, const VALUE *argv, call_type call_scope, VALUE self) { /* Snip */ struct rb_callinfo ci; scope_to_ci(scope, mid, argc, &ci); const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, &ci); /* Snip */ return vm_call0_cc(ec, recv, mid, argc, argv, cc, kw_splat); } static inline VALUE rb_call0(rb_execution_context_t *ec, VALUE recv, ID mid, int argc, const VALUE *argv, call_type call_scope, VALUE self) { /* Snip */ struct rb_callinfo ci; scope_to_ci(scope, mid, argc, &ci); const struct rb_callcache *cc = gccct_method_search(ec, recv, mid, &ci); /* Snip */ return vm_call0_cc(ec, recv, mid, argc, argv, cc, kw_splat); } 

If Ruby methods store caches in byte code, where do C functions store them? 

gccct_method_search gccct: Global call cache cache table static inline const struct rb_callcache * gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci) { /* snip */ // search global method cache unsigned int index = (unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE); rb_vm_t *vm = rb_ec_vm_ptr(ec); const struct rb_callcache *cc = vm->global_cc_cache_table[index]; if (LIKELY(cc)) { if (LIKELY(vm_cc_class_check(cc, klass))) { const rb_callable_method_entry_t *cme = vm_cc_cme(cc); if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) && cme->called_id == mid)) { VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid))); return cc; } } } return gccct_method_search_slowpath(vm, klass, index, ci); } static inline const struct rb_callcache * gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci) { /* snip */ // search global method cache unsigned int index = (unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE); rb_vm_t *vm = rb_ec_vm_ptr(ec); const struct rb_callcache *cc = vm->global_cc_cache_table[index]; if (LIKELY(cc)) { if (LIKELY(vm_cc_class_check(cc, klass))) { const rb_callable_method_entry_t *cme = vm_cc_cme(cc); if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) && cme->called_id == mid)) { VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid))); return cc; } } } return gccct_method_search_slowpath(vm, klass, index, ci); } static inline const struct rb_callcache * gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci) { /* snip */ // search global method cache unsigned int index = (unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE); rb_vm_t *vm = rb_ec_vm_ptr(ec); const struct rb_callcache *cc = vm->global_cc_cache_table[index]; if (LIKELY(cc)) { if (LIKELY(vm_cc_class_check(cc, klass))) { const rb_callable_method_entry_t *cme = vm_cc_cme(cc); if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) && cme->called_id == mid)) { VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid))); return cc; } } } return gccct_method_search_slowpath(vm, klass, index, ci); } static inline const struct rb_callcache * gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci) { /* snip */ // search global method cache unsigned int index = (unsigned int)(gccct_hash(klass, mid) % VM_GLOBAL_CC_CACHE_TABLE_SIZE); rb_vm_t *vm = rb_ec_vm_ptr(ec); const struct rb_callcache *cc = vm->global_cc_cache_table[index]; if (LIKELY(cc)) { if (LIKELY(vm_cc_class_check(cc, klass))) { const rb_callable_method_entry_t *cme = vm_cc_cme(cc); if (LIKELY(!METHOD_ENTRY_INVALIDATED(cme) && cme->called_id == mid)) { VM_ASSERT(vm_cc_check_cme(cc, rb_callable_method_entry(klass, mid))); return cc; } } } return gccct_method_search_slowpath(vm, klass, index, ci); } Lookup cache in global table Is the cache entry good? Slow path 

C methods calling Ruby methods It has “method caches” Stored in a global table Cache entries limited by table size 

Calling Conventions What they are, and impact on method calls. 

A “convention” for connect methods Calling convention de fi nes where parameters and return values will be def bar(x, y, z) x + y + z end def foo bar(1, 2, 3) end Arguments are stored in a certain place Parameters are read from a certain place Return value is stored in a certain place Return value is read from a certain place 

Decouple caller and callee 

Languages can define their own calling conventions 

Ruby calling convention 

Ruby: Stack based VM 

def bar(a, b, c) a + b + c end def foo bar(5, 7, 9) end Ruby Code Calling Convention: Caller’s Side Stack values become method parameters def bar(a, b, c) a + b + c end def foo bar(5, 7, 9) end Ruby Code Push 5 Instructions Stack 5 Push 7 Push 9 7 9 Call bar 

def bar(a, b, c) a + b + c end def foo bar(5, 7, 9) end Ruby Code Calling Convention: Callee’s side Stack values become method parameters Instructions Stack 5 Getlocal -3 Getlocal -2 Add Getlocal -1 Add 7 9 5 12 21 Return 7 9 

Calling Convention: Keyword Arguments Stack values become method parameters def bar(a:, b:, c:) a + b + c end def foo bar(a: 5, b: 7, c: 9) end Ruby Code Instructions Stack 5 Getlocal -3 Getlocal -2 Add Getlocal -1 Add 7 9 5 12 21 Return 

Calling Convention: Keyword Arguments Stack values become method parameters def bar(a:, b:, c:) a + b + c end def foo bar(c: 9, a: 5, b: 7) end Ruby Code Instructions Stack 9 Push 9 Push 5 Push 7 Call bar 5 7 

Keyword Args can be slower (Please DO NOT change your code) 

C: No concept of KW args, splats, defaults, etc 

Friction Between Languages 

Conversion takes time 

Keyword Arguments Normally don’t require allocations def bar(a:, b:, c:) a + b + c end def foo bar(c: 9, a: 5, b: 7) end count_allocs { foo } # heat p count_allocs { foo } # => 0 Ruby Ruby 

Keyword Arguments + Initialize We expect one allocation, Foo, but there are two allocations class Foo def initialize(a:, b:, c:) end end def foo Foo.new(c: 9, a: 5, b: 7) end count_allocs { foo } # heat p count_allocs { foo } # => 2 Ruby C Ruby 

Hash is allocated across language barrier We have to convert kwargs to a hash, then back to stack positions 5 7 9 { a: 5, b: 7, c: 9 } 5 7 9 

Class#new implementation Implement a new new in Ruby and performance test it 

Class#new First implementation class Class def new(...) instance = allocate instance.initialize(...) instance end end Initialize is private! 

Trying to call Initialize won’t work Because it’s a private method 😭 class Foo def initialize end private def bar; end end Foo.allocate.initialize $ ruby thing.rb thing.rb:10:in '': private method 'initialize' called for an instance of Foo (NoMethodError) Foo.allocate.initialize ^^^^^^^^^^^ 

Class#new, second attempt Also doesn’t work class Class def new(...) instance = allocate instance.send(:initialize, ...) instance end end No “send” on BasicObject 

BasicObject is very Basic It doesn’t support send! obj = BasicObject.new obj.send :initialize $ ruby thing.rb thing.rb:2:in '': undefined method 'send' for an instance of BasicObject (NoMethodError) obj.send :initialize ^^^^^ 

We need to call a private method without using send. 

We cheat! 

Special flags on send instruction FCALL means “ignore method visibility” class Foo def initialize bar end private def bar; end end Ruby Code == disasm: # 0000 putself ( 3)[LiCa] 0001 send , nil 0004 leave ( 4)[Re] VM Instructions == disasm: # 0000 putself ( 3)[LiCa] 0001 send , nil 0004 leave ( 4)[Re] VM Instructions 

Class#new First implementation class Class def new(...) instance = allocate instance.initialize(...) instance end end 

Class#new Instructions We need an FCALL fl ag == disasm: # local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 2] "..."@0 [ 1] instance@1 0000 putself ( 3)[LiCa] 0001 send , nil 0004 setlocal instance@1, 0 0007 getlocal instance@1, 0 ( 4)[Li] 0010 getlocal "..."@0, 0 0013 sendforward , nil 0016 pop 0017 getlocal instance@1, 0 ( 5)[Li] 0020 leave ( 6)[Re] == disasm: # local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 2] "..."@0 [ 1] instance@1 0000 putself ( 3)[LiCa] 0001 send , nil 0004 setlocal instance@1, 0 0007 getlocal instance@1, 0 ( 4)[Li] 0010 getlocal "..."@0, 0 0013 sendforward , nil 0016 pop 0017 getlocal instance@1, 0 ( 5)[Li] 0020 leave ( 6)[Re] Add FCALL here 

New Primitive 

Class#new take three With a primitive class Class def new(...) obj = allocate Primitive.send_delegate!( obj, :initialize, ...) obj end end 

== disasm: #:2 (2,2)-(8,5)> local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 2] "..."@0 [ 1] obj@1 0000 putself ( 3)[LiCa] 0001 opt_send_without_block 0003 setlocal_WC_0 obj@1 0005 getlocal_WC_0 obj@1 ( 5)[Li] 0007 getlocal_WC_0 "..."@0 ( 4) 0009 sendforward , nil 0012 pop 0013 getlocal_WC_0 obj@1 ( 7)[Li] 0015 leave ( 8)[Re] Class#new take 3 Instructions == disasm: #:2 (2,2)-(8,5)> local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1, kw: -1@-1, kwrest: -1]) [ 2] "..."@0 [ 1] obj@1 0000 putself ( 3)[LiCa] 0001 opt_send_without_block 0003 setlocal_WC_0 obj@1 0005 getlocal_WC_0 obj@1 ( 5)[Li] 0007 getlocal_WC_0 "..."@0 ( 4) 0009 sendforward , nil 0012 pop 0013 getlocal_WC_0 obj@1 ( 7)[Li] 0015 leave ( 8)[Re] FCALL 

Initialize without send! 

Class#new take three Doesn’t pass tests class Class def new(...) obj = allocate Primitive.send_delegate!( obj, :initialize, ...) obj end end People monkey patch allocate 

Monkeypatch to allocate is ignored This code works fi ne class Class def allocate raise "hahahaha" end end class Foo end Foo.new # works fine 

New Primitive! 

Allocate an object without calling “allocate” Primitive is not impacted by monkey patches class Class def new(...) obj = Primitive.rb_class_alloc2 Primitive.send_delegate!( obj, :initialize, ...) obj end end class Class def new(...) obj = Primitive.rb_class_alloc2 Primitive.send_delegate!( obj, :initialize, ...) obj end end 

Class#new instruction sequence Allocating a new object: 8 instructions obj = Primitive.rb_class_alloc2 Primitive.send_delegate!( obj, :initialize, ...) obj Ruby Code allocate Instructions Stack setlocal getlocal getlocal send pop getlocal leave new instance ... 

Ruby without Ruby Inlining Class#new 

Ruby Code is YARV Our Ruby code is converted to YARV instructions class Class def new(...) obj = Primitive.rb_class_alloc2 Primitive.send_delegate!( obj, :initialize, ...) obj end end Ruby Code YARV Instructions allocate send pop leave dup Foo.new Ruby Code putobject Foo send 

YARV Instructions Paste “Class#new” code at the call site allocate send pop dup Foo.new Ruby Code putobject Foo 

Implement Class#new in Ruby without Ruby 

Compiler Modifications - PUSH_SEND_R(ret, location, method_id, INT2FIX(orig_argc), block_iseq, INT2FIX(flags), kw_arg); + LABEL *not_basic_new = NEW_LABEL(location.line); + LABEL *not_basic_new_finish = NEW_LABEL(location.line); + + bool inline_new = ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction && + method_id == rb_intern("new") && + call_node->block == NULL && + !(flags & VM_CALL_ARGS_BLOCKARG); + + if (inline_new) { + if (LAST_ELEMENT(ret) == opt_new_prelude) { + PUSH_INSN(ret, location, putnil); + PUSH_INSN(ret, location, swap); + } + else { + ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.line, location.node_id, BIN(swap), 0)->link); + ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.line, location.node_id, BIN(putnil), 0)->link); + } + + // Jump unless the receiver uses the "basic" implementation of "new" + VALUE ci; + if (flags & VM_CALL_FORWARDING) { + ci = (VALUE)new_callinfo(iseq, method_id, orig_argc + 1, flags, kw_arg, 0); + } + else { + ci = (VALUE)new_callinfo(iseq, method_id, orig_argc, flags, kw_arg, 0); + } + + PUSH_INSN2(ret, location, opt_new, ci, not_basic_new); + LABEL_REF(not_basic_new); + // optimized path + PUSH_SEND_R(ret, location, rb_intern("initialize"), INT2FIX(orig_argc), block_iseq, INT2FIX(flags | VM_CALL_FCALL), kw_arg); + PUSH_INSNL(ret, location, jump, not_basic_new_finish); + Is this a call to “new”? Insert special instructions If not new, jump to slow path 

“Object.new” Before and after inlining Instructions for “new” are inserted at the call site > ruby --dump=insns -e'Object.new' == disasm: #@-e:1 (1,0)-(1,10)> 0000 opt_getconstant_path ( 1)[Li] 0002 opt_send_without_block 0004 leave Before > ./ruby --dump=insns -e'Object.new' == disasm: #@-e:1 (1,0)-(1,10)> 0000 opt_getconstant_path ( 1)[Li] 0002 putnil 0003 swap 0004 opt_new , 11 0007 opt_send_without_block 0009 jump 14 0011 opt_send_without_block 0013 swap 0014 pop 0015 leave After 

How does it perform? 

Keyword Arguments Only one object allocated class Foo def initialize(a:, b:, c:) end end def foo Foo.new(c: 9, a: 5, b: 7) end count_allocs { foo } # heat p count_allocs { foo } # => 1 Only One Allocation!!! 

Allocations per second 

Increase the number of parameters Foo.new Foo.new(1) Foo.new(1, 2) Foo.new(1, 2, 3) 

Change the type of parameters Foo.new Foo.new(a: 1) Foo.new(a: 1, b: 2) Foo.new(a: 1, b: 2, c: 3) 

Vary the type of object Foo.new Bar.new Foo.new Bar.new Foo.new Bar.new Foo.new Bar.new 

Positional Parameters Allocations per Second by Ruby version Allocations Per Second 0 9500000 19000000 28500000 38000000 Number of Parameters 0 1 2 3 4 5 6 7 8 9 10 Ruby 3.5 + inlining Ruby 3.4 

~1.8x Faster 

Keyword Parameters Allocations per second by Ruby version Allocations Per Second 0 10000000 20000000 30000000 40000000 Number of Parameters 0 1 2 3 4 5 6 7 8 9 10 Ruby 3.5+inlining Ruby 3.4 

3 Keyword Params: 3.2x faster 

10 Keyword Params: 6.2x faster 

Positional Parameters + Varied Classes Allocations per second by Ruby version
 (varying allocated class) Allocations per Second 0 9500000 19000000 28500000 38000000 Number of Parameters 0 1 2 3 4 5 6 7 8 9 10 Ruby 3.5+Inlining Ruby 3.4 

Keyword Parameters + Varied Classes Allocations per second by Ruby version
 (varying allocated class) Allocations Per Second 0 10000000 20000000 30000000 40000000 Number of Parameters 0 1 2 3 4 5 6 7 8 9 10 Ruby 3.5+Inlining Ruby 3.4 

Speedup depends on parameters 

Minimum: 1.4x faster 

Downsides 

More memory 

Measure ISeq size How many bytes does the “alloc” method use? require "objspace" def alloc Object.new end m = method(:alloc) insn = RubyVM::InstructionSequence.of(insn) puts ObjectSpace.memsize_of(insn) Ruby 3.5 + inlining: 656 bytes Ruby 3.4: 544 bytes +122 Bytes 

Different Stack Trace 

Stack Trace is Different Class#new is missing class Foo def initialize puts caller end end def hello Foo.new end hello > ruby test.rb test.rb:8:in 'Class#new' test.rb:8:in 'Object#hello' test.rb:11:in '' Ruby 3.4 > ./ruby test.rb test.rb:8:in 'Object#hello' test.rb:11:in '' Ruby 3.5 + inlining 

Let’s wrap this up 

Class#new The C implementation 

Inline caches How they help speed up method calls 

Calling conventions What they are and their impact on our code 

Class#new + Inlining In Ruby, and its performance characteristics 

Excited about Ruby internals 

Excited about RUBY! 

THANK YOU!!!