uringmachine 0.4 → 0.5.1

data/ext/um/um.h

@@ -1,7 +1,7 @@
 #ifndef UM_H
 #define UM_H
 
-#include "ruby.h"
+#include <ruby.h>
 #include <liburing.h>
 
 // debugging
@@ -20,38 +20,66 @@
 #define likely(cond)	__builtin_expect(!!(cond), 1)
 #endif
 
-enum op_state {
-  OP_initial,     // initial state
-  OP_submitted,   // op has been submitted (SQE prepared)
-  OP_completed,   // op has been completed (CQE processed)
-  OP_cancelled,   // op is cancelled (after CQE is processed)
-  OP_abandonned,  // op is abandonned by fiber (before CQE is processed)
-  OP_schedule,    // the corresponding fiber is scheduled
+enum op_kind {
+  OP_TIMEOUT,
+  OP_SCHEDULE,
+
+  OP_SLEEP,
+  OP_READ,
+  OP_WRITE,
+  OP_CLOSE,
+  OP_ACCEPT,
+  OP_RECV,
+  OP_SEND,
+  OP_SOCKET,
+  OP_CONNECT,
+  OP_BIND,
+  OP_LISTEN,
+  OP_GETSOCKOPT,
+  OP_SETSOCKOPT,
+
+  OP_FUTEX_WAIT,
+  OP_FUTEX_WAKE,
+
+  OP_ACCEPT_MULTISHOT,
+  OP_READ_MULTISHOT,
+  OP_RECV_MULTISHOT
 };
 
-struct um_result_entry {
-  struct um_result_entry *next;
+#define OP_F_COMPLETED        (1U << 0)
+#define OP_F_TRANSIENT        (1U << 1)
+#define OP_F_ASYNC            (1U << 2)
+#define OP_F_IGNORE_CANCELED  (1U << 3)
+#define OP_F_MULTISHOT        (1U << 4)
 
-  __s32 result;
+struct um_op_result {
+  __s32 res;
   __u32 flags;
+  struct um_op_result *next;
 };
 
 struct um_op {
-  enum op_state state;
   struct um_op *prev;
   struct um_op *next;
 
-  // linked list for multishot results
-  struct um_result_entry *results_head;
-  struct um_result_entry *results_tail;
+  enum op_kind kind;
+  unsigned flags;
 
   VALUE fiber;
-  VALUE resume_value;
-  int is_multishot;
-  struct __kernel_timespec ts;
+  VALUE value;
+  VALUE async_op;
 
-  int cqe_result;
-  int cqe_flags;
+  struct um_op_result result;
+  struct um_op_result *multishot_result_tail;
+  unsigned multishot_result_count;
+
+  struct __kernel_timespec ts; // used for timeout operation
+};
+
+struct um_buffer {
+  struct um_buffer *next;
+  void *ptr;
+  long len;
 };
 
 struct buf_ring_descriptor {
@@ -66,11 +94,9 @@ struct buf_ring_descriptor {
 #define BUFFER_RING_MAX_COUNT 10
 
 struct um {
-  struct um_op *op_freelist;
-  struct um_result_entry *result_freelist;
+  VALUE self;
 
-  struct um_op *runqueue_head;
-  struct um_op *runqueue_tail;
+  struct um_buffer *buffer_freelist;
 
   struct io_uring ring;
 
@@ -80,48 +106,105 @@ struct um {
 
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
   unsigned int buffer_ring_count;
+
+  struct um_op *transient_head;
+  struct um_op *runqueue_head;
+  struct um_op *runqueue_tail;
+
+  struct um_op *op_freelist;
+  struct um_op_result *result_freelist;
+};
+
+struct um_mutex {
+  VALUE self;
+  uint32_t state;
+};
+
+struct um_queue_entry {
+  struct um_queue_entry *prev;
+  struct um_queue_entry *next;
+  VALUE value;
+};
+
+struct um_queue {
+  VALUE self;
+
+  struct um_queue_entry *head;
+  struct um_queue_entry *tail;
+  struct um_queue_entry *free_head;
+  
+  uint32_t num_waiters;
+  uint32_t state;
+  uint32_t count;
+};
+
+struct um_async_op {
+  VALUE self;
+
+  struct um *machine;
+  struct um_op *op;
 };
 
 extern VALUE cUM;
+extern VALUE cMutex;
+extern VALUE cQueue;
+extern VALUE cAsyncOp;
 
-void um_setup(struct um *machine);
+struct um *um_get_machine(VALUE self);
+void um_setup(VALUE self, struct um *machine);
 void um_teardown(struct um *machine);
-void um_free_op_linked_list(struct um *machine, struct um_op *op);
-void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry);
+
+struct um_op *um_op_alloc(struct um *machine);
+void um_op_free(struct um *machine, struct um_op *op);
+void um_op_clear(struct um *machine, struct um_op *op);
+void um_op_transient_add(struct um *machine, struct um_op *op);
+void um_op_transient_remove(struct um *machine, struct um_op *op);
+void um_op_list_mark(struct um *machine, struct um_op *head);
+void um_op_list_compact(struct um *machine, struct um_op *head);
+
+void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags);
+void um_op_multishot_results_clear(struct um *machine, struct um_op *op);
+
+void um_runqueue_push(struct um *machine, struct um_op *op);
+struct um_op *um_runqueue_shift(struct um *machine);
+
+struct um_buffer *um_buffer_checkout(struct um *machine, int len);
+void um_buffer_checkin(struct um *machine, struct um_buffer *buffer);
+void um_free_buffer_linked_list(struct um *machine);
 
 struct __kernel_timespec um_double_to_timespec(double value);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
-void um_raise_on_system_error(int result);
 
+#define raise_if_exception(v) (um_value_is_exception_p(v) ? um_raise_exception(v) : v)
+
+void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind);
+void um_raise_on_error_result(int result);
 void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
 void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags);
-
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
 VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
 
+struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
+
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
+void um_submit_cancel_op(struct um *machine, struct um_op *op);
+void um_cancel_and_wait(struct um *machine, struct um_op *op);
+int um_check_completion(struct um *machine, struct um_op *op);
 
-void um_op_checkin(struct um *machine, struct um_op *op);
-struct um_op* um_op_checkout(struct um *machine);
-void um_op_result_push(struct um *machine, struct um_op *op, __s32 result, __u32 flags);
-int um_op_result_shift(struct um *machine, struct um_op *op, __s32 *result, __u32 *flags);
-
-struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber);
-void um_runqueue_push(struct um *machine, struct um_op *op);
-struct um_op *um_runqueue_shift(struct um *machine);
-void um_runqueue_unshift(struct um *machine, struct um_op *op);
+#define um_op_completed_p(op) ((op)->flags & OP_F_COMPLETED)
 
 void um_schedule(struct um *machine, VALUE fiber, VALUE value);
-void um_interrupt(struct um *machine, VALUE fiber, VALUE value);
 VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 
 VALUE um_sleep(struct um *machine, double duration);
 VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
-VALUE um_write(struct um *machine, int fd, VALUE buffer, int len);
+VALUE um_write(struct um *machine, int fd, VALUE str, int len);
 VALUE um_close(struct um *machine, int fd);
+VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
+VALUE um_waitpid(struct um *machine, int pid, int options);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -129,9 +212,35 @@ VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint fla
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen);
 VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags);
+VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);
 VALUE um_listen(struct um *machine, int fd, int backlog);
+VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
+VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value);
+
+void um_async_op_set(VALUE self, struct um *machine, struct um_op *op);
+VALUE um_async_op_await(struct um_async_op *async_op);
+void um_async_op_cancel(struct um_async_op *async_op);
+
+VALUE um_prep_timeout(struct um *machine, double interval);
+
+struct um_mutex *Mutex_data(VALUE self);
+struct um_queue *Queue_data(VALUE self);
+
+void um_mutex_init(struct um_mutex *mutex);
+VALUE um_mutex_synchronize(struct um *machine, uint32_t *state);
+
+void um_queue_init(struct um_queue *queue);
+void um_queue_free(struct um_queue *queue);
+void um_queue_mark(struct um_queue *queue);
+void um_queue_compact(struct um_queue *queue);
+VALUE um_queue_push(struct um *machine, struct um_queue *queue, VALUE value);
+VALUE um_queue_pop(struct um *machine, struct um_queue *queue);
+VALUE um_queue_unshift(struct um *machine, struct um_queue *queue, VALUE value);
+VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
 void um_define_net_constants(VALUE mod);
 
+// void Init_micro_ssl(VALUE mod);
+
 #endif // UM_H

data/ext/um/um_async_op.c

@@ -0,0 +1,40 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE um_prep_timeout(struct um *machine, double interval) {
+  static ID ID_new = 0;
+  if (!ID_new) ID_new = rb_intern("new");
+
+  struct um_op *op = malloc(sizeof(struct um_op));
+  um_prep_op(machine, op, OP_TIMEOUT);
+  op->ts = um_double_to_timespec(interval);
+  op->flags = OP_F_TRANSIENT | OP_F_ASYNC;
+
+  VALUE obj = rb_funcall(cAsyncOp, rb_intern_const("new"), 0);
+  um_async_op_set(obj, machine, op);
+
+  RB_OBJ_WRITE(machine->self, &op->async_op, obj);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
+
+  um_op_transient_add(machine, op);
+
+  return obj;
+}
+
+VALUE um_async_op_await(struct um_async_op *async_op) {
+  RB_OBJ_WRITE(async_op->machine->self, &async_op->op->fiber, rb_fiber_current());
+  async_op->op->flags &= ~OP_F_ASYNC;
+
+  VALUE ret = um_fiber_switch(async_op->machine);
+  if (!um_op_completed_p(async_op->op))
+    um_cancel_and_wait(async_op->machine, async_op->op);
+
+  raise_if_exception(ret);
+  return INT2NUM(async_op->op->result.res);
+}
+
+void um_async_op_cancel(struct um_async_op *async_op) {
+  um_submit_cancel_op(async_op->machine, async_op->op);
+}

data/ext/um/um_async_op_class.c

@@ -0,0 +1,136 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE cAsyncOp;
+
+VALUE SYM_timeout;
+
+static void AsyncOp_mark(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  rb_gc_mark_movable(async_op->self);
+  rb_gc_mark_movable(async_op->machine->self);
+}
+
+static void AsyncOp_compact(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  async_op->self = rb_gc_location(async_op->self);
+}
+
+static size_t AsyncOp_size(const void *ptr) {
+  return sizeof(struct um_async_op);
+}
+
+static void AsyncOp_free(void *ptr) {
+  struct um_async_op *async_op = ptr;
+  um_op_free(async_op->machine, async_op->op);
+  free(ptr);
+}
+
+static const rb_data_type_t AsyncOp_type = {
+    "UringMachine::AsyncOp",
+    {AsyncOp_mark, AsyncOp_free, AsyncOp_size, AsyncOp_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE AsyncOp_allocate(VALUE klass) {
+  struct um_async_op *async_op = malloc(sizeof(struct um_async_op));
+  return TypedData_Wrap_Struct(klass, &AsyncOp_type, async_op);
+}
+
+inline struct um_async_op *AsyncOp_data(VALUE self) {
+  return RTYPEDDATA_DATA(self);
+}
+
+VALUE AsyncOp_initialize(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  memset(async_op, 0, sizeof(struct um_async_op));
+  async_op->self = self;
+  return self;
+}
+
+void um_async_op_set(VALUE self, struct um *machine, struct um_op *op) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  async_op->machine = machine;
+  async_op->op = op;
+}
+
+inline void raise_on_missing_op(struct um_async_op *async_op) {
+  if (!async_op->op)
+    rb_raise(rb_eRuntimeError, "Missing op");
+}
+
+inline int async_op_is_done(struct um_async_op *async_op) {
+  return (async_op->op->flags & OP_F_COMPLETED);
+}
+
+VALUE AsyncOp_kind(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  switch(async_op->op->kind) {
+    case OP_TIMEOUT:
+      return SYM_timeout;
+    default:
+      rb_raise(rb_eRuntimeError, "Invalid op kind");
+  }
+}
+
+VALUE AsyncOp_done_p(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  return async_op_is_done(async_op) ? Qtrue : Qfalse;
+}
+
+VALUE AsyncOp_result(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  return async_op_is_done(async_op) ? INT2NUM(async_op->op->result.res) : Qnil;
+}
+
+VALUE AsyncOp_cancelled_p(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (!async_op_is_done(async_op)) return Qnil;
+
+  return (async_op->op->result.res == -ECANCELED) ? Qtrue : Qfalse;
+}
+
+VALUE AsyncOp_await(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (async_op_is_done(async_op))
+    return INT2NUM(async_op->op->result.res);
+
+  return um_async_op_await(async_op);
+}
+
+VALUE AsyncOp_cancel(VALUE self) {
+  struct um_async_op *async_op = AsyncOp_data(self);
+  raise_on_missing_op(async_op);
+
+  if (!async_op_is_done(async_op))
+    um_async_op_cancel(async_op);
+
+  return self;
+}
+
+void Init_AsyncOp(void) {
+  cAsyncOp = rb_define_class_under(cUM, "AsyncOp", rb_cObject);
+  rb_define_alloc_func(cAsyncOp, AsyncOp_allocate);
+
+  rb_define_method(cAsyncOp, "initialize", AsyncOp_initialize, 0);
+  rb_define_method(cAsyncOp, "kind", AsyncOp_kind, 0);
+  rb_define_method(cAsyncOp, "done?", AsyncOp_done_p, 0);
+  rb_define_method(cAsyncOp, "result", AsyncOp_result, 0);
+  rb_define_method(cAsyncOp, "cancelled?", AsyncOp_cancelled_p, 0);
+
+  rb_define_method(cAsyncOp, "await", AsyncOp_await, 0);
+  rb_define_method(cAsyncOp, "join", AsyncOp_await, 0);
+  rb_define_method(cAsyncOp, "cancel", AsyncOp_cancel, 0);
+
+  SYM_timeout = ID2SYM(rb_intern("timeout"));
+}

data/ext/um/um_buffer.c

@@ -0,0 +1,49 @@
+#include "um.h"
+
+inline long buffer_size(long len) {
+  len--;
+  len |= len >> 1;
+  len |= len >> 2;
+  len |= len >> 4;
+  len |= len >> 8;
+  len |= len >> 16;
+  len++;
+  return (len > 4096) ? len : 4096;
+}
+
+inline struct um_buffer *um_buffer_checkout(struct um *machine, int len) {
+  struct um_buffer *buffer = machine->buffer_freelist;
+  if (buffer)
+    machine->buffer_freelist = buffer->next;
+  else {
+    buffer = malloc(sizeof(struct um_buffer));
+    memset(buffer, 0, sizeof(struct um_buffer));
+  }
+
+  if (buffer->len < len) {
+    if (buffer->ptr) {
+      free(buffer->ptr);
+      buffer->ptr = NULL;
+    }
+
+    buffer->len = buffer_size(len);
+    if (posix_memalign(&buffer->ptr, 4096, buffer->len))
+      rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
+  }
+  return buffer;
+}
+
+inline void um_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
+  buffer->next = machine->buffer_freelist;
+  machine->buffer_freelist = buffer;
+}
+
+inline void um_free_buffer_linked_list(struct um *machine) {
+  struct um_buffer *buffer = machine->buffer_freelist;
+  while (buffer) {
+    struct um_buffer *next = buffer->next;
+    if (buffer->ptr) free(buffer->ptr);
+    free(buffer);
+    buffer = next;
+  }
+}