skaes-ruby-prof 0.7.3

data/lib/ruby-prof/method_info.rb

@@ -0,0 +1,131 @@
+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 if call_info.minimal?
+          sum
+        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_time
+      @children_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.children_time if call_info.minimal?
+          sum
+        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 children
+      @children ||= begin
+        call_infos.map do |call_info|
+          call_info.children
+        end.flatten
+      end
+    end
+
+    def aggregate_parents
+      # Group call info's based on their parents
+      groups = self.call_infos.inject(Hash.new) do |hash, call_info|
+        key = call_info.parent ? call_info.parent.target : self
+        (hash[key] ||= []) << call_info
+        hash
+      end
+
+      groups.map do |key, value|
+        AggregateCallInfo.new(value)
+      end
+    end
+
+    def aggregate_children
+      # Group call info's based on their targets
+      groups = self.children.inject(Hash.new) do |hash, call_info|
+        key = call_info.target
+        (hash[key] ||= []) << call_info
+        hash
+      end
+
+      groups.map do |key, value|
+        AggregateCallInfo.new(value)
+      end
+    end
+
+    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

data/lib/ruby-prof/multi_printer.rb

@@ -0,0 +1,55 @@
+module RubyProf
+  class MultiPrinter
+    # 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.
+
+    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/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/task.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/testtask'
+require 'fileutils'
+
+module RubyProf
+
+  # Define a task library for profiling unit tests with ruby-prof.
+  #
+  # All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #   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
+  #                called "profile" and is created underneath
+  #                the current working directory.
+  #
+  #   printer - Specifies the output printer.  Valid values include
+  #             :flat, :graph, :graph_html and :call_tree.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #                 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"
+  #     t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake profile                           # run tests normally
+  #   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 :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|  
+          run_script(file_path)
+        end
+      end
+      self
+    end
+    
+    # Run script
+    def run_script(script_path)
+      run_code = ''
+      RakeFileUtils.verbose(@verbose) do
+        file_name = File.basename(script_path, File.extname(script_path))
+        case @printer
+          when :flat, :graph, :call_tree
+            file_name += ".txt"
+          when :graph_html
+            file_name += ".html"
+          else
+            file_name += ".txt"
+        end
+          
+        output_file_path = File.join(output_directory, file_name)
+          
+        command_line = @ruby_opts.join(" ") + 
+                      " --file=" + output_file_path +
+                      " " + script_path
+
+        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
+        # do that again
+        begin
+          ruby command_line
+        rescue => e
+          STDOUT << e << "\n"
+          STDOUT.flush
+        end
+        puts ""
+        puts ""
+      end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+    
+    def create_output_directory
+      if not File.exist?(output_directory)
+        Dir.mkdir(output_directory)
+      end
+    end
+
+    def clean_output_directory
+      if File.exist?(output_directory)
+        files = Dir.glob(output_directory + '/*')
+        FileUtils.rm(files)
+      end
+    end
+    
+    def option_list # :nodoc:
+      ENV['OPTIONS'] || @options.join(" ") || ""
+    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