ruby-prof 0.15.5 → 0.15.6

data/ext/ruby_prof/rp_call_info.h

@@ -26,7 +26,7 @@ typedef struct prof_call_info_t
 } prof_call_info_t;
 
 /* Array of call_info objects */
-typedef struct prof_call_infos_t 
+typedef struct prof_call_infos_t
 {
     prof_call_info_t **start;
     prof_call_info_t **end;

data/lib/ruby-prof/call_info.rb

@@ -2,7 +2,38 @@
 
 module RubyProf
   class CallInfo
-    attr_accessor :recursive
+    # part of this class is defined in C code.
+    # it provides the following attributes pertaining to tree structure:
+    # depth:      tree level (0 == root)
+    # parent:     parent call info (can be nil)
+    # children:   array of call info children (can be empty)
+    # target:     method info (containing an array of call infos)
+
+    attr_reader :recursive
+
+    def non_recursive?
+      @non_recursive
+    end
+
+    def detect_recursion(visited_methods = Hash.new(0))
+      @recursive = (visited_methods[target] += 1) > 1
+      @non_recursive = true
+      children.each do |child|
+        @non_recursive = false if child.detect_recursion(visited_methods)
+      end
+      visited_methods.delete(target) if (visited_methods[target] -= 1) == 0
+      return !@non_recursive
+    end
+
+    def recalc_recursion(visited_methods = Hash.new(0))
+      return if @non_recursive
+      target.clear_cached_values_which_depend_on_recursiveness
+      @recursive = (visited_methods[target] += 1) > 1
+      children.each do |child|
+        child.recalc_recursion(visited_methods)
+      end
+      visited_methods.delete(target) if (visited_methods[target] -= 1) == 0
+    end
 
     def children_time
       children.inject(0) do |sum, call_info|
@@ -33,8 +64,29 @@ module RubyProf
       self.parent.nil?
     end
 
+    def descendent_of(other)
+      p = self.parent
+      while p && p != other && p.depth > other.depth
+        p = p.parent
+      end
+      p == other
+    end
+
+    def self.roots_of(call_infos)
+      roots = []
+      sorted = call_infos.sort_by(&:depth).reverse
+      while call_info = sorted.shift
+        roots << call_info unless sorted.any?{|p| call_info.descendent_of(p)}
+      end
+      roots
+    end
+
     def to_s
-      "#{self.target.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, ct: #{self.children_time})"
+      "#{target.full_name} (c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
+    end
+
+    def inspect
+      super + "(#{target.full_name}, d: #{depth}, c: #{called}, tt: #{total_time}, st: #{self_time}, ct: #{children_time})"
     end
 
     # eliminate call info from the call tree.

data/lib/ruby-prof/call_info_visitor.rb

@@ -1,11 +1,10 @@
-# 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
+# The call info visitor class does a depth-first traversal across a
+# list of method infos. 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)
+#   visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)
 #
 #   method_names = Array.new
 #
@@ -18,15 +17,13 @@
 module RubyProf
   class CallInfoVisitor
 
-    def initialize(thread)
-      @thread = thread
+    def initialize(call_infos)
+      @call_infos = CallInfo.roots_of(call_infos)
     end
 
     def visit(&block)
-      @thread.top_methods.each do |method_info|
-        method_info.call_infos.each do |call_info|
-          visit_call_info(call_info, &block)
-        end
+      @call_infos.each do |call_info|
+        visit_call_info(call_info, &block)
       end
     end
 
@@ -39,4 +36,5 @@ module RubyProf
       yield call_info, :exit
     end
   end
+
 end

data/lib/ruby-prof/method_info.rb

@@ -18,6 +18,18 @@ module RubyProf
       end
     end
 
+    def detect_recursion
+      call_infos.each(&:detect_recursion)
+    end
+
+    def recalc_recursion
+      call_infos.each(&:recalc_recursion)
+    end
+
+    def clear_cached_values_which_depend_on_recursiveness
+      @total_time = @self_time = @wait_time = @children_time = nil
+    end
+
     def called
       @called ||= begin
         call_infos.inject(0) do |sum, call_info|
@@ -38,7 +50,7 @@ module RubyProf
     def self_time
       @self_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.self_time  unless call_info.recursive
+          sum += call_info.self_time unless call_info.recursive
           sum
         end
       end
@@ -56,16 +68,14 @@ module RubyProf
     def children_time
       @children_time ||= begin
         call_infos.inject(0) do |sum, call_info|
-          sum += call_info.children_time  unless call_info.recursive
+          sum += call_info.children_time unless call_info.recursive
           sum
         end
       end
     end
 
     def min_depth
-      @min_depth ||= call_infos.map do |call_info|
-        call_info.depth
-      end.min
+      @min_depth ||= call_infos.map(&:depth).min
     end
 
     def root?
@@ -77,25 +87,30 @@ module RubyProf
     end
 
     def recursive?
-      call_infos.detect do |call_info|
-        call_info.recursive
-      end
+      call_infos.detect(&:recursive)
+    end
+
+    def non_recursive?
+      non_recursive == 1
+    end
+
+    def non_recursive
+      @non_recursive ||= call_infos.all?(&:non_recursive?) ? 1 : 0
     end
 
     def children
-      @children ||= begin
-        call_infos.map do |call_info|
-          call_info.children
-        end.flatten
-      end
+      @children ||= call_infos.map(&:children).flatten
+    end
+
+    def parents
+      @parents ||= call_infos.map(&:parent)
     end
 
     def aggregate_parents
       # Group call info's based on their parents
-      groups = self.call_infos.inject(Hash.new) do |hash, call_info|
+      groups = self.call_infos.each_with_object({}) do |call_info, hash|
         key = call_info.parent ? call_info.parent.target : self
         (hash[key] ||= []) << call_info
-        hash
       end
 
       groups.map do |key, value|
@@ -105,10 +120,9 @@ module RubyProf
 
     def aggregate_children
       # Group call info's based on their targets
-      groups = self.children.inject(Hash.new) do |hash, call_info|
+      groups = self.children.each_with_object({}) do |call_info, hash|
         key = call_info.target
         (hash[key] ||= []) << call_info
-        hash
       end
 
       groups.map do |key, value|

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module RubyProf
-  # Prints out the call graph based on CallInfo instances.  This
+  # Prints out the call graph based on CallInfo instances. This
   # is mainly for debugging purposes as it provides access into
   # into RubyProf's internals.
 
@@ -19,7 +19,7 @@ module RubyProf
     end
 
     def print_methods(thread)
-      visitor = CallInfoVisitor.new(thread)
+      visitor = CallInfoVisitor.new(thread.top_call_infos)
 
       visitor.visit do |call_info, event|
         if event == :enter

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

@@ -12,39 +12,39 @@ module RubyProf
   #
   #   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 DotPrinter < RubyProf::AbstractPrinter
     CLASS_COLOR = '"#666666"'
     EDGE_COLOR  = '"#666666"'
-    
+
     # Creates the DotPrinter using a RubyProf::Result.
     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 
+    #
+    # 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;"
@@ -53,31 +53,31 @@ module RubyProf
       puts '}'
     end
 
-    private 
-    
+    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|
@@ -90,14 +90,14 @@ module RubyProf
         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}\";"
@@ -107,26 +107,26 @@ module RubyProf
           big_methods.each do |m|
             puts "#{m.object_id};"
           end
-          puts "}"  
-        end        
+          puts "}"
+        end
       end
     end
-    
+
     def print_edges(total_time, method)
       method.aggregate_children.sort_by(&:total_time).reverse.each do |child|
-        
+
         target_percentage = (child.target.total_time / total_time) * 100.0
         next if target_percentage < min_percent
-        
+
         # Get children method
         puts "#{dot_id(method)} -> #{dot_id(child.target)} [label=\"#{child.called}/#{child.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/graph_html_printer.rb

@@ -133,7 +133,7 @@ module RubyProf
   </style>
   </head>
   <body>
-    <h1>Profile Report</h1>
+    <h1>Profile Report: <%= RubyProf.measure_mode_string %></h1>
     <!-- Threads Table -->
     <table>
       <tr>
@@ -173,63 +173,67 @@ module RubyProf
         <tbody>
           <% min_time = @options[:min_time] || (@options[:nonzero] ? 0.005 : nil)
              methods.sort_by(&sort_method).reverse_each do |method|
-              total_percentage = (method.total_time/total_time) * 100
-              next if total_percentage < min_percent
-              next if min_time && method.total_time < min_time
-              self_percentage = (method.self_time/total_time) * 100 %>
-
-              <!-- Parents -->
-              <% for caller in method.aggregate_parents.sort_by(&:total_time)
-                   next unless caller.parent
-                   next if min_time && caller.total_time < min_time  %>
-                <tr>
-                  <td>&nbsp;</td>
-                  <td>&nbsp;</td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.total_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.self_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.wait_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.children_time) %></td>
-                  <% called = "#{caller.called}/#{method.called}" %>
-                  <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
-                  <td class="method_name"><%= create_link(thread, total_time, caller.parent.target) %></td>
-                  <td><%= file_link(caller.parent.target.source_file, caller.line) %></td>
-                </tr>
-              <% end %>
-
-              <tr class="method">
-                <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage) %></td>
-                <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage) %></td>
-                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.total_time) %></td>
-                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.self_time) %></td>
-                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.wait_time) %></td>
-                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.children_time) %></td>
-                <td><%= sprintf("%#{CALL_WIDTH}i", method.called) %></td>
-                <td class="method_name">
-                  <a name="<%= method_href(thread, method) %>">
-                    <%= method.recursive? ? "*" : " "%><%= h method.full_name %>
-                  </a>
-                </td>
-                <td><%= file_link(method.source_file, method.line) %></td>
-              </tr>
-
-              <!-- Children -->
-              <% for callee in method.aggregate_children.sort_by(&:total_time).reverse %>
-              <%   next if min_time && callee.total_time < min_time  %>
-                <tr>
-                  <td>&nbsp;</td>
-                  <td>&nbsp;</td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.total_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.self_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.wait_time) %></td>
-                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.children_time) %></td>
-                  <% called = "#{callee.called}/#{callee.target.called}" %>
-                  <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
-                  <td class="method_name"><%= create_link(thread, total_time, callee.target) %></td>
-                  <td><%= file_link(method.source_file, callee.line) %></td>
-                </tr>
-              <% end %>
-              <!-- Create divider row -->
-              <tr class="break"><td colspan="9"></td></tr>
+               total_percentage = (method.total_time/total_time) * 100
+
+               next if total_percentage < min_percent
+               next if min_time && method.total_time < min_time
+
+               self_percentage = (method.self_time/total_time) * 100 %>
+
+               <!-- Parents -->
+               <% for caller in method.aggregate_parents.sort_by(&:total_time)
+                    next unless caller.parent
+                    next if min_time && caller.total_time < min_time  %>
+                 <tr>
+                   <td>&nbsp;</td>
+                   <td>&nbsp;</td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.total_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.self_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.wait_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.children_time) %></td>
+                   <% called = "#{caller.called}/#{method.called}" %>
+                   <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                   <td class="method_name"><%= create_link(thread, total_time, caller.parent.target) %></td>
+                   <td><%= file_link(caller.parent.target.source_file, caller.line) %></td>
+                 </tr>
+               <% end %>
+
+               <tr class="method">
+                 <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage) %></td>
+                 <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage) %></td>
+                 <td><%= sprintf("%#{TIME_WIDTH}.2f", method.total_time) %></td>
+                 <td><%= sprintf("%#{TIME_WIDTH}.2f", method.self_time) %></td>
+                 <td><%= sprintf("%#{TIME_WIDTH}.2f", method.wait_time) %></td>
+                 <td><%= sprintf("%#{TIME_WIDTH}.2f", method.children_time) %></td>
+                 <td><%= sprintf("%#{CALL_WIDTH}i", method.called) %></td>
+                 <td class="method_name">
+                   <a name="<%= method_href(thread, method) %>">
+                     <%= method.recursive? ? "*" : " "%><%= h method.full_name %>
+                   </a>
+                 </td>
+                 <td><%= file_link(method.source_file, method.line) %></td>
+               </tr>
+
+               <!-- Children -->
+               <% method.recalc_recursion unless method.non_recursive? %>
+               <% for callee in method.aggregate_children.sort_by(&:total_time).reverse %>
+               <%   next if min_time && callee.total_time < min_time  %>
+                 <tr>
+                   <td>&nbsp;</td>
+                   <td>&nbsp;</td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.total_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.self_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.wait_time) %></td>
+                   <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.children_time) %></td>
+                   <% called = "#{callee.called}/#{callee.target.called}" %>
+                   <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                   <td class="method_name"><%= create_link(thread, total_time, callee.target) %></td>
+                   <td><%= file_link(method.source_file, callee.line) %></td>
+                 </tr>
+               <% end %>
+               <!-- Create divider row -->
+               <tr class="break"><td colspan="9"></td></tr>
+            <% thread.recalc_recursion unless method.non_recursive? %>
           <% end %>
         </tbody>
         <tfoot>