rdp-ruby-prof 0.7.4

data/lib/ruby-prof/graph_printer.rb.orig

@@ -0,0 +1,164 @@
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_txt.html] profile reports as text. 
+  # To use the graph printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphPrinter.new(result, 5)
+  #   printer.print(STDOUT, 0)
+  #
+  # The constructor takes two arguments.  The first is
+  # a RubyProf::Result object generated from a profiling
+  # run.  The second is the minimum %total (the methods 
+  # total time divided by the overall total time) that
+  # a method must take for it to be printed out in 
+  # the report.  Use this parameter to eliminate methods
+  # that are not important to the overall profiling results.
+
+  class GraphPrinter < AbstractPrinter
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 10
+    CALL_WIDTH = 17
+  
+    # Create a GraphPrinter.  Result is a RubyProf::Result  
+    # object generated from a profiling run.
+    def initialize(result)
+      super(result)
+      @thread_times = Hash.new
+      calculate_thread_times
+    end
+
+    def calculate_thread_times
+      # Cache thread times since this is an expensive
+      # operation with the required sorting      
+      @result.threads.each do |thread_id, methods|
+        top = methods.sort.last
+        
+        thread_time = 0.01
+        thread_time = top.total_time if top.total_time > 0
+
+        @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. 
+    # The default value is STDOUT.
+    # 
+    # options - Hash of print options.  See #setup_options 
+    #           for more information.
+    #
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      print_threads
+    end
+
+    private 
+    def print_threads
+      # sort assumes that spawned threads have higher object_ids
+      @result.threads.sort.each do |thread_id, methods|
+        print_methods(thread_id, methods)
+        @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)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.children_time)
+        @output << sprintf("%#{CALL_WIDTH}i", method.called)
+        @output << sprintf("     %s", method_name(method))
+        if print_file
+          @output << sprintf("  %s:%s", method.source_file, method.line)
+        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")
+      @output << sprintf("%#{TIME_WIDTH}s", "total")
+      @output << sprintf("%#{TIME_WIDTH}s", "self")
+      @output << sprintf("%#{TIME_WIDTH}s", "wait")
+      @output << sprintf("%#{TIME_WIDTH}s", "child")
+      @output << sprintf("%#{CALL_WIDTH}s", "calls")
+      @output << "   Name"
+      @output << "\n"
+    end
+    
+    def print_parents(thread_id, method)
+      method.aggregate_parents.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)
+        @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.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)
+        @output << sprintf("%#{TIME_WIDTH}.2f", child.children_time)
+
+        call_called = "#{child.called}/#{child.target.called}"
+        @output << sprintf("%#{CALL_WIDTH}s", call_called)
+        @output << sprintf("     %s", child.target.full_name)
+        @output << "\n"
+      end
+    end
+  end
+end 
+

data/lib/ruby-prof/method_info.rb

@@ -0,0 +1,111 @@
+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_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 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
+  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