ruby-prof 0.18.0 → 1.2.0

data/test/printing_recursive_graph_test.rb

@@ -25,45 +25,43 @@ end
 # --- expected test output ---
 =begin
 Measure Mode: wall_time
-Thread ID: 70238775664960
-Fiber ID: 70238784046840
-Total Time: 2.040249824523926
-Sort by: total_time
+Thread ID: 1307675084040
+Fiber ID: 1307708787440
+Total Time: 2.0939999999973224
+Sort by:
 
-  %total   %self      total       self       wait      child            calls    Name
+  %total   %self      total       self       wait      child            calls     name
 --------------------------------------------------------------------------------
- 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PrintingRecursiveGraphTest#setup
-                      2.040      0.000      0.000      2.040              1/1      PRGT#run
+                      1.657      0.000      0.000      1.657              2/2     Integer#times
+  79.13%   0.00%      1.657      0.000      0.000      1.657                2     PRGT#g
+                      1.657      0.000      0.000      1.657              2/5     Integer#times
 --------------------------------------------------------------------------------
-                      2.040      0.000      0.000      2.040              1/1      PrintingRecursiveGraphTest#setup
- 100.00%   0.00%      2.040      0.000      0.000      2.040                1      PRGT#run
-                      2.040      0.000      0.000      2.040              1/5      Integer#times
+                      2.094      2.094      0.000      0.000            12/12     Integer#times
+ 100.00% 100.00%      2.094      2.094      0.000      0.000               12     Kernel#sleep
 --------------------------------------------------------------------------------
-                      0.409      0.000      0.000      0.409              2/5      Prgt#f
-                      1.631      0.000      0.000      1.631              2/5      PRGT#g
-                      2.040      0.000      0.000      2.040              1/5      PRGT#run
- 100.00%   0.00%      2.040      0.000      0.000      2.040                5     *Integer#times
-                      2.040      2.040      0.000      0.000            12/12      Kernel#sleep
-                      1.631      0.000      0.000      1.631              2/2      PRGT#g
-                      0.409      0.000      0.000      0.409              2/2      PRGT#f
+                      0.437      0.000      0.000      0.437              2/2     Integer#times
+  20.87%   0.00%      0.437      0.000      0.000      0.437                2     PRGT#f
+                      0.437      0.000      0.000      0.437              2/5     Integer#times
 --------------------------------------------------------------------------------
-                      2.040      2.040      0.000      0.000            12/12      Integer#times
-  99.99%  99.99%      2.040      2.040      0.000      0.000               12      Kernel#sleep
+                      0.437      0.000      0.000      0.437              2/5     PRGT#f
+                      1.657      0.000      0.000      1.657              2/5     PRGT#g
+                      2.094      0.000      0.000      2.094              1/5     PRGT#run
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                5    *Integer#times
+                      2.094      2.094      0.000      0.000            12/12     Kernel#sleep
+                      1.657      0.000      0.000      1.657              2/2     PRGT#g
+                      0.437      0.000      0.000      0.437              2/2     PRGT#f
 --------------------------------------------------------------------------------
-                      1.631      0.000      0.000      1.631              2/2      Integer#times
-  79.94%   0.00%      1.631      0.000      0.000      1.631                2      PRGT#g
-                      1.631      0.000      0.000      1.631              2/5      Integer#times
+                      2.094      0.000      0.000      2.094              1/1     PrintingRecursiveGraphTest#setup
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PRGT#run
+                      2.094      0.000      0.000      2.094              1/5     Integer#times
 --------------------------------------------------------------------------------
-                      0.409      0.000      0.000      0.409              2/2      Integer#times
-  20.05%   0.00%      0.409      0.000      0.000      0.409                2      PRGT#f
-                      0.409      0.000      0.000      0.409              2/5      Integer#times
+ 100.00%   0.00%      2.094      0.000      0.000      2.094                1     PrintingRecursiveGraphTest#setup
+                      2.094      0.000      0.000      2.094              1/1     PRGT#run
 
 * indicates recursively called methods
 =end
 
 class PrintingRecursiveGraphTest < TestCase
-  include PrinterTestHelper
-
   def setup
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
     RubyProf::measure_mode = RubyProf::WALL_TIME
@@ -74,54 +72,10 @@ class PrintingRecursiveGraphTest < TestCase
 
   def test_printing_rescursive_graph
     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( integer_times  = parsed_output.metrics_for("*Integer#times") )
-
-    actual_parents = integer_times.parents.map(&:name)
-    expected_parents = %w(PRGT#f PRGT#g PRGT#run)
-    assert_equal expected_parents, actual_parents
-
-    actual_children = integer_times.children.map(&:name)
-    expected_children = %w(Kernel#sleep PRGT#g PRGT#f)
-    assert_equal expected_children, actual_children
-
-    assert( fp = integer_times.parent("PRGT#f") )
-    assert_in_delta(fp.total, fp.child, 0.01)
-    assert_equal("2/5", fp.calls)
-
-    assert( gp = integer_times.parent("PRGT#g") )
-    assert_in_delta(gp.total, gp.child, 0.01)
-    assert_equal("2/5", gp.calls)
-
-    assert( rp = integer_times.parent("PRGT#run") )
-    assert_in_delta(rp.total, rp.child, 0.01)
-    assert_equal("1/5", rp.calls)
-
-    assert_in_delta(4*fp.total, gp.total, 0.05)
-    assert_in_delta(fp.total + gp.total, rp.total, 0.05)
-    assert_in_delta(integer_times.metrics.total, rp.total, 0.05)
-
-    assert( fc = integer_times.child("PRGT#f") )
-    assert_in_delta(fc.total, fc.child, 0.01)
-    assert_equal("2/2", fc.calls)
-
-    assert( gc = integer_times.child("PRGT#g") )
-    assert_in_delta(gc.total, gc.child, 0.01)
-    assert_equal("2/2", gc.calls)
-
-    assert( ks = integer_times.child("Kernel#sleep") )
-    assert_in_delta(ks.total, ks.self_t, 0.01)
-    assert_equal("12/12", ks.calls)
-
-    assert_in_delta(4*fc.total, gc.total, 0.05)
-    assert_in_delta(fp.total + gc.total, ks.total, 0.05)
-    assert_in_delta(integer_times.metrics.total, ks.total, 0.05)
+    refute_nil(buffer)
   end
 end

data/test/recursive_test.rb

@@ -7,12 +7,10 @@ module SimpleRecursion
   # Simple recursive test
   def simple(n)
     sleep(1)
-    n -= 1
     return if n == 0
-    simple(n)
+    simple(n-1)
   end
 
-
   # More complicated recursive test
   def render_partial(i)
     sleep(1)
@@ -44,12 +42,9 @@ class RecursiveTest < TestCase
 
   def test_simple
     result = RubyProf.profile do
-      simple(2)
+      simple(1)
     end
 
-    # Remove Fixnum+, Fixnum== for less than Ruby 1.9
-    result.eliminate_methods!(%w(Fixnum#== Fixnum#-))
-
     methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
@@ -57,56 +52,58 @@ class RecursiveTest < TestCase
     method = methods[0]
     assert_equal('RecursiveTest#test_simple', method.full_name)
     assert_equal(1, method.called)
+    refute(method.recursive?)
     assert_in_delta(2, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(2, method.children_time, 0.1)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert(!call_info.recursive?)
-    assert_equal('RecursiveTest#test_simple', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(0, method.call_trees.callers.length)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
 
     # Method 1: SimpleRecursion#simple
     method = methods[1]
     assert_equal('SimpleRecursion#simple', method.full_name)
     assert_equal(2, method.called)
+    assert(method.recursive?)
     assert_in_delta(2, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(2, method.children_time, 0.1)
 
-    assert_equal(2, method.call_infos.length)
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('RecursiveTest#test_simple', call_tree.parent.target.full_name)
 
-    call_info = method.call_infos.first
-    assert_equal(2, call_info.children.length)
-    assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple', call_info.call_sequence)
-    assert(!call_info.recursive?)
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
 
-    call_info = method.call_infos.last
-    assert_equal(1, call_info.children.length)
-    assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->SimpleRecursion#simple', call_info.call_sequence)
-    assert(call_info.recursive?)
+    assert_equal(2, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
 
+    call_tree = method.call_trees.callees[1]
+    assert_equal('SimpleRecursion#simple', call_tree.target.full_name)
+
+    # Method 2: Kernel#sleep
     method = methods[2]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(2, method.called)
+    refute(method.recursive?)
     assert_in_delta(2, method.total_time, 0.1)
     assert_in_delta(2, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(0, method.children_time, 0.1)
 
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('SimpleRecursion#simple', call_tree.parent.target.full_name)
+    assert_equal(0, method.call_trees.callees.length)
 
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_simple->SimpleRecursion#simple->SimpleRecursion#simple->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(0, method.call_trees.callees.length)
   end
 
   def test_cycle
@@ -120,96 +117,90 @@ class RecursiveTest < TestCase
     method = methods[0]
     assert_equal('RecursiveTest#test_cycle', method.full_name)
     assert_equal(1, method.called)
+    refute(method.recursive?)
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(0, method.call_trees.callers.length)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#render', call_tree.target.full_name)
 
     method = methods[1]
     assert_equal('SimpleRecursion#render', method.full_name)
     assert_equal(1, method.called)
+    refute(method.recursive?)
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.01)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(1, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('RecursiveTest#test_cycle', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Integer#times', call_tree.target.full_name)
 
     method = methods[2]
     assert_equal('Integer#times', method.full_name)
     assert_equal(2, method.called)
+    assert(method.recursive?)
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.1)
     assert_in_delta(5, method.children_time, 0.1)
 
-    assert_equal(2, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('SimpleRecursion#render', call_tree.parent.target.full_name)
+
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
 
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(call_info.recursive?)
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
 
     method = methods[3]
     assert_equal('SimpleRecursion#render_partial', method.full_name)
     assert_equal(5, method.called)
+    assert(method.recursive?)
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(5, method.children_time, 0.05)
 
-    assert_equal(3, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
-    assert_equal(3, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(2, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('Integer#times', call_tree.parent.target.full_name)
+
+    call_tree = method.call_trees.callers[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.parent.target.full_name)
+
+    assert_equal(3, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
 
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#render_partial', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(call_info.recursive?)
+    call_tree = method.call_trees.callees[1]
+    assert_equal('SimpleRecursion#render_partial', call_tree.target.full_name)
 
-    call_info = method.call_infos[2]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
-    assert(call_info.recursive?)
+    call_tree = method.call_trees.callees[2]
+    assert_equal('Integer#times', call_tree.target.full_name)
 
     method = methods[4]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(5, method.called)
+    refute(method.recursive?)
     assert_in_delta(5, method.total_time, 0.1)
     assert_in_delta(5, method.self_time, 0.1)
     assert_in_delta(0, method.wait_time, 0.01)
     assert_in_delta(0, method.children_time, 0.01)
 
-    assert_equal(3, method.call_infos.length)
-    call_info = method.call_infos[0]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive?)
-
-    call_info = method.call_infos[1]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive?)
-
-    call_info = method.call_infos[2]
-    assert_equal('RecursiveTest#test_cycle->SimpleRecursion#render->Integer#times->SimpleRecursion#render_partial->Integer#times->SimpleRecursion#render_partial->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
-    assert(!call_info.recursive?)
+    assert_equal(0, method.call_trees.callees.length)
   end
 end

data/test/stack_printer_test.rb

@@ -41,7 +41,7 @@ class StackPrinterTest < TestCase
     expected_time = end_time - start_time
 
     file_contents = nil
-    assert_nothing_raised { file_contents = print(result) }
+    file_contents = print(result)
     re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
     assert_match(re, file_contents)
     file_contents =~ re
@@ -49,23 +49,10 @@ class StackPrinterTest < TestCase
     assert_in_delta(expected_time, actual_time, 0.1)
   end
 
-  def test_method_elimination
-    RubyProf.start
-    5.times{STPT.new.a}
-    result = RubyProf.stop
-    assert_nothing_raised {
-      # result.dump
-      result.eliminate_methods!([/Integer#times/])
-      # $stderr.puts "================================"
-      # result.dump
-      print(result)
-    }
-  end
-
   private
   def print(result)
     test = caller.first =~ /in `(.*)'/ ? $1 : "test"
-    testfile_name = "#{RubyProf.tmpdir}/ruby_prof_#{test}.html"
+    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
     # puts "printing to #{testfile_name}"
     printer = RubyProf::CallStackPrinter.new(result)
     File.open(testfile_name, "w") {|f| printer.print(f, :threshold => 0, :min_percent => 0, :title => "ruby_prof #{test}")}

data/test/start_stop_test.rb

@@ -39,24 +39,15 @@ class StartStopTest < TestCase
     end
   end
     
-
   def test_different_methods
     method1
 
     # Ruby prof should be stopped
     assert_equal(false, RubyProf.running?)
 
-
-    # Length should be 4:
-    #   StartStopTest#method1
-    #   StartStopTest#method2
-    #   StartStopTest#method3
-    #   Kernel#sleep
-
     methods = @result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)
 
-    # Check StackTest#test_call_sequence
     method = methods[0]
     assert_equal('StartStopTest#method1', method.full_name)
     assert_equal(1, method.called)
@@ -64,11 +55,10 @@ class StartStopTest < TestCase
     assert_in_delta(0, method.wait_time, 0.02)
     assert_in_delta(0, method.self_time, 0.02)
     assert_in_delta(2, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
 
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('StartStopTest#method2', call_tree.target.full_name)
 
     method = methods[1]
     assert_equal('StartStopTest#method2', method.full_name)
@@ -77,11 +67,14 @@ class StartStopTest < TestCase
     assert_in_delta(0, method.wait_time, 0.02)
     assert_in_delta(0, method.self_time, 0.02)
     assert_in_delta(2, method.children_time, 0.05)
-    assert_equal(1, method.call_infos.length)
 
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1->StartStopTest#method2', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method1', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('StartStopTest#method3', call_tree.target.full_name)
 
     method = methods[2]
     assert_equal('StartStopTest#method3', method.full_name)
@@ -90,11 +83,14 @@ class StartStopTest < TestCase
     assert_in_delta(0, method.wait_time, 0.02)
     assert_in_delta(0, method.self_time, 0.02)
     assert_in_delta(2, method.children_time, 0.02)
-    assert_equal(1, method.call_infos.length)
 
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3', call_info.call_sequence)
-    assert_equal(1, call_info.children.length)
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method2', call_tree.parent.target.full_name)
+
+    assert_equal(1, method.call_trees.callees.length)
+    call_tree = method.call_trees.callees[0]
+    assert_equal('Kernel#sleep', call_tree.target.full_name)
 
     method = methods[3]
     assert_equal('Kernel#sleep', method.full_name)
@@ -103,10 +99,11 @@ class StartStopTest < TestCase
     assert_in_delta(0, method.wait_time, 0.02)
     assert_in_delta(2, method.self_time, 0.02)
     assert_in_delta(0, method.children_time, 0.02)
-    assert_equal(1, method.call_infos.length)
 
-    call_info = method.call_infos[0]
-    assert_equal('StartStopTest#method1->StartStopTest#method2->StartStopTest#method3->Kernel#sleep', call_info.call_sequence)
-    assert_equal(0, call_info.children.length)
+    assert_equal(1, method.call_trees.callers.length)
+    call_tree = method.call_trees.callers[0]
+    assert_equal('StartStopTest#method3', call_tree.parent.target.full_name)
+
+    assert_equal(0, method.call_trees.callees.length)
   end
 end