ruby-prof 0.18.0-x64-mingw32

data/lib/ruby-prof/call_info_visitor.rb

@@ -0,0 +1,40 @@
+# The call info visitor class does a depth-first traversal across a
+# list of method infos. At each call_info node, the visitor executes
+# the block provided in the #visit method. The block is passed two
+# parameters, the event and the call_info instance. Event will be
+# either :enter or :exit.
+#
+#   visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
+#
+#   method_names = Array.new
+#
+#   visitor.visit do |call_info, event|
+#     method_names << call_info.target.full_name if event == :enter
+#   end
+#
+#   puts method_names
+
+module RubyProf
+  class CallInfoVisitor
+
+    def initialize(call_infos)
+      @call_infos = CallInfo.roots_of(call_infos)
+    end
+
+    def visit(&block)
+      @call_infos.each do |call_info|
+        visit_call_info(call_info, &block)
+      end
+    end
+
+    private
+    def visit_call_info(call_info, &block)
+      yield call_info, :enter
+      call_info.children.each do |child|
+        visit_call_info(child, &block)
+      end
+      yield call_info, :exit
+    end
+  end
+
+end

data/lib/ruby-prof/compatibility.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+# These methods are here for backwards compatability with previous RubyProf releases
+module RubyProf
+  # Measurements
+  def self.cpu_frequency
+    Measure::CpuTime.frequency
+  end
+
+  def self.measure_allocations
+    Measure::Allocations.measure
+  end
+
+  def self.measure_cpu_time
+    Measure::CpuTime.measure
+  end
+
+  def self.measure_gc_runs
+    Measure::GcRuns.measure
+  end
+
+  def self.measure_gc_time
+    Measure::GcTime.measure
+  end
+
+  def self.measure_memory
+    Measure::Memory.measure
+  end
+
+  def self.measure_process_time
+    Measure::ProcessTime.measure
+  end
+
+  def self.measure_wall_time
+    Measure::WallTime.measure
+  end
+
+  # call-seq:
+  # measure_mode -> measure_mode
+  #
+  # Returns what ruby-prof is measuring.  Valid values include:
+  #
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+
+  def self.measure_mode
+    @measure_mode ||= RubyProf::WALL_TIME
+  end
+
+  # call-seq:
+  # measure_mode=value -> void
+  #
+  # Specifies what ruby-prof should measure.  Valid values include:
+  #
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  def self.measure_mode=(value)
+    @measure_mode = value
+  end
+
+  def self.measure_mode_string
+    case measure_mode
+    when WALL_TIME    then "wall_time"
+    when CPU_TIME     then "cpu_time"
+    when PROCESS_TIME then "process_time_time"
+    when ALLOCATIONS  then "allocations"
+    when MEMORY       then "memory"
+    when GC_TIME      then "gc_time"
+    when GC_RUNS      then "gc_runs"
+    end
+  end
+
+  # call-seq:
+  # exclude_threads -> exclude_threads
+  #
+  # Returns threads ruby-prof should exclude from profiling
+
+  def self.exclude_threads
+    @exclude_threads ||= Array.new
+  end
+
+  # call-seq:
+  # exclude_threads= -> void
+  #
+  # Specifies what threads ruby-prof should exclude from profiling
+
+  def self.exclude_threads=(value)
+    @exclude_threads = value
+  end
+
+  # Profiling
+  def self.start_script(script)
+    start
+    load script
+  end
+
+  def self.start
+    ensure_not_running!
+    @profile = Profile.new(measure_mode: measure_mode, exclude_threads: exclude_threads)
+    enable_gc_stats_if_needed
+    @profile.start
+  end
+
+  def self.pause
+    ensure_running!
+    disable_gc_stats_if_needed
+    @profile.pause
+  end
+
+  def self.running?
+    if defined?(@profile) and @profile
+      @profile.running?
+    else
+      false
+    end
+  end
+
+  def self.resume
+    ensure_running!
+    enable_gc_stats_if_needed
+    @profile.resume
+  end
+
+  def self.stop
+    ensure_running!
+    result = @profile.stop
+    disable_gc_stats_if_needed
+    @profile = nil
+    result
+  end
+
+  # Profile a block
+  def self.profile(options = {}, &block)
+    ensure_not_running!
+    gc_stat_was_enabled = enable_gc_stats_if_needed
+    options = { measure_mode: measure_mode, exclude_threads: exclude_threads }.merge!(options)
+    result = Profile.profile(options, &block)
+  ensure
+    disable_gc_stats_if_needed(gc_stat_was_enabled)
+    result
+  end
+
+
+private
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  end
+
+  def self.ensure_not_running!
+    raise(RuntimeError, "RubyProf is already running") if running?
+  end
+
+  # for GC.allocated_size to work GC statistics should be enabled
+  def self.enable_gc_stats_if_needed
+    if measure_mode_requires_gc_stats_enabled?
+      @gc_stat_was_enabled = GC.enable_stats
+    end
+  end
+
+  def self.disable_gc_stats_if_needed(was_enabled=nil)
+    was_enabled ||= defined?(@gc_stat_was_enabled) && @gc_stat_was_enabled
+    GC.disable_stats if measure_mode_requires_gc_stats_enabled? && !was_enabled
+  end
+
+  def self.measure_mode_requires_gc_stats_enabled?
+    GC.respond_to?(:enable_stats) &&
+      [RubyProf::MEMORY, RubyProf::GC_TIME, RubyProf::GC_RUNS].include?(measure_mode)
+  end
+end

data/lib/ruby-prof/method_info.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module RubyProf
+  class MethodInfo
+    include Comparable
+
+    def <=>(other)
+      if self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      elsif self.min_depth < other.min_depth
+        1
+      elsif self.min_depth > other.min_depth
+        -1
+      else
+        self.full_name <=> other.full_name
+      end
+    end
+
+    def called
+      @called ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum + call_info.called
+        end
+      end
+    end
+
+    def total_time
+      @total_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.total_time if !call_info.recursive?
+          sum
+        end
+      end
+    end
+
+    def self_time
+      @self_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.self_time if !call_info.recursive?
+          sum
+        end
+      end
+    end
+
+    def wait_time
+      @wait_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.wait_time if !call_info.recursive?
+          sum
+        end
+      end
+    end
+
+    def children_time
+      @children_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.children_time if !call_info.recursive?
+          sum
+        end
+      end
+    end
+
+    def min_depth
+      @min_depth ||= call_infos.map(&:depth).min
+    end
+
+    def root?
+      @root ||= begin
+        call_infos.find do |call_info|
+          not call_info.root?
+        end.nil?
+      end
+    end
+
+    def children
+      @children ||= call_infos.map(&:children).flatten
+    end
+
+    def parents
+      @parents ||= call_infos.map(&:parent)
+    end
+
+    def aggregate_parents
+      # group call infos based on their parents
+      groups = self.call_infos.each_with_object({}) do |call_info, hash|
+        key = call_info.parent ? call_info.parent.target : self
+        (hash[key] ||= []) << call_info
+      end
+
+      groups.map do |key, value|
+        AggregateCallInfo.new(value, self)
+      end
+    end
+
+    def aggregate_children
+      # group call infos based on their targets
+      groups = self.children.each_with_object({}) do |call_info, hash|
+        key = call_info.target
+        (hash[key] ||= []) << call_info
+      end
+
+      groups.map do |key, value|
+        AggregateCallInfo.new(value, self)
+      end
+    end
+
+    def to_s
+      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
+    end
+
+    # remove method from the call graph. should not be called directly.
+    def eliminate!
+      # $stderr.puts "eliminating #{self}"
+      call_infos.each{ |call_info| call_info.eliminate! }
+      call_infos.clear
+    end
+
+  end
+end

data/lib/ruby-prof/printers/abstract_printer.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module RubyProf
+  class AbstractPrinter
+    # Create a new printer.
+    #
+    # result should be the output generated from a profiling run
+    def initialize(result)
+      @result = result
+      @output = nil
+    end
+
+    # Specify print options.
+    #
+    # options - Hash table
+    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #                  %self (the methods self time divided by the
+    #                  overall total time) that a method must take
+    #                  for it to be printed out in the report.
+    #                  Default value is 0.
+    #
+    #   :print_file  - True or false. Specifies if a method's source
+    #                  file should be printed.  Default value if false.
+    #
+    #   :sort_method - Specifies method used for sorting method infos.
+    #                  Available values are :total_time, :self_time,
+    #                  :wait_time, :children_time
+    #                  Default value is :total_time
+    #    :editor_uri - Specifies editor uri scheme used for opening files
+    #                  e.g. :atm or :mvim. For OS X default is :txmt.
+    #                  Pass false to print bare filenames.
+    #                  Use RUBY_PROF_EDITOR_URI environment variable to override.
+    def setup_options(options = {})
+      @options = options
+    end
+
+    def min_percent
+      @options[:min_percent] || 0
+    end
+
+    def print_file
+      @options[:print_file] || false
+    end
+
+    def sort_method
+      @options[:sort_method] || :total_time
+    end
+
+    def editor_uri
+      if ENV.key?('RUBY_PROF_EDITOR_URI')
+        ENV['RUBY_PROF_EDITOR_URI'] || false
+      elsif @options.key?(:editor_uri)
+        @options[:editor_uri]
+      else
+        RUBY_PLATFORM =~ /darwin/ ? 'txmt' : false
+      end
+    end
+
+    def method_name(method)
+      name = method.full_name
+      if print_file
+        name += " (#{method.source_file}:#{method.line}}"
+      end
+      name
+    end
+
+    # Print a profiling report to the provided output.
+    #
+    # output - Any IO object, including STDOUT or a file.
+    # The default value is STDOUT.
+    #
+    # options - Hash of print options.  See #setup_options
+    # for more information.  Note that each printer can
+    # define its own set of options.
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      print_threads
+    end
+
+    def print_threads
+      @result.threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def print_thread(thread)
+      print_header(thread)
+      print_methods(thread)
+      print_footer(thread)
+    end
+
+    def print_header(thread)
+    end
+
+    def print_footer(thread)
+    end
+
+    # whether this printer need a :path option pointing to a directory
+    def self.needs_dir?
+      false
+    end
+  end
+end

data/lib/ruby-prof/printers/call_info_printer.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RubyProf
+  # Prints out the call graph based on CallInfo instances. This
+  # is mainly for debugging purposes as it provides access into
+  # into RubyProf's internals.
+
+  class CallInfoPrinter < AbstractPrinter
+    TIME_WIDTH = 0
+
+    private
+
+    def print_header(thread)
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Fiber ID: #{thread.fiber_id}\n"
+      @output << "Total Time: #{thread.total_time}\n"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      visitor = CallInfoVisitor.new(thread.top_call_infos)
+
+      visitor.visit do |call_info, event|
+        if event == :enter
+          @output << "  " * call_info.depth
+          @output << call_info.target.full_name
+          @output << " ("
+          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.total_time)}, "
+          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_info.self_time)}, "
+          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.wait_time)}, "
+          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_info.children_time)}, "
+          @output << "call:#{call_info.called}, "
+          @output << "rec:#{call_info.recursive?}"
+          @output << ")"
+          @output << "\n"
+        end
+      end
+    end
+  end
+end