ruby-prof 1.4.5 → 1.5.0

data/test/measurement_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', __FILE__)
+
+class MeasurementTest < Minitest::Test
+  def test_initialize
+    measurement = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    assert_equal(3.3, measurement.total_time)
+    assert_equal(2.2, measurement.self_time)
+    assert_equal(1.1, measurement.wait_time)
+    assert_equal(4, measurement.called)
+  end
+
+  def test_clone
+    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement_2 = measurement_1.clone
+
+    refute(measurement_1.equal?(measurement_2))
+    refute(measurement_1.eql?(measurement_2))
+    refute(measurement_1 == measurement_2)
+
+    assert_equal(measurement_1.total_time, measurement_2.total_time)
+    assert_equal(measurement_1.self_time, measurement_2.self_time)
+    assert_equal(measurement_1.wait_time, measurement_2.wait_time)
+    assert_equal(measurement_1.called, measurement_2.called)
+  end
+
+  def test_dup
+    measurement_1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement_2 = measurement_1.dup
+
+    refute(measurement_1.equal?(measurement_2))
+    refute(measurement_1.eql?(measurement_2))
+    refute(measurement_1 == measurement_2)
+
+    assert_equal(measurement_1.total_time, measurement_2.total_time)
+    assert_equal(measurement_1.self_time, measurement_2.self_time)
+    assert_equal(measurement_1.wait_time, measurement_2.wait_time)
+    assert_equal(measurement_1.called, measurement_2.called)
+  end
+
+  def test_merge!
+    measurement1 = RubyProf::Measurement.new(3.3, 2.2, 1.1, 4)
+    measurement2 = RubyProf::Measurement.new(3, 2, 1, 3)
+
+    measurement1.merge!(measurement2)
+
+    assert_equal(6.3, measurement1.total_time)
+    assert_equal(4.2, measurement1.self_time)
+    assert_equal(2.1, measurement1.wait_time)
+    assert_equal(7, measurement1.called)
+
+    assert_equal(3, measurement2.total_time)
+    assert_equal(2, measurement2.self_time)
+    assert_equal(1, measurement2.wait_time)
+    assert_equal(3, measurement2.called)
+  end
+
+  def test_set_total_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.total_time = 5.1
+    assert_equal(5.1, measurement.total_time)
+  end
+
+  def test_set_self_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.self_time = 3.1
+    assert_equal(3.1, measurement.self_time)
+  end
+
+  def test_set_wait_time
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.wait_time = 1.1
+    assert_equal(1.1, measurement.wait_time)
+  end
+
+  def test_set_called
+    measurement = RubyProf::Measurement.new(4, 3, 1, 1)
+    measurement.called = 2
+    assert_equal(2, measurement.called)
+  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/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

data/test/recursive_test.rb

@@ -375,7 +375,7 @@ class RecursiveTest < TestCase
       assert_in_delta(5, method.total_time, 0.1)
       assert_in_delta(0, method.self_time, 0.1)
       assert_in_delta(0, method.wait_time, 0.01)
-      assert_in_delta(5, method.children_time, 0.05)
+      assert_in_delta(5, method.children_time, 0.1)
 
       assert_equal(2, method.call_trees.callers.length)
       call_tree = method.call_trees.callers[0]

data/test/scheduler.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+# This is an example and simplified scheduler for test purposes.
+# It is not efficient for a large number of file descriptors as it uses IO.select().
+# Production Fiber schedulers should use epoll/kqueue/etc.
+
+require 'fiber'
+require 'socket'
+
+begin
+  require 'io/nonblock'
+rescue LoadError
+  # Ignore.
+end
+
+class Scheduler
+  def initialize
+    @readable = {}
+    @writable = {}
+    @waiting = {}
+
+    @closed = false
+
+    @lock = Thread::Mutex.new
+    @blocking = Hash.new.compare_by_identity
+    @ready = []
+
+    @urgent = IO.pipe
+  end
+
+  attr :readable
+  attr :writable
+  attr :waiting
+
+  def next_timeout
+    _fiber, timeout = @waiting.min_by{|key, value| value}
+
+    if timeout
+      offset = timeout - current_time
+
+      if offset < 0
+        return 0
+      else
+        return offset
+      end
+    end
+  end
+
+  def run
+    # $stderr.puts [__method__, Fiber.current].inspect
+
+    while @readable.any? or @writable.any? or @waiting.any? or @blocking.any?
+      # Can only handle file descriptors up to 1024...
+      readable, writable = IO.select(@readable.keys + [@urgent.first], @writable.keys, [], next_timeout)
+
+      # puts "readable: #{readable}" if readable&.any?
+      # puts "writable: #{writable}" if writable&.any?
+
+      selected = {}
+
+      readable&.each do |io|
+        if fiber = @readable.delete(io)
+          @writable.delete(io) if @writable[io] == fiber
+          selected[fiber] = IO::READABLE
+        elsif io == @urgent.first
+          @urgent.first.read_nonblock(1024)
+        end
+      end
+
+      writable&.each do |io|
+        if fiber = @writable.delete(io)
+          @readable.delete(io) if @readable[io] == fiber
+          selected[fiber] = selected.fetch(fiber, 0) | IO::WRITABLE
+        end
+      end
+
+      selected.each do |fiber, events|
+        fiber.resume(events)
+      end
+
+      if @waiting.any?
+        time = current_time
+        waiting, @waiting = @waiting, {}
+
+        waiting.each do |fiber, timeout|
+          if fiber.alive?
+            if timeout <= time
+              fiber.resume
+            else
+              @waiting[fiber] = timeout
+            end
+          end
+        end
+      end
+
+      if @ready.any?
+        ready = nil
+
+        @lock.synchronize do
+          ready, @ready = @ready, []
+        end
+
+        ready.each do |fiber|
+          fiber.resume
+        end
+      end
+    end
+  end
+
+  def scheduler_close
+    close(true)
+  end
+
+  def close(internal = false)
+    # $stderr.puts [__method__, Fiber.current].inspect
+
+    unless internal
+      if Fiber.scheduler == self
+        return Fiber.set_scheduler(nil)
+      end
+    end
+
+    if @closed
+      raise "Scheduler already closed!"
+    end
+
+    self.run
+  ensure
+    if @urgent
+      @urgent.each(&:close)
+      @urgent = nil
+    end
+
+    @closed ||= true
+
+    # We freeze to detect any unintended modifications after the scheduler is closed:
+    self.freeze
+  end
+
+  def closed?
+    @closed
+  end
+
+  def current_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def timeout_after(duration, klass, message, &block)
+    fiber = Fiber.current
+
+    self.fiber do
+      sleep(duration)
+
+      if fiber&.alive?
+        fiber.raise(klass, message)
+      end
+    end
+
+    begin
+      yield(duration)
+    ensure
+      fiber = nil
+    end
+  end
+
+  def process_wait(pid, flags)
+    # $stderr.puts [__method__, pid, flags, Fiber.current].inspect
+
+    # This is a very simple way to implement a non-blocking wait:
+    Thread.new do
+      Process::Status.wait(pid, flags)
+    end.value
+  end
+
+  def io_wait(io, events, duration)
+    # $stderr.puts [__method__, io, events, duration, Fiber.current].inspect
+
+    unless (events & IO::READABLE).zero?
+      @readable[io] = Fiber.current
+    end
+
+    unless (events & IO::WRITABLE).zero?
+      @writable[io] = Fiber.current
+    end
+
+    Fiber.yield
+  ensure
+    @readable.delete(io)
+    @writable.delete(io)
+  end
+
+  def io_select(...)
+    # Emulate the operation using a non-blocking thread:
+    Thread.new do
+      IO.select(...)
+    end.value
+  end
+
+  # 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
+  end
+
+  # Used when blocking on synchronization (Thread::Mutex#lock,
+  # Thread::Queue#pop, Thread::SizedQueue#push, ...)
+  def block(blocker, timeout = nil)
+    # $stderr.puts [__method__, blocker, timeout].inspect
+
+    fiber = Fiber.current
+
+    if timeout
+      @waiting[fiber] = current_time + timeout
+      begin
+        Fiber.yield
+      ensure
+        # Remove from @waiting in the case #unblock was called before the timeout expired:
+        @waiting.delete(fiber)
+      end
+    else
+      @blocking[fiber] = true
+      begin
+        Fiber.yield
+      ensure
+        @blocking.delete(fiber)
+      end
+    end
+  end
+
+  # Used when synchronization wakes up a previously-blocked fiber
+  # (Thread::Mutex#unlock, Thread::Queue#push, ...).
+  # This might be called from another thread.
+  def unblock(blocker, fiber)
+    # $stderr.puts [__method__, blocker, fiber].inspect
+    # $stderr.puts blocker.backtrace.inspect
+    # $stderr.puts fiber.backtrace.inspect
+
+    @lock.synchronize do
+      @ready << fiber
+    end
+
+    io = @urgent.last
+    io.write_nonblock('.')
+  end
+
+  def fiber(&block)
+    fiber = Fiber.new(blocking: false, &block)
+
+    fiber.resume
+
+    return fiber
+  end
+
+  def address_resolve(hostname)
+    Thread.new do
+      Addrinfo.getaddrinfo(hostname, nil).map(&:ip_address).uniq
+    end.value
+  end
+end
+
+class IOBufferScheduler < Scheduler
+  EAGAIN = -Errno::EAGAIN::Errno
+
+  def io_read(io, buffer, length, offset)
+    total = 0
+    io.nonblock = true
+
+    while true
+      maximum_size = buffer.size - offset
+      result = blocking{buffer.read(io, maximum_size, offset)}
+
+      if result > 0
+        total += result
+        offset += result
+        break if total >= length
+      elsif result == 0
+        break
+      elsif result == EAGAIN
+        if length > 0
+          self.io_wait(io, IO::READABLE, nil)
+        else
+          return result
+        end
+      elsif result < 0
+        return result
+      end
+    end
+
+    return total
+  end
+
+  def io_write(io, buffer, length, offset)
+    total = 0
+    io.nonblock = true
+
+    while true
+      maximum_size = buffer.size - offset
+      result = blocking{buffer.write(io, maximum_size, offset)}
+
+      if result > 0
+        total += result
+        offset += result
+        break if total >= length
+      elsif result == 0
+        break
+      elsif result == EAGAIN
+        if length > 0
+          self.io_wait(io, IO::WRITABLE, nil)
+        else
+          return result
+        end
+      elsif result < 0
+        return result
+      end
+    end
+
+    return total
+  end
+
+  def blocking(&block)
+    Fiber.blocking(&block)
+  end
+end
+
+class BrokenUnblockScheduler < Scheduler
+  def unblock(blocker, fiber)
+    super
+
+    raise "Broken unblock!"
+  end
+end
+
+class SleepingUnblockScheduler < Scheduler
+  # This method is invoked when the thread is exiting.
+  def unblock(blocker, fiber)
+    super
+
+    # This changes the current thread state to `THREAD_RUNNING` which causes `thread_join_sleep` to hang.
+    sleep(0.1)
+  end
+end
+
+class SleepingBlockingScheduler < Scheduler
+  def kernel_sleep(duration = nil)
+    # Deliberaly sleep in a blocking state which can trigger a deadlock if the implementation is not correct.
+    Fiber.blocking{sleep 0.0001}
+
+    self.block(:sleep, duration)
+
+    return true
+  end
+end

data/test/thread_test.rb

@@ -4,6 +4,7 @@
 require File.expand_path('../test_helper', __FILE__)
 require 'timeout'
 require 'benchmark'
+require_relative './call_tree_builder'
 
 # --  Tests ----
 class ThreadTest < TestCase
@@ -12,6 +13,31 @@ class ThreadTest < TestCase
     RubyProf::measure_mode = RubyProf::WALL_TIME
   end
 
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    assert_equal(call_tree, thread.call_tree)
+    assert(thread)
+    assert(thread.id)
+    assert(thread.fiber_id)
+  end
+
+  def test_merge
+    call_tree_1 = create_call_tree_1
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, Fiber.current)
+
+    call_tree_2 = create_call_tree_2
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, Fiber.current)
+
+    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)
+  end
+
   def test_thread_count
     RubyProf.start
 
@@ -71,10 +97,10 @@ class ThreadTest < TestCase
     method = methods[0]
     assert_equal('ThreadTest#test_thread_timings', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(1, method.total_time, 0.1)
     assert_in_delta(0, method.self_time, 0.05)
     assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(1, method.children_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.1)
     assert_equal(0, method.call_trees.callers.length)
 
     method = methods[1]