ruby-prof 1.1.0-x64-mingw32 → 1.3.0-x64-mingw32

data/ext/ruby_prof/rp_thread.h

@@ -8,14 +8,14 @@
 #include "rp_stack.h"
 
 /* Profiling information for a thread. */
-typedef struct
+typedef struct thread_data_t
 {
     // Runtime
     VALUE object;                     /* Cache to wrapped object */
     VALUE fiber;                      /* Fiber */
     prof_stack_t* stack;              /* Stack of frames */
     bool trace;                       /* Are we tracking this thread */
-
+    prof_call_tree_t* call_tree;      /* The root of the call tree*/
     VALUE thread_id;                  /* Thread id */
     VALUE fiber_id;                   /* Fiber id */
     VALUE methods;                    /* Array of RubyProf::MethodInfo */
@@ -23,13 +23,16 @@ typedef struct
 } thread_data_t;
 
 void rp_init_thread(void);
-st_table * threads_table_create(void);
-thread_data_t *threads_table_lookup(void *profile, VALUE fiber);
-thread_data_t* threads_table_insert(void *profile, VALUE fiber);
-void switch_thread(void *profile, thread_data_t *thread_data, double measurement);
-void threads_table_free(st_table *table);
-VALUE prof_thread_wrap(thread_data_t *thread);
-void prof_thread_mark(void *data);
+st_table* threads_table_create(void);
+thread_data_t* threads_table_lookup(void* profile, VALUE fiber);
+thread_data_t* threads_table_insert(void* profile, VALUE fiber);
+void threads_table_free(st_table* table);
+
+thread_data_t* prof_get_thread(VALUE self);
+VALUE prof_thread_wrap(thread_data_t* thread);
+void prof_thread_mark(void* data);
+
+void switch_thread(void* profile, thread_data_t* thread_data, double measurement);
 int pause_thread(st_data_t key, st_data_t value, st_data_t data);
 int unpause_thread(st_data_t key, st_data_t value, st_data_t data);
 

data/ext/ruby_prof/ruby_prof.c

@@ -1,34 +1,36 @@
 /* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-/* ruby-prof tracks the time spent executing every method in ruby programming.
-   The main players are:
-
-     profile_t         - This represents 1 profile.
-     thread_data_t     - Stores data about a single thread.
-     prof_stack_t      - The method call stack in a particular thread
-     prof_method_t     - Profiling information about each method
-     prof_call_info_t  - Keeps track a method's callers and callees.
-
-  The final result is an instance of a profile object which has a hash table of
-  thread_data_t, keyed on the thread id.  Each thread in turn has a hash table
-  of prof_method_t, keyed on the method id.  A hash table is used for quick 
-  look up when doing a profile.  However, it is exposed to Ruby as an array.
-
-  Each prof_method_t has two hash tables, parent and children, of prof_call_info_t.
-  These objects keep track of a method's callers (who called the method) and its
-  callees (who the method called).  These are keyed the method id, but once again,
-  are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
-  caller or callee method, thereby making it easy to navigate through the call
-  hierarchy in ruby - which is very helpful for creating call graphs.
-*/
+   /* ruby-prof tracks the time spent executing every method in ruby programming.
+      The main players are:
+
+        profile_t         - This represents 1 profile.
+        thread_data_t     - Stores data about a single thread.
+        prof_stack_t      - The method call stack in a particular thread
+        prof_method_t     - Profiling information about each method
+        prof_call_tree_t  - Keeps track a method's callers and callees.
+
+     The final result is an instance of a profile object which has a hash table of
+     thread_data_t, keyed on the thread id.  Each thread in turn has a hash table
+     of prof_method_t, keyed on the method id.  A hash table is used for quick
+     look up when doing a profile.  However, it is exposed to Ruby as an array.
+
+     Each prof_method_t has two hash tables, parent and children, of prof_call_tree_t.
+     These objects keep track of a method's callers (who called the method) and its
+     callees (who the method called).  These are keyed the method id, but once again,
+     are exposed to Ruby as arrays.  Each prof_call_into_t maintains a pointer to the
+     caller or callee method, thereby making it easy to navigate through the call
+     hierarchy in ruby - which is very helpful for creating call graphs.
+   */
 
 #include "ruby_prof.h"
 
 #include "rp_allocation.h"
 #include "rp_measurement.h"
 #include "rp_method.h"
-#include "rp_call_info.h"
+#include "rp_call_tree.h"
+#include "rp_aggregate_call_tree.h"
+#include "rp_call_trees.h"
 #include "rp_profile.h"
 #include "rp_stack.h"
 #include "rp_thread.h"
@@ -40,7 +42,9 @@ void Init_ruby_prof()
     mProf = rb_define_module("RubyProf");
 
     rp_init_allocation();
-    rp_init_call_info();
+    rp_init_call_tree();
+    rp_init_aggregate_call_tree();
+    rp_init_call_trees();
     rp_init_measure();
     rp_init_method_info();
     rp_init_profile();

data/ext/ruby_prof/ruby_prof.h

@@ -9,6 +9,15 @@
 #include <stdio.h>
 #include <stdbool.h>
 
+#ifndef rb_st_lookup
+#define rb_st_foreach st_foreach
+#define rb_st_free_table st_free_table
+#define rb_st_init_numtable st_init_numtable
+#define rb_st_insert st_insert
+#define rb_st_lookup st_lookup
+#endif
+
+
 extern VALUE mProf;
 
 // This method is not exposed in Ruby header files - at least not as of Ruby 2.6.3 :(

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -64,7 +64,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>..\</OutDir>
+    <OutDir>..\..\..\lib</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -102,30 +102,34 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.6.5vc\include\ruby-2.6.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.6.5vc\include\ruby-2.6.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.7.0vc\include\ruby-2.7.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.7.0vc\include\ruby-2.7.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>HAVE_RB_TRACEARG_CALLEE_ID;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.6.5vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>x64-vcruntime140-ruby260.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.7.0vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>x64-vcruntime140-ruby270.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
+      <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="..\rp_aggregate_call_tree.h" />
     <ClInclude Include="..\rp_allocation.h" />
-    <ClInclude Include="..\rp_call_info.h" />
+    <ClInclude Include="..\rp_call_tree.h" />
+    <ClInclude Include="..\rp_call_trees.h" />
     <ClInclude Include="..\rp_measurement.h" />
     <ClInclude Include="..\rp_method.h" />
     <ClInclude Include="..\rp_profile.h" />
     <ClInclude Include="..\rp_stack.h" />
     <ClInclude Include="..\rp_thread.h" />
     <ClInclude Include="..\ruby_prof.h" />
-    <ClInclude Include="..\version.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="..\rp_aggregate_call_tree.c" />
     <ClCompile Include="..\rp_allocation.c" />
-    <ClCompile Include="..\rp_call_info.c" />
+    <ClCompile Include="..\rp_call_tree.c" />
+    <ClCompile Include="..\rp_call_trees.c" />
     <ClCompile Include="..\rp_measurement.c" />
     <ClCompile Include="..\rp_measure_allocations.c" />
     <ClCompile Include="..\rp_measure_memory.c" />

data/lib/ruby-prof.rb

@@ -9,7 +9,7 @@ rescue LoadError
 end
 
 require 'ruby-prof/version'
-require 'ruby-prof/call_info'
+require 'ruby-prof/call_tree'
 require 'ruby-prof/compatibility'
 require 'ruby-prof/measurement'
 require 'ruby-prof/method_info'
@@ -18,8 +18,7 @@ require 'ruby-prof/rack'
 require 'ruby-prof/thread'
 
 module RubyProf
-  autoload :CallInfoVisitor, 'ruby-prof/call_info_visitor'
-
+  autoload :CallTreeVisitor, 'ruby-prof/call_tree_visitor'
   autoload :AbstractPrinter, 'ruby-prof/printers/abstract_printer'
   autoload :CallInfoPrinter, 'ruby-prof/printers/call_info_printer'
   autoload :CallStackPrinter, 'ruby-prof/printers/call_stack_printer'

data/lib/ruby-prof/assets/call_stack_printer.html.erb

@@ -697,13 +697,10 @@
         <div class="thread">
           <span>Thread: <%= thread.id %>, Fiber: <%= thread.fiber_id %> (<%= thread_info %>)</span>
           <ul name="thread">
-            <% call_infos = thread.root_methods.map(&:callers).flatten %>
-            <% call_infos.each do |call_info| %>
-              <% visited = Set.new
-                 output = StringIO.new('')
-                 print_stack(output, visited, call_info, call_info.total_time) %>
-              <%= output.string %>
-            <% end %>
+            <% visited = Set.new
+               output = StringIO.new('')
+               print_stack(output, visited, thread.call_tree, thread.call_tree.total_time) %>
+            <%= output.string %>
           </ul>
         </div>
       <% end %>

data/lib/ruby-prof/assets/graph_printer.html.erb

@@ -217,8 +217,7 @@
            self_percentage = (method.self_time/total_time) * 100  %>
 
         <!-- Parents -->
-        <% for caller in method.callers.sort
-             next if method.root?
+        <% for caller in method.call_trees.callers.sort
              next if min_time && caller.total_time < min_time %>
           <tr>
             <td>&nbsp;</td>
@@ -228,12 +227,12 @@
             <td><%= sprintf("%.2f", caller.wait_time) %></td>
             <td><%= sprintf("%.2f", caller.children_time) %></td>
             <td><%= "#{caller.called}/#{method.called}" %></td>
-            <td class="method_name"><%= create_link(thread, total_time, caller.parent) %></td>
+            <td class="method_name"><%= create_link(thread, total_time, caller.parent.target) %></td>
             <% if @result.track_allocations? %>
               <td>-</td>
             <% end %>
-            <td><%= if caller.parent.source_file
-                      file_link(caller.parent.source_file, caller.line)
+            <td><%= if caller.parent.target.source_file
+                      file_link(caller.parent.target.source_file, caller.line)
                     end %></td>
           </tr>
         <% end %>
@@ -293,7 +292,7 @@
         <% end %>
 
         <!-- Children -->
-        <% for callee in method.callees.sort_by(&:total_time).reverse
+        <% for callee in method.call_trees.callees.sort_by(&:total_time).reverse
              next if min_time && callee.total_time < min_time %>
           <tr>
             <td>&nbsp;</td>

data/lib/ruby-prof/{call_info.rb → call_tree.rb}

@@ -1,11 +1,11 @@
 # encoding: utf-8
 
 module RubyProf
-  # The CallInfo class is used to track the relationships between methods. It is a helper class used by
+  # The CallTree class is used to track the relationships between methods. It is a helper class used by
   # RubyProf::MethodInfo to keep track of which methods called a given method and which methods a given
-  # method called. Each CallInfo has a parent and target method. You cannot create a CallInfo object directly,
+  # method called. Each CallTree has a parent and target method. You cannot create a CallTree object directly,
   # they are generated while running a profile.
-  class CallInfo
+  class CallTree
     # The number of times the parent method called the target method
     def called
       self.measurement.called
@@ -31,7 +31,7 @@ module RubyProf
       self.total_time - self.self_time - self.wait_time
     end
 
-    # Compares two CallInfo instances. The comparison is based on the CallInfo#parent, CallInfo#target,
+    # Compares two CallTree instances. The comparison is based on the CallTree#parent, CallTree#target,
     # and total time.
     def <=>(other)
       if self.target == other.target && self.parent == other.parent
@@ -47,11 +47,11 @@ module RubyProf
 
     # :nodoc:
     def to_s
-      "#{parent ? parent.full_name : '<nil>'} - #{target.full_name}"
+      "<#{self.class.name} - #{self.target.full_name}>"
     end
 
     def inspect
-      super + "(#{self.to_s})"
+      self.to_s
     end
   end
 end

data/lib/ruby-prof/call_tree_visitor.rb

@@ -0,0 +1,36 @@
+module RubyProf
+  # The call info visitor class does a depth-first traversal across a
+  # list of call infos. At each call_tree node, the visitor executes
+  # the block provided in the #visit method. The block is passed two
+  # parameters, the event and the call_tree instance. Event will be
+  # either :enter or :exit.
+  #
+  #   visitor = RubyProf::CallTreeVisitor.new(result.threads.first.call_tree)
+  #
+  #   method_names = Array.new
+  #
+  #   visitor.visit do |call_tree, event|
+  #     method_names << call_tree.target.full_name if event == :enter
+  #   end
+  #
+  #   puts method_names
+  class CallTreeVisitor
+    def initialize(call_tree)
+      @call_tree = call_tree
+    end
+
+    def visit(&block)
+      visit_call_tree(@call_tree, &block)
+    end
+
+    private
+
+    def visit_call_tree(call_tree, &block)
+      yield call_tree, :enter
+      call_tree.children.each do |child|
+        visit_call_tree(child, &block)
+      end
+      yield call_tree, :exit
+    end
+  end
+end

data/lib/ruby-prof/measurement.rb

@@ -1,8 +1,11 @@
 module RubyProf
   # The Measurement class is a helper class used by RubyProf::MethodInfo to store information about the method.
-  # You cannot create a CallInfo object directly, they are generated while running a profile.
+  # You cannot create a CallTree object directly, they are generated while running a profile.
   class Measurement
-    # :nodoc:
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
     def to_s
       "c: #{called}, tt: #{total_time}, st: #{self_time}"
     end

data/lib/ruby-prof/method_info.rb

@@ -52,14 +52,9 @@ module RubyProf
       self.total_time - self.self_time - self.wait_time
     end
 
-    # The min call depth of this method
-    def min_depth
-      @min_depth ||= callers.map(&:depth).min
-    end
-
     # :enddoc:
     def <=>(other)
-      if other == nil
+      if other.nil?
         -1
       elsif self.full_name == other.full_name
         0
@@ -67,9 +62,9 @@ module RubyProf
         -1
       elsif self.total_time > other.total_time
         1
-      elsif self.min_depth < other.min_depth
+      elsif self.call_trees.min_depth < other.call_trees.min_depth
         1
-      elsif self.min_depth > other.min_depth
+      elsif self.call_trees.min_depth > other.call_trees.min_depth
         -1
       else
         self.full_name <=> other.full_name
@@ -79,12 +74,5 @@ module RubyProf
     def to_s
       "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
     end
-
-    # Remove method from the call graph. should not be called directly.
-    def eliminate!
-      # $stderr.puts "eliminating #{self}"
-      callers.each{ |call_info| call_info.eliminate! }
-      callers.clear
-    end
   end
 end

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 CallTree instances. This
   # is mainly for debugging purposes as it provides access into
   # into RubyProf's internals.
   #
@@ -19,6 +19,7 @@ module RubyProf
     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"
@@ -27,18 +28,18 @@ module RubyProf
     end
 
     def print_methods(thread)
-      visitor = CallInfoVisitor.new(thread.root_methods)
+      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 << "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
@@ -46,6 +47,7 @@ module RubyProf
     end
 
     def print_footer(thread)
+      @output << "\n" << "\n"
     end
   end
 end

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

@@ -46,7 +46,6 @@ module RubyProf
     def print(output = STDOUT, options = {})
       setup_options(options)
       output << @erb.result(binding)
-      a = 1
     end
 
     # :enddoc:
@@ -55,50 +54,49 @@ module RubyProf
       @erb = ERB.new(self.template)
     end
 
-    def print_stack(output, visited, 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.target.callees
       visible = percent_total >= threshold
       expanded = percent_total >= expansion
       display = visible ? "block" : "none"
 
       output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
 
-      if visited.include?(call_info)
+      if visited.include?(call_tree)
         output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
-        output << "<span>%s %s</span>" % [link(call_info.target, true), graph_link(call_info)] << "\n"
+        output << "<span>%s %s</span>" % [link(call_tree.target, true), graph_link(call_tree)] << "\n"
       else
-        visited << call_info
+        visited << call_tree
 
-        if kids.empty?
+        if call_tree.children.empty?
           output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
         else
-          visible_children = kids.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
+          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
         output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
-                                                            link(call_info.target, false), graph_link(call_info)] << "\n"
+                                                            link(call_tree.target, false), graph_link(call_tree)] << "\n"
 
-        unless kids.empty?
+        unless call_tree.children.empty?
           output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
-          kids.sort_by{|c| -c.total_time}.each do |child_call_info|
-            print_stack(output, visited, child_call_info, total_time)
+          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
 
-        visited.delete(call_info)
+        visited.delete(call_tree)
       end
       output << '</li>' << "\n"
     end
 
-    def name(call_info)
-      method = call_info.target
+    def name(call_tree)
+      method = call_tree.target
       method.full_name
     end
 
@@ -112,19 +110,18 @@ module RubyProf
       end
     end
 
-    def graph_link(call_info)
-      total_calls = call_info.target.called
-      href = "#{method_href(call_info.target)}"
+    def graph_link(call_tree)
+      total_calls = call_tree.target.called
       totals = total_calls.to_s
-      "[#{call_info.called} calls, #{totals} total]"
+      "[#{call_tree.called} calls, #{totals} total]"
     end
 
     def method_href(method)
       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)