uringmachine 0.25.0 → 0.27.0

data/ext/um/um_op.c

@@ -18,9 +18,11 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_STATX:              return "OP_STATX";
     case OP_ACCEPT:             return "OP_ACCEPT";
     case OP_RECV:               return "OP_RECV";
+    case OP_RECVMSG:            return "OP_RECVMSG";
     case OP_SEND:               return "OP_SEND";
-    case OP_SENDV:              return "OP_SENDV";
     case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
+    case OP_SENDMSG:            return "OP_SENDMSG";
+    case OP_SENDV:              return "OP_SENDV";
     case OP_SOCKET:             return "OP_SOCKET";
     case OP_CONNECT:            return "OP_CONNECT";
     case OP_BIND:               return "OP_BIND";
@@ -37,7 +39,6 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     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";
   }
 }
@@ -59,6 +60,7 @@ inline void um_op_transient_add(struct um *machine, struct um_op *op) {
 }
 
 inline void um_op_transient_remove(struct um *machine, struct um_op *op) {
+  op->flags &= ~OP_F_TRANSIENT;
   if (op->prev)
     op->prev->next = op->next;
   if (op->next)
@@ -185,3 +187,17 @@ inline void um_op_free(struct um *machine, struct um_op *op) {
   machine->op_freelist = op;
   machine->metrics.ops_free++;
 }
+
+inline struct um_op *um_op_acquire(struct um *machine) {
+  return um_op_alloc(machine);
+}
+
+inline void um_op_release(struct um *machine, struct um_op *op) {
+  op->ref_count--;
+  if (op->ref_count) return;
+
+  if (op->flags & OP_F_FREE_IOVECS) free(op->iovecs);
+  if (op->flags & OP_F_MULTISHOT)
+    um_op_multishot_results_clear(machine, op);
+  um_op_free(machine, op);
+}

data/ext/um/um_ssl.c

@@ -97,7 +97,7 @@ int um_ssl_write(struct um *machine, VALUE ssl_obj, VALUE buf, int len) {
   SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
   const void *base;
   size_t size;
-  um_get_buffer_bytes_for_writing(buf, &base, &size);
+  um_get_buffer_bytes_for_writing(buf, &base, &size, true);
   if ((len == (int)-1) || (len > (int)size)) len = (int)size;
   if (unlikely(!len)) return INT2NUM(0);
 

data/ext/um/um_sync.c

@@ -6,35 +6,42 @@
 
 // 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);
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_FUTEX_WAIT, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_futex_wait(
     sqe, (uint32_t *)futex, value, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_yield(machine);
-  if (!um_op_completed_p(&op))
-    um_cancel_and_wait(machine, &op);
+
+  if (unlikely(!OP_CQE_DONE_P(op)))
+    um_cancel_op_and_await_cqe(machine, op);
   else {
-    if (op.result.res != -EAGAIN)
-      um_raise_on_error_result(op.result.res);
+    int res = op->result.res;
+    if (res != -EAGAIN) {
+      um_op_release(machine, op);
+      um_raise_on_error_result(res);
+    }
   }
+  um_op_release(machine, op);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
 }
 
 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);
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_FUTEX_WAKE, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_futex_wake(
     sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_yield(machine);
-  um_check_completion(machine, &op);
+
+  um_verify_op_completion(machine, op, true);
+  um_op_release(machine, op);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);

data/ext/um/um_utils.c

@@ -98,15 +98,21 @@ inline void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 res
   adjust_read_buffer_len(buffer, result, buffer_offset);
 }
 
-inline void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size) {
+// returns false if buffer is invalid and raise_on_bad_buffer is false
+inline int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size, int raise_on_bad_buffer) {
   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");
+  else {
+    if (raise_on_bad_buffer)
+      um_raise_internal_error("Invalid buffer provided");
+    else
+      return false;
+  }
+  return true;
 }
 
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
@@ -204,7 +210,11 @@ inline struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *
   size_t len = 0;
 
   for (int i = 0; i < argc; i++) {
-    um_get_buffer_bytes_for_writing(argv[i], (const void **)&iovecs[i].iov_base, &iovecs[i].iov_len);
+    int ok = um_get_buffer_bytes_for_writing(argv[i], (const void **)&iovecs[i].iov_base, &iovecs[i].iov_len, false);
+    if (unlikely(!ok)) {
+      free(iovecs);
+      um_raise_internal_error("Invalid buffer provided");
+    }
     len += iovecs[i].iov_len;
   }
   if (total_len) *total_len = len;

data/grant-2025/tasks.md

@@ -129,10 +129,10 @@
 
     - [v] Postgres test
 
-- [ ] Ruby Fiber::Scheduler interface
+- [v] Ruby Fiber::Scheduler interface
   - [v] Make a PR for resetting the scheduler and resetting the fiber non-blocking flag.
   - [v] hook for close
-  - [ ] hooks for send/recv/sendmsg/recvmsg
+  - [x] hooks for send/recv/sendmsg/recvmsg (Ruby core PR pending for send/recv)
 
 - [v] SSL
   - [v] setup custom BIO

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.25.0'
+  VERSION = '0.27.0'
 end

data/test/test_async_op.rb

@@ -51,11 +51,12 @@ class AsyncOpTest < UMBaseTest
       @op.cancel
     end
 
-    res = @op.await
+    assert_raises(Errno::ECANCELED) {
+      @op.await
+    }
 
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal true, @op.done?
-    assert_equal (-ECANCELED), res
     assert_equal true, @op.cancelled?
   end
 

data/test/test_fiber_scheduler.rb

@@ -393,9 +393,12 @@ class FiberSchedulerTest < UMBaseTest
       sleep 0.001
       buf = IO.read(fn)
     end
-    assert_equal 2, machine.metrics[:total_ops]
 
     @scheduler.join
+    metrics = machine.metrics
+    assert_in_range 5..12, metrics[:total_ops]
+    assert_equal 0, metrics[:ops_pending]
+    assert_equal 256, metrics[:ops_free]
     assert_equal 'foobar', buf
     assert_equal({
       fiber: 2,