uringmachine 0.19.1 → 0.21.0

data/ext/um/um_op.c

@@ -1,5 +1,42 @@
 #include "um.h"
 
+const char * um_op_kind_name(enum um_op_kind kind) {
+  switch (kind) {
+    case OP_TIMEOUT:            return "OP_TIMEOUT";
+    case OP_SCHEDULE:           return "OP_SCHEDULE";
+    case OP_SLEEP:              return "OP_SLEEP";
+    case OP_OPEN:               return "OP_OPEN";
+    case OP_READ:               return "OP_READ";
+    case OP_WRITE:              return "OP_WRITE";
+    case OP_WRITE_ASYNC:        return "OP_WRITE_ASYNC";
+    case OP_CLOSE:              return "OP_CLOSE";
+    case OP_CLOSE_ASYNC:        return "OP_CLOSE_ASYNC";
+    case OP_STATX:              return "OP_STATX";
+    case OP_ACCEPT:             return "OP_ACCEPT";
+    case OP_RECV:               return "OP_RECV";
+    case OP_SEND:               return "OP_SEND";
+    case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
+    case OP_SOCKET:             return "OP_SOCKET";
+    case OP_CONNECT:            return "OP_CONNECT";
+    case OP_BIND:               return "OP_BIND";
+    case OP_LISTEN:             return "OP_LISTEN";
+    case OP_GETSOCKOPT:         return "OP_GETSOCKOPT";
+    case OP_SETSOCKOPT:         return "OP_SETSOCKOPT";
+    case OP_SHUTDOWN:           return "OP_SHUTDOWN";
+    case OP_SHUTDOWN_ASYNC:     return "OP_SHUTDOWN_ASYNC";
+    case OP_POLL:               return "OP_POLL";
+    case OP_WAITID:             return "OP_WAITID";
+    case OP_FUTEX_WAIT:         return "OP_FUTEX_WAIT";
+    case OP_FUTEX_WAKE:         return "OP_FUTEX_WAKE";
+    case OP_ACCEPT_MULTISHOT:   return "OP_ACCEPT_MULTISHOT";
+    case OP_READ_MULTISHOT:     return "OP_READ_MULTISHOT";
+    case OP_RECV_MULTISHOT:     return "OP_RECV_MULTISHOT";
+    case OP_TIMEOUT_MULTISHOT:  return "OP_TIMEOUT_MULTISHOT";
+    case OP_SLEEP_MULTISHOT:    return "OP_SLEEP_MULTISHOT";
+    default:                    return "UNKNOWN_OP_KIND";
+  }
+}
+
 inline void um_op_clear(struct um *machine, struct um_op *op) {
   memset(op, 0, sizeof(struct um_op));
   op->fiber = Qnil;

data/ext/um/um_queue_class.c

@@ -26,7 +26,7 @@ static const rb_data_type_t Queue_type = {
     .dsize = NULL,
     .dcompact = Queue_compact
   },
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE Queue_allocate(VALUE klass) {

data/ext/um/um_stream.c

@@ -211,7 +211,7 @@ static inline VALUE resp_decode_simple_error(char *ptr, ulong len) {
   if (!ID_new) ID_new = rb_intern("new");
 
   VALUE msg = rb_str_new(ptr + 1, len - 1);
-  VALUE err = rb_funcall(rb_eRuntimeError, ID_new, 1, msg);
+  VALUE err = rb_funcall(eStreamRESPError, ID_new, 1, msg);
   RB_GC_GUARD(msg);
   return err;
 }
@@ -221,7 +221,7 @@ static inline VALUE resp_decode_error(struct um_stream *stream, VALUE out_buffer
   if (!ID_new) ID_new = rb_intern("new");
 
   VALUE msg = resp_decode_string(stream, out_buffer, len);
-  VALUE err = rb_funcall(rb_eRuntimeError, ID_new, 1, msg);
+  VALUE err = rb_funcall(eStreamRESPError, ID_new, 1, msg);
   RB_GC_GUARD(msg);
   return err;
 }
@@ -264,7 +264,7 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
     case ':': // integer
       return resp_decode_integer(ptr);
     case '(': // big integer
-      rb_raise(rb_eRuntimeError, "Big integers are not supported");
+      um_raise_internal_error("Big integers are not supported");
     case ',': // float
       return resp_decode_float(ptr);
 
@@ -274,7 +274,7 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
       data_len = resp_parse_length_field(ptr, len);
       return resp_decode_error(stream, out_buffer, data_len);
     default:
-      rb_raise(rb_eRuntimeError, "Invalid character encountered");
+      um_raise_internal_error("Invalid character encountered");
   }
 
   RB_GC_GUARD(msg);
@@ -390,6 +390,6 @@ void resp_encode(struct um_write_buffer *buf, VALUE obj) {
         return;
       }
     default:
-      rb_raise(rb_eRuntimeError, "Can't encode object");
+      um_raise_internal_error("Can't encode object");
   }
 }

data/ext/um/um_stream_class.c

@@ -1,6 +1,7 @@
 #include "um.h"
 
 VALUE cStream;
+VALUE eStreamRESPError;
 
 static void Stream_mark(void *ptr) {
   struct um_stream *stream = ptr;
@@ -94,4 +95,6 @@ void Init_Stream(void) {
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
   rb_define_singleton_method(cStream, "resp_encode", Stream_resp_encode, 2);
+
+  eStreamRESPError = rb_define_class_under(cStream, "RESPError", rb_eStandardError);
 }

data/ext/um/um_sync.c

@@ -4,13 +4,13 @@
 
 #define FUTEX2_SIZE_U32		0x02
 
-void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
+// The value argument is the current (known) futex value.
+void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t value) {
   struct um_op op;
   um_prep_op(machine, &op, OP_FUTEX_WAIT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_futex_wait(
-    sqe, (uint32_t *)futex, expect, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, value, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_fiber_switch(machine);
@@ -29,10 +29,8 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   struct um_op op;
   um_prep_op(machine, &op, OP_FUTEX_WAKE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
-  // submit futex_wait
   io_uring_prep_futex_wake(
-    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_fiber_switch(machine);
@@ -45,55 +43,55 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
 void um_futex_wake_transient(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
   io_uring_prep_futex_wake(
-    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
+  um_submit(machine);
 }
 
-
 #define MUTEX_LOCKED    1
 #define MUTEX_UNLOCKED  0
 
 void um_mutex_init(struct um_mutex *mutex) {
   mutex->state = MUTEX_UNLOCKED;
+  mutex->num_waiters = 0;
 }
 
-inline void um_mutex_lock(struct um *machine, uint32_t *state) {
-  while (*state == MUTEX_LOCKED) {
-    um_futex_wait(machine, state, MUTEX_LOCKED);
+inline void um_mutex_lock(struct um *machine, struct um_mutex *mutex) {
+  mutex->num_waiters++;
+  while (mutex->state == MUTEX_LOCKED) {
+    um_futex_wait(machine, &mutex->state, MUTEX_LOCKED);
   }
-  *state = MUTEX_LOCKED;
+  mutex->num_waiters--;
+  mutex->state = MUTEX_LOCKED;
 }
 
-inline void um_mutex_unlock(struct um *machine, uint32_t *state) {
-  *state = MUTEX_UNLOCKED;
-  // Wake up 1 waiting fiber
-  um_futex_wake(machine, state, 1);
+inline void um_mutex_unlock(struct um *machine, struct um_mutex *mutex) {
+  mutex->state = MUTEX_UNLOCKED;
+
+  if (mutex->num_waiters)
+    // Wake up 1 waiting fiber
+    um_futex_wake(machine, &mutex->state, 1);
 }
 
 struct sync_ctx {
   struct um *machine;
-  VALUE mutex;
-  uint32_t *state;
+  struct um_mutex *mutex;
 };
 
 VALUE synchronize_start(VALUE arg) {
   struct sync_ctx *ctx = (struct sync_ctx *)arg;
-  um_mutex_lock(ctx->machine, ctx->state);
+  um_mutex_lock(ctx->machine, ctx->mutex);
   return rb_yield(Qnil);
 }
 
 VALUE synchronize_complete(VALUE arg) {
   struct sync_ctx *ctx = (struct sync_ctx *)arg;
-  // Mutex is an embedded data class, so it might have moved while the operation
-  // was ongoing. We need to update the pointer to the embedded state variable.
-  ctx->state = &Mutex_data(ctx->mutex)->state;
-  um_mutex_unlock(ctx->machine, ctx->state);
+  um_mutex_unlock(ctx->machine, ctx->mutex);
   return Qnil;
 }
 
-inline VALUE um_mutex_synchronize(struct um *machine, VALUE mutex, uint32_t *state) {
-  struct sync_ctx ctx = { .machine = machine, .mutex = mutex, .state = state };
+inline VALUE um_mutex_synchronize(struct um *machine, struct um_mutex *mutex) {
+  struct sync_ctx ctx = { .machine = machine, .mutex = mutex };
   return rb_ensure(synchronize_start, (VALUE)&ctx, synchronize_complete, (VALUE)&ctx);
 }
 
@@ -209,7 +207,6 @@ static inline VALUE um_queue_add(struct um *machine, struct um_queue *queue, VAL
   else          queue_add_tail(queue, value);
 
   queue->count++;
-
   queue->state = QUEUE_READY;
   if (queue->num_waiters)
     um_futex_wake_transient(machine, &queue->state, 1);
@@ -228,7 +225,6 @@ enum queue_op { QUEUE_POP, QUEUE_SHIFT };
 
 struct queue_wait_ctx {
   struct um *machine;
-  VALUE queue_obj;
   struct um_queue *queue;
   enum queue_op op;
 };
@@ -241,10 +237,8 @@ VALUE um_queue_remove_start(VALUE arg) {
     um_futex_wait(ctx->machine, &ctx->queue->state, QUEUE_EMPTY);
   }
 
-  if (ctx->queue->state != QUEUE_READY)
-    rb_raise(rb_eRuntimeError, "Internal error: queue should be in ready state!");
-  if (!ctx->queue->tail)
-    rb_raise(rb_eRuntimeError, "Internal error: queue should be in ready state!");
+  assert(ctx->queue->state == QUEUE_READY);
+  assert(ctx->queue->tail);
 
   ctx->queue->count--;
   return (ctx->op == QUEUE_POP ? queue_remove_tail : queue_remove_head)(ctx->queue);
@@ -252,11 +246,6 @@ VALUE um_queue_remove_start(VALUE arg) {
 
 VALUE um_queue_remove_complete(VALUE arg) {
   struct queue_wait_ctx *ctx = (struct queue_wait_ctx *)arg;
-
-  // the um_queue struct is embedded, so it might have been moved while the op
-  // was ongoing, so we need to get it again on op completion
-  ctx->queue = Queue_data(ctx->queue_obj);
-
   ctx->queue->num_waiters--;
 
   if (ctx->queue->num_waiters && ctx->queue->tail) {
@@ -270,11 +259,11 @@ VALUE um_queue_remove_complete(VALUE arg) {
 }
 
 VALUE um_queue_pop(struct um *machine, struct um_queue *queue) {
-  struct queue_wait_ctx ctx = { .machine = machine, .queue_obj = queue->self, .queue = queue, .op = QUEUE_POP };
+  struct queue_wait_ctx ctx = { .machine = machine, .queue = queue, .op = QUEUE_POP };
   return rb_ensure(um_queue_remove_start, (VALUE)&ctx, um_queue_remove_complete, (VALUE)&ctx);
 }
 
 VALUE um_queue_shift(struct um *machine, struct um_queue *queue) {
-  struct queue_wait_ctx ctx = { .machine = machine, .queue_obj = queue->self, .queue = queue, .op = QUEUE_SHIFT };
+  struct queue_wait_ctx ctx = { .machine = machine, .queue = queue, .op = QUEUE_SHIFT };
   return rb_ensure(um_queue_remove_start, (VALUE)&ctx, um_queue_remove_complete, (VALUE)&ctx);
 }

data/ext/um/um_utils.c

@@ -1,6 +1,7 @@
 #include "um.h"
 #include <sys/mman.h>
 #include <stdlib.h>
+#include <ruby/io/buffer.h>
 
 inline struct __kernel_timespec um_double_to_timespec(double value) {
   double integral;
@@ -32,35 +33,70 @@ inline void um_raise_on_error_result(int result) {
   if (unlikely(result < 0)) rb_syserr_fail(-result, strerror(-result));
 }
 
-inline void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs) {
-  unsigned current_len = RSTRING_LEN(buffer);
-  if (ofs < 0) ofs = current_len + ofs + 1;
-  unsigned new_len = len + (unsigned)ofs;
-
-  if (current_len < new_len)
-    rb_str_modify_expand(buffer, new_len);
+inline void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs) {
+  if (TYPE(buffer) == T_STRING) {
+    size_t current_len = RSTRING_LEN(buffer);
+    if (len == -1) len = current_len;
+    if (ofs < 0) ofs = current_len + ofs + 1;
+    size_t new_len = len + (size_t)ofs;
+
+    if (current_len < new_len)
+      rb_str_modify_expand(buffer, new_len);
+    else
+      rb_str_modify(buffer);
+    return RSTRING_PTR(buffer) + ofs;
+  }
+  else if (IO_BUFFER_P(buffer)) {
+    void *base;
+    size_t size;
+    rb_io_buffer_get_bytes_for_writing(buffer, &base, &size); // writing *to* buffer
+    if (len == -1) len = size;
+    if (ofs < 0) ofs = size + ofs + 1;
+    size_t new_size = len + (size_t)ofs;
+
+    if (size < new_size) {
+      rb_io_buffer_resize(buffer, new_size);
+      rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
+    }
+    return base + ofs;
+  }
   else
-    rb_str_modify(buffer);
-  return RSTRING_PTR(buffer) + ofs;
+    um_raise_internal_error("Invalid buffer provided");
 }
 
-static inline void adjust_read_buffer_len(VALUE buffer, int result, int ofs) {
-  rb_str_modify(buffer);
-  unsigned len = result > 0 ? (unsigned)result : 0;
-  unsigned current_len = RSTRING_LEN(buffer);
-  if (ofs < 0) ofs = current_len + ofs + 1;
-  rb_str_set_len(buffer, len + (unsigned)ofs);
+static inline void adjust_read_buffer_len(VALUE buffer, int result, ssize_t ofs) {
+  if (TYPE(buffer) == T_STRING) {
+    rb_str_modify(buffer);
+    unsigned len = result > 0 ? (unsigned)result : 0;
+    unsigned current_len = RSTRING_LEN(buffer);
+    if (ofs < 0) ofs = current_len + ofs + 1;
+    rb_str_set_len(buffer, len + (unsigned)ofs);
+  }
+  else if (IO_BUFFER_P(buffer)) {
+    // do nothing?
+  }
 }
 
-inline void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags) {
+inline void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offset, __s32 result, __u32 flags) {
   if (!result) return;
 
   adjust_read_buffer_len(buffer, result, buffer_offset);
 }
 
+inline void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size) {
+  if (TYPE(buffer) == T_STRING) {
+    *base = RSTRING_PTR(buffer);
+    *size = RSTRING_LEN(buffer);
+  }
+  else if (IO_BUFFER_P(buffer))
+    rb_io_buffer_get_bytes_for_reading(buffer, base, size); // reading *from* buffer
+  else
+    um_raise_internal_error("Invalid buffer provided");
+}
+
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   if (machine->buffer_ring_count == BUFFER_RING_MAX_COUNT)
-    rb_raise(rb_eRuntimeError, "Cannot setup more than BUFFER_RING_MAX_COUNT buffer rings");
+    um_raise_internal_error("Cannot setup more than BUFFER_RING_MAX_COUNT buffer rings");
 
   struct buf_ring_descriptor *desc = machine->buffer_rings + machine->buffer_ring_count;
   desc->buf_count = count;
@@ -72,7 +108,7 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
     NULL, desc->br_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
   );
   if (mapped == MAP_FAILED)
-    rb_raise(rb_eRuntimeError, "Failed to allocate buffer ring");
+    um_raise_internal_error("Failed to allocate buffer ring");
 
   desc->br = (struct io_uring_buf_ring *)mapped;
   io_uring_buf_ring_init(desc->br);
@@ -88,7 +124,7 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   if (size > 0) {
     if (posix_memalign(&desc->buf_base, 4096, desc->buf_count * desc->buf_size)) {
       io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
-      rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
+      um_raise_internal_error("Failed to allocate buffers");
     }
 
     void *ptr = desc->buf_base;
@@ -143,3 +179,7 @@ inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE st
   RB_GC_GUARD(converted);
   io_uring_buf_ring_advance(desc->br, count);
 }
+
+inline void um_raise_internal_error(const char *msg) {
+  rb_raise(eUMError, "UringMachine error: %s", msg);
+}