ruby-prof 0.15.8 → 0.15.9

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

@@ -210,7 +210,6 @@ module RubyProf
                </tr>
                <!-- Children -->
                <%
-                  method.recalc_recursion unless method.non_recursive?
                   for callee in method.aggregate_children.sort_by(&:total_time).reverse
                     next if min_time && callee.total_time < min_time
                %>
@@ -228,7 +227,6 @@ module RubyProf
                <% end %>
                <!-- Create divider row -->
                <tr class="break"><td colspan="9"></td></tr>
-            <% thread.recalc_recursion unless method.non_recursive? %>
           <% end %>
         </tbody>
         <tfoot>

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

@@ -36,7 +36,7 @@ module RubyProf
       @output << sprintf("%#{TIME_WIDTH}s", "wait")
       @output << sprintf("%#{TIME_WIDTH}s", "child")
       @output << sprintf("%#{CALL_WIDTH}s", "calls")
-      @output << "    Name"
+      @output << "     name"
       @output << "\n"
     end
 
@@ -63,16 +63,14 @@ module RubyProf
         @output << sprintf("%#{TIME_WIDTH}.3f", method.wait_time)
         @output << sprintf("%#{TIME_WIDTH}.3f", method.children_time)
         @output << sprintf("%#{CALL_WIDTH}i", method.called)
-        @output << sprintf("     %s",  method.recursive? ? "*" : " ")
+        @output << sprintf("    %s",  method.recursive? ? "*" : " ")
         @output << sprintf("%s", method_name(method))
         if print_file
           @output << sprintf("  %s:%s", method.source_file, method.line)
         end
         @output << "\n"
 
-        method.recalc_recursion unless method.non_recursive?
         print_children(method)
-        thread.recalc_recursion unless method.non_recursive?
       end
     end
 
@@ -87,7 +85,7 @@ module RubyProf
 
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("      %s", caller.parent.target.full_name)
+        @output << sprintf("     %s", caller.parent.target.full_name)
         @output << "\n"
       end
     end
@@ -105,7 +103,7 @@ module RubyProf
 
         call_called = "#{child.called}/#{child.target.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("      %s", child.target.full_name)
+        @output << sprintf("     %s", child.target.full_name)
         @output << "\n"
       end
     end

data/lib/ruby-prof/rack.rb

@@ -38,9 +38,16 @@ module Rack
       end
     end
 
+    private
+
     def print(data, path)
       @printer_klasses.each do |printer_klass, base_name|
         printer = printer_klass.new(data)
+
+        if base_name.respond_to?(:call)
+          base_name = base_name.call
+        end
+
         file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
         ::File.open(file_name, 'wb') do |file|
           printer.print(file, @options)

data/lib/ruby-prof/thread.rb

@@ -16,10 +16,6 @@ module RubyProf
       top_call_infos.each(&:detect_recursion)
     end
 
-    def recalc_recursion
-      top_call_infos.each(&:recalc_recursion)
-    end
-
     def total_time
       self.top_methods.inject(0) do |sum, method_info|
         method_info.call_infos.each do |call_info|

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "0.15.8"
+  VERSION = "0.15.9"
 end

data/ruby-prof.gemspec

@@ -51,7 +51,7 @@ EOF
   spec.required_ruby_version = '>= 1.9.3'
   spec.date = Time.now.strftime('%Y-%m-%d')
   spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
-  spec.add_development_dependency('minitest', '~> 5.5.0')
+  spec.add_development_dependency('minitest', '~> 5.8.3')
   spec.add_development_dependency('rake-compiler')
   spec.add_development_dependency('rdoc')
 end

data/test/basic_test.rb

@@ -53,7 +53,7 @@ class BasicTest < TestCase
     assert_equal(1, profile.threads.count)
 
     thread = profile.threads.first
-    assert_in_delta(0.25, thread.total_time, 0.01)
+    assert_in_delta(0.25, thread.total_time, 0.015)
 
     top_methods = thread.top_methods.sort
     assert_equal(2, top_methods.count)
@@ -65,24 +65,24 @@ class BasicTest < TestCase
 
     # Check times
     assert_equal("<Class::RubyProf::C1>#hello", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
-    assert_in_delta(0.0,  methods[0].wait_time, 0.01)
-    assert_in_delta(0.0,  methods[0].self_time, 0.01)
+    assert_in_delta(0.1, methods[0].total_time, 0.015)
+    assert_in_delta(0.0,  methods[0].wait_time, 0.015)
+    assert_in_delta(0.0,  methods[0].self_time, 0.015)
 
     assert_equal("BasicTest#start", methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.01)
-    assert_in_delta(0.0, methods[1].wait_time, 0.01)
-    assert_in_delta(0.0, methods[1].self_time, 0.01)
+    assert_in_delta(0.1, methods[1].total_time, 0.015)
+    assert_in_delta(0.0, methods[1].wait_time, 0.015)
+    assert_in_delta(0.0, methods[1].self_time, 0.015)
 
     assert_equal("BasicTest#test_leave_method", methods[2].full_name)
-    assert_in_delta(0.15, methods[2].total_time, 0.01)
-    assert_in_delta(0.0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.0, methods[2].self_time, 0.01)
+    assert_in_delta(0.15, methods[2].total_time, 0.015)
+    assert_in_delta(0.0, methods[2].wait_time, 0.015)
+    assert_in_delta(0.0, methods[2].self_time, 0.015)
 
     assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.25, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.25, methods[3].self_time, 0.01)
+    assert_in_delta(0.25, methods[3].total_time, 0.015)
+    assert_in_delta(0.0, methods[3].wait_time, 0.015)
+    assert_in_delta(0.25, methods[3].self_time, 0.015)
   end
 
   def test_leave_method_2
@@ -94,7 +94,7 @@ class BasicTest < TestCase
     assert_equal(1, profile.threads.count)
 
     thread = profile.threads.first
-    assert_in_delta(0.3, thread.total_time, 0.01)
+    assert_in_delta(0.3, thread.total_time, 0.015)
 
     top_methods = thread.top_methods.sort
     assert_equal(2, top_methods.count)
@@ -106,23 +106,23 @@ class BasicTest < TestCase
 
     # Check times
     assert_equal("BasicTest#start", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.01)
-    assert_in_delta(0.0, methods[0].wait_time, 0.01)
-    assert_in_delta(0.0, methods[0].self_time, 0.01)
+    assert_in_delta(0.1, methods[0].total_time, 0.015)
+    assert_in_delta(0.0, methods[0].wait_time, 0.015)
+    assert_in_delta(0.0, methods[0].self_time, 0.015)
 
     assert_equal("BasicTest#test_leave_method_2", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.01)
-    assert_in_delta(0.0, methods[1].wait_time, 0.01)
-    assert_in_delta(0.0, methods[1].self_time, 0.01)
+    assert_in_delta(0.2, methods[1].total_time, 0.015)
+    assert_in_delta(0.0, methods[1].wait_time, 0.015)
+    assert_in_delta(0.0, methods[1].self_time, 0.015)
 
     assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.3, methods[2].total_time, 0.01)
-    assert_in_delta(0.0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.3, methods[2].self_time, 0.01)
+    assert_in_delta(0.3, methods[2].total_time, 0.015)
+    assert_in_delta(0.0, methods[2].wait_time, 0.015)
+    assert_in_delta(0.3, methods[2].self_time, 0.015)
 
     assert_equal("<Class::RubyProf::C1>#hello", methods[3].full_name)
-    assert_in_delta(0.3, methods[3].total_time, 0.01)
-    assert_in_delta(0.0, methods[3].wait_time, 0.01)
-    assert_in_delta(0.0, methods[3].self_time, 0.01)
+    assert_in_delta(0.3, methods[3].total_time, 0.015)
+    assert_in_delta(0.0, methods[3].wait_time, 0.015)
+    assert_in_delta(0.0, methods[3].self_time, 0.015)
   end
 end

data/test/issue137_test.rb

@@ -0,0 +1,63 @@
+#!/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_allocations_test.rb

@@ -16,10 +16,11 @@ class MeasureAllocationsTest < TestCase
   if RubyProf::ALLOCATIONS_ENABLED
     def test_allocations
       t = RubyProf.measure_allocations
-      assert_kind_of Integer, t
-
+      refute_empty("a" + "b")
       u = RubyProf.measure_allocations
-      assert u > t, [t, u].inspect
+      assert_kind_of Integer, t
+      assert_kind_of Integer, u
+      assert_operator t, :<, u
     end
   end
 end

data/test/measure_cpu_time_test.rb

@@ -35,13 +35,13 @@ class MeasureCpuTimeTest < TestCase
     assert_equal('<Class::RubyProf::C7>#hello', methods[1].full_name)
 
     # Check times
-    assert_in_delta(0.1, methods[0].total_time, 0.02)
-    assert_in_delta(0, methods[0].wait_time, 0.02)
-    assert_in_delta(0, methods[0].self_time, 0.02)
+    assert_in_delta(0.1, 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.1, methods[1].total_time, 0.02)
-    assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0, methods[1].self_time, 0.02)
+    assert_in_delta(0.1, 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.03)
   end
 
   def test_instance_methods

data/test/measure_process_time_test.rb

@@ -31,15 +31,15 @@ class MeasureProcessTimeTest < TestCase
 
     methods = result.threads.first.methods.sort.reverse
 
-    # WTF?
-    if RUBY_VERSION =~ /^1\.9\.3/
-      assert_equal 16, methods.length
-    elsif RUBY_VERSION =~ /^2\.0/
-      assert_equal 15, methods.length
-    else # if RUBY_VERSION =~ /^2\.1/
-      assert_equal 14, methods.length
-    end
+    expected_number_of_methods =
+      case RUBY_VERSION
+      when /^1\.9\.3/  then 16
+      when /^2\.0/     then 15
+      when /^2\.(1|2)/ then 14
+      else                  13
+      end
     # puts methods.map(&:full_name).inspect
+    assert_equal expected_number_of_methods, methods.length
 
     # Check times
     assert_equal("MeasureProcessTimeTest#test_primes", methods[0].full_name)

data/test/pause_resume_test.rb

@@ -43,17 +43,17 @@ class PauseResumeTest < TestCase
     assert_equal('PauseResumeTest#test_pause_resume', methods[2].full_name)
 
     # Check times
-    assert_in_delta(0.2, 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.2, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
 
-    assert_in_delta(0.2, methods[1].total_time, 0.01)
-    assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0.2, methods[1].self_time, 0.01)
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0.2, methods[1].self_time, 0.02)
 
-    assert_in_delta(0.2, methods[2].total_time, 0.01)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0, methods[2].self_time, 0.01)
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0, methods[2].self_time, 0.02)
   end
 
   # pause/resume in the same frame

data/test/printers_test.rb

@@ -11,7 +11,7 @@ class PrintersTest < TestCase
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
     RubyProf::measure_mode = RubyProf::WALL_TIME
     @result = RubyProf.profile do
-      run_primes(200)
+      run_primes(1000, 5000)
     end
   end
 

data/test/printing_recursive_graph_test.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'fileutils'
+
+# --- code to be tested ---
+module PRGT
+  extend self
+
+  def f(n)
+    n.times { sleep 0.1 }
+  end
+
+  def g(n)
+    n.times { sleep 0.2 }
+  end
+
+  def run
+    2.times { f(2); g(4) }
+  end
+end
+
+# --- expected test output ---
+=begin
+Measure Mode: wall_time
+Thread ID: 70238775664960
+Fiber ID: 70238784046840
+Total Time: 2.040249824523926
+Sort by: total_time
+
+  %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
+--------------------------------------------------------------------------------
+                      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
+--------------------------------------------------------------------------------
+                      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
+--------------------------------------------------------------------------------
+                      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
+--------------------------------------------------------------------------------
+                      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
+--------------------------------------------------------------------------------
+                      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
+
+* 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
+    @result = RubyProf.profile do
+      PRGT.run
+    end
+  end
+
+  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)
+  end
+end