evt 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 792dc614f6216687c600f101b8fac515a71fc0249c4ca6af3f880cb71ee17eff
-  data.tar.gz: c64b75645bd2adb22a3947c7b239c9cde05a8fb1ac42a6e08f2cfe653bc20a84
+  metadata.gz: 40b96a960c2027db56a915a8c4d6e20f8d29fd9f195003ef1a93cf9fad13a151
+  data.tar.gz: d6f99c7c134954a47b68c56f9a68f1227ed9ac90cefedefbef33a9c8978730aa
 SHA512:
-  metadata.gz: '016090b4ba576eb10896099d3879445d3c65d3b8f6d9475731786639282c5e7f37ba1029e6d1201b165f9bfbf20193fb13017b5ea6af90792b60989f33691899'
-  data.tar.gz: 83d15ffca0e28b5c96f241197bbd97eabe1a935e01f71c6e4bb94a2eb9ad413148b2318d1b55a4df4b11444e989508b32cd7da9f1b19b839512d13b92b7034b9
+  metadata.gz: 75dbf1e519db25b8a0f63958cb2578fe852f12374eaed0a5a3b9595b30315ad92971477db2b27ed1bd2db6bd051553fa93eaa41263ed45c08c57ace0b43117fd
+  data.tar.gz: 905988d2a76fed454cd42b3acc014d5ddce044ecdf918352d8a6ede58213b3006dda7588a7d5889c6a4b16b23cce0a14308d71e4ba02430efcfe0fcdfa8f38c6

data/.github/workflows/build.yml

@@ -0,0 +1,21 @@
+name: Build
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: '3.0'
+          bundler-cache: false
+      - name: Install Dependencies
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+      - name: Build
+        run: rake build

data/.github/workflows/test.yml

@@ -12,13 +12,13 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - { os: ubuntu-20.04, ruby: '3.0' }
-        - { os: ubuntu-20.04, ruby: ruby-head }
-        - { os: macos-11.0, ruby: '3.0' }
-        - { os: macos-11.0, ruby: ruby-head }
-        - { os: windows-2019, ruby: mingw }
-        - { os: windows-2019, ruby: mswin }
-    name: ${{ matrix.os }} ${{ matrix.ruby }}
+        - { os: ubuntu-20.04, ruby: '3.0', backend: epoll }
+        - { os: ubuntu-20.04, ruby: '3.0', backend: ruby, disable-epoll: 1 }
+        - { os: macos-11.0, ruby: '3.0', backend: kqueue }
+        - { os: macos-11.0, ruby: '3.0', backend: ruby, disable-kqueue: 1 }
+        - { os: windows-2019, ruby: mingw, backend: ruby }
+        - { os: windows-2019, ruby: mswin, backend: ruby }
+    name: test ${{ matrix.os }} ${{ matrix.ruby }} ${{ matrix.backend }}
     runs-on: ${{ matrix.os }}
     timeout-minutes: 5
     steps:
@@ -32,20 +32,9 @@ jobs:
             gem install bundler
             bundle install --jobs 4 --retry 3
       - name: Compile
+        env:
+          DISABLE_EPOLL: ${{ matrix.disable-epoll }}
+          DISABLE_KQUEUE: ${{ matrix.disable-kqueue }}
         run: rake compile
       - name: Test
-        run: rake
-  build:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@master
-        with:
-          ruby-version: '3.0'
-          bundler-cache: false
-      - name: Install Dependencies
-        run: |
-          gem install bundler
-          bundle install --jobs 4 --retry 3
-      - name: Build
-        run: gem build evt.gemspec
+        run: rake test

data/README.md

@@ -1,15 +1,16 @@
 # Evt
 
-The Event Library that designed for Ruby 3.0.
+The Event Library that designed for Ruby 3.0 Fiber Scheduler.
 
 **This gem is still under development, APIs and features are not stable. Advices and PRs are highly welcome.**
 
-![CI Tests](https://github.com/dsh0416/evt/workflows/CI%20Tests/badge.svg)
+[![CI Tests](https://github.com/dsh0416/evt/workflows/CI%20Tests/badge.svg)](https://github.com/dsh0416/evt/actions?query=workflow%3A%22Build%22)
+[![Build](https://github.com/dsh0416/evt/workflows/Build/badge.svg)](https://github.com/dsh0416/evt/actions?query=workflow%3A%22CI+Tests%22)
+[![Gem Version](https://badge.fury.io/rb/evt.svg)](https://rubygems.org/gems/evt)
+[![Downloads](https://ruby-gem-downloads-badge.herokuapp.com/evt?type=total)](https://rubygems.org/gems/evt)
 
 ## Features
 
-
-
 ### IO Backend Support
 
 |                 | Linux       | Windows     | macOS       | FreeBSD     |
@@ -18,14 +19,33 @@ The Event Library that designed for Ruby 3.0.
 | epoll           | ✅  (See 2) | ❌          | ❌          | ❌          |
 | kqueue          | ❌          | ❌          | ✅ (⚠️ See 5) | ✅          |
 | IOCP            | ❌          | ❌ (⚠️See 3) | ❌          | ❌          |
-| Ruby (`select`) | ✅ Fallback | ✅ (⚠️See 4) | ✅ Fallback | ✅ Fallback |
+| Ruby (`IO.select`) | ✅ Fallback | ✅ (⚠️See 4) | ✅ Fallback | ✅ Fallback |
 
 1. when liburing is installed
-2. when kernel version >= 2.6.8
+2. when kernel version >= 2.6.9
 3. WOULD NOT WORK until `FILE_FLAG_OVERLAPPED` is included in I/O initialization process.
 4. Some I/Os are not able to be nonblock under Windows. See [Scheduler Docs](https://docs.ruby-lang.org/en/master/doc/scheduler_md.html#label-IO).
 5. `kqueue` performance in Darwin is very poor. **MAY BE DISABLED IN THE FUTURE.**
 
+### Benchmark
+
+The benchmark is running under `v0.2.2` version. See [evt-server-benchmark](https://github.com/dsh0416/evt-server-benchmark) for test code, the test is running under a single-thread server.
+
+The test command is `wrk -t4 -c8192 -d30s http://localhost:3001`.
+
+All of the systems have set their file descriptor limit to maximum.
+
+| OS    | CPU         | Memory | Backend                | req/s    |
+| ----- | ----------- | ------ | ---------------------- | -------- |
+| Linux | Ryzen 2700x | 64GB   | epoll                  | 54680.08 |
+| Linux | Ryzen 2700x | 64GB   | io_uring               | 50245.53 |
+| Linux | Ryzen 2700x | 64GB   | IO.select (using poll) | 44159.23 |
+| macOS | i7-6820HQ   | 16GB   | kqueue                 | 37855.53 |
+| macOS | i7-6820HQ   | 16GB   | IO.select (using poll) | 28293.36 |
+
+The benchmark uses an invalid parser, and `wrk` is very error-sensitive. The benchmark can't close the connection properly.
+Use a valid parser, recent updates to my [midori](https://github.com/midori-rb/midori.rb) is able to use Ruby scheduler, which could achives 247k+ req/s on single thread with `kqueue` and 647k+ req/s with `epoll`.
+
 ## Install
 
 ```bash
@@ -53,8 +73,6 @@ Fiber.schedule do
   wr.close
 end
 
-scheduler.run
-
 # "Hello World"
 ```
 
@@ -66,6 +84,7 @@ scheduler.run
 - [x] Support iov features of io_uring
 - [x] Support IOCP (**NOT ENABLED YET**)
 - [x] Setup tests with Ruby 3
+- [x] Selectable backend compilation by environment variable
 - [ ] Support IOCP with iov features
 - [ ] Setup more tests for production purpose
 - [ ] Documentation for usages

data/Rakefile

@@ -11,6 +11,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
 end
 
 task :default => :test

data/evt.gemspec

@@ -6,11 +6,11 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Delton Ding"]
   spec.email         = ["dsh0416@gmail.com"]
 
-  spec.summary       = "A low-level Event Handler designed for Ruby 3 Scheduler"
+  spec.summary       = "The Event Library that designed for Ruby 3.0 Fiber Scheluer."
   spec.description   = "A low-level Event Handler designed for Ruby 3 Scheduler for better performance"
   spec.homepage      = "https://github.com/dsh0416/evt"
   spec.license       = 'BSD-3-Clause'
-  spec.required_ruby_version = '>= 2.8.0.dev'
+  spec.required_ruby_version = '>= 3.0.0.rc1'
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/dsh0416/evt"
@@ -18,10 +18,11 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|.vscode)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|examples|.vscode)/}) }
   end
   spec.require_paths = ["lib"]
   spec.extensions = ['ext/evt/extconf.rb']
 
   spec.add_development_dependency 'rake-compiler', '~> 1.0'
+  spec.add_development_dependency 'simplecov', '~> 0.20.0'
 end

data/ext/evt/epoll.h

@@ -1,14 +1,14 @@
 #ifndef EPOLL_H
-#define EPOLL_G
+#define EPOLL_H
 #include "evt.h"
 
 #if HAVE_SYS_EPOLL_H
-VALUE method_scheduler_init(VALUE self) {
+VALUE method_scheduler_epoll_init(VALUE self) {
     rb_iv_set(self, "@epfd", INT2NUM(epoll_create(1))); // Size of epoll is ignored after Linux 2.6.8.
     return Qnil;
 }
 
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+VALUE method_scheduler_epoll_register(VALUE self, VALUE io, VALUE interest) {
     struct epoll_event event;
     ID id_fileno = rb_intern("fileno");
     int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
@@ -31,7 +31,7 @@ VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
     return Qnil;
 }
 
-VALUE method_scheduler_deregister(VALUE self, VALUE io) {
+VALUE method_scheduler_epoll_deregister(VALUE self, VALUE io) {
     ID id_fileno = rb_intern("fileno");
     int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
     int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
@@ -39,7 +39,7 @@ VALUE method_scheduler_deregister(VALUE self, VALUE io) {
     return Qnil;
 }
 
-VALUE method_scheduler_wait(VALUE self) {
+VALUE method_scheduler_epoll_wait(VALUE self) {
     int n, epfd, i, event_flag, timeout;
     VALUE next_timeout, obj_io, readables, writables, result;
     ID id_next_timeout = rb_intern("next_timeout");
@@ -56,7 +56,7 @@ VALUE method_scheduler_wait(VALUE self) {
         timeout = NUM2INT(next_timeout);
     }
 
-    struct epoll_event* events = (struct epoll_event*) xmalloc(sizeof(struct epoll_event) * EPOLL_MAX_EVENTS);
+    struct epoll_event events[EPOLL_MAX_EVENTS];
     
     n = epoll_wait(epfd, events, EPOLL_MAX_EVENTS, timeout);
     if (n < 0) {
@@ -79,12 +79,10 @@ VALUE method_scheduler_wait(VALUE self) {
     result = rb_ary_new2(2);
     rb_ary_store(result, 0, readables);
     rb_ary_store(result, 1, writables);
-
-    xfree(events);
     return result;
 }
 
-VALUE method_scheduler_backend(VALUE klass) {
+VALUE method_scheduler_epoll_backend(VALUE klass) {
     return rb_str_new_cstr("epoll");
 }
 #endif

data/ext/evt/evt.c

@@ -5,30 +5,41 @@
 
 void Init_evt_ext()
 {
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
     Evt = rb_define_module("Evt");
-    Scheduler = rb_define_class_under(Evt, "Scheduler", rb_cObject);
-    Payload = rb_define_class_under(Scheduler, "Payload", rb_cObject);
+    Bundled = rb_define_class_under(Evt, "Bundled", rb_cObject);
+    Payload = rb_define_class_under(Bundled, "Payload", rb_cObject);
     Fiber = rb_define_class("Fiber", rb_cObject);
-    rb_define_singleton_method(Scheduler, "backend", method_scheduler_backend, 0);
-    rb_define_method(Scheduler, "init_selector", method_scheduler_init, 0);
-    rb_define_method(Scheduler, "register", method_scheduler_register, 2);
-    rb_define_method(Scheduler, "deregister", method_scheduler_deregister, 1);
-    rb_define_method(Scheduler, "wait", method_scheduler_wait, 0);
-
-#if HAVELIBURING_H
-    rb_define_method(Scheduler, "io_read", method_scheduler_io_read, 4);
-    rb_define_method(Scheduler, "io_write", method_scheduler_io_read, 4);
+#if HAVE_LIBURING_H
+    rb_define_singleton_method(Bundled, "uring_backend", method_scheduler_uring_backend, 0);
+    rb_define_method(Bundled, "uring_init_selector", method_scheduler_uring_init, 0);
+    rb_define_method(Bundled, "uring_register", method_scheduler_uring_register, 2);
+    rb_define_method(Bundled, "uring_wait", method_scheduler_uring_wait, 0);
+    rb_define_method(Bundled, "uring_io_read", method_scheduler_uring_io_read, 4);
+    rb_define_method(Bundled, "uring_io_write", method_scheduler_uring_io_write, 4);
+#endif
+#if HAVE_SYS_EPOLL_H
+    rb_define_singleton_method(Bundled, "epoll_backend", method_scheduler_epoll_backend, 0);
+    rb_define_method(Bundled, "epoll_init_selector", method_scheduler_epoll_init, 0);
+    rb_define_method(Bundled, "epoll_register", method_scheduler_epoll_register, 2);
+    rb_define_method(Bundled, "epoll_deregister", method_scheduler_epoll_deregister, 1);
+    rb_define_method(Bundled, "epoll_wait", method_scheduler_epoll_wait, 0);
 #endif
+#if HAVE_SYS_EVENT_H
+    rb_define_singleton_method(Bundled, "kqueue_backend", method_scheduler_kqueue_backend, 0);
+    rb_define_method(Bundled, "kqueue_init_selector", method_scheduler_kqueue_init, 0);
+    rb_define_method(Bundled, "kqueue_register", method_scheduler_kqueue_register, 2);
+    rb_define_method(Bundled, "kqueue_wait", method_scheduler_kqueue_wait, 0);
+#endif
+    rb_define_singleton_method(Bundled, "select_backend", method_scheduler_select_backend, 0);
+    rb_define_method(Bundled, "select_wait", method_scheduler_select_wait, 0);
 }
 
-#if HAVE_LIBURING_H
-    #include "uring.h"
-#elif HAVE_SYS_EPOLL_H
-    #include "epoll.h"
-#elif HAVE_SYS_EVENT_H
-    #include "kqueue.h"
-#elif HAVE_WINDOWS_H
-    #include "select.h"
-    // #include "iocp.h"
-#endif
+#include "uring.h"
+#include "epoll.h"
+#include "kqueue.h"
+// #include "iocp.h"
+#include "select.h"
 #endif

data/ext/evt/evt.h

@@ -4,29 +4,22 @@
 #include <ruby.h>
 
 VALUE Evt = Qnil;
-VALUE Scheduler = Qnil;
+VALUE Bundled = Qnil;
 VALUE Payload = Qnil;
 VALUE Fiber = Qnil;
 
 void Init_evt_ext();
-VALUE method_scheduler_init(VALUE self);
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest);
-VALUE method_scheduler_deregister(VALUE self, VALUE io);
-VALUE method_scheduler_wait(VALUE self);
-VALUE method_scheduler_backend(VALUE klass);
-#if HAVE_LIBURING_H
-VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length);
-VALUE method_scheduler_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length);
-#endif
-
-#if HAV_WINDOWS_H
-VALUE method_scheduler_io_read(VALUE io, VALUE buffer, VALUE offset, VALUE length);
-VALUE method_scheduler_io_write(VALUE io, VALUE buffer, VALUE offset, VALUE length);
-#endif
 
 #if HAVE_LIBURING_H
-    #include <liburing.h>
+    VALUE method_scheduler_uring_init(VALUE self);
+    VALUE method_scheduler_uring_register(VALUE self, VALUE io, VALUE interest);
+    VALUE method_scheduler_uring_deregister(VALUE self, VALUE io);
+    VALUE method_scheduler_uring_wait(VALUE self);
+    VALUE method_scheduler_uring_backend(VALUE klass);
+    VALUE method_scheduler_uring_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length);
+    VALUE method_scheduler_uring_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length);
 
+    #include <liburing.h>
     #define URING_ENTRIES 64
     #define URING_MAX_EVENTS 64
 
@@ -49,13 +42,26 @@ VALUE method_scheduler_io_write(VALUE io, VALUE buffer, VALUE offset, VALUE leng
         .data = NULL,
         .flags = RUBY_TYPED_FREE_IMMEDIATELY,
     };
-#elif HAVE_SYS_EPOLL_H
+#endif
+#if HAVE_SYS_EPOLL_H
+    VALUE method_scheduler_epoll_init(VALUE self);
+    VALUE method_scheduler_epoll_register(VALUE self, VALUE io, VALUE interest);
+    VALUE method_scheduler_epoll_deregister(VALUE self, VALUE io);
+    VALUE method_scheduler_epoll_wait(VALUE self);
+    VALUE method_scheduler_epoll_backend(VALUE klass);
     #include <sys/epoll.h>
     #define EPOLL_MAX_EVENTS 64
-#elif HAVE_SYS_EVENT_H
+#endif
+#if HAVE_SYS_EVENT_H
+    VALUE method_scheduler_kqueue_init(VALUE self);
+    VALUE method_scheduler_kqueue_register(VALUE self, VALUE io, VALUE interest);
+    VALUE method_scheduler_kqueue_deregister(VALUE self, VALUE io);
+    VALUE method_scheduler_kqueue_wait(VALUE self);
+    VALUE method_scheduler_kqueue_backend(VALUE klass);
     #include <sys/event.h>
     #define KQUEUE_MAX_EVENTS 64
-#elif HAVE_WINDOWS_H
+#endif
+#if HAVE_WINDOWS_H
     // #include <Windows.h>
     // #define IOCP_MAX_EVENTS 64
 
@@ -79,4 +85,6 @@ VALUE method_scheduler_io_write(VALUE io, VALUE buffer, VALUE offset, VALUE leng
     //     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
     // };
 #endif
+    VALUE method_scheduler_select_wait(VALUE self);
+    VALUE method_scheduler_select_backend(VALUE klass);
 #endif

data/ext/evt/extconf.rb

@@ -2,11 +2,22 @@ require 'mkmf'
 extension_name = 'evt_ext'
 dir_config(extension_name)
 
-have_library('uring')
-have_header('liburing.h')
-have_header('sys/epoll.h')
-have_header('sys/event.h')
-have_header('Windows.h') 
+def env_defined?(v)
+  return false if ENV[v].nil?
+  return false if ENV[v].empty?
+  return false if ENV[v].upcase == 'FALSE'
+  return false if ENV[v] == '0'
+  true
+end
+
+unless env_defined?('DISABLE_URING')
+  have_library('uring')
+  have_header('liburing.h')
+end
+
+have_header('sys/epoll.h') unless env_defined?('DISABLE_EPOLL')
+have_header('sys/event.h') unless env_defined?('DISABLE_KQUEUE')
+have_header('Windows.h')  unless env_defined?('DISABLE_IOCP')
 
 create_header
 create_makefile(extension_name)

data/ext/evt/iocp.h

@@ -11,13 +11,13 @@ size_t iocp_payload_size(const void* data) {
     return sizeof(HANDLE);
 }
 
-VALUE method_scheduler_init(VALUE self) {
+VALUE method_scheduler_iocp_init(VALUE self) {
     HANDLE iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
     rb_iv_set(self, "@iocp", TypedData_Wrap_Struct(Payload, &type_iocp_payload, iocp));
     return Qnil;
 }
 
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+VALUE method_scheduler_iocp_register(VALUE self, VALUE io, VALUE interest) {
     HANDLE iocp;
     VALUE iocp_obj = rb_iv_get(self, "@iocp");
     struct iocp_data* data;
@@ -47,11 +47,7 @@ VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
     return Qnil;
 }
 
-VALUE method_scheduler_deregister(VALUE self, VALUE io) {
-    return Qnil;
-}
-
-VALUE method_scheduler_wait(VALUE self) {
+VALUE method_scheduler_iocp_wait(VALUE self) {
     ID id_next_timeout = rb_intern("next_timeout");
     ID id_push = rb_intern("push");
     VALUE iocp_obj = rb_iv_get(self, "@iocp");
@@ -119,7 +115,7 @@ VALUE method_scheduler_wait(VALUE self) {
     return result;
 }
 
-VALUE method_scheduler_backend(VALUE klass) {
+VALUE method_scheduler_iocp_backend(VALUE klass) {
     return rb_str_new_cstr("iocp");
 }
 #endif

data/ext/evt/kqueue.h

@@ -4,12 +4,12 @@
 
 #if HAVE_SYS_EVENT_H
 
-VALUE method_scheduler_init(VALUE self) {
+VALUE method_scheduler_kqueue_init(VALUE self) {
     rb_iv_set(self, "@kq", INT2NUM(kqueue()));
     return Qnil;
 }
 
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+VALUE method_scheduler_kqueue_register(VALUE self, VALUE io, VALUE interest) {
     struct kevent event;
     u_short event_flags = 0;
     ID id_fileno = rb_intern("fileno");
@@ -27,26 +27,15 @@ VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
         event_flags |= EVFILT_WRITE;
     }
 
-    EV_SET(&event, fd, event_flags, EV_ADD|EV_ENABLE, 0, 0, (void*) io);
+    EV_SET(&event, fd, event_flags, EV_ADD|EV_ENABLE|EV_ONESHOT, 0, 0, (void*) io);
     kevent(kq, &event, 1, NULL, 0, NULL); // TODO: Check the return value
     return Qnil;
 }
 
-VALUE method_scheduler_deregister(VALUE self, VALUE io) {
-    struct kevent event;
-    ID id_fileno = rb_intern("fileno");
-    int kq = NUM2INT(rb_iv_get(self, "@kq"));
-    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
-    EV_SET(&event, fd, 0, EV_DELETE, 0, 0, (void*) io);
-    kevent(kq, &event, 1, NULL, 0, (void*) io); // TODO: Check the return value
-    return Qnil;
-}
-
-VALUE method_scheduler_wait(VALUE self) {
+VALUE method_scheduler_kqueue_wait(VALUE self) {
     int n, kq, i;
     u_short event_flags = 0;
-
-    struct kevent* events; // Event Triggered
+    struct kevent events[KQUEUE_MAX_EVENTS];
     struct timespec timeout;
     VALUE next_timeout, obj_io, readables, writables, result;
     ID id_next_timeout = rb_intern("next_timeout");
@@ -57,8 +46,6 @@ VALUE method_scheduler_wait(VALUE self) {
     readables = rb_ary_new();
     writables = rb_ary_new();
 
-    events = (struct kevent*) xmalloc(sizeof(struct kevent) * KQUEUE_MAX_EVENTS);
-
     if (next_timeout == Qnil || NUM2INT(next_timeout) == -1) {
         n = kevent(kq, NULL, 0, events, KQUEUE_MAX_EVENTS, NULL);
     } else {
@@ -70,7 +57,6 @@ VALUE method_scheduler_wait(VALUE self) {
     // TODO: Check if n >= 0
     for (i = 0; i < n; i++) {
         event_flags = events[i].filter;
-        printf("event flags: %d\n", event_flags);
         if (event_flags & EVFILT_READ) {
             obj_io = (VALUE) events[i].udata;
             rb_funcall(readables, id_push, 1, obj_io);
@@ -86,11 +72,10 @@ VALUE method_scheduler_wait(VALUE self) {
     rb_ary_store(result, 0, readables);
     rb_ary_store(result, 1, writables);
 
-    xfree(events);
     return result;
 }
 
-VALUE method_scheduler_backend(VALUE klass) {
+VALUE method_scheduler_kqueue_backend(VALUE klass) {
     return rb_str_new_cstr("kqueue");
 }
 #endif

data/ext/evt/select.h

@@ -2,19 +2,7 @@
 #define SELECT_H
 #include "evt.h"
 
-VALUE method_scheduler_init(VALUE self) {
-    return Qnil;
-}
-
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
-    return Qnil;
-}
-
-VALUE method_scheduler_deregister(VALUE self, VALUE io) {
-    return Qnil;
-}
-
-VALUE method_scheduler_wait(VALUE self) {
+VALUE method_scheduler_select_wait(VALUE self) {
     // return IO.select(@readable.keys, @writable.keys, [], next_timeout)
     VALUE readable, writable, readable_keys, writable_keys, next_timeout;
     ID id_select = rb_intern("select");
@@ -30,7 +18,7 @@ VALUE method_scheduler_wait(VALUE self) {
     return rb_funcall(rb_cIO, id_select, 4, readable_keys, writable_keys, rb_ary_new(), next_timeout);
 }
 
-VALUE method_scheduler_backend(VALUE klass) {
+VALUE method_scheduler_select_backend(VALUE klass) {
     return rb_str_new_cstr("ruby");
 }
 #endif

data/ext/evt/uring.h

@@ -12,7 +12,7 @@ size_t uring_payload_size(const void* data) {
     return sizeof(struct io_uring);
 }
 
-VALUE method_scheduler_init(VALUE self) {
+VALUE method_scheduler_uring_init(VALUE self) {
     int ret;
     struct io_uring* ring;
     ring = xmalloc(sizeof(struct io_uring));
@@ -24,7 +24,7 @@ VALUE method_scheduler_init(VALUE self) {
     return Qnil;
 }
 
-VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+VALUE method_scheduler_uring_register(VALUE self, VALUE io, VALUE interest) {
     VALUE ring_obj;
     struct io_uring* ring;
     struct io_uring_sqe *sqe;
@@ -60,12 +60,7 @@ VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
     return Qnil;
 }
 
-VALUE method_scheduler_deregister(VALUE self, VALUE io) {
-    // io_uring runs under oneshot mode. No need to deregister.
-    return Qnil;
-}
-
-VALUE method_scheduler_wait(VALUE self) {
+VALUE method_scheduler_uring_wait(VALUE self) {
     struct io_uring* ring;
     struct io_uring_cqe *cqes[URING_MAX_EVENTS];
     struct uring_data *data;
@@ -90,27 +85,27 @@ VALUE method_scheduler_wait(VALUE self) {
         data = (struct uring_data*) io_uring_cqe_get_data(cqes[i]);
         poll_events = data->poll_mask;
         obj_io = data->io;
-        if (!data->is_poll) {
+        if (data->is_poll) {
+            if (poll_events & POLL_IN) {
+                rb_funcall(readables, id_push, 1, obj_io);
+            }
+            
+            if (poll_events & POLL_OUT) {
+                rb_funcall(writables, id_push, 1, obj_io);
+            }
+        } else {
             rb_funcall(iovs, id_push, 1, obj_io);
         }
-        
-        if (poll_events & POLL_IN) {
-            rb_funcall(readables, id_push, 1, obj_io);
-        }
-        
-        if (poll_events & POLL_OUT) {
-            rb_funcall(writables, id_push, 1, obj_io);
-        }
-        xfree(data);
+        io_uring_cqe_seen(ring, cqes[i]);
     }
 
     if (ret == 0) {
        if (next_timeout != Qnil && NUM2INT(next_timeout) != -1) {
             // sleep
             time = next_timeout / 1000;
-            rb_funcall(rb_mKernel, id_sleep, 1, RFLOAT_VALUE(time));
+            rb_funcall(rb_mKernel, id_sleep, 1, rb_float_new(time));
        } else {
-            rb_funcall(rb_mKernel, id_sleep, 1, RFLOAT_VALUE(0.001)); // To avoid infinite loop
+            rb_funcall(rb_mKernel, id_sleep, 1, rb_float_new(0.001)); // To avoid infinite loop
        }
     }
 
@@ -122,7 +117,7 @@ VALUE method_scheduler_wait(VALUE self) {
     return result;
 }
 
-VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+VALUE method_scheduler_uring_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
     struct io_uring* ring;
     struct uring_data *data;
     char* read_buffer;
@@ -152,7 +147,6 @@ VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset,
     io_uring_submit(ring);
 
     VALUE result = rb_str_new(read_buffer, strlen(read_buffer));
-    xfree(read_buffer);
     if (buffer != Qnil) {
         rb_str_append(buffer, result);
     }
@@ -161,7 +155,7 @@ VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset,
     return result;
 }
 
-VALUE method_scheduler_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+VALUE method_scheduler_uring_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
     struct io_uring* ring;
     struct uring_data *data;
     char* write_buffer;
@@ -193,7 +187,7 @@ VALUE method_scheduler_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset
     return length;
 }
 
-VALUE method_scheduler_backend(VALUE klass) {
+VALUE method_scheduler_uring_backend(VALUE klass) {
     return rb_str_new_cstr("liburing");
 }
 

data/lib/evt.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
+require 'fiber'
+require 'socket'
+require 'io/nonblock'
 require_relative 'evt/version'
+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'
 

data/lib/evt/backends/bundled.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+class Evt::Bundled
+  MAXIMUM_TIMEOUT = 5
+  COLLECT_COUNTER_MAX = 16384
+
+  def initialize
+    @readable = {}
+    @writable = {}
+    @waiting = {}
+    @iovs = {}
+    
+    @lock = Mutex.new
+    @blocking = 0
+    @ready = []
+    @collect_counter = 0
+  
+    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
+
+      collect
+
+      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
+
+  # Collect closed streams in readables and writables
+  def collect
+    if @collect_counter < COLLECT_COUNTER_MAX
+      @collect_counter += 1
+      return
+    end
+
+    @collect_counter = 0
+
+    @readable.keys.each do |io|
+      @readable.delete(io) if io.closed?
+    end
+    
+    @writable.keys.each do |io|
+      @writable.delete(io) if io.closed?
+    end
+  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,121 +1,36 @@
 # frozen_string_literal: true
 
-require 'fiber'
-require 'socket'
-require 'io/nonblock'
-
+##
+# 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 = {}
-    @iovs = {}
-    @waiting = {}
-    
-    @lock = Mutex.new
-    @locking = 0
-    @ready = []
-
-    @ios = ObjectSpace::WeakMap.new
-    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
-      offset < 0 ? 0 : offset
-    end
-  end
-
-  def run
-    while @readable.any? or @writable.any? or @waiting.any? or @iovs.any? or @locking.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
+  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 current_time
-    Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  end
-
-  def io_wait(io, events, duration)
-    @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
-
-  def kernel_sleep(duration = nil)
-    @waiting[Fiber.current] = current_time + duration if duration.nil?
-    Fiber.yield
-    true
-  end
-
-  def mutex_lock(mutex)
-    @locking += 1
-    Fiber.yield
-  ensure
-    @locking -= 1
-  end
 
-  def mutex_unlock(mutex, fiber)
-    @lock.synchronize do
-      @ready << fiber
+    ##
+    # Returns all available backends on this machine
+    def availables
+      BACKENDS.filter do |backend|
+        backend.available?
+      end
     end
   end
-
-  def fiber(&block)
-    fiber = Fiber.new(blocking: false, &block)
-    fiber.resume
-    fiber
-  end
 end

data/lib/evt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evt
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Delton Ding
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-21 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
 description: A low-level Event Handler designed for Ruby 3 Scheduler for better performance
 email:
 - dsh0416@gmail.com
@@ -32,6 +46,7 @@ extensions:
 - ext/evt/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/build.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - CODE_OF_CONDUCT.md
@@ -49,6 +64,12 @@ files:
 - ext/evt/select.h
 - ext/evt/uring.h
 - lib/evt.rb
+- lib/evt/backends/bundled.rb
+- lib/evt/backends/epoll.rb
+- lib/evt/backends/iocp.rb
+- lib/evt/backends/kqueue.rb
+- lib/evt/backends/select.rb
+- lib/evt/backends/uring.rb
 - lib/evt/scheduler.rb
 - lib/evt/version.rb
 homepage: https://github.com/dsh0416/evt
@@ -65,7 +86,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.8.0.dev
+      version: 3.0.0.rc1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -75,5 +96,5 @@ requirements: []
 rubygems_version: 3.2.2
 signing_key:
 specification_version: 4
-summary: A low-level Event Handler designed for Ruby 3 Scheduler
+summary: The Event Library that designed for Ruby 3.0 Fiber Scheluer.
 test_files: []