ruby-prof 2.0.4 → 2.0.5

data/test/scheduler.rb

@@ -1,367 +0,0 @@
-# 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
-  experimental = Warning[:experimental]
-  begin
-    Warning[:experimental] = false
-    IO::Buffer.new(0)
-  ensure
-    Warning[:experimental] = experimental
-  end
-
-  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 fiber_interrupt(fiber, exception)
-    fiber.raise(exception)
-  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/singleton_test.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-require 'stringio'
-require 'timeout'
-
-# --  Test for bug [#5657]
-# http://rubyforge.org/tracker/index.php?func=detail&aid=5657&group_id=1814&atid=7060
-
-
-class A
-  attr_accessor :as
-  def initialize
-    @as = []
-    class << @as
-      def <<(an_a)
-        super
-      end
-    end
-  end
-
-  def <<(an_a)
-    @as << an_a
-  end
-end
-
-class SingletonTest < TestCase
-  def test_singleton
-    result = RubyProf::Profile.profile do
-      a = A.new
-      a << :first_thing
-      assert_equal(1, a.as.size)
-    end
-    printer = RubyProf::FlatPrinter.new(result)
-    output = ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT'] == "1" ? STDOUT : StringIO.new
-    printer.print(output)
-  end
-end

data/test/stack_printer_test.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-require File.expand_path('../test_helper', __FILE__)
-
-# Test data
-#     A
-#    / \
-#   B   C
-#        \
-#         B
-
-class STPT
-  def a
-    100.times{b}
-    300.times{c}
-    c;c;c
-  end
-
-  def b
-    sleep 0
-  end
-
-  def c
-    5.times{b}
-  end
-end
-
-class StackPrinterTest < TestCase
-  def test_stack_can_be_printed
-    start_time = Time.now
-    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
-
-    file_contents = nil
-    file_contents = print(result)
-    re = /Thread: (\d+)(, Fiber: (\d+))? \([\.0-9]+.[\.0-9]+% ~ ([\.0-9]+)\)/
-    assert_match(re, file_contents)
-    file_contents =~ re
-    actual_time = $4.to_f
-    assert_in_delta(expected_time, actual_time, 0.1)
-  end
-
-  private
-
-  def print(result)
-    test = caller.first =~ /in `(.*)'/ ? $1 : "test"
-    testfile_name = "#{Dir.tmpdir}/ruby_prof_#{test}.html"
-    # puts "printing to #{testfile_name}"
-    printer = RubyProf::CallStackPrinter.new(result)
-    File.open(testfile_name, "w") {|f| printer.print(f, threshold: 0, min_percent: 0, title: "ruby_prof #{test}")}
-    system("open '#{testfile_name}'") if RUBY_PLATFORM =~ /darwin/ && ENV['SHOW_RUBY_PROF_PRINTER_OUTPUT']=="1"
-    assert File.exist?(testfile_name), "#{testfile_name} does not exist"
-    assert File.readable?(testfile_name), "#{testfile_name} is no readable"
-    File.read(testfile_name)
-  end
-end

data/test/start_stop_test.rb

@@ -1,106 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-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
-    @profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
-  end
-
-  def method1
-    @profile.start
-    method2
-  end
-
-  def method2
-    method3
-  end
-
-  def method3
-    sleep(2)
-    @result = @profile.stop
-  end
-
-  def test_extra_stop_should_raise
-    @profile.start
-    assert_raises(RuntimeError) do
-      @profile.start
-    end
-
-    @profile.stop # ok
-    assert_raises(RuntimeError) do
-      @profile.stop
-    end
-  end
-
-  def test_different_methods
-    method1
-
-    # Ruby prof should be stopped
-    assert_equal(false, @profile.running?)
-
-    methods = @result.threads.first.methods.sort.reverse
-    assert_equal(4, methods.length)
-
-    method = methods[0]
-    assert_equal('StartStopTest#method1', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
-    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
-    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
-    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('StartStopTest#method2', call_tree.target.full_name)
-
-    method = methods[1]
-    assert_equal('StartStopTest#method2', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
-    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
-    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
-    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method1', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('StartStopTest#method3', call_tree.target.full_name)
-
-    method = methods[2]
-    assert_equal('StartStopTest#method3', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
-    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
-    assert_in_delta(0, method.self_time, 0.02 * delta_multiplier)
-    assert_in_delta(2, method.children_time, 0.05 * delta_multiplier)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method2', call_tree.parent.target.full_name)
-
-    assert_equal(1, method.call_trees.callees.length)
-    call_tree = method.call_trees.callees[0]
-    assert_equal('Kernel#sleep', call_tree.target.full_name)
-
-    method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(2, method.total_time, 0.05 * delta_multiplier)
-    assert_in_delta(0, method.wait_time, 0.02 * delta_multiplier)
-    assert_in_delta(2, method.self_time, 0.05 * delta_multiplier)
-    assert_in_delta(0, method.children_time, 0.02 * delta_multiplier)
-
-    assert_equal(1, method.call_trees.callers.length)
-    call_tree = method.call_trees.callers[0]
-    assert_equal('StartStopTest#method3', call_tree.parent.target.full_name)
-
-    assert_equal(0, method.call_trees.callees.length)
-  end
-end

data/test/test_helper.rb

@@ -1,24 +0,0 @@
-# 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(ext_path)
-
-# Now load code
-require 'ruby-prof'
-
-# Disable minitest parallel tests. The problem is the thread switching will change test results
-# (self vs wait time)
-ENV["MT_CPU"] = "0" # New versions of minitest
-ENV["N"] = "0" # Older versions of minitest
-
-require 'minitest/autorun'
-Minitest.load_plugins
-class TestCase < Minitest::Test
-  def delta_multiplier
-    osx? && ENV["GITHUB_ACTIONS"] ? 6 : 1
-  end
-end