ZJIT: Object allocation optimization opportunities

[k0kubun]

I want to record the list of object allocation optimization opportunities I found in Hack Days.

[k0kubun]

rubocop

RuboCop::AST::Node#type? (rubocop-ast 1.46.0) — ~8,700 calls/iteration, rest size usually 1–3:
https://github.com/rubocop/rubocop-ast/blob/v1.46.0/lib/rubocop/ast/node.rb#L167-L172

  def type?(*types)
    return true if types.include?(type)

    group_type = GROUP_FOR_TYPE[type]
    !group_type.nil? && types.include?(group_type)
  end

Parser::Source::Range#is? (parser 3.3.9.0) — ~3,000 calls/iteration, rest size 1:
https://github.com/whitequark/parser/blob/v3.3.9.0/lib/parser/source/range.rb#L141-L143

  def is?(*what)
    what.include?(source)
  end

---

These rest parameters are used only as the receiver of Array#include?.

Aaron and I discussed this case, and thought we should stack-allocate a C array (not a Ruby object Array) and pass a pointer to it to rb_vm_opt_newarray_include_p (the C function used by Insn::ArrayInclude) in this case.

[k0kubun]

shipit

rest parameters in shipit:

1. SpawnMethods#merge! (9.2k calls) has a completely unused *rest — scalarizable today
2. where!/order!/extending!/Arel.sql all feed the array into builders

(1) was trivially optimizable, but Aaron just deleted it in Rails head: rails/rails#58214

[k0kubun]

sequel

Sequel::Model::ClassMethods#[] (sequel 5.94.0, 1,000 calls/iteration in the sequel benchmark — one per query, always called with a single arg like Post[id]):
https://github.com/jeremyevans/sequel/blob/5.94.0/lib/sequel/model/base.rb#L212-L215

  def [](*args)
    args = args.first if args.size <= 1
    args.is_a?(Hash) ? first(args) : (primary_key_lookup(args) unless args.nil?)
  end

---

• For the args.size == 1 case (always the case in the benchmark), we can scalarize the first element.
• Even if args.size > 1, we should still be able to constant-fold Array#size if we do escape analysis.

[k0kubun]

ruby-lsp

Named-rest calls/itr: 17,579
% of allocs (upper bound): 7.9%

All hot sites are sorbet-runtime sig validator wrappers: |*args, &blk| → passes args on and bind_call(instance, *args, &blk)

---

I think this is also an interesting case we could hopefully optimize; if you have a rest parameter that is just proxied into a splat, we can probably get away without allocating a Ruby array.