ruby-prof 0.16.2 → 1.1.0

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

@@ -1,64 +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" % [
-            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 << "\n"
-         else
-           @output << "\n      defined at:\n"
-           @output << "          %s:%s\n" % [File.expand_path(method.source_file), method.line]
-         end
-
-         callers = []
-         method.call_infos.each do |ci|
-           if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
-             callers << [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
-           end
-         end
-         # make sure callers are unique
-         callers.uniq!
-
-         unless callers.empty?
-           @output << "      called from:\n"
-           callers.each do |args|
-             @output << "          %s (%s:%s)\n" % args
-           end
-         end
-         @output << "\n"
-      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 < 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

data/test/block_test.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path("../test_helper", __FILE__)
-
-class BlockMethodTest < 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_block
-    result = RubyProf.profile do
-      1.times { RubyProf::C1.new.hello }
-    end
-
-    # Methods called
-    #  Kernel#sleep
-    #  <Class::BasicObject>#allocate
-    #  #{RubyProf.parent_object}#inizialize
-    #  RubyProf::C1#hello
-    #  Class#new
-    #  Integer#times
-    #  BlockMethodTest#test_block
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(RubyProf.ruby_2? ? 6 : 7, methods.length)
-
-    # Check times
-    assert_equal("BlockMethodTest#test_block", methods[0].full_name)
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0.0, methods[0].wait_time, 0.02)
-    assert_in_delta(0.0, methods[0].self_time, 0.02)
-
-    assert_equal("Integer#times", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0.0, methods[1].wait_time, 0.02)
-    assert_in_delta(0.0, methods[1].self_time, 0.02)
-
-    assert_equal("RubyProf::C1#hello", methods[2].full_name)
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0.0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.0, methods[2].self_time, 0.02)
-
-    assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.2, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.2, methods[3].self_time, 0.01)
-
-    assert_equal("Class#new", methods[4].full_name)
-    assert_in_delta(0.0, methods[4].total_time, 0.01)
-    assert_in_delta(0.0, methods[4].wait_time, 0.01)
-    assert_in_delta(0.0, methods[4].self_time, 0.01)
-
-    # the timing difference between #initialize and #allocate is so small
-    # that we cannot rely on #initialize appearing first.
-    # so switch them, if necessary
-    if methods[5].full_name =~ /#allocate/
-      methods[5], methods[6] = methods[6], methods[5]
-    end
-
-    assert_equal("#{RubyProf.parent_object}#initialize", methods[5].full_name)
-    assert_in_delta(0.0, methods[5].total_time, 0.01)
-    assert_in_delta(0.0, methods[5].wait_time, 0.01)
-    assert_in_delta(0.0, methods[5].self_time, 0.01)
-
-    unless RubyProf.ruby_2?
-      assert_equal("<Class::#{RubyProf.parent_object}>#allocate", methods[6].full_name)
-      assert_in_delta(0.0, methods[6].total_time, 0.01)
-      assert_in_delta(0.0, methods[6].wait_time, 0.01)
-      assert_in_delta(0.0, methods[6].self_time, 0.01)
-    end
-  end
-end

data/test/call_info_test.rb

@@ -1,78 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class CallInfoTest < 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_clone
-#    result = RubyProf.profile do
-#      RubyProf::C1.hello
-#    end
-#
-#    method = result.threads.first.top_methods.first
-#    call_info = method.call_infos.first
-#    call_info_clone = call_info.clone
-#
-##    assert_equal(call_info.target, call_info_clone.target)
-#    assert_equal(call_info.total_time, call_info_clone.total_time)
-#  end
-
-  def test_merge
-    result1 = RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    methods = result1.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
-    assert_in_delta(0, methods[0].wait_time, 0.01)
-    assert_in_delta(0, methods[0].self_time, 0.01)
-    assert_equal(1, methods[0].called)
-
-    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-    assert_equal(1, methods[1].called)
-
-    assert_equal('Kernel#sleep', methods[2].full_name)
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
-    assert_equal(1, methods[2].called)
-
-    RubyProf.profile do
-      RubyProf::C1.hello
-    end
-
-    # Merge the trees
-    methods = result1.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
-
-    assert_equal('CallInfoTest#test_merge', methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
-    assert_in_delta(0, methods[0].wait_time, 0.01)
-    assert_in_delta(0, methods[0].self_time, 0.01)
-    assert_equal(1, methods[0].called)
-
-    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-    assert_equal(1, methods[1].called)
-
-    assert_equal('Kernel#sleep', methods[2].full_name)
-    assert_in_delta(0.1, methods[2].total_time, 0.01)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.1, methods[2].self_time, 0.01)
-    assert_equal(1, methods[2].called)
-  end
-end
-

data/test/issue137_test.rb

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# issue 137 is about correctly attributing time of recursive children
-
-class RecursiveChildrenTest < TestCase
-  class SlowClass
-    def time_sink
-      1234567890 ** 100 == 0
-    end
-  end
-
-  class SlowSearcher
-    def do_find(slow_objects)
-      slow_objects.find(&:time_sink)
-    end
-  end
-
-  class MainClass
-    def self.main_method
-      slow_objects = [SlowClass.new] * 100_000
-      slow_searcher = SlowSearcher.new
-      slow_searcher.do_find(slow_objects)
-    end
-  end
-
-  include PrinterTestHelper
-
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_simple
-    result = RubyProf.profile do
-      # make array each recursive
-      [1].each do
-        MainClass.main_method
-      end
-    end
-
-    # methods = result.threads.first.methods.sort.reverse
-
-    printer = RubyProf::GraphPrinter.new(result)
-
-    buffer = ''
-    printer.print(StringIO.new(buffer))
-
-    puts buffer if ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1"
-
-    parsed_output = MetricsArray.parse(buffer)
-
-    assert( enum_find  = parsed_output.metrics_for("Enumerable#find") )
-    assert( array_each = enum_find.child("Array#each") )
-
-    assert_operator enum_find.metrics.total, :>=, array_each.total
-    assert_operator enum_find.metrics.total, :>, 0
-    assert_in_delta enum_find.metrics.total, array_each.total, 0.02
-  end
-
-end

data/test/measure_cpu_time_test.rb

@@ -1,213 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-class MeasureCpuTimeTest < TestCase
-  def setup
-    RubyProf::measure_mode = RubyProf::CPU_TIME
-  end
-
-  def teardown
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
-  def test_mode
-    assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
-  end
-
-  def test_cpu_time_enabled_defined
-    assert(defined?(RubyProf::CPU_TIME_ENABLED))
-  end
-
-  def test_class_methods
-    result = RubyProf.profile do
-      RubyProf::C7.busy_wait
-    end
-
-    # Length should be greater 2:
-    #   MeasureCpuTimeTest#test_class_methods
-    #   <Class::RubyProf::C1>#busy_wait
-    #   ....
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    # Check the names
-    assert_equal('MeasureCpuTimeTest#test_class_methods', methods[0].full_name)
-    assert_equal('<Class::RubyProf::C7>#busy_wait', methods[1].full_name)
-
-    # Check times
-    assert_in_delta(0.1, methods[0].total_time, 0.05)
-    assert_in_delta(0, methods[0].wait_time, 0.05)
-    assert_in_delta(0, methods[0].self_time, 0.05)
-
-    assert_in_delta(0.1, methods[1].total_time, 0.05)
-    assert_in_delta(0, methods[1].wait_time, 0.05)
-    assert_in_delta(0, methods[1].self_time, 0.05)
-  end
-
-  def test_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C7.new.busy_wait
-    end
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    # Methods at this point:
-    #   MeasureCpuTimeTest#test_instance_methods
-    #   C7#busy_wait
-    #   ...
-
-    names = methods.map(&:full_name)
-    assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
-    assert_equal('RubyProf::C7#busy_wait', names[1])
-
-
-    # Check times
-    assert_in_delta(0.2, methods[0].total_time, 0.03)
-    assert_in_delta(0, methods[0].wait_time, 0.03)
-    assert_in_delta(0, methods[0].self_time, 0.03)
-
-    assert_in_delta(0.2, methods[1].total_time, 0.03)
-    assert_in_delta(0, methods[1].wait_time, 0.03)
-    assert_in_delta(0, methods[1].self_time, 0.2)
-  end
-
-  def test_module_methods
-    result = RubyProf.profile do
-      RubyProf::C8.busy_wait
-    end
-
-    # Methods:
-    #   MeasureCpuTimeTest#test_module_methods
-    #   M1#busy_wait
-    #   ...
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-
-    assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
-    assert_equal('RubyProf::M7#busy_wait', methods[1].full_name)
-
-    # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0, methods[0].wait_time, 0.02)
-    assert_in_delta(0, methods[0].self_time, 0.02)
-
-    assert_in_delta(0.3, methods[1].total_time, 0.1)
-    assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0, methods[1].self_time, 0.1)
-  end
-
-  def test_module_instance_methods
-    result = RubyProf.profile do
-      RubyProf::C8.new.busy_wait
-    end
-
-    # Methods:
-    #   MeasureCpuTimeTest#test_module_instance_methods
-    #   M7#busy_wait
-    #   ...
-
-    methods = result.threads.first.methods.sort.reverse[0..1]
-    assert_equal(2, methods.length)
-    names = methods.map(&:full_name)
-    assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
-    assert_equal('RubyProf::M7#busy_wait', names[1])
-
-    # Check times
-    assert_in_delta(0.3, methods[0].total_time, 0.1)
-    assert_in_delta(0, methods[0].wait_time, 0.1)
-    assert_in_delta(0, methods[0].self_time, 0.1)
-
-    assert_in_delta(0.3, methods[1].total_time, 0.1)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.1)
-  end
-
-  def test_singleton
-    c3 = RubyProf::C3.new
-
-    class << c3
-      def busy_wait
-      end
-    end
-
-    result = RubyProf.profile do
-      c3.busy_wait
-    end
-
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(2, methods.length)
-
-    assert_equal('MeasureCpuTimeTest#test_singleton', methods[0].full_name)
-    assert_equal('<Object::RubyProf::C3>#busy_wait', methods[1].full_name)
-
-    assert_in_delta(0, methods[0].total_time, 0.01)
-    assert_in_delta(0, methods[0].wait_time, 0.01)
-    assert_in_delta(0, methods[0].self_time, 0.01)
-
-    assert_in_delta(0, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-  end
-
-
-  def test_sleeping_does_accumulate_wall_time
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    result = RubyProf.profile do
-      sleep 0.1
-    end
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_accumulate_wall_time", "Kernel#sleep"], methods.map(&:full_name))
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_equal(0, methods[1].wait_time)
-    assert_in_delta(0.1, methods[1].self_time, 0.01)
-  end
-
-  def test_sleeping_does_not_accumulate_significant_cpu_time
-    result = RubyProf.profile do
-      sleep 0.1
-    end
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(["MeasureCpuTimeTest#test_sleeping_does_not_accumulate_significant_cpu_time", "Kernel#sleep"], methods.map(&:full_name))
-    assert_in_delta(0, methods[1].total_time, 0.01)
-    assert_equal(0, methods[1].wait_time)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-  end
-
-  def test_waiting_for_threads_does_not_accumulate_cpu_time
-    background_thread = nil
-    result = RubyProf.profile do
-      background_thread = Thread.new{ sleep 0.1 }
-      background_thread.join
-    end
-    # check number of threads
-    assert_equal(2, result.threads.length)
-    fg, bg = result.threads
-    assert(fg.methods.map(&:full_name).include?("Thread#join"))
-    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
-    assert_in_delta(0, fg.total_time, 0.01)
-    assert_in_delta(0, bg.total_time, 0.01)
-  end
-
-  def test_waiting_for_threads_does_accumulate_wall_time
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    background_thread = nil
-    result = RubyProf.profile do
-      background_thread = Thread.new{ sleep 0.1 }
-      background_thread.join
-    end
-    # check number of threads
-    assert_equal(2, result.threads.length)
-    fg, bg = result.threads
-    assert(fg.methods.map(&:full_name).include?("Thread#join"))
-    assert(bg.methods.map(&:full_name).include?("Kernel#sleep"))
-    assert_in_delta(0.1, fg.total_time, 0.01)
-    assert_in_delta(0.1, fg.wait_time, 0.01)
-    assert_in_delta(0.1, bg.total_time, 0.01)
-  end
-
-end