ruby-prof 0.17.0 → 0.18.0

data/lib/ruby-prof/call_info.rb

@@ -1,115 +1,115 @@
-# encoding: utf-8
-
-module RubyProf
-  class CallInfo
-    # part of this class is defined in C code.
-    # it provides the following attributes pertaining to tree structure:
-    # depth:      tree level (0 == root)
-    # parent:     parent call info (can be nil)
-    # children:   array of call info children (can be empty)
-    # target:     method info (containing an array of call infos)
-
-    def children_time
-      children.inject(0) do |sum, call_info|
-        sum += call_info.total_time
-      end
-    end
-
-    def stack
-      @stack ||= begin
-        methods = Array.new
-        call_info = self
-
-        while call_info
-          methods << call_info.target
-          call_info = call_info.parent
-        end
-        methods.reverse
-      end
-    end
-
-    def call_sequence
-      @call_sequence ||= begin
-        stack.map {|method| method.full_name}.join('->')
-      end
-    end
-
-    def root?
-      self.parent.nil?
-    end
-
-    def descendent_of(other)
-      p = self.parent
-      while p && p != other && p.depth > other.depth
-        p = p.parent
-      end
-      p == other
-    end
-
-    def self.roots_of(call_infos)
-      roots = []
-      sorted = call_infos.sort_by(&:depth).reverse
-      while call_info = sorted.shift
-        roots << call_info unless sorted.any?{|p| call_info.descendent_of(p)}
-      end
-      roots
-    end
-
-    def to_s
-      "#{target.full_name} (c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
-    end
-
-    def inspect
-      super + "(#{target.full_name}, d: #{depth}, c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
-    end
-
-    # eliminate call info from the call tree.
-    # adds self and wait time to parent and attaches called methods to parent.
-    # merges call trees for methods called from both praent end self.
-    def eliminate!
-      # puts "eliminating #{self}"
-      return unless parent
-      parent.add_self_time(self)
-      parent.add_wait_time(self)
-      children.each do |kid|
-        if call = parent.find_call(kid)
-          call.merge_call_tree(kid)
-        else
-          parent.children << kid
-          # $stderr.puts "setting parent of #{kid}\nto #{parent}"
-          kid.parent = parent
-        end
-      end
-      parent.children.delete(self)
-    end
-
-    # find a specific call in list of children. returns nil if not found.
-    # note: there can't be more than one child with a given target method. in other words:
-    # x.children.grep{|y|y.target==m}.size <= 1 for all method infos m and call infos x
-    def find_call(other)
-      matching = children.select { |kid| kid.target == other.target }
-      raise "inconsistent call tree" unless matching.size <= 1
-      matching.first
-    end
-
-    # merge two call trees. adds self, wait, and total time of other to self and merges children of other into children of self.
-    def merge_call_tree(other)
-      # $stderr.puts "merging #{self}\nand #{other}"
-      self.called += other.called
-      add_self_time(other)
-      add_wait_time(other)
-      add_total_time(other)
-      other.children.each do |other_kid|
-        if kid = find_call(other_kid)
-          # $stderr.puts "merging kids"
-          kid.merge_call_tree(other_kid)
-        else
-          other_kid.parent = self
-          children << other_kid
-        end
-      end
-      other.children.clear
-      other.target.call_infos.delete(other)
-    end
-  end
-end
+# encoding: utf-8
+
+module RubyProf
+  class CallInfo
+    # part of this class is defined in C code.
+    # it provides the following attributes pertaining to tree structure:
+    # depth:      tree level (0 == root)
+    # parent:     parent call info (can be nil)
+    # children:   array of call info children (can be empty)
+    # target:     method info (containing an array of call infos)
+
+    def children_time
+      children.inject(0) do |sum, call_info|
+        sum += call_info.total_time
+      end
+    end
+
+    def stack
+      @stack ||= begin
+        methods = Array.new
+        call_info = self
+
+        while call_info
+          methods << call_info.target
+          call_info = call_info.parent
+        end
+        methods.reverse
+      end
+    end
+
+    def call_sequence
+      @call_sequence ||= begin
+        stack.map {|method| method.full_name}.join('->')
+      end
+    end
+
+    def root?
+      self.parent.nil?
+    end
+
+    def descendent_of(other)
+      p = self.parent
+      while p && p != other && p.depth > other.depth
+        p = p.parent
+      end
+      p == other
+    end
+
+    def self.roots_of(call_infos)
+      roots = []
+      sorted = call_infos.sort_by(&:depth).reverse
+      while call_info = sorted.shift
+        roots << call_info unless sorted.any?{|p| call_info.descendent_of(p)}
+      end
+      roots
+    end
+
+    def to_s
+      "#{target.full_name} (c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
+    end
+
+    def inspect
+      super + "(#{target.full_name}, d: #{depth}, c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
+    end
+
+    # eliminate call info from the call tree.
+    # adds self and wait time to parent and attaches called methods to parent.
+    # merges call trees for methods called from both praent end self.
+    def eliminate!
+      # puts "eliminating #{self}"
+      return unless parent
+      parent.add_self_time(self)
+      parent.add_wait_time(self)
+      children.each do |kid|
+        if call = parent.find_call(kid)
+          call.merge_call_tree(kid)
+        else
+          parent.children << kid
+          # $stderr.puts "setting parent of #{kid}\nto #{parent}"
+          kid.parent = parent
+        end
+      end
+      parent.children.delete(self)
+    end
+
+    # find a specific call in list of children. returns nil if not found.
+    # note: there can't be more than one child with a given target method. in other words:
+    # x.children.grep{|y|y.target==m}.size <= 1 for all method infos m and call infos x
+    def find_call(other)
+      matching = children.select { |kid| kid.target == other.target }
+      raise "inconsistent call tree" unless matching.size <= 1
+      matching.first
+    end
+
+    # merge two call trees. adds self, wait, and total time of other to self and merges children of other into children of self.
+    def merge_call_tree(other)
+      # $stderr.puts "merging #{self}\nand #{other}"
+      self.called += other.called
+      add_self_time(other)
+      add_wait_time(other)
+      add_total_time(other)
+      other.children.each do |other_kid|
+        if kid = find_call(other_kid)
+          # $stderr.puts "merging kids"
+          kid.merge_call_tree(other_kid)
+        else
+          other_kid.parent = self
+          children << other_kid
+        end
+      end
+      other.children.clear
+      other.target.call_infos.delete(other)
+    end
+  end
+end

data/lib/ruby-prof/call_info_visitor.rb

@@ -1,40 +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
+# 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

@@ -1,178 +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)
-    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
+# 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