airbnb-ruby-prof 0.0.1

data/lib/ruby-prof/thread.rb

@@ -0,0 +1,35 @@
+module RubyProf
+  class Thread
+    def top_methods
+      self.methods.select do |method_info|
+        method_info.call_infos.detect(&:root?)
+      end
+    end
+
+    def top_call_infos
+      top_methods.map(&:call_infos).flatten.select(&:root?)
+    end
+
+    def total_time
+      self.top_methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          if call_info.parent.nil?
+            sum += call_info.total_time
+          end
+        end
+        sum
+      end
+    end
+
+    def wait_time
+      # wait_time, like self:time, is always method local
+      # thus we need to sum over all methods and call infos
+      self.methods.inject(0) do |sum, method_info|
+        method_info.call_infos.each do |call_info|
+          sum += call_info.wait_time
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -0,0 +1,4 @@
+module RubyProf
+  # Based off ruby-prof 0.16.2
+  VERSION = "0.0.1"
+end

data/lib/ruby-prof/walker.rb

@@ -0,0 +1,95 @@
+module RubyProf
+  class Walker
+    attr_reader :roots
+    attr_reader :min_fraction
+
+    def initialize(roots, options={})
+      @roots = roots
+      @options = options
+
+      @all_time = @roots.map(&:total_time).inject(0.0, &:+)
+      @min_percent = options[:min_percent] || 2
+      @min_self_percent = options[:min_self_percent] || 0.001
+    end
+
+    def run
+      around_frame(@roots, :all, "all", 1, 0.0, @all_time) do
+        @roots.each { |r| visit(r) }
+      end
+    end
+
+    def enter_frame(type, obj, name, called, elf_value, total_value)
+      raise NotImplementedError
+    end
+
+    def leave_frame(type, obj)
+      raise NotImplementedError
+    end
+
+    private
+
+    def visit(obj)
+      case obj
+      when RubyProf::Thread   then visit_thread(obj)
+      when RubyProf::CallInfo then visit_context(obj)
+      else raise ArgumentError
+      end
+    end
+
+    def visit_thread(th)
+      name = !th.main? ? "Thread ##{th.index}" : "Main Thread"
+      around_frame(th, :thread, name, 1, 0.0, th.total_time) do
+        th.top_call_infos.each { |ci| visit_context(ci) }
+      end
+    end
+
+    def visit_context(ci)
+      ctx_stack = []; ctx = ci
+      vis_stack = []; vis = true
+      idx_stack = []; idx = 0
+
+      # Enter the current node.
+      name = ctx.target.source_name
+      enter_frame(:context, ctx, name, ctx.called, ctx.self_time, ctx.total_time)
+
+      # While we still have a call info...
+      while ctx
+        # Does this current node has a child at this index.
+        if (child = ctx.children[idx])
+          # Consume the child at the next index.
+          idx += 1
+
+          total_percent = 100.0 * child.total_time / @all_time.to_f
+          self_percent  = 100.0 * child.self_time / ctx.total_time.to_f
+          # Does this meet the minimum requirement to explore?
+          next if total_percent <= @min_percent
+          # Does this span not contain enough information to be useful itself?
+          hide_vis = self_percent <= @min_self_percent
+          # Push the parent onto the stack.
+          # The child becomes the current node.
+          ctx_stack << ctx; ctx = child
+          vis_stack << vis; vis = !hide_vis
+          idx_stack << idx; idx = 0
+          # If visualizing the span, enter it.
+          if vis
+            name = ctx.target.source_name
+            enter_frame(:context, ctx, name, ctx.called, ctx.self_time, ctx.total_time)
+          end
+        else
+          # If we visualized this span, leave it.
+          leave_frame(:context, ctx) if vis
+          # Pop the parent from the stack.
+          ctx = ctx_stack.pop
+          vis = vis_stack.pop
+          idx = idx_stack.pop
+        end
+      end
+    end
+
+    def around_frame(type, obj, name, called, self_value, total_value)
+      enter_frame(type, obj, name, called, self_value, total_value)
+      yield
+      leave_frame(type, obj)
+    end
+  end
+end

data/lib/unprof.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

data/ruby-prof.gemspec

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby-prof/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "airbnb-ruby-prof"
+
+  spec.homepage = "https://github.com/ruby-prof/ruby-prof/"
+  spec.summary = "Fast Ruby profiler"
+  spec.description = <<-EOF
+ruby-prof is a fast code profiler for Ruby. It is a C extension and
+therefore is many times faster than the standard Ruby profiler. It
+supports both flat and graph profiles.  For each method, graph profiles
+show how long the method ran, which methods called it and which
+methods it called. RubyProf generate both text and html and can output
+it to standard out or to a file.
+EOF
+  spec.license = 'BSD-2-Clause'
+  spec.version = RubyProf::VERSION
+
+  spec.author = "Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes"
+  spec.email = "shugo@ruby-lang.org, cfis@savagexi.com, rogerdpack@gmail.com, skaes@railsexpress.de"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.bindir = "bin"
+  spec.executables = ["ruby-prof", "ruby-prof-check-trace"]
+  spec.extensions = ["ext/ruby_prof/extconf.rb"]
+  spec.files = Dir['CHANGES',
+                   'LICENSE',
+                   'Rakefile',
+                   'README.rdoc',
+                   'ruby-prof.gemspec',
+                   'bin/ruby-prof',
+                   'bin/ruby-prof-check-trace',
+                   'examples/*',
+                   'ext/ruby_prof/extconf.rb',
+                   'ext/ruby_prof/*.c',
+                   'ext/ruby_prof/*.h',
+                   'ext/ruby_prof/vc/*.sln',
+                   'ext/ruby_prof/vc/*.vcxproj',
+                   'lib/ruby-prof.rb',
+                   'lib/unprof.rb',
+                   'lib/ruby-prof/*.rb',
+                   'lib/ruby-prof/assets/*.{html,png,erb}',
+                   'lib/ruby-prof/profile/*.rb',
+                   'lib/ruby-prof/printers/*.rb',
+                   'test/*.rb']
+
+  spec.test_files = Dir["test/test_*.rb"]
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.date = Time.now.strftime('%Y-%m-%d')
+  spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
+  spec.add_development_dependency('minitest', '~> 5.8.3')
+  spec.add_development_dependency('rake-compiler')
+end

data/test/aggregate_test.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# Test data
+#   A   B   C
+#   |   |   |
+#   Z   A   A
+#       |   |
+#       Z   Z
+
+class AggClass
+  def z
+    sleep 1
+  end
+
+  def a
+    z
+  end
+
+  def b
+    a
+  end
+
+  def c
+    a
+  end
+end
+
+class AggregateTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_all_call_infos_are_not_recursive
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+    methods = result.threads.first.methods.sort.reverse
+    methods.each do |m|
+      m.call_infos.each do |ci|
+        assert(!ci.recursive?)
+      end
+    end
+  end
+
+  def test_call_infos
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
+
+    # Check AggClass#z
+    assert_equal('AggClass#z', method.full_name)
+    assert_equal(3, method.called)
+    assert_in_delta(3, method.total_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(3, method.children_time, 0.05)
+    assert_equal(3, method.call_infos.length)
+
+    call_info = method.call_infos[0]
+    assert_equal('AggregateTest#test_call_infos->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[1]
+    assert_equal('AggregateTest#test_call_infos->AggClass#b->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+
+    call_info = method.call_infos[2]
+    assert_equal('AggregateTest#test_call_infos->AggClass#c->AggClass#a->AggClass#z', call_info.call_sequence)
+    assert_equal(1, call_info.children.length)
+  end
+
+  def test_aggregates_parents
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#z'}
+
+    # Check AggClass#z
+    assert_equal('AggClass#z', method.full_name)
+
+    call_infos = method.aggregate_parents
+    assert_equal(1, call_infos.length)
+
+    call_info = call_infos.first
+    assert_equal('AggClass#a', call_info.parent.target.full_name)
+    assert_in_delta(3, call_info.total_time, 0.05)
+    assert_in_delta(0, call_info.wait_time, 0.05)
+    assert_in_delta(0, call_info.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+
+  def test_aggregates_children
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.first.methods.sort.reverse
+    method = methods.find {|meth| meth.full_name == 'AggClass#a'}
+
+    # Check AggClass#a
+    assert_equal('AggClass#a', method.full_name)
+
+    call_infos = method.aggregate_children
+    assert_equal(1, call_infos.length)
+
+    call_info = call_infos.first
+    assert_equal('AggClass#z', call_info.target.full_name)
+    assert_in_delta(3, call_info.total_time, 0.05)
+    assert_in_delta(0, call_info.wait_time, 0.05)
+    assert_in_delta(0, call_info.self_time, 0.05)
+    assert_in_delta(3, call_info.children_time, 0.05)
+    assert_equal(3, call_info.called)
+  end
+end

data/test/basic_test.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class BasicTest < TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def start
+    RubyProf.start
+    RubyProf::C1.hello
+  end
+
+  def test_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+
+  def test_double_profile
+    RubyProf.start
+    assert_raises(RuntimeError) do
+      RubyProf.start
+    end
+    RubyProf.stop
+  end
+
+  def test_no_block
+    assert_raises(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+
+  def test_traceback
+    RubyProf.start
+    assert_raises(NoMethodError) do
+      RubyProf.xxx
+    end
+
+    RubyProf.stop
+  end
+
+  def test_leave_method
+    start
+    sleep 0.15
+    profile = RubyProf.stop
+
+    assert_equal(1, profile.threads.count)
+
+    thread = profile.threads.first
+    assert_in_delta(0.25, thread.total_time, 0.015)
+
+    top_methods = thread.top_methods.sort
+    assert_equal(2, top_methods.count)
+    assert_equal("BasicTest#start", top_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method", top_methods[1].full_name)
+
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
+
+    # Check times
+    assert_equal("<Class::RubyProf::C1>#hello", methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.015)
+    assert_in_delta(0.0,  methods[0].wait_time, 0.015)
+    assert_in_delta(0.0,  methods[0].self_time, 0.015)
+
+    assert_equal("BasicTest#start", methods[1].full_name)
+    assert_in_delta(0.1, methods[1].total_time, 0.015)
+    assert_in_delta(0.0, methods[1].wait_time, 0.015)
+    assert_in_delta(0.0, methods[1].self_time, 0.015)
+
+    assert_equal("BasicTest#test_leave_method", methods[2].full_name)
+    assert_in_delta(0.15, methods[2].total_time, 0.015)
+    assert_in_delta(0.0, methods[2].wait_time, 0.015)
+    assert_in_delta(0.0, methods[2].self_time, 0.015)
+
+    assert_equal("Kernel#sleep", methods[3].full_name)
+    assert_in_delta(0.25, methods[3].total_time, 0.015)
+    assert_in_delta(0.0, methods[3].wait_time, 0.015)
+    assert_in_delta(0.25, methods[3].self_time, 0.015)
+  end
+
+  def test_leave_method_2
+    start
+    RubyProf::C1.hello
+    RubyProf::C1.hello
+    profile = RubyProf.stop
+
+    assert_equal(1, profile.threads.count)
+
+    thread = profile.threads.first
+    assert_in_delta(0.3, thread.total_time, 0.015)
+
+    top_methods = thread.top_methods.sort
+    assert_equal(2, top_methods.count)
+    assert_equal("BasicTest#start", top_methods[0].full_name)
+    assert_equal("BasicTest#test_leave_method_2", top_methods[1].full_name)
+
+    assert_equal(4, thread.methods.length)
+    methods = profile.threads.first.methods.sort
+
+    # Check times
+    assert_equal("BasicTest#start", methods[0].full_name)
+    assert_in_delta(0.1, methods[0].total_time, 0.015)
+    assert_in_delta(0.0, methods[0].wait_time, 0.015)
+    assert_in_delta(0.0, methods[0].self_time, 0.015)
+
+    assert_equal("BasicTest#test_leave_method_2", methods[1].full_name)
+    assert_in_delta(0.2, methods[1].total_time, 0.015)
+    assert_in_delta(0.0, methods[1].wait_time, 0.015)
+    assert_in_delta(0.0, methods[1].self_time, 0.015)
+
+    assert_equal("Kernel#sleep", methods[2].full_name)
+    assert_in_delta(0.3, methods[2].total_time, 0.015)
+    assert_in_delta(0.0, methods[2].wait_time, 0.015)
+    assert_in_delta(0.3, methods[2].self_time, 0.015)
+
+    assert_equal("<Class::RubyProf::C1>#hello", methods[3].full_name)
+    assert_in_delta(0.3, methods[3].total_time, 0.015)
+    assert_in_delta(0.0, methods[3].wait_time, 0.015)
+    assert_in_delta(0.0, methods[3].self_time, 0.015)
+  end
+end