ruby-prof 1.6.1-x64-mingw-ucrt → 1.6.2-x64-mingw-ucrt

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/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/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

data/test/thread_test.rb

@@ -17,20 +17,87 @@ class ThreadTest < TestCase
     assert(thread)
     assert(thread.id)
     assert(thread.fiber_id)
+
+    assert_equal(1, thread.methods.size)
+    assert_same(method_info, thread.methods[0])
   end
 
   def test_merge
     call_tree_1 = create_call_tree_1
     thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, Fiber.current)
+    assert_equal(6, thread_1.methods.size)
 
     call_tree_2 = create_call_tree_2
     thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, Fiber.current)
+    assert_equal(6, thread_2.methods.size)
 
     thread_1.merge!(thread_2)
-    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)
+    assert_equal(7, thread_1.methods.size)
+
+    # Method times
+    assert_in_delta(11.6, thread_1.methods[0].total_time, 0.00001) # root
+    assert_in_delta(4.1, thread_1.methods[1].total_time, 0.00001)  # a
+    assert_in_delta(1.5, thread_1.methods[2].total_time, 0.00001)  # aa
+    assert_in_delta(2.6, thread_1.methods[3].total_time, 0.00001)  # ab
+    assert_in_delta(7.5, thread_1.methods[4].total_time, 0.00001)  # b
+    assert_in_delta(6.6, thread_1.methods[5].total_time, 0.00001)  # bb
+    assert_in_delta(0.9, thread_1.methods[6].total_time, 0.00001)  # ba
+
+    # Root
+    call_tree = call_tree_1
+    assert_equal(:root, call_tree.target.method_name)
+    assert_in_delta(11.6, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(11.6, call_tree.children_time, 0.00001)
+
+    # a
+    call_tree = call_tree_1.children[0]
+    assert_equal(:a, call_tree.target.method_name)
+    assert_in_delta(4.1, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(4.1, call_tree.children_time, 0.00001)
+
+    # aa
+    call_tree = call_tree_1.children[0].children[0]
+    assert_equal(:aa, call_tree.target.method_name)
+    assert_in_delta(1.5, call_tree.total_time, 0.00001)
+    assert_in_delta(1.5, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # ab
+    call_tree = call_tree_1.children[0].children[1]
+    assert_equal(:ab, call_tree.target.method_name)
+    assert_in_delta(2.6, call_tree.total_time, 0.00001)
+    assert_in_delta(2.6, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # # b
+    # call_tree = call_tree_1.children[1]
+    # assert_equal(:b, call_tree.target.method_name)
+    # assert_in_delta(7.5, call_tree.total_time, 0.00001)
+    # assert_in_delta(0, call_tree.self_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    # assert_in_delta(7.5, call_tree.children_time, 0.00001)
+
+    # bb
+    # call_tree = call_tree_1.children[1].children[0]
+    # assert_equal(:bb, call_tree.target.method_name)
+    # assert_in_delta(6.6, call_tree.total_time, 0.00001)
+    # assert_in_delta(6.6, call_tree.self_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # ba
+    call_tree = call_tree_1.children[1].children[1]
+    assert_equal(:ba, call_tree.target.method_name)
+    assert_in_delta(0.9, call_tree.total_time, 0.00001)
+    assert_in_delta(0.7, call_tree.self_time, 0.00001)
+    assert_in_delta(0.2, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
   end
 
   def test_thread_count

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: x64-mingw-ucrt
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-21 00:00:00.000000000 Z
+date: 2023-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -136,6 +136,7 @@ files:
 - test/measure_times.rb
 - test/measure_wall_time_test.rb
 - test/measurement_test.rb
+- test/merge_test.rb
 - test/method_info_test.rb
 - test/multi_printer_test.rb
 - test/no_method_class_test.rb
@@ -167,7 +168,7 @@ metadata:
   bug_tracker_uri: https://github.com/ruby-prof/ruby-prof/issues
   changelog_uri: https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES
   documentation_uri: https://ruby-prof.github.io/
-  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.6.1
+  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.6.2
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -183,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.8
 signing_key:
 specification_version: 4
 summary: Fast Ruby profiler