ruby-prof 0.6.0-x86-mswin32-60

data/test/test_helper.rb

@@ -0,0 +1,55 @@
+def print_results(result)
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+    
+  STDOUT << "\n" * 2
+    
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print(STDOUT)
+end
+
+def check_parent_times(method)
+  return if method.parents.length == 0 
+
+  parents_self_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.self_time
+  end
+
+  assert_in_delta(method.self_time, parents_self_time, 0.01, 
+                  "Invalid parent times for method #{method.full_name}")
+    
+  parents_wait_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.wait_time
+  end
+
+  assert_in_delta(method.wait_time, parents_wait_time, 0.01, method.full_name)
+   
+  parents_children_time = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.children_time
+  end
+  
+  assert_in_delta(method.children_time, parents_children_time, 0.01,
+                  "Invalid child times for method #{method.full_name}")
+end
+  
+def check_parent_calls(method)
+  return if method.parents.length == 0 
+  
+  parent_calls = method.parents.inject(0) do |sum, call_info|
+    sum + call_info.called
+  end
+  
+  assert_equal(method.called, parent_calls,  
+                  "Invalid parent calls for method #{method.full_name}")
+end
+  
+def check_child_times(method)
+  return if method.children.length == 0
+    
+  children_total_time = method.children.inject(0) do |sum, call_info|
+    sum + call_info.total_time
+  end
+  
+  assert_in_delta(method.children_time, children_total_time, 0.01,
+                  "Invalid child time for method #{method.full_name}")
+end

data/test/test_suite.rb

@@ -0,0 +1,19 @@
+# file ts_dbaccess.rb
+require 'test/unit'
+require 'basic_test'
+require 'duplicate_names_test'
+require 'line_number_test'
+require 'measure_mode_test'
+require 'module_test'
+require 'no_method_class_test'
+require 'prime_test'
+require 'printers_test'
+require 'recursive_test'
+require 'singleton_test'
+require 'thread_test'
+require 'timing_test'
+
+# Can't use this one here cause it breaks
+# the rest of the unit tets (Ruby Prof gets
+# started twice).
+#require 'profile_unit_test'

data/test/thread_test.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'timeout'
+require 'test_helper'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+# --  Tests ----
+class ThreadTest < Test::Unit::TestCase
+  def test_thread_timings
+    RubyProf.start
+    
+    sleep(2)    
+
+    thread = Thread.new do
+      sleep(0.5)
+      sleep(2)
+    end
+    
+    thread.join
+    
+    result = RubyProf.stop
+
+    values = result.threads.values.sort do |value1, value2|
+      value1.length <=> value2.length
+    end
+    
+    # Check background thread
+    methods = values.first.sort.reverse
+    assert_equal(2, methods.length)
+    
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0.5, method.wait_time, 0.02)
+    assert_in_delta(2.0, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(1, method.children.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(2.0, method.self_time, 0.02)
+    assert_in_delta(0.5, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    # Check foreground thread
+    methods = values.last.sort.reverse
+    assert_equal(5, methods.length)
+    methods = methods.sort.reverse
+    
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_in_delta(4.5, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(2.0, method.wait_time, 0.02)
+    assert_in_delta(2.5, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(3, method.children.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', method.full_name)
+    assert_in_delta(2.5, method.total_time, 0.02)
+    assert_in_delta(0.5, method.self_time, 0.02)
+    assert_in_delta(2.0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(2.0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[3]
+    assert_equal('<Class::Thread>#new', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(1, method.children.length)
+    
+    method = methods[4]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_in_delta(0, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+  end
+
+  def test_thread
+    result = RubyProf.profile do 
+      begin
+        status = Timeout::timeout(2) do
+          while true
+            next
+          end
+        end
+      rescue Timeout::Error
+      end
+    end
+    
+    printer = RubyProf::GraphPrinter.new(result)
+    printer.print
+    
+    result.threads.each do |thread_id, methods|
+      STDOUT << "thread: " << thread_id << "\n"
+      methods.each do |method|
+        check_parent_times(method)
+        check_parent_calls(method)
+        check_child_times(method)   
+      end
+    end
+  end
+end

data/test/timing_test.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+# Need to use wall time for this test due to the sleep calls
+RubyProf::measure_mode = RubyProf::WALL_TIME
+
+def method1
+  sleep(1)
+end
+
+def method2
+  sleep(2)
+  method1
+end
+  
+def method3
+  sleep(3)
+  method2
+  method1
+end
+
+
+class TimingTest < Test::Unit::TestCase
+
+  def test_basic
+    result = RubyProf.profile do
+      method1
+    end
+    print_results(result)
+
+    assert_equal(1, result.threads.length)
+
+    methods = result.threads.values.first
+    assert_equal(3, methods.length)
+
+    
+    methods = methods.sort.reverse
+    
+    method = methods[0]
+    assert_equal('TimingTest#test_basic', method.full_name)
+    assert_in_delta(1, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(1, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(1, method.children.length)
+    
+    method = methods[1]
+    assert_equal('Object#method1', method.full_name)
+    assert_in_delta(1, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(1, method.children.length)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(1, method.total_time, 0.02)
+    assert_in_delta(1, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(0, method.children.length)
+  end
+  
+  def test_timings
+    result = RubyProf.profile do
+      method3
+    end
+
+    assert_equal(1, result.threads.length)
+    methods = result.threads.values.first
+    assert_equal(5, methods.length)
+    
+    methods = methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('TimingTest#test_timings', method.full_name)
+    assert_in_delta(7, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(7, method.children_time, 0.02)
+    assert_equal(0, method.called)
+    assert_equal(0, method.parents.length)
+    assert_equal(1, method.children.length)
+    
+    method = methods[1]
+    assert_equal('Object#method3', method.full_name)
+    assert_in_delta(7, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(7, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(3, method.children.length)
+    
+    method = methods[2]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_in_delta(7, method.total_time, 0.02)
+    assert_in_delta(7, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(0, method.children_time, 0.02)
+    assert_equal(4, method.called)
+    assert_equal(3, method.parents.length)
+    assert_equal(0, method.children.length)
+    
+    method = methods[3]
+    assert_equal('Object#method2', method.full_name)
+    assert_in_delta(3, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(3, method.children_time, 0.02)
+    assert_equal(1, method.called)
+    assert_equal(1, method.parents.length)
+    assert_equal(2, method.children.length)
+    
+    method = methods[4]
+    assert_equal('Object#method1', method.full_name)
+    assert_in_delta(2, method.total_time, 0.02)
+    assert_in_delta(0, method.self_time, 0.02)
+    assert_in_delta(0, method.wait_time, 0.02)
+    assert_in_delta(2, method.children_time, 0.02)
+    assert_equal(2, method.called)
+    assert_equal(2, method.parents.length)
+    assert_equal(1, method.children.length)
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-prof
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: x86-mswin32-60
+authors: 
+- Shugo Maeda and Charlie Savage
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-02-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 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.
+email: shugo@ruby-lang.org and cfis@savagexi.com
+executables: 
+- ruby-prof
+extensions: []
+
+extra_rdoc_files: 
+- bin/ruby-prof
+- ext/ruby_prof.c
+- examples/flat.txt
+- examples/graph.txt
+- examples/graph.html
+- README
+- LICENSE
+files: 
+- Rakefile
+- README
+- LICENSE
+- CHANGES
+- bin/ruby-prof
+- lib/ruby-prof
+- lib/ruby-prof.rb
+- lib/unprof.rb
+- lib/ruby-prof/abstract_printer.rb
+- lib/ruby-prof/call_tree_printer.rb
+- lib/ruby-prof/call_tree_printer.rb.rej
+- lib/ruby-prof/flat_printer.rb
+- lib/ruby-prof/graph_html_printer.rb
+- lib/ruby-prof/graph_printer.rb
+- lib/ruby-prof/profile_test_case.rb
+- lib/ruby-prof/task.rb
+- rails_plugin/ruby-prof
+- rails_plugin/ruby-prof/init.rb
+- rails_plugin/ruby-prof/lib
+- rails_plugin/ruby-prof/lib/profiling.rb
+- examples/flat.txt
+- examples/graph.html
+- examples/graph.txt
+- ext/extconf.rb
+- ext/extconf.rb.rej
+- ext/measure_allocations.h
+- ext/measure_cpu_time.h
+- ext/measure_memory.h
+- ext/measure_process_time.h
+- ext/measure_wall_time.h
+- ext/ruby_prof.c
+- test/basic_test.rb
+- test/duplicate_names_test.rb
+- test/line_number_test.rb
+- test/measure_mode_test.rb
+- test/module_test.rb
+- test/no_method_class_test.rb
+- test/prime.rb
+- test/prime1.rb
+- test/prime2.rb
+- test/prime3.rb
+- test/prime_test.rb
+- test/printers_test.rb
+- test/profile_unit_test.rb
+- test/recursive_test.rb
+- test/singleton_test.rb
+- test/start_test.rb
+- test/test_helper.rb
+- test/test_suite.rb
+- test/thread_test.rb
+- test/timing_test.rb
+- lib/ruby_prof.so
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-prof/
+post_install_message: 
+rdoc_options: 
+- --title
+- ruby-prof
+- --inline-source
+- --line-numbers
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-prof
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Fast Ruby profiler
+test_files: 
+- test/test_helper.rb
+- test/test_suite.rb