ruby-prof-danielhoey 0.8.1

data/lib/unprof.rb

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

data/rails/environment/profile.rb

@@ -0,0 +1,24 @@
+# Settings specified here will take precedence over those in config/environment.rb
+# The profile environment should match the same settings
+# as the production environment to give a reasonalbe
+# approximation of performance.  However, it should
+# definitely not use the production databse!
+
+
+# Cache classes - otherwise your code 
+# will run approximately 5 times slower and the
+# profiling results will be overwhelmed by Rails
+# dependency loading mechanism
+config.cache_classes = true
+
+# Don't check template timestamps - once again this
+# is to avoid IO times overwhelming profile results
+config.action_view.cache_template_loading            = true
+
+# This is debatable, but turn off action controller
+# caching to see how long it really takes to run
+# queries and render templates
+config.action_controller.perform_caching             = false
+
+# Turn off most logging
+config.log_level = :info

data/rails/example/example_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '../profile_test_helper'
+
+class ExampleTest < Test::Unit::TestCase
+  include RubyProf::Test
+  
+  def test_stuff
+    puts "Test method"
+  end
+end   

data/rails/profile_test_helper.rb

@@ -0,0 +1,21 @@
+# Load profile environment
+env = ENV["RAILS_ENV"] = "profile"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+
+# Load Rails testing infrastructure
+require 'test_help'
+
+# Now we can load test_helper since we've already loaded the
+# profile RAILS environment.
+require File.expand_path(File.join(RAILS_ROOT, 'test', 'test_helper'))
+
+# Reset the current environment back to profile
+# since test_helper reset it to test
+ENV["RAILS_ENV"] = env
+
+# Now load ruby-prof and away we go
+require 'ruby-prof'
+
+# Setup output directory to Rails tmp directory
+RubyProf::Test::PROFILE_OPTIONS[:output_dir] = 
+    File.expand_path(File.join(RAILS_ROOT, 'tmp', 'profile'))

data/test/aggregate_test.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+# 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 < Test::Unit::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_call_infos
+    c1 = AggClass.new
+    result = RubyProf.profile do
+      c1.a
+      c1.b
+      c1.c
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    method = methods.find {|method| method.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.01)
+    assert_in_delta(0, method.wait_time, 0.01)
+    assert_in_delta(0, method.self_time, 0.01)
+    assert_in_delta(3, method.children_time, 0.01)
+    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.values.first.sort.reverse
+    method = methods.find {|method| method.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.01)
+    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.values.first.sort.reverse
+    method = methods.find {|method| method.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.01)
+    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,290 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+
+class C1
+  def C1.hello
+    sleep(0.1)
+  end
+  
+  def hello
+    sleep(0.2)
+  end
+end
+
+module M1
+  def hello
+    sleep(0.3)
+  end
+end
+
+class C2
+  include M1
+  extend M1
+end
+
+class C3
+  def hello
+    sleep(0.4)
+  end
+end
+
+module M4
+  def hello
+    sleep(0.5)
+  end
+end
+
+module M5
+  include M4
+  def goodbye
+    hello
+  end
+end
+
+class C6
+  include M5
+  def test
+    goodbye
+  end
+end
+
+class BasicTest < Test::Unit::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_running
+    assert(!RubyProf.running?)
+    RubyProf.start
+    assert(RubyProf.running?)
+    RubyProf.stop
+    assert(!RubyProf.running?)
+  end
+
+  def test_double_profile
+    RubyProf.start
+    assert_raise(RuntimeError) do
+      RubyProf.start
+    end
+
+    assert_raise(RuntimeError) do
+      RubyProf.profile do
+        puts 1
+      end
+    end
+    RubyProf.stop
+  end
+
+  def test_no_block
+    assert_raise(ArgumentError) do
+      RubyProf.profile
+    end
+  end
+
+  def test_class_methods
+    result = RubyProf.profile do
+      C1.hello
+    end
+
+    # Length should be 3:
+    #   BasicTest#test_class_methods
+    #   <Class::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('BasicTest#test_class_methods', methods[0].full_name)
+    assert_equal('<Class::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+  end
+  
+  if RUBY_VERSION < '1.9'
+    PARENT = Object
+  else
+    PARENT = BasicObject
+  end
+
+  def test_instance_methods
+    result = RubyProf.profile do
+      C1.new.hello
+    end
+
+    # Methods called
+    #   BasicTest#test_instance_methods
+    #   Class.new
+    #   Class:Object#allocate
+    #   for Object#initialize
+    #   C1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('BasicTest#test_instance_methods', names[0])
+    assert_equal('C1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    # order can differ
+    assert(names.include?("<Class::#{PARENT}>#allocate"))
+    assert(names.include?("#{PARENT}#initialize"))
+
+    # Check times
+    assert_in_delta(0.2, methods[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.2, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.2, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_module_methods
+    result = RubyProf.profile do
+      C2.hello
+    end
+
+    # Methods:
+    #   BasicTest#test_module_methods
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(3, methods.length)
+
+    assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+    assert_equal('M1#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.1)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.1)
+    assert_in_delta(0, methods[2].wait_time, 0.02)
+    assert_in_delta(0.3, methods[2].self_time, 0.1)
+  end
+
+  def test_module_instance_methods
+    result = RubyProf.profile do
+      C2.new.hello
+    end
+
+    # Methods:
+    #   BasicTest#test_module_instance_methods
+    #   Class#new
+    #   <Class::Object>#allocate
+    #   Object#initialize
+    #   M1#hello
+    #   Kernel#sleep
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(6, methods.length)
+    names = methods.map(&:full_name)
+    assert_equal('BasicTest#test_module_instance_methods', names[0])
+    assert_equal('M1#hello', names[1])
+    assert_equal('Kernel#sleep', names[2])
+    assert_equal('Class#new', names[3])
+    assert(names.include?("<Class::#{PARENT}>#allocate"))
+    assert(names.include?("#{PARENT}#initialize"))
+    
+    # Check times
+    assert_in_delta(0.3, methods[0].total_time, 0.1)
+    assert_in_delta(0, methods[0].wait_time, 0.1)
+    assert_in_delta(0, methods[0].self_time, 0.1)
+
+    assert_in_delta(0.3, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.3, methods[2].total_time, 0.02)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.3, methods[2].self_time, 0.02)
+
+    assert_in_delta(0, methods[3].total_time, 0.01)
+    assert_in_delta(0, methods[3].wait_time, 0.01)
+    assert_in_delta(0, methods[3].self_time, 0.01)
+
+    assert_in_delta(0, methods[4].total_time, 0.01)
+    assert_in_delta(0, methods[4].wait_time, 0.01)
+    assert_in_delta(0, methods[4].self_time, 0.01)
+
+    assert_in_delta(0, methods[5].total_time, 0.01)
+    assert_in_delta(0, methods[5].wait_time, 0.01)
+    assert_in_delta(0, methods[5].self_time, 0.01)
+  end
+
+  def test_singleton
+    c3 = C3.new
+
+    class << c3
+      def hello
+      end
+    end
+
+    result = RubyProf.profile do
+      c3.hello
+    end
+
+    methods = result.threads.values.first.sort.reverse
+    assert_equal(2, methods.length)
+
+    assert_equal('BasicTest#test_singleton', methods[0].full_name)
+    assert_equal('<Object::C3>#hello', methods[1].full_name)
+
+    assert_in_delta(0, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  end
+
+  def test_traceback
+    RubyProf.start
+    assert_raise(NoMethodError) do
+      RubyProf.xxx
+    end
+
+    RubyProf.stop
+  end
+end