uringmachine 0.12.1 → 0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 540e2e4df0b1953f58e36ab4dea2024a793b1bea4fd2358f64733f003b192510
-  data.tar.gz: 463cf782db4604358e1f54270e24e4bb97ee92176cafdb36079fd9d4a5132fda
+  metadata.gz: 38a9b75f18075a31aa179cc63b67e7e80b75b3797a701e1b2164831f4c20c352
+  data.tar.gz: 50432253c8aca2713b7eeaf8ae69c72c1e4efece1c85285076cf91c97011a887
 SHA512:
-  metadata.gz: 9e54c0f81a6a6a0523a5210a00e5bd7d3a7c0598d8e15c4434080429ae10328079a06d1075fab88894eb2c6ac827e8c929b4fbc18a2bdc7cf20d7efda0d1bd81
-  data.tar.gz: 9de7ecd460344ec496fc061edb15a9fadd8b9a5b81db0ca8844afd6cc81bb79b7881af54a008b3c43565725f9234ea66728e69c7eaa6a09d090a0977128e0326
+  metadata.gz: c7426118f51b6b3460d7ec46cc6e64e8a3aaa50e2552d2c44f718cfa79a9624310d9d68148f030be5a03582abf3fe520389e7a27fb814cff141c78f327f4f76a
+  data.tar.gz: a2e0ce93138435f99f84956ba82004fe06b4c7f530c37aa6585d998f2a4f6c448eac406ef0c7c602335bc776c5d40b543288f6e5cf16b1fe8bab1141fe7569c6

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2025-06-09 Version 0.14
+
+- Add `#close_async`, `#shutdown_async`
+
+# 2025-06-07 Version 0.13
+
+- Add `#write_async`
+
 # 2025-06-07 Version 0.12.1
 
 - Improve portability of `UM` constants

data/ext/um/um.c

@@ -72,6 +72,11 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
   //   op, op->kind, op->flags, cqe->res, cqe->flags, machine->pending_count
   // );
 
+  if (op->flags & OP_F_FREE_ON_COMPLETE) {
+    um_op_free(machine, op);
+    return;
+  }
+
   if (unlikely((cqe->res == -ECANCELED) && (op->flags & OP_F_IGNORE_CANCELED))) return;
 
   op->flags |= OP_F_COMPLETED;
@@ -247,20 +252,14 @@ inline VALUE um_await(struct um *machine) {
   return raise_if_exception(v);
 }
 
-inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind) {
+inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags) {
   memset(op, 0, sizeof(struct um_op));
   op->kind = kind;
-  switch (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:
-  }
-  RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
-  op->value = Qnil;
+  op->flags = flags;
+
+  VALUE fiber = (flags & OP_F_FREE_ON_COMPLETE) ? Qnil : rb_fiber_current();
+  RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
 }
 
 inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
@@ -302,7 +301,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   if (!ID_new) ID_new = rb_intern("new");
 
   struct um_op *op = um_op_alloc(machine);
-  um_prep_op(machine, op, OP_TIMEOUT);
+  um_prep_op(machine, op, OP_TIMEOUT, 0);
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
   RB_OBJ_WRITE(machine->self, &op->value, rb_funcall(class, ID_new, 0));
@@ -320,7 +319,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
 
 VALUE um_sleep(struct um *machine, double duration) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SLEEP);
+  um_prep_op(machine, &op, OP_SLEEP, 0);
   op.ts = um_double_to_timespec(duration);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_timeout(sqe, &op.ts, 0, 0);
@@ -339,7 +338,7 @@ VALUE um_sleep(struct um *machine, double duration) {
 
 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);
+  um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, buffer_offset);
   io_uring_prep_read(sqe, fd, ptr, maxlen, -1);
@@ -358,7 +357,7 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
 
 inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_READ);
+  um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_read(sqe, fd, buffer, maxlen, -1);
 
@@ -374,7 +373,7 @@ inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen)
 
 VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_WRITE);
+  um_prep_op(machine, &op, OP_WRITE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   const int str_len = RSTRING_LEN(str);
   if (len > str_len) len = str_len;
@@ -390,9 +389,19 @@ VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
   return raise_if_exception(ret);
 }
 
+VALUE um_write_async(struct um *machine, int fd, VALUE str) {
+  struct um_op *op = um_op_alloc(machine);
+  um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->value, str);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_write(sqe, fd, RSTRING_PTR(str), RSTRING_LEN(str), -1);
+  return str;
+}
+
 VALUE um_close(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_CLOSE);
+  um_prep_op(machine, &op, OP_CLOSE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_close(sqe, fd);
 
@@ -404,9 +413,19 @@ VALUE um_close(struct um *machine, int fd) {
   return raise_if_exception(ret);
 }
 
+VALUE um_close_async(struct um *machine, int fd) {
+  struct um_op *op = um_op_alloc(machine);
+  um_prep_op(machine, op, OP_CLOSE_ASYNC, OP_F_FREE_ON_COMPLETE);
+  
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_close(sqe, fd);
+
+  return INT2NUM(fd);
+}
+
 VALUE um_accept(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_ACCEPT);
+  um_prep_op(machine, &op, OP_ACCEPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_accept(sqe, fd, NULL, NULL, 0);
 
@@ -420,7 +439,7 @@ VALUE um_accept(struct um *machine, int fd) {
 
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SOCKET);
+  um_prep_op(machine, &op, OP_SOCKET, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_socket(sqe, domain, type, protocol, flags);
 
@@ -434,7 +453,7 @@ 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) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_CONNECT);
+  um_prep_op(machine, &op, OP_CONNECT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_connect(sqe, fd, addr, addrlen);
 
@@ -448,7 +467,7 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
 
 VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SEND);
+  um_prep_op(machine, &op, OP_SEND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_send(sqe, fd, RSTRING_PTR(buffer), len, flags);
 
@@ -463,7 +482,7 @@ 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) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_RECV);
+  um_prep_op(machine, &op, OP_RECV, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, 0);
   io_uring_prep_recv(sqe, fd, ptr, maxlen, flags);
@@ -481,7 +500,7 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
 
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_BIND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_bind(sqe, fd, addr, addrlen);
 
@@ -495,7 +514,7 @@ VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrl
 
 VALUE um_listen(struct um *machine, int fd, int backlog) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_BIND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_listen(sqe, fd, backlog);
 
@@ -513,7 +532,7 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
 
 #ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
-  um_prep_op(machine, &op, OP_GETSOCKOPT);
+  um_prep_op(machine, &op, OP_GETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_GETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
@@ -537,7 +556,7 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
 
 #ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
-  um_prep_op(machine, &op, OP_SETSOCKOPT);
+  um_prep_op(machine, &op, OP_SETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_SETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
@@ -559,7 +578,7 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   VALUE ret = Qnil;
 
   struct um_op op;
-  um_prep_op(machine, &op, OP_SHUTDOWN);
+  um_prep_op(machine, &op, OP_SHUTDOWN, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_shutdown(sqe, fd, how);
 
@@ -571,9 +590,19 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   return raise_if_exception(ret);
 }
 
+VALUE um_shutdown_async(struct um *machine, int fd, int how) {
+  struct um_op *op = um_op_alloc(machine);
+  um_prep_op(machine, op, OP_SHUTDOWN_ASYNC, OP_F_FREE_ON_COMPLETE);
+  
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_shutdown(sqe, fd, how);
+
+  return INT2NUM(fd);
+}
+
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_OPEN);
+  um_prep_op(machine, &op, OP_OPEN, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_open(sqe, StringValueCStr(pathname), flags, mode);
 
@@ -587,7 +616,7 @@ VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
 
 VALUE um_waitpid(struct um *machine, int pid, int options) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_WAITPID);
+  um_prep_op(machine, &op, OP_WAITPID, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   siginfo_t infop;
@@ -628,7 +657,7 @@ VALUE statx_to_hash(struct statx *stat) {
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_STATX);
+  um_prep_op(machine, &op, OP_STATX, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   struct statx stat;
@@ -703,7 +732,7 @@ VALUE multishot_complete(VALUE arg) {
 
 VALUE um_accept_each(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_ACCEPT_MULTISHOT);
+  um_prep_op(machine, &op, OP_ACCEPT_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .read_buf = NULL };
   return rb_ensure(accept_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -716,7 +745,7 @@ int um_read_each_singleshot_loop(struct op_ctx *ctx) {
   int total = 0;
 
   while (1) {
-    um_prep_op(ctx->machine, ctx->op, OP_READ);
+    um_prep_op(ctx->machine, ctx->op, OP_READ, 0);
     struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
     io_uring_prep_read(sqe, ctx->fd, ctx->read_buf, ctx->read_maxlen, -1);
 
@@ -806,7 +835,7 @@ VALUE read_recv_each_start(VALUE arg) {
 
 VALUE um_read_each(struct um *machine, int fd, int bgid) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_READ_MULTISHOT);
+  um_prep_op(machine, &op, OP_READ_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -814,7 +843,7 @@ VALUE um_read_each(struct um *machine, int fd, int bgid) {
 
 VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_RECV_MULTISHOT);
+  um_prep_op(machine, &op, OP_RECV_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -853,7 +882,7 @@ VALUE periodically_start(VALUE arg) {
 
 VALUE um_periodically(struct um *machine, double interval) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT, OP_F_MULTISHOT);
   op.ts = um_double_to_timespec(interval);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .ts = op.ts, .read_buf = NULL };

data/ext/um/um.h

@@ -28,7 +28,9 @@ enum op_kind {
   OP_OPEN,
   OP_READ,
   OP_WRITE,
+  OP_WRITE_ASYNC,
   OP_CLOSE,
+  OP_CLOSE_ASYNC,
   OP_STATX,
 
   OP_ACCEPT,
@@ -41,6 +43,7 @@ enum op_kind {
   OP_GETSOCKOPT,
   OP_SETSOCKOPT,
   OP_SHUTDOWN,
+  OP_SHUTDOWN_ASYNC,
   
   OP_WAITPID,
 
@@ -59,6 +62,7 @@ enum op_kind {
 #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
+#define OP_F_FREE_ON_COMPLETE (1U << 5) // op should be freed on receiving CQE
 
 struct um_op_result {
   __s32 res;
@@ -200,7 +204,7 @@ VALUE um_raise_exception(VALUE v);
 
 #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_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags);
 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);
@@ -227,9 +231,11 @@ size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE str, int len);
 VALUE um_close(struct um *machine, int fd);
+VALUE um_close_async(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_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
+VALUE um_write_async(struct um *machine, int fd, VALUE str);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -243,6 +249,7 @@ 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);
 VALUE um_shutdown(struct um *machine, int fd, int how);
+VALUE um_shutdown_async(struct um *machine, int fd, int how);
 
 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);

data/ext/um/um_async_op.c

@@ -6,9 +6,8 @@ VALUE um_prep_timeout(struct um *machine, double interval) {
   if (!ID_new) ID_new = rb_intern("new");
 
   struct um_op *op = malloc(sizeof(struct um_op));
-  um_prep_op(machine, op, OP_TIMEOUT);
+  um_prep_op(machine, op, OP_TIMEOUT, OP_F_TRANSIENT | OP_F_ASYNC);
   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);

data/ext/um/um_class.c

@@ -131,6 +131,11 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   return um_write(machine, NUM2INT(fd), buffer, bytes);
 }
 
+VALUE UM_write_async(VALUE self, VALUE fd, VALUE str) {
+  struct um *machine = um_get_machine(self);
+  return um_write_async(machine, NUM2INT(fd), str);
+}
+
 VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
   struct um *machine = um_get_machine(self);
   return um_statx(machine, NUM2INT(dirfd), path, NUM2INT(flags), NUM2UINT(mask));
@@ -141,6 +146,11 @@ VALUE UM_close(VALUE self, VALUE fd) {
   return um_close(machine, NUM2INT(fd));
 }
 
+VALUE UM_close_async(VALUE self, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_close_async(machine, NUM2INT(fd));
+}
+
 VALUE UM_accept(VALUE self, VALUE fd) {
   struct um *machine = um_get_machine(self);
   return um_accept(machine, NUM2INT(fd));
@@ -159,7 +169,11 @@ VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flag
 VALUE UM_shutdown(VALUE self, VALUE fd, VALUE how) {
   struct um *machine = um_get_machine(self);
   return um_shutdown(machine, NUM2INT(fd), NUM2INT(how));
+}
 
+VALUE UM_shutdown_async(VALUE self, VALUE fd, VALUE how) {
+  struct um *machine = um_get_machine(self);
+  return um_shutdown_async(machine, NUM2INT(fd), NUM2INT(how));
 }
 
 VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
@@ -342,12 +356,14 @@ void Init_UM(void) {
   rb_define_method(cUM, "yield", UM_yield, 0);
 
   rb_define_method(cUM, "close", UM_close, 1);
+  rb_define_method(cUM, "close_async", UM_close_async, 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, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
+  rb_define_method(cUM, "write_async", UM_write_async, 2);
   rb_define_method(cUM, "statx", UM_statx, 4);
 
   rb_define_method(cUM, "waitpid", UM_waitpid, 2);
@@ -364,6 +380,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
   rb_define_method(cUM, "socket", UM_socket, 4);
   rb_define_method(cUM, "shutdown", UM_shutdown, 2);
+  rb_define_method(cUM, "shutdown_async", UM_shutdown_async, 2);
 
   rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
 

data/ext/um/um_sync.c

@@ -6,7 +6,7 @@
 
 void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_FUTEX_WAIT);
+  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,
@@ -27,7 +27,7 @@ void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
 
 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);
+  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(

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -35,14 +35,15 @@ class UringMachine
         f.add_done_listener(queue)
       end
     end
-    return results.values if !pending
-
-    while !pending.empty?
-      f = self.shift(queue)
-      pending.delete(f)
-      results[f] = f.result
+    if pending
+      while !pending.empty?
+        f = self.shift(queue)
+        pending.delete(f)
+        results[f] = f.result
+      end
     end
-    results.values
+    values = results.values
+    fibers.size == 1 ? values.first : values
   end
 
   def resolve(hostname, type = :A)

data/test/helper.rb

@@ -74,4 +74,20 @@ class UMBaseTest < Minitest::Test
       @@port += 1
     end
   end
+
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
 end

data/test/test_fiber.rb

@@ -88,7 +88,7 @@ class FiberJoinTest < UMBaseTest
     res = machine.join(f)
     assert_equal 0, x
     assert_equal 3, machine.shift(q)
-    assert_equal [42], res
+    assert_equal 42, res
   end
 
   def test_join_multiple
@@ -125,7 +125,7 @@ class FiberJoinTest < UMBaseTest
     f = machine.shift(q)
     assert_kind_of Fiber, f
     res = machine.join(f)
-    assert_equal [:foo], res
+    assert_equal :foo, res
   ensure
     t2.join
   end
@@ -135,8 +135,7 @@ class FiberJoinTest < UMBaseTest
       raise "Foobar"
     end
 
-    res = machine.join(f)
-    e = res.first
+    e = machine.join(f)
     assert_kind_of RuntimeError, e
     assert_equal 'Foobar', e.message
   end

data/test/test_um.rb

@@ -25,6 +25,12 @@ class SpinTest < UMBaseTest
 
     assert_equal :foo, x
   end
+
+  def test_spin_with_unhandled_exception
+    f = machine.spin { raise 'foo' }
+    result = machine.join(f)
+    assert_kind_of RuntimeError, result
+  end
 end
 
 class SnoozeTest < UMBaseTest
@@ -271,7 +277,7 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    2.times { machine.snooze }
+    5.times { machine.snooze }
     assert_equal 0, machine.pending_count
     t1 = monotonic_clock
     assert_in_range 0.05..0.08, t1 - t0
@@ -532,6 +538,30 @@ class WriteTest < UMBaseTest
   end
 end
 
+class WriteAsyncTest < UMBaseTest
+  def test_write_async
+    r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal 'foo', r.readpartial(3)
+  end
+
+  def test_write_async_bad_fd
+    r, _w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    machine.write_async(r.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+  end
+end
+
 class CloseTest < UMBaseTest
   def test_close
     r, w = IO.pipe
@@ -545,25 +575,31 @@ class CloseTest < UMBaseTest
 
     assert_raises(Errno::EBADF) { machine.close(w.fileno) }
   end
-end
-
-class ShutdownTest < UMBaseTest
-  def make_socket_pair
-    port = 10000 + rand(30000)
-    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-    @machine.bind(server_fd, '127.0.0.1', port)
-    @machine.listen(server_fd, UM::SOMAXCONN)
 
-    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.connect(client_conn_fd, '127.0.0.1', port)
+  def test_close_bad_fd
+    r, w = IO.pipe
+    machine.close(w.fileno)
+    
+    assert_raises(Errno::EBADF) { machine.close(w.fileno) }
+  end
+end
 
-    server_conn_fd = @machine.accept(server_fd)
+class CloseAsyncTest < UMBaseTest
+  def test_close_async
+    r, w = IO.pipe
+    machine.write(w.fileno, 'foo')
+    assert_equal 'foo', r.readpartial(3)
 
-    @machine.close(server_fd)
-    [client_conn_fd, server_conn_fd]
+    assert_equal 0, machine.pending_count
+    machine.close_async(w.fileno)
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal '', r.read
   end
+end
 
+class ShutdownTest < UMBaseTest
   def test_shutdown
     c_fd, s_fd = make_socket_pair
     res = @machine.send(c_fd, 'abc', 3, 0)
@@ -595,6 +631,37 @@ class ShutdownTest < UMBaseTest
   end
 end
 
+class ShutdownAsyncTest < UMBaseTest
+  def test_shutdown_async
+    c_fd, s_fd = make_socket_pair
+    res = @machine.send(c_fd, 'abc', 3, 0)
+    assert_equal 3, res
+
+    buf = +''
+    res = @machine.recv(s_fd, buf, 256, 0)
+    assert_equal 3, res
+    assert_equal 'abc', buf
+
+    res = @machine.shutdown_async(c_fd, UM::SHUT_WR)
+    assert_equal c_fd, res
+
+    machine.sleep(0.01)
+    assert_raises(Errno::EPIPE) { @machine.send(c_fd, 'abc', 3, 0) }
+
+    res = @machine.shutdown_async(s_fd, UM::SHUT_RD)
+    assert_equal s_fd, res
+
+    res = @machine.recv(s_fd, buf, 256, 0)
+    assert_equal 0, res
+
+    res = @machine.shutdown_async(c_fd, UM::SHUT_RDWR)
+    assert_equal c_fd, res
+  ensure
+    @machine.close(c_fd)
+    @machine.close(s_fd)
+  end
+end
+
 class AcceptTest < UMBaseTest
   def setup
     super

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: '0.14'
 platform: ruby
 authors:
 - Sharon Rosner