ruby-prof 0.8.1-x86-mingw32 → 0.11.0.rc1-x86-mingw32

data/lib/ruby-prof/multi_printer.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module RubyProf
+  # Helper class to simplify printing profiles of several types from
+  # one profiling run. Currently prints a flat profile, a callgrind
+  # profile, a call stack profile and a graph profile.
+  class MultiPrinter
+    def initialize(result)
+      @stack_printer = CallStackPrinter.new(result)
+      @graph_printer = GraphHtmlPrinter.new(result)
+      @tree_printer = CallTreePrinter.new(result)
+      @flat_printer = FlatPrinter.new(result)
+    end
+
+    # create profile files under options[:path] or the current
+    # directory. options[:profile] is used as the base name for the
+    # pofile file, defaults to "profile".
+    def print(options)
+      @profile = options.delete(:profile) || "profile"
+      @directory = options.delete(:path) || File.expand_path(".")
+      File.open(stack_profile, "w") do |f|
+        @stack_printer.print(f, options.merge(:graph => "#{@profile}.graph.html"))
+      end
+      File.open(graph_profile, "w") do |f|
+        @graph_printer.print(f, options)
+      end
+      File.open(tree_profile, "w") do |f|
+        @tree_printer.print(f, options)
+      end
+      File.open(flat_profile, "w") do |f|
+        @flat_printer.print(f, options)
+      end
+    end
+
+    # the name of the call stack profile file
+    def stack_profile
+      "#{@directory}/#{@profile}.stack.html"
+    end
+
+    # the name of the graph profile file
+    def graph_profile
+      "#{@directory}/#{@profile}.graph.html"
+    end
+
+    # the name of the callgrind profile file
+    def tree_profile
+      "#{@directory}/#{@profile}.grind.dat"
+    end
+
+    # the name of the flat profile file
+    def flat_profile
+      "#{@directory}/#{@profile}.flat.txt"
+    end
+
+  end
+end

data/lib/ruby-prof/profile.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+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)
+          end
+        end
+      end
+    end
+
+    # eliminate some calls from the graph by merging the information into callers.
+    # matchers can be a list of strings or regular expressions or the name of a file containing regexps.
+    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)) }
+      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
+    def read_regexps_from_file(file_name)
+      matchers = []
+      File.open(matchers).each_line do |l|
+        next if (l =~ /^(#.*|\s*)$/) # emtpy lines and lines starting with #
+        matchers << Regexp.new(l.strip)
+      end
+    end
+
+    # eliminate methods matching matcher
+    def eliminate_methods(methods, matcher)
+      eliminated = []
+      i = 0
+      while i < methods.size
+        method_info = methods[i]
+        method_name = method_info.full_name
+        if matcher === method_name
+          raise "can't eliminate root method" if method_info.root?
+          eliminated << methods.delete_at(i)
+          method_info.eliminate!
+        else
+          i += 1
+        end
+      end
+      eliminated
+    end
+
+  end
+end

data/lib/ruby-prof/rack.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rack
+  class RubyProf
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      ::RubyProf.start
+      result = @app.call(env)
+      data = ::RubyProf.stop
+
+      print(data)
+      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|
+        printer = printer_klass.new(data)
+        ::File.open(file_name, 'wb') do |file|
+          printer.print(file, :min_percent => 0.00000001 )
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/symbol_to_proc.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 unless (:a.respond_to?(:to_proc))
  class Symbol
    def to_proc
@@ -5,4 +7,4 @@ unless (:a.respond_to?(:to_proc))
    end
  end
 end
- 
+

data/lib/ruby-prof/task.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# encoding: utf-8
 
 require 'rake'
 require 'rake/testtask'
@@ -15,7 +16,7 @@ module RubyProf
   #
   # ruby-prof specific options include:
   #
-  #   output_dir - For each file specified an output 
+  #   output_dir - For each file specified an output
   #                file with profile information will be
   #                written to the output directory.
   #                By default, the output directory is
@@ -29,9 +30,9 @@ module RubyProf
   #                 will not be written out.
   #
   # Example:
-  #   
+  #
   #   require 'ruby-prof/task'
-  #   
+  #
   #   RubyProf::ProfileTask.new do |t|
   #     t.test_files = FileList['test/test*.rb']
   #     t.output_dir = "c:/temp"
@@ -55,37 +56,37 @@ module RubyProf
   #   rake profile TEST=just_one_file.rb     # run just one test file.
   #   rake profile TESTOPTS="-v"             # run in verbose mode
   #   rake profile TESTOPTS="--runner=fox"   # use the fox test runner
-  
+
   class ProfileTask < Rake::TestTask
-    attr_accessor :output_dir 
-    attr_accessor :min_percent 
+    attr_accessor :output_dir
+    attr_accessor :min_percent
     attr_accessor :printer
-    
+
     def initialize(name = :profile)
       super(name)
     end
-    
+
     # Create the tasks defined by this task lib.
     def define
       lib_path = @libs.join(File::PATH_SEPARATOR)
       desc "Profile" + (@name==:profile ? "" : " for #{@name}")
-      
+
       task @name do
         create_output_directory
-        
+
         @ruby_opts.unshift( "-I#{lib_path}" )
         @ruby_opts.unshift( "-w" ) if @warning
         @ruby_opts.push("-S ruby-prof")
         @ruby_opts.push("--printer #{@printer}")
         @ruby_opts.push("--min_percent #{@min_percent}")
 
-        file_list.each do |file_path|  
+        file_list.each do |file_path|
           run_script(file_path)
         end
       end
       self
     end
-    
+
     # Run script
     def run_script(script_path)
       run_code = ''
@@ -99,14 +100,14 @@ module RubyProf
           else
             file_name += ".txt"
         end
-          
+
         output_file_path = File.join(output_directory, file_name)
-          
-        command_line = @ruby_opts.join(" ") + 
+
+        command_line = @ruby_opts.join(" ") +
                       " --file=" + output_file_path +
                       " " + script_path
 
-        puts "ruby " + command_line 
+        puts "ruby " + command_line
         # We have to catch the exeption to continue on.  However,
         # the error message will have been output to STDERR
         # already by the time we get here so we don't have to
@@ -125,7 +126,7 @@ module RubyProf
     def output_directory
       File.expand_path(@output_dir)
     end
-    
+
     def create_output_directory
       if not File.exist?(output_directory)
         Dir.mkdir(output_directory)
@@ -138,9 +139,9 @@ module RubyProf
         FileUtils.rm(files)
       end
     end
-    
+
     def option_list # :nodoc:
       ENV['OPTIONS'] || @options.join(" ") || ""
     end
   end
-end
+end

data/lib/ruby-prof/test.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Now load ruby-prof and away we go
 require 'fileutils'
 require 'ruby-prof'
@@ -15,7 +17,7 @@ module RubyProf
     def output_dir
       PROFILE_OPTIONS[:output_dir]
     end
-          
+
     def run(result)
       return if @method_name.to_s == "default_test"
 
@@ -108,7 +110,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 +147,4 @@ module RubyProf
       end
     end
   end
-end
+end

data/lib/unprof.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "ruby-prof"
 
 at_exit {

data/test/aggregate_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
+# encoding: UTF-8
 
-require 'test/unit'
-require 'ruby-prof'
+require File.expand_path('../test_helper', __FILE__)
 
 # Test data
 #   A   B   C
@@ -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,15 +58,15 @@ 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)
     assert_equal(3, method.called)
-    assert_in_delta(3, method.total_time, 0.01)
-    assert_in_delta(0, method.wait_time, 0.01)
-    assert_in_delta(0, method.self_time, 0.01)
-    assert_in_delta(3, method.children_time, 0.01)
+    assert_in_delta(3, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(3, method.children_time, 0.05)
     assert_equal(3, method.call_infos.length)
 
     call_info = method.call_infos[0]
@@ -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)
@@ -87,7 +102,7 @@ class AggregateTest < Test::Unit::TestCase
     call_info = call_infos.first
     assert_equal('AggClass#a', call_info.parent.target.full_name)
     assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.01)
+    assert_in_delta(0, call_info.wait_time, 0.05)
     assert_in_delta(0, call_info.self_time, 0.05)
     assert_in_delta(3, call_info.children_time, 0.05)
     assert_equal(3, call_info.called)
@@ -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)
@@ -113,9 +128,9 @@ class AggregateTest < Test::Unit::TestCase
     call_info = call_infos.first
     assert_equal('AggClass#z', call_info.target.full_name)
     assert_in_delta(3, call_info.total_time, 0.05)
-    assert_in_delta(0, call_info.wait_time, 0.01)
+    assert_in_delta(0, call_info.wait_time, 0.05)
     assert_in_delta(0, call_info.self_time, 0.05)
     assert_in_delta(3, call_info.children_time, 0.05)
     assert_equal(3, call_info.called)
   end
-end
+end