ruby-prof 0.18.0 → 1.2.0

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

@@ -1,7 +1,14 @@
 # encoding: utf-8
 
 module RubyProf
+  # This is the base class for all Printers. It is never used directly.
   class AbstractPrinter
+    # :stopdoc:
+    def self.needs_dir?
+      false
+    end
+    # :startdoc:
+
     # Create a new printer.
     #
     # result should be the output generated from a profiling run
@@ -10,72 +17,63 @@ module RubyProf
       @output = nil
     end
 
-    # Specify print options.
+    # Returns the min_percent of total time a method must take to be included in a profiling report
+    def min_percent
+      @options[:min_percent] || 0
+    end
+
+    # Returns the time format used to show when a profile was run
+    def time_format
+      '%A, %B %-d at %l:%M:%S %p (%Z)'
+    end
+
+    # Returns how profile data should be sorted
+    def sort_method
+      @options[:sort_method]
+    end
+
+    # Prints a report to the provided output.
+    #
+    # output - Any IO object, including STDOUT or a file.
+    # The default value is STDOUT.
+    #
+    # options - Hash of print options. Note that each printer can
+    # define its own set of options.
     #
-    # options - Hash table
     #   :min_percent - Number 0 to 100 that specifes the minimum
     #                  %self (the methods self time divided by the
     #                  overall total time) that a method must take
     #                  for it to be printed out in the report.
     #                  Default value is 0.
     #
-    #   :print_file  - True or false. Specifies if a method's source
-    #                  file should be printed.  Default value if false.
-    #
     #   :sort_method - Specifies method used for sorting method infos.
     #                  Available values are :total_time, :self_time,
     #                  :wait_time, :children_time
     #                  Default value is :total_time
-    #    :editor_uri - Specifies editor uri scheme used for opening files
-    #                  e.g. :atm or :mvim. For OS X default is :txmt.
-    #                  Pass false to print bare filenames.
-    #                  Use RUBY_PROF_EDITOR_URI environment variable to override.
-    def setup_options(options = {})
-      @options = options
-    end
-
-    def min_percent
-      @options[:min_percent] || 0
-    end
-
-    def print_file
-      @options[:print_file] || false
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      print_threads
     end
 
-    def sort_method
-      @options[:sort_method] || :total_time
+    # :nodoc:
+    def setup_options(options = {})
+      @options = options
     end
 
-    def editor_uri
-      if ENV.key?('RUBY_PROF_EDITOR_URI')
-        ENV['RUBY_PROF_EDITOR_URI'] || false
-      elsif @options.key?(:editor_uri)
-        @options[:editor_uri]
-      else
-        RUBY_PLATFORM =~ /darwin/ ? 'txmt' : false
+    def method_location(method)
+      if method.source_file
+        "#{method.source_file}:#{method.line}"
       end
     end
 
-    def method_name(method)
-      name = method.full_name
-      if print_file
-        name += " (#{method.source_file}:#{method.line}}"
-      end
-      name
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.fiber_id.to_s)
     end
 
-    # Print a profiling 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.  Note that each printer can
-    # define its own set of options.
-    def print(output = STDOUT, options = {})
-      @output = output
-      setup_options(options)
-      print_threads
+    def open_asset(file)
+      path = File.join(File.expand_path('../../assets', __FILE__), file)
+      File.open(path, 'rb').read
     end
 
     def print_threads
@@ -91,14 +89,39 @@ module RubyProf
     end
 
     def print_header(thread)
+      @output << "Measure Mode: %s\n" % RubyProf.measure_mode_string
+      @output << "Thread ID: %d\n" % thread.id
+      @output << "Fiber ID: %d\n" % thread.fiber_id unless thread.id == thread.fiber_id
+      @output << "Total: %0.6f\n" % thread.total_time
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+      print_column_headers
     end
 
-    def print_footer(thread)
+    def print_column_headers
     end
 
-    # whether this printer need a :path option pointing to a directory
-    def self.needs_dir?
-      false
+    def print_footer(thread)
+      @output << <<~EOT
+      
+        * recursively called methods
+
+        Columns are:
+
+          %self     - The percentage of time spent in this method, derived from self_time/total_time.
+          total     - The time spent in this method and its children.
+          self      - The time spent in this method.
+          wait      - The amount of time this method waited for other threads.
+          child     - The time spent in this method's children.
+          calls     - The number of times this method was called.
+          name      - The name of the method.
+          location  - The location of the method.
+
+        The interpretation of method names is:
+
+          * MyObject#test - An instance method "test" of the class "MyObject"
+          * <Object:MyObject>#test - The <> characters indicate a method on a singleton class.
+      EOT
     end
   end
 end

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

@@ -1,16 +1,25 @@
 # encoding: utf-8
 
 module RubyProf
-  # Prints out the call graph based on CallInfo instances. This
+  # Prints out the call graph based on CallTree instances. This
   # is mainly for debugging purposes as it provides access into
   # into RubyProf's internals.
-
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallInfoPrinter.new(result)
+  #   printer.print(STDOUT)
   class CallInfoPrinter < AbstractPrinter
     TIME_WIDTH = 0
 
     private
 
     def print_header(thread)
+      @output << "----------------------------------------------------\n"
       @output << "Thread ID: #{thread.id}\n"
       @output << "Fiber ID: #{thread.fiber_id}\n"
       @output << "Total Time: #{thread.total_time}\n"
@@ -19,23 +28,26 @@ module RubyProf
     end
 
     def print_methods(thread)
-      visitor = CallInfoVisitor.new(thread.top_call_infos)
+      visitor = CallTreeVisitor.new(thread.call_tree)
 
-      visitor.visit do |call_info, event|
+      visitor.visit do |call_tree, event|
         if event == :enter
-          @output << "  " * call_info.depth
-          @output << call_info.target.full_name
+          @output << "  " * call_tree.depth
+          @output << call_tree.target.full_name
           @output << " ("
-          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.total_time)}, "
-          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_info.self_time)}, "
-          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_info.wait_time)}, "
-          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_info.children_time)}, "
-          @output << "call:#{call_info.called}, "
-          @output << "rec:#{call_info.recursive?}"
+          @output << "tt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.total_time)}, "
+          @output << "st:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.self_time)}, "
+          @output << "wt:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.wait_time)}, "
+          @output << "ct:#{sprintf("%#{TIME_WIDTH}.2f", call_tree.children_time)}, "
+          @output << "call:#{call_tree.called}, "
           @output << ")"
           @output << "\n"
         end
       end
     end
+
+    def print_footer(thread)
+      @output << "\n" << "\n"
+    end
   end
 end

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

@@ -3,9 +3,20 @@
 require 'erb'
 require 'fileutils'
 require 'base64'
+require 'set'
 
 module RubyProf
-  # prints a HTML visualization of the call tree
+  # Prints a HTML visualization of the call tree.
+  #
+  # To use the printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::CallStackPrinter.new(result)
+  #   printer.print(STDOUT)
+
   class CallStackPrinter < AbstractPrinter
     include ERB::Util
 
@@ -18,9 +29,6 @@ module RubyProf
     #                  for it to be printed out in the report.
     #                  Default value is 0.
     #
-    #   :print_file  - True or false. Specifies if a method's source
-    #                  file should be printed.  Default value if false.
-    #
     #   :threshold   - a float from 0 to 100 that sets the threshold of
     #                  results displayed.
     #                  Default value is 1.0
@@ -35,114 +43,85 @@ module RubyProf
     #
     #   :application - a String to overide the name of the application,
     #                  as it appears on the report.
-    #
-    #    :editor_uri - Specifies editor uri scheme used for opening files
-    #                  e.g. :atm or :mvim. For OS X default is :txmt.
-    #                  Use RUBY_PROF_EDITOR_URI environment variable to overide.
     def print(output = STDOUT, options = {})
-      @output = output
       setup_options(options)
-      @editor = editor_uri
-      if @graph_html = options.delete(:graph)
-        @graph_html = "file://" + @graph_html if @graph_html[0]=="/"
-      end
-
-      print_header
-
-      @overall_threads_time = @result.threads.inject(0) do |val, thread|
-        val += thread.total_time
-      end
-
-      @result.threads.each do |thread|
-        @current_thread_id = thread.fiber_id
-        @overall_time = thread.total_time
-				thread_info = String.new("Thread: #{thread.id}")
-        thread_info << ", Fiber: #{thread.fiber_id}" unless thread.id == thread.fiber_id
-        thread_info << " (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})"
-        @output.print "<div class=\"thread\">#{thread_info}</div>"
-        @output.print "<ul name=\"thread\">"
-        thread.methods.each do |m|
-          # $stderr.print m.dump
-          next unless m.root?
-          m.call_infos.each do |ci|
-            next unless ci.root?
-            print_stack ci, thread.total_time
-          end
-        end
-        @output.print "</ul>"
-      end
-
-      print_footer
+      output << @erb.result(binding)
+    end
 
+    # :enddoc:
+    def setup_options(options)
+      super(options)
+      @erb = ERB.new(self.template)
     end
 
-    def print_stack(call_info, parent_time)
-      total_time = call_info.total_time
+    def print_stack(output, visited, call_tree, parent_time)
+      total_time = call_tree.total_time
       percent_parent = (total_time/parent_time)*100
       percent_total = (total_time/@overall_time)*100
       return unless percent_total > min_percent
       color = self.color(percent_total)
-      kids = call_info.children
       visible = percent_total >= threshold
       expanded = percent_total >= expansion
       display = visible ? "block" : "none"
-      @output.print "<li class=\"color#{color}\" style=\"display:#{display}\">"
-      if kids.empty?
-        @output.print "<a href=\"#\" class=\"toggle empty\" ></a>"
+
+      output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
+
+      if visited.include?(call_tree)
+        output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
       else
-        visible_children = kids.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
-        image = visible_children ? (expanded ? "minus" : "plus") : "empty"
-        @output.print "<a href=\"#\" class=\"toggle #{image}\" ></a>"
-      end
-      @output.printf "<span> %4.2f%% (%4.2f%%) %s %s</span>\n", percent_total, percent_parent, link(call_info), graph_link(call_info)
-      unless kids.empty?
-        if expanded
-          @output.print "<ul>"
+        visited << call_tree
+
+        if call_tree.children.empty?
+          output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
         else
-          @output.print '<ul style="display:none">'
+          visible_children = call_tree.children.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
+          image = visible_children ? (expanded ? "minus" : "plus") : "empty"
+          output << "<a href=\"#\" class=\"toggle #{image}\" ></a>" << "\n"
         end
-        kids.sort_by{|c| -c.total_time}.each do |callinfo|
-          print_stack callinfo, total_time
+        output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
+                                                            link(call_tree.target, false), graph_link(call_tree)] << "\n"
+
+        unless call_tree.children.empty?
+          output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
+          call_tree.children.sort_by{|c| -c.total_time}.each do |child_call_tree|
+            print_stack(output, visited, child_call_tree, total_time)
+          end
+          output << '</ul>' << "\n"
         end
-        @output.print "</ul>"
+
+        visited.delete(call_tree)
       end
-      @output.print "</li>"
+      output << '</li>' << "\n"
     end
 
-    def name(call_info)
-      method = call_info.target
+    def name(call_tree)
+      method = call_tree.target
       method.full_name
     end
 
-    def link(call_info)
-      method = call_info.target
-      file = File.expand_path(method.source_file)
-      if file =~ /\/ruby_runtime$/
-        h(name(call_info))
+    def link(method, recursive)
+      method_name = "#{recursive ? '*' : ''}#{method.full_name}"
+      if method.source_file.nil?
+        h method_name
       else
-        if @editor
-          "<a href=\"#{@editor}://" \
-          "open?url=file://#{file}&line=#{method.line}\">" \
-          "#{h(name(call_info))}</a>"
-        else
-          "<a href=\"file://#{file}##{method.line}\">#{h(name(call_info))}</a>"
-        end
+        file = File.expand_path(method.source_file)
+       "<a href=\"file://#{file}##{method.line}\">#{h method_name}</a>"
       end
     end
 
-    def graph_link(call_info)
-      total_calls = call_info.target.call_infos.inject(0){|t, ci| t += ci.called}
-      href = "#{@graph_html}##{method_href(call_info.target)}"
-      totals = @graph_html ? "<a href='#{href}'>#{total_calls}</a>" : total_calls.to_s
-      "[#{call_info.called} calls, #{totals} total]"
+    def graph_link(call_tree)
+      total_calls = call_tree.target.called
+      totals = total_calls.to_s
+      "[#{call_tree.called} calls, #{totals} total]"
     end
 
     def method_href(method)
-      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + @current_thread_id.to_s)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
     end
 
-    def total_time(call_infos)
-      sum(call_infos.map{|ci| ci.total_time})
+    def total_time(call_trees)
+      sum(call_trees.map{|ci| ci.total_time})
     end
 
     def sum(a)
@@ -186,80 +165,15 @@ module RubyProf
       @options[:expansion] || 10.0
     end
 
-    def print_header
-      @output.puts "<html><head>"
-      @output.puts '<meta http-equiv="content-type" content="text/html; charset=utf-8">'
-      @output.puts "<title>#{h title}</title>"
-      print_css
-      print_java_script
-      @output.puts '</head><body><div style="display: inline-block;">'
-      print_title_bar
-      print_commands
-      print_help
-    end
-
-    def print_footer
-      @output.puts '<div id="sentinel"></div></div></body></html>'
-    end
-
-    def open_asset(file)
-      path = File.join(File.expand_path('../../assets', __FILE__), file)
-      File.open(path, 'rb').read
-    end
-
-    def print_css
-      html = open_asset('call_stack_printer.css.html')
-      @output.puts html.gsub('%s', base64_image)
-    end
-
     def base64_image
-      file = open_asset('call_stack_printer.png')
-      Base64.encode64(file).gsub(/\n/, '')
-    end
-
-    def print_java_script
-      html = open_asset('call_stack_printer.js.html')
-      @output.puts html
-    end
-
-    def print_title_bar
-      @output.puts <<-"end_title_bar"
-<div id="titlebar">
-Call tree for application <b>#{h application} #{h arguments}</b><br/>
-Generated on #{Time.now} with options #{h @options.inspect}<br/>
-</div>
-end_title_bar
-    end
-
-    def print_commands
-      @output.puts <<-"end_commands"
-<div id=\"commands\">
-<span style=\"font-size: 11pt; font-weight: bold;\">Threshold:</span>
-<input value=\"#{h threshold}\" size=\"3\" id=\"threshold\" type=\"text\">
-<input value=\"Apply\" onclick=\"setThreshold();\" type=\"submit\">
-<input value=\"Expand All\" onclick=\"expandAll(event);\" type=\"submit\">
-<input value=\"Collapse All\" onclick=\"collapseAll(event);\" type=\"submit\">
-<input value=\"Show Help\" onclick=\"toggleHelp(this);\" type=\"submit\">
-</div>
-end_commands
+      @data ||= begin
+        file = open_asset('call_stack_printer.png')
+        Base64.encode64(file).gsub(/\n/, '')
+      end
     end
 
-    def print_help
-      @output.puts <<-'end_help'
-<div style="display: none;" id="help">
-&#8226; Enter a decimal value <i>d</i> into the threshold field and click "Apply"
-        to hide all nodes marked with time values lower than <i>d</i>.<br>
-&#8226; Click on "Expand All" for full tree expansion.<br>
-&#8226; Click on "Collapse All" to show only top level nodes.<br>
-&#8226; Use a, s, d, w as in Quake or Urban Terror to navigate the tree.<br>
-&#8226; Use f and b to navigate the tree in preorder forward and backwards.<br>
-&#8226; Use x to toggle visibility of a subtree.<br>
-&#8226; Use * to expand/collapse a whole subtree.<br>
-&#8226; Use h to navigate to thread root.<br>
-&#8226; Use n and p to navigate between threads.<br>
-&#8226; Click on background to move focus to a subtree.<br>
-</div>
-end_help
+    def template
+      open_asset('call_stack_printer.html.erb')
     end
   end
 end