uringmachine 0.5 → 0.6

data/ext/um/um.c

@@ -5,7 +5,6 @@ void um_setup(VALUE self, struct um *machine) {
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
-  RB_OBJ_WRITE(self, &machine->poll_fiber, Qnil);
 
   unsigned prepared_limit = 4096;
   unsigned flags = IORING_SETUP_SUBMIT_ALL | IORING_SETUP_COOP_TASKRUN;
@@ -76,7 +75,7 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
   if (unlikely((cqe->res == -ECANCELED) && (op->flags & OP_F_IGNORE_CANCELED))) return;
 
   op->flags |= OP_F_COMPLETED;
-  if (unlikely(op->flags & OP_F_TRANSIENT))
+  if (op->flags & OP_F_TRANSIENT)
     um_op_transient_remove(machine, op);
 
   if (op->flags & OP_F_MULTISHOT) {
@@ -89,6 +88,8 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
     op->result.flags  = cqe->flags;
   }
 
+  if (op->flags & OP_F_ASYNC) return;
+  
   um_runqueue_push(machine, op);
 }
 
@@ -181,7 +182,7 @@ inline VALUE um_fiber_switch(struct um *machine) {
   }
 }
 
-static inline void um_submit_cancel_op(struct um *machine, struct um_op *op) {
+void um_submit_cancel_op(struct um *machine, struct um_op *op) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
   io_uring_prep_cancel64(sqe, (long long)op, 0);
 }
@@ -216,6 +217,8 @@ inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind)
     case OP_ACCEPT_MULTISHOT:
     case OP_READ_MULTISHOT:
     case OP_RECV_MULTISHOT:
+    case OP_TIMEOUT_MULTISHOT:
+    case OP_SLEEP_MULTISHOT:
       op->flags |= OP_F_MULTISHOT;
     default:
   }
@@ -261,7 +264,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   static ID ID_new = 0;
   if (!ID_new) ID_new = rb_intern("new");
 
-  struct um_op *op = malloc(sizeof(struct um_op));
+  struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_TIMEOUT);
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
@@ -297,6 +300,33 @@ VALUE um_sleep(struct um *machine, double duration) {
   return raise_if_exception(ret);
 }
 
+// VALUE um_periodically(struct um *machine, double interval) {
+//   struct um_op op;
+//   VALUE ret = Qnil;
+//   um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+//   op.ts = um_double_to_timespec(interval);
+//   op.flags |= OP_F_MULTISHOT;
+//   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+//   io_uring_prep_timeout(sqe, &op.ts, 0, IORING_TIMEOUT_MULTISHOT);
+
+//   while (true) {
+//     ret = um_fiber_switch(machine);
+
+//     if (!um_op_completed_p(&op)) {
+//       um_cancel_and_wait(machine, &op);
+//       break;
+//     }
+//     else {
+//       if (op.result.res != -ETIME) um_raise_on_error_result(op.result.res);
+//       ret = DBL2NUM(interval);
+//     }
+//   }
+
+//   RB_GC_GUARD(ret);
+//   return raise_if_exception(ret);
+
+// }
+
 inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
   struct um_op op;
   um_prep_op(machine, &op, OP_READ);
@@ -701,3 +731,44 @@ VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_begin, (VALUE)&ctx, multishot_ensure, (VALUE)&ctx);
 }
+
+VALUE periodically_begin(VALUE arg) {
+  struct op_ctx *ctx = (struct op_ctx *)arg;
+  struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
+  io_uring_prep_timeout(sqe, &ctx->ts, 0, IORING_TIMEOUT_MULTISHOT);
+
+  while (true) {
+    VALUE ret = um_fiber_switch(ctx->machine);
+    if (!um_op_completed_p(ctx->op))
+      return raise_if_exception(ret);
+
+    int more = false;
+    struct um_op_result *result = &ctx->op->result;
+    while (result) {
+      more = (result->flags & IORING_CQE_F_MORE);
+      if (result->res < 0 && result->res != -ETIME) {
+        um_op_multishot_results_clear(ctx->machine, ctx->op);
+        return Qnil;
+      }
+      rb_yield(Qnil);
+      result = result->next;
+    }
+    um_op_multishot_results_clear(ctx->machine, ctx->op);
+    if (more)
+      ctx->op->flags &= ~OP_F_COMPLETED;
+    else
+      break;
+  }
+
+  return Qnil;
+}
+
+VALUE um_periodically(struct um *machine, double interval) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+  op.ts = um_double_to_timespec(interval);
+  
+  struct op_ctx ctx = { .machine = machine, .op = &op, .ts = op.ts, .read_buf = NULL };
+  return rb_ensure(periodically_begin, (VALUE)&ctx, multishot_ensure, (VALUE)&ctx);
+}
+

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
@@ -43,13 +43,16 @@ enum op_kind {
 
   OP_ACCEPT_MULTISHOT,
   OP_READ_MULTISHOT,
-  OP_RECV_MULTISHOT
+  OP_RECV_MULTISHOT,
+  OP_TIMEOUT_MULTISHOT,
+  OP_SLEEP_MULTISHOT
 };
 
-#define OP_F_COMPLETED        (1U << 0)
-#define OP_F_TRANSIENT        (1U << 1)
-#define OP_F_IGNORE_CANCELED  (1U << 2)
-#define OP_F_MULTISHOT        (1U << 3)
+#define OP_F_COMPLETED        (1U << 0) // op is completed (set on each CQE for multishot ops)
+#define OP_F_TRANSIENT        (1U << 1) // op is heap allocated
+#define OP_F_ASYNC            (1U << 2) // op belongs to an AsyncOp
+#define OP_F_IGNORE_CANCELED  (1U << 3) // CQE with -ECANCEL should be ignored
+#define OP_F_MULTISHOT        (1U << 4) // op is multishot
 
 struct um_op_result {
   __s32 res;
@@ -66,6 +69,7 @@ struct um_op {
 
   VALUE fiber;
   VALUE value;
+  VALUE async_op;
 
   struct um_op_result result;
   struct um_op_result *multishot_result_tail;
@@ -93,7 +97,6 @@ struct buf_ring_descriptor {
 
 struct um {
   VALUE self;
-  VALUE poll_fiber;
 
   struct um_buffer *buffer_freelist;
 
@@ -137,10 +140,19 @@ struct um_queue {
   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;
 
+struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine);
 void um_teardown(struct um *machine);
 
@@ -179,6 +191,7 @@ 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);
 
@@ -188,6 +201,7 @@ void um_schedule(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_periodically(struct um *machine, double interval);
 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 str, int len);
@@ -207,6 +221,12 @@ 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);
 
@@ -224,4 +244,6 @@ 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_class.c

@@ -14,7 +14,6 @@ static void UM_mark(void *ptr) {
 static void UM_compact(void *ptr) {
   struct um *machine = ptr;
   machine->self = rb_gc_location(machine->self);
-  machine->poll_fiber = rb_gc_location(machine->poll_fiber);
 
   um_op_list_compact(machine, machine->transient_head);
   um_op_list_compact(machine, machine->runqueue_head);
@@ -41,7 +40,7 @@ static VALUE UM_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &UM_type, machine);
 }
 
-inline struct um *get_machine(VALUE self) {
+inline struct um *um_get_machine(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
   if (!machine->ring_initialized)
     rb_raise(rb_eRuntimeError, "Machine not initialized");
@@ -55,45 +54,50 @@ VALUE UM_initialize(VALUE self) {
 }
 
 VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   int bgid = um_setup_buffer_ring(machine, NUM2UINT(size), NUM2UINT(count));
   return INT2NUM(bgid);
 }
 
 VALUE UM_pending_count(VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return INT2NUM(machine->pending_count);
 }
 
 VALUE UM_snooze(VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   um_schedule(machine, rb_fiber_current(), Qnil);
   return um_await(machine);
 }
 
 VALUE UM_yield(VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_await(machine);
 }
 
 VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   um_schedule(machine, fiber, value);
   return self;
 }
 
 VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_timeout(machine, interval, class);
 }
 
 VALUE UM_sleep(VALUE self, VALUE duration) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_sleep(machine, NUM2DBL(duration));
 }
 
+VALUE UM_periodically(VALUE self, VALUE interval) {
+  struct um *machine = um_get_machine(self);
+  return um_periodically(machine, NUM2DBL(interval));
+}
+
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   VALUE fd;
   VALUE buffer;
   VALUE maxlen;
@@ -108,7 +112,7 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
 
 VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
 #ifdef HAVE_IO_URING_PREP_READ_MULTISHOT
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
 #else
   rb_raise(rb_eRuntimeError, "Not supported by kernel");
@@ -116,7 +120,7 @@ VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
 }
 
 VALUE UM_write(int argc, VALUE *argv, VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   VALUE fd;
   VALUE buffer;
   VALUE len;
@@ -127,27 +131,27 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE UM_close(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_close(machine, NUM2INT(fd));
 }
 
 VALUE UM_accept(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_accept(machine, NUM2INT(fd));
 }
 
 VALUE UM_accept_each(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_accept_each(machine, NUM2INT(fd));
 }
 
 VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_socket(machine, NUM2INT(domain), NUM2INT(type), NUM2INT(protocol), NUM2UINT(flags));
 }
 
 VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
 
   struct sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
@@ -159,17 +163,17 @@ VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
 }
 
 VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
 }
 
 VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_recv(machine, NUM2INT(fd), buffer, NUM2INT(maxlen), NUM2INT(flags));
 }
 
 VALUE UM_recv_each(VALUE self, VALUE fd, VALUE bgid, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_recv_each(machine, NUM2INT(fd), NUM2INT(bgid), NUM2INT(flags));
 }
 
@@ -181,7 +185,7 @@ VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
   addr.sin_port = htons(NUM2INT(port));
 
 #ifdef HAVE_IO_URING_PREP_BIND
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_bind(machine, NUM2INT(fd), (struct sockaddr *)&addr, sizeof(addr));
 #else
   int res = bind(NUM2INT(fd), (struct sockaddr *)&addr, sizeof(addr));
@@ -193,7 +197,7 @@ VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
 
 VALUE UM_listen(VALUE self, VALUE fd, VALUE backlog) {
 #ifdef HAVE_IO_URING_PREP_LISTEN
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_listen(machine, NUM2INT(fd), NUM2INT(backlog));
 #else
   int res = listen(NUM2INT(fd), NUM2INT(backlog));
@@ -215,43 +219,43 @@ static inline int numeric_value(VALUE value) {
 }
 
 VALUE UM_getsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_getsockopt(machine, NUM2INT(fd), NUM2INT(level), NUM2INT(opt));
 }
 
 VALUE UM_setsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt, VALUE value) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_setsockopt(machine, NUM2INT(fd), NUM2INT(level), NUM2INT(opt), numeric_value(value));
 }
 
 #ifdef HAVE_IO_URING_PREP_FUTEX
 
 VALUE UM_mutex_synchronize(VALUE self, VALUE mutex) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   struct um_mutex *mutex_data = Mutex_data(mutex);
   return um_mutex_synchronize(machine, &mutex_data->state);
 }
 
 VALUE UM_queue_push(VALUE self, VALUE queue, VALUE value) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   struct um_queue *que = Queue_data(queue);
   return um_queue_push(machine, que, value);
 }
 
 VALUE UM_queue_pop(VALUE self, VALUE queue) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   struct um_queue *que = Queue_data(queue);
   return um_queue_pop(machine, que);
 }
 
 VALUE UM_queue_unshift(VALUE self, VALUE queue, VALUE value) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   struct um_queue *que = Queue_data(queue);
   return um_queue_unshift(machine, que, value);
 }
 
 VALUE UM_queue_shift(VALUE self, VALUE queue) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   struct um_queue *que = Queue_data(queue);
   return um_queue_shift(machine, que);
 }
@@ -270,7 +274,7 @@ VALUE UM_open_ensure(VALUE arg) {
 }
 
 VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   // TODO: take optional perm (mode) arg
   VALUE fd = um_open(machine, pathname, NUM2INT(flags), 0666);
   if (rb_block_given_p()) {
@@ -282,10 +286,15 @@ VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
 }
 
 VALUE UM_waitpid(VALUE self, VALUE pid, VALUE options) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
 }
 
+VALUE UM_prep_timeout(VALUE self, VALUE interval) {
+  struct um *machine = um_get_machine(self);
+  return um_prep_timeout(machine, NUM2DBL(interval));
+}
+
 VALUE UM_pipe(VALUE self) {
   int fds[2];
   int ret = pipe(fds);
@@ -325,6 +334,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "read", UM_read, -1);
   rb_define_method(cUM, "read_each", UM_read_each, 2);
   rb_define_method(cUM, "sleep", UM_sleep, 1);
+  rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
 
   rb_define_method(cUM, "waitpid", UM_waitpid, 2);
@@ -341,6 +351,8 @@ void Init_UM(void) {
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
   rb_define_method(cUM, "socket", UM_socket, 4);
 
+  rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
+
   #ifdef HAVE_IO_URING_PREP_FUTEX
   rb_define_method(cUM, "pop", UM_queue_pop, 1);
   rb_define_method(cUM, "push", UM_queue_push, 2);
@@ -349,5 +361,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "unshift", UM_queue_unshift, 2);
   #endif
 
+  // Init_micro_ssl(cUM);
+
   um_define_net_constants(cUM);
 }