ruby-prof 0.11.0.rc1 → 0.11.0.rc2

data/lib/ruby-prof/profile.rb

@@ -3,16 +3,31 @@
 require 'set'
 module RubyProf
   class Profile
-    # this method gets called internally when profiling is stopped.
-    # it determines for each call_info whether it is minimal: a
-    # call_info is minimal in a call tree if the call_info is not a
-    # descendant of a call_info of the same method
-    def compute_minimality
-      threads.each do |threadid, method_infos|
-        root_methods = method_infos.select{|mi| mi.root?}
-        root_methods.each do |mi|
-          mi.call_infos.select{|ci| ci.root?}.each do |call_info_root|
-            call_info_root.compute_minimality(Set.new)
+    # This method gets called once profiling has been completed
+    # but before results are returned to the user.  Thus it provides
+    # a hook to do any necessary post-processing on the call graph.
+    def post_process
+      self.threads.each do |thread|
+        detect_recursion(thread)
+      end
+    end
+
+    # This method detect recursive calls in the call graph.
+    def detect_recursion(thread)
+      visited_methods = Hash.new do |hash, key|
+        hash[key] = 0
+      end
+
+      visitor = CallInfoVisitor.new(thread)
+      visitor.visit do |call_info, event|
+        case event
+        when :enter
+          visited_methods[call_info.target] += 1
+          call_info.recursive = (visited_methods[call_info.target] > 1)
+        when :exit
+          visited_methods[call_info.target] -= 1
+          if visited_methods[call_info.target] == 0
+            visited_methods.delete(call_info.target)
           end
         end
       end
@@ -23,22 +38,12 @@ module RubyProf
     def eliminate_methods!(matchers)
       matchers = read_regexps_from_file(matchers) if matchers.is_a?(String)
       eliminated = []
-      threads.each do |thread_id, methods|
-        matchers.each{ |matcher| eliminated.concat(eliminate_methods(methods, matcher)) }
+      threads.each do |thread|
+        matchers.each{ |matcher| eliminated.concat(eliminate_methods(thread.methods, matcher)) }
       end
-      compute_minimality # is this really necessary?
       eliminated
     end
 
-    def dump
-      threads.each do |thread_id, methods|
-        $stderr.puts "Call Info Dump for thread id #{thread_id}"
-        methods.each do |method_info|
-          $stderr.puts method_info.dump
-        end
-      end
-    end
-
     private
 
     # read regexps from file

data/lib/ruby-prof/rack.rb

@@ -1,29 +1,39 @@
 # encoding: utf-8
+require 'tmpdir'
 
 module Rack
   class RubyProf
-    def initialize(app)
+    def initialize(app, options = {})
       @app = app
+      @options = options
+      @options[:min_percent] ||= 1
+      @tmpdir = options[:path] || Dir.tmpdir
+      @printer_klasses = {::RubyProf::FlatPrinter => 'flat.txt',
+                          ::RubyProf::GraphPrinter => 'graph.txt',
+                          ::RubyProf::GraphHtmlPrinter => 'graph.html',
+                          ::RubyProf::CallStackPrinter => 'call_stack.html'}
     end
 
     def call(env)
-      ::RubyProf.start
-      result = @app.call(env)
-      data = ::RubyProf.stop
+      result = nil
+      data = ::RubyProf::Profile.profile do
+        result = @app.call(env)
+      end
+
+      request = Rack::Request.new(env)
+      path = request.path.gsub('/', '-')
+      path.slice!(0)
 
-      print(data)
+      print(data, path)
       result
     end
 
-    def print(data)
-      require 'tmpdir' # late require so we load on demand only
-      printers = {::RubyProf::FlatPrinter => ::File.join(Dir.tmpdir, 'profile.txt'),
-                  ::RubyProf::GraphHtmlPrinter => ::File.join(Dir.tmpdir, 'profile.html')}
-
-      printers.each do |printer_klass, file_name|
+    def print(data, path)
+      @printer_klasses.each do |printer_klass, base_name|
         printer = printer_klass.new(data)
+        file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
         ::File.open(file_name, 'wb') do |file|
-          printer.print(file, :min_percent => 0.00000001 )
+          printer.print(file, @options)
         end
       end
     end

data/ruby-prof.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+# Read version from header file
+version_header = File.read(File.expand_path('../ext/ruby_prof/version.h', __FILE__))
+#match = version_header.match(/RUBY_PROF_VERSION\s*"(\.+)"/)
+match = version_header.match(/RUBY_PROF_VERSION\s*"([^"]+)"/)
+raise(RuntimeError, "Could not determine RUBY_PROF_VERSION") if not match
+
+# For now make this an rc1
+RUBY_PROF_VERSION = "#{match[1]}.rc2"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-prof"
+
+  spec.homepage = "http://rubyforge.org/projects/ruby-prof/"
+  spec.summary = "Fast Ruby profiler"
+  spec.description = <<-EOF
+ruby-prof is a fast code profiler for Ruby. It is a C extension and
+therefore is many times faster than the standard Ruby profiler. It
+supports both flat and graph profiles.  For each method, graph profiles
+show how long the method ran, which methods called it and which
+methods it called. RubyProf generate both text and html and can output
+it to standard out or to a file.
+EOF
+
+  spec.version = RUBY_PROF_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
+  spec.require_path = "lib"
+  spec.bindir = "bin"
+  spec.executables = ["ruby-prof"]
+  spec.extensions = ["ext/ruby_prof/extconf.rb"]
+  spec.files = Dir['CHANGES',
+                   'LICENSE',
+                   'Rakefile',
+                   'README.rdoc',
+                   'ruby-prof.gemspec',
+                   'bin/ruby-prof',
+                   'doc/**/*',
+                   'examples/*',
+                   'ext/ruby_prof/extconf.rb',
+                   'ext/ruby_prof/*.c',
+                   'ext/ruby_prof/*.h',
+                   'ext/ruby_prof/vc/*.sln',
+                   'ext/ruby_prof/vc/*.vcxproj',
+                   'lib/ruby-prof/*.rb',
+                   'lib/ruby-prof/images/*.png',
+                   'lib/ruby-prof/printers/*.rb',
+                   'test/*.rb']
+
+  spec.test_files = Dir["test/test_*.rb"]
+  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'
+end

data/test/aggregate_test.rb

@@ -34,17 +34,17 @@ class AggregateTest < Test::Unit::TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
-  def test_all_call_infos_are_minimal_as_there_is_no_recursion
+  def test_all_call_infos_are_not_recursive
     c1 = AggClass.new
     result = RubyProf.profile do
       c1.a
       c1.b
       c1.c
     end
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.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"
+        assert(!ci.recursive)
       end
     end
   end
@@ -57,7 +57,7 @@ class AggregateTest < Test::Unit::TestCase
       c1.c
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     method = methods.find {|meth| meth.full_name == 'AggClass#z'}
 
     # Check AggClass#z
@@ -90,7 +90,7 @@ class AggregateTest < Test::Unit::TestCase
       c1.c
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     method = methods.find {|meth| meth.full_name == 'AggClass#z'}
 
     # Check AggClass#z
@@ -116,7 +116,7 @@ class AggregateTest < Test::Unit::TestCase
       c1.c
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     method = methods.find {|meth| meth.full_name == 'AggClass#a'}
 
     # Check AggClass#a

data/test/call_info_visitor_test.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class CallInfoVisitorTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::CPU_TIME
+  end
+
+  def test_visit
+    result = RubyProf.profile do
+      RubyProf::C1.hello
+    end
+
+    visitor = RubyProf::CallInfoVisitor.new(result.threads.first)
+
+    method_names = Array.new
+
+    visitor.visit do |call_info, event|
+      method_names << call_info.target.full_name if event == :enter
+    end
+
+    assert_equal(3, method_names.length)
+    assert_equal("CallInfoVisitorTest#test_visit", method_names[0])
+    assert_equal("<Class::RubyProf::C1>#hello", method_names[1])
+    assert_equal("Kernel#sleep", method_names[2])
+  end
+end
+

data/test/duplicate_names_test.rb

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

data/test/dynamic_method_test.rb

@@ -19,7 +19,7 @@ class DynamicMethodTest < Test::Unit::TestCase
     #  Integer#times
     #  DynamicMethodTest#test_dynamic_method
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(7, methods.length)
 
     # Check times

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_equal(result.threads.first.methods.length, 4)
   end
 end

data/test/exclude_threads_test.rb

@@ -40,8 +40,8 @@ class ExcludeThreadsTest < Test::Unit::TestCase
     assert_equal(2, result.threads.length)
 
     output = Array.new
-    result.threads.each do | thread_id, methods |
-      methods.each do | m |
+    result.threads.each do |thread|
+      thread.methods.each do | m |
         if m.full_name.index("ExcludeThreadsTest#thread") == 0
           output.push(m.full_name)
         end

data/test/gc_test.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class GcTest < 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 run_profile
+    RubyProf.profile do
+      RubyProf::C1.hello
+    end
+  end
+
+  def test_gc
+    result = run_profile
+
+    thread = result.threads.first
+    method = thread.methods.first
+    call_info = method.call_infos.first
+
+    result = nil
+
+    1000.times do
+      GC.start
+      Array.new(1000)
+    end
+
+    puts thread.methods
+    puts method.full_name
+  end
+end

data/test/line_number_test.rb

@@ -27,7 +27,7 @@ class LineNumbersTest < Test::Unit::TestCase
       numbers.method2
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     method = methods[0]
@@ -50,7 +50,7 @@ class LineNumbersTest < Test::Unit::TestCase
       numbers.method3
     end
 
-    methods = result.threads.values.first.sort_by {|method| method.full_name}
+    methods = result.threads.first.methods.sort_by {|method| method.full_name}
     assert_equal(3, methods.length)
 
     # Methods:

data/test/measure_cpu_time_test.rb

@@ -31,7 +31,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   <Class::RubyProf::C1>#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     # Check the names
@@ -66,7 +66,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   C1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
@@ -113,7 +113,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
@@ -147,7 +147,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
@@ -195,7 +195,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
       c3.hello
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(2, methods.length)
 
     assert_equal('MeasureCpuTimeTest#test_singleton', methods[0].full_name)

data/test/measure_process_time_test.rb

@@ -28,7 +28,7 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     #   <Class::RubyProf::C1>#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     puts methods[0].total_time
 
     assert_equal(3, methods.length)
@@ -63,7 +63,7 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     #   C1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
 
     # Check times
@@ -108,7 +108,7 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(3, methods.length)
 
     # Check times
@@ -141,7 +141,7 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
     #   M1#hello
     #   Kernel#sleep
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(6, methods.length)
 
     # Check times
@@ -188,7 +188,7 @@ class MeasureProcessTimeTest < Test::Unit::TestCase
       c3.hello
     end
 
-    methods = result.threads.values.first.sort.reverse
+    methods = result.threads.first.methods.sort.reverse
     assert_equal(2, methods.length)
 
     assert_equal("MeasureProcessTimeTest#test_singleton", methods[0].full_name)