ruby-prof 0.11.3 → 0.12.1

data/ext/ruby_prof/version.h

@@ -1,7 +1,7 @@
-/* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+/* 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.11.3" // as a string, for easy parsing from rake files
+#define RUBY_PROF_VERSION  "0.12.1" // as a string, for easy parsing from rake files
 #define RUBY_PROF_VERSION_MAJ   0
-#define RUBY_PROF_VERSION_MIN   11
-#define RUBY_PROF_VERSION_MIC   2
+#define RUBY_PROF_VERSION_MIN   12
+#define RUBY_PROF_VERSION_MIC   1

data/lib/ruby-prof.rb

@@ -15,6 +15,7 @@ require 'ruby-prof/compatibility'
 require 'ruby-prof/method_info'
 require 'ruby-prof/profile'
 require 'ruby-prof/rack'
+require 'ruby-prof/thread'
 
 require 'ruby-prof/printers/abstract_printer'
 require 'ruby-prof/printers/call_info_printer'

data/lib/ruby-prof/call_info.rb

@@ -57,7 +57,7 @@ module RubyProf
       parent.children.delete(self)
     end
 
-    # find a sepcific call in list of children. returns nil if not found.
+    # 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)

data/lib/ruby-prof/call_info_visitor.rb

@@ -26,8 +26,10 @@ module RubyProf
     def visit(&block)
       @block = block
 
-      self.thread.top_method.call_infos.each do |call_info|
-        self.visit_call_info(call_info)
+      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
 

data/lib/ruby-prof/compatibility.rb

@@ -91,6 +91,11 @@ module RubyProf
   end
 
   # Profiling
+  def self.start_script(script)
+    start
+    load script
+  end
+
   def self.start
     ensure_not_running!
     @profile = Profile.new(self.measure_mode, self.exclude_threads)
@@ -120,8 +125,8 @@ module RubyProf
 
   def self.stop
     ensure_running!
-    disable_gc_stats_if_needed
     result = @profile.stop
+    disable_gc_stats_if_needed
     @profile = nil
     result
   end

data/lib/ruby-prof/method_info.rb

@@ -14,7 +14,7 @@ module RubyProf
       elsif self.min_depth > other.min_depth
         -1
       else
-        -1 * (self.full_name <=> other.full_name)
+        self.full_name <=> other.full_name
       end
     end
 

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

@@ -12,7 +12,7 @@ module RubyProf
 
     def print_header(thread)
       @output << "Thread ID: #{thread.id}\n"
-      @output << "Total Time: #{thread.top_method.total_time}\n"
+      @output << "Total Time: #{thread.total_time}\n"
       @output << "Sort by: #{sort_method}\n"
       @output << "\n"
     end

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

@@ -45,12 +45,12 @@ module RubyProf
       print_header
 
       @overall_threads_time = @result.threads.inject(0) do |val, thread|
-        val += thread.top_method.total_time
+        val += thread.total_time
       end
 
       @result.threads.each do |thread|
         @current_thread_id = thread.id
-        @overall_time = thread.top_method.total_time
+        @overall_time = thread.total_time
         @output.print "<div class=\"thread\">Thread: #{thread.id} (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})</div>"
         @output.print "<ul name=\"thread\">"
         thread.methods.each do |m|
@@ -58,7 +58,7 @@ module RubyProf
           next unless m.root?
           m.call_infos.each do |ci|
             next unless ci.root?
-            print_stack ci, thread.top_method.total_time
+            print_stack ci, thread.total_time
           end
         end
         @output.print "</ul>"

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

@@ -79,7 +79,7 @@ module RubyProf
     end
     
     def print_thread(thread)
-      total_time = thread.top_method.total_time
+      total_time = thread.total_time
       thread.methods.sort_by(&sort_method).reverse_each do |method|
         total_percentage = (method.total_time/total_time) * 100
 

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

@@ -28,14 +28,14 @@ module RubyProf
 
     def print_header(thread)
       @output << "Thread ID: %d\n" % thread.id
-      @output << "Total: %0.6f\n" % thread.top_method.total_time
+      @output << "Total: %0.6f\n" % thread.total_time
       @output << "Sort by: #{sort_method}\n"
       @output << "\n"
-      @output << " %self     total     self     wait    child    calls   name\n"
+      @output << " %self      total      self      wait     child     calls  name\n"
     end
 
     def print_methods(thread)
-      total_time = thread.top_method.total_time
+      total_time = thread.total_time
       methods = thread.methods.sort_by(&sort_method).reverse
 
       sum = 0
@@ -47,7 +47,7 @@ module RubyProf
         #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  %8.2f %8.2f %8.2f %8.2f %8d  %s%s \n" % [
+        @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

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

@@ -13,7 +13,7 @@ module RubyProf
   #
   class FlatPrinterWithLineNumbers < FlatPrinter
     def print_methods(thread)
-      total_time = thread.top_method.total_time
+      total_time = thread.total_time
 
       methods = thread.methods.sort_by(&sort_method).reverse
       sum = 0
@@ -25,7 +25,7 @@ module RubyProf
         #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  %8.2f %8.2f %8.2f %8.2f %8d  %s%s \n" % [
+        @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

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

@@ -48,7 +48,7 @@ module RubyProf
     # specified by the user, since they will not be
     # printed out.
     def create_link(thread, method)
-      overall_time = thread.top_method.total_time
+      overall_time = thread.total_time
       total_percent = (method.total_time/overall_time) * 100
       if total_percent < min_percent
         # Just return name
@@ -144,7 +144,7 @@ module RubyProf
       <% for thread in @result.threads %>
       <tr>
         <td><a href="#<%= thread.id %>"><%= thread.id %></a></td>
-        <td><%= thread.top_method.total_time %></td>
+        <td><%= thread.total_time %></td>
       </tr>
       <% end %>
     </table>
@@ -152,7 +152,7 @@ module RubyProf
     <!-- Methods Tables -->
     <% for thread in @result.threads
          methods = thread.methods
-         total_time = thread.top_method.total_time %>
+         total_time = thread.total_time %>
       <h2><a name="<%= thread.id %>">Thread <%= thread.id %></a></h2>
 
       <table>

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

@@ -15,14 +15,14 @@ module RubyProf
 
   class GraphPrinter < AbstractPrinter
     PERCENTAGE_WIDTH = 8
-    TIME_WIDTH = 10
+    TIME_WIDTH = 11
     CALL_WIDTH = 17
 
     private
 
     def print_header(thread)
       @output << "Thread ID: #{thread.id}\n"
-      @output << "Total Time: #{thread.top_method.total_time}\n"
+      @output << "Total Time: #{thread.total_time}\n"
       @output << "Sort by: #{sort_method}\n"
       @output << "\n"
 
@@ -39,7 +39,7 @@ module RubyProf
     end
 
     def print_methods(thread)
-      total_time = thread.top_method.total_time
+      total_time = thread.total_time
       # Sort methods from longest to shortest total time
       methods = thread.methods.sort_by(&sort_method)
 
@@ -57,10 +57,10 @@ module RubyProf
         # 1 is for % sign
         @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage)
         @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage)
-        @output << sprintf("%#{TIME_WIDTH}.2f", method.total_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", method.self_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", method.wait_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", method.children_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.self_time)
+        @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_name(method))
@@ -77,10 +77,10 @@ module RubyProf
       method.aggregate_parents.sort_by(&:total_time).each do |caller|
         next unless caller.parent
         @output << " " * 2 * PERCENTAGE_WIDTH
-        @output << sprintf("%#{TIME_WIDTH}.2f", caller.total_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", caller.self_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", caller.wait_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", caller.children_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.children_time)
 
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
@@ -95,10 +95,10 @@ module RubyProf
 
         @output << " " * 2 * PERCENTAGE_WIDTH
 
-        @output << sprintf("%#{TIME_WIDTH}.2f", child.total_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", child.self_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", child.wait_time)
-        @output << sprintf("%#{TIME_WIDTH}.2f", child.children_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.children_time)
 
         call_called = "#{child.called}/#{child.target.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)

data/lib/ruby-prof/thread.rb

@@ -0,0 +1,22 @@
+module RubyProf
+  class Thread
+    def top_methods
+      self.methods.select do |method_info|
+        method_info.call_infos.detect do |call_info|
+          call_info.parent.nil?
+        end
+      end
+    end
+
+    def total_time
+      self.top_methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          if call_info.parent.nil?
+            sum += call_info.total_time
+          end
+        end
+        sum
+      end
+    end
+  end
+end

data/ruby-prof.gemspec

@@ -55,5 +55,6 @@ EOF
   spec.required_ruby_version = '>= 1.8.7'
   spec.date = DateTime.now
   spec.homepage = 'https://github.com/rdp/ruby-prof'
-  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('rake-compiler')
 end

data/test/basic_test.rb

@@ -9,6 +9,11 @@ class BasicTest < Test::Unit::TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def start
+    RubyProf.start
+    RubyProf::C1.hello
+  end
+
   def test_running
     assert(!RubyProf.running?)
     RubyProf.start
@@ -40,57 +45,84 @@ class BasicTest < Test::Unit::TestCase
     RubyProf.stop
   end
 
-  def test_pause_seq
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-    p.start ; assert !p.paused?
-    p.pause ; assert p.paused?
-    p.resume; assert !p.paused?
-    p.pause ; assert p.paused?
-    p.pause ; assert p.paused?
-    p.resume; assert !p.paused?
-    p.resume; assert !p.paused?
-    p.stop  ; assert !p.paused?
-  end
+  def test_leave_method
+    start
+    sleep 0.15
+    profile = RubyProf.stop
 
-  def test_pause_block
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-    p.start
-    p.pause
-    assert p.paused?
+    assert_equal(1, profile.threads.count)
 
-    times_block_invoked = 0
-    retval= p.resume{
-      times_block_invoked += 1
-      120 + times_block_invoked
-    }
-    assert_equal 1, times_block_invoked
-    assert p.paused?
+    thread = profile.threads.first
+    assert_in_delta(0.25, thread.total_time, 0.01)
 
-    assert_equal 121, retval, "resume() should return the result of the given block."
+    top_methods = thread.top_methods.sort
+    assert_equal(2, top_methods.count)
+    assert_equal("BasicTest#start", top_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method", top_methods[1].full_name)
 
-    p.stop
-  end
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
 
-  def test_pause_block_with_error
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-    p.start
-    p.pause
-    assert p.paused?
-
-    begin
-      p.resume{ raise }
-      flunk 'Exception expected.'
-    rescue
-      assert p.paused?
-    end
+    # 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_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_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)
 
-    p.stop
+    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)
   end
 
-  def test_resume_when_not_paused
-    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
-    p.start ; assert !p.paused?
-    p.resume; assert !p.paused?
-    p.stop  ; assert !p.paused?
+  def test_leave_method_2
+    start
+    RubyProf::C1.hello
+    RubyProf::C1.hello
+    profile = RubyProf.stop
+
+    assert_equal(1, profile.threads.count)
+
+    thread = profile.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.01)
+
+    top_methods = thread.top_methods.sort
+    assert_equal(2, top_methods.count)
+    assert_equal("BasicTest#start", top_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method_2", top_methods[1].full_name)
+
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
+
+    # 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_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_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_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)
   end
-end
+end

data/test/call_info_test.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class CallInfoTest < 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_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)
+
+    result2 = 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
+