ruby-prof 0.11.0.rc1-x86-mingw32 → 0.11.0.rc2-x86-mingw32

data/lib/ruby-prof/call_info_visitor.rb

@@ -0,0 +1,42 @@
+# The call info visitor class does a depth-first traversal
+# across a thread's call stack.  At each call_info node,
+# the visitor executes the block provided in the
+# #visit method.  The block is passed two parameters, the
+# event and the call_info instance.  Event will be
+# either :enter or :exit.
+#
+#   visitor = RubyProf::CallInfoVisitor.new(result.threads.first)
+#
+#   method_names = Array.new
+#
+#   visitor.visit do |call_info, event|
+#     method_names << call_info.target.full_name if event == :enter
+#   end
+#
+#   puts method_names
+
+module RubyProf
+  class CallInfoVisitor
+    attr_reader :block, :thread
+
+    def initialize(thread)
+      @thread = thread
+    end
+
+    def visit(&block)
+      @block = block
+
+      self.thread.top_method.call_infos.each do |call_info|
+        self.visit_call_info(call_info)
+      end
+    end
+
+    def visit_call_info(call_info)
+      self.block.call(call_info, :enter)
+      call_info.children.each do |child|
+        visit_call_info(child)
+      end
+      self.block.call(call_info, :exit)
+    end
+  end
+end

data/lib/ruby-prof/method_info.rb

@@ -29,7 +29,7 @@ module RubyProf
     def total_time
       @total_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.total_time if call_info.minimal?
+          sum += call_info.total_time unless call_info.recursive
           sum
         end
       end
@@ -38,7 +38,8 @@ module RubyProf
     def self_time
       @self_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.self_time
+          sum += call_info.self_time  unless call_info.recursive
+          sum
         end
       end
     end
@@ -46,7 +47,8 @@ module RubyProf
     def wait_time
       @wait_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.wait_time
+          sum += call_info.wait_time unless call_info.recursive
+          sum
         end
       end
     end
@@ -54,7 +56,7 @@ module RubyProf
     def children_time
       @children_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.children_time if call_info.minimal?
+          sum += call_info.children_time  unless call_info.recursive
           sum
         end
       end
@@ -74,6 +76,12 @@ module RubyProf
       end
     end
 
+    def recursive?
+      call_infos.detect do |call_info|
+        call_info.recursive
+      end
+    end
+
     def children
       @children ||= begin
         call_infos.map do |call_info|
@@ -109,17 +117,7 @@ module RubyProf
     end
 
     def to_s
-      full_name
-    end
-
-    def dump
-      res = ""
-      res << "MINFO: #{klass_name}##{method_name} total_time: #{total_time} (#{full_name})\n"
-      call_infos.each do |ci|
-        pinfo = ci.root? ? "TOPLEVEL" : (p=ci.parent.target; "#{p.klass_name}##{p.method_name} (#{ci.parent.object_id}) (#{p.full_name})")
-        res << "CINFO[#{ci.object_id}] called #{ci.called} times from #{pinfo}\n"
-      end
-      res
+      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, ct: #{self.children_time})"
     end
 
     # remove method from the call graph. should not be called directly.

data/lib/ruby-prof/{abstract_printer.rb → printers/abstract_printer.rb}

@@ -2,10 +2,12 @@
 
 module RubyProf
   class AbstractPrinter
+    # Create a new printer.
+    #
+    # result should be the output generated from a profiling run
     def initialize(result)
       @result = result
       @output = nil
-      @options = {}
     end
 
     # Specify print options.
@@ -47,5 +49,37 @@ module RubyProf
       end
       name
     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
+    end
+
+    def print_threads
+      @result.threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def print_thread(thread)
+      print_header(thread)
+      print_methods(thread)
+      print_footer(thread)
+    end
+
+    def print_header(thread)
+    end
+
+    def print_footer(thread)
+    end
   end
-end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module RubyProf
+  # Prints out the call graph based on CallInfo instances.  This
+  # is mainly for debugging purposes as it provides access into
+  # into RubyProf's internals.
+
+  class CallInfoPrinter < AbstractPrinter
+    TIME_WIDTH = 0
+
+    private
+
+    def print_header(thread)
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Total Time: #{thread.top_method.total_time}\n"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+    end
+
+    def print_methods(thread)
+      visitor = CallInfoVisitor.new(thread)
+
+      visitor.visit do |call_info, event|
+        if event == :enter
+          @output << "  " * call_info.depth
+          @output << call_info.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 << ")"
+          @output << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/{call_stack_printer.rb → printers/call_stack_printer.rb}

@@ -42,28 +42,23 @@ module RubyProf
         @graph_html = "file://" + @graph_html if @graph_html[0]=="/"
       end
 
-      @overall_threads_time = 0.0
-      @threads_totals = Hash.new
-      @result.threads.each do |thread_id, methods|
-        roots = methods.select{|m| m.root?}
-        thread_total_time = sum(roots.map{|r| self.total_time(r.call_infos)})
-        @overall_threads_time += thread_total_time
-        @threads_totals[thread_id] = thread_total_time
-      end
-
       print_header
 
-      @result.threads.keys.sort.each do |thread_id|
-        @current_thread_id = thread_id
-        @overall_time = @threads_totals[thread_id]
-        @output.print "<div class=\"thread\">Thread: #{thread_id} (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})</div>"
+      @overall_threads_time = @result.threads.inject(0) do |val, thread|
+        val += thread.top_method.total_time
+      end
+
+      @result.threads.each do |thread|
+        @current_thread_id = thread.id
+        @overall_time = thread.top_method.total_time
+        @output.print "<div class=\"thread\">Thread: #{thread.id} (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})</div>"
         @output.print "<ul name=\"thread\">"
-        @result.threads[thread_id].each do |m|
+        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, @threads_totals[thread_id]
+            print_stack ci, thread.top_method.total_time
           end
         end
         @output.print "</ul>"
@@ -185,7 +180,7 @@ module RubyProf
     def copy_image_files
       if @output.is_a?(File)
         target_dir = File.dirname(@output.path)
-        image_dir = File.dirname(__FILE__)
+        image_dir = File.join(File.dirname(__FILE__), '..', 'images')
         %w(empty plus minus).each do |img|
           source_file = "#{image_dir}/#{img}.png"
           target_file = "#{target_dir}/#{img}.png"

data/lib/ruby-prof/{call_tree_printer.rb → printers/call_tree_printer.rb}

@@ -54,8 +54,8 @@ module RubyProf
     end
 
     def print_threads
-      @result.threads.each do |thread_id, methods|
-        print_methods(thread_id, methods)
+      @result.threads.each do |thread|
+        print_thread(thread)
       end
     end
 
@@ -67,8 +67,8 @@ module RubyProf
       File.expand_path(method.source_file)
     end
 
-    def print_methods(thread_id, methods)
-      methods.reverse_each do |method|
+    def print_thread(thread)
+      thread.methods.reverse_each do |method|
         # Print out the file and method name
         @output << "fl=#{file(method)}\n"
         @output << "fn=#{method_name(method)}\n"

data/lib/ruby-prof/{dot_printer.rb → printers/dot_printer.rb}

@@ -45,10 +45,8 @@ module RubyProf
       @output = output
       setup_options(options)
       
-      total_time = thread_times.values.inject{|a,b| a+b}
-      
       puts 'digraph "Profile" {'
-      puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
+      #puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
       puts "labelloc=t;"
       puts "labeljust=l;"
       print_threads
@@ -64,32 +62,14 @@ module RubyProf
       RubyProf.constants.find{|c| RubyProf.const_get(c) == RubyProf.measure_mode}
     end
     
-    # Computes the total time per thread:
-    def thread_times
-      @thread_times ||= begin
-        times = {}
-        @result.threads.each do |thread_id, methods|
-          toplevel = methods.sort.last
-
-          total_time = toplevel.total_time
-          # This looks like a hack for very small times... from GraphPrinter
-          total_time = 0.01 if total_time == 0 
-          times[thread_id] = total_time
-        end
-        
-        times
-      end
-    end
-    
     def print_threads
-      # sort assumes that spawned threads have higher object_ids
-      @result.threads.sort.each do |thread_id, methods|
-        puts "subgraph \"Thread #{thread_id}\" {"
-        
-        print_methods(thread_id, methods)
+      @result.threads.each do |thread|
+        puts "subgraph \"Thread #{thread.id}\" {"
+
+        print_thread(thread)
         puts "}"
         
-        print_classes(thread_id, methods)
+        print_classes(thread)
       end
     end
     
@@ -98,9 +78,9 @@ module RubyProf
       subject.object_id
     end
     
-    def print_methods(thread_id, methods)
-      total_time = thread_times[thread_id]
-      methods.sort_by(&sort_method).reverse_each do |method|
+    def print_thread(thread)
+      total_time = thread.top_method.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
@@ -111,9 +91,9 @@ module RubyProf
       end
     end
       
-    def print_classes(thread_id, methods)
+    def print_classes(thread)
       grouped = {}
-      methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
+      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, small_methods  = methods2.partition{|m| @seen_methods.include? m}

data/lib/ruby-prof/{flat_printer.rb → printers/flat_printer.rb}

@@ -12,46 +12,31 @@ module RubyProf
   #   printer.print(STDOUT, {})
   #
   class FlatPrinter < AbstractPrinter
-    # Print a flat profile 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.
-    #
-    def print(output = STDOUT, options = {})
-      @output = output
-      # Now sort methods by largest self time by default,
-      # not total time like in other printouts
-      options[:sort_method] ||= :self_time
-      setup_options(options)
-      print_threads
+    # Override for this printer to sort by self time by default
+    def sort_method
+      @options[:sort_method] || :self_time
     end
 
     private
 
-    def print_threads
-      @result.threads.each do |thread_id, methods|
-        print_methods(thread_id, methods)
-        @output << "\n" * 2
-      end
-    end
-
-    def print_methods(thread_id, methods)
-      # Get total time
-      toplevel = methods.max
-      total_time = toplevel.total_time
-      if total_time == 0
-        total_time = 0.01
-      end
-
-      methods = methods.sort_by(&sort_method).reverse
+    #def print_threads
+    #  @result.threads.each do |thread|
+    #    print_thread(thread)
+    #    @output << "\n" * 2
+    #  end
+    #end
 
-      @output << "Thread ID: %d\n" % thread_id
-      @output << "Total: %0.6f\n" % total_time
+    def print_header(thread)
+      @output << "Thread ID: %d\n" % thread.id
+      @output << "Total: %0.6f\n" % thread.top_method.total_time
+      @output << "Sort by: #{sort_method}\n"
       @output << "\n"
-      @output << " %self     total     self     wait    child    calls  name\n"
+      @output << " %self     total     self     wait    child    calls   name\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.top_method.total_time
+      methods = thread.methods.sort_by(&sort_method).reverse
 
       sum = 0
       methods.each do |method|
@@ -62,16 +47,22 @@ module RubyProf
         #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  %8.2f %8.2f %8.2f %8.2f %8d  %s\n" % [
+        @output << "%6.2f  %8.2f %8.2f %8.2f %8.2f %8d  %s%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_name(method)                  # name
                   ]
       end
     end
+
+    def print_footer(thread)
+      @output << "\n"
+      @output << "* in front of method name means it is recursively called\n"
+    end
   end
 end