ruby-prof 1.4.3 → 1.6.3

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/method_info_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+require 'base64'
+
+class MethodInfoTest < Minitest::Test
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal("Base64", method_info.klass_name)
+    assert_equal(:encode64, method_info.method_name)
+    assert_equal("Base64#encode64", method_info.full_name)
+    assert_equal(0, method_info.klass_flags)
+    assert_match(/base64\.rb/, method_info.source_file)
+    assert_kind_of(Integer, method_info.line)
+    refute(method_info.recursive?)
+
+    assert_kind_of(RubyProf::Measurement, method_info.measurement)
+    assert_kind_of(RubyProf::CallTrees, method_info.call_trees)
+    assert_empty(method_info.allocations)
+  end
+
+  def test_initialize_nil_klass
+    error = assert_raises(NoMethodError) do
+      RubyProf::MethodInfo.new(nil, nil)
+    end
+    assert_match(/undefined method `instance_method' for nil:NilClass/, error.message)
+  end
+
+  def test_initialize_nil_method_name
+    error = assert_raises(TypeError) do
+      RubyProf::MethodInfo.new(Base64, nil)
+    end
+    assert_equal("nil is not a symbol nor a string", error.to_s)
+  end
+
+  def test_initialize_unknown_location
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    assert_equal('Array', method_info.klass_name)
+    assert_equal(:size, method_info.method_name)
+    assert_nil(method_info.source_file)
+    assert_equal(0, method_info.line)
+  end
+
+  def test_measurement
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal(0, method_info.total_time)
+    assert_equal(0, method_info.self_time)
+    assert_equal(0, method_info.wait_time)
+    assert_equal(0, method_info.children_time)
+    assert_equal(0, method_info.called)
+  end
+
+  def test_compare
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal(0, method_info_1 <=> method_info_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :decode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal(-1, method_info_1 <=> method_info_2)
+
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :decode64)
+    assert_equal(1, method_info_1 <=> method_info_2)
+  end
+
+  def test_eql?
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert(method_info_1.eql?(method_info_2))
+  end
+
+  def test_equal?
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    refute(method_info_1.equal?(method_info_2))
+  end
+
+  def test_equality
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert(method_info_1 == method_info_2)
+  end
+
+  def test_hash
+    method_info_1 = RubyProf::MethodInfo.new(Base64, :encode64)
+    method_info_2 = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal(method_info_1.hash, method_info_2.hash)
+  end
+
+  def test_to_s
+    method_info = RubyProf::MethodInfo.new(Base64, :encode64)
+    assert_equal("Base64#encode64 (c: 0, tt: 0.0, st: 0.0, wt: 0.0, ct: 0.0)", method_info.to_s)
+  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
@@ -19,8 +19,8 @@ class PrinterCallTreeTest < TestCase
   def test_call_tree_string
     printer = RubyProf::CallTreePrinter.new(@result)
 
-    printer.print(:profile => "lolcat", :path => Dir.tmpdir)
-    main_output_file_name = File.join(Dir.tmpdir, "lolcat.callgrind.out.#{$$}")
+    printer.print(:path => Dir.tmpdir)
+    main_output_file_name = File.join(Dir.tmpdir, "callgrind.out.#{$$}")
     assert(File.exist?(main_output_file_name))
     output = File.read(main_output_file_name)
     assert_match(/fn=Object::find_primes/i, output)

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/profile_test.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
 
 class ProfileTest < TestCase
   def test_measure_mode
@@ -13,4 +14,88 @@ class ProfileTest < TestCase
     profile = RubyProf::Profile.new(:measure_mode => RubyProf::PROCESS_TIME)
     assert_equal("process_time", profile.measure_mode_string)
   end
+
+  def test_add_thread
+    profile = RubyProf::Profile.new
+    assert_empty(profile.threads)
+
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    profile.add_thread(thread)
+    assert_equal(1, profile.threads.size)
+    assert(thread.equal?(profile.threads.first))
+  end
+
+  def test_add_threads
+    call_tree_1 = create_call_tree_1
+    ruby_thread_1 = Thread.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, ruby_thread_1, Fiber.current)
+
+    call_tree_2 = create_call_tree_2
+    ruby_thread_2 = Thread.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, ruby_thread_2, Fiber.current)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+    assert_equal(1, profile.threads.count)
+  end
+
+  def test_add_fibers
+    call_tree_1 = create_call_tree_1
+    fiber_1 = Fiber.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, fiber_1)
+
+    call_tree_2 = create_call_tree_2
+    fiber_2 = Fiber.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, fiber_2)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+    assert_equal(2, profile.threads.count)
+  end
+
+  def test_remove_thread
+    profile = RubyProf::Profile.new
+    assert_empty(profile.threads)
+
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    profile.add_thread(thread)
+    assert_equal(1, profile.threads.size)
+    assert(thread.equal?(profile.threads.first))
+
+    removed = profile.remove_thread(thread)
+    assert_equal(0, profile.threads.size)
+    assert(removed.equal?(thread))
+  end
+
+  def test_merge
+    call_tree_1 = create_call_tree_1
+    fiber_1 = Thread.new { }
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, fiber_1)
+
+    call_tree_2 = create_call_tree_2
+    fiber_2 = Thread.new { }
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, fiber_2)
+
+    profile = RubyProf::Profile.new
+    profile.add_thread(thread_1)
+    profile.add_thread(thread_2)
+
+    profile.merge!
+    assert_equal(1, profile.threads.count)
+
+    assert_equal(thread_1, profile.threads.first)
+
+    assert_in_delta(11.6, thread_1.call_tree.total_time, 0.00001)
+    assert_in_delta(0, thread_1.call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, thread_1.call_tree.wait_time, 0.00001)
+    assert_in_delta(11.6, thread_1.call_tree.children_time, 0.00001)
+  end
 end