In Files

  • yjit.rb

Files

Class/Module Index [+]

Quicksearch

RubyVM::YJIT

This module allows for introspection of YJIT, CRuby's experimental in-process just-in-time compiler. This module exists only to help develop YJIT, as such, everything in the module is highly implementation specific and comes with no API stability guarantee whatsoever.

This module may not exist if YJIT does not support the particular platform for which CRuby is built. There is also no API stability guarantee as to in what situations this module is defined.

Public Class Methods

disasm(iseq) click to toggle source

Produce disassembly for an iseq

 
               # File yjit.rb, line 140
def self.disasm(iseq)
  # If a method or proc is passed in, get its iseq
  iseq = RubyVM::InstructionSequence.of(iseq)

  if self.enabled?
    # Produce the disassembly string
    # Include the YARV iseq disasm in the string for additional context
    iseq.disasm + "\n" + Primitive.rb_yjit_disasm_iseq(iseq)
  else
    iseq.disasm
  end
end
            
dump_exit_locations(filename) click to toggle source

Marshal dumps exit locations to the given filename.

Usage:

In a script call:

RubyVM::YJIT.dump_exit_locations("my_file.dump")

Then run the file with the following options:

ruby --yjit --yjit-stats --yjit-trace-exits test.rb

Once the code is done running, use Stackprof to read the dump file. See Stackprof documentation for options.

 
               # File yjit.rb, line 125
def self.dump_exit_locations(filename)
  unless trace_exit_locations_enabled?
    raise ArgumentError, "--yjit-trace-exits must be enabled to use dump_exit_locations."
  end

  File.binwrite(filename, Marshal.dump(RubyVM::YJIT.exit_locations))
end
            
enabled?() click to toggle source

Check if YJIT is enabled

 
               # File yjit.rb, line 13
def self.enabled?
  Primitive.cexpr! 'RBOOL(rb_yjit_enabled_p())'
end
            
exit_locations() click to toggle source

If –yjit-trace-exits is enabled parse the hashes from Primitive.rb_yjit_get_exit_locations into a format readable by Stackprof. This will allow us to find the exact location of a side exit in YJIT based on the instruction that is exiting.

 
               # File yjit.rb, line 35
def self.exit_locations
  return unless trace_exit_locations_enabled?

  results = Primitive.rb_yjit_get_exit_locations
  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
            
insns_compiled(iseq) click to toggle source

Produce a list of instructions compiled by YJIT for an iseq

 
               # File yjit.rb, line 154
def self.insns_compiled(iseq)
  # If a method or proc is passed in, get its iseq
  iseq = RubyVM::InstructionSequence.of(iseq)

  if self.enabled?
    Primitive.rb_yjit_insns_compiled(iseq)
  else
    Qnil
  end
end
            
reset_stats!() click to toggle source

Discard statistics collected for –yjit-stats.

 
               # File yjit.rb, line 27
def self.reset_stats!
  Primitive.rb_yjit_reset_stats_bang
end
            
runtime_stats() click to toggle source

Return a hash for statistics generated for the –yjit-stats command line option. Return nil when option is not passed or unavailable.

 
               # File yjit.rb, line 135
def self.runtime_stats
  Primitive.rb_yjit_get_stats
end
            
simulate_oom!() click to toggle source
 
               # File yjit.rb, line 165
def self.simulate_oom!
  Primitive.rb_yjit_simulate_oom_bang
end
            
stats_enabled?() click to toggle source
 
               # File yjit.rb, line 17
def self.stats_enabled?
  Primitive.rb_yjit_stats_enabled_p
end
            
trace_exit_locations_enabled?() click to toggle source

Check if rb_yjit_trace_exit_locations_enabled_p is enabled.

 
               # File yjit.rb, line 22
def self.trace_exit_locations_enabled?
  Primitive.rb_yjit_trace_exit_locations_enabled_p
end
            

Private Class Methods

_print_stats() click to toggle source

Format and print out counters

 
               # File yjit.rb, line 178
def _print_stats
  stats = runtime_stats
  return unless stats

  $stderr.puts("***YJIT: Printing YJIT statistics on exit***")

  print_counters(stats, prefix: 'send_', prompt: 'method call exit reasons: ')
  print_counters(stats, prefix: 'invokesuper_', prompt: 'invokesuper exit reasons: ')
  print_counters(stats, prefix: 'leave_', prompt: 'leave exit reasons: ')
  print_counters(stats, prefix: 'gbpp_', 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: 'oaref_', prompt: 'opt_aref exit reasons: ')
  print_counters(stats, prefix: 'expandarray_', prompt: 'expandarray exit reasons: ')
  print_counters(stats, prefix: 'opt_getinlinecache_', prompt: 'opt_getinlinecache exit reasons: ')
  print_counters(stats, prefix: 'invalidate_', prompt: 'invalidation reasons: ')

  side_exits = total_exit_count(stats)
  total_exits = side_exits + stats[:leave_interp_return]

  # Number of instructions that finish executing in YJIT.
  # See :count-placement: about the subtraction.
  retired_in_yjit = stats[:exec_instruction] - side_exits

  # Average length of instruction sequences executed by YJIT
  avg_len_in_yjit = retired_in_yjit.to_f / total_exits

  # Proportion of instructions that retire in YJIT
  total_insns_count = retired_in_yjit + stats[:vm_insns_count]
  yjit_ratio_pct = 100.0 * retired_in_yjit.to_f / total_insns_count

  # Number of failed compiler invocations
  compilation_failure = stats[:compilation_failure]

  $stderr.puts "bindings_allocations:  " + ("%10d" % stats[:binding_allocations])
  $stderr.puts "bindings_set:          " + ("%10d" % stats[:binding_set])
  $stderr.puts "compilation_failure:   " + ("%10d" % compilation_failure) if compilation_failure != 0
  $stderr.puts "compiled_iseq_count:   " + ("%10d" % stats[:compiled_iseq_count])
  $stderr.puts "compiled_block_count:  " + ("%10d" % stats[:compiled_block_count])
  $stderr.puts "invalidation_count:    " + ("%10d" % stats[:invalidation_count])
  $stderr.puts "constant_state_bumps:  " + ("%10d" % stats[:constant_state_bumps])
  $stderr.puts "inline_code_size:      " + ("%10d" % stats[:inline_code_size])
  $stderr.puts "outlined_code_size:    " + ("%10d" % stats[:outlined_code_size])
  $stderr.puts "num_gc_obj_refs:       " + ("%10d" % stats[:num_gc_obj_refs])

  $stderr.puts "total_exit_count:      " + ("%10d" % total_exits)
  $stderr.puts "total_insns_count:     " + ("%10d" % total_insns_count)
  $stderr.puts "vm_insns_count:        " + ("%10d" % stats[:vm_insns_count])
  $stderr.puts "yjit_insns_count:      " + ("%10d" % stats[:exec_instruction])
  $stderr.puts "ratio_in_yjit:         " + ("%9.1f" % yjit_ratio_pct) + "%"
  $stderr.puts "avg_len_in_yjit:       " + ("%10.1f" % avg_len_in_yjit)

  print_sorted_exit_counts(stats, prefix: "exit_")
end
            
total_exit_count(stats, prefix: "exit_") click to toggle source
 
               # File yjit.rb, line 264
def total_exit_count(stats, prefix: "exit_")
  total = 0
  stats.each do |k,v|
    total += v if k.start_with?(prefix)
  end
  total
end