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 code changes made in Ruby 3.4 to eliminate unnecessary implicit allocations.

Eliminating

Unnecessary

Implicit

Allocations

RubyKaigi 2025

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

GitHub: jeremyevans

Twitter: @jeremyevans0

I work at Ubicloud as a Principal Software Engineer. We are building an open source alternative to Amazon Web Services.

@

I am going to start this presentation with a discussion on regressions,

Regressions

specifically, allocation regressions. An allocation regression is a case where Ruby unnecessarily allocates an object in a case where it did not do so previously.

Allocation

Regressions

While working on reducing allocations, in the span of about two weeks, I found and fixed three separate allocation regressions, all of which I caused.

3 Allocation

Regressions

The first allocation regression involved this type of method call, which passes a positional splat, keyword splat, and block.

Allocation

Regression #1

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

When I started working on reducing implicit allocations, this allocated 1 array.

Allocation

Regression #1

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


# Ruby 3.3-dev: 1 arrays, 0 hashes

I made changes to the optimizer that made this call allocationless.

Allocation

Regression #1

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


# Ruby 3.3-dev: 0 arrays, 0 hashes

Unfortunately, I found there was an evaluation order issue in this code, if kw was not a hash and block was not a proc,

Allocation

Regression #1

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


# Ruby 3.3-dev: 0 arrays, 0 hashes

as the code would call block.to_proc before kw.to_hash.

Allocation

Regression #1

meth(*a, **kw, &block)
# block.to proc before kw.to_hash

# Ruby 3.3-dev: 0 arrays, 0 hashes

I fixed this before the release of Ruby 3.3, so that the code would call kw.to_hash before block.to_proc.

Allocation

Regression #1

meth(*a, **kw, &block)
# kw.to_hash before block.to proc

# Ruby 3.3-dev: 0 arrays, 0 hashes

Unfortunately, that broke the optimization, so in Ruby 3.3, this call still allocated an unnecessary array.

Allocation

Regression #1

meth(*a, **kw, &block)
# kw.to_hash before block.to proc

# Ruby 3.3: 1 array, 0 hashes

I fixed this allocation regression in Ruby 3.4, so this call is once again allocationless.

Allocation

Regression #1

meth(*a, **kw, &block)
# kw.to_hash before block.to proc

# Ruby 3.3: 1 arrays, 0 hashes
# Ruby 3.4: 0 arrays, 0 hashes

The second allocation regression affected this code.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

Here we have a method that accepts a keyword argument.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

We are calling the method with a keyword splat. This should not require an allocation, because we can just look into the keyword splat hash to get the value.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

Indeed, in Ruby 3.2, this call was allocationless. In Ruby 3.3, I fixed a bug that passed the keyword splat directly as a positional argument, instead of passing a copy of the keyword splat, if the calling method did not accept keywords.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

# Ruby 3.2: 0 arrays, 0 hashes

Unfortunately, that bug fix caused an allocation regression, resulting in this code allocating a hash.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

# Ruby 3.2: 0 arrays, 0 hashes
# Ruby 3.3: 0 arrays, 1 hashes

I fixed this regression in Ruby 3.4, so this type of call is once again allocationless.

Allocation

Regression #2

def foo(a:) = a
hash = {a: 10}
foo(**hash)

# Ruby 3.2: 0 arrays, 0 hashes
# Ruby 3.3: 0 arrays, 1 hashes
# Ruby 3.4: 0 arrays, 0 hashes

The third allocation regression involved this type of call.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

We have the same method as in the previous example,

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

but this time, we are calling it with a positional splat and static literal keywords.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

This allocates a single hash in Ruby 3.3.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

# Ruby 3.3: 0 arrays, 1 hashes

When adding a optimization early in the Ruby 3.4 development cycle, I introduced an allocation regression, and made this call allocate an array as well as a hash.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

# Ruby 3.3: 0 arrays, 1 hashes
# Ruby 3.4-dev: 1 arrays, 1 hashes

I was able to fix the regression, so the code no longer allocated an unnecessary array.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

# Ruby 3.3: 0 arrays, 1 hashes
# Ruby 3.4-dev: 0 arrays, 1 hashes

I was also able to eliminate the unnecessary hash allocation, so this call is now allocationless in Ruby 3.4.

Allocation

Regression #3

def foo(a:) = a
array = []
foo(*a, a: 1)

# Ruby 3.3: 0 arrays, 1 hashes
# Ruby 3.4: 0 arrays, 0 hashes

As I mentioned, I found and fixed these three allocation regressions within about two weeks. Finding multiple allocation regressions in so short a timeframe was disheartening. It indicated to me that there was little point in attempting to eliminate unnecessary allocations, unless I could prevent future allocation regressions.

3 Allocation

Regressions

So I thought about how to do that. The conclusion I came to is that allocation regressions are no different in nature than any other regressions. And how do you avoid regressions generally?

How To Avoid

Regressions?

Well, you add tests. Tests help you ensure expected behavior.

Tests

If the expected behavior is that a certain type of method call allocates a certain number of objects, you need to write a test for that. That way, if you change the code and it results in an allocation regression, the related test breaks, alerting you to the problem immediately, and allowing you to fix it.

Allocation

Tests

So I started writing an allocation test suite.

Allocation

Test

Suite

As I have limited time, I am not going to discuss the implementation of the allocation test suite, but I will go over a simplified example of an allocation test. In this allocation test, we define a method.

def required(x); end

Then we call the check_allocations method.

def required(x); end

check_allocations(0, 0, "required(1)")

The third argument is the code that will be executed.

def required(x); end

check_allocations(0, 0, "required(1)")

The first argument is the number of arrays the code should allocate.

def required(x); end

check_allocations(0, 0, "required(1)")

The second argument is the number of hashes the code should allocate.

def required(x); end

check_allocations(0, 0, "required(1)")

So this line tests that calling a method that accepts a single positional parameter with a single positional argument should not allocate an array or a hash.

def required(x); end

check_allocations(0, 0, "required(1)")

This line tests that calling the same method with a keyword splat does not allocate an array, but does allocate one hash. This is expected, as the positional parameter should be passed a copy of the keyword splat hash.

def required(x); end

check_allocations(0, 0, "required(1)")
check_allocations(0, 1, "required(**hash")

I think the allocation test suite I created was my most important contribution to Ruby 3.4. It resulted in 3 major benefits.

Allocation

Test

Suite

The first benefit is that since its introduction, it has prevented further allocation regressions, at least for the cases it tests.

Prevent

Allocation

Regressions

The second benefit was that it allowed the Prism team to find all of the tested cases where the Prism compiler was allocating more objects than the parse.y compiler, and fix all of those cases before Prism was made the default parser. This prevented allocation regressions from the parser switch.

Prism

Finally, the test suite shows for each type of call, how many implicit allocations the call was making.

Shows

Implicit

Allocations

I could review the allocation numbers for a passing allocation test suite, and find cases where Ruby was unnecessarily allocating objects.

Determine

Unnecessary

Implicit

Allocations

The allocation test suite basically provided me a list of call types where I could eliminate unnecessary implicit allocations.

Eliminating

Unnecessary

Implicit

Allocations

Note that not all unnecessary implicit allocations were in method calling. I found that large literal arrays can allocate more than one array.

Large

Literal

Arrays

For some background, I will give a brief overview of the instructions used to create literal arrays in Ruby.

Literal

Arrays

The empty literal array allocates one array.

[]
# 1 array

This is implemented using a single VM instruction, newarray 0.

[]
# 1 array

newarray       0

If an array contains only other frozen literals, such as numbers and symbols, it also only allocates 1 array.

[1]
# 1 array

In this case, a frozen array is statically allocated for the literal, and the duparray instruction is used, which returns a copy of the array.

[1]
# 1 array

duparray       [1]

This is true regardless of the size of the array, as long as all elements are frozen literals. Even if the literal array has a million elements, it only allocates one array,

[1, 2, ..., 1_000_000]
# 1 array

because a single duparray instruction is still used, which returns a copy of the frozen array.

[1, 2, ..., 1_000_000]
# 1 array

duparray       [1, 2, ..., 1_000_000]

In Ruby 3.3, if the literal array contains a non-frozen literal or an expression, the number of array allocations is based on the number of elements in the array. Here we have an array created with a single local variable.

v = 1
[v]
# 1 array

This literal array will be created using two instructions

v = 1
[v]
# 1 array

getlocal_WC_0  v@0
newarray       1

The first instruction will retrive the value of the local variable, and place it on the VM stack.

v = 1
[v]
# 1 array

getlocal_WC_0  v@0
newarray       1

The second instruction will allocate a new array with a single element, using the top element on the VM stack.

v = 1
[v]
# 1 array

getlocal_WC_0  v@0
newarray       1

Here is a more complex case, a literal array with 257 elements, all of which are local variable accesses.

v = 1
[v, v, ..., v] # 257 times

This is a case that actually allocates more than 1 array in Ruby 3.3. It allocates 3 arrays.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

Here are the VM instructions used.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

The first 256 instructions just retrieve the local variable value and push it onto the VM stack.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

Then it creates one array with 256 elements. This is the first array allocation.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

This instruction is the same as the earlier instructions, and pushes the local variable value onto the VM stack.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

This newarray instruction allocates another array to wrap that element, which is the second array allocation.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

The final instruction is a concatarray instruction, which takes the 2 temporary arrays, and combines them, returning a newly allocated array. This is the third array allocation.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

I am guessing that a lot of you may be wondering why Ruby allocates a new array for every 256 elements. It certainly was not obvious to me when I first started looking at this code. It turns out the reason Ruby does this is to avoid VM stack overflow.|The VM stack has a limited size, and if you tried to define a large enough literal array, you could overflow the VM stack. To avoid that, Ruby chunks large literal arrays into sub arrays of 256 elements, then concatenates them together, which seems reasonable.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

That being said, while this array allocation seems necessary, since a literal array must allocate at least one array,

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

these two array allocations seem unnecessary. Instead of allocating new arrays, we should append to the array allocated in the newarray 256 instruction.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
newarray       1
concatarray

We can do that by using the pushtoarray instruction I discussed in last year's RubyKaigi presentation.

v = 1
[v, v, ..., v] # 257 times
# 3 arrays

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
pushtoarray    1

That change means that this literal array only allocates a single array in Ruby 3.4.

v = 1
[v, v, ..., v] # 257 times
# 1 array

getlocal_WC_0  v@0
getlocal_WC_0  v@0
# 253 more times
getlocal_WC_0  v@0
newarray       256
getlocal_WC_0  v@0
pushtoarray    1

It turns out it was not just large literal arrays that allocated more than one array in Ruby 3.3.

Large

Literal

Arrays

Literal arrays that contained positional splats also allocate more than one array in Ruby 3.3.

Literal

Arrays

with Splats

For example, this literal array, which contains a single splat.

v = []
[v, *v, v]

Allocates 4 arrays in Ruby 3.3.

v = []
[v, *v, v]
# 4 arrays

Here are the instructions used to create the literal array in Ruby 3.3.

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concatarray
getlocal_WC_0  v@0
newarray       1
concatarray

All four of these instructions allocate an array, even though only one array allocation is needed.

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concatarray
getlocal_WC_0  v@0
newarray       1
concatarray

Switching the final newarray and concatarray instructions to pushtoarray eliminates 2 array allocations.

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concatarray
getlocal_WC_0  v@0
pushtoarray    1

The final unnecessary allocation is due to this concatarray instruction,

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concatarray
getlocal_WC_0  v@0
pushtoarray    1

which is used to implement the splat part of the literal array.

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concatarray
getlocal_WC_0  v@0
pushtoarray    1

This is fixed by using the other new VM instruction I discussed in last year's presentation, which is called concattoarray. This instruction is similar to concatarray, but it does not allocate a new array.

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concattoarray
getlocal_WC_0  v@0
pushtoarray    1

With these two changes,

v = []
[v, *v, v]
# 4 arrays

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concattoarray
getlocal_WC_0  v@0
pushtoarray    1

Ruby 3.4 now only allocates a single array when creating a literal array with splats.

v = []
[v, *v, v]
# 1 array

getlocal_WC_0  v@0
newarray       1
getlocal_WC_0  v@0
concattoarray
getlocal_WC_0  v@0
pushtoarray    1

I think it is good that I was able to reuse VM instructions that I added to speed up method calls to also speed up literal arrays. However, I ran into a case that was not possible to optimize with existing instructions.

Literal

Arrays

This case involved using keyword splats in literal arrays.

Literal

Arrays

with Keyword

Splats

Here is the example. We create a literal array using a splat of an array, and a keyword splat of a hash.

v = []
h = {kw: 1}
[*v, **h]

Ruby 3.3 allocates three arrays for this case.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays

It uses the following simplified VM instructions for creating the literal array.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

This set of instructions is for the keyword splat.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

These 3 instructions each allocate an array.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

This array allocation is needed, since a literal array does need to allocate an array.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

But the array allocations for these instructions should be eliminated.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

It is possible to save one array allocation by changing this concatarray instruction

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concatarray

to concattoarray, which does not allocate a new array

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concattoarray

However, then we would not be able to eliminate the array allocation in the newarraykwsplat instruction, since concattoarray can only combine arrays.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
newarraykwsplat   1
concattoarray

Unfortunately, it is not possible to replace both instructions with a pushtoarray instruction, because this will push an empty hash onto the array if the keyword splat is empty.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
pushtoarray       1

The simplest solution to avoid the unnecessary array allocation was to add a new VM instruction with the expected semantics, so that is what I did. This instruction is named pushtoarraykwsplat, and it is similar to pushtoarray, but it does not accept an argument. This instruction pops the VM stack, then appends the popped object to the array at the current top of the VM stack, unless the popped object is an empty hash.

v = []
h = {kw: 1}
[*v, **h]
# 3 arrays


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
pushtoarraykwsplat

With that change, literal arrays with keyword splats only allocate a single array in Ruby 3.4.

v = []
h = {kw: 1}
[*v, **h]
# 1 array


getlocal_WC_0     v@0
splatarray        true
putspecialobject  1
newhash           0
getlocal_WC_0     h@1
send              #hash_merge_kwd, argc:2
pushtoarraykwsplat

Related to this, before I started work on this optimization, we received a bug report that Ruby's behavior for this case was actually incorrect.

v = []
h = {}
[*v, **h]

If you were keyword splatting an empty hash,

v = []
h = {}
[*v, **h]

and the keyword splat was directly after a positional splat, with no elements in between,

v = []
h = {}
[*v, **h]

then Ruby 3.3 and below would include an empty hash in the array.|I submitted a pull request that fixed this bug in a backwards compatible way before working on the literal array optimizations. The pushtoarraykwsplat instruction optimization also fixed this bug, and was committed first.|However, my original pull request was backported to Ruby 3.2 and 3.3.

v = []
h = {}
[*v, **h]
# => [{}]

So now Ruby 3.2 and above will no longer include an empty hash for an empty keyword splat in a literal array.

v = []
h = {}
[*v, **h]
# => []

With those optimizations, I believe that all literal arrays now only allocate a single array in Ruby 3.4.

Literal

Arrays

I am now going to discuss how I eliminated unnecessary caller-side positional splat allocations.

Caller-Side

Splat

Allocations

As I discussed last year, I was able to eliminate implicit array allocations for the following method calls in Ruby 3.3, by adding an optimization pass that changed splatarray true to splatarray false. Unfortunately, while the approach of using the optimizer worked for these types of calls,

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

it did not work for other types of calls. These calls all allocated an unnecessary array for the positional splat. All of these cases result in a dynamic hash after the positional splat, which is not one of the cases that the optimizer can optimize, because the instructions for creating dynamic hashes are not fixed.|Optimizing these cases requires knowledge of the parse tree, not just access to the unoptimized instructions. This meant that to optimize these cases, I would have to move the optimization from the optimizer to the compiler.

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

# Array Allocated
a(*ary, **kw, **kw)
a(*ary, **kw, **kw, &block)
a(*ary, kw: 1, **kw)
a(*ary, kw: 1, **kw, &block)
a(*ary, kw: lvar)
a(*ary, kw: lvar, &block)
a(*ary, kw: @ivar)
a(*ary, kw: @ivar, &block)
a(1, *ary, **kw, **kw)
a(1, *ary, **kw, **kw, &block)
a(1, *ary, kw: 1, **kw)
a(1, *ary, kw: 1, **kw, &block)

So it looked into how to optimize these cases in the compiler. At the time, the default parser was parse.y, and the main function for compiling arguments for method calls when using parse.y is named setup_args_core.

static int
setup_args_core(rb_iseq_t *iseq, LINK_ANCHOR *const args, const NODE *argn,
                int dup_rest, unsigned int *flag_ptr,
                struct rb_callinfo_kwarg **kwarg_ptr)

The fourth argument is whether you should duplicate an array being splatted. This is what controls whether the method call allocates an array for the splat.|My first thought to optimize these cases was to look for places where we are passing non-zero for the dup_rest argument, and see it we can change it to pass zero while still complying with Ruby semantics.

static int
setup_args_core(rb_iseq_t *iseq, LINK_ANCHOR *const args, const NODE *argn,
                int dup_rest, unsigned int *flag_ptr,
                struct rb_callinfo_kwarg **kwarg_ptr)

One case I found is this recursive call, inside setup_args_core.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

This case happens when compiling an ARGSPUSH node.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

The ARGSPUSH node is used in Ruby when you have arguments following a positional splat. Here are examples of calls that would use an ARGSPUSH node.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

This type of method call, with a positional argument following a positional splat, needs to allocate an array, because Ruby's internal method calling API does not handle positional arguments after a positional splat, so an array needs to be allocated for the positional splat and the argument following the splat needs to be appended to that array.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

These four calls do not need to allocate an array, because there is only a positional splat, and no positional arguments following the splat.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

These two cases were previously optimized via the optimizer in Ruby 3.3. So the compiler would create instructions that allocated an array, but the optimizer would recognize those instruction combinations, and change them so they did not allocate an array.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

These are two cases that allocated an unnecessary array in Ruby 3.3, because the optimizer only handled cases where static keywords or a single keyword splat were used.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

Here we are calling setup_args_core with a non-zero value, forcing array allocations for splats in this recursive call, even though array allocations may not always be necessary. It turns out, in some cases, we can know before the recursive call that it is safe to avoid the array allocation.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, 1, NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

By replacing those two lines with this code, I was able to optimize more cases. Let me go over what this new code does.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

First, realize that this code is the same as the previous code, just split into an additional if statement.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

This is the new code being added.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

The first condition for the optimization is the head of the ARGSPUSH node is a SPLAT node.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

That is true in all of these cases, since the first argument to the method is a positional splat.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

The second condition is the body of the ARGSPUSH node is a HASH node.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

That is true for all of these cases, because literal hashes, literal keywords, and keyword splats are all parsed as HASH nodes.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

The final condition is that nd_brace is not set. nd_brace is set on HASH nodes for literal hashes, but not set on HASH nodes for literal keywords or keyword splats.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

This affects the bottom four cases, which all use literal keywords and/or keyword splats and do not need to allocate an array, but not the top case, which uses a literal hash, and does need to allocate.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

If all three of those conditions are true,

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

then the recursive call to setup_args_core is set to not allocate an array for the splat.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

m(*ary, {kw: 1})
m(*ary, kw: 1)
m(*ary, **kw)
m(*ary, kw: 1, **kw)
m(*ary, **kw, **kw)

That eliminated the array allocation for these calls.

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

# No Array Allocated
a(*ary, **kw, **kw)
a(*ary, **kw, **kw, &block)
a(*ary, kw: 1, **kw)
a(*ary, kw: 1, **kw, &block)
a(*ary, kw: lvar)
a(*ary, kw: lvar, &block)
a(*ary, kw: @ivar)
a(*ary, kw: @ivar, &block)

# Array Allocated
a(1, *ary, **kw, **kw)
a(1, *ary, **kw, **kw, &block)
a(1, *ary, kw: 1, **kw)
a(1, *ary, kw: 1, **kw, &block)

However, Ruby would still allocate an array for these calls. That is because these calls use a different parse tree.

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

# No Array Allocated
a(*ary, **kw, **kw)
a(*ary, **kw, **kw, &block)
a(*ary, kw: 1, **kw)
a(*ary, kw: 1, **kw, &block)
a(*ary, kw: lvar)
a(*ary, kw: lvar, &block)
a(*ary, kw: @ivar)
a(*ary, kw: @ivar, &block)

# Array Allocated
a(1, *ary, **kw, **kw)
a(1, *ary, **kw, **kw, &block)
a(1, *ary, kw: 1, **kw)
a(1, *ary, kw: 1, **kw, &block)

I will choose these two calls to show the difference. The only difference between these two calls is the bottom call has an argument before the positional splat.

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

# No Array Allocated
a(*ary, **kw, **kw)
a(*ary, **kw, **kw, &block)
a(*ary, kw: 1, **kw)
a(*ary, kw: 1, **kw, &block)
a(*ary, kw: lvar)
a(*ary, kw: lvar, &block)
a(*ary, kw: @ivar)
a(*ary, kw: @ivar, &block)

# Array Allocated
a(1, *ary, **kw, **kw)
a(1, *ary, **kw, **kw, &block)
a(1, *ary, kw: 1, **kw)
a(1, *ary, kw: 1, **kw, &block)

Here is the simplified parse tree for both calls

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

This is the difference between the parse trees. Without a leading argument, a SPLAT node is used, but with a leading argument, an ARGSCAT node is used.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

ARGSCAT node compilation had similar code to ARGSPUSH node compilation, in that it told recursive calls to allocate a new array. However, the same optimization could not be safely applied to the ARGSCAT node.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

That is because ARGSCAT is also used for method calls with multiple positional splats.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, *ary)
# NODE_FCALL
#  NODE_ARGSCAT
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#     NODE_LVAR
#  NODE_LVAR

To properly optimize, you would need to compile these two ARGSCAT nodes differently.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, *ary)
# NODE_FCALL
#  NODE_ARGSCAT
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#     NODE_LVAR
#  NODE_LVAR

You would want this ARGSCAT node to not allocate an array, because only a single positional splat is used.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, *ary)
# NODE_FCALL
#  NODE_ARGSCAT
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#     NODE_LVAR
#  NODE_LVAR

You would want this ARGSCAT node to allocate an array, since there are multiple positional splats. I could not see how that was possible with the setup_args_core API.

a(*ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_SPLAT
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw, **kw)
# NODE_FCALL
#  NODE_ARGSPUSH
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#    NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, *ary)
# NODE_FCALL
#  NODE_ARGSCAT
#   NODE_ARGSCAT
#    NODE_LIST
#     NODE_LIT: 1
#     NODE_LVAR
#  NODE_LVAR

So I changed the API.

static int
setup_args_core(rb_iseq_t *iseq, LINK_ANCHOR *const args, const NODE *argn,
                int dup_rest, unsigned int *flag_ptr,
                struct rb_callinfo_kwarg **kwarg_ptr)

Instead of taking an integer for whether the current node you are compiling should allocate an array for a splat.

static int
setup_args_core(rb_iseq_t *iseq, LINK_ANCHOR *const args, const NODE *argn,
                int dup_rest, unsigned int *flag_ptr,
                struct rb_callinfo_kwarg **kwarg_ptr)

I changed the argument to be a pointer to unsigned int. This allowed for tracking this information in a single place across recursive calls to setup_args_core.

static int
setup_args_core(rb_iseq_t *iseq, LINK_ANCHOR *const args, const NODE *argn,
                unsigned int* dup_rest, unsigned int *flag_ptr,
                struct rb_callinfo_kwarg **kwarg_ptr)

For the ARGSPUSH node compilation, which I previously changed to this.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

I was able to take all this code,

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int recurse_dup_rest = 1;

        if (nd_type_p(RNODE_ARGSPUSH(argn)->nd_head, NODE_SPLAT) &&
                nd_type_p(RNODE_ARGSPUSH(argn)->nd_body, NODE_HASH) &&
                !RNODE_HASH(RNODE_ARGSPUSH(argn)->nd_body)->nd_brace) {
            recurse_dup_rest = 0;
        }
        else if (flag_ptr) {
            *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

and delete it.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

As I was no longer defining this variable,

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, recurse_dup_rest,
                                   NULL, NULL);

I just had it pass the existing pointer directly.

      case NODE_ARGSPUSH: {
        if (flag_ptr) *flag_ptr |= VM_CALL_ARGS_SPLAT;
        int argc = setup_args_core(iseq, args, RNODE_ARGSPUSH(argn)->nd_head, dup_rest,
                                   NULL, NULL);

Here is a case where the dup_rest argument was used to make a decision about whether to allocate an array for the splat.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
            if (dup_rest) *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }

This adds the splatarray instruction,

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
            if (dup_rest) *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }

and the argument to the splatarray instruction is whether to allocate an array for the splat.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
            if (dup_rest) *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }

Now that dup_rest is a pointer and not an integer, we need to change this to dereference the pointer.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(*dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
            if (dup_rest) *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }

This code previously set that the positional splat was mutable if we were allocating a new array.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(*dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
            if (dup_rest) *flag_ptr |= VM_CALL_ARGS_SPLAT_MUT;
        }

That code was eliminated from this branch and other similar branches, and moved to a centralized location.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(*dup_rest));
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
        }

To ensure we never allocate more than one array per method call, if we did allocate an array in the splatarray argument, we set the dup_rest flag to zero, so no more arrays will be allocated.

      case NODE_SPLAT: {
        // f(*a)
        NO_CHECK(COMPILE(args, "args (splat)", RNODE_SPLAT(argn)->nd_head));
        ADD_INSN1(args, argn, splatarray, RBOOL(*dup_rest));
        if (*dup_rest) *dup_rest = 0;
        if (flag_ptr)  {
            *flag_ptr |= VM_CALL_ARGS_SPLAT;
        }

To avoid unnecessary allocations, we decide whether to allocate an array for the positional splat before the call to setup_args_core.

  unsigned int dup_rest = 1;
  
  if (should_not_allocate) {
    dup_rest = 0;
  }

  setup_args_core(iseq, args, argn, &dup_rest, flag, keywords)

We default to allocating an array.

  unsigned int dup_rest = 1;
  
  if (should_not_allocate) {
    dup_rest = 0;
  }

  setup_args_core(iseq, args, argn, &dup_rest, flag, keywords)

If we are sure an array allocation is not needed,

  unsigned int dup_rest = 1;
  
  if (should_not_allocate) {
    dup_rest = 0;
  }

  setup_args_core(iseq, args, argn, &dup_rest, flag, keywords)

then we set the call to not allocate an array.

  unsigned int dup_rest = 1;
  
  if (should_not_allocate) {
    dup_rest = 0;
  }

  setup_args_core(iseq, args, argn, &dup_rest, flag, keywords)

This is psuedocode, as it takes a significant amount of code to determine whether it is safe to avoid allocation.|There are four parse tree cases where we can avoid allocating an array.

  unsigned int dup_rest = 1;
  
  if (should_not_allocate) {
    dup_rest = 0;
  }

  setup_args_core(iseq, args, argn, &dup_rest, flag, keywords)

The first case is when the only argument is a positional splat.

a(*ary)

The primary argument node in this case is a SPLAT node.

a(*ary)
# NODE_SPLAT
#    NODE_LVAR

If the primary argument node is a SPLAT node, it is always safe to avoid allocation.

a(*ary)
# NODE_SPLAT
#    NODE_LVAR

case(NODE_SPLAT):
  // avoid caller side array allocation for f(*arg)
  dup_rest = 0;
  break;

The second case is when there are one or more positional arguments followed by a positional splat.

a(1, *ary)

In this case, the primary argument node is an ARGSCAT node, and the head of the ARGSCAT node is a LIST node.

a(1, *ary)
# NODE_ARGSCAT
#  NODE_LIST
#   NODE_LIT: 1
#  NODE_LVAR

So the code checks if the primary argument node is an ARGSCAT node,

a(1, *ary)
# NODE_ARGSCAT
#  NODE_LIST
#   NODE_LIT: 1
#  NODE_LVAR


case(NODE_ARGSCAT):
  // avoid caller side array allocation for f(1, *arg)
  dup_rest = !nd_type_p(RNODE_ARGSCAT(check_arg)->nd_head, NODE_LIST);
  break;

and if the head of the ARGSCAT node is a LIST node, then it is safe to avoid allocation.

a(1, *ary)
# NODE_ARGSCAT
#  NODE_LIST
#   NODE_LIT: 1
#  NODE_LVAR


case(NODE_ARGSCAT):
  // avoid caller side array allocation for f(1, *arg)
  dup_rest = !nd_type_p(RNODE_ARGSCAT(check_arg)->nd_head, NODE_LIST);
  break;

The third case is when there is a positional splat followed by literal keywords or a keyword splat.

a(*ary, **kw)

The parse tree for this case has ARGSPUSH as the primary argument node, with the head being a SPLAT node and the body being a HASH node that is a keyword argument.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

The third and fourth cases are related, so I will discuss the fourth case at the same time. This is when there are one or more positional arguments, followed by a positional splat, and then followed by literal keywords or a keyword splat.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)

In the fourth case, instead of a SPLAT node, you have an ARGSCAT node where the head is a LIST node.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

So the code first checks that the primary argument node is ARGSPUSH,

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

and if so, checks whether the head of that node is a SPLAT node

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

or the head is an ARGSCAT node where the head of that is a LIST node.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

Finally, the code checks whether the body of the ARGSPUSH node is a HASH node where nd_brace is not set.|With these four cases handled, I was able to avoid array allocation for all cases where a single positional splat and no post-splat positional arguments are used.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

Unfortunately, this broke tests, because it is actually not safe to eliminate the allocation for all such calls. For example, if kw is a local variable, it is safe to avoid allocation, but if kw is a method call, then it is not safe, because the method call could modify the array being splatted, and that is an evaluation order issue.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

In order to be safe, you need to inspect all subnodes of the HASH node, and determine whether any of those nodes contains an expression that could cause an evaluation order issue.

a(*ary, **kw)
# NODE_ARGSPUSH
#  NODE_SPLAT
#   NODE_LVAR
#  NODE_HASH (keyword argument)

a(1, *ary, **kw)
# NODE_ARGSPUSH
#  NODE_ARGSCAT
#   NODE_LIST
#    NODE_LIT: 1
#   NODE_LVAR
#  NODE_HASH (keyword argument)

case(NODE_ARGSPUSH):
  // avoid caller side array allocation for f(*arg, **hash) and f(1, *arg, **hash)
  dup_rest = !((nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_SPLAT) ||
  (nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_head, NODE_ARGSCAT) &&
  nd_type_p(RNODE_ARGSCAT(RNODE_ARGSPUSH(check_arg)->nd_head)->nd_head, NODE_LIST))) &&
  nd_type_p(RNODE_ARGSPUSH(check_arg)->nd_body, NODE_HASH) &&
  !RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_brace);

So I added a function that can be passed a node and will return true if the node could potentially modify an existing argument splat.

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

This will allow local and instance variables,

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

most literals,

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

as well as most constant references

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

This line handles nested constants, which may not be safe.

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

For example, this type of nested constant reference, where all parts are constant references, is safe enough to not force allocating an array for the splat.

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

Foo::Bar # safe

However, this type of constant reference, which looks for a constant under a module returned by a method call, is not safe, as the method call could modify the argument being splatted.

static bool
setup_args_dup_rest_p(const NODE *argn)
{
    switch(nd_type(argn)) {
      case NODE_LVAR:
      case NODE_DVAR:
      case NODE_GVAR:
      case NODE_IVAR:
      case NODE_CVAR:
      case NODE_CONST:
      case NODE_COLON3:
      case NODE_INTEGER:
      case NODE_FLOAT:
      case NODE_RATIONAL:
      case NODE_IMAGINARY:
      case NODE_STR:
      case NODE_SYM:
      case NODE_REGX:
      case NODE_SELF:
      case NODE_NIL:
      case NODE_TRUE:
      case NODE_FALSE:
      case NODE_LAMBDA:
      case NODE_NTH_REF:
      case NODE_BACK_REF:
        return false;
      case NODE_COLON2:
        return setup_args_dup_rest_p(RNODE_COLON2(argn)->nd_head);
      default:
        return true;
    }
}

Foo::Bar # safe
method_call::Bar # not safe

With that function defined, the remaining step is to check all of the key and value nodes for literal keywords, as well as the nodes for keyword splats, so I added this code.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

We start with the HASH node for the literal keywords and keyword splats. All keys and values of literal keywords as well as keyword splats will be inside this node.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

Each entry inside this HASH node is either a key/value pair, or a keyword splat, and we will iterate over all of them.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

The head of this node is the key node for a literal keyword, and NULL for a keyword splat.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

If the key node is set, we call the function to determine whether the node is safe.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

If it is not safe, we mark that we need to allocate an array for the splat, and stop processing.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

If it is safe, we move to the next node,


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

and then get the head node for that, which is either the value node for a literal keyword, or the node for the keyword splat expression.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

We do the same check as we did for the key node, and handle unsafe nodes the same way.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

We repeat this process for every keyword or keyword splat in the method call.


if (!dup_rest) {
  // require allocation for keyword key/value/splat that may modify splatted argument
  NODE *node = RNODE_HASH(RNODE_ARGSPUSH(check_arg)->nd_body)->nd_head;

  while (node) {
    NODE *key_node = RNODE_LIST(node)->nd_head;
    if (key_node && setup_args_dup_rest_p(key_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
    NODE *value_node = RNODE_LIST(node)->nd_head;
    if (setup_args_dup_rest_p(value_node)) {
      dup_rest = 1;
      break;
    }

    node = RNODE_LIST(node)->nd_next;
  }
}

It turns out that in addition to checking the keyword arguments, if a block is being passed via an ampersand, we also need to check the block pass expression. Here is the code for that.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

First, if we already know we are going to duplicate the array anyway, we do not need check the block pass expression.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

We only want to do this check if a block pass expression is provided.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

We do the same check on the block pass expression that we did on the keywords.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

If the block pass expression is not safe, they we must duplicate the array being splatted.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

With that change, all cases that unnecessarily allocated a caller side array for a positional splat in Ruby 3.3 no longer do so in Ruby 3.4.| Additionally, I was able to remove the entire optimizer change I added in Ruby 3.3, because this compiler change handled all cases the optimizer handled, as well as all of these additional cases.

# No Array Allocated
a(1, *ary)
a(1, *ary, &block)
a(*ary, **kw)
a(*ary, **kw, &block)
a(*ary, kw: 1)
a(*ary, kw: 1, &block)

# No Array Allocated
a(*ary, **kw, **kw)
a(*ary, **kw, **kw, &block)
a(*ary, kw: 1, **kw)
a(*ary, kw: 1, **kw, &block)
a(*ary, kw: lvar)
a(*ary, kw: lvar, &block)
a(*ary, kw: @ivar)
a(*ary, kw: @ivar, &block)
a(1, *ary, **kw, **kw)
a(1, *ary, **kw, **kw, &block)
a(1, *ary, kw: 1, **kw)
a(1, *ary, kw: 1, **kw, &block)

A while after making that optimization, I found a related evaluation order issue, in this type of method call.


a(**h, &h.delete(key))

Here we are keyword splatting a variable. Since this is a single keyword splat without literal keywords, it would generally not be duplicated.


a(**h, &h.delete(key))

However, in the same method call, we are mutating the variable in the block pass expression. If we don't duplicate the keyword splat expression, then this is an evaluation order issue, because the deleted key will not appear as a keyword argument.


a(**h, &h.delete(key))

To fix this evaluation order issue, we go back to the setup_args code.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

We previously were only using 0 or 1 values for dup_rest. However, we now want dup_rest to track two types of information. The first type of information is whether the positional splat array should be duplicated. The second type of information is whether keyword splat hash for a single keyword splat should be duplicated.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = 1;
}

In order to do that, I created macros for these two conditions.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
}

SPLATARRAY_TRUE is used for the condition where we need to duplicate the splat array.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
}

DUP_SINGLE_KW_SPLAT is used for the condition where we need to duplicate the keyword splat hash.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
}

Note that we want to set DUP_SINGLE_KW_SPLAT even if we are already going to be duplicating the splat array.


if (!dup_rest && (check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
}

So we need to remove this condition.


if ((check_arg != argn) &&
        setup_args_dup_rest_p(RNODE_BLOCK_PASS(argn)->nd_body)) {
    // require allocation for block pass that may modify splatted argument
    dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
}

Now that we have set that flag, we need to change the keyword compilation code to use it. This is what the code looked like before the change.


             if (!keyword_node_single_splat_p(kwnode)) {
                 *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
             }
             compile_hash(iseq, args, kwnode, TRUE, FALSE);
             argc += 1;

If the keyword splat node was not a single keyword splat,


             if (!keyword_node_single_splat_p(kwnode)) {
                 *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
             }
             compile_hash(iseq, args, kwnode, TRUE, FALSE);
             argc += 1;

We mark the method call as containing a mutable keyword.


             if (!keyword_node_single_splat_p(kwnode)) {
                 *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
             }
             compile_hash(iseq, args, kwnode, TRUE, FALSE);
             argc += 1;

Then we call compile_hash with the keyword node, which may be literal keywords and/or one or more keyword splats.


             if (!keyword_node_single_splat_p(kwnode)) {
                 *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
             }
             compile_hash(iseq, args, kwnode, TRUE, FALSE);
             argc += 1;

Here is the code I added to fix the evaluation order issue.


            if (!keyword_node_single_splat_p(kwnode)) {
                *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
                compile_single_keyword_splat_mutable(iseq, args, argn,
                    kwnode, flag_ptr);
            }
            else {
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            argc += 1;

These sections are basically the same as the previous code, split into two parts.


            if (!keyword_node_single_splat_p(kwnode)) {
                *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
                compile_single_keyword_splat_mutable(iseq, args, argn,
                    kwnode, flag_ptr);
            }
            else {
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            argc += 1;

This is the new code.


            if (!keyword_node_single_splat_p(kwnode)) {
                *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
                compile_single_keyword_splat_mutable(iseq, args, argn,
                    kwnode, flag_ptr);
            }
            else {
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            argc += 1;

If the keyword node is a single keyword splat, and the DUP_SINGLE_KW_SPLAT flag is set.


            if (!keyword_node_single_splat_p(kwnode)) {
                *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
                compile_single_keyword_splat_mutable(iseq, args, argn,
                    kwnode, flag_ptr);
            }
            else {
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            argc += 1;

We call a new function, designed only to compile single keyword splats where we need to duplicate the splat hash to avoid the evaluation order issue.


            if (!keyword_node_single_splat_p(kwnode)) {
                *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
                compile_single_keyword_splat_mutable(iseq, args, argn,
                    kwnode, flag_ptr);
            }
            else {
                compile_hash(iseq, args, kwnode, TRUE, FALSE);
            }
            argc += 1;

Here is the definition of that function.


static void
compile_single_keyword_splat_mutable(rb_iseq_t *iseq, LINK_ANCHOR *const args,
                                     const NODE *argn, NODE *kwnode,
                                     unsigned int *flag_ptr)
{
    *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
    ADD_INSN1(args, argn, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
    ADD_INSN1(args, argn, newhash, INT2FIX(0));
    compile_hash(iseq, args, kwnode, TRUE, FALSE);
    ADD_SEND(args, argn, id_core_hash_merge_kwd, INT2FIX(2));
}

First, since we will be allocating a new hash for the keyword splat, we mark the method as passing a mutable keyword splat.


static void
compile_single_keyword_splat_mutable(rb_iseq_t *iseq, LINK_ANCHOR *const args,
                                     const NODE *argn, NODE *kwnode,
                                     unsigned int *flag_ptr)
{
    *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
    ADD_INSN1(args, argn, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
    ADD_INSN1(args, argn, newhash, INT2FIX(0));
    compile_hash(iseq, args, kwnode, TRUE, FALSE);
    ADD_SEND(args, argn, id_core_hash_merge_kwd, INT2FIX(2));
}

This is the same compile_hash call that we had previously. This will compile the keyword splat node without duplicating it.


static void
compile_single_keyword_splat_mutable(rb_iseq_t *iseq, LINK_ANCHOR *const args,
                                     const NODE *argn, NODE *kwnode,
                                     unsigned int *flag_ptr)
{
    *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
    ADD_INSN1(args, argn, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
    ADD_INSN1(args, argn, newhash, INT2FIX(0));
    compile_hash(iseq, args, kwnode, TRUE, FALSE);
    ADD_SEND(args, argn, id_core_hash_merge_kwd, INT2FIX(2));
}

These instructions create a new empty hash before the evaluating the keyword splat expression, and merge the keyword splat hash into the new hash. In other words, this is duplicating the keyword splat hash.


static void
compile_single_keyword_splat_mutable(rb_iseq_t *iseq, LINK_ANCHOR *const args,
                                     const NODE *argn, NODE *kwnode,
                                     unsigned int *flag_ptr)
{
    *flag_ptr |= VM_CALL_KW_SPLAT_MUT;
    ADD_INSN1(args, argn, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
    ADD_INSN1(args, argn, newhash, INT2FIX(0));
    compile_hash(iseq, args, kwnode, TRUE, FALSE);
    ADD_SEND(args, argn, id_core_hash_merge_kwd, INT2FIX(2));
}

With that change, this code no longer had an evaluation order issue, as it now duplicates the keyword splat hash before calling delete on it.


a(**h, &h.delete(key))

I would like to finish up this presentation by discussing the remaining implicit allocations in method calls, and whether they could be fixed.

Remaining

Implicit

Allocations

Let me start with the caller-side implicit allocations.

Caller-Side

Implicit

Allocations

First, having arguments after a positional splat or having multiple positional splats. Ruby's internal method calling API only supports a single positional splat, and does not support arguments after it, so in both cases the caller needs to allocate a new array to combine these arguments. This is not fixable without major internal changes.


a(*ary, arg)
a(*ary1, *ary2)

Second, having literal keywords and a keyword splat, or multiple keyword splats. Again, Ruby's internal method calling API does not support this. It supports only literal keywords or only a single keyword splat, so in both of these cases, the caller must allocate a hash and merge these into the hash. This also is not fixable without major internal changes.


a(kw: 1, **hash)
a(**hash1, **hash2)

Finally, a positional splat followed by non-static literal keywords. This currently allocates a hash, even though it does not need to, because Ruby's internal method calling API does not support both a positional splat and literal keywords, only a positional splat and a keyword splat. So this internally converts the literal keywords to a keyword splat. I think this case is much easier to fix than the other two cases.


a(*ary1, kw: lvar)

Now let me discuss the callee-side implicit allocations.

Callee-Side

Implicit

Allocations

First, having a named positional splat parameter requires array allocation. I think this allocation is unavoidable in the general case until we have a generic deoptimization framework, because any method call could result in an eval or access to the binding.


def a(*args)
  # ...
end

Second, a named keyword splat parameter requires hash allocation. I think this allocation is unavoidable, for the same reason.


def a(**kwargs)
  # ...
end

Finally, calling a method that only accepts positional arguments with literal keywords or a keyword splat. The callee automatically converts the keywords to a hash, and I think this allocation is also unavoidable, for the same reason.


def a(arg)
  # ...
end

a(k: 1)
a(**hash)

I hope you had fun learning about a few of the allocation reduction optimizations in Ruby 3.4.

Eliminating

Unnecessary

Implicit

Allocations

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. If you have any questions, please ask me during the break.