ruby-prof 0.6.0-x86-mswin32-60 → 0.7.0-x86-mswin32-60

data/ext/version.h

@@ -0,0 +1,4 @@
+#define RUBY_PROF_VERSION  "0.7.0"
+#define RUBY_PROF_VERSION_MAJ   0
+#define RUBY_PROF_VERSION_MIN   7
+#define RUBY_PROF_VERSION_MIC   0

data/lib/ruby-prof.rb

@@ -1,10 +1,14 @@
 require "ruby_prof.so"
 
+require "ruby-prof/method_info"
+require "ruby-prof/call_info"
 require "ruby-prof/flat_printer"
 require "ruby-prof/graph_printer"
 require "ruby-prof/graph_html_printer"
 require "ruby-prof/call_tree_printer"
 
+require "ruby-prof/test"
+
 module RubyProf
   # See if the user specified the clock mode via 
   # the RUBY_PROF_MEASURE_MODE environment variable

data/lib/ruby-prof/call_info.rb

@@ -0,0 +1,47 @@
+module RubyProf
+  class CallInfo
+    def depth
+      result = 0
+      call_info = self.parent
+
+      while call_info
+        result += 1
+        call_info = call_info.parent
+      end
+      result
+    end
+
+    def children_time
+      children.inject(0) do |sum, call_info|
+        sum += call_info.total_time
+      end
+    end
+
+    def stack
+      @stack ||= begin
+        methods = Array.new
+        call_info = self
+
+        while call_info
+          methods << call_info.target
+          call_info = call_info.parent
+        end
+        methods.reverse
+      end
+    end
+
+    def call_sequence
+      @call_sequence ||= begin
+        stack.map {|method| method.full_name}.join('->')
+      end
+    end
+
+    def root?
+      self.parent.nil?
+    end
+    
+    def to_s
+      "#{call_sequence}"
+    end
+  end
+end

data/lib/ruby-prof/call_tree_printer.rb

@@ -27,8 +27,16 @@ module RubyProf
         when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
           @value_scale = 1
           @output << 'memory'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @output << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @output << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
       end
-      @output << "\n\n"  
+      @output << "\n\n"
 
       print_threads
     end

data/lib/ruby-prof/graph_html_printer.rb

@@ -115,6 +115,7 @@ module RubyProf
       font-family: Verdana, Arial, Helvetica, sans-serif;
       font-size: 9pt;
       line-height: normal;
+      width: 100%;
     }
 
     th {
@@ -152,7 +153,6 @@ module RubyProf
 
     .method_name {
       text-align: left;
-      max-width: 25em;
     }
   </style>
   </head>
@@ -198,8 +198,9 @@ module RubyProf
             self_percentage = (method.self_time/total_time) * 100 %>
           
             <!-- Parents -->
-            <% for caller in method.parents %>
-            <%   next if min_time && caller.total_time < min_time  %>
+            <% for caller in method.call_infos
+                 next unless caller.parent
+                 next if min_time && caller.total_time < min_time  %>
               <tr>
                 <td>&nbsp;</td>
                 <td>&nbsp;</td>
@@ -209,8 +210,8 @@ module RubyProf
                 <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.children_time) %></td>
                 <% called = "#{caller.called}/#{method.called}" %>
                 <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
-                <td class="method_name"><%= create_link(thread_id, caller.target) %></td>
-                <td><a href="file://<%=h srcfile=File.expand_path(caller.target.source_file) %>#line=<%= linenum=caller.line %>" title="<%=h srcfile %>:<%= linenum %>"><%= caller.line %></a></td>
+                <td class="method_name"><%= create_link(thread_id, caller.parent.target) %></td>
+                <td><a href="file://<%=h srcfile=File.expand_path(caller.parent.target.source_file) %>#line=<%= linenum=caller.line %>" title="<%=h srcfile %>:<%= linenum %>"><%= caller.line %></a></td>
               </tr>
             <% end %>
 

data/lib/ruby-prof/graph_printer.rb

@@ -127,7 +127,8 @@ module RubyProf
     end
     
     def print_parents(thread_id, method)
-      method.parents.each do |caller|
+      method.call_infos.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)
@@ -136,7 +137,7 @@ module RubyProf
     
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("     %s", caller.target.full_name)
+        @output << sprintf("     %s", caller.parent.target.full_name)
         @output << "\n"
       end
     end

data/lib/ruby-prof/method_info.rb

@@ -0,0 +1,85 @@
+module RubyProf
+  class MethodInfo
+    include Comparable
+
+    def <=>(other)
+      if self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      elsif self.min_depth < other.min_depth
+        1
+      elsif self.min_depth > other.min_depth
+        -1
+      else
+        -1 * (self.full_name <=> other.full_name)
+      end
+    end
+
+    def called
+      @called ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.called
+        end
+      end
+    end
+
+    def total_time
+      @total_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.total_time
+        end
+      end
+    end
+    
+    def self_time
+      @self_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.self_time
+        end
+      end
+    end
+
+    def wait_time
+      @wait_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.wait_time
+        end
+      end
+    end
+
+    def children
+      @children ||= begin
+        call_infos.map do |call_info|
+          call_info.children
+        end.flatten
+      end
+    end
+
+    def children_time
+      @children_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.children_time
+        end
+      end
+    end
+
+    def min_depth
+      call_infos.map do |call_info|
+        call_info.depth
+      end.min
+    end
+
+    def root?
+      @root ||= begin
+        call_infos.find do |call_info|
+          not call_info.root?
+        end.nil?
+      end
+    end
+
+    def to_s
+      full_name
+    end
+  end
+end

data/lib/ruby-prof/task.rb

@@ -143,5 +143,4 @@ module RubyProf
       ENV['OPTIONS'] || @options.join(" ") || ""
     end
   end
-end
-
+end

data/lib/ruby-prof/test.rb

@@ -0,0 +1,148 @@
+# Now load ruby-prof and away we go
+require 'fileutils'
+require 'ruby-prof'
+require 'benchmark'
+
+module RubyProf
+  module Test
+    PROFILE_OPTIONS = {
+      :measure_modes => [RubyProf::PROCESS_TIME],
+      :count => 10,
+      :printers => [RubyProf::FlatPrinter, RubyProf::GraphHtmlPrinter],
+      :min_percent => 0.05,
+      :output_dir => Dir.pwd }
+
+    def output_dir
+      PROFILE_OPTIONS[:output_dir]
+    end
+          
+    def run(result)
+      return if @method_name.to_s == "default_test"
+
+      yield(self.class::STARTED, name)
+      @_result = result
+      run_warmup
+      PROFILE_OPTIONS[:measure_modes].each do |measure_mode|
+        data = run_profile(measure_mode)
+        report_profile(data, measure_mode)
+        result.add_run
+      end
+      yield(self.class::FINISHED, name)
+    end
+
+    def run_test
+      begin
+        setup
+        yield
+      rescue ::Test::Unit::AssertionFailedError => e
+        add_failure(e.message, e.backtrace)
+      rescue StandardError, ScriptError
+        add_error($!)
+      ensure
+        begin
+          teardown
+        rescue ::Test::Unit::AssertionFailedError => e
+          add_failure(e.message, e.backtrace)
+        rescue StandardError, ScriptError
+          add_error($!)
+        end
+      end
+    end
+
+    def run_warmup
+      print "\n#{self.class.name}##{method_name}"
+
+      run_test do
+        bench = Benchmark.realtime do
+          __send__(@method_name)
+        end
+        puts " (%.2fs warmup)" % bench
+      end
+    end
+
+    def run_profile(measure_mode)
+      RubyProf.measure_mode = measure_mode
+
+      print '  '
+      PROFILE_OPTIONS[:count].times do |i|
+        run_test do
+          begin
+            print '.'
+            $stdout.flush
+            GC.disable
+
+            RubyProf.resume do
+              __send__(@method_name)
+            end
+          ensure
+            GC.enable
+          end
+        end
+      end
+
+      data = RubyProf.stop
+      bench = data.threads.values.inject(0) do |total, method_infos|
+        top = method_infos.sort.last
+        total += top.total_time
+        total
+      end
+
+      puts "\n  #{measure_mode_name(measure_mode)}: #{format_profile_total(bench, measure_mode)}\n"
+
+      data
+    end
+
+    def format_profile_total(total, measure_mode)
+      case measure_mode
+        when RubyProf::PROCESS_TIME, RubyProf::WALL_TIME
+          "%.2f seconds" % total
+        when RubyProf::MEMORY
+          "%.2f kilobytes" % total
+        when RubyProf::ALLOCATIONS
+          "%d allocations" % total
+        else
+          "%.2f #{measure_mode}"
+      end
+    end
+
+    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)
+
+        # Open the file
+        file_name = report_filename(printer, measure_mode)
+
+        File.open(file_name, 'wb') do |file|
+          printer.print(file, PROFILE_OPTIONS)
+        end
+      end
+    end
+
+    # The report filename is test_name + measure_mode + report_type
+    def report_filename(printer, measure_mode)
+      suffix =
+        case printer
+          when RubyProf::FlatPrinter; 'flat.txt'
+          when RubyProf::GraphPrinter; 'graph.txt'
+          when RubyProf::GraphHtmlPrinter; 'graph.html'
+          when RubyProf::CallTreePrinter; 'tree.txt'
+          else printer.to_s.downcase
+        end
+
+      "#{output_dir}/#{method_name}_#{measure_mode_name(measure_mode)}_#{suffix}"
+    end
+
+    def measure_mode_name(measure_mode)
+      case measure_mode
+        when RubyProf::PROCESS_TIME; 'process_time'
+        when RubyProf::WALL_TIME; 'wall_time'
+        when RubyProf::MEMORY; 'memory'
+        when RubyProf::ALLOCATIONS; 'allocations'
+        else "measure#{measure_mode}"
+      end
+    end
+  end
+end

data/rails/environment/profile.rb

@@ -0,0 +1,24 @@
+# Settings specified here will take precedence over those in config/environment.rb
+# The profile environment should match the same settings
+# as the production environment to give a reasonalbe
+# approximation of performance.  However, it should
+# definitely not use the production databse!
+
+
+# Cache classes - otherwise your code 
+# will run approximately 5 times slower and the
+# profiling results will be overwhelmed by Rails
+# dependency loading mechanism
+config.cache_classes = true
+
+# Don't check template timestamps - once again this
+# is to avoid IO times overwhelming profile results
+config.action_view.cache_template_loading            = true
+
+# This is debatable, but turn off action controller
+# caching to see how long it really takes to run
+# queries and render templates
+config.action_controller.perform_caching             = false
+
+# Turn off most logging
+config.log_level = :info

data/rails/example/example_test.rb

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

data/rails/profile_test_helper.rb

@@ -0,0 +1,21 @@
+# Load profile environment
+env = ENV["RAILS_ENV"] = "profile"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+
+# Load Rails testing infrastructure
+require 'test_help'
+
+# Now we can load test_helper since we've already loaded the
+# profile RAILS environment.
+require File.expand_path(File.join(RAILS_ROOT, 'test', 'test_helper'))
+
+# Reset the current environment back to profile
+# since test_helper reset it to test
+ENV["RAILS_ENV"] = env
+
+# Now load ruby-prof and away we go
+require 'ruby-prof'
+
+# Setup output directory to Rails tmp directory
+RubyProf::Test::PROFILE_OPTIONS[:output_dir] = 
+    File.expand_path(File.join(RAILS_ROOT, 'tmp', 'profile'))

data/test/basic_test.rb

@@ -2,10 +2,6 @@
 
 require 'test/unit'
 require 'ruby-prof'
-require 'test_helper'
-
-# Need to use wall time for this test due to the sleep calls
-RubyProf::measure_mode = RubyProf::WALL_TIME
 
 class C1
   def C1.hello
@@ -55,6 +51,11 @@ class C6
 end
 
 class BasicTest < 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_running
     assert(!RubyProf.running?)
     RubyProf.start
@@ -62,13 +63,13 @@ class BasicTest < Test::Unit::TestCase
     RubyProf.stop
     assert(!RubyProf.running?)
   end
-  
+
   def test_double_profile
     RubyProf.start
     assert_raise(RuntimeError) do
       RubyProf.start
     end
-    
+
     assert_raise(RuntimeError) do
       RubyProf.profile do
         puts 1
@@ -76,115 +77,207 @@ class BasicTest < Test::Unit::TestCase
     end
     RubyProf.stop
   end
-  
+
   def test_no_block
     assert_raise(ArgumentError) do
       RubyProf.profile
     end
   end
-  
-  def test_class_and_instance_methods
+
+  def test_class_methods
     result = RubyProf.profile do
       C1.hello
-      C1.new.hello
     end
-    
-    methods = result.threads.values.first
-    
-    # Length should be 7:
-    #   1 test_class_and_instance_methods (this method)
-    #   1 Class.new
-    #   1 Class:Object allocate
-    #   1 for Object.initialize
-    #   1 for Class hello
-    #   1 for Object hello
-    #   1 sleep
-    assert_equal(7, methods.length)
-    
+
+    # Length should be 3:
+    #   BasicTest#test_class_methods
+    #   <Class::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
     # Check the names
-    methods = methods.sort.reverse
-    
-    assert_equal('BasicTest#test_class_and_instance_methods', methods[0].full_name)
-    assert_equal('Kernel#sleep', methods[1].full_name)
-    assert_equal('C1#hello', methods[2].full_name)
-    assert_equal('<Class::C1>#hello', methods[3].full_name)
-    
-    # The last three methods have total times of zero
-    assert_equal(0, methods[4].total_time)
-    assert_equal(0, methods[5].total_time)
-    assert_equal(0, methods[6].total_time)
-    
-    #assert_equal('Class#new', methods[4].full_name)
-    #assert_equal('<Class::Object>#allocate', methods[5].full_name)
-    #assert_equal('Object#initialize', methods[6].full_name)
+    assert_equal('BasicTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    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_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_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)
   end
-  
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      C1.new.hello
+    end
+
+    # Methods called
+    #   BasicTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+
+    assert_equal('BasicTest#test_instance_methods', methods[0].full_name)
+    assert_equal('C1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_equal('Class#new', methods[3].full_name)
+    assert_equal('<Class::Object>#allocate', methods[4].full_name)
+    assert_equal('Object#initialize', methods[5].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[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_in_delta(0.2, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.2, methods[2].self_time, 0.01)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
   def test_module_methods
     result = RubyProf.profile do
       C2.hello
+    end
+
+    # Methods:
+    #   BasicTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+    assert_equal('M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.3, 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.3, 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_in_delta(0.3, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.01)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
       C2.new.hello
     end
-  
-    methods = result.threads.values.first
-   
-    # Length should be 6:
-    #   1 BasicTest#test_module_methods (this method)
-    #   1 Class#new
-    #   1 <Class::Object>#allocate
-    #   1 Object#initialize
-    #   1 M1#hello
-    #   1 Kernel#sleep
 
+    # Methods:
+    #   BasicTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
     assert_equal(6, methods.length)
 
-    # Check the names
-    methods = methods.sort.reverse
-    
-    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
-    assert_equal('Kernel#sleep', methods[1].full_name)
-    assert_equal('M1#hello', methods[2].full_name)
-    
-    # The last three methods have times of zero
-    assert_equal(0, methods[3].total_time)
-    assert_equal(0, methods[4].total_time)
-    assert_equal(0, methods[5].total_time)
-    
-    #assert_equal('<Class::Object>#allocate', methods[3].full_name)
-    #assert_equal('Class#new', methods[4].full_name)
-    #assert_equal('Object#initialize', methods[5].full_name)
+    assert_equal('BasicTest#test_module_instance_methods', methods[0].full_name)
+    assert_equal('M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_equal('Class#new', methods[3].full_name)
+    assert_equal('<Class::Object>#allocate', methods[4].full_name)
+    assert_equal('Object#initialize', methods[5].full_name)
+
+    # Check times
+    assert_in_delta(0.3, 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.3, 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_in_delta(0.3, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.01)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
   end
-  
+
   def test_singleton
     c3 = C3.new
-    
+
     class << c3
       def hello
       end
     end
-  
+
     result = RubyProf.profile do
       c3.hello
     end
-  
-    methods = result.threads.values.first
-    
-    # Length should be 2 - one for top level
-    # and one for the singleton method.
+
+    methods = result.threads.values.first.sort.reverse
     assert_equal(2, methods.length)
-    
-    # Check singleton method
-    methods = methods.sort.reverse
-    
+
     assert_equal('BasicTest#test_singleton', methods[0].full_name)
     assert_equal('<Object::C3>#hello', methods[1].full_name)
+
+    assert_in_delta(0, 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, 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)
   end
-  
+
   def test_traceback
     RubyProf.start
     assert_raise(NoMethodError) do
       RubyProf.xxx
     end
-    
+
     RubyProf.stop
-  end   
-end
+  end
+end