退役将军们都去了哪？11人在专委会任职刘源专委会将军

Transcript

1. Hello!

2. Aaron Patterson @tenderlove

3. Speeding up Class#new A new approach

4. None

5. I LOVE Ruby!! It’s a Fact

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

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

   enough?

8. Study Class#new implementation We can’t speed it up if we

   don’t know how it works!

9. Inline Caches What they are, how they work.

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

11. Class#new implementation Implement a new new in Ruby and performance

    test it

12. Why Class#new?

13. It’s implemented in C

14. It’s very popular

15. Examples of using Class#new Creating new objects User.new(name: "Aaron") #

    haha business YourBusinessObject.new(1, 2)

16. 100 Objects?

17. 100,000 objects?

18. 500 trillion objects!!!

19. Nobody complains if it’s faster (?)

20. Class#new implementation

21. Allocate an instance Pass parameters to initialize Returns the instance

22. 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

23. 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) # => #<Foo ...>

24. 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) # => #<Foo ...> method call method call 2 inline caches Calling conventions

25. 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) # => #<Foo ...> 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) # => #<Foo ...> Allocation happens here

26. 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) # => #<Foo ...> Actual Implementation Class#new implementation in C

27. 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) # => #<Foo ...> Actual Implementation Class#new implementation in C

28. 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) # => #<Foo ...> Actual Implementation Class#new implementation in C

29. 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) # => #<Foo ...> Actual Implementation Class#new implementation in C C Ruby Ruby

30. Different Calling Conventions Crossing language border requires translation C Ruby

    Ruby Translate to C calling convention Translate back to Ruby calling convention

31. Crossing Language Barrier Can Cost Language barrier means “translation” C

    Ruby Ruby Ruby Ruby Ruby

32. Crossing Language Barrier Can Cost Language barrier means “translation” C

    Ruby Ruby Ruby Ruby Ruby Time Time Savings

33. Where is time spent? Arrows are impacted by calling convention

    C Ruby Ruby Ruby Ruby Ruby Time Savings

34. Where is time spent? Methods are impacted by VM speed

    / method lookup (inline caches) C Ruby Ruby Ruby Ruby Ruby Time Savings

35. Inline Caches Making method lookups faster

36. 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?

37. 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

38. 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 ??

39. Cache the Method!

40. 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

41. Cache: Stored inline with bytecode That’s why it’s called “inline”

    cache == disasm: #<ISeq:[email protected]:11 (11,2)-(13,5)> 0000 putself ( 12)[LiCa] 0001 opt_send_without_block <calldata!mid:baz, argc:0, FCALL|ARGS_SIMPLE> 0003 leave ( 13)[Re]

42. Cache: Stored inline with bytecode That’s why it’s called “inline”

    cache == disasm: #<ISeq:[email protected]:11 (11,2)-(13,5)> 0000 putself ( 12)[LiCa] 0001 opt_send_without_block <calldata!mid:baz, argc:0, FCALL|ARGS_SIMPLE> 0003 leave ( 13)[Re]

43. 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

44. 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

45. Warmups are important ??

46. 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

47. 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

48. 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

49. 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

50. Benchmark Results Never hitting is about 40% slower $ ruby

    test.rb ruby 3.4.1 (2025-08-06 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 (2025-08-06 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

51. Inline caches are important for performance

52. Class#new is written in C!

53. 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) # => #<Foo ...> Initialize is called from C Class#new implementation in C

54. 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

55. 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); }

56. 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????? ??

57. 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); }

58. If Ruby methods store caches in byte code, where do

    C functions store them?

59. 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

60. C methods calling Ruby methods It has “method caches” Stored

    in a global table Cache entries limited by table size

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

62. 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

63. Decouple caller and callee

64. Languages can define their own calling conventions

65. Ruby calling convention

66. Ruby: Stack based VM

67. 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

68. 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

69. 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

70. 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

71. Keyword Args can be slower (Please DO NOT change your

    code)

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

73. Friction Between Languages

74. Conversion takes time

75. 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

76. 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

77. 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

78. Class#new implementation Implement a new new in Ruby and performance

    test it

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

    instance.initialize(...) instance end end Initialize is private!

80. 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 '<main>': private method 'initialize' called for an instance of Foo (NoMethodError) Foo.allocate.initialize ^^^^^^^^^^^

81. Class#new, second attempt Also doesn’t work class Class def new(...)

    instance = allocate instance.send(:initialize, ...) instance end end No “send” on BasicObject

82. BasicObject is very Basic It doesn’t support send! obj =

    BasicObject.new obj.send :initialize $ ruby thing.rb thing.rb:2:in '<main>': undefined method 'send' for an instance of BasicObject (NoMethodError) obj.send :initialize ^^^^^

83. We need to call a private method without using send.

84. We cheat!

85. Special flags on send instruction FCALL means “ignore method visibility”

    class Foo def initialize bar end private def bar; end end Ruby Code == disasm: #<ISeq:[email protected]:2 (2,2)-(4,5)> 0000 putself ( 3)[LiCa] 0001 send <calldata!mid:bar, argc:0, FCALL|VCALL|ARGS_SIMPLE>, nil 0004 leave ( 4)[Re] VM Instructions == disasm: #<ISeq:[email protected]:2 (2,2)-(4,5)> 0000 putself ( 3)[LiCa] 0001 send <calldata!mid:bar, argc:0, FCALL|VCALL|ARGS_SIMPLE>, nil 0004 leave ( 4)[Re] VM Instructions

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

    instance.initialize(...) instance end end

87. Class#new Instructions We need an FCALL fl ag == disasm:

    #<ISeq:[email protected]:2 (2,2)-(6,5)> 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 <calldata!mid:allocate, argc:0, FCALL|VCALL|ARGS_SIMPLE>, nil 0004 setlocal instance@1, 0 0007 getlocal instance@1, 0 ( 4)[Li] 0010 getlocal "..."@0, 0 0013 sendforward <calldata!mid:initialize, argc:0, FORWARDING>, nil 0016 pop 0017 getlocal instance@1, 0 ( 5)[Li] 0020 leave ( 6)[Re] == disasm: #<ISeq:[email protected]:2 (2,2)-(6,5)> 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 <calldata!mid:allocate, argc:0, FCALL|VCALL|ARGS_SIMPLE>, nil 0004 setlocal instance@1, 0 0007 getlocal instance@1, 0 ( 4)[Li] 0010 getlocal "..."@0, 0 0013 sendforward <calldata!mid:initialize, argc:0, FORWARDING>, nil 0016 pop 0017 getlocal instance@1, 0 ( 5)[Li] 0020 leave ( 6)[Re] Add FCALL here

88. New Primitive

89. Class#new take three With a primitive class Class def new(...)

    obj = allocate Primitive.send_delegate!( obj, :initialize, ...) obj end end

90. == disasm: #<ISeq:new@<internal:class>: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 <calldata!mid:allocate, argc:0, FCALL|VCALL|ARGS_SIMPLE> 0003 setlocal_WC_0 obj@1 0005 getlocal_WC_0 obj@1 ( 5)[Li] 0007 getlocal_WC_0 "..."@0 ( 4) 0009 sendforward <calldata!mid:initialize, argc:0, FCALL|FORWARDING>, nil 0012 pop 0013 getlocal_WC_0 obj@1 ( 7)[Li] 0015 leave ( 8)[Re] Class#new take 3 Instructions == disasm: #<ISeq:new@<internal:class>: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 <calldata!mid:allocate, argc:0, FCALL|VCALL|ARGS_SIMPLE> 0003 setlocal_WC_0 obj@1 0005 getlocal_WC_0 obj@1 ( 5)[Li] 0007 getlocal_WC_0 "..."@0 ( 4) 0009 sendforward <calldata!mid:initialize, argc:0, FCALL|FORWARDING>, nil 0012 pop 0013 getlocal_WC_0 obj@1 ( 7)[Li] 0015 leave ( 8)[Re] FCALL

91. Initialize without send!

92. 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

93. 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

94. New Primitive!

95. 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

96. 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 ...

97. Ruby without Ruby Inlining Class#new

98. 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

99. YARV Instructions Paste “Class#new” code at the call site allocate

    send pop dup Foo.new Ruby Code putobject Foo

100. Implement Class#new in Ruby without Ruby

101. 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

102. “Object.new” Before and after inlining Instructions for “new” are inserted

     at the call site > ruby --dump=insns -e'Object.new' == disasm: #<ISeq:<main>@-e:1 (1,0)-(1,10)> 0000 opt_getconstant_path <ic:0 Object> ( 1)[Li] 0002 opt_send_without_block <calldata!mid:new, argc:0, ARGS_SIMPLE> 0004 leave Before > ./ruby --dump=insns -e'Object.new' == disasm: #<ISeq:<main>@-e:1 (1,0)-(1,10)> 0000 opt_getconstant_path <ic:0 Object> ( 1)[Li] 0002 putnil 0003 swap 0004 opt_new <calldata!mid:new, argc:0, ARGS_SIMPLE>, 11 0007 opt_send_without_block <calldata!mid:initialize, argc:0, FCALL|ARGS_SIMPLE> 0009 jump 14 0011 opt_send_without_block <calldata!mid:new, argc:0, ARGS_SIMPLE> 0013 swap 0014 pop 0015 leave After

103. How does it perform?

104. 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!!!

105. Allocations per second

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

     2, 3)

107. 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)

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

     Bar.new Foo.new Bar.new

109. 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

110. ~1.8x Faster

111. 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

112. 3 Keyword Params: 3.2x faster

113. 10 Keyword Params: 6.2x faster

114. 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

115. 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

116. Speedup depends on parameters

117. Minimum: 1.4x faster

118. Downsides

119. More memory

120. 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

121. Different Stack Trace

122. 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 '<main>' Ruby 3.4 > ./ruby test.rb test.rb:8:in 'Object#hello' test.rb:11:in '<main>' Ruby 3.5 + inlining

123. Let’s wrap this up

124. Class#new The C implementation

125. Inline caches How they help speed up method calls

126. Calling conventions What they are and their impact on our

     code

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

128. Excited about Ruby internals

129. Excited about RUBY!

130. THANK YOU!!!