uringmachine 0.4 → 0.5

data/ext/um/um.h

@@ -20,38 +20,64 @@
 #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_IGNORE_CANCELED  (1U << 2)
+#define OP_F_MULTISHOT        (1U << 3)
 
-  __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;
 
-  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 +92,10 @@ 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;
+  VALUE poll_fiber;
 
-  struct um_op *runqueue_head;
-  struct um_op *runqueue_tail;
+  struct um_buffer *buffer_freelist;
 
   struct io_uring ring;
 
@@ -80,48 +105,95 @@ 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;
 };
 
 extern VALUE cUM;
+extern VALUE cMutex;
+extern VALUE cQueue;
 
-void um_setup(struct um *machine);
+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_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,8 +201,26 @@ 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);
+
+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);
 

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;
+  }
+}

data/ext/um/um_class.c

@@ -4,13 +4,20 @@
 VALUE cUM;
 
 static void UM_mark(void *ptr) {
-  // struct um *machine = ptr;
-  // um_runqueue_mark(machine);
+  struct um *machine = ptr;
+  rb_gc_mark_movable(machine->self);
+
+  um_op_list_mark(machine, machine->transient_head);
+  um_op_list_mark(machine, machine->runqueue_head);
 }
 
 static void UM_compact(void *ptr) {
-  // struct um *machine = ptr;
-  // um_runqueue_compact(machine);
+  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);
 }
 
 static void UM_free(void *ptr) {
@@ -43,7 +50,7 @@ inline struct um *get_machine(VALUE self) {
 
 VALUE UM_initialize(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
-  um_setup(machine);
+  um_setup(self, machine);
   return self;
 }
 
@@ -55,7 +62,7 @@ VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
 
 VALUE UM_pending_count(VALUE self) {
   struct um *machine = get_machine(self);
-  return INT2FIX(machine->pending_count);
+  return INT2NUM(machine->pending_count);
 }
 
 VALUE UM_snooze(VALUE self) {
@@ -75,12 +82,6 @@ VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
   return self;
 }
 
-VALUE UM_interrupt(VALUE self, VALUE fiber, VALUE value) {
-  struct um *machine = get_machine(self);
-  um_interrupt(machine, fiber, value);
-  return self;
-}
-
 VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
   struct um *machine = get_machine(self);
   return um_timeout(machine, interval, class);
@@ -88,8 +89,7 @@ VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
 
 VALUE UM_sleep(VALUE self, VALUE duration) {
   struct um *machine = get_machine(self);
-  um_sleep(machine, NUM2DBL(duration));
-  return duration;
+  return um_sleep(machine, NUM2DBL(duration));
 }
 
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
@@ -107,8 +107,12 @@ 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);
   return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
+#else
+  rb_raise(rb_eRuntimeError, "Not supported by kernel");
+#endif
 }
 
 VALUE UM_write(int argc, VALUE *argv, VALUE self) {
@@ -164,6 +168,11 @@ VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
   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);
+  return um_recv_each(machine, NUM2INT(fd), NUM2INT(bgid), NUM2INT(flags));
+}
+
 VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
   struct sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
@@ -194,6 +203,104 @@ VALUE UM_listen(VALUE self, VALUE fd, VALUE backlog) {
 #endif
 }
 
+static inline int numeric_value(VALUE value) {
+  switch (TYPE(value)) {
+    case T_TRUE:
+      return 1;
+    case T_FALSE:
+      return 0;
+    default:
+      return NUM2INT(value);
+  }
+}
+
+VALUE UM_getsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt) {
+  struct um *machine = 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);
+  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_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_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_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_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_queue *que = Queue_data(queue);
+  return um_queue_shift(machine, que);
+}
+
+#endif
+
+struct um_open_ctx {
+  VALUE self;
+  VALUE fd;
+};
+
+VALUE UM_open_ensure(VALUE arg) {
+  struct um_open_ctx *ctx = (struct um_open_ctx *)arg;
+  UM_close(ctx->self, ctx->fd);
+  return ctx->self;
+}
+
+VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
+  struct um *machine = get_machine(self);
+  // TODO: take optional perm (mode) arg
+  VALUE fd = um_open(machine, pathname, NUM2INT(flags), 0666);
+  if (rb_block_given_p()) {
+    struct um_open_ctx ctx = { self, fd };
+    return rb_ensure(rb_yield, fd, UM_open_ensure, (VALUE)&ctx);
+  }
+  else
+    return fd;
+}
+
+VALUE UM_waitpid(VALUE self, VALUE pid, VALUE options) {
+  struct um *machine = get_machine(self);
+  return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
+}
+
+VALUE UM_pipe(VALUE self) {
+  int fds[2];
+  int ret = pipe(fds);
+  if (ret) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  return rb_ary_new_from_args(2, INT2NUM(fds[0]), INT2NUM(fds[1]));
+}
+
+VALUE UM_kernel_version(VALUE self) {
+  return INT2NUM(UM_KERNEL_VERSION);
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
@@ -201,29 +308,46 @@ void Init_UM(void) {
   rb_define_alloc_func(cUM, UM_allocate);
 
   rb_define_method(cUM, "initialize", UM_initialize, 0);
-  rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
   rb_define_method(cUM, "pending_count", UM_pending_count, 0);
+  rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
+
+  rb_define_singleton_method(cUM, "pipe", UM_pipe, 0);
+  rb_define_singleton_method(cUM, "kernel_version", UM_kernel_version, 0);
+
 
-  rb_define_method(cUM, "snooze", UM_snooze, 0);
-  rb_define_method(cUM, "yield", UM_yield, 0);
   rb_define_method(cUM, "schedule", UM_schedule, 2);
-  rb_define_method(cUM, "interrupt", UM_interrupt, 2);
+  rb_define_method(cUM, "snooze", UM_snooze, 0);
   rb_define_method(cUM, "timeout", UM_timeout, 2);
+  rb_define_method(cUM, "yield", UM_yield, 0);
 
-  rb_define_method(cUM, "sleep", UM_sleep, 1);
+  rb_define_method(cUM, "close", UM_close, 1);
+  rb_define_method(cUM, "open", UM_open, 2);
   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, "write", UM_write, -1);
-  rb_define_method(cUM, "close", UM_close, 1);
+
+  rb_define_method(cUM, "waitpid", UM_waitpid, 2);
 
   rb_define_method(cUM, "accept", UM_accept, 1);
   rb_define_method(cUM, "accept_each", UM_accept_each, 1);
-  rb_define_method(cUM, "socket", UM_socket, 4);
-  rb_define_method(cUM, "connect", UM_connect, 3);
-  rb_define_method(cUM, "send", UM_send, 4);
-  rb_define_method(cUM, "recv", UM_recv, 4);
   rb_define_method(cUM, "bind", UM_bind, 3);
+  rb_define_method(cUM, "connect", UM_connect, 3);
+  rb_define_method(cUM, "getsockopt", UM_getsockopt, 3);
   rb_define_method(cUM, "listen", UM_listen, 2);
+  rb_define_method(cUM, "recv", UM_recv, 4);
+  rb_define_method(cUM, "recv_each", UM_recv_each, 3);
+  rb_define_method(cUM, "send", UM_send, 4);
+  rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
+  rb_define_method(cUM, "socket", UM_socket, 4);
+
+  #ifdef HAVE_IO_URING_PREP_FUTEX
+  rb_define_method(cUM, "pop", UM_queue_pop, 1);
+  rb_define_method(cUM, "push", UM_queue_push, 2);
+  rb_define_method(cUM, "shift", UM_queue_shift, 1);
+  rb_define_method(cUM, "synchronize", UM_mutex_synchronize, 1);
+  rb_define_method(cUM, "unshift", UM_queue_unshift, 2);
+  #endif
 
   um_define_net_constants(cUM);
 }

data/ext/um/um_const.c

@@ -1,4 +1,8 @@
 #include "ruby.h"
+
+#include <fcntl.h>
+#include <sys/wait.h>
+
 #include <arpa/inet.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -12,6 +16,31 @@
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
 void um_define_net_constants(VALUE mod) {
+  DEF_CONST_INT(mod, O_APPEND);
+  DEF_CONST_INT(mod, O_CLOEXEC);
+  DEF_CONST_INT(mod, O_CREAT);
+  DEF_CONST_INT(mod, O_DIRECT);
+  DEF_CONST_INT(mod, O_DIRECTORY);
+  DEF_CONST_INT(mod, O_DSYNC);
+  DEF_CONST_INT(mod, O_EXCL);
+  DEF_CONST_INT(mod, O_NOCTTY);
+  DEF_CONST_INT(mod, O_NOFOLLOW);
+  DEF_CONST_INT(mod, O_PATH);
+  DEF_CONST_INT(mod, O_RDONLY);
+  DEF_CONST_INT(mod, O_RDWR);
+  DEF_CONST_INT(mod, O_SYNC);
+  DEF_CONST_INT(mod, O_TMPFILE);
+  DEF_CONST_INT(mod, O_TRUNC);
+  DEF_CONST_INT(mod, O_WRONLY);
+
+  DEF_CONST_INT(mod, WNOHANG);
+  DEF_CONST_INT(mod, WUNTRACED);
+  DEF_CONST_INT(mod, WCONTINUED);
+  DEF_CONST_INT(mod, WEXITED);
+  DEF_CONST_INT(mod, WSTOPPED);
+  DEF_CONST_INT(mod, WCONTINUED);
+  DEF_CONST_INT(mod, WNOWAIT);
+
   DEF_CONST_INT(mod, SOCK_STREAM);
   DEF_CONST_INT(mod, SOCK_DGRAM);
   DEF_CONST_INT(mod, SOCK_RAW);
@@ -181,4 +210,4 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, IF_NAMESIZE);
 
   DEF_CONST_INT(mod, SOMAXCONN);
-}
+}

data/ext/um/um_ext.c

@@ -1,5 +1,9 @@
 void Init_UM();
+void Init_Mutex();
+void Init_Queue();
 
 void Init_um_ext(void) {
   Init_UM();
+  Init_Mutex();
+  Init_Queue();
 }

data/ext/um/um_mutex_class.c

@@ -0,0 +1,47 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE cMutex;
+
+static void Mutex_mark(void *ptr) {
+  struct um_mutex *mutex = ptr;
+  rb_gc_mark_movable(mutex->self);
+}
+
+static void Mutex_compact(void *ptr) {
+  struct um_mutex *mutex = ptr;
+  mutex->self = rb_gc_location(mutex->self);
+}
+
+static size_t Mutex_size(const void *ptr) {
+  return sizeof(struct um_mutex);
+}
+
+static const rb_data_type_t Mutex_type = {
+    "UringMachineMutex",
+    {Mutex_mark, free, Mutex_size, Mutex_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE Mutex_allocate(VALUE klass) {
+  struct um_mutex *mutex = malloc(sizeof(struct um_mutex));
+  return TypedData_Wrap_Struct(klass, &Mutex_type, mutex);
+}
+
+inline struct um_mutex *Mutex_data(VALUE self) {
+  return RTYPEDDATA_DATA(self);
+}
+
+VALUE Mutex_initialize(VALUE self) {
+  struct um_mutex *mutex = Mutex_data(self);
+  mutex->self = self;
+  um_mutex_init(mutex);
+  return self;
+}
+
+void Init_Mutex(void) {
+  cMutex = rb_define_class_under(cUM, "Mutex", rb_cObject);
+  rb_define_alloc_func(cMutex, Mutex_allocate);
+
+  rb_define_method(cMutex, "initialize", Mutex_initialize, 0);
+}