evt 0.1.4 → 0.3.0

data/lib/evt.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
+require 'fiber'
+require 'socket'
+require 'io/nonblock'
 require_relative 'evt/version'
-require_relative 'evt/io'
-require_relative 'evt_ext'
+require_relative 'evt/backends/bundled'
+require_relative 'evt/backends/epoll'
+require_relative 'evt/backends/iocp'
+require_relative 'evt/backends/kqueue'
+require_relative 'evt/backends/select'
+require_relative 'evt/backends/uring'
 require_relative 'evt/scheduler'
+require_relative 'evt_ext'
 
 module Evt
 end

data/lib/evt/backends/bundled.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+class Evt::Bundled
+  MAXIMUM_TIMEOUT = 5
+
+  def initialize
+    @readable = {}
+    @writable = {}
+    @waiting = {}
+    @iovs = {}
+    
+    @lock = Mutex.new
+    @blocking = 0
+    @ready = []
+  
+    init_selector
+  end
+
+  attr_reader :readable
+  attr_reader :writable
+  attr_reader :waiting
+
+  def next_timeout
+    _fiber, timeout = @waiting.min_by{|key, value| value}
+
+    if timeout
+      offset = timeout - current_time
+      return 0 if offset < 0
+      return offset if offset < MAXIMUM_TIMEOUT
+    end
+
+    MAXIMUM_TIMEOUT
+  end
+
+  def run
+    while @readable.any? or @writable.any? or @waiting.any? or @iovs.any? or @blocking.positive?
+      readable, writable, iovs = self.wait
+
+      readable&.each do |io|
+        fiber = @readable.delete(io)
+        fiber&.resume
+      end
+
+      writable&.each do |io|
+        fiber = @writable.delete(io)
+        fiber&.resume
+      end
+
+      unless iovs.nil?
+        iovs&.each do |io|
+          fiber = @iovs.delete(io)
+          fiber&.resume
+        end
+      end
+
+      if @waiting.any?
+        time = current_time
+        waiting, @waiting = @waiting, {}
+
+        waiting.each do |fiber, timeout|
+          if timeout <= time
+            fiber.resume
+          else
+            @waiting[fiber] = timeout
+          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 current_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  # Wait for the given file descriptor to match the specified events within
+  # the specified timeout.
+  # @parameter event [Integer] A bit mask of `IO::READABLE`,
+  #   `IO::WRITABLE` and `IO::PRIORITY`.
+  # @parameter timeout [Numeric] The amount of time to wait for the event in seconds.
+  # @returns [Integer] The subset of events that are ready.
+  def io_wait(io, events, duration)
+    # TODO: IO::PRIORITY
+    @readable[io] = Fiber.current unless (events & IO::READABLE).zero?
+    @writable[io] = Fiber.current unless (events & IO::WRITABLE).zero?
+    self.register(io, events)
+    Fiber.yield
+    self.deregister(io)
+    true
+  end
+
+  # Sleep the current task for the specified duration, or forever if not
+  # specified.
+  # @param duration [Numeric] The amount of time to sleep in seconds.
+  def kernel_sleep(duration = nil)
+    self.block(:sleep, duration)
+    true
+  end
+
+  # Block the calling fiber.
+  # @parameter blocker [Object] What we are waiting on, informational only.
+  # @parameter timeout [Numeric | Nil] The amount of time to wait for in seconds.
+  # @returns [Boolean] Whether the blocking operation was successful or not.
+  def block(blocker, timeout = nil)
+    if timeout
+      @waiting[Fiber.current] = current_time + timeout
+      begin
+        Fiber.yield
+      ensure
+        @waiting.delete(Fiber.current)
+      end
+    else
+      @blocking += 1
+      begin
+        Fiber.yield
+      ensure
+        @blocking -= 1
+      end
+    end
+  end
+
+  # Unblock the specified fiber.
+  # @parameter blocker [Object] What we are waiting on, informational only.
+  # @parameter fiber [Fiber] The fiber to unblock.
+  # @reentrant Thread safe.
+  def unblock(blocker, fiber)
+    @lock.synchronize do
+      @ready << fiber
+    end
+  end
+
+  # Invoked when the thread exits.
+  def close
+    self.run
+  end
+
+  # Intercept the creation of a non-blocking fiber.
+  # @returns [Fiber]
+  def fiber(&block)
+    fiber = Fiber.new(blocking: false, &block)
+    fiber.resume
+    fiber
+  end
+end

data/lib/evt/backends/epoll.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Evt::Epoll < Evt::Bundled
+  def self.available?
+    self.respond_to?(:epoll_backend)
+  end
+
+  def self.backend
+    self.epoll_backend
+  end
+
+  def init_selector
+    epoll_init_selector
+  end
+
+  def register(io, interest)
+    epoll_register(io, interest)
+  end
+
+  def deregister(io)
+    epoll_deregister(io)
+  end
+
+  def wait
+    epoll_wait
+  end
+end

data/lib/evt/backends/iocp.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Evt::Iocp < Evt::Bundled
+  ##
+  # IOCP is totally disabled for now
+  def self.available?
+    false
+  end
+
+  def init_selector
+    # Placeholder
+  end
+
+  def register(io, interest)
+    # Placeholder
+  end
+
+  def deregister(io)
+    # Placeholder
+  end
+
+  def io_read(io, buffer, offset, length)
+    # Placeholder
+  end
+
+  def io_write(io, buffer, offset, length)
+    # Placeholder
+  end
+
+  def wait
+    # Placeholder
+  end
+end

data/lib/evt/backends/kqueue.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Evt::Kqueue < Evt::Bundled
+  def self.available?
+    self.respond_to?(:kqueue_backend)
+  end
+
+  def self.backend
+    self.kqueue_backend
+  end
+
+  def init_selector
+    kqueue_init_selector
+  end
+
+  def register(io, interest)
+    kqueue_register(io, interest)
+  end
+
+  def deregister(io)
+    # Kqueue running under one-shot mode, no need to deregister
+  end
+
+  def wait
+    kqueue_wait
+  end
+end

data/lib/evt/backends/select.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Evt::Select < Evt::Bundled
+  def self.available?
+    self.respond_to?(:select_backend)
+  end
+
+  def self.backend
+    self.select_backend
+  end
+
+  def init_selector
+    # Select is stateless
+  end
+
+  def register(io, interest)
+    # Select is stateless
+  end
+
+  def deregister(io)
+    # Select is stateless
+  end
+
+  def wait
+    select_wait
+  end
+end

data/lib/evt/backends/uring.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Evt::Uring < Evt::Bundled
+  def self.available?
+    self.respond_to?(:uring_backend)
+  end
+
+  def self.backend
+    self.uring_backend
+  end
+
+  def init_selector
+    uring_init_selector
+  end
+
+  def register(io, interest)
+    uring_register(io, register)
+  end
+
+  def deregister(io)
+    # io_uring running under one-shot mode, no need to deregister
+  end
+
+  def io_read(io, buffer, offset, length)
+    uring_io_read(io, buffer, offset, length)
+  end
+
+  def io_write(io, buffer, offset, length)
+    uring_io_write(io, buffer, offset, length)
+  end
+
+  def wait
+    uring_wait
+  end
+end

data/lib/evt/scheduler.rb

@@ -1,162 +1,36 @@
 # frozen_string_literal: true
 
-require 'fiber'
-require 'socket'
-
-begin
-  require 'io/nonblock'
-rescue LoadError
-  # Ignore.
-end
-
+##
+# The major class for Ruby Fiber Scheduler
+# @example
+#   scheduler = Evt::Scheduler.new
+#   Fiber.set_scheduler scheduler
+#   scheduler.run
 class Evt::Scheduler
-  def initialize
-    @readable = {}
-    @writable = {}
-    @waiting = {}
-    @blocking = []
-
-    @ios = ObjectSpace::WeakMap.new
-    init_selector
-  end
-
-  attr :readable
-  attr :writable
-  attr :waiting
-  attr :blocking
-
-  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
+  class << self
+    BACKENDS = [
+      Evt::Uring,
+      Evt::Epoll,
+      Evt::Kqueue,
+      Evt::Iocp,
+      Evt::Select,
+    ].freeze
+
+    ##
+    # Returns the fastest possible scheduler
+    # Use the backend scheduler directly if you want to choose it yourself
+    def new
+      BACKENDS.each do |backend|
+        return backend.new if backend.available?
       end
     end
-  end
-
-  def run
-    while @readable.any? or @writable.any? or @waiting.any?
-      readable, writable = self.wait
-
-      # puts "readable: #{readable}" if readable&.any?
-      # puts "writable: #{writable}" if writable&.any?
-
-      readable&.each do |io|
-        @readable[io]&.resume
-      end
-
-      writable&.each do |io|
-        @writable[io]&.resume
-      end
-
-      if @waiting.any?
-        time = current_time
-        waiting = @waiting
-        @waiting = {}
 
-        waiting.each do |fiber, timeout|
-          if timeout <= time
-            fiber.resume
-          else
-            @waiting[fiber] = timeout
-          end
-        end
+    ##
+    # Returns all available backends on this machine
+    def availables
+      BACKENDS.filter do |backend|
+        backend.available?
       end
     end
   end
-
-  def for_fd(fd)
-    @ios[fd] ||= ::IO.for_fd(fd, autoclose: false)
-  end
-
-  def wait_readable(io)
-    @readable[io] = Fiber.current
-    self.register(io, IO::WAIT_READABLE)
-    Fiber.yield
-    @readable.delete(io)
-    self.deregister(io)
-    return true
-  end
-
-  def wait_readable_fd(fd)
-    wait_readable(
-      for_fd(fd)
-    )
-  end
-
-  def wait_writable(io)
-    @writable[io] = Fiber.current
-    self.register(io, IO::WAIT_WRITABLE)
-    Fiber.yield
-    @writable.delete(io)
-    self.deregister(io)
-    return true
-  end
-
-  def wait_writable_fd(fd)
-    wait_writable(
-      for_fd(fd)
-    )
-  end
-
-  def current_time
-    Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  end
-
-  def wait_sleep(duration = nil)
-    @waiting[Fiber.current] = current_time + duration
-
-    Fiber.yield
-
-    return true
-  end
-
-  def wait_any(io, events, duration)
-    unless (events & IO::WAIT_READABLE).zero?
-      @readable[io] = Fiber.current
-    end
-
-    unless (events & IO::WAIT_WRITABLE).zero?
-      @writable[io] = Fiber.current
-    end
-
-    self.register(io, events)
-
-    Fiber.yield
-
-    @readable.delete(io)
-    @writable.delete(io)
-    self.deregister(io)
-
-    return true
-  end
-
-
-  def wait_for_single_fd(fd, events, duration)
-    wait_any(
-      for_fd(fd),
-      events,
-      duration
-    )
-  end
-
-  def enter_blocking_region
-    # puts "Enter blocking region: #{caller.first}"
-  end
-
-  def exit_blocking_region
-    # puts "Exit blocking region: #{caller.first}"
-    @blocking << caller.first
-  end
-
-  def fiber(&block)
-    fiber = Fiber.new(blocking: false, &block)
-    fiber.resume
-    return fiber
-  end
 end