evt 0.1.3 → 0.2.3

data/ext/evt/evt.h

@@ -1,11 +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 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,23 @@
 require 'mkmf'
 extension_name = 'evt_ext'
-create_header
 dir_config(extension_name)
-create_makefile(extension_name)
+
+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

@@ -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,87 @@
+#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|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) {
+    // One-shot mode
+    return Qnil;
+}
+
+VALUE method_scheduler_wait(VALUE self) {
+    int n, kq, i;
+    u_short event_flags = 0;
+    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");
+    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();
+
+    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);
+
+    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,200 @@
+#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);
+        }
+        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, 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