ruby-prof 1.8.0-x64-mswin64-140

data/lib/ruby-prof/printers/call_tree_printer.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'fiber'
+require 'thread'
+require 'fileutils'
+
+module RubyProf
+  # Generates profiling information in callgrind format for use by
+  # kcachegrind and similar tools.
+
+  class CallTreePrinter < AbstractPrinter
+    def calltree_name(method_info)
+      klass_path = method_info.klass_name.gsub("::", '/')
+      result = "#{klass_path}::#{method_info.method_name}"
+
+      case method_info.klass_flags
+        when 0x2
+          "#{result}^"
+        when 0x4
+          "#{result}^"
+        when 0x8
+         "#{result}*"
+        else
+         result
+      end
+    end
+
+    def determine_event_specification_and_value_scale
+      @event_specification = "events: "
+      case @result.measure_mode
+        when RubyProf::PROCESS_TIME
+          @value_scale = RubyProf::CLOCKS_PER_SEC
+          @event_specification << 'process_time'
+        when RubyProf::WALL_TIME
+          @value_scale = 1_000_000
+          @event_specification << 'wall_time'
+        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+          @value_scale = 1
+          @event_specification << 'allocations'
+        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
+          @value_scale = 1
+          @event_specification << 'memory'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @event_specification << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @event_specification << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
+      end
+    end
+
+    def print(options = {})
+      validate_print_params(options)
+      setup_options(options)
+      determine_event_specification_and_value_scale
+      print_threads
+    end
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    end
+
+    def print_threads
+      remove_subsidiary_files_from_previous_profile_runs
+      @result.threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def convert(value)
+      (value * @value_scale).round
+    end
+
+    def file(method)
+      method.source_file ? File.expand_path(method.source_file) : ''
+    end
+
+    def print_thread(thread)
+      File.open(file_path_for_thread(thread), "w") do |f|
+        print_headers(f, thread)
+        thread.methods.reverse_each do |method|
+          print_method(f, method)
+        end
+      end
+    end
+
+    def path
+      @options[:path] || "."
+    end
+
+    def self.needs_dir?
+      true
+    end
+
+    def remove_subsidiary_files_from_previous_profile_runs
+      pattern = ["callgrind.out", $$, "*"].join(".")
+      files = Dir.glob(File.join(path, pattern))
+      FileUtils.rm_f(files)
+    end
+
+    def file_name_for_thread(thread)
+      if thread.fiber_id == Fiber.current.object_id
+        ["callgrind.out", $$].join(".")
+      else
+        ["callgrind.out", $$, thread.fiber_id].join(".")
+      end
+    end
+
+    def file_path_for_thread(thread)
+      File.join(path, file_name_for_thread(thread))
+    end
+
+    def print_headers(output, thread)
+      output << "#{@event_specification}\n\n"
+      # this doesn't work. kcachegrind does not fully support the spec.
+      # output << "thread: #{thread.id}\n\n"
+    end
+
+    def print_method(output, method)
+      # Print out the file and method name
+      output << "fl=#{file(method)}\n"
+      output << "fn=#{self.calltree_name(method)}\n"
+
+      # Now print out the function line number and its self time
+      output << "#{method.line} #{convert(method.self_time)}\n"
+
+      # Now print out all the children methods
+      method.call_trees.callees.each do |callee|
+        output << "cfl=#{file(callee.target)}\n"
+        output << "cfn=#{self.calltree_name(callee.target)}\n"
+        output << "calls=#{callee.called} #{callee.line}\n"
+
+        # Print out total times here!
+        output << "#{callee.line} #{convert(callee.total_time)}\n"
+      end
+      output << "\n"
+    end
+  end
+end

data/lib/ruby-prof/printers/dot_printer.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+require 'set'
+
+module RubyProf
+  # Generates a graphviz graph in dot format.
+  #
+  # To use the dot printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::DotPrinter.new(result)
+  #   printer.print(STDOUT)
+  #
+  # You can use either dot viewer such as GraphViz, or the dot command line tool
+  # to reformat the output into a wide variety of outputs:
+  #
+  #   dot -Tpng graph.dot > graph.png
+  #
+  class DotPrinter < RubyProf::AbstractPrinter
+    CLASS_COLOR = '"#666666"'
+    EDGE_COLOR  = '"#666666"'
+
+    # Creates the DotPrinter using a RubyProf::Proile.
+    def initialize(result)
+      super(result)
+      @seen_methods = Set.new
+    end
+
+    # Print a graph report to the provided output.
+    #
+    # output - Any IO object, including STDOUT or a file. The default value is
+    # STDOUT.
+    #
+    # options - Hash of print options.  See #setup_options
+    # for more information.
+    #
+    # When profiling results that cover a large number of method calls it
+    # helps to use the :min_percent option, for example:
+    #
+    #   DotPrinter.new(result).print(STDOUT, :min_percent=>5)
+    #
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+
+      puts 'digraph "Profile" {'
+      #puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
+      puts "labelloc=t;"
+      puts "labeljust=l;"
+      print_threads
+      puts '}'
+    end
+
+    private
+
+    # Something of a hack, figure out which constant went with the
+    # RubyProf.measure_mode so that we can display it.  Otherwise it's easy to
+    # forget what measurement was made.
+    def mode_name
+      RubyProf.constants.find{|c| RubyProf.const_get(c) == RubyProf.measure_mode}
+    end
+
+    def print_threads
+      @result.threads.each do |thread|
+        puts "subgraph \"Thread #{thread.id}\" {"
+
+        print_thread(thread)
+        puts "}"
+
+        print_classes(thread)
+      end
+    end
+
+    # Determines an ID to use to represent the subject in the Dot file.
+    def dot_id(subject)
+      subject.object_id
+    end
+
+    def print_thread(thread)
+      total_time = thread.total_time
+      thread.methods.sort_by(&sort_method).reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+
+        next if total_percentage < min_percent
+        name = method.full_name.split("#").last
+        puts "#{dot_id(method)} [label=\"#{name}\\n(#{total_percentage.round}%)\"];"
+        @seen_methods << method
+        print_edges(total_time, method)
+      end
+    end
+
+    def print_classes(thread)
+      grouped = {}
+      thread.methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
+      grouped.each do |cls, methods2|
+        # Filter down to just seen methods
+        big_methods = methods2.select{|m| @seen_methods.include? m}
+
+        if !big_methods.empty?
+          puts "subgraph cluster_#{cls.object_id} {"
+          puts "label = \"#{cls}\";"
+          puts "fontcolor = #{CLASS_COLOR};"
+          puts "fontsize = 16;"
+          puts "color = #{CLASS_COLOR};"
+          big_methods.each do |m|
+            puts "#{m.object_id};"
+          end
+          puts "}"
+        end
+      end
+    end
+
+    def print_edges(total_time, method)
+      method.call_trees.callers.sort_by(&:total_time).reverse.each do |call_tree|
+        target_percentage = (call_tree.target.total_time / total_time) * 100.0
+        next if target_percentage < min_percent
+
+        # Get children method
+        puts "#{dot_id(method)} -> #{dot_id(call_tree.target)} [label=\"#{call_tree.called}/#{call_tree.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
+      end
+    end
+
+    # Silly little helper for printing to the @output
+    def puts(str)
+      @output.puts(str)
+    end
+
+  end
+end

data/lib/ruby-prof/printers/flat_printer.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module RubyProf
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
+  # To use the flat printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlatPrinter.new(result)
+  #   printer.print(STDOUT, {})
+  #
+  class FlatPrinter < AbstractPrinter
+    # Override for this printer to sort by self time by default
+    def sort_method
+      @options[:sort_method] || :self_time
+    end
+
+    private
+
+    def print_column_headers
+      @output << " %self      total      self      wait     child     calls  name                           location\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.total_time
+      methods = thread.methods.sort_by(&sort_method).reverse
+
+      sum = 0
+      methods.each do |method|
+        percent = (method.send(filter_by) / total_time) * 100
+        next if percent < min_percent
+        next if percent > max_percent
+
+        sum += method.self_time
+        #self_time_called = method.called > 0 ? method.self_time/method.called : 0
+        #total_time_called = method.called > 0? method.total_time/method.called : 0
+
+        @output << "%6.2f  %9.3f %9.3f %9.3f %9.3f %8d  %s%-30s %s\n" % [
+                      method.self_time / total_time * 100, # %self
+                      method.total_time,                   # total
+                      method.self_time,                    # self
+                      method.wait_time,                    # wait
+                      method.children_time,                # children
+                      method.called,                       # calls
+                      method.recursive? ? "*" : " ",       # cycle
+                      method.full_name,                    # method_name]
+                      method_location(method)]             # location]
+      end
+    end
+  end
+end

data/lib/ruby-prof/printers/graph_html_printer.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'erb'
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_html.html] profile reports as html.
+  # To use the graph html printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphHtmlPrinter.new(result)
+  #   printer.print(STDOUT, :min_percent=>0)
+  #
+  # The Graph printer takes the following options in its print methods:
+
+  class GraphHtmlPrinter < AbstractPrinter
+    include ERB::Util
+
+    def setup_options(options)
+      super(options)
+      @erb = ERB.new(self.template)
+    end
+
+    def print(output = STDOUT, options = {})
+      setup_options(options)
+      output << @erb.result(binding)
+    end
+
+    # Creates a link to a method.  Note that we do not create
+    # links to methods which are under the min_percent
+    # specified by the user, since they will not be
+    # printed out.
+    def create_link(thread, overall_time, method)
+      total_percent = (method.total_time/overall_time) * 100
+      if total_percent < min_percent
+        # Just return name
+        h method.full_name
+      else
+        href = '#' + method_href(thread, method)
+        "<a href=\"#{href}\">#{h method.full_name}</a>"
+      end
+    end
+
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.fiber_id.to_s)
+    end
+
+    def file_link(path, linenum)
+      if path.nil?
+        ""
+      else
+        srcfile = File.expand_path(path)
+        "<a href=\"file://#{h srcfile}##{linenum}\" title=\"#{h srcfile}:#{linenum}\">#{linenum}</a>"
+      end
+    end
+
+    def template
+      open_asset('graph_printer.html.erb')
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+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)
+  #   printer.print(STDOUT, {})
+  #
+  # The constructor takes two arguments. See the README
+
+  class GraphPrinter < AbstractPrinter
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 11
+    CALL_WIDTH = 17
+
+    private
+
+    def sort_method
+      @options[:sort_method] || :total_time
+    end
+
+    def print_header(thread)
+      @output << "Measure Mode: %s\n" % @result.measure_mode_string
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Fiber ID: #{thread.fiber_id}\n"
+      @output << "Total Time: #{thread.total_time}\n"
+      @output << "Sort by: #{sort_method}\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 << "                          location"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.total_time
+      # Sort methods from longest to shortest total time
+      methods = thread.methods.sort_by(&sort_method)
+
+      # Print each method in total time order
+      methods.reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+        next if total_percentage < min_percent
+
+        self_percentage = (method.self_time/total_time) * 100
+
+        @output << "-" * 150 << "\n"
+        print_parents(thread, 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}.3f", method.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", method.children_time)
+        @output << sprintf("%#{CALL_WIDTH}i", method.called)
+        @output << sprintf("    %s",  method.recursive? ? "*" : " ")
+        @output << sprintf("%-30s", method.full_name)
+        @output << sprintf(" %s", method_location(method))
+        @output << "\n"
+
+        print_children(method)
+      end
+    end
+
+    def print_parents(thread, method)
+      method.call_trees.callers.sort_by(&:total_time).each do |caller|
+        @output << " " * 2 * PERCENTAGE_WIDTH
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", caller.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", 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.call_trees.callees.sort_by(&:total_time).reverse.each do |child|
+        # Get children method
+
+        @output << " " * 2 * PERCENTAGE_WIDTH
+
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", child.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.3f", 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/printers/multi_printer.rb

@@ -0,0 +1,127 @@
+# 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, printers = [:flat, :graph_html])
+      @flat_printer = printers.include?(:flat) ? FlatPrinter.new(result) : nil
+
+      @graph_printer = printers.include?(:graph) ? GraphPrinter.new(result) : nil
+      @graph_html_printer = printers.include?(:graph_html) ? GraphHtmlPrinter.new(result) : nil
+
+      @tree_printer = printers.include?(:tree) ? CallTreePrinter.new(result) : nil
+      @call_info_printer = printers.include?(:call_tree) ? CallInfoPrinter.new(result) : nil
+
+      @stack_printer = printers.include?(:stack) ? CallStackPrinter.new(result) : nil
+      @dot_printer = printers.include?(:dot) ? DotPrinter.new(result) : nil
+    end
+
+    def self.needs_dir?
+      true
+    end
+
+    # create profile files under options[:path] or the current
+    # directory. options[:profile] is used as the base name for the
+    # profile file, defaults to "profile".
+    def print(options)
+      validate_print_params(options)
+
+      @file_name = options.delete(:profile) || "profile"
+      @directory = options.delete(:path) || File.expand_path(".")
+
+      print_to_flat(options) if @flat_printer
+
+      print_to_graph(options) if @graph_printer
+      print_to_graph_html(options) if @graph_html_printer
+
+      print_to_stack(options) if @stack_printer
+      print_to_call_info(options) if @call_info_printer
+      print_to_tree(options) if @tree_printer
+      print_to_dot(options) if @dot_printer
+    end
+
+    # the name of the flat profile file
+    def flat_report
+      "#{@directory}/#{@file_name}.flat.txt"
+    end
+
+    # the name of the graph profile file
+    def graph_report
+      "#{@directory}/#{@file_name}.graph.txt"
+    end
+
+    def graph_html_report
+      "#{@directory}/#{@file_name}.graph.html"
+    end
+
+    # the name of the callinfo profile file
+    def call_info_report
+      "#{@directory}/#{@file_name}.call_tree.txt"
+    end
+
+    # the name of the callgrind profile file
+    def tree_report
+      "#{@directory}/#{@file_name}.callgrind.out.#{$$}"
+    end
+
+    # the name of the call stack profile file
+    def stack_report
+      "#{@directory}/#{@file_name}.stack.html"
+    end
+
+    # the name of the call stack profile file
+    def dot_report
+      "#{@directory}/#{@file_name}.dot"
+    end
+
+    def print_to_flat(options)
+      File.open(flat_report, "wb") do |file|
+        @flat_printer.print(file, options)
+      end
+    end
+
+    def print_to_graph(options)
+      File.open(graph_report, "wb") do |file|
+        @graph_printer.print(file, options)
+      end
+    end
+
+    def print_to_graph_html(options)
+      File.open(graph_html_report, "wb") do |file|
+        @graph_html_printer.print(file, options)
+      end
+    end
+
+    def print_to_call_info(options)
+      File.open(call_info_report, "wb") do |file|
+        @call_info_printer.print(file, options)
+      end
+    end
+
+    def print_to_tree(options)
+      @tree_printer.print(options.merge(:path => @directory, :profile => @file_name))
+    end
+
+    def print_to_stack(options)
+      File.open(stack_report, "wb") do |file|
+        @stack_printer.print(file, options.merge(:graph => "#{@file_name}.graph.html"))
+      end
+    end
+
+    def print_to_dot(options)
+      File.open(dot_report, "wb") do |file|
+        @dot_printer.print(file, options)
+      end
+    end
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    end
+  end
+end

data/lib/ruby-prof/profile.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME
+          "wall_time"
+        when PROCESS_TIME
+          "process_time"
+        when ALLOCATIONS
+          "allocations"
+        when MEMORY
+          "memory"
+      end
+    end
+
+    # Hides methods that, when represented as a call graph, have
+    # extremely large in and out degrees and make navigation impossible.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_names)
+      [method_names].flatten.each do |method_name|
+        exclude_method!(mod, method_name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_names)
+      exclude_methods!(mod.singleton_class, *method_names)
+    end
+
+    # call-seq:
+    # merge! -> self
+    #
+    # Merges RubyProf threads whose root call_trees reference the same target method. This is useful
+    # when profiling code that uses a main thread/fiber to distribute work to multiple workers.
+    # If there are tens or hundreds of workers, viewing results per worker thread/fiber can be
+    # overwhelming. Using +merge!+ will combine the worker times together into one result.
+    #
+    # Note the reported time will be much greater than the actual wall time. For example, if there
+    # are 10 workers that each run for 5 seconds, merged results will show one thread that
+    # ran for 50 seconds.
+    #
+    def merge!
+      # First group threads by their root call tree target (method). If the methods are
+      # different than there is nothing to merge
+      grouped = threads.group_by do |thread|
+        thread.call_tree.target
+      end
+
+      # For each target, get the first thread. Then loop over the remaining threads,
+      # and merge them into the first one and ten delete them. So we will be left with
+      # one thread per target.
+      grouped.each do |target, threads|
+        thread = threads.shift
+        threads.each do |other_thread|
+          thread.merge!(other_thread)
+          remove_thread(other_thread)
+        end
+        thread
+      end
+
+      self
+    end
+  end
+end