Epoll event loop (linux)

src/channel.cr

@@ -743,9 +743,11 @@ class Channel(T)
     end
 
     def time_expired(fiber : Fiber) : Nil
-      if @select_context.try &.try_trigger
-        fiber.enqueue
-      end
+      fiber.enqueue if time_expired?
+    end
+
+    def time_expired? : Bool
+      @select_context.try &.try_trigger || false
     end
   end
 end

src/crystal/pointer_linked_list.cr

@@ -86,4 +86,8 @@ struct Crystal::PointerLinkedList(T)
     each { |node| yield node }
     @head = Pointer(T).null
   end
+
+  def clear : Nil
+    @head = Pointer(T).null
+  end
 end

src/crystal/system/event_loop.cr

@@ -3,6 +3,8 @@ abstract class Crystal::EventLoop
   def self.create : self
     {% if flag?(:wasi) %}
       Crystal::Wasi::EventLoop.new
+    {% elsif flag?(:linux) || flag?(:solaris) %}
+      Crystal::Epoll::EventLoop.new
     {% elsif flag?(:unix) %}
       Crystal::LibEvent::EventLoop.new
     {% elsif flag?(:win32) %}
@@ -72,6 +74,8 @@ end
 
 {% if flag?(:wasi) %}
   require "./wasi/event_loop"
+{% elsif flag?(:linux) || flag?(:solaris) %}
+  require "./unix/epoll/event_loop"
 {% elsif flag?(:unix) %}
   require "./unix/event_loop_libevent"
 {% elsif flag?(:win32) %}

src/crystal/system/file.cr

@@ -87,13 +87,6 @@ module Crystal::System::File
   private def self.error_is_file_exists?(errno)
     errno.in?(Errno::EEXIST, WinError::ERROR_FILE_EXISTS)
   end
-
-  # Closes the internal file descriptor without notifying libevent.
-  # This is directly used after the fork of a process to close the
-  # parent's Crystal::System::Signal.@@pipe reference before re initializing
-  # the event loop. In the case of a fork that will exec there is even
-  # no need to initialize the event loop at all.
-  # def file_descriptor_close
 end
 
 {% if flag?(:wasi) %}

src/crystal/system/file_descriptor.cr

@@ -14,6 +14,13 @@ module Crystal::System::FileDescriptor
   # cooked mode otherwise.
   # private def system_raw(enable : Bool, & : ->)
 
+  # Closes the internal file descriptor without notifying libevent.
+  # This is directly used after the fork of a process to close the
+  # parent's Crystal::System::Signal.@@pipe reference before re initializing
+  # the event loop. In the case of a fork that will exec there is even
+  # no need to initialize the event loop at all.
+  # def file_descriptor_close(raise_on_error = true) : Nil
+
   private def system_read(slice : Bytes) : Int32
     event_loop.read(self, slice)
   end

src/crystal/system/unix/epoll.cr

@@ -0,0 +1,39 @@
+{% skip_file unless flag?(:linux) || flag?(:solaris) %}
+
+require "c/sys/epoll"
+
+struct Crystal::System::Epoll
+  def initialize
+    @epfd = LibC.epoll_create1(LibC::EPOLL_CLOEXEC)
+    raise RuntimeError.from_errno("epoll_create1") if @epfd == -1
+  end
+
+  def add(fd : Int32, epoll_event : LibC::EpollEvent*) : Nil
+    if LibC.epoll_ctl(@epfd, LibC::EPOLL_CTL_ADD, fd, epoll_event) == -1
+      raise RuntimeError.from_errno("epoll_ctl(EPOLL_CTL_ADD)")
+    end
+  end
+
+  def modify(fd : Int32, epoll_event : LibC::EpollEvent*) : Nil
+    if LibC.epoll_ctl(@epfd, LibC::EPOLL_CTL_MOD, fd, epoll_event) == -1
+      raise RuntimeError.from_errno("epoll_ctl(EPOLL_CTL_MOD)")
+    end
+  end
+
+  def delete(fd : Int32) : Nil
+    if LibC.epoll_ctl(@epfd, LibC::EPOLL_CTL_DEL, fd, nil) == -1
+      raise RuntimeError.from_errno("epoll_ctl(EPOLL_CTL_DEL)")
+    end
+  end
+
+  # `timeout` is in milliseconds; -1 will wait indefinitely; 0 will never wait.
+  def wait(events : Slice(LibC::EpollEvent), timeout : Int32) : Slice(LibC::EpollEvent)
+    count = LibC.epoll_wait(@epfd, events.to_unsafe, events.size, timeout)
+    raise RuntimeError.from_errno("epoll_wait") if count == -1 && Errno.value != Errno::EINTR
+    events[0, count.clamp(0..)]
+  end
+
+  def close : Nil
+    LibC.close(@epfd)
+  end
+end

src/crystal/system/unix/epoll/event.cr

@@ -0,0 +1,40 @@
+{% skip_file unless flag?(:linux) || flag?(:solaris) %}
+
+require "../epoll"
+require "../timerfd"
+
+struct Crystal::Epoll::Event
+  enum Type
+    IoRead
+    IoWrite
+    Sleep
+    SelectTimeout
+    System
+  end
+
+  getter fiber : Fiber
+  getter type : Type
+  getter fd : Int32
+
+  property! time : Time::Span?
+  getter? timed_out : Bool = false
+
+  include PointerLinkedList::Node
+
+  # Allocates a system event into the HEAP. A system event doesn't have an
+  # associated fiber.
+  def self.system(fd : Int32) : self*
+    event = Pointer(self).malloc(1)
+    fiber = uninitialized Fiber
+    event.value.initialize(fd, fiber, :system)
+    event
+  end
+
+  def initialize(@fd : Int32, @fiber : Fiber, @type : Type, timeout : Time::Span? = nil)
+    @time = ::Time.monotonic + timeout if timeout
+  end
+
+  def timed_out! : Bool
+    @timed_out = true
+  end
+end