libev_scheduler 0.1

data/lib/libev_scheduler.rb

@@ -0,0 +1,23 @@
+require_relative './libev_scheduler_ext'
+
+module Libev
+  class Scheduler
+    def fiber(&block)
+      fiber = Fiber.new(blocking: false, &block)
+      unblock(nil, fiber)
+      # fiber.resume
+      return fiber
+    end
+
+    def kernel_sleep(duration = nil)
+      block(:sleep, duration)
+    end
+
+    def process_wait(pid, flags)
+      # This is a very simple way to implement a non-blocking wait:
+      Thread.new do
+        Process::Status.wait(pid, flags)
+      end.value
+    end  
+  end
+end

data/lib/libev_scheduler/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Libev
+  VERSION = '0.1'
+end

data/libev_scheduler.gemspec

@@ -0,0 +1,26 @@
+require_relative './lib/libev_scheduler/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'libev_scheduler'
+  s.version     = Libev::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = 'Libev-based fiber scheduler for Ruby 3.0'
+  s.author      = 'Sharon Rosner'
+  s.email       = 'sharon@noteflakes.com'
+  s.files       = `git ls-files`.split
+  s.homepage    = 'https://github.com/digital-fabric/libev_scheduler'
+  s.metadata    = {
+    'source_code_uri' => 'https://github.com/digital-fabric/libev_scheduler',
+    'homepage_uri' => 'https://github.com/digital-fabric/libev_scheduler',
+    'changelog_uri' => 'https://github.com/digital-fabric/libev_scheduler/blob/master/CHANGELOG.md'
+  }
+  s.rdoc_options = ['--title', "libev_scheduler", '--main', 'README.md']
+  s.extra_rdoc_files = ['README.md']
+  s.extensions = ['ext/libev_scheduler/extconf.rb']
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 3.0'
+
+  s.add_development_dependency 'rake-compiler',       '1.1.1'
+  s.add_development_dependency  'minitest',           '5.14.2'
+  s.add_development_dependency  'minitest-reporters', '1.4.2'
+  end

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_enumerator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'libev_scheduler'
+
+class TestFiberEnumerator < MiniTest::Test
+  MESSAGE = "Hello World"
+
+  def test_read_characters
+    i, o = IO.pipe
+
+    message = String.new
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      e = i.to_enum(:each_char)
+
+      Fiber.schedule do
+        o.write("Hello World")
+        o.close
+      end
+
+      Fiber.schedule do
+        begin
+          while c = e.next
+            message << c
+          end
+        rescue StopIteration
+          # Ignore.
+        end
+
+        i.close
+      end
+    end
+
+    thread.join
+
+    assert_equal(MESSAGE, message)
+    assert_predicate(i, :closed?)
+    assert_predicate(o, :closed?)
+  end
+end

data/test/test_io.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'libev_scheduler'
+
+class TestFiberIO < MiniTest::Test
+  MESSAGE = "Hello World"
+
+  def test_read
+    i, o = IO.pipe
+
+    message = nil
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        message = i.read(20)
+        i.close
+      end
+
+      Fiber.schedule do
+        o.write("Hello World")
+        o.close
+      end
+    end
+
+    thread.join
+
+    assert_equal MESSAGE, message
+    assert_predicate(i, :closed?)
+    assert_predicate(o, :closed?)
+  end
+
+  def test_heavy_read
+    16.times.map do
+      Thread.new do
+        i, o = IO.pipe
+
+        scheduler = Libev::Scheduler.new
+        Fiber.set_scheduler scheduler
+
+        Fiber.schedule do
+          i.read(20)
+          i.close
+        end
+
+        Fiber.schedule do
+          o.write("Hello World")
+          o.close
+        end
+      end
+    end.each(&:join)
+  end
+end

data/test/test_mutex.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'libev_scheduler'
+
+class TestFiberMutex < MiniTest::Test
+  def test_mutex_synchronize
+    mutex = Mutex.new
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        assert !Fiber.blocking?
+
+        mutex.synchronize do
+          assert !Fiber.blocking?
+        end
+      end
+    end
+
+    thread.join
+  end
+
+  def test_mutex_interleaved_locking
+    mutex = Mutex.new
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        mutex.lock
+        sleep 0.1
+        mutex.unlock
+      end
+
+      Fiber.schedule do
+        mutex.lock
+        sleep 0.1
+        mutex.unlock
+      end
+
+      scheduler.run
+    end
+
+    thread.join
+  end
+
+  def test_mutex_thread
+    mutex = Mutex.new
+    mutex.lock
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        mutex.lock
+        sleep 0.1
+        mutex.unlock
+      end
+
+      scheduler.run
+    end
+
+    sleep 0.1
+    mutex.unlock
+
+    thread.join
+  end
+
+  def test_mutex_fiber_raise
+    skip "stuck"
+    mutex = Mutex.new
+    ran = false
+
+    main = Thread.new do
+      p [1, :pre_lock]
+      mutex.lock
+      p [1, :post_lock]
+
+      thread = Thread.new do
+        scheduler = Libev::Scheduler.new
+        Fiber.set_scheduler scheduler
+
+        f = Fiber.schedule do
+          assert_raise_message("bye") do
+            p [2, :pre_lock]
+            mutex.lock
+            p [2, :post_lock]
+          end
+
+          ran = true
+        end
+
+        Fiber.schedule do
+          p [3, :pre_raise]
+          f.raise "bye"
+          p [3, :post_raise]
+        end
+      end
+
+      thread.join
+    end
+
+    main.join # causes mutex to be released
+    assert_equal false, mutex.locked?
+    assert_equal true, ran
+  end
+
+  def test_condition_variable
+    mutex = Mutex.new
+    condition = ConditionVariable.new
+
+    signalled = 0
+
+    Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        mutex.synchronize do
+          3.times do
+            condition.wait(mutex)
+            signalled += 1
+          end
+        end
+      end
+
+      Fiber.schedule do
+        3.times do
+          mutex.synchronize do
+            condition.signal
+          end
+
+          sleep 0.1
+        end
+      end
+
+      scheduler.run
+    end.join
+
+    assert_equal 3, signalled
+  end
+
+  def test_queue
+    queue = Queue.new
+    processed = 0
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        3.times do |i|
+          queue << i
+          sleep 0.1
+        end
+
+        queue.close
+      end
+
+      Fiber.schedule do
+        while item = queue.pop
+          processed += 1
+        end
+      end
+
+      scheduler.run
+    end
+
+    thread.join
+
+    assert_equal 3, processed
+  end
+
+  def test_queue_pop_waits
+    queue = Queue.new
+    running = false
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      result = nil
+      Fiber.schedule do
+        result = queue.pop
+      end
+
+      running = true
+      scheduler.run
+      result
+    end
+
+    Thread.pass until running
+    sleep 0.1
+
+    queue << :done
+    assert_equal :done, thread.value
+  end
+
+  def test_mutex_deadlock
+    skip "no impl of assert_in_out_err"
+    error_pattern = /No live threads left. Deadlock\?/
+
+    assert_in_out_err %W[-I#{__dir__} -], <<-RUBY, ['in synchronize'], error_pattern, success: false
+    require 'scheduler'
+    mutex = Mutex.new
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        mutex.synchronize do
+          puts 'in synchronize'
+          Fiber.yield
+        end
+      end
+
+      mutex.lock
+    end
+
+    thread.join
+    RUBY
+  end
+end

data/test/test_process.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'libev_scheduler'
+
+class TestFiberProcess < MiniTest::Test
+  def test_process_wait
+    Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        pid = Process.spawn("true")
+        Process.wait(pid)
+
+        # TODO test that scheduler was invoked.
+
+        assert_predicate $?, :success?
+      end
+    end.join
+  end
+
+  def test_system
+    Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      Fiber.schedule do
+        system("true")
+
+        # TODO test that scheduler was invoked (currently it's not).
+
+        assert_predicate $?, :success?
+      end
+    end.join
+  end
+end

data/test/test_sleep.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'libev_scheduler'
+
+class TestFiberSleep < MiniTest::Test
+  ITEMS = [0, 1, 2, 3, 4]
+
+  def setup
+    sleep 0.1
+  end
+
+  def test_sleep
+    items = []
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+
+      5.times do |i|
+        Fiber.schedule do
+          assert_operator sleep(i/100.0), :>=, 0
+          items << i
+        end
+      end
+    end
+
+    thread.join
+
+    assert_equal ITEMS, items
+  end
+
+  def test_sleep_returns_seconds_slept
+    seconds = nil
+    t0 = Time.now
+
+    thread = Thread.new do
+      scheduler = Libev::Scheduler.new
+      Fiber.set_scheduler scheduler
+      Fiber.schedule do
+        seconds = sleep(1)
+      end
+    end
+
+    thread.join
+    elapsed = Time.now - t0
+
+    assert_operator seconds, :>=, 1.0, "actual: %p" % seconds
+    assert_operator elapsed, :>=, 1.0, "actual: %p" % elapsed
+  end
+end