ruby-prof 1.1.0-x64-mingw32 → 1.4.2-x64-mingw32

data/lib/ruby-prof/thread.rb

@@ -1,23 +1,8 @@
 module RubyProf
   class Thread
-    # Returns the root methods (ie, methods that were not called by other methods) that were profiled while
-    # this thread was executing. Generally there is only one root method (multiple root methods can occur
-    # when Profile#pause is used). By starting with the root methods, you can descend down the profile
-    # call tree.
-    def root_methods
-      self.methods.select do |method_info|
-        method_info.root?
-      end
-    end
-
     # Returns the total time this thread was executed.
     def total_time
-      self.root_methods.inject(0) do |sum, method_info|
-        method_info.callers.each do |call_info|
-          sum += call_info.total_time
-        end
-        sum
-      end
+      self.call_tree.total_time
     end
 
     # Returns the amount of time this thread waited while other thread executed.
@@ -25,8 +10,8 @@ module RubyProf
       # wait_time, like self:time, is always method local
       # thus we need to sum over all methods and call infos
       self.methods.inject(0) do |sum, method_info|
-        method_info.callers.each do |call_info|
-          sum += call_info.wait_time
+        method_info.callers.each do |call_tree|
+          sum += call_tree.wait_time
         end
         sum
       end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.1.0"
+  VERSION = "1.4.2"
 end

data/ruby-prof.gemspec

@@ -19,6 +19,13 @@ EOF
   spec.license = 'BSD-2-Clause'
   spec.version = RubyProf::VERSION
 
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/ruby-prof/ruby-prof/issues",
+    "changelog_uri"     => "https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES",
+    "documentation_uri" => "https://ruby-prof.github.io/",
+    "source_code_uri"   => "https://github.com/ruby-prof/ruby-prof/tree/v#{spec.version}",
+  }
+
   spec.author = "Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes"
   spec.email = "shugo@ruby-lang.org, cfis@savagexi.com, rogerdpack@gmail.com, skaes@railsexpress.de"
   spec.platform = Gem::Platform::RUBY

data/test/alias_test.rb

@@ -37,19 +37,16 @@ class AliasTest < TestCase
       assert_equal(28, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_nil(call_info.parent)
-      assert_equal(28, call_info.line)
+      assert_equal(0, method.call_trees.callers.count)
 
-      assert_equal(2, method.callees.count)
-      call_info = method.callees[0]
-      assert_equal('Class#new', call_info.target.full_name)
-      assert_equal(28, call_info.line)
+      assert_equal(2, method.call_trees.callees.count)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Class#new', call_tree.target.full_name)
+      assert_equal(28, call_tree.line)
 
-      call_info = method.callees[1]
-      assert_equal('AliasTest::TestMe#some_method', call_info.target.full_name)
-      assert_equal(28, call_info.line)
+      call_tree = method.call_trees.callees[1]
+      assert_equal('AliasTest::TestMe#some_method', call_tree.target.full_name)
+      assert_equal(28, call_tree.line)
 
       # Method 1
       method = methods[1]
@@ -57,15 +54,15 @@ class AliasTest < TestCase
       assert_equal(0, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
-      assert_equal(28, call_info.line)
+      assert_equal(1, method.call_trees.callers.count)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+      assert_equal(28, call_tree.line)
 
-      assert_equal(1, method.callees.count)
-      call_info = method.callees[0]
-      assert_equal('BasicObject#initialize', call_info.target.full_name)
-      assert_equal(0, call_info.line)
+      assert_equal(1, method.call_trees.callees.count)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('BasicObject#initialize', call_tree.target.full_name)
+      assert_equal(0, call_tree.line)
 
       # Method 2
       method = methods[2]
@@ -73,12 +70,12 @@ class AliasTest < TestCase
       assert_equal(0, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_equal('Class#new', call_info.parent.full_name)
-      assert_equal(0, call_info.line)
+      assert_equal(1, method.call_trees.callers.count)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('Class#new', call_tree.parent.target.full_name)
+      assert_equal(0, call_tree.line)
 
-      assert_equal(0, method.callees.count)
+      assert_equal(0, method.call_trees.callees.count)
 
       # Method 3
       method = methods[3]
@@ -86,15 +83,15 @@ class AliasTest < TestCase
       assert_equal(13, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_equal('AliasTest#test_alias', call_info.parent.full_name)
-      assert_equal(28, call_info.line)
+      assert_equal(1, method.call_trees.callers.count)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('AliasTest#test_alias', call_tree.parent.target.full_name)
+      assert_equal(28, call_tree.line)
 
-      assert_equal(1, method.callees.count)
-      call_info = method.callees[0]
-      assert_equal('AliasTest::TestMe#some_method_original', call_info.target.full_name)
-      assert_equal(14, call_info.line)
+      assert_equal(1, method.call_trees.callees.count)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_tree.target.full_name)
+      assert_equal(14, call_tree.line)
 
       # Method 4
       method = methods[4]
@@ -102,15 +99,15 @@ class AliasTest < TestCase
       assert_equal(8, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_equal('AliasTest::TestMe#some_method', call_info.parent.full_name)
-      assert_equal(14, call_info.line)
+      assert_equal(1, method.call_trees.callers.count)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('AliasTest::TestMe#some_method', call_tree.parent.target.full_name)
+      assert_equal(14, call_tree.line)
 
-      assert_equal(1, method.callees.count)
-      call_info = method.callees[0]
-      assert_equal('Kernel#sleep', call_info.target.full_name)
-      assert_equal(9, call_info.line)
+      assert_equal(1, method.call_trees.callees.count)
+      call_tree = method.call_trees.callees[0]
+      assert_equal('Kernel#sleep', call_tree.target.full_name)
+      assert_equal(9, call_tree.line)
 
       # Method 5
       method = methods[5]
@@ -118,12 +115,12 @@ class AliasTest < TestCase
       assert_equal(0, method.line)
       refute(method.recursive?)
 
-      assert_equal(1, method.callers.count)
-      call_info = method.callers[0]
-      assert_equal('AliasTest::TestMe#some_method_original', call_info.parent.full_name)
-      assert_equal(9, call_info.line)
+      assert_equal(1, method.call_trees.callers.count)
+      call_tree = method.call_trees.callers[0]
+      assert_equal('AliasTest::TestMe#some_method_original', call_tree.parent.target.full_name)
+      assert_equal(9, call_tree.line)
 
-      assert_equal(0, method.callees.count)
+      assert_equal(0, method.call_trees.callees.count)
     end
   end
 end

data/test/basic_test.rb

@@ -10,11 +10,6 @@ class BasicTest < TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
-  def start
-    RubyProf.start
-    RubyProf::C1.sleep_wait
-  end
-
   def test_running
     assert(!RubyProf.running?)
     RubyProf.start
@@ -45,85 +40,4 @@ class BasicTest < TestCase
 
     RubyProf.stop
   end
-
-  def test_leave_method
-    start
-    sleep 0.15
-    profile = RubyProf.stop
-
-    assert_equal(1, profile.threads.count)
-
-    thread = profile.threads.first
-    assert_in_delta(0.25, thread.total_time, 0.05)
-
-    root_methods = thread.root_methods.sort
-    assert_equal(2, root_methods.count)
-    assert_equal("BasicTest#start", root_methods[0].full_name)
-    assert_equal("BasicTest#test_leave_method", root_methods[1].full_name)
-
-    assert_equal(4, thread.methods.length)
-    methods = profile.threads.first.methods.sort
-
-    # Check times
-    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[0].full_name)
-    assert_in_delta(0.1, methods[0].total_time, 0.05)
-    assert_in_delta(0.0,  methods[0].wait_time, 0.05)
-    assert_in_delta(0.0,  methods[0].self_time, 0.05)
-
-    assert_equal("BasicTest#start", methods[1].full_name)
-    assert_in_delta(0.1, methods[1].total_time, 0.05)
-    assert_in_delta(0.0, methods[1].wait_time, 0.05)
-    assert_in_delta(0.0, methods[1].self_time, 0.05)
-
-    assert_equal("BasicTest#test_leave_method", methods[2].full_name)
-    assert_in_delta(0.15, methods[2].total_time, 0.05)
-    assert_in_delta(0.0, methods[2].wait_time, 0.05)
-    assert_in_delta(0.0, methods[2].self_time, 0.05)
-
-    assert_equal("Kernel#sleep", methods[3].full_name)
-    assert_in_delta(0.25, methods[3].total_time, 0.05)
-    assert_in_delta(0.0, methods[3].wait_time, 0.05)
-    assert_in_delta(0.25, methods[3].self_time, 0.05)
-  end
-
-  def test_leave_method_2
-    start
-    RubyProf::C1.sleep_wait
-    RubyProf::C1.sleep_wait
-    profile = RubyProf.stop
-
-    assert_equal(1, profile.threads.count)
-
-    thread = profile.threads.first
-    assert_in_delta(0.3, thread.total_time, 0.05)
-
-    root_methods = thread.root_methods.sort
-    assert_equal(2, root_methods.count)
-    assert_equal("BasicTest#start", root_methods[0].full_name)
-    assert_equal("BasicTest#test_leave_method_2", root_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.05)
-    assert_in_delta(0.0, methods[0].wait_time, 0.05)
-    assert_in_delta(0.0, methods[0].self_time, 0.05)
-
-    assert_equal("BasicTest#test_leave_method_2", methods[1].full_name)
-    assert_in_delta(0.2, methods[1].total_time, 0.05)
-    assert_in_delta(0.0, methods[1].wait_time, 0.05)
-    assert_in_delta(0.0, methods[1].self_time, 0.05)
-
-    assert_equal("Kernel#sleep", methods[2].full_name)
-    assert_in_delta(0.3, methods[2].total_time, 0.05)
-    assert_in_delta(0.0, methods[2].wait_time, 0.05)
-    assert_in_delta(0.3, methods[2].self_time, 0.05)
-
-    assert_equal("<Class::RubyProf::C1>#sleep_wait", methods[3].full_name)
-    assert_in_delta(0.3, methods[3].total_time, 0.05)
-    assert_in_delta(0.0, methods[3].wait_time, 0.05)
-    assert_in_delta(0.0, methods[3].self_time, 0.05)
-  end
 end

data/test/{call_info_visitor_test.rb → call_tree_visitor_test.rb}

@@ -2,8 +2,9 @@
 # encoding: UTF-8
 
 require File.expand_path('../test_helper', __FILE__)
+require_relative './measure_times'
 
-class CallInfoVisitorTest < TestCase
+class CallTreeVisitorTest < TestCase
   def setup
     # Need to use wall time for this test due to the sleep calls
     RubyProf::measure_mode = RubyProf::WALL_TIME
@@ -14,16 +15,16 @@ class CallInfoVisitorTest < TestCase
       RubyProf::C1.sleep_wait
     end
 
-    visitor = RubyProf::CallInfoVisitor.new(result.threads.first.root_methods)
+    visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
 
     method_names = Array.new
 
-    visitor.visit do |call_info, event|
-      method_names << call_info.target.full_name if event == :enter
+    visitor.visit do |call_tree, event|
+      method_names << call_tree.target.full_name if event == :enter
     end
 
     assert_equal(3, method_names.length)
-    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
+    assert_equal("CallTreeVisitorTest#test_visit", method_names[0])
     assert_equal("<Class::RubyProf::C1>#sleep_wait", method_names[1])
     assert_equal("Kernel#sleep", method_names[2])
   end

data/test/call_trees_test.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# --  Tests ----
+class CallTreesTest < TestCase
+  def some_method_1
+    some_method_2
+  end
+
+  def some_method_2
+  end
+
+  def test_call_infos
+    result = RubyProf.profile do
+      some_method_1
+    end
+
+    thread = result.threads.first
+    assert_equal(3, thread.methods.length)
+
+    method = thread.methods[0]
+    assert_equal('CallTreesTest#test_call_infos', method.full_name)
+
+    call_trees = method.call_trees
+    assert_empty(call_trees.callers)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[1]
+    assert_equal('CallTreesTest#some_method_1', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#test_call_infos', call_trees.callers[0].parent.target.full_name)
+    assert_equal(1, call_trees.callees.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callees[0])
+    assert_equal('CallTreesTest#some_method_2', call_trees.callees[0].target.full_name)
+
+    method = thread.methods[2]
+    assert_equal('CallTreesTest#some_method_2', method.full_name)
+
+    call_trees = method.call_trees
+    assert_equal(1, call_trees.callers.length)
+    assert_kind_of(RubyProf::AggregateCallTree, call_trees.callers[0])
+    assert_equal('CallTreesTest#some_method_1', call_trees.callers[0].parent.target.full_name)
+    assert_empty(call_trees.callees)
+  end
+
+  def test_gc
+    result = RubyProf.profile do
+      some_method_1
+    end
+
+    method = result.threads.first.methods[1]
+
+    100.times do |i|
+      method.call_trees.callers
+      GC.start
+    end
+    assert(true)
+  end
+end

data/test/exclude_methods_test.rb

@@ -43,13 +43,12 @@ class ExcludeMethodsTest < TestCase
     obj = ExcludeMethodsClass.new
     prf = RubyProf::Profile.new
 
-    result = prf.profile { 5.times {obj.a} }
+    result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
-
     assert_equal(10, methods.count)
     assert_equal('ExcludeMethodsTest#test_methods_can_be_profiled', methods[0].full_name)
-    assert_equal('Integer#times', methods[1].full_name)
-    assert_equal('ExcludeMethodsClass#a', methods[2].full_name)
+    assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
+    assert_equal('Integer#times', methods[2].full_name)
     assert_equal('ExcludeMethodsClass#b', methods[3].full_name)
     assert_equal('<Class::ExcludeMethodsClass>#e', methods[4].full_name)
     assert_equal('<Class::ExcludeMethodsClass>#f', methods[5].full_name)
@@ -65,7 +64,7 @@ class ExcludeMethodsTest < TestCase
 
     prf.exclude_methods!(Integer, :times)
 
-    result = prf.profile { 5.times {obj.a} }
+    result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
 
     assert_equal(9, methods.count)
@@ -88,7 +87,7 @@ class ExcludeMethodsTest < TestCase
     prf.exclude_methods!(ExcludeMethodsClass.singleton_class, :f)
     prf.exclude_methods!(ExcludeMethodsModule.singleton_class, :d)
 
-    result = prf.profile { 5.times {obj.a} }
+    result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
 
     assert_equal(7, methods.count)
@@ -107,13 +106,19 @@ class ExcludeMethodsTest < TestCase
 
     prf.exclude_common_methods!
 
-    result = prf.profile { 5.times {obj.a} }
+    result = prf.profile {obj.a}
     methods = result.threads.first.methods.sort.reverse
 
     assert_equal(9, methods.count)
     assert_equal('ExcludeMethodsTest#test_exclude_common_methods1', methods[0].full_name)
     assert_equal('ExcludeMethodsClass#a', methods[1].full_name)
     assert_equal('ExcludeMethodsClass#b', methods[2].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#e', methods[3].full_name)
+    assert_equal('<Class::ExcludeMethodsClass>#f', methods[4].full_name)
+    assert_equal('Kernel#sleep', methods[5].full_name)
+    assert_equal('ExcludeMethodsModule#c', methods[6].full_name)
+    assert_equal('<Module::ExcludeMethodsModule>#d', methods[7].full_name)
+    assert_equal('Kernel#class', methods[8].full_name)
   end
 
   def test_exclude_common_methods2
@@ -130,14 +135,14 @@ class ExcludeMethodsTest < TestCase
 
   private
 
-  def assert_method_has_been_eliminated(result, eliminated_method)
+  def assert_method_has_been_excluded(result, excluded_method)
     result.threads.each do |thread|
       thread.methods.each do |method|
-        method.call_infos.each do |ci|
-          assert(ci.target != eliminated_method, "broken self")
-          assert(ci.parent.target != eliminated_method, "broken parent") if ci.parent
+        method.call_trees.each do |ci|
+          assert(ci.target != excluded_method, "broken self")
+          assert(ci.parent.target != excluded_method, "broken parent") if ci.parent
           ci.children.each do |callee|
-            assert(callee.target != eliminated_method, "broken kid")
+            assert(callee.target != excluded_method, "broken kid")
           end
         end
       end