evt 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c45ef9b7d8ed527d6280ca836777fb2c54822e23c9414c0cdeb234561115f47
-  data.tar.gz: 9543f98474500b00ae1a68009a261db1538d986e71bb7d9437bc9f190aff3c38
+  metadata.gz: 9466e3fd37da9807dc59525feebfe9252489a460a83111febf95973ff77fee56
+  data.tar.gz: 531808277a49049dc156144294346730a457d717699e091348125086dca529de
 SHA512:
-  metadata.gz: d9fe5b68df1d9e72d10314744ac173bc4f99a3d420034d861b4d1685c1f36bfbe24c993c9686c5862d45926dd8ddb901759d913dfb0ab39d730c380bfa27f3d4
-  data.tar.gz: cfbe9a5c112c71d96a737f29d9b4c5e1fd078b060331d999b7007a846b8e2a71f4de2eeebfc53e22dae8c33bf89afb15df5b36205b17f43f6f7e00096d3950f7
+  metadata.gz: c12a241295309fd31bf21bc4957374a636ff046b6aa1c5f670113f0cdeedb3df74f974145ba6f19f9e442d5f8d9ae373d70bfee6ae417dc09e9b620d57bcc78f
+  data.tar.gz: b3a369c7640d4770a89e7d37166930a757ca25266132fbd0544f2f0a065670de1c13578ea4cf7fc43ad1fb2c2020757b20cc972e85c23cab720bb229103fb070

data/.github/workflows/test.yml

@@ -0,0 +1,51 @@
+name: CI Tests
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+  schedule:
+    - cron: '0 7 * * SUN'
+jobs:
+  test:
+    strategy:
+      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 }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: false
+      - name: Install Dependencies
+        run: |
+            gem install bundler
+            bundle install --jobs 4 --retry 3
+      - name: Compile
+        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

data/.gitignore

@@ -9,3 +9,4 @@
 /*.gem
 /lib/*.bundle
 /lib/*.so
+Gemfile.lock

data/Gemfile

@@ -3,5 +3,5 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in evt.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
+gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"

data/README.md

@@ -1,2 +1,73 @@
-# evt
-A low-level Event Handler designed for Ruby 3 Scheduler
+# Evt
+
+The Event Library that designed for Ruby 3.0.
+
+**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)](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     |
+| --------------- | ----------- | ------------| ----------- | ----------- |
+| io_uring        | ✅  (See 1) | ❌          | ❌          | ❌          |
+| epoll           | ✅  (See 2) | ❌          | ❌          | ❌          |
+| kqueue          | ❌          | ❌          | ✅ (⚠️ See 5) | ✅          |
+| IOCP            | ❌          | ❌ (⚠️See 3) | ❌          | ❌          |
+| Ruby (`select`) | ✅ Fallback | ✅ (⚠️See 4) | ✅ Fallback | ✅ Fallback |
+
+1. when liburing is installed
+2. when kernel version >= 2.6.8
+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.**
+
+## Install
+
+```bash
+gem install evt
+```
+
+## Usage
+
+```ruby
+require 'evt'
+
+rd, wr = IO.pipe
+scheduler = Evt::Scheduler.new
+
+Fiber.set_scheduler scheduler
+
+Fiber.schedule do
+  message = rd.read(20)
+  puts message
+  rd.close
+end
+
+Fiber.schedule do
+  wr.write("Hello World")
+  wr.close
+end
+
+scheduler.run
+
+# "Hello World"
+```
+
+## Roadmap
+
+- [x] Support epoll/kqueue/select
+- [x] Upgrade to the latest Scheduler API
+- [x] Support io_uring
+- [x] Support iov features of io_uring
+- [x] Support IOCP (**NOT ENABLED YET**)
+- [x] Setup tests with Ruby 3
+- [ ] Support IOCP with iov features
+- [ ] Setup more tests for production purpose
+- [ ] Documentation for usages

data/evt.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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.7.1'
+  spec.required_ruby_version = '>= 2.8.0.dev'
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/dsh0416/evt"
@@ -18,7 +18,7 @@ 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)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|.vscode)/}) }
   end
   spec.require_paths = ["lib"]
   spec.extensions = ['ext/evt/extconf.rb']

data/ext/evt/epoll.h

@@ -0,0 +1,91 @@
+#ifndef EPOLL_H
+#define EPOLL_G
+#include "evt.h"
+
+#if HAVE_SYS_EPOLL_H
+VALUE method_scheduler_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) {
+    struct epoll_event event;
+    ID id_fileno = rb_intern("fileno");
+    int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
+    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
+    int ruby_interest = NUM2INT(interest);
+    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+    
+    if (ruby_interest & readable) {
+        event.events |= EPOLLIN;
+    }
+
+    if (ruby_interest & writable) {
+        event.events |= EPOLLOUT;
+    }
+
+    event.data.ptr = (void*) io;
+
+    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
+    return Qnil;
+}
+
+VALUE method_scheduler_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));
+    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL); // Require Linux 2.6.9 for NULL event.
+    return Qnil;
+}
+
+VALUE method_scheduler_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");
+    ID id_push = rb_intern("push");
+    
+    epfd = NUM2INT(rb_iv_get(self, "@epfd"));
+    next_timeout = rb_funcall(self, id_next_timeout, 0);
+    readables = rb_ary_new();
+    writables = rb_ary_new();
+
+    if (next_timeout == Qnil) {
+        timeout = -1;
+    } else {
+        timeout = NUM2INT(next_timeout);
+    }
+
+    struct epoll_event* events = (struct epoll_event*) xmalloc(sizeof(struct epoll_event) * EPOLL_MAX_EVENTS);
+    
+    n = epoll_wait(epfd, events, EPOLL_MAX_EVENTS, timeout);
+    if (n < 0) {
+        rb_raise(rb_eIOError, "unable to call epoll_wait");
+    }
+
+    for (i = 0; i < n; i++) {
+        event_flag = events[i].events;
+        if (event_flag & EPOLLIN) {
+            obj_io = (VALUE) events[i].data.ptr;
+            rb_funcall(readables, id_push, 1, obj_io);
+        }
+
+        if (event_flag & EPOLLOUT) {
+            obj_io = (VALUE) events[i].data.ptr;
+            rb_funcall(writables, id_push, 1, obj_io);
+        }
+    }
+
+    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) {
+    return rb_str_new_cstr("epoll");
+}
+#endif
+#endif

data/ext/evt/evt.c

@@ -1,122 +1,34 @@
-#include <ruby.h>
+#ifndef EVT_C
+#define EVT_C
 
-VALUE Scheduler = 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);
+#include "evt.h"
 
 void Init_evt_ext()
 {
-  Scheduler = rb_define_class("Scheduler", rb_cObject);
-  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 defined(__linux__) // TODO: Do more checks for using epoll
-#include <sys/epoll.h>
-#define EPOLL_MAX_EVENTS 65535
-
-VALUE method_scheduler_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) {
-    struct epoll_event event;
-    ID id_fileno = rb_intern("fileno");
-    int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
-    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
-    int ruby_interest = NUM2INT(interest);
-    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_READABLE")));
-    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_WRITABLE")));
-    
-    if (ruby_interest & readable) {
-        event.events |= EPOLLIN;
-    } else if (ruby_interest & writable) {
-        event.events |= EPOLLOUT;
-    }
-    event.data.ptr = (void*) io;
-
-    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
-    return Qnil;
-}
-
-VALUE method_scheduler_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));
-    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL); // Require Linux 2.6.9 for NULL event.
-    return Qnil;
-}
-
-VALUE method_scheduler_wait(VALUE self) {
-    int n, epfd, i, event_flag;
-    VALUE next_timeout, obj_io, readables, writables, result;
-    ID id_next_timeout = rb_intern("next_timeout");
-    ID id_push = rb_intern("push");
-    
-    epfd = NUM2INT(rb_iv_get(self, "@epfd"));
-    next_timeout = rb_funcall(self, id_next_timeout, 0);
-    readables = rb_ary_new();
-    writables = rb_ary_new();
-
-    struct epoll_event* events = (struct epoll_event*) xmalloc(sizeof(struct epoll_event) * EPOLL_MAX_EVENTS);
-    
-    n = epoll_wait(epfd, events, EPOLL_MAX_EVENTS, next_timeout);
-    // Check if n > 0
-
-    for (i = 0; i < n; i++) {
-        event_flag = events[i].events;
-        if (event_flag & EPOLLIN) {
-            obj_io = (VALUE) events[i].data.ptr;
-            rb_funcall(readables, id_push, 1, obj_io);
-        } else if (event_flag & EPOLLOUT) {
-            obj_io = (VALUE) events[i].data.ptr;
-            rb_funcall(writables, id_push, 1, obj_io);
-        }
-    }
-
-    result = rb_ary_new2(2);
-    rb_ary_store(result, 0, readables);
-    rb_ary_store(result, 1, writables);
-
-    xfree(events);
-    return result;
-}
-#else
-// Fallback to IO.select
-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) {
-    // return IO.select(@readable.keys, @writable.keys, [], next_timeout)
-    VALUE readable, writable, readable_keys, writable_keys, next_timeout;
-    ID id_select = rb_intern("select");
-    ID id_keys = rb_intern("keys");
-    ID id_next_timeout = rb_intern("next_timeout");
-
-    readable = rb_iv_get(self, "@readable");
-    writable = rb_iv_get(self, "@writable");
-
-    readable_keys = rb_funcall(readable, id_keys, 0);
-    writable_keys = rb_funcall(writable, id_keys, 0);
-    next_timeout = rb_funcall(self, id_next_timeout, 0);
-
-    return rb_funcall(rb_cIO, id_select, 4, readable_keys, writable_keys, rb_ary_new(), next_timeout);
-}
-#endif
+    Evt = rb_define_module("Evt");
+    Scheduler = rb_define_class_under(Evt, "Scheduler", rb_cObject);
+    Payload = rb_define_class_under(Scheduler, "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);
+#endif
+}
+
+#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
+#endif

data/ext/evt/evt.h

@@ -0,0 +1,82 @@
+#ifndef EVT_H
+#define EVT_H
+
+#include <ruby.h>
+
+VALUE Evt = Qnil;
+VALUE Scheduler = 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>
+
+    #define URING_ENTRIES 64
+    #define URING_MAX_EVENTS 64
+
+    struct uring_data {
+        bool is_poll;
+        short poll_mask;
+        VALUE io;
+    };
+
+    void uring_payload_free(void* data);
+    size_t uring_payload_size(const void* data);
+
+    static const rb_data_type_t type_uring_payload = {
+        .wrap_struct_name = "uring_payload",
+        .function = {
+            .dmark = NULL,
+            .dfree = uring_payload_free,
+            .dsize = uring_payload_size,
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    };
+#elif HAVE_SYS_EPOLL_H
+    #include <sys/epoll.h>
+    #define EPOLL_MAX_EVENTS 64
+#elif HAVE_SYS_EVENT_H
+    #include <sys/event.h>
+    #define KQUEUE_MAX_EVENTS 64
+#elif HAVE_WINDOWS_H
+    // #include <Windows.h>
+    // #define IOCP_MAX_EVENTS 64
+
+    // struct iocp_data {
+    //     VALUE io;
+    //     bool is_poll;
+    //     int interest;
+    // };
+
+    // void iocp_payload_free(void* data);
+    // size_t iocp_payload_size(const void* data);
+
+    // static const rb_data_type_t type_iocp_payload = {
+    //     .wrap_struct_name = "iocp_payload",
+    //     .function = {
+    //         .dmark = NULL,
+    //         .dfree = iocp_payload_free,
+    //         .dsize = iocp_payload_size,
+    //     },
+    //     .data = NULL,
+    //     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    // };
+#endif
+#endif

data/ext/evt/extconf.rb

@@ -1,5 +1,12 @@
 require 'mkmf'
 extension_name = 'evt_ext'
-create_header
 dir_config(extension_name)
-create_makefile(extension_name)
+
+have_library('uring')
+have_header('liburing.h')
+have_header('sys/epoll.h')
+have_header('sys/event.h')
+have_header('Windows.h') 
+
+create_header
+create_makefile(extension_name)

data/ext/evt/iocp.h

@@ -0,0 +1,126 @@
+#ifndef IOCP_H
+#define IOCP_H
+#include "evt.h"
+
+#if HAVE_WINDOWS_H
+void iocp_payload_free(void* data) {
+    CloseHandle((HANDLE) data);
+}
+
+size_t iocp_payload_size(const void* data) {
+    return sizeof(HANDLE);
+}
+
+VALUE method_scheduler_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) {
+    HANDLE iocp;
+    VALUE iocp_obj = rb_iv_get(self, "@iocp");
+    struct iocp_data* data;
+    TypedData_Get_Struct(iocp_obj, HANDLE, &type_iocp_payload, iocp);
+    int fd = NUM2INT(rb_funcallv(io, rb_intern("fileno"), 0, 0));
+    HANDLE io_handler = (HANDLE)rb_w32_get_osfhandle(fd);
+    
+    int ruby_interest = NUM2INT(interest);
+    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+    data = (struct iocp_data*) xmalloc(sizeof(struct iocp_data));
+    data->io = io;
+    data->is_poll = true;
+    data->interest = 0;
+
+    if (ruby_interest & readable) {
+        interest |= readable;
+    }
+
+    if (ruby_interest & writable) {
+        interest |= writable;
+    }
+
+    HANDLE res = CreateIoCompletionPort(io_handler, iocp, (ULONG_PTR) data, 0);
+    printf("IO at address: 0x%08x\n", (void *)data);
+
+    return Qnil;
+}
+
+VALUE method_scheduler_deregister(VALUE self, VALUE io) {
+    return Qnil;
+}
+
+VALUE method_scheduler_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");
+    VALUE next_timeout = rb_funcall(self, id_next_timeout, 0);
+    
+    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+
+    HANDLE iocp;
+    OVERLAPPED_ENTRY lpCompletionPortEntries[IOCP_MAX_EVENTS];
+    ULONG ulNumEntriesRemoved;
+    TypedData_Get_Struct(iocp_obj, HANDLE, &type_iocp_payload, iocp);
+
+    DWORD timeout;
+    if (next_timeout == Qnil) {
+        timeout = 0x5000;
+    } else {
+        timeout = NUM2INT(next_timeout) * 1000; // seconds to milliseconds
+    }
+
+    DWORD NumberOfBytesTransferred;
+    LPOVERLAPPED pOverlapped;
+    ULONG_PTR CompletionKey;
+
+    BOOL res = GetQueuedCompletionStatus(iocp, &NumberOfBytesTransferred, &CompletionKey, &pOverlapped, timeout);
+    // BOOL res = GetQueuedCompletionStatusEx(
+    //    iocp, lpCompletionPortEntries, IOCP_MAX_EVENTS, &ulNumEntriesRemoved, timeout, TRUE);
+
+    VALUE result = rb_ary_new2(2);
+
+    VALUE readables = rb_ary_new();
+    VALUE writables = rb_ary_new();
+
+    rb_ary_store(result, 0, readables);
+    rb_ary_store(result, 1, writables);
+
+    if (!result) {
+        return result;
+    }
+
+    printf("--------- Received! ---------\n");
+    printf("Received IO at address: 0x%08x\n", (void *)CompletionKey);
+    printf("dwNumberOfBytesTransferred: %lld\n", NumberOfBytesTransferred);
+
+    // if (ulNumEntriesRemoved > 0) {
+    //     printf("Entries: %ld\n", ulNumEntriesRemoved);
+    // }
+
+    // for (ULONG i = 0; i < ulNumEntriesRemoved; i++) {
+    //     OVERLAPPED_ENTRY entry = lpCompletionPortEntries[i];
+        
+    //     struct iocp_data *data = (struct iocp_data*) entry.lpCompletionKey;
+
+    //     int interest = data->interest;
+    //     VALUE obj_io = data->io;
+    //     if (interest & readable) {
+    //         rb_funcall(readables, id_push, 1, obj_io);
+    //     } else if (interest & writable) {
+    //         rb_funcall(writables, id_push, 1, obj_io);
+    //     }
+
+    //     xfree(data);
+    // }
+
+    return result;
+}
+
+VALUE method_scheduler_backend(VALUE klass) {
+    return rb_str_new_cstr("iocp");
+}
+#endif
+#endif

data/ext/evt/kqueue.h

@@ -0,0 +1,96 @@
+#ifndef KQUEUE_H
+#define KQUEUE_H
+#include "evt.h"
+
+#if HAVE_SYS_EVENT_H
+
+VALUE method_scheduler_init(VALUE self) {
+    rb_iv_set(self, "@kq", INT2NUM(kqueue()));
+    return Qnil;
+}
+
+VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+    struct kevent event;
+    u_short event_flags = 0;
+    ID id_fileno = rb_intern("fileno");
+    int kq = NUM2INT(rb_iv_get(self, "@kq"));
+    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
+    int ruby_interest = NUM2INT(interest);
+    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+    
+    if (ruby_interest & readable) {
+        event_flags |= EVFILT_READ;
+    }
+
+    if (ruby_interest & writable) {
+        event_flags |= EVFILT_WRITE;
+    }
+
+    EV_SET(&event, fd, event_flags, EV_ADD|EV_ENABLE, 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) {
+    int n, kq, i;
+    u_short event_flags = 0;
+
+    struct kevent* events; // Event Triggered
+    struct timespec timeout;
+    VALUE next_timeout, obj_io, readables, writables, result;
+    ID id_next_timeout = rb_intern("next_timeout");
+    ID id_push = rb_intern("push");
+
+    kq = NUM2INT(rb_iv_get(self, "@kq"));
+    next_timeout = rb_funcall(self, id_next_timeout, 0);
+    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 {
+        timeout.tv_sec = next_timeout / 1000;
+        timeout.tv_nsec = next_timeout % 1000 * 1000 * 1000;
+        n = kevent(kq, NULL, 0, events, KQUEUE_MAX_EVENTS, &timeout);
+    }
+
+    // TODO: Check if n >= 0
+    for (i = 0; i < n; i++) {
+        event_flags = events[i].filter;
+        if (event_flags & EVFILT_READ) {
+            obj_io = (VALUE) events[i].udata;
+            rb_funcall(readables, id_push, 1, obj_io);
+        }
+        
+        if (event_flags & EVFILT_WRITE) {
+            obj_io = (VALUE) events[i].udata;
+            rb_funcall(writables, id_push, 1, obj_io);
+        }
+    }
+
+    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) {
+    return rb_str_new_cstr("kqueue");
+}
+#endif
+#endif

data/ext/evt/select.h

@@ -0,0 +1,36 @@
+#ifndef SELECT_H
+#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) {
+    // return IO.select(@readable.keys, @writable.keys, [], next_timeout)
+    VALUE readable, writable, readable_keys, writable_keys, next_timeout;
+    ID id_select = rb_intern("select");
+    ID id_next_timeout = rb_intern("next_timeout");
+
+    readable = rb_iv_get(self, "@readable");
+    writable = rb_iv_get(self, "@writable");
+
+    readable_keys = rb_funcall(readable, rb_intern("keys"), 0);
+    writable_keys = rb_funcall(writable, rb_intern("keys"), 0);
+    next_timeout = rb_funcall(self, id_next_timeout, 0);
+
+    return rb_funcall(rb_cIO, id_select, 4, readable_keys, writable_keys, rb_ary_new(), next_timeout);
+}
+
+VALUE method_scheduler_backend(VALUE klass) {
+    return rb_str_new_cstr("ruby");
+}
+#endif

data/ext/evt/uring.h

@@ -0,0 +1,199 @@
+#ifndef URING_H
+#define URING_H
+#include "evt.h"
+#if HAVE_LIBURING_H
+void uring_payload_free(void* data) {
+    // TODO: free the uring_data structs if the payload is freed before all IO responds
+    io_uring_queue_exit((struct io_uring*) data);
+    xfree(data);
+}
+
+size_t uring_payload_size(const void* data) {
+    return sizeof(struct io_uring);
+}
+
+VALUE method_scheduler_init(VALUE self) {
+    int ret;
+    struct io_uring* ring;
+    ring = xmalloc(sizeof(struct io_uring));
+    ret = io_uring_queue_init(URING_ENTRIES, ring, 0);
+    if (ret < 0) {
+        rb_raise(rb_eIOError, "unable to initalize io_uring");
+    }
+    rb_iv_set(self, "@ring", TypedData_Wrap_Struct(Payload, &type_uring_payload, ring));
+    return Qnil;
+}
+
+VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
+    VALUE ring_obj;
+    struct io_uring* ring;
+    struct io_uring_sqe *sqe;
+    struct uring_data *data;
+    short poll_mask = 0;
+    ID id_fileno = rb_intern("fileno");
+
+    ring_obj = rb_iv_get(self, "@ring");
+    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
+    sqe = io_uring_get_sqe(ring);
+    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
+
+    int ruby_interest = NUM2INT(interest);
+    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+
+    if (ruby_interest & readable) {
+        poll_mask |= POLL_IN;
+    }
+
+    if (ruby_interest & writable) {
+        poll_mask |= POLL_OUT;
+    }
+
+    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
+    data->is_poll = true;
+    data->io = io;
+    data->poll_mask = poll_mask;
+    
+    io_uring_prep_poll_add(sqe, fd, poll_mask);
+    io_uring_sqe_set_data(sqe, data);
+    io_uring_submit(ring);
+    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) {
+    struct io_uring* ring;
+    struct io_uring_cqe *cqes[URING_MAX_EVENTS];
+    struct uring_data *data;
+    VALUE next_timeout, obj_io, readables, writables, iovs, result;
+    unsigned ret, i;
+    double time = 0.0;
+    short poll_events;
+
+    ID id_next_timeout = rb_intern("next_timeout");
+    ID id_push = rb_intern("push");
+    ID id_sleep = rb_intern("sleep");
+
+    next_timeout = rb_funcall(self, id_next_timeout, 0);
+    readables = rb_ary_new();
+    writables = rb_ary_new();
+    iovs = rb_ary_new();
+
+    TypedData_Get_Struct(rb_iv_get(self, "@ring"), struct io_uring, &type_uring_payload, ring);
+    ret = io_uring_peek_batch_cqe(ring, cqes, URING_MAX_EVENTS);
+
+    for (i = 0; i < ret; i++) {
+        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 (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 (ret == 0) {
+       if (next_timeout != Qnil && NUM2INT(next_timeout) != -1) {
+            // sleep
+            time = next_timeout / 1000;
+            rb_funcall(rb_mKernel, id_sleep, 1, rb_float_new(time));
+       } else {
+            rb_funcall(rb_mKernel, id_sleep, 1, rb_float_new(0.001)); // To avoid infinite loop
+       }
+    }
+
+    result = rb_ary_new2(3);
+    rb_ary_store(result, 0, readables);
+    rb_ary_store(result, 1, writables);
+    rb_ary_store(result, 2, iovs);
+
+    return result;
+}
+
+VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+    struct io_uring* ring;
+    struct uring_data *data;
+    char* read_buffer;
+    ID id_fileno = rb_intern("fileno");
+    // @iov[io] = Fiber.current
+    VALUE iovs = rb_iv_get(self, "@iovs");
+    rb_hash_aset(iovs, io, rb_funcall(Fiber, rb_intern("current"), 0));
+    // register
+    VALUE ring_obj = rb_iv_get(self, "@ring");
+    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
+    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
+
+    read_buffer = (char*) xmalloc(NUM2SIZET(length));
+    struct iovec iov = {
+        .iov_base = read_buffer,
+        .iov_len = NUM2SIZET(length),
+    };
+
+    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
+    data->is_poll = false;
+    data->io = io;
+    data->poll_mask = 0;
+    
+    io_uring_prep_readv(sqe, fd, &iov, 1, NUM2SIZET(offset));
+    io_uring_sqe_set_data(sqe, data);
+    io_uring_submit(ring);
+
+    VALUE result = rb_str_new(read_buffer, strlen(read_buffer));
+    if (buffer != Qnil) {
+        rb_str_append(buffer, result);
+    }
+
+    rb_funcall(Fiber, rb_intern("yield"), 0); // Fiber.yield
+    return result;
+}
+
+VALUE method_scheduler_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+    struct io_uring* ring;
+    struct uring_data *data;
+    char* write_buffer;
+    ID id_fileno = rb_intern("fileno");
+    // @iov[io] = Fiber.current
+    VALUE iovs = rb_iv_get(self, "@iovs");
+    rb_hash_aset(iovs, io, rb_funcall(Fiber, rb_intern("current"), 0));
+    // register
+    VALUE ring_obj = rb_iv_get(self, "@ring");
+    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
+    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
+
+    write_buffer = StringValueCStr(buffer);
+    struct iovec iov = {
+        .iov_base = write_buffer,
+        .iov_len = NUM2SIZET(length),
+    };
+
+    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
+    data->is_poll = false;
+    data->io = io;
+    data->poll_mask = 0;
+    
+    io_uring_prep_writev(sqe, fd, &iov, 1, NUM2SIZET(offset));
+    io_uring_sqe_set_data(sqe, data);
+    io_uring_submit(ring);
+    rb_funcall(Fiber, rb_intern("yield"), 0); // Fiber.yield
+    return length;
+}
+
+VALUE method_scheduler_backend(VALUE klass) {
+    return rb_str_new_cstr("liburing");
+}
+
+#endif
+#endif

data/lib/evt.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
+
 require_relative 'evt/version'
-require 'evt_ext'
 require_relative 'evt/scheduler'
+require_relative 'evt_ext'
 
 module Evt
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/evt/scheduler.rb

@@ -2,62 +2,55 @@
 
 require 'fiber'
 require 'socket'
+require 'io/nonblock'
 
-begin
-  require 'io/nonblock'
-rescue LoadError
-  # Ignore.
-end
-
-class IO
-  WAIT_READABLE = 1
-  WAIT_WRITABLE = 3
-end
-
-class Scheduler
+class Evt::Scheduler
   def initialize
     @readable = {}
     @writable = {}
+    @iovs = {}
     @waiting = {}
-    @blocking = []
+    
+    @lock = Mutex.new
+    @locking = 0
+    @ready = []
 
     @ios = ObjectSpace::WeakMap.new
     init_selector
   end
 
-  attr :readable
-  attr :writable
-  attr :waiting
-  attr :blocking
+  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
-
-      if offset < 0
-        return 0
-      else
-        return offset
-      end
+      offset < 0 ? 0 : offset
     end
   end
 
   def run
-    while @readable.any? or @writable.any? or @waiting.any?
-      # Can only handle file descriptors up to 1024...
-      readable, writable = self.wait
-
-      # puts "readable: #{readable}" if readable&.any?
-      # puts "writable: #{writable}" if writable&.any?
+    while @readable.any? or @writable.any? or @waiting.any? or @iovs.any? or @locking.positive?
+      readable, writable, iovs = self.wait
 
       readable&.each do |io|
-        @readable[io]&.resume
+        fiber = @readable.delete(io)
+        fiber&.resume
       end
 
       writable&.each do |io|
-        @writable[io]&.resume
+        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?
@@ -73,98 +66,56 @@ class Scheduler
           end
         end
       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
+      if @ready.any?
+        ready = nil
 
-  def wait_readable_fd(fd)
-    wait_readable(
-      for_fd(fd)
-    )
-  end
-
-  def wait_writable(io)
-    @writable[io] = Fiber.current
-    self.register(io, IO::WAIT_READABLE)
-    Fiber.yield
-    @writable.delete(io)
-    self.deregister(io)
-    return true
-  end
+        @lock.synchronize do
+          ready, @ready = @ready, []
+        end
 
-  def wait_writable_fd(fd)
-    wait_writable(
-      for_fd(fd)
-    )
+        ready.each do |fiber|
+          fiber.resume
+        end
+      end
+    end
   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
-
+  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
-
-    @readable.delete(io)
-    @writable.delete(io)
     self.deregister(io)
-
-    return true
+    true
   end
 
-
-  def wait_for_single_fd(fd, events, duration)
-    wait_any(
-      for_fd(fd),
-      events,
-      duration
-    )
+  def kernel_sleep(duration = nil)
+    @waiting[Fiber.current] = current_time + duration if duration.nil?
+    Fiber.yield
+    true
   end
 
-  def enter_blocking_region
-    # puts "Enter blocking region: #{caller.first}"
+  def mutex_lock(mutex)
+    @locking += 1
+    Fiber.yield
+  ensure
+    @locking -= 1
   end
 
-  def exit_blocking_region
-    # puts "Exit blocking region: #{caller.first}"
-    @blocking << caller.first
+  def mutex_unlock(mutex, fiber)
+    @lock.synchronize do
+      @ready << fiber
+    end
   end
 
   def fiber(&block)
     fiber = Fiber.new(blocking: false, &block)
-
     fiber.resume
-
-    return fiber
+    fiber
   end
 end

data/lib/evt/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Evt
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Delton Ding
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -32,17 +32,22 @@ extensions:
 - ext/evt/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
 - evt.gemspec
+- ext/evt/epoll.h
 - ext/evt/evt.c
+- ext/evt/evt.h
 - ext/evt/extconf.rb
+- ext/evt/iocp.h
+- ext/evt/kqueue.h
+- ext/evt/select.h
+- ext/evt/uring.h
 - lib/evt.rb
 - lib/evt/scheduler.rb
 - lib/evt/version.rb
@@ -60,14 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.1
+      version: 2.8.0.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.2
 signing_key:
 specification_version: 4
 summary: A low-level Event Handler designed for Ruby 3 Scheduler

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - ruby-head
-before_install: gem install bundler -v 2.1.4

data/Gemfile.lock

@@ -1,24 +0,0 @@
-PATH
-  remote: .
-  specs:
-    evt (0.1.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    minitest (5.14.1)
-    rake (12.3.3)
-    rake-compiler (1.1.1)
-      rake
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  evt!
-  minitest (~> 5.0)
-  rake (~> 12.0)
-  rake-compiler (~> 1.0)
-
-BUNDLED WITH
-   2.2.0.dev