ruby-prof 0.8.2 → 0.9.0

data/lib/ruby-prof/graph_printer.rb

@@ -1,7 +1,7 @@
 require 'ruby-prof/abstract_printer'
 
 module RubyProf
-  # Generates graph[link:files/examples/graph_txt.html] profile reports as text. 
+  # Generates graph[link:files/examples/graph_txt.html] profile reports as text.
   # To use the graph printer:
   #
   #   result = RubyProf.profile do
@@ -17,8 +17,8 @@ module RubyProf
     PERCENTAGE_WIDTH = 8
     TIME_WIDTH = 10
     CALL_WIDTH = 17
-  
-    # Create a GraphPrinter.  Result is a RubyProf::Result  
+
+    # Create a GraphPrinter.  Result is a RubyProf::Result
     # object generated from a profiling run.
     def initialize(result)
       super(result)
@@ -28,22 +28,22 @@ module RubyProf
 
     def calculate_thread_times
       # Cache thread times since this is an expensive
-      # operation with the required sorting      
+      # operation with the required sorting
       @result.threads.each do |thread_id, methods|
         top = methods.max
-        
+
         thread_time = [top.total_time, 0.01].max
-        
-        @thread_times[thread_id] = thread_time 
+
+        @thread_times[thread_id] = thread_time
       end
     end
-    
+
     # Print a graph report to the provided output.
-    # 
-    # output - Any IO oject, including STDOUT or a file. 
+    #
+    # output - Any IO oject, including STDOUT or a file.
     # The default value is STDOUT.
-    # 
-    # options - Hash of print options.  See #setup_options 
+    #
+    # options - Hash of print options.  See #setup_options
     #           for more information.
     #
     def print(output = STDOUT, options = {})
@@ -52,7 +52,7 @@ module RubyProf
       print_threads
     end
 
-    private 
+    private
     def print_threads
       # sort assumes that spawned threads have higher object_ids
       @result.threads.sort.each do |thread_id, methods|
@@ -60,30 +60,30 @@ module RubyProf
         @output << "\n" * 2
       end
     end
-    
+
     def print_methods(thread_id, methods)
       # Sort methods from longest to shortest total time
       methods = methods.sort
-      
+
       toplevel = methods.last
       total_time = toplevel.total_time
       if total_time == 0
         total_time = 0.01
       end
-      
+
       print_heading(thread_id)
-    
+
       # Print each method in total time order
       methods.reverse_each do |method|
         total_percentage = (method.total_time/total_time) * 100
         self_percentage = (method.self_time/total_time) * 100
-        
+
         next if total_percentage < min_percent
-        
+
         @output << "-" * 80 << "\n"
 
         print_parents(thread_id, method)
-    
+
         # 1 is for % sign
         @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage)
         @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage)
@@ -95,18 +95,18 @@ module RubyProf
         @output << sprintf("     %s", method_name(method))
         if print_file
           @output << sprintf("  %s:%s", method.source_file, method.line)
-        end          
+        end
         @output << "\n"
-    
+
         print_children(method)
       end
     end
-  
+
     def print_heading(thread_id)
       @output << "Thread ID: #{thread_id}\n"
       @output << "Total Time: #{@thread_times[thread_id]}\n"
       @output << "\n"
-      
+
       # 1 is for % sign
       @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%total")
       @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%self")
@@ -118,7 +118,7 @@ module RubyProf
       @output << "   Name"
       @output << "\n"
     end
-    
+
     def print_parents(thread_id, method)
       method.aggregate_parents.sort_by(&:total_time).each do |caller|
         next unless caller.parent
@@ -127,20 +127,20 @@ module RubyProf
         @output << sprintf("%#{TIME_WIDTH}.2f", caller.self_time)
         @output << sprintf("%#{TIME_WIDTH}.2f", caller.wait_time)
         @output << sprintf("%#{TIME_WIDTH}.2f", caller.children_time)
-    
+
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
         @output << sprintf("     %s", caller.parent.target.full_name)
         @output << "\n"
       end
     end
-  
+
     def print_children(method)
       method.aggregate_children.sort_by(&:total_time).reverse.each do |child|
         # Get children method
-        
+
         @output << " " * 2 * PERCENTAGE_WIDTH
-        
+
         @output << sprintf("%#{TIME_WIDTH}.2f", child.total_time)
         @output << sprintf("%#{TIME_WIDTH}.2f", child.self_time)
         @output << sprintf("%#{TIME_WIDTH}.2f", child.wait_time)
@@ -153,5 +153,5 @@ module RubyProf
       end
     end
   end
-end 
+end
 

data/lib/ruby-prof/method_info.rb

@@ -27,11 +27,12 @@ module RubyProf
     def total_time
       @total_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.total_time
+          sum += call_info.total_time if call_info.minimal?
+          sum
         end
       end
     end
-    
+
     def self_time
       @self_time ||= begin
         call_infos.inject(0) do |sum, call_info|
@@ -51,7 +52,8 @@ module RubyProf
     def children_time
       @children_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.children_time
+          sum += call_info.children_time if call_info.minimal?
+          sum
         end
       end
     end
@@ -107,5 +109,23 @@ module RubyProf
     def to_s
       full_name
     end
+
+    def dump
+      res = ""
+      res << "MINFO: #{klass_name}##{method_name} total_time: #{total_time} (#{full_name})\n"
+      call_infos.each do |ci|
+        pinfo = ci.root? ? "TOPLEVEL" : (p=ci.parent.target; "#{p.klass_name}##{p.method_name} (#{ci.parent.object_id}) (#{p.full_name})")
+        res << "CINFO[#{ci.object_id}] called #{ci.called} times from #{pinfo}\n"
+      end
+      res
+    end
+
+    # remove method from the call graph. should not be called directly.
+    def eliminate!
+      # $stderr.puts "eliminating #{self}"
+      call_infos.each{ |call_info| call_info.eliminate! }
+      call_infos.clear
+    end
+
   end
-end
+end

data/lib/ruby-prof/multi_printer.rb

@@ -0,0 +1,54 @@
+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/rack.rb

@@ -0,0 +1,28 @@
+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
+      printers = {::RubyProf::FlatPrinter => 'c:/temp/profile.txt',
+                  ::RubyProf::GraphHtmlPrinter => 'c:/temp/profile.html'}
+
+      printers.each do |printer_klass, file_name|
+        printer = printer_klass.new(result)
+          ::File.open(file_name, 'wb') do |file|
+          printer.print(file, :min_percent => 0.00000001 )
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/result.rb

@@ -0,0 +1,70 @@
+require 'set'
+module RubyProf
+  class Result
+    # 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/symbol_to_proc.rb

@@ -5,4 +5,4 @@ unless (:a.respond_to?(:to_proc))
    end
  end
 end
- 
+

data/lib/ruby-prof/task.rb

@@ -15,7 +15,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 +29,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 +55,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 +99,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 +125,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 +138,9 @@ module RubyProf
         FileUtils.rm(files)
       end
     end
-    
+
     def option_list # :nodoc:
       ENV['OPTIONS'] || @options.join(" ") || ""
     end
   end
-end
+end