ruby-prof 1.5.0 → 1.6.2

data/test/merge_test.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
+
+require_relative './scheduler'
+
+  # --  Tests ----
+class MergeTest < TestCase
+  def worker1
+    sleep(0.5)
+  end
+
+  def worker2
+    sleep(0.5)
+    sleep(0.5)
+  end
+
+  def worker3
+    sleep(0.5)
+  end
+
+  def concurrency_single_worker
+    scheduler = Scheduler.new
+    Fiber.set_scheduler(scheduler)
+
+    3.times do
+      Fiber.schedule do
+        worker1
+      end
+    end
+    Fiber.scheduler.close
+  end
+
+  def concurrency_multiple_workers
+    scheduler = Scheduler.new
+    Fiber.set_scheduler(scheduler)
+
+    3.times do |i|
+      Fiber.schedule do
+        method = "worker#{i + 1}".to_sym
+        send(method)
+      end
+    end
+    Fiber.scheduler.close
+  end
+
+  def test_single_worker_unmerged
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_single_worker }
+    assert_equal(4, result.threads.size)
+
+    thread = result.threads[0]
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[1]
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[2]
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[3]
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+  end
+
+  def test_single_worker_merged
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_single_worker }
+    result.merge!
+
+    assert_equal(2, result.threads.size)
+
+    thread = result.threads[0]
+    assert_in_delta(0.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[1]
+    assert_in_delta(1.5, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(1.5, thread.call_tree.target.children_time, 0.1)
+  end
+
+  def test_multiple_workers_unmerged
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_multiple_workers }
+    assert_equal(4, result.threads.count)
+
+    thread = result.threads[0]
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[1]
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[2]
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[3]
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(0.5, thread.call_tree.target.children_time, 0.1)
+  end
+
+  def test_multiple_workers_merged
+    result  = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) { concurrency_multiple_workers }
+    result.merge!
+
+    assert_equal(2, result.threads.count)
+
+    thread = result.threads[0]
+    assert_in_delta(1.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.children_time, 0.1)
+
+    thread = result.threads[1]
+    assert_in_delta(3.0, thread.call_tree.target.total_time, 0.1)
+    assert_in_delta(0.0, thread.call_tree.target.self_time, 0.1)
+    assert_in_delta(1.0, thread.call_tree.target.wait_time, 0.1)
+    assert_in_delta(2.0, thread.call_tree.target.children_time, 0.1)
+  end
+end
+end

data/test/multi_printer_test.rb

@@ -27,11 +27,6 @@ class MSTPT
 end
 
 class MultiPrinterTest < 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_refuses_io_objects
     # we don't need a real profile for this test
     p = RubyProf::MultiPrinter.new nil

data/test/no_method_class_test.rb

@@ -4,7 +4,7 @@
 require File.expand_path('../test_helper', __FILE__)
 
 # Make sure this works with no class or method
-result = RubyProf.profile do
+result = RubyProf::Profile.profile do
   sleep 1
 end
 

data/test/pause_resume_test.rb

@@ -5,26 +5,22 @@ require File.expand_path('../test_helper', __FILE__)
 require_relative 'measure_times'
 
 class PauseResumeTest < 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_pause_resume
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
     # Measured
-    RubyProf.start
+    profile.start
     RubyProf::C1.sleep_wait
 
     # Not measured
-    RubyProf.pause
+    profile.pause
     sleep 1
     RubyProf::C1.sleep_wait
 
     # Measured
-    RubyProf.resume
+    profile.resume
     RubyProf::C1.sleep_wait
 
-    result = RubyProf.stop
+    result = profile.stop
 
     # Length should be 3:
     #   PauseResumeTest#test_pause_resume
@@ -59,7 +55,7 @@ class PauseResumeTest < TestCase
 
   # pause/resume in the same frame
   def test_pause_resume_1
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     profile.start
     method_1a
@@ -79,7 +75,7 @@ class PauseResumeTest < TestCase
 
   # pause in parent frame, resume in child
   def test_pause_resume_2
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     profile.start
     method_2a
@@ -96,7 +92,7 @@ class PauseResumeTest < TestCase
 
   # pause in child frame, resume in parent
   def test_pause_resume_3
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
 
     profile.start
     method_3a(profile)
@@ -120,7 +116,7 @@ class PauseResumeTest < TestCase
   end
 
   def test_pause_seq
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
     profile.start ; assert !profile.paused?
     profile.pause ; assert profile.paused?
     profile.resume; assert !profile.paused?
@@ -132,7 +128,7 @@ class PauseResumeTest < TestCase
   end
 
   def test_pause_block
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
     profile.start
     profile.pause
     assert profile.paused?
@@ -151,7 +147,7 @@ class PauseResumeTest < TestCase
   end
 
   def test_pause_block_with_error
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
     profile.start
     profile.pause
     assert profile.paused?
@@ -167,7 +163,7 @@ class PauseResumeTest < TestCase
   end
 
   def test_resume_when_not_paused
-    profile = RubyProf::Profile.new
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
     profile.start ; assert !profile.paused?
     profile.resume; assert !profile.paused?
     profile.stop  ; assert !profile.paused?

data/test/printer_call_stack_test.rb

@@ -9,9 +9,9 @@ require_relative 'prime'
 # --  Tests ----
 class PrinterCallStackTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end

data/test/printer_call_tree_test.rb

@@ -9,9 +9,9 @@ require_relative 'prime'
 # --  Tests ----
 class PrinterCallTreeTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end

data/test/printer_flat_test.rb

@@ -10,7 +10,7 @@ require_relative 'prime'
 # --  Tests ----
 class PrinterFlatTest < TestCase
   def run_profile
-    RubyProf.profile(:measure_mode => RubyProf::WALL_TIME) do
+    RubyProf::Profile.profile(:measure_mode => RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end

data/test/printer_graph_html_test.rb

@@ -9,9 +9,9 @@ require_relative 'prime'
 # --  Tests ----
 class PrinterGraphHtmlTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end

data/test/printer_graph_test.rb

@@ -9,9 +9,9 @@ require_relative 'prime'
 # --  Tests ----
 class PrinterGraphTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end

data/test/printers_test.rb

@@ -10,9 +10,9 @@ require_relative 'prime'
 # --  Tests ----
 class PrintersTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       run_primes(1000, 5000)
     end
   end
@@ -24,7 +24,7 @@ class PrintersTest < TestCase
     printer.print(output)
 
     printer = RubyProf::CallTreePrinter.new(@result)
-    printer.print()
+    printer.print(:path => Dir.tmpdir)
 
     printer = RubyProf::FlatPrinter.new(@result)
     printer.print(output)
@@ -37,25 +37,19 @@ class PrintersTest < TestCase
   end
 
   def test_print_to_files
-    output_dir = 'tmp/examples2'
-
-    if ENV['SAVE_NEW_PRINTER_EXAMPLES']
-      output_dir = 'tmp/examples'
-    end
-    FileUtils.mkdir_p output_dir
-
     printer = RubyProf::DotPrinter.new(@result)
-    File.open("#{output_dir}/graph.dot", "w") {|f| printer.print(f)}
+    File.open("#{Dir.tmpdir}/graph.dot", "w") {|f| printer.print(f)}
 
     printer = RubyProf::CallStackPrinter.new(@result)
-    File.open("#{output_dir}/stack.html", "w") {|f| printer.print(f, :application => "primes")}
-
-    # printer = RubyProf::MultiPrinter.new(@result)
-    # printer.print(:path => "#{output_dir}", :profile => "multi", :application => "primes")
-    # for file in ['graph.dot', 'multi.flat.txt', 'multi.graph.html', "multi.callgrind.out.#{$$}", 'multi.stack.html', 'stack.html']
-    #   existant_file = output_dir + '/' + file
-    #   assert File.size(existant_file) > 0
-    # end
+    File.open("#{Dir.tmpdir}/stack.html", "w") {|f| printer.print(f, :application => "primes")}
+
+    printer = RubyProf::MultiPrinter.new(@result)
+    printer.print(:path => Dir.tmpdir, :profile => "multi", :application => "primes")
+
+    ['graph.dot', 'multi.flat.txt', 'multi.graph.html', "multi.callgrind.out.#{$$}", 'multi.stack.html', 'stack.html'].each do |file_name|
+      file_path = File.join(Dir.tmpdir, file_name)
+      refute(File.empty?(file_path))
+    end
   end
 
   def test_refuses_io_objects
@@ -124,7 +118,7 @@ class PrintersTest < TestCase
   end
 
   def test_all_with_small_percentiles
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       sleep 2
       do_nothing
     end

data/test/printing_recursive_graph_test.rb

@@ -63,9 +63,9 @@ Sort by:
 
 class PrintingRecursiveGraphTest < TestCase
   def setup
+    super
     # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-    @result = RubyProf.profile do
+    @result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       PRGT.run
     end
   end

data/test/recursive_test.rb

@@ -33,15 +33,10 @@ end
 
 # --  Tests ----
 class RecursiveTest < TestCase
-  def setup
-    # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
-  end
-
   include SimpleRecursion
 
   def test_simple
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       simple(1)
     end
 
@@ -201,7 +196,7 @@ class RecursiveTest < TestCase
   end
 
   def test_cycle
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
       render
     end
 

data/test/scheduler.rb

@@ -14,6 +14,14 @@ rescue LoadError
 end
 
 class Scheduler
+  experimental = Warning[:experimental]
+  begin
+    Warning[:experimental] = false
+    IO::Buffer.new(0)
+  ensure
+    Warning[:experimental] = experimental
+  end
+
   def initialize
     @readable = {}
     @writable = {}
@@ -199,6 +207,7 @@ class Scheduler
   # Used for Kernel#sleep and Thread::Mutex#sleep
   def kernel_sleep(duration = nil)
     # $stderr.puts [__method__, duration, Fiber.current].inspect
+
     self.block(:sleep, duration)
 
     return true

data/test/singleton_test.rb

@@ -26,7 +26,7 @@ end
 
 class SingletonTest < TestCase
   def test_singleton
-    result = RubyProf.profile do
+    result = RubyProf::Profile.profile do
       a = A.new
       a << :first_thing
       assert_equal(1, a.as.size)

data/test/stack_printer_test.rb

@@ -27,16 +27,12 @@ class STPT
 end
 
 class StackPrinterTest < 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_stack_can_be_printed
     start_time = Time.now
-    RubyProf.start
-    5.times{STPT.new.a}
-    result = RubyProf.stop
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      5.times{STPT.new.a}
+    end
+
     end_time = Time.now
     expected_time = end_time - start_time
 
@@ -50,6 +46,7 @@ class StackPrinterTest < TestCase
   end
 
   private
+
   def print(result)
     test = caller.first =~ /in `(.*)'/ ? $1 : "test"
     testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"

data/test/start_stop_test.rb

@@ -5,37 +5,34 @@ require File.expand_path('../test_helper', __FILE__)
 
 class StartStopTest < TestCase
   def setup
+    super
     # Need to use wall time for this test due to the sleep calls
-    RubyProf::measure_mode = RubyProf::WALL_TIME
+    @profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
   end
 
   def method1
-     RubyProf.start
-     method2
+    @profile.start
+    method2
   end
 
   def method2
-     method3
+    method3
   end
 
   def method3
     sleep(2)
-    @result = RubyProf.stop
+    @result = @profile.stop
   end
 
   def test_extra_stop_should_raise
-    RubyProf.start
+    @profile.start
     assert_raises(RuntimeError) do
-      RubyProf.start
+      @profile.start
     end
 
+    @profile.stop # ok
     assert_raises(RuntimeError) do
-      RubyProf.profile {}
-    end
-
-    RubyProf.stop # ok
-    assert_raises(RuntimeError) do
-      RubyProf.stop
+      @profile.stop
     end
   end
 
@@ -43,7 +40,7 @@ class StartStopTest < TestCase
     method1
 
     # Ruby prof should be stopped
-    assert_equal(false, RubyProf.running?)
+    assert_equal(false, @profile.running?)
 
     methods = @result.threads.first.methods.sort.reverse
     assert_equal(4, methods.length)

data/test/test_helper.rb

@@ -1,6 +1,13 @@
 # encoding: UTF-8
 
+# To make testing/debugging easier test within this source tree versus an installed gem
 require 'bundler/setup'
+
+# Add ext directory to load path to make it easier to test locally built extensions
+ext_path = File.expand_path(File.join(__dir__, '..', 'ext', 'ruby_prof'))
+$LOAD_PATH.unshift(File.expand_path(ext_path))
+
+# Now load code
 require 'ruby-prof'
 
 # Disable minitest parallel tests. The problem is the thread switching will change test results