ruby-prof 0.8.2 → 0.9.0

data/lib/ruby-prof/test.rb

@@ -15,7 +15,7 @@ module RubyProf
     def output_dir
       PROFILE_OPTIONS[:output_dir]
     end
-          
+
     def run(result)
       return if @method_name.to_s == "default_test"
 
@@ -108,7 +108,7 @@ module RubyProf
     def report_profile(data, measure_mode)
       PROFILE_OPTIONS[:printers].each do |printer_klass|
         printer = printer_klass.new(data)
-        
+
         # Makes sure the output directory exits
         FileUtils.mkdir_p(output_dir)
 
@@ -145,4 +145,4 @@ module RubyProf
       end
     end
   end
-end
+end

data/rails/environment/profile.rb

@@ -5,7 +5,7 @@
 # definitely not use the production databse!
 
 
-# Cache classes - otherwise your code 
+# Cache classes - otherwise your code
 # will run approximately 5 times slower and the
 # profiling results will be overwhelmed by Rails
 # dependency loading mechanism
@@ -21,4 +21,4 @@ config.action_view.cache_template_loading            = true
 config.action_controller.perform_caching             = false
 
 # Turn off most logging
-config.log_level = :info
+config.log_level = :info

data/rails/example/example_test.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + '../profile_test_helper'
 
 class ExampleTest < Test::Unit::TestCase
   include RubyProf::Test
-  
+
   def test_stuff
     puts "Test method"
   end
-end   
+end

data/rails/profile_test_helper.rb

@@ -17,5 +17,5 @@ ENV["RAILS_ENV"] = env
 require 'ruby-prof'
 
 # Setup output directory to Rails tmp directory
-RubyProf::Test::PROFILE_OPTIONS[:output_dir] = 
+RubyProf::Test::PROFILE_OPTIONS[:output_dir] =
     File.expand_path(File.join(RAILS_ROOT, 'tmp', 'profile'))

data/test/aggregate_test.rb

@@ -14,7 +14,7 @@ class AggClass
   def z
     sleep 1
   end
-  
+
   def a
     z
   end
@@ -24,7 +24,7 @@ class AggClass
   end
 
   def c
-   a
+    a
   end
 end
 
@@ -34,6 +34,21 @@ class AggregateTest < Test::Unit::TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def test_all_call_infos_are_minimal_as_there_is_no_recursion
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+    methods = result.threads.values.first.sort.reverse
+    methods.each do |m|
+      m.call_infos.each do |ci|
+        assert ci.minimal?, "#{ci.call_sequence} should be minimal in the call tree"
+      end
+    end
+  end
+
   def test_call_infos
     c1 = AggClass.new
     result = RubyProf.profile do
@@ -43,7 +58,7 @@ class AggregateTest < Test::Unit::TestCase
     end
 
     methods = result.threads.values.first.sort.reverse
-    method = methods.find {|method| method.full_name == 'AggClass#z'}
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
 
     # Check AggClass#z
     assert_equal('AggClass#z', method.full_name)
@@ -76,7 +91,7 @@ class AggregateTest < Test::Unit::TestCase
     end
 
     methods = result.threads.values.first.sort.reverse
-    method = methods.find {|method| method.full_name == 'AggClass#z'}
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
 
     # Check AggClass#z
     assert_equal('AggClass#z', method.full_name)
@@ -102,7 +117,7 @@ class AggregateTest < Test::Unit::TestCase
     end
 
     methods = result.threads.values.first.sort.reverse
-    method = methods.find {|method| method.full_name == 'AggClass#a'}
+    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
 
     # Check AggClass#a
     assert_equal('AggClass#a', method.full_name)
@@ -118,4 +133,4 @@ class AggregateTest < Test::Unit::TestCase
     assert_in_delta(3, call_info.children_time, 0.05)
     assert_equal(3, call_info.called)
   end
-end
+end

data/test/basic_test.rb

@@ -7,7 +7,7 @@ class C1
   def C1.hello
     sleep(0.1)
   end
-  
+
   def hello
     sleep(0.2)
   end
@@ -115,7 +115,7 @@ class BasicTest < Test::Unit::TestCase
     assert_in_delta(0, methods[2].wait_time, 0.01)
     assert_in_delta(0.1, methods[2].self_time, 0.01)
   end
-  
+
   if RUBY_VERSION < '1.9'
     PARENT = Object
   else
@@ -225,7 +225,7 @@ class BasicTest < Test::Unit::TestCase
     assert_equal('Class#new', names[3])
     assert(names.include?("<Class::#{PARENT}>#allocate"))
     assert(names.include?("#{PARENT}#initialize"))
-    
+
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
     assert_in_delta(0, methods[0].wait_time, 0.1)

data/test/duplicate_names_test.rb

@@ -19,10 +19,10 @@ class DuplicateNames < Test::Unit::TestCase
       eval str
       Foo::Bar.new.foo
     end
-    
+
     # There should be 3 foo methods
     methods = result.threads.values.first.sort.reverse
-    
+
     methods = methods.select do |method|
       method.full_name == 'DuplicateNames::Foo::Bar#foo'
     end

data/test/enumerable_test.rb

@@ -11,6 +11,6 @@ class EnumerableTest < Test::Unit::TestCase
     result = RubyProf.profile do
       3.times {  [1,2,3].any? {|n| n} }
     end
-    assert result.threads.to_a.first[1].length == 4    
+    assert result.threads.to_a.first[1].length == 4
   end
-end
+end

data/test/exceptions_test.rb

@@ -5,11 +5,11 @@ require 'ruby-prof'
 class ExceptionsTest < Test::Unit::TestCase
   def test_profile
     result = begin
-      RubyProf.profile do 
+      RubyProf.profile do
         raise(RuntimeError, 'Test error')
       end
     rescue => e
-    end    
+    end
     assert_not_nil(result)
   end
 end

data/test/exclude_threads_test.rb

@@ -6,49 +6,49 @@ require 'ruby-prof'
 
 # --  Tests ----
 class ExcludeThreadsTest < Test::Unit::TestCase
-  def test_exclude_threads
-
-    def thread1_proc
-      sleep(0.5)
-      sleep(2)
-    end
-
-    def thread2_proc
-      sleep(0.5)
-      sleep(2)
-    end
-        
-    thread1 = Thread.new do 
-      thread1_proc
-    end
-
-    thread2 = Thread.new do
-      thread2_proc
-    end
-
-    RubyProf::exclude_threads = [ thread2 ]
- 
-    RubyProf.start
-
-    thread1.join
-    thread2.join
-
-    result = RubyProf.stop
-
-    RubyProf::exclude_threads = nil
-
-    assert_equal(2, result.threads.length)
-
-    output = Array.new
-    result.threads.each do | thread_id, methods |
-      methods.each do | m |
-        if m.full_name.index("ExcludeThreadsTest#thread") == 0
-          output.push(m.full_name)
-        end
-      end
-    end
-
-    assert_equal(1, output.length)
-    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
+  def test_exclude_threads
+
+    def thread1_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    def thread2_proc
+      sleep(0.5)
+      sleep(2)
+    end
+
+    thread1 = Thread.new do
+      thread1_proc
+    end
+
+    thread2 = Thread.new do
+      thread2_proc
+    end
+
+    RubyProf::exclude_threads = [ thread2 ]
+
+    RubyProf.start
+
+    thread1.join
+    thread2.join
+
+    result = RubyProf.stop
+
+    RubyProf::exclude_threads = nil
+
+    assert_equal(2, result.threads.length)
+
+    output = Array.new
+    result.threads.each do | thread_id, methods |
+      methods.each do | m |
+        if m.full_name.index("ExcludeThreadsTest#thread") == 0
+          output.push(m.full_name)
+        end
+      end
+    end
+
+    assert_equal(1, output.length)
+    assert_equal("ExcludeThreadsTest#thread1_proc", output[0])
   end
-end
+end

data/test/exec_test.rb

@@ -9,6 +9,6 @@ class EnumerableTest < Test::Unit::TestCase
   def test_being_able_to_run_its_binary
     Dir.chdir(File.dirname(__FILE__)) do
       assert system(OS.ruby_bin + " ruby-prof-bin do_nothing.rb")
-    end    
+    end
   end
-end
+end

data/test/line_number_test.rb

@@ -7,12 +7,12 @@ class LineNumbers
   def method1
     a = 3
   end
-  
+
   def method2
     a = 3
     method1
   end
-  
+
   def method3
     sleep(1)
   end
@@ -22,30 +22,30 @@ end
 class LineNumbersTest < Test::Unit::TestCase
   def test_function_line_no
     numbers = LineNumbers.new
-    
+
     result = RubyProf.profile do
       numbers.method2
     end
 
     methods = result.threads.values.first.sort.reverse
     assert_equal(3, methods.length)
-    
+
     method = methods[0]
     assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
     assert_equal(27, method.line)
-    
+
     method = methods[1]
     assert_equal('LineNumbers#method2', method.full_name)
     assert_equal(11, method.line)
-    
+
     method = methods[2]
     assert_equal('LineNumbers#method1', method.full_name)
     assert_equal(7, method.line)
   end
-  
+
   def test_c_function
     numbers = LineNumbers.new
-    
+
     result = RubyProf.profile do
       numbers.method3
     end
@@ -61,13 +61,13 @@ class LineNumbersTest < Test::Unit::TestCase
     method = methods[0]
     assert_equal('Kernel#sleep', method.full_name)
     assert_equal(0, method.line)
-    
+
     method = methods[1]
     assert_equal('LineNumbers#method3', method.full_name)
     assert_equal(16, method.line)
-    
+
     method = methods[2]
     assert_equal('LineNumbersTest#test_c_function', method.full_name)
     assert_equal(50, method.line)
   end
-end
+end

data/test/measurement_test.rb

@@ -42,7 +42,7 @@ class MeasurementTest < Test::Unit::TestCase
       RubyProf::measure_mode = RubyProf::CPU_TIME
       assert_equal(RubyProf::CPU_TIME, RubyProf::measure_mode)
     end
-    
+
     def test_cpu_time
       RubyProf.cpu_frequency = 2.33e9
 
@@ -82,8 +82,9 @@ class MeasurementTest < Test::Unit::TestCase
       u = RubyProf.measure_memory
       assert(u >= t, [t, u].inspect)
 
+      RubyProf::measure_mode = RubyProf::MEMORY
       result = RubyProf.profile {Array.new}
-      total = result.threads.values.first.methods.inject(0) { |sum, m| sum + m.total_time }
+      total = result.threads.values.first.inject(0) { |sum, m| sum + m.total_time }
 
       assert(total > 0, 'Should measure more than zero kilobytes of memory usage')
       assert_not_equal(0, total % 1, 'Should not truncate fractional kilobyte measurements')
@@ -118,4 +119,4 @@ class MeasurementTest < Test::Unit::TestCase
       assert u > t, [t, u].inspect
     end
   end
-end
+end

data/test/method_elimination_test.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'tmpdir'
+
+# Test data
+#     A
+#    / \
+#   B   C
+#        \
+#         B
+
+class ESTPT
+  def a
+    100.times{b}
+    300.times{c}
+    c;c;c
+  end
+
+  def b
+    sleep 0
+  end
+
+  def c
+    5.times{b}
+  end
+end
+
+class MethodEliminationTest < 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_setting_parent
+    result = RubyProf.profile do
+      1000.times { 1+1 }
+    end
+    method_infos = result.threads.values.first
+    assert(m1 = method_infos[0])
+    assert(c1 = m1.call_infos.first)
+    assert_equal(c1, c1.parent = c1)
+    assert_equal c1, c1.parent
+  end
+
+  def test_methods_can_be_eliminated
+    RubyProf.start
+    5.times{ESTPT.new.a}
+    result = RubyProf.stop
+    # result.dump
+    eliminated = result.eliminate_methods!([/Integer#times/])
+    # puts eliminated.inspect
+    # result.dump
+    eliminated.each do |m|
+      assert_method_has_been_eliminated(result, m)
+    end
+  end
+
+  private
+  def assert_method_has_been_eliminated(result, eliminated_method)
+    result.threads.each do |thread_id, methods|
+      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
+          ci.children.each do |callee|
+            assert(callee.target != eliminated_method, "broken kid")
+          end
+        end
+      end
+    end
+  end
+end