ruby-prof 0.13.1 → 1.4.2

data/ext/ruby_prof/version.h

@@ -1,7 +0,0 @@
-/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#define RUBY_PROF_VERSION  "0.13.1" // as a string, for easy parsing from rake files
-#define RUBY_PROF_VERSION_MAJ   0
-#define RUBY_PROF_VERSION_MIN   13
-#define RUBY_PROF_VERSION_MIC   1

data/lib/ruby-prof/aggregate_call_info.rb

@@ -1,72 +0,0 @@
-# encoding: utf-8
-
-module RubyProf
-  class AggregateCallInfo
-    attr_reader :call_infos
-
-    def initialize(call_infos)
-      if call_infos.length == 0
-        raise(ArgumentError, "Must specify at least one call info.")
-      end
-      @call_infos = call_infos
-    end
-
-    def target
-      call_infos.first.target
-    end
-
-    def parent
-      call_infos.first.parent
-    end
-
-    def line
-      call_infos.first.line
-    end
-
-    def children
-      call_infos.inject(Array.new) do |result, call_info|
-        result.concat(call_info.children)
-      end
-    end
-
-    def total_time
-      aggregate_without_recursion(:total_time)
-    end
-
-    def self_time
-      aggregate_without_recursion(:self_time)
-    end
-
-    def wait_time
-      aggregate_without_recursion(:wait_time)
-    end
-
-    def children_time
-      aggregate_without_recursion(:children_time)
-    end
-
-    def called
-      aggregate(:called)
-    end
-
-    def to_s
-      "#{call_infos.first.target.full_name}"
-    end
-
-    private
-
-    def aggregate(method_name)
-      self.call_infos.inject(0) do |sum, call_info|
-        sum += call_info.send(method_name)
-        sum
-      end
-    end
-
-    def aggregate_without_recursion(method_name)
-      self.call_infos.inject(0) do |sum, call_info|
-        sum += call_info.send(method_name) unless call_info.recursive
-        sum
-      end
-    end
-  end
-end

data/lib/ruby-prof/call_info.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-module RubyProf
-  class CallInfo
-    attr_accessor :recursive
-
-    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 to_s
-      "#{self.target.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, ct: #{self.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,44 +0,0 @@
-# The call info visitor class does a depth-first traversal
-# across a thread's call stack.  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)
-#
-#   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
-    attr_reader :block, :thread
-
-    def initialize(thread)
-      @thread = thread
-    end
-
-    def visit(&block)
-      @block = block
-
-      self.thread.top_methods.each do |method_info|
-        method_info.call_infos.each do |call_info|
-          self.visit_call_info(call_info)
-        end
-      end
-    end
-
-    def visit_call_info(call_info)
-      self.block.call(call_info, :enter)
-      call_info.children.each do |child|
-        visit_call_info(child)
-      end
-      self.block.call(call_info, :exit)
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-module RubyProf
-  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
-  # To use the flat printer with line numbers:
-  #
-  #   result = RubyProf.profile do
-  #     [code to profile]
-  #   end
-  #
-  #   printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
-  #   printer.print(STDOUT, {})
-  #
-  class FlatPrinterWithLineNumbers < FlatPrinter
-    def print_methods(thread)
-      total_time = thread.total_time
-
-      methods = thread.methods.sort_by(&sort_method).reverse
-      sum = 0
-      methods.each do |method|
-        self_percent = (method.self_time / total_time) * 100
-        next if self_percent < min_percent
-
-        sum += method.self_time
-        #self_time_called = method.called > 0 ? method.self_time/method.called : 0
-        #total_time_called = method.called > 0? method.total_time/method.called : 0
-
-        @output << "%6.2f  %9.3f %9.3f %9.3f %9.3f %8d  %s%s \n" % [
-            method.self_time / total_time * 100, # %self
-            method.total_time,                   # total
-            method.self_time,                    # self
-            method.wait_time,                    # wait
-            method.children_time,                # children
-            method.called,                       # calls
-            method.recursive? ? "*" : " ",       # cycle
-            method_name(method)                  # name
-        ]
-         if method.source_file != 'ruby_runtime'
-           @output << "  %s:%s" % [File.expand_path(method.source_file), method.line]
-         end
-         @output << "\n\tcalled from: "
-
-         # make sure they're unique
-         method.call_infos.map{|ci|
-           if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
-              [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
-           else
-              nil
-           end
-         }.compact.uniq.each{|args|
-             @output << " %s (%s:%s) " % args
-         }
-         @output << "\n\n"
-      end
-    end
-  end
-end

data/lib/ruby-prof/test.rb

@@ -1,150 +0,0 @@
-# encoding: utf-8
-
-# Now load ruby-prof and away we go
-require 'fileutils'
-require 'ruby-prof'
-require 'benchmark'
-
-module RubyProf
-  module Test
-    PROFILE_OPTIONS = {
-      :measure_modes => [RubyProf::PROCESS_TIME],
-      :count => 10,
-      :printers => [RubyProf::FlatPrinter, RubyProf::GraphHtmlPrinter],
-      :min_percent => 0.05,
-      :output_dir => Dir.pwd }
-
-    def output_dir
-      PROFILE_OPTIONS[:output_dir]
-    end
-
-    def run(result)
-      return if @method_name.to_s == "default_test"
-
-      yield(self.class::STARTED, name)
-      @_result = result
-      run_warmup
-      PROFILE_OPTIONS[:measure_modes].each do |measure_mode|
-        data = run_profile(measure_mode)
-        report_profile(data, measure_mode)
-        result.add_run
-      end
-      yield(self.class::FINISHED, name)
-    end
-
-    def run_test
-      begin
-        setup
-        yield
-      rescue ::Test::Unit::AssertionFailedError => e
-        add_failure(e.message, e.backtrace)
-      rescue StandardError, ScriptError
-        add_error($!)
-      ensure
-        begin
-          teardown
-        rescue ::Test::Unit::AssertionFailedError => e
-          add_failure(e.message, e.backtrace)
-        rescue StandardError, ScriptError
-          add_error($!)
-        end
-      end
-    end
-
-    def run_warmup
-      print "\n#{self.class.name}##{method_name}"
-
-      run_test do
-        bench = Benchmark.realtime do
-          __send__(@method_name)
-        end
-        puts " (%.2fs warmup)" % bench
-      end
-    end
-
-    def run_profile(measure_mode)
-      RubyProf.measure_mode = measure_mode
-
-      print '  '
-      PROFILE_OPTIONS[:count].times do |i|
-        run_test do
-          begin
-            print '.'
-            $stdout.flush
-            GC.disable
-
-            RubyProf.resume do
-              __send__(@method_name)
-            end
-          ensure
-            GC.enable
-          end
-        end
-      end
-
-      data = RubyProf.stop
-      bench = data.threads.values.inject(0) do |total, method_infos|
-        top = method_infos.max
-        total += top.total_time
-        total
-      end
-
-      puts "\n  #{measure_mode_name(measure_mode)}: #{format_profile_total(bench, measure_mode)}\n"
-
-      data
-    end
-
-    def format_profile_total(total, measure_mode)
-      case measure_mode
-        when RubyProf::PROCESS_TIME, RubyProf::WALL_TIME
-          "%.2f seconds" % total
-        when RubyProf::MEMORY
-          "%.2f kilobytes" % total
-        when RubyProf::ALLOCATIONS
-          "%d allocations" % total
-        else
-          "%.2f #{measure_mode}"
-      end
-    end
-
-    def report_profile(data, measure_mode)
-      PROFILE_OPTIONS[:printers].each do |printer_klass|
-        printer = printer_klass.new(data)
-
-        # Makes sure the output directory exits
-        FileUtils.mkdir_p(output_dir)
-
-        # Open the file
-        file_name = report_filename(printer, measure_mode)
-
-        File.open(file_name, 'wb') do |file|
-          printer.print(file, PROFILE_OPTIONS)
-        end
-      end
-    end
-
-    # The report filename is test_name + measure_mode + report_type
-    def report_filename(printer, measure_mode)
-      suffix =
-        case printer
-          when RubyProf::FlatPrinter; 'flat.txt'
-          when RubyProf::GraphPrinter; 'graph.txt'
-          when RubyProf::GraphHtmlPrinter; 'graph.html'
-          when RubyProf::CallTreePrinter; 'tree.txt'
-          else printer.to_s.downcase
-        end
-
-      "#{output_dir}/#{method_name}_#{measure_mode_name(measure_mode)}_#{suffix}"
-    end
-
-    def measure_mode_name(measure_mode)
-      case measure_mode
-        when RubyProf::PROCESS_TIME; 'process_time'
-        when RubyProf::WALL_TIME; 'wall_time'
-        when RubyProf::MEMORY; 'memory'
-        when RubyProf::ALLOCATIONS; 'allocations'
-        else "measure#{measure_mode}"
-      end
-    end
-  end
-end

data/test/aggregate_test.rb

@@ -1,136 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#   A   B   C
-#   |   |   |
-#   Z   A   A
-#       |   |
-#       Z   Z
-
-class AggClass
-  def z
-    sleep 1
-  end
-
-  def a
-    z
-  end
-
-  def b
-    a
-  end
-
-  def c
-    a
-  end
-end
-
-class AggregateTest < Test::Unit::TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_all_call_infos_are_not_recursive
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-    methods = result.threads.first.methods.sort.reverse
-    methods.each do |m|
-      m.call_infos.each do |ci|
-        assert(!ci.recursive)
-      end
-    end
-  end
-
-  def test_call_infos
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
-
-    # Check AggClass#z
-    assert_equal('AggClass#z', method.full_name)
-    assert_equal(3, method.called)
-    assert_in_delta(3, method.total_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(3, method.children_time, 0.05)
-    assert_equal(3, method.call_infos.length)
-
-    call_info = method.call_infos[0]
-    assert_equal('AggregateTest#test_call_infos->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    call_info = method.call_infos[1]
-    assert_equal('AggregateTest#test_call_infos->AggClass#b->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-
-    call_info = method.call_infos[2]
-    assert_equal('AggregateTest#test_call_infos->AggClass#c->AggClass#a->AggClass#z', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-  end
-
-  def test_aggregates_parents
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
-
-    # Check AggClass#z
-    assert_equal('AggClass#z', method.full_name)
-
-    call_infos = method.aggregate_parents
-    assert_equal(1, call_infos.length)
-
-    call_info = call_infos.first
-    assert_equal('AggClass#a', call_info.parent.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.05)
-    assert_in_delta(0, call_info.self_time, 0.05)
-    assert_in_delta(3, call_info.children_time, 0.05)
-    assert_equal(3, call_info.called)
-  end
-
-  def test_aggregates_children
-    c1 = AggClass.new
-    result = RubyProf.profile do
-      c1.a
-      c1.b
-      c1.c
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
-
-    # Check AggClass#a
-    assert_equal('AggClass#a', method.full_name)
-
-    call_infos = method.aggregate_children
-    assert_equal(1, call_infos.length)
-
-    call_info = call_infos.first
-    assert_equal('AggClass#z', call_info.target.full_name)
-    assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.05)
-    assert_in_delta(0, call_info.self_time, 0.05)
-    assert_in_delta(3, call_info.children_time, 0.05)
-    assert_equal(3, call_info.called)
-  end
-end