acunote-ruby-prof 0.9.2

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

@@ -0,0 +1,8 @@
+unless (:a.respond_to?(:to_proc))
+ class Symbol
+   def to_proc
+      proc {|stuff| stuff.send(self)}
+   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.max
+        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/lib/unprof.rb

@@ -0,0 +1,8 @@
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

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/aggregate_test.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+# Test data
+#   A   B   C
+#   |   |   |
+#   Z   A   A
+#       |   |
+#       Z   Z
+
+class AggClass
+  def z
+    sleep 1
+  end
+
+  def a
+    z
+  end
+
+  def b
+    a
+  end
+
+  def c
+    a
+  end
+end
+
+class AggregateTest < 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_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
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    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_equal(3, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('AggregateTest#test_call_infos->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('AggregateTest#test_call_infos->AggClass#b->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[2]
+    assert_equal('AggregateTest#test_call_infos->AggClass#c->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+  end
+
+  def test_aggregates_parents
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
+
+    # Check AggClass#z
+    assert_equal('AggClass#z', method.full_name)
+
+    call_infos = method.aggregate_parents
+    assert_equal(1, call_infos.length)
+
+    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.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+
+  def test_aggregates_children
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
+
+    # Check AggClass#a
+    assert_equal('AggClass#a', method.full_name)
+
+    call_infos = method.aggregate_children
+    assert_equal(1, call_infos.length)
+
+    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.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+end