ZJIT: ruby-bench perf burndown

[k0kubun]

I investigated how ZJIT could beat YJIT in some of the benchmarks where it's currently losing. I use this issue as a reminder to make sure we tackle them. They have PoC patches, but it's not meant to be upstreamed as is; it's only there to clarify the problem. Feel free to pick up anything from here.

micro

• throw
  • Inline block calls and specialize TAG_RETURN throw from a block. Return from the function, popping multiple frames as needed. (PoC)
• setivar_object, setivar_young
  • GC fastpath for write barriers. (PoC)
• ruby-xor
  • Inline String#setbyte fastpath. (PoC)
  • I haven't fully figured out what to do for "cached coderange" yet. Are there realistically no drawbacks? Should we profile, specialize, and recompile? Should the fastpath always have two branches? If we decide to just always clear it, it'd be also nice to lift it into HIR to deduplicate them.
• str_concat
  • Inline String#<< fastpath. (PoC)
  • Similarly to the above String#setbyte discussion, I'm trying to lift codegen into HIR ZJIT: Compute the String#<< encoding check in HIR ruby/ruby#18251, but the patch is currently slower than master.
• send_cfunc_block
  • List of patches.
  • Would stack maps for locals solve all the spill overhead? Would we still need to think about ZJIT: Avoid spilling locals/stack slots that have already been spilled and not modified yet #718 for things like fallbacks?

other

• binarytrees
  • Specialize splat. (PoC)
  • ZJIT: Specialize send with caller_splat #1004 is already in progress
• graphql, graphql-native
  • Pass extra JIT-to-JIT arguments on the stack. (PoC)
  • It's already in progress. I've just merged ZJIT: Pass overflow invokebuiltin ccall args on the stack ruby/ruby#18285, so I'll open a follow-up PR to do the same thing for JIT-to-JIT calls.

The following things need more to catch up, but I haven't found enough for them yet:

• protoboeuf-encode
  • Inline the fastpath for String#<< with a codepoint. (PoC)
  • IIRC Kevin shared his interest in porting one from YJIT this morning?
• erubi
  • Inline String#<< fastpath & some extension to it. (PoC)
• splay
  • Specialize Float comparison operators (PoC)
• rubyboy
  • Compile opt_case_dispatch. (PoC)
  • Some reprofile for ivars. (PoC) I'll take a look at it as part of the function lifecycle effort.
• rack
  • Exception handlers. WIP at ZJIT: Compile exception handlers ruby/ruby#18253

headline

(many of them are still under investigation)

• mail
  • List of patches.
  • Exits from expandarray seem like a nice thing to work on first, but it doesn't seem to give a speedup in isolation.
  • Another place to avoid exits is coderange on some string method specialization. (commit)
  • ISEQ/ifunc-mixed polymorphic invokeblock. That will be a follow-up to ZJIT: Respect no_side_exits policy in monomorphic invokeblock ruby/ruby#18254, but it's still waiting for reviews.
  • Duplicated local spill elimination. Are stack maps for locals enough, or do we also need ZJIT: Avoid spilling locals/stack slots that have already been spilled and not modified yet #718?
• rubocop
  • List of patches.
  • I guess we could compile once as a fallback? The impact is small though.
  • (ran out of time; will write up the rest later)