z, ?	toggle help (this)
space, →	next slide
shift-space, ←	previous slide
d	toggle debug mode
## <ret>	go to slide #
r	reload slides
n	toggle notes

loading presentation...

Hello everyone! In this presentation, I will be discussing changes we made in Ruby 3.3 and 3.4 to reduce implicit allocations during method calling.

Reducing

Implicit Allocations

During

Method Calling

RubyKaigi 2024

My name is Jeremy Evans. I am a Ruby committer who focuses on fixing bugs in Ruby.

GitHub: jeremyevans

Twitter: @jeremyevans0

I am also the author of Polished Ruby Programming, which was published in English a few years ago, and was published in Japanese last year. This book is aimed at intermediate Ruby programmers and focuses on teaching principles of Ruby programming, as well as trade-offs to consider when making implementation decisions.

If we want to reduce implicit allocations,

Reducing

Implicit Allocations

the first step is to measure the implicit allocations. If you do not know how many objects a method call implicitly allocates, you cannot determine whether it is possible to reduce the number of allocations.

Measuring

Implicit Allocations

Here is a method that displays how many arrays and hashes are allocated inside a block. Unfortunately, I do not have enough time to explain how it works.

COUNTS = {}
def objects_allocated
  ObjectSpace.count_objects(COUNTS)
  arrays = COUNTS[:T_ARRAY]
  hashes = COUNTS[:T_HASH]
  yield
  ObjectSpace.count_objects(COUNTS)
  arrays -= COUNTS[:T_ARRAY]
  hashes -= COUNTS[:T_HASH]
  puts "Allocates: #{-arrays} arrays, #{-hashes} hashes"
end

GC.start
GC.disable
objects_allocated do
  # nothing
end
# Allocates: 0 arrays, 0 hashes

The important part is you can call the objects_allocated method with a block.

COUNTS = {}
def objects_allocated
  ObjectSpace.count_objects(COUNTS)
  arrays = COUNTS[:T_ARRAY]
  hashes = COUNTS[:T_HASH]
  yield
  ObjectSpace.count_objects(COUNTS)
  arrays -= COUNTS[:T_ARRAY]
  hashes -= COUNTS[:T_HASH]
  puts "Allocates: #{-arrays} arrays, #{-hashes} hashes"
end

GC.start
GC.disable
objects_allocated do
  # nothing
end
# Allocates: 0 arrays, 0 hashes

method

And it will print the number of arrays and hashes allocated by the block. Using the objects_allocated method, we can examine how many objects are allocated for certain types of method calls.

COUNTS = {}
def objects_allocated
  ObjectSpace.count_objects(COUNTS)
  arrays = COUNTS[:T_ARRAY]
  hashes = COUNTS[:T_HASH]
  yield
  ObjectSpace.count_objects(COUNTS)
  arrays -= COUNTS[:T_ARRAY]
  hashes -= COUNTS[:T_HASH]
  puts "Allocates: #{-arrays} arrays, #{-hashes} hashes"
end

GC.start
GC.disable
objects_allocated do
  # nothing
end
# Allocates: 0 arrays, 0 hashes

The first allocation reduction optimization we will examine I am calling Keyword Splat Separation. This technique was implemented by Sasada-san early in the Ruby 3.3 development cycle.

Keyword

Splat

Separation

Consider this code example.

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end

We are going to call an empty method that takes no arguments.

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end

We are going to create an empty array and hash,

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end

and then splat the array and keyword splat the hash when calling the method. Any guesses as to how many objects this method call allocates?

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end

It turns out that Ruby 3.2 allocates 4 arrays and 1 hash for this call. Considering that delegating arguments to other methods is commonly done via splats and keyword splats, this unnecessary object allocation can result in a significant slowdown.

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end
# Ruby 3.2: Allocates: 4 arrays, 1 hashes

Ruby 3.3 fixes this, avoiding any allocation for this type of call.

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end
# Ruby 3.2: Allocates: 4 arrays, 1 hashes
# Ruby 3.3: Allocates: 0 arrays, 0 hashes

We can examine why this type of call allocates so many objects in Ruby 3.2.

def a

end

ary = []
kw = {}

objects_allocated do
  a(*ary, **kw)
end
# Ruby 3.2: Allocates: 4 arrays, 1 hashes
# Ruby 3.3: Allocates: 0 arrays, 0 hashes

We can run ruby with the –dump instructions option, which will dump the virtual machine instructions used,

$ ruby32 --dump=insns -e '
ary = []
kw = {}
a(*ary, **kw)
'

and pass the code to evaluate with the -e option.

$ ruby32 --dump=insns -e '
ary = []
kw = {}
a(*ary, **kw)
'

Here are the dumped instructions.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

The method call starts with putself and ends with the second opt_send_without_block instruction. Let us go through these instructions to see where the allocations are.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

The first array allocation during the method call is for splatarray true, which will duplicate the ary local variable.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

This newhash instruction allocates a new hash

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

and this instruction copies the contents of the kw local variable into the newly allocated hash.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

This newarray instruction wraps that newly allocated hash in a newly allocated array.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

This concatarray instruction allocates a new array when concating the array containing the keyword splat to the array produced by splatarray true, even though splatarray true has already allocated a new array for this purpose. However, something does not add up here.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

These instructions should only result in 3 array allocations and 1 hash allocation. Where does the 4th array allocation take place?

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

The final array allocation is on the callee-side of the method, which duplicates the array of arguments, because it is going to remove the empty keyword splat from the array.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              true
putspecialobject        1
newhash                 0
getlocal_WC_0           kw@1
opt_send_without_block  core#hash_merge_kwd, 2, ARGS_SIMPLE
newarray                1
concatarray
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

Ruby 3.2 treats code with both a positional splat and a keyword splat


a(*ary, **kw)

as a splat of a single array containing the positional splat and keyword splat hash, and was not efficient about allocation when doing that.


a(*[*ary, **kw])

As I mentioned, Sasada-san fixed this in Ruby 3.3. So if you generate the instructions in Ruby 3.3:

$ ruby33 --dump=insns -e '
ary = []
kw = {}
a(*ary, **kw)
'

You get much simpler instructions.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              false
getlocal_WC_0           kw@1
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

Because the keyword splat is not combined into the positional splat array, the callee-side does not need to modify the positional splat array, so it avoids the callee-side array allocation.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              false
getlocal_WC_0           kw@1
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

My first change to reduce implicit allocations was making this particular change. After Sasada-san’s changes, this instruction still used splatarray true, which allocates an array. I determined that it was unnecessary to allocate a new array now that Ruby is no longer appending the keyword splat to it, so I changed it to use splatarray false, making the call allocationless.|As I was working on that fix, I saw that it affected other cases, and I decided to do something about this issue. First, I decided on a goal I think Ruby should have regarding implicit object allocations.

newarray                0
setlocal_WC_0           ary@0
newhash                 0
setlocal_WC_0           kw@1
putself
getlocal_WC_0           ary@0
splatarray              false
getlocal_WC_0           kw@1
opt_send_without_block  a, 1, ARGS_SPLAT|FCALL|KW_SPLAT
leave

That goal is to have no unnecessary object allocations. I think Ruby should only allocate an object if it is necessary to do so. This goal has two corollaries.

No

Unnecessary

Allocations

The first corollary is Ruby should allocate at most 1 array implicitly during method calling. There are cases where Ruby needs to allocate an array, such as for a positional splat parameter, but there should be no reason to allocate multiple arrays implicitly.

At Most

1 Array

Allocation

Similarly, the second corollary is Ruby should allocate at most 1 hash implicitly during method calling. A keyword splat parameter may require a hash allocation, but there should be no reason to allocate multiple hashes implicitly.

At Most

1 Hash

Allocation

My first steps towards reducing allocations were to fix additional cases where Ruby was using splatarray true, when splatarray false would work, since an array allocation was not necessary.

Unnecessary

`splatarray true`

Allocations

Here is an example where Ruby 3.2 did not need to allocate any objects during a method call.

def a(b=nil)

end

ary = []


objects_allocated do
  a(*ary)
end

We have a method that accepts an optional positional argument

def a(b=nil)

end

ary = []


objects_allocated do
  a(*ary)
end

We call that method with a positional splat.

def a(b=nil)

end

ary = []


objects_allocated do
  a(*ary)
end

Even if Ruby 3.2, this does not allocate any objects.

def a(b=nil)

end

ary = []


objects_allocated do
  a(*ary)
end
# Ruby 3.2: Allocates: 0 arrays, 0 hashes

However, if you change the call to pass both a positional argument and a positional argument splat.

def a(b=nil)

end

ary = []


objects_allocated do
  a(1, *ary)
end
# Ruby 3.2: Allocates: 0 arrays, 0 hashes

Then Ruby 3.2 will allocate an array. The cause is the same as in the earlier example, where Ruby 3.2 uses splatarray true instead of splatarray false. So I assumed the fix would be similar.

def a(b=nil)

end

ary = []


objects_allocated do
  a(1, *ary)
end
# Ruby 3.2: Allocates: 1 arrays, 0 hashes

When I first started work on these splatarray optimizations, I tried to make the changes directly in the compiler. That ended up being challenging.

Updating

the

Compiler

The compiler is the third step in converting your Ruby source code to virtual machine instructions.

Compiler

The first step is the lexer, which takes your source code and separates it into a stream of tokens.

Lexer

The second step is the parser, which takes that token stream, and builds an abstract syntax tree.

Parser

The compiler takes the abstract syntax tree, and creates virtual machine instructions.

Compiler

There is a fourth step, the optimizer, which takes the virtual machine instructions generated by the compiler, and potentially modifies the instructions to use more optimized instructions that have the same effect.

Optimizer

If you want to optimize code depending on the abstract syntax tree, then it is best to make that change in the compiler.

Compiler

However, if you want to optimize code for all cases where specific combinations of instructions are used, regardless of the abstract syntax tree that generated the instructions, those changes are best made in the optimizer.

Optimizer

For this method call,

def a(b=nil)

end

ary = []


objects_allocated do
  a(1, *ary)
end

these are the virtual machine instructions.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

To remove the unnecessary array allocation, we need to change this splatarray true to splatarray false. However, you cannot change splatarray true to splatarray false in all cases. There are cases where splatarray true is necessary for correct behavior.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

For the optimization to work correctly, you need to look at what instructions follow the splatarray instruction. If the splatarray instruction is followed directly by a send instruction, and that send instruction supports an argument splat but does not use keywords or a block, then it is safe to change splatarray true to splatarray false.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

To implement the change of splatarray true to splatarray false, I added the following code to the optimizer. I will walk through each part of the code.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

The way the optimizer works is that it goes through every generated instruction. The optimization we added does not need to consider these instructions, so during the optimization pass, these would be ignored by the new optimization.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

This is the instruction we want to change, splatarray with an argument of true.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

So in the optimizer we check whether the current instruction is a splatarray instruction


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

and if so, whether it has an argument of true. These are potential candidates for switching the argument to false, assuming that doing so is safe.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

In this optimization, we only want to change the splatarray instruction argument if it is directly followed by a send instruction.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

So the optimizer checks if the next instruction is a send instruction.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

There is a disconnect here, since the instruction shown in the output is opt_send_without_block, and the instruction the optimizer looks for is send. The reason for this disconnect is that the instructions shown are the instructions after optimization, not the instructions before optimization.


putself
putobject_INT2FIX_1_
getlocal_WC_0           ary@0
splatarray              true
opt_send_without_block  a, argc:2, ARGS_SPLAT|FCALL

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

So when working in the optimizer, it is often useful to get Ruby to output the instructions before optimization, which you can access via the insns_without_opt argument for the dump option. Note that this dump option is changing in Ruby 3.4.

$ ruby32 --dump=insns_without_opt -e '
ary = []
a(1, *ary)
'

In Ruby 3.4, you’ll need to use this value for the dump option.

$ ruby34 --dump=insns,-opt -e '
ary = []
a(1, *ary)
'

Here are the instructions for the method call before optimization.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

The change from send to opt_send_without_block happens in a later optimization pass, so at the point this optimization is run, the instruction is still send, so it will match.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

This code extracts the callinfo flags from the send instruction.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

These are the callinfo flags, which contain information about the method call.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

ARGS_SPLAT means the method call contains a positional splat.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

FCALL means the method call does not have an explicit receiver, or the explicit receiver is self. send instructions with the FCALL flag are allowed to call private methods.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

We are looking for instructions that have the ARGS_SPLAT callinfo flag, so the optimizer code checks for that flag.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

Additionally, this optimization is only safe if the method call does not pass keywords or a block, so we need to check that those flags are not present.


putself
putobject     1
getlocal      ary@0, 0
splatarray    true
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

Finally, to eliminate the array allocation, we update the splatarray instruction argument to false. This makes the call allocationless.


putself
putobject     1
getlocal      ary@0, 0
splatarray    false
send          a, argc:2, ARGS_SPLAT|FCALL, nil

if (IS_INSN_ID(iobj, splatarray) && OPERAND_AT(iobj, 0) == Qtrue) {
  if (IS_NEXT_INSN_ID(niobj, send)) {
    niobj = niobj->next;
    unsigned int flag = vm_ci_flag((const struct rb_callinfo *)OPERAND_AT(niobj, 0));
    if ((flag & VM_CALL_ARGS_SPLAT) && !(flag & (VM_CALL_KW_SPLAT|VM_CALL_ARGS_BLOCKARG))) {
      OPERAND_AT(iobj, 0) = Qfalse;
    }
  }
}

All of that code was added to avoid the unnecessary array allocation in this case, where you had one or more positional arguments, followed by a positional splat, with no keywords and no block.


a(1, *ary)

If a block is passed, that case needs to be optimized separately.


a(1, *ary)
a(1, *ary, &block)

The instructions generated in that case look like this.


a(1, *ary)
a(1, *ary, &block)


putself
putobject     1
getlocal      a@0, 0
splatarray    true
getlocal      block@0, 0
send          a, argc:2, ARGS_SPLAT|ARGS_BLOCKARG|FCALL, nil

Between the splatarray and send instructions, there is an instruction to get the local variable for the block.


a(1, *ary)
a(1, *ary, &block)


putself
putobject     1
getlocal      a@0, 0
splatarray    true
getlocal      block@0, 0
send          a, argc:2, ARGS_SPLAT|ARGS_BLOCKARG|FCALL, nil

And when checking the send instruction callinfo flags, you need to check for the presence of ARGS_BLOCKARG, instead of the absence of the flag.


a(1, *ary)
a(1, *ary, &block)


putself
putobject     1
getlocal      a@0, 0
splatarray    true
getlocal      block@0, 0
send          a, argc:2, ARGS_SPLAT|ARGS_BLOCKARG|FCALL, nil

Note that this optimization only affects cases where block is a local variable or an instance variable. It is not used if block is a method call. The reason for that is that if block is a method call,


a(1, *ary)
a(1, *ary, &block)

calling the method could result in a modification of the ary object, and modifications after the object has been splatted should not have an effect on the splat.


a(1, *ary)
a(1, *ary, &block)

In addition to these two cases, there were other cases optimized. For lack of time, I will just go over the cases without discussing the instruction changes for each.


a(1, *ary)
a(1, *ary, &block)

The next case is when a positional splat is followed by a keyword splat. I mentioned this case earlier when discussing Keyword Splat Separation. I originally developed the optimization for this case as a compiler change, but switched it to an optimizer change after adding the optimizer changes for the other cases.


a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)

The next case is when a positional splat, keyword splat, and block are all used.


a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)

The next case is when a positional splat and literal keywords are used. This is similar to the keyword splat case, as CRuby passes a implicit keyword splat for literal keywords if they follow a positional splat. The only difference here is that CRuby uses a different instruction to generate the keyword splat hash.


a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)

The final splatarray optimization was when a positional splat, literal keywords, and a block are all used.


a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

Unfortunately, it turns out that optimizing these cases of a literal keyword after a positional splat caused a bug.


a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

If the method being called accepts an positional splat parameter, but does not accept keywords.


def a(*ary)
end

a(*ary, kw: 1)

The hash for the keyword splat


def a(*ary)
end

a(*ary, kw: 1)

would be appened to the argument being splatted, instead of a copy of the argument. This issue was hidden before, because Ruby would always duplicate the positional splat argument on the caller-side. I fixed this case by duplicating the positional splat argument on the callee-side.


def a(*ary)
end

a(*ary, kw: 1)

I mentioned earlier that optimizing this case, with a positional splat and block, could result in issues


a(1, *ary, &block)

in the case where block is a method call, as calling block may modify the positional splat argument. This type of issue is called an evaluation order issue.


a(1, *ary, &block)

During this optimization work, I found that this type of call, with a keyword splat and a block, also had an evaluation order issue, because if the keyword splat argument was not a hash and the block was not a proc, block.to_proc would be called before kw.to_hash.


a(**kw, &block)

Ruby 3.2 would generate the following instructions for this method call.


a(**kw, &block)


putself
getlocal_WC_0  kw@0
getlocal_WC_0  block@1
send           a, argc:1, ARGS_BLOCKARG|FCALL|KW_SPLAT, nil

Both block.to_proc and kw.to_hash would be called inside the send instruction, but block.to_proc would be called first.


a(**kw, &block)


putself
getlocal_WC_0  kw@0
getlocal_WC_0  block@1
send           a, argc:1, ARGS_BLOCKARG|FCALL|KW_SPLAT, nil

I fixed this case by adding a new instruction named splatkw, which is issued directly before send instructions that have both keyword splats and block arguments. If the keyword splat object is not a hash, this instruction calls to_hash on it, ensuring to_hash is called before send calls block.to_proc.|Unfortunately, the introduction of this instruction broke some of the optimizations I made previously, and I did not fix those cases until after the release of Ruby 3.3.


a(**kw, &block)


putself
getlocal_WC_0  kw@0
getlocal_WC_0  block@1
splatkw
send           a, argc:1, ARGS_BLOCKARG|FCALL|KW_SPLAT, nil

While analyzing additional cases to fix, I found that super calls with explicit arguments also had this evaluation order issue, so I fixed those as well.


a(**kw, &block)
super(**kw, &block)

I also found that you could pass both a keyword splat and block using operator assignment syntax. However, this would result in a TypeError exception being raised.


obj[**kw, &block] += 1

This was true even if not passing a block.


obj[**kw, &block] += 1
obj[**kw] += 1

And if you passed literal keywords when using operator assignment syntax, it would segfault the compiler.


obj[**kw, &block] += 1
obj[**kw] += 1
obj[kw: 1] += 1

I fixed all of these cases, so they all work in Ruby 3.3. However, support for both blocks and keywords in the operator assignment syntax has already been removed from the master branch, so these will all result in a SyntaxError in Ruby 3.4.


obj[**kw, &block] += 1
obj[**kw] += 1
obj[kw: 1] += 1

Another bug I found when I first starting working on the splatarray optimizations was introduced by Keyword Splat Separation, and affected this code.

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

Here we have a plain object.

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

We define a to_hash method on the object that returns a hash

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

If you call a method with a positional splat, and a keyword splat of the object implementing to_hash,

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

and the method accepts both a positional splat and keyword splat parameter,

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

Ruby would call the to_hash method on the keyword splat argument to check that it returned a hash,

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

but the value of the keyword splat parameter

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw
end

f(*[], **o)

would be the keyword splat argument, not the hash produced by to_hash. Once I found this, it was easy to fix by using the result of to_hash as the keyword splat parameter, instead of ignoring the result of the to_hash method.

o = Object.new

def o.to_hash
  {a: 1}
end

def f(*a, **kw)
  kw # => o !!!
end

f(*[], **o)

The final bug I discovered during this optimization work was introduced by my keyword argument separation changes in Ruby 3.0.

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)


f(**kw)

We have a method that returns the object it has been passed.

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)


f(**kw)

If we call the method with both an empty positional splat and a keyword splat,

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)


f(**kw)

the return value of the method is a copy of the keyword splat argument, as expected.

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)
# => kw.dup

f(**kw)

However, if you call the method with a keyword splat and no positional splat.

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)
# => kw.dup

f(**kw)

it would pass the keyword splat argument directly instead of making a copy of it, as if you had passed the keyword splat as a positional argument. Even though this behavior made no sense and completely goes against keyword argument separation, it turns out there were specs added for it, making users who reviewed the specs think this was intended. Thankfully, fixing this was approved, and easily done by duplicating the keyword splat hash on the callee-side.

def f(obj)
  obj
end

ary = []
kw = {a: 1}

f(*ary, **kw)
# => kw.dup

f(**kw)
# => kw

Up to now, all of the optimizations and bug fixes I have discussed are available in Ruby 3.3.

Ruby 3.3

The rest of the presentation will discuss some of the implicit allocation reduction optimizations I worked on that will be in Ruby 3.4.

Ruby 3.4

I will start with this example.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end

This passes multiple positional splats when calling a method.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end

The method itself has a positional splat parameter.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end

In Ruby 3.3, this allocates 3 arrays.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end
# Ruby 3.3: Allocates: 3 arrays, 0 hashes

Here are the instructions generated for the method call.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

The first thing to be aware of is that Ruby’s internal method calling API does not support multiple splats, it only supports a single splat.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

Ruby implicitly combines the multiple splats into an single array, and calls the method with a splatted version of the generated array.

def a(*ary)

end

a(*[*ary, *ary])


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

The first array allocation during the method call is for splatarray true, which will duplicate the ary local variable for the first positional splat. You cannot eliminate this allocation, because Ruby does need to provide a single array to splat when calling the method, and it cannot modify either of the splatted arrays.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

The second positional splat uses the splatarray false instruction, so it does not allocate an array.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

Ruby combines the two positional splats into a single array, and the instruction it uses for this is concatarray.|If the first positional splat is already an array, concatarray will make a copy of that array before the concatenation. So this is the second array allocation. This allocation is unnecessary, since Ruby already allocated a new array in the splatarray true instruction.

def a(*ary)

end

a(*[*ary, *ary])


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

The final array allocation is in the opt_send_without_block instruction, and this is because the method accepts a positional splat parameter. Positional splat parameters should never be the same object as the positional splat argument, so Ruby duplicates the positional splat argument when setting the positional splat parameter value.|Ruby’s method call interface did not support the ability for the caller to tell the callee that it already allocated a new array for the positional splat argument. I first worked on removing this unnecessary allocation.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

To eliminate the allocation, I added an ARGS_SPLAT_MUT callinfo flag. This callinfo flag is used for method calls where a new array for the splat is allocated caller-side before the method call, and indicates to the callee that they can use the passed positional splat argument directly instead of duplicating it.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

So the ARGS_SPLAT_MUT optimization makes this call only allocate 2 arrays. However, that is still more than the goal of at most 1 array allocation.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

I mentioned that you cannot eliminate the array allocation for splatarray true, because Ruby does need to allocate an array on the caller side.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

So to achieve our goal, we need to eliminate the array allocation for concatarray. Unfortunately, Ruby did not have another virtual machine instruction that can be used to combine arrays. There were two possible ways to fix this.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

One way is to have the concatarray instruction require an argument, which it could use to determine whether it needs to duplicate the array being concatenated to.|The main issue with this approach is that it is invasive, since all calling code needs to be adjusted. When all code you need to modify was only in the virtual machine, this was not as challenging, but now that YJIT optimizes pretty much all instructions, this would require changes to both YJIT and the virtual machine.|Additionally, this approach is slower, as it requires checking the instruction argument value. So I did not use this approach.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concatarray             false
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

Instead, I chose to add a new instruction, named concattoarray. This instruction would only be used when you are directly mutating an existing array when concatenating, and it could assume the array being concatenated to is already an array, saving an additional type check.

def a(*ary)

end

a(*ary, *ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
splatarray              false
concattoarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

With these changes, the method call that used to allocate 3 arrays in Ruby 3.3 now only allocates a single array, achieving our goal.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end
# Ruby 3.3: Allocates: 3 arrays, 0 hashes
# Ruby 3.4: Allocates: 1 arrays, 0 hashes

Now that the multiple splat case was optimized, I moved onto the next case,

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, *ary)
end
# Ruby 3.3: Allocates: 3 arrays, 0 hashes
# Ruby 3.4: Allocates: 1 arrays, 0 hashes

which is where a positional argument follows a positional splat.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, ary)
end
# Ruby 3.3: Allocates: 
# Ruby 3.4: Allocates:

Suprisingly, this allocates more arrays than the multiple splat case in Ruby 3.3, with 4 array allocations.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, ary)
end
# Ruby 3.3: Allocates: 4 arrays, 0 hashes
# Ruby 3.4: Allocates:

Here are the instructions generated for this method call.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

If you notice, these are exactly the same instructions as the multiple splat method call, except for this newarray instruction. The reason for this instruction is that Ruby did not have a virtual machine instruction for pushing objects onto an array. So in cases where Ruby needed to push an object onto an existing array, it would wrap that object in an new array, and then concatenate that new array to the existing array.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

Ruby treats the method call like this, wrapping the argument after the splat in a separate array before combining it.

def a(*ary)

end

a(*[*ary, *[ary]])


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|FCALL

The previous optimization for mutable positional splats already removed the callee-side array allocation, bringing the total down to three array allocations.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

I could have switched the concatarray instruction to concattoarray to bring this down to only two array allocations.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concattoarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

But then it would not have been possible to eliminate the newarray instruction array allocation. This would mean we could not achieve our goal of at most one array allocation.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concattoarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

To achieve our goal, we need to eliminate the allocations for both of these instructions.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
newarray                1
concatarray
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

I achieved the goal by adding a pushtoarray instruction. This instruction is similar to the newarray instruction, in that pops the given number of objects off the stack. However, instead of creating a new array with the objects, it pushes each object to the array then currently at the top of the stack.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
pushtoarray             1
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

In this case, that is the array created by splatarray true.

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
pushtoarray             1
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

So with the combination of ARGS_SPLAT_MUT and pushtoarray,

def a(*ary)

end

a(*ary, ary)


putself
getlocal_WC_0           ary@0
splatarray              true
getlocal_WC_0           ary@0
pushtoarray             1
opt_send_without_block  a, argc:1, ARGS_SPLAT|ARGS_SPLAT_MUT|FCALL

Ruby 3.4 will only allocate a single array for the call, achieving our goal.

def a(*ary)

end

ary = []

objects_allocated do
  a(*ary, ary)
end
# Ruby 3.3: Allocates: 4 arrays, 0 hashes
# Ruby 3.4: Allocates: 1 arrays, 0 hashes

In this example, we have a method that accepts a positional splat parameter.

def a(*c)
  # ...
end

It is not possible to avoid allocating an array for this parameter.

def a(*c)
  # ...
end

That is because any code inside the method could access the c variable. While working on these optimizations, I realized that if you could remove the ability to access the variable, then it would be possible to avoid the allocation. It turns out Ruby already supports that,

def a(*c)
  # ...
end

using the anonymous splat parameter syntax introduced in Ruby 3.2. Technically, using anonymous splat parameters in method definitions is allowed in earlier versions of Ruby.

def a(*)
  # ...
end

What Ruby 3.2 added was support for using the anonymous splat parameter as a splat argument when calling other methods.

def a(*)
  p(*)
end

This was supported for keyword splats in addition to positional splats.

def a(*, **)
  p(*, **)
end

Here is an example with anonymous splat parameters.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end

We have a method that accepts a positional argument and a keyword argument.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end

We have a method that delegates all positional arguments and keyword arguments to that method using anonymous splats.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end

When we call the method with a positional splat and keyword splat,

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end

We can see that Ruby 3.3 allocates both an array and a hash.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The array is allocated for the anonymous positional splat.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The hash is allocated for the anonymous keyword splat.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

Both of these allocations are unnecessary, as we can be sure the method is not able to access the objects directly, only pass them as splats when calling other methods. So my next task was to eliminate these allocations.

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

To do so, I first needed to track whether the method uses anonymous splats or not, and the easiest way to track that is using iseq parameter flags. For every method defined in Ruby, there is an instruction sequence or iseq, and each iseq method has a set of parameter flags.

ISEQ

Parameter

Flags

The g method in this example has two parameter flags set

def g(a, b:)
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The has_lead flag is set, because the method has a mandatory positional argument.

def g(a, b:) # has_lead
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The has_kw flag is set, because the method accepts a keyword argument.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

For the f method,

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **)
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The has_rest flag is set, since the method accepts a positional splat.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

The has_kwrest flag is set, since the method accepts a keyword splat.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

To start the optimization process, I added an anon_rest flag, since the positional splat is anonymous.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

I also added an anon_kwrest flag, since the keyword splat is anonymous.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

Then I implemented the anonymous positional splat optimization. When calling a method with a positional splat, if that method has the anon_rest parameter flag set, and it is possible to use the positional splat argument directly as the positional splat parameter, then the duplication of positional splat argument is eliminated. Note that it is not always possible to use the positional splat argument directly.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

For example, if the method you are calling accepts a mandatory positional argument,

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(a, *, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

but that was not provided separately when calling the method, then you cannot eliminate the allocation, because you need to remove the first element of the splatted array,

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(a, *, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

as that element becomes the positional argument parameter.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(a, *, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

Next I implemented the anonymous keyword splat optimization. If calling a method with a keyword splat, when the anon_kwrest flag is set, and the method does not have named keyword parameters, this avoids the duplication of the keyword splat hash.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes

With those changes, Ruby 3.4 will not allocate any objects for that method call.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

One of the nice things about this optimization is that it works even with multiple levels of indirection, as long as each level uses anonymous splats.

def g(a, b:) # has_lead, has_kw
  a + b
end

def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

If we add a level of indirection via an h method, which uses anonymous positional and keyword splats, and delegates to g,

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  g(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

and we change f to call h instead of g,

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 1 arrays, 1 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

Ruby 3.3 would allocate 2 arrays and 2 hashes, one for each indirection level.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

But Ruby 3.4 would still not allocate any objects for this method call.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

In Ruby 3.2 and 3.3, using anonymous parameters was purely for nicer syntax, but starting in Ruby 3.4, it offers better performance in some cases, granting Ruby users an additional way to optimize their code.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

I really like this optimization, and have given it a name, Allocationless Anonymous Splat Forwarding.

Allocationless

Anonymous

Splat

Forwarding

The final optimization I will discuss is a change to generic argument forwarding.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

If we switch these anonymous splats,

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(*, **) = g(*, **)
def f(*, **) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(*, **)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

To use generic argument forwarding.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(...) = g(...)
def f(...) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(...)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 2 arrays, 2 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

Ruby 3.3 would allocate 3 arrays and 3 hashes. The reason this uses more arrays and hashes in Ruby 3.3,

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(...) = g(...)
def f(...) # has_rest, has_kwrest, anon_rest, anon_kwrest
  h(...)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 3 arrays, 3 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

is that generic argument forwarding is implemented via ruby2_keywords, which is not optimized as well as separate positional and keyword splats after Keyword Splat Separation.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(...) = g(...)
def f(...) # def f(*, &); ruby2_keywords :f
  h(...)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 3 arrays, 3 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

I switched generic argument forwarding to use an anonymous keyword splat internally,

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(...) = g(...)
def f(...) # def f(*, **, &)
  h(...)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 3 arrays, 3 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

so on Ruby 3.4, these calls are also allocationless.

def g(a, b:) # has_lead, has_kw
  a + b
end
def h(...) = g(...)
def f(...) # def f(*, **, &)
  h(...)
end

a = [1]
kw = {b: 2}

objects_allocated do
  f(*a, **kw)
end
# Ruby 3.3: Allocates: 3 arrays, 3 hashes
# Ruby 3.4: Allocates: 0 arrays, 0 hashes

Here are a couple of closing thoughts related to my experience working on these optimizations and fixing the bugs I discovered during that process.

Closing

Thoughts

First, working on optimizations is a great way to find bugs. To optimize code, you really need to understand how the code works, and once you understand how the code works, the cases that could be problematic often become more obvious.

Optimizations

Find

Bugs

Second, once a bug is found, fixing that bug takes priority over the optimization work. In this presentation, I discussed the Ruby 3.3 optimizations before the bug fixes, but the bug fixes were committed either before or at the same time as the optimizations. We must always remember that performance comes after correctness, not before.

Fixing

Bugs

Takes Priority

I hope you had fun learning about the implicit allocation reductions in Ruby 3.3 and Ruby 3.4.

Reducing

Implicit Allocations

During

Method Calling

There are bunch of additional allocation reduction optimizations I worked on that will be in Ruby 3.4, so possibly there will be a part two of this presentation at the next RubyKaigi.

To Be

Continued?

If you enjoyed this presentation, and want to read more of my thoughts on Ruby programming, please consider picking up a copy of Polished Ruby Programming.

That concludes my presentation. I would like to thank all of you for listening to me.

ありがとうございました

A special thank you to Shopify for sponsoring my travel to RubyKaigi. If you have any questions, please ask me during the break.