@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-3

package/lib/ruby/3.4.11/ruby_vm/rjit/invariants.rb

@@ -0,0 +1,155 @@
+require 'set'
+
+module RubyVM::RJIT
+  class Invariants
+    class << self
+      # Called by RubyVM::RJIT::Compiler to lazily initialize this
+      # @param cb [CodeBlock]
+      # @param ocb [CodeBlock]
+      # @param compiler [RubyVM::RJIT::Compiler]
+      # @param exit_compiler [RubyVM::RJIT::ExitCompiler]
+      def initialize(cb, ocb, compiler, exit_compiler)
+        @cb = cb
+        @ocb = ocb
+        @compiler = compiler
+        @exit_compiler = exit_compiler
+        @bop_blocks = Set.new # TODO: actually invalidate this
+        @cme_blocks = Hash.new { |h, k| h[k] = Set.new }
+        @const_blocks = Hash.new { |h, k| h[k] = Set.new }
+        @patches = {}
+
+        # freeze # workaround a binding.irb issue. TODO: resurrect this
+      end
+
+      # @param jit [RubyVM::RJIT::JITState]
+      # @param klass [Integer]
+      # @param op [Integer]
+      def assume_bop_not_redefined(jit, klass, op)
+        return false unless C.BASIC_OP_UNREDEFINED_P(klass, op)
+
+        ensure_block_entry_exit(jit, cause: 'assume_bop_not_redefined')
+        @bop_blocks << jit.block
+        true
+      end
+
+      # @param jit [RubyVM::RJIT::JITState]
+      def assume_method_lookup_stable(jit, cme)
+        ensure_block_entry_exit(jit, cause: 'assume_method_lookup_stable')
+        @cme_blocks[cme.to_i] << jit.block
+      end
+
+      # @param jit [RubyVM::RJIT::JITState]
+      def assume_method_basic_definition(jit, klass, mid)
+        if C.rb_method_basic_definition_p(klass, mid)
+          cme = C.rb_callable_method_entry(klass, mid)
+          assume_method_lookup_stable(jit, cme)
+          true
+        else
+          false
+        end
+      end
+
+      def assume_stable_constant_names(jit, idlist)
+        (0..).each do |i|
+          break if (id = idlist[i]) == 0
+          @const_blocks[id] << jit.block
+        end
+      end
+
+      # @param asm [RubyVM::RJIT::Assembler]
+      def record_global_inval_patch(asm, target)
+        asm.pos_marker do |address|
+          if @patches.key?(address)
+            raise 'multiple patches in the same address'
+          end
+          @patches[address] = target
+        end
+      end
+
+      def on_cme_invalidate(cme)
+        @cme_blocks.fetch(cme.to_i, []).each do |block|
+          @cb.with_write_addr(block.start_addr) do
+            asm = Assembler.new
+            asm.comment('on_cme_invalidate')
+            asm.jmp(block.entry_exit)
+            @cb.write(asm)
+          end
+          # TODO: re-generate branches that refer to this block
+        end
+        @cme_blocks.delete(cme.to_i)
+      end
+
+      def on_constant_ic_update(iseq, ic, insn_idx)
+        # TODO: check multi ractor as well
+        if ic.entry.ic_cref
+          # No need to recompile the slowpath
+          return
+        end
+
+        pc = iseq.body.iseq_encoded + insn_idx
+        insn_name = Compiler.decode_insn(pc.*).name
+        if insn_name != :opt_getconstant_path && insn_name != :trace_opt_getconstant_path
+          raise 'insn_idx was not at opt_getconstant_path'
+        end
+        if ic.to_i != pc[1]
+          raise 'insn_idx + 1 was not at the updated IC'
+        end
+        @compiler.invalidate_blocks(iseq, pc.to_i)
+      end
+
+      def on_constant_state_changed(id)
+        @const_blocks.fetch(id, []).each do |block|
+          @compiler.invalidate_block(block)
+        end
+      end
+
+      def on_tracing_invalidate_all
+        invalidate_all
+      end
+
+      def on_update_references
+        # Give up. In order to support GC.compact, you'd have to update ISEQ
+        # addresses in BranchStub, etc. Ideally, we'd need to update moved
+        # pointers in JITed code here, but we just invalidate all for now.
+        invalidate_all
+      end
+
+      # @param jit [RubyVM::RJIT::JITState]
+      # @param block [RubyVM::RJIT::Block]
+      def ensure_block_entry_exit(jit, cause:)
+        block = jit.block
+        if block.entry_exit.nil?
+          block.entry_exit = Assembler.new.then do |asm|
+            @exit_compiler.compile_entry_exit(block.pc, block.ctx, asm, cause:)
+            @ocb.write(asm)
+          end
+        end
+      end
+
+      private
+
+      def invalidate_all
+        # On-Stack Replacement
+        @patches.each do |address, target|
+          # TODO: assert patches don't overlap each other
+          @cb.with_write_addr(address) do
+            asm = Assembler.new
+            asm.comment('on_tracing_invalidate_all')
+            asm.jmp(target)
+            @cb.write(asm)
+          end
+        end
+        @patches.clear
+
+        C.rjit_for_each_iseq do |iseq|
+          # Avoid entering past code
+          iseq.body.jit_entry = 0
+          # Avoid reusing past code
+          iseq.body.rjit_blocks.clear if iseq.body.rjit_blocks
+          # Compile this again if not converted to trace_* insns
+          iseq.body.jit_entry_calls = 0
+        end
+      end
+    end
+  end
+end

package/lib/ruby/3.4.11/ruby_vm/rjit/jit_state.rb

@@ -0,0 +1,65 @@
+module RubyVM::RJIT
+  class JITState < Struct.new(
+    :iseq,                        # @param `RubyVM::RJIT::CPointer::Struct_rb_iseq_t`
+    :pc,                          # @param [Integer] The JIT target PC
+    :cfp,                         # @param `RubyVM::RJIT::CPointer::Struct_rb_control_frame_t` The JIT source CFP (before RJIT is called)
+    :block,                       # @param [RubyVM::RJIT::Block]
+    :stack_size_for_pc,           # @param [Integer]
+    :side_exit_for_pc,            # @param [Hash{ Integer => Integer }] { sp_offset => address }
+    :record_boundary_patch_point, # @param [TrueClass,FalseClass]
+  )
+    def initialize(side_exit_for_pc: {}, record_boundary_patch_point: false, **) = super
+
+    def insn
+      Compiler.decode_insn(C.VALUE.new(pc).*)
+    end
+
+    def operand(index, signed: false, ruby: false)
+      addr = pc + (index + 1) * Fiddle::SIZEOF_VOIDP
+      value = Fiddle::Pointer.new(addr)[0, Fiddle::SIZEOF_VOIDP].unpack(signed ? 'q' : 'Q')[0]
+      if ruby
+        value = C.to_ruby(value)
+      end
+      value
+    end
+
+    def at_current_insn?
+      pc == cfp.pc.to_i
+    end
+
+    def peek_at_local(n)
+      local_table_size = iseq.body.local_table_size
+      offset = -C::VM_ENV_DATA_SIZE - local_table_size + n + 1
+      value = (cfp.ep + offset).*
+      C.to_ruby(value)
+    end
+
+    def peek_at_stack(depth_from_top)
+      raise 'not at current insn' unless at_current_insn?
+      offset = -(1 + depth_from_top)
+      # rb_rjit_branch_stub_hit updates SP, so you don't need to worry about sp_offset
+      value = (cfp.sp + offset).*
+      C.to_ruby(value)
+    end
+
+    def peek_at_self
+      C.to_ruby(cfp.self)
+    end
+
+    def peek_at_block_handler(level)
+      ep = ep_at_level(cfp, level:)
+      ep[C::VM_ENV_DATA_INDEX_SPECVAL]
+    end
+
+    private
+
+    def ep_at_level(cfp, level:)
+      ep = cfp.ep
+      level.times do
+        # VM_ENV_PREV_EP
+        ep = C.VALUE.new(ep[C::VM_ENV_DATA_INDEX_SPECVAL] & ~0x03)
+      end
+      ep
+    end
+  end
+end

package/lib/ruby/3.4.11/ruby_vm/rjit/stats.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+module RubyVM::RJIT
+  # Return a Hash for \RJIT statistics. \--rjit-stats makes more information available.
+  def self.runtime_stats
+    stats = {}
+
+    # Insn exits
+    INSNS.each_value do |insn|
+      exits = C.rjit_insn_exits[insn.bin]
+      if exits > 0
+        stats[:"exit_#{insn.name}"] = exits
+      end
+    end
+
+    # Runtime stats
+    C.rb_rjit_runtime_counters.members.each do |member|
+      stats[member] = C.rb_rjit_counters.public_send(member)
+    end
+    stats[:vm_insns_count] = C.rb_vm_insns_count
+
+    # Other stats are calculated here
+    stats[:side_exit_count] = stats.select { |name, _count| name.start_with?('exit_') }.sum(&:last)
+    if stats[:vm_insns_count] > 0
+      retired_in_rjit = stats[:rjit_insns_count] - stats[:side_exit_count]
+      stats[:total_insns_count] = retired_in_rjit + stats[:vm_insns_count]
+      stats[:ratio_in_rjit] = 100.0 * retired_in_rjit / stats[:total_insns_count]
+    else
+      stats.delete(:vm_insns_count)
+    end
+
+    stats
+  end
+
+  # :nodoc: all
+  class << self
+    private
+
+    # --yjit-stats at_exit
+    def print_stats
+      stats = runtime_stats
+      $stderr.puts("***RJIT: Printing RJIT statistics on exit***")
+
+      print_counters(stats, prefix: 'send_', prompt: 'method call exit reasons')
+      print_counters(stats, prefix: 'invokeblock_', prompt: 'invokeblock exit reasons')
+      print_counters(stats, prefix: 'invokesuper_', prompt: 'invokesuper exit reasons')
+      print_counters(stats, prefix: 'getblockpp_', prompt: 'getblockparamproxy exit reasons')
+      print_counters(stats, prefix: 'getivar_', prompt: 'getinstancevariable exit reasons')
+      print_counters(stats, prefix: 'setivar_', prompt: 'setinstancevariable exit reasons')
+      print_counters(stats, prefix: 'optaref_', prompt: 'opt_aref exit reasons')
+      print_counters(stats, prefix: 'optgetconst_', prompt: 'opt_getconstant_path exit reasons')
+      print_counters(stats, prefix: 'expandarray_', prompt: 'expandarray exit reasons')
+
+      $stderr.puts "compiled_block_count:  #{format_number(13, stats[:compiled_block_count])}"
+      $stderr.puts "side_exit_count:       #{format_number(13, stats[:side_exit_count])}"
+      $stderr.puts "total_insns_count:     #{format_number(13, stats[:total_insns_count])}" if stats.key?(:total_insns_count)
+      $stderr.puts "vm_insns_count:        #{format_number(13, stats[:vm_insns_count])}" if stats.key?(:vm_insns_count)
+      $stderr.puts "rjit_insns_count:      #{format_number(13, stats[:rjit_insns_count])}"
+      $stderr.puts "ratio_in_rjit:         #{format('%12.1f', stats[:ratio_in_rjit])}%" if stats.key?(:ratio_in_rjit)
+
+      print_exit_counts(stats)
+    end
+
+    def print_counters(stats, prefix:, prompt:)
+      $stderr.puts("#{prompt}: ")
+      counters = stats.filter { |key, _| key.start_with?(prefix) }
+      counters.filter! { |_, value| value != 0 }
+      counters.transform_keys! { |key| key.to_s.delete_prefix(prefix) }
+
+      if counters.empty?
+        $stderr.puts("    (all relevant counters are zero)")
+        return
+      end
+
+      counters = counters.to_a
+      counters.sort_by! { |(_, counter_value)| counter_value }
+      longest_name_length = counters.max_by { |(name, _)| name.length }.first.length
+      total = counters.sum { |(_, counter_value)| counter_value }
+
+      counters.reverse_each do |(name, value)|
+        percentage = value.fdiv(total) * 100
+        $stderr.printf("    %*s %s (%4.1f%%)\n", longest_name_length, name, format_number(10, value), percentage)
+      end
+    end
+
+    def print_exit_counts(stats, how_many: 20, padding: 2)
+      exits = stats.filter_map { |name, count| [name.to_s.delete_prefix('exit_'), count] if name.start_with?('exit_') }.to_h
+      return if exits.empty?
+
+      top_exits = exits.sort_by { |_name, count| -count }.first(how_many).to_h
+      total_exits = exits.values.sum
+      $stderr.puts "Top-#{top_exits.size} most frequent exit ops (#{format("%.1f", 100.0 * top_exits.values.sum / total_exits)}% of exits):"
+
+      name_width  = top_exits.map { |name, _count| name.length }.max + padding
+      count_width = top_exits.map { |_name, count| format_number(10, count).length }.max + padding
+      top_exits.each do |name, count|
+        ratio = 100.0 * count / total_exits
+        $stderr.puts "#{format("%#{name_width}s", name)}: #{format_number(count_width, count)} (#{format('%4.1f', ratio)}%)"
+      end
+    end
+
+    # Format large numbers with comma separators for readability
+    def format_number(pad, number)
+      integer, decimal = number.to_s.split('.')
+      d_groups = integer.chars.reverse.each_slice(3)
+      with_commas = d_groups.map(&:join).join(',').reverse
+      [with_commas, decimal].compact.join('.').rjust(pad, ' ')
+    end
+
+    # --yjit-trace-exits at_exit
+    def dump_trace_exits
+      filename = "#{Dir.pwd}/rjit_exit_locations.dump"
+      File.binwrite(filename, Marshal.dump(exit_traces))
+      $stderr.puts("RJIT exit locations dumped to:\n#{filename}")
+    end
+
+    # Convert rb_rjit_raw_samples and rb_rjit_line_samples into a StackProf format.
+    def exit_traces
+      results = C.rjit_exit_traces
+      raw_samples = results[:raw].dup
+      line_samples = results[:lines].dup
+      frames = results[:frames].dup
+      samples_count = 0
+
+      # Loop through the instructions and set the frame hash with the data.
+      # We use nonexistent.def for the file name, otherwise insns.def will be displayed
+      # and that information isn't useful in this context.
+      RubyVM::INSTRUCTION_NAMES.each_with_index do |name, frame_id|
+        frame_hash = { samples: 0, total_samples: 0, edges: {}, name: name, file: "nonexistent.def", line: nil, lines: {} }
+        results[:frames][frame_id] = frame_hash
+        frames[frame_id] = frame_hash
+      end
+
+      # Loop through the raw_samples and build the hashes for StackProf.
+      # The loop is based off an example in the StackProf documentation and therefore
+      # this functionality can only work with that library.
+      #
+      # Raw Samples:
+      # [ length, frame1, frame2, frameN, ..., instruction, count
+      #
+      # Line Samples
+      # [ length, line_1, line_2, line_n, ..., dummy value, count
+      i = 0
+      while i < raw_samples.length
+        stack_length = raw_samples[i] + 1
+        i += 1 # consume the stack length
+
+        prev_frame_id = nil
+        stack_length.times do |idx|
+          idx += i
+          frame_id = raw_samples[idx]
+
+          if prev_frame_id
+            prev_frame = frames[prev_frame_id]
+            prev_frame[:edges][frame_id] ||= 0
+            prev_frame[:edges][frame_id] += 1
+          end
+
+          frame_info = frames[frame_id]
+          frame_info[:total_samples] += 1
+
+          frame_info[:lines][line_samples[idx]] ||= [0, 0]
+          frame_info[:lines][line_samples[idx]][0] += 1
+
+          prev_frame_id = frame_id
+        end
+
+        i += stack_length # consume the stack
+
+        top_frame_id = prev_frame_id
+        top_frame_line = 1
+
+        sample_count = raw_samples[i]
+
+        frames[top_frame_id][:samples] += sample_count
+        frames[top_frame_id][:lines] ||= {}
+        frames[top_frame_id][:lines][top_frame_line] ||= [0, 0]
+        frames[top_frame_id][:lines][top_frame_line][1] += sample_count
+
+        samples_count += sample_count
+        i += 1
+      end
+
+      results[:samples] = samples_count
+      # Set missed_samples and gc_samples to 0 as their values
+      # don't matter to us in this context.
+      results[:missed_samples] = 0
+      results[:gc_samples] = 0
+      results
+    end
+  end
+end

package/lib/ruby/3.4.11/ruby_vm/rjit/type.rb

@@ -0,0 +1,221 @@
+module RubyVM::RJIT
+  # Represent the type of a value (local/stack/self) in RJIT
+  Type = Data.define(:type) do
+    # Check if the type is an immediate
+    def imm?
+      case self
+      in Type::UnknownImm then true
+      in Type::Nil then true
+      in Type::True then true
+      in Type::False then true
+      in Type::Fixnum then true
+      in Type::Flonum then true
+      in Type::ImmSymbol then true
+      else false
+      end
+    end
+
+    # Returns true when the type is not specific.
+    def unknown?
+      case self
+      in Type::Unknown | Type::UnknownImm | Type::UnknownHeap then true
+      else false
+      end
+    end
+
+    # Returns true when we know the VALUE is a specific handle type,
+    # such as a static symbol ([Type::ImmSymbol], i.e. true from RB_STATIC_SYM_P()).
+    # Opposite of [Self::is_unknown].
+    def specific?
+      !self.unknown?
+    end
+
+    # Check if the type is a heap object
+    def heap?
+      case self
+      in Type::UnknownHeap then true
+      in Type::TArray then true
+      in Type::Hash then true
+      in Type::HeapSymbol then true
+      in Type::TString then true
+      in Type::CString then true
+      in Type::BlockParamProxy then true
+      else false
+      end
+    end
+
+    # Check if it's a T_ARRAY object
+    def array?
+      case self
+      in Type::TArray then true
+      else false
+      end
+    end
+
+    # Check if it's a T_STRING object (both TString and CString are T_STRING)
+    def string?
+      case self
+      in Type::TString then true
+      in Type::CString then true
+      else false
+      end
+    end
+
+    # Returns the class if it is known, otherwise nil
+    def known_class
+      case self
+      in Type::Nil then C.rb_cNilClass
+      in Type::True then C.rb_cTrueClass
+      in Type::False then C.rb_cFalseClass
+      in Type::Fixnum then C.rb_cInteger
+      in Type::Flonum then C.rb_cFloat
+      in Type::ImmSymbol | Type::HeapSymbol then C.rb_cSymbol
+      in Type::CString then C.rb_cString
+      else nil
+      end
+    end
+
+    # Returns a boolean representing whether the value is truthy if known, otherwise nil
+    def known_truthy
+      case self
+      in Type::Nil then false
+      in Type::False then false
+      in Type::UnknownHeap then false
+      in Type::Unknown | Type::UnknownImm then nil
+      else true
+      end
+    end
+
+    # Returns a boolean representing whether the value is equal to nil if known, otherwise nil
+    def known_nil
+      case [self, self.known_truthy]
+      in Type::Nil, _ then true
+      in Type::False, _ then false # Qfalse is not nil
+      in _, true then false # if truthy, can't be nil
+      in _, _ then nil # otherwise unknown
+      end
+    end
+
+    def diff(dst)
+      # Perfect match, difference is zero
+      if self == dst
+        return TypeDiff::Compatible[0]
+      end
+
+      # Any type can flow into an unknown type
+      if dst == Type::Unknown
+        return TypeDiff::Compatible[1]
+      end
+
+      # A CString is also a TString.
+      if self == Type::CString && dst == Type::TString
+        return TypeDiff::Compatible[1]
+      end
+
+      # Specific heap type into unknown heap type is imperfect but valid
+      if self.heap? && dst == Type::UnknownHeap
+        return TypeDiff::Compatible[1]
+      end
+
+      # Specific immediate type into unknown immediate type is imperfect but valid
+      if self.imm? && dst == Type::UnknownImm
+        return TypeDiff::Compatible[1]
+      end
+
+      # Incompatible types
+      return TypeDiff::Incompatible
+    end
+
+    def upgrade(new_type)
+      assert(new_type.diff(self) != TypeDiff::Incompatible)
+      new_type
+    end
+
+    private
+
+    def assert(cond)
+      unless cond
+        raise "'#{cond.inspect}' was not true"
+      end
+    end
+  end
+
+  # This returns an appropriate Type based on a known value
+  class << Type
+    def from(val)
+      if C::SPECIAL_CONST_P(val)
+        if fixnum?(val)
+          Type::Fixnum
+        elsif val.nil?
+          Type::Nil
+        elsif val == true
+          Type::True
+        elsif val == false
+          Type::False
+        elsif static_symbol?(val)
+          Type::ImmSymbol
+        elsif flonum?(val)
+          Type::Flonum
+        else
+          raise "Illegal value: #{val.inspect}"
+        end
+      else
+        val_class = C.to_value(C.rb_class_of(val))
+        if val_class == C.rb_cString && C.rb_obj_frozen_p(val)
+          return Type::CString
+        end
+        if C.to_value(val) == C.rb_block_param_proxy
+          return Type::BlockParamProxy
+        end
+        case C::BUILTIN_TYPE(val)
+        in C::RUBY_T_ARRAY
+          Type::TArray
+        in C::RUBY_T_HASH
+          Type::Hash
+        in C::RUBY_T_STRING
+          Type::TString
+        else
+          Type::UnknownHeap
+        end
+      end
+    end
+
+    private
+
+    def fixnum?(obj)
+      (C.to_value(obj) & C::RUBY_FIXNUM_FLAG) == C::RUBY_FIXNUM_FLAG
+    end
+
+    def flonum?(obj)
+      (C.to_value(obj) & C::RUBY_FLONUM_MASK) == C::RUBY_FLONUM_FLAG
+    end
+
+    def static_symbol?(obj)
+      (C.to_value(obj) & 0xff) == C::RUBY_SYMBOL_FLAG
+    end
+  end
+
+  # List of types
+  Type::Unknown     = Type[:Unknown]
+  Type::UnknownImm  = Type[:UnknownImm]
+  Type::UnknownHeap = Type[:UnknownHeap]
+  Type::Nil         = Type[:Nil]
+  Type::True        = Type[:True]
+  Type::False       = Type[:False]
+  Type::Fixnum      = Type[:Fixnum]
+  Type::Flonum      = Type[:Flonum]
+  Type::Hash        = Type[:Hash]
+  Type::ImmSymbol   = Type[:ImmSymbol]
+  Type::HeapSymbol  = Type[:HeapSymbol]
+
+  Type::TString = Type[:TString] # An object with the T_STRING flag set, possibly an rb_cString
+  Type::CString = Type[:CString] # An un-subclassed string of type rb_cString (can have instance vars in some cases)
+  Type::TArray  = Type[:TArray]  # An object with the T_ARRAY flag set, possibly an rb_cArray
+
+  Type::BlockParamProxy = Type[:BlockParamProxy] # A special sentinel value indicating the block parameter should be read from
+
+  module TypeDiff
+    Compatible = Data.define(:diversion) # The smaller, the more compatible.
+    Incompatible = :Incompatible
+  end
+end