ruby-prof 0.16.2 → 1.1.0

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

@@ -1,116 +1,114 @@
-# 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 print_header(thread)
-      @output << "Measure Mode: %s\n" % RubyProf.measure_mode_string
-      @output << "Thread ID: #{thread.id}\n"
-      @output << "Fiber ID: #{thread.fiber_id}\n" unless thread.id == thread.fiber_id
-      @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 << "\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 << "-" * 80 << "\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("%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_parents(thread, method)
-      method.aggregate_parents.sort_by(&:total_time).each do |caller|
-        next unless caller.parent
-        @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.aggregate_children.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
-
-    def print_footer(thread)
-      @output << "\n"
-      @output << "* indicates recursively called methods\n"
-    end
-  end
-end
+# 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" % RubyProf.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)
+      return if method.root?
+      method.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.full_name)
+        @output << "\n"
+      end
+    end
+
+    def print_children(method)
+      method.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

@@ -1,58 +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)
-      @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
-
-      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
-
-      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}.callgrind.out.#{$$}"
-    end
-
-    # the name of the flat profile file
-    def flat_profile
-      "#{@directory}/#{@profile}.flat.txt"
-    end
-
-  end
-end
+# 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 = FlatPrinter.new(result) if printers.include?(:flat)
+
+      @graph_printer = GraphPrinter.new(result) if printers.include?(:graph)
+      @graph_html_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph_html)
+
+      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
+      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_info)
+
+      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
+      @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
+    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)
+
+      @profile = 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}/#{@profile}.flat.txt"
+    end
+
+    # the name of the graph profile file
+    def graph_report
+      "#{@directory}/#{@profile}.graph.txt"
+    end
+
+    def graph_html_report
+      "#{@directory}/#{@profile}.graph.html"
+    end
+
+    # the name of the callinfo profile file
+    def call_info_report
+      "#{@directory}/#{@profile}.call_info.txt"
+    end
+
+    # the name of the callgrind profile file
+    def tree_report
+      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+    end
+
+    # the name of the call stack profile file
+    def stack_report
+      "#{@directory}/#{@profile}.stack.html"
+    end
+
+    # the name of the call stack profile file
+    def dot_report
+      "#{@directory}/#{@profile}.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 => @profile))
+    end
+
+    def print_to_stack(options)
+      File.open(stack_report, "wb") do |file|
+        @stack_printer.print(file, options.merge(:graph => "#{@profile}.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

@@ -1,55 +1,33 @@
-# encoding: utf-8
-
-module RubyProf
-  class Profile
-    # This method gets called once profiling has been completed
-    # but before results are returned to the user.  Thus it provides
-    # a hook to do any necessary post-processing on the call graph.
-    def post_process
-      self.threads.each do |thread|
-        thread.detect_recursion
-      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|
-        matchers.each{ |matcher| eliminated.concat(eliminate_methods(thread.methods, matcher)) }
-      end
-      eliminated
-    end
-
-    private
-
-    # read regexps from file
-    def read_regexps_from_file(file_name)
-      matchers = []
-      File.open(file_name).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
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    # :nodoc:
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME    then "wall_time"
+        when PROCESS_TIME then "process_time"
+        when ALLOCATIONS  then "allocations"
+        when MEMORY       then "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_or_methods)
+      [method_or_methods].flatten.each do |name|
+        exclude_method!(mod, name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_or_methods)
+      exclude_methods!(mod.singleton_class, *method_or_methods)
+    end
+  end
+end