RubyGems - airbnb-ruby-prof - Versions diffs - 0.0.1 - Mend

airbnb-ruby-prof 0.0.1

Files changed (116) hide show

data/CHANGES +483 -0
data/LICENSE +25 -0
data/README.rdoc +426 -0
data/Rakefile +51 -0
data/bin/ruby-prof +279 -0
data/bin/ruby-prof-check-trace +45 -0
data/examples/flat.txt +50 -0
data/examples/graph.dot +84 -0
data/examples/graph.html +823 -0
data/examples/graph.txt +139 -0
data/examples/multi.flat.txt +23 -0
data/examples/multi.graph.html +760 -0
data/examples/multi.grind.dat +114 -0
data/examples/multi.stack.html +547 -0
data/examples/stack.html +547 -0
data/ext/ruby_prof/extconf.rb +67 -0
data/ext/ruby_prof/rp_call_info.c +374 -0
data/ext/ruby_prof/rp_call_info.h +59 -0
data/ext/ruby_prof/rp_fast_call_tree_printer.c +247 -0
data/ext/ruby_prof/rp_fast_call_tree_printer.h +10 -0
data/ext/ruby_prof/rp_measure.c +71 -0
data/ext/ruby_prof/rp_measure.h +56 -0
data/ext/ruby_prof/rp_measure_allocations.c +74 -0
data/ext/ruby_prof/rp_measure_cpu_time.c +134 -0
data/ext/ruby_prof/rp_measure_gc_runs.c +71 -0
data/ext/ruby_prof/rp_measure_gc_time.c +58 -0
data/ext/ruby_prof/rp_measure_memory.c +75 -0
data/ext/ruby_prof/rp_measure_process_time.c +69 -0
data/ext/ruby_prof/rp_measure_wall_time.c +43 -0
data/ext/ruby_prof/rp_method.c +717 -0
data/ext/ruby_prof/rp_method.h +79 -0
data/ext/ruby_prof/rp_stack.c +221 -0
data/ext/ruby_prof/rp_stack.h +81 -0
data/ext/ruby_prof/rp_thread.c +312 -0
data/ext/ruby_prof/rp_thread.h +36 -0
data/ext/ruby_prof/ruby_prof.c +800 -0
data/ext/ruby_prof/ruby_prof.h +64 -0
data/ext/ruby_prof/vc/ruby_prof.sln +32 -0
data/ext/ruby_prof/vc/ruby_prof_18.vcxproj +108 -0
data/ext/ruby_prof/vc/ruby_prof_19.vcxproj +110 -0
data/ext/ruby_prof/vc/ruby_prof_20.vcxproj +110 -0
data/lib/ruby-prof.rb +63 -0
data/lib/ruby-prof/aggregate_call_info.rb +76 -0
data/lib/ruby-prof/assets/call_stack_printer.css.html +117 -0
data/lib/ruby-prof/assets/call_stack_printer.js.html +385 -0
data/lib/ruby-prof/assets/call_stack_printer.png +0 -0
data/lib/ruby-prof/assets/flame_graph_printer.lib.css.html +149 -0
data/lib/ruby-prof/assets/flame_graph_printer.lib.js.html +707 -0
data/lib/ruby-prof/assets/flame_graph_printer.page.js.html +56 -0
data/lib/ruby-prof/assets/flame_graph_printer.tmpl.html.erb +39 -0
data/lib/ruby-prof/call_info.rb +111 -0
data/lib/ruby-prof/call_info_visitor.rb +40 -0
data/lib/ruby-prof/compatibility.rb +186 -0
data/lib/ruby-prof/method_info.rb +109 -0
data/lib/ruby-prof/printers/abstract_printer.rb +85 -0
data/lib/ruby-prof/printers/call_info_printer.rb +41 -0
data/lib/ruby-prof/printers/call_stack_printer.rb +260 -0
data/lib/ruby-prof/printers/call_tree_printer.rb +130 -0
data/lib/ruby-prof/printers/dot_printer.rb +132 -0
data/lib/ruby-prof/printers/fast_call_tree_printer.rb +87 -0
data/lib/ruby-prof/printers/flame_graph_html_printer.rb +59 -0
data/lib/ruby-prof/printers/flame_graph_json_printer.rb +157 -0
data/lib/ruby-prof/printers/flat_printer.rb +70 -0
data/lib/ruby-prof/printers/flat_printer_with_line_numbers.rb +64 -0
data/lib/ruby-prof/printers/graph_html_printer.rb +244 -0
data/lib/ruby-prof/printers/graph_printer.rb +116 -0
data/lib/ruby-prof/printers/multi_printer.rb +58 -0
data/lib/ruby-prof/profile.rb +22 -0
data/lib/ruby-prof/profile/exclude_common_methods.rb +201 -0
data/lib/ruby-prof/rack.rb +95 -0
data/lib/ruby-prof/task.rb +147 -0
data/lib/ruby-prof/thread.rb +35 -0
data/lib/ruby-prof/version.rb +4 -0
data/lib/ruby-prof/walker.rb +95 -0
data/lib/unprof.rb +10 -0
data/ruby-prof.gemspec +56 -0
data/test/aggregate_test.rb +136 -0
data/test/basic_test.rb +128 -0
data/test/block_test.rb +74 -0
data/test/call_info_test.rb +78 -0
data/test/call_info_visitor_test.rb +31 -0
data/test/duplicate_names_test.rb +32 -0
data/test/dynamic_method_test.rb +55 -0
data/test/enumerable_test.rb +21 -0
data/test/exceptions_test.rb +16 -0
data/test/exclude_methods_test.rb +146 -0
data/test/exclude_threads_test.rb +53 -0
data/test/fiber_test.rb +79 -0
data/test/issue137_test.rb +63 -0
data/test/line_number_test.rb +71 -0
data/test/measure_allocations_test.rb +26 -0
data/test/measure_cpu_time_test.rb +213 -0
data/test/measure_gc_runs_test.rb +32 -0
data/test/measure_gc_time_test.rb +36 -0
data/test/measure_memory_test.rb +33 -0
data/test/measure_process_time_test.rb +63 -0
data/test/measure_wall_time_test.rb +255 -0
data/test/module_test.rb +45 -0
data/test/multi_measure_test.rb +38 -0
data/test/multi_printer_test.rb +83 -0
data/test/no_method_class_test.rb +15 -0
data/test/pause_resume_test.rb +166 -0
data/test/prime.rb +54 -0
data/test/printers_test.rb +255 -0
data/test/printing_recursive_graph_test.rb +127 -0
data/test/rack_test.rb +93 -0
data/test/recursive_test.rb +212 -0
data/test/singleton_test.rb +38 -0
data/test/stack_printer_test.rb +65 -0
data/test/stack_test.rb +138 -0
data/test/start_stop_test.rb +112 -0
data/test/test_helper.rb +264 -0
data/test/thread_test.rb +187 -0
data/test/unique_call_path_test.rb +202 -0
data/test/yarv_test.rb +55 -0
metadata +211 -0

data/lib/ruby-prof/assets/flame_graph_printer.page.js.html ADDED

@@ -0,0 +1,56 @@
+<script type="text/javascript">
+// Flamegraph
+var cellHeight = 14;
+var height = cellHeight * data.depth + 40;
+var flameGraph = d3.flameGraph()
+  .width(1250)
+  .height(height)
+  .cellHeight(cellHeight)
+  .transitionDuration(750)
+  .transitionEase('cubic-in-out')
+  .sort(true)
+  .title("");
+// Tooltip
+var tip = d3.tip()
+  .direction("s")
+  .offset([8, 0])
+  .attr('class', 'd3-flame-graph-tip')
+  .html(function(d) {
+    return d.name + " (" +
+      d3.round(d.called, 0) + "; " +
+      d3.round(100 * d.dx, 3) + "%)";
+  });
+flameGraph.tooltip(tip);
+// Searching and Zooming
+document.getElementById("form").addEventListener("submit", function(event) {
+  event.preventDefault();
+  search();
+});
+function search() {
+  var term = document.getElementById("term").value;
+  flameGraph.search(term);
+}
+function clear() {
+  document.getElementById('term').value = '';
+  flameGraph.clear();
+}
+function resetZoom() {
+  flameGraph.resetZoom();
+}
+d3.select("#chart")
+  .datum(data.root)
+  .call(flameGraph);
+</script>

data/lib/ruby-prof/assets/flame_graph_printer.tmpl.html.erb ADDED

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+<%= css_libraries_html %>
+    <title>Flame Graph</title>
+  </head>
+  <body>
+    <div class="container">
+      <div class="header clearfix">
+        <nav>
+          <div class="pull-right">
+            <form class="form-inline" id="form">
+              <a class="btn" href="javascript: resetZoom();">Reset zoom</a>
+              <a class="btn" href="javascript: clear();">Clear</a>
+              <div class="form-group">
+                <input type="text" class="form-control" id="term">
+              </div>
+              <a class="btn btn-primary" href="javascript: search();">Search</a>
+            </form>
+          </div>
+        </nav>
+        <h3 class="text-muted">Flame Graph</h3>
+      </div>
+      <div id="chart">
+      </div>
+    </div>
+<%= js_libraries_html %>
+<%= js_data_html %>
+<%= js_code_html %>
+  </body>
+</html>

data/lib/ruby-prof/call_info.rb ADDED

@@ -0,0 +1,111 @@
+# encoding: utf-8
+module RubyProf
+  class CallInfo
+    # 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)
+    def measure_values_memoized
+      @measure_values ||= measure_values
+    end
+    def total_time(i = 0)
+      measure_values_memoized[i][0]
+    end
+    def self_time(i = 0)
+      measure_values_memoized[i][1]
+    end
+    def wait_time(i = 0)
+      measure_values_memoized[i][2]
+    end
+    def children_time(i = 0)
+      children.inject(0) do |sum, call_info|
+        sum += call_info.total_time(i)
+      end
+    end
+    def stack
+      @stack ||= begin
+        methods = Array.new
+        call_info = self
+        while call_info
+          methods << call_info.target
+          call_info = call_info.parent
+        end
+        methods.reverse
+      end
+    end
+    def call_sequence
+      @call_sequence ||= begin
+        stack.map {|method| method.full_name}.join('->')
+      end
+    end
+    def root?
+      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
+      "#{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
+    # find a specific call in list of children. returns nil if not found.
+    # note: there can't be more than one child with a given target method. in other words:
+    # x.children.grep{|y|y.target==m}.size <= 1 for all method infos m and call infos x
+    def find_call(other)
+      matching = children.select { |kid| kid.target == other.target }
+      raise "inconsistent call tree" unless matching.size <= 1
+      matching.first
+    end
+    # merge two call trees. adds self, wait, and total time of other to self and merges children of other into children of self.
+    def merge_call_tree(other)
+      # $stderr.puts "merging #{self}\nand #{other}"
+      self.called += other.called
+      add_self_time(other)
+      add_wait_time(other)
+      add_total_time(other)
+      other.children.each do |other_kid|
+        if kid = find_call(other_kid)
+          # $stderr.puts "merging kids"
+          kid.merge_call_tree(other_kid)
+        else
+          other_kid.parent = self
+          children << other_kid
+        end
+      end
+      other.children.clear
+      other.target.call_infos.delete(other)
+    end
+  end
+end

data/lib/ruby-prof/call_info_visitor.rb ADDED

@@ -0,0 +1,40 @@
+# 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.top_call_infos)
+#
+#   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
+    def initialize(call_infos)
+      @call_infos = CallInfo.roots_of(call_infos)
+    end
+    def visit(&block)
+      @call_infos.each do |call_info|
+        visit_call_info(call_info, &block)
+      end
+    end
+    private
+    def visit_call_info(call_info, &block)
+      yield call_info, :enter
+      call_info.children.each do |child|
+        visit_call_info(child, &block)
+      end
+      yield call_info, :exit
+    end
+  end
+end

data/lib/ruby-prof/compatibility.rb ADDED

@@ -0,0 +1,186 @@
+# encoding: utf-8
+# These methods are here for backwards compatability with previous RubyProf releases
+module RubyProf
+  # Measurements
+  def self.cpu_frequency
+    Measure::CpuTime.frequency
+  end
+  def self.measure_allocations
+    Measure::Allocations.measure
+  end
+  def self.measure_cpu_time
+    Measure::CpuTime.measure
+  end
+  def self.measure_gc_runs
+    Measure::GcRuns.measure
+  end
+  def self.measure_gc_time
+    Measure::GcTime.measure
+  end
+  def self.measure_memory
+    Measure::Memory.measure
+  end
+  def self.measure_process_time
+    Measure::ProcessTime.measure
+  end
+  def self.measure_wall_time
+    Measure::WallTime.measure
+  end
+  # call-seq:
+  # measure_mode -> measure_mode
+  #
+  # Returns what ruby-prof is measuring.  Valid values include:
+  #
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  def self.measure_mode
+    measure_modes.first
+  end
+  # call-seq:
+  # measure_mode=value -> void
+  #
+  # Specifies what ruby-prof should measure.  Valid values include:
+  #
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
+  # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
+  # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
+  # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  def self.measure_mode=(value)
+    self.measure_modes = [value]
+  end
+  def self.measure_modes
+    @measure_modes ||= [RubyProf::WALL_TIME]
+  end
+  def self.measure_modes=(value)
+    @measure_modes = value
+  end
+  def self.measure_mode_string
+    case measure_mode
+    when WALL_TIME    then "wall_time"
+    when CPU_TIME     then "cpu_time"
+    when PROCESS_TIME then "process_time_time"
+    when ALLOCATIONS  then "allocations"
+    when MEMORY       then "memory"
+    when GC_TIME      then "gc_time"
+    when GC_RUNS      then "gc_runs"
+    end
+  end
+  # call-seq:
+  # exclude_threads -> exclude_threads
+  #
+  # Returns threads ruby-prof should exclude from profiling
+  def self.exclude_threads
+    @exclude_threads ||= Array.new
+  end
+  # call-seq:
+  # exclude_threads= -> void
+  #
+  # Specifies what threads ruby-prof should exclude from profiling
+  def self.exclude_threads=(value)
+    @exclude_threads = value
+  end
+  # Profiling
+  def self.start_script(script)
+    start
+    load script
+  end
+  def self.start
+    ensure_not_running!
+    @profile = Profile.new(measure_modes: measure_modes, exclude_threads: exclude_threads)
+    enable_gc_stats_if_needed
+    @profile.start
+  end
+  def self.pause
+    ensure_running!
+    disable_gc_stats_if_needed
+    @profile.pause
+  end
+  def self.running?
+    if defined?(@profile) and @profile
+      @profile.running?
+    else
+      false
+    end
+  end
+  def self.resume
+    ensure_running!
+    enable_gc_stats_if_needed
+    @profile.resume
+  end
+  def self.stop
+    ensure_running!
+    result = @profile.stop
+    disable_gc_stats_if_needed
+    @profile = nil
+    result
+  end
+  # Profile a block
+  def self.profile(options = {}, &block)
+    ensure_not_running!
+    gc_stat_was_enabled = enable_gc_stats_if_needed
+    options = { measure_modes: [measure_mode], exclude_threads: exclude_threads }.merge!(options)
+    result = Profile.profile(options, &block)
+    disable_gc_stats_if_needed(gc_stat_was_enabled)
+    result
+  end
+private
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  end
+  def self.ensure_not_running!
+    raise(RuntimeError, "RubyProf is already running") if running?
+  end
+  # for GC.allocated_size to work GC statistics should be enabled
+  def self.enable_gc_stats_if_needed
+    if measure_mode_requires_gc_stats_enabled?
+      @gc_stat_was_enabled = GC.enable_stats
+    end
+  end
+  def self.disable_gc_stats_if_needed(was_enabled=nil)
+    was_enabled ||= defined?(@gc_stat_was_enabled) && @gc_stat_was_enabled
+    GC.disable_stats if measure_mode_requires_gc_stats_enabled? && !was_enabled
+  end
+  def self.measure_mode_requires_gc_stats_enabled?
+    GC.respond_to?(:enable_stats) &&
+      [RubyProf::MEMORY, RubyProf::GC_TIME, RubyProf::GC_RUNS].include?(measure_mode)
+  end
+end

data/lib/ruby-prof/method_info.rb ADDED

@@ -0,0 +1,109 @@
+# encoding: utf-8
+module RubyProf
+  class MethodInfo
+    include Comparable
+    def <=>(other)
+      if self.total_time < other.total_time
+        -1
+      elsif self.total_time > other.total_time
+        1
+      elsif self.min_depth < other.min_depth
+        1
+      elsif self.min_depth > other.min_depth
+        -1
+      else
+        self.full_name <=> other.full_name
+      end
+    end
+    def called
+      @called ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum + call_info.called
+        end
+      end
+    end
+    def total_time(i = 0)
+      @total_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.total_time(i) if !call_info.recursive?
+          sum
+        end
+      end
+    end
+    def self_time(i = 0)
+      @self_time ||= []
+      @self_time[i] ||= self_time_unmemoized(i)
+    end
+    def wait_time(i = 0)
+      @wait_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.wait_time(i) if !call_info.recursive?
+          sum
+        end
+      end
+    end
+    def children_time(i = 0)
+      @children_time ||= begin
+        call_infos.inject(0) do |sum, call_info|
+          sum += call_info.children_time(i) if !call_info.recursive?
+          sum
+        end
+      end
+    end
+    def min_depth
+      @min_depth ||= call_infos.map(&:depth).min
+    end
+    def root?
+      @root ||= begin
+        call_infos.find do |call_info|
+          not call_info.root?
+        end.nil?
+      end
+    end
+    def children
+      @children ||= call_infos.map(&:children).flatten
+    end
+    def parents
+      @parents ||= call_infos.map(&:parent)
+    end
+    def aggregate_parents
+      # group call infos based on their parents
+      groups = self.call_infos.each_with_object({}) do |call_info, hash|
+        key = call_info.parent ? call_info.parent.target : self
+        (hash[key] ||= []) << call_info
+      end
+      groups.map do |key, value|
+        AggregateCallInfo.new(value, self)
+      end
+    end
+    def aggregate_children
+      # group call infos based on their targets
+      groups = self.children.each_with_object({}) do |call_info, hash|
+        key = call_info.target
+        (hash[key] ||= []) << call_info
+      end
+      groups.map do |key, value|
+        AggregateCallInfo.new(value, self)
+      end
+    end
+    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
+  end
+end