uringmachine 0.18 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18144dad22716ba83fde0f2ec1d3bffbb1a13684044f99f279eba183a70e7181
-  data.tar.gz: 0e742fa4e8ac06475fa7bfab120239863b76f47f5ca33c2a9cc3d0c26ef27bc8
+  metadata.gz: ff89f34d541e086f8016156d4b5290a6a2fdc94292f04e7a3104ef9e7cda256d
+  data.tar.gz: 01dbe57b83effbab744fbd07461dcd803246a88bbf3ce1aeaf1e4eace32fd0ad
 SHA512:
-  metadata.gz: fe981430bc6dace32cb166e3e8177ab5b4cf90f86021ee14990fa01b573459fbace2f17484e2307a9cf8ee83b59b547ae5e2c051774fcb8a444297293214d1e4
-  data.tar.gz: 8cc7d29d54de95ab70d197db9c1a035d6302750ca86d2ecfb94599e9bed5e3b4f1119eefc8e4804f89f09a20242cd35c0fe277b1a214f2742fce7642b6b83c97
+  metadata.gz: ca0e44f1121384634b4234b2cd49643f87e8255e77eb250f64fb62be8bcdcb18e6a82480e5da003322c941c9ae2def119a048797d53bc064c4e1f77796b82c4d
+  data.tar.gz: 322090fd12498525d303b63f66ec1c559ed9933e89e74d3b01c9cc5c0f3f1dcee951c767625690c288478d5e460248418bbd693fbd7c31146c7aff76cf545a5d

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.19.1 2025-01-03
+
+- Add `RB_GC_GUARD` in `process_runqueue_op`
+
+# 0.19 2025-10-27
+
+- Fix usage of `RAISE_IF_EXCEPTION` after `RB_GC_GUARD`
+
 # 0.18 2025-08-30
 
 - Fix `#write_async` to properly mark the given string

data/TODO.md

@@ -1,3 +1,44 @@
+## immediate
+
+- make a reproducer for segfault on timeout, spin lots of fibers where a timeout
+  wraps a #shift call (from an empty queue).
+- see also: https://mensfeld.pl/2025/11/ruby-ffi-gc-bug-hash-becomes-string/
+
+Analysis:
+
+- The segfault is related to timeouts
+- Looking at process_runqueue_op (um.c):
+
+  ```c
+  inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
+    VALUE fiber = op->fiber;
+    VALUE value = op->value;
+
+    // on timeout, the op flags are changed to turn on OP_F_TRANSIENT
+    if (unlikely(op->flags & OP_F_TRANSIENT))
+      // here the op is freed, so the value is not visible to the GC anymoore
+      um_op_free(machine, op);
+
+    // if a GC occurs here, we risk a segfault
+
+    // value is used
+    return rb_fiber_transfer(fiber, 1, &value);
+  }
+  ```
+
+- So, a possible solution is to put a `RB_GC_GUARD` after the `return`.
+- But first, I want to be able to reproduce it. We can start by setting
+  `GC.stress = true` on tests and see if we segfault.
+
+## FiberScheduler implementation
+
+Some resources:
+
+- https://github.com/socketry/async/blob/main/context/getting-started.md
+- https://github.com/socketry/async/blob/main/context/scheduler.md
+- https://github.com/socketry/async/blob/main/lib/async/scheduler.rb#L28
+- 
+
 ## useful concurrency tools
 
 - debounce
@@ -16,7 +57,7 @@
 - splice / - tee
 - sendto
 - recvfrom
-- poll_add / poll_remove / poll_multishot / poll_update
+- poll_multishot
 - fsync
 - mkdir / mkdirat
 - link / linkat / unlink / unlinkat / symlink

data/examples/fiber_scheduler_demo.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+require_relative '../lib/uringmachine/fiber_scheduler'
+require 'net/http'
+
+machine = UringMachine.new
+scheduler = UM::FiberScheduler.new(machine)
+Fiber.set_scheduler scheduler
+
+i, o = IO.pipe
+
+f1 = Fiber.schedule do
+  # sleep 0.4
+  # o.write 'Hello, world!'
+  # o.close
+end
+
+f2 = Fiber.schedule do
+  # puts "hi"
+  # 10.times do
+  #   sleep 0.1
+  #   puts "."
+  # end
+end
+
+# Fiber.schedule do
+#   scheduler.block(:wait)
+# end
+
+f3 = Fiber.schedule do
+#   message = i.read
+#   puts message
+# rescue => e
+#   scheduler.p e
+#   scheduler.p e.backtrace
+end
+
+f4 = Fiber.schedule do
+  puts '*' * 40
+  # tcp = TCPSocket.new('noteflakes.com', 80)
+  # tcp.timeout = 10
+  # scheduler.p tcp
+  # tcp << "GET / HTTP/1.1\r\nHost: noteflakes.com\r\n\r\n"
+  # s = tcp.read
+  # scheduler.p s: s
+  ret = Net::HTTP.get('noteflakes.com', '/ping')
+  scheduler.p ret: ret
+rescue => e
+  scheduler.p e
+  scheduler.p e.backtrace
+end
+
+scheduler.join(f1, f2, f3, f4)
+
+__END__
+
+stdout_fd = STDOUT.fileno
+stdin_fd = STDIN.fileno
+machine.write(stdout_fd, "Hello, world!\n")
+
+loop do
+  machine.write(stdout_fd, "Say something: ")
+  buf = +''
+  res = machine.read(stdin_fd, buf, 8192)
+  if res > 0
+    machine.write(stdout_fd, "You said: #{buf}")
+  else
+    break
+  end
+end

data/ext/um/um.c

@@ -194,7 +194,10 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   if (unlikely(op->flags & OP_F_TRANSIENT))
     um_op_free(machine, op);
 
-  return rb_fiber_transfer(fiber, 1, &value);
+  VALUE ret = rb_fiber_transfer(fiber, 1, &value);
+  RB_GC_GUARD(value);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 inline VALUE um_fiber_switch(struct um *machine) {
@@ -252,8 +255,10 @@ inline int um_check_completion(struct um *machine, struct um_op *op) {
 }
 
 inline VALUE um_await(struct um *machine) {
-  VALUE v = um_fiber_switch(machine);
-  return raise_if_exception(v);
+  VALUE ret = um_fiber_switch(machine);
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags) {
@@ -264,6 +269,7 @@ inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind,
   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);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 }
 
 inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
@@ -273,6 +279,7 @@ inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
   op->flags = OP_F_TRANSIENT;
   RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
   RB_OBJ_WRITE(machine->self, &op->value, value);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
   um_runqueue_push(machine, op);
 }
 
@@ -309,6 +316,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   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));
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_timeout(sqe, &op->ts, 0, 0);
@@ -340,8 +348,9 @@ VALUE um_sleep(struct um *machine, double duration) {
     ret = DBL2NUM(duration);
   }
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
@@ -357,10 +366,11 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
     ret = INT2NUM(op.result.res);
 
   }
-
   RB_GC_GUARD(buffer);
+
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen) {
@@ -375,7 +385,8 @@ inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen)
 
   }
 
-  raise_if_exception(ret);
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
   return 0;
 }
 
@@ -393,14 +404,18 @@ VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
     ret = INT2NUM(op.result.res);
 
   RB_GC_GUARD(str);
+
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return 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_TRANSIENT | OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
   RB_OBJ_WRITE(machine->self, &op->value, str);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_write(sqe, fd, RSTRING_PTR(str), RSTRING_LEN(str), -1);
@@ -419,13 +434,17 @@ VALUE um_close(struct um *machine, int fd) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(fd);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return 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);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_close(sqe, fd);
@@ -443,8 +462,9 @@ VALUE um_accept(struct um *machine, int fd) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags) {
@@ -457,8 +477,9 @@ VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint fla
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen) {
@@ -471,8 +492,9 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
@@ -486,8 +508,10 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
     ret = INT2NUM(op.result.res);
 
   RB_GC_GUARD(buffer);
+
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
@@ -505,10 +529,8 @@ VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
-
-
   return ret;
 }
 
@@ -526,8 +548,10 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
   }
 
   RB_GC_GUARD(buffer);
+
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen) {
@@ -540,8 +564,9 @@ VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrl
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_listen(struct um *machine, int fd, int backlog) {
@@ -554,8 +579,9 @@ VALUE um_listen(struct um *machine, int fd, int backlog) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
@@ -579,8 +605,9 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
   ret = INT2NUM(value);
 #endif
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
@@ -602,8 +629,9 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
   ret = INT2NUM(0);
 #endif
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_shutdown(struct um *machine, int fd, int how) {
@@ -618,13 +646,17 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return 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);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_shutdown(sqe, fd, how);
@@ -642,8 +674,24 @@ VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+VALUE um_poll(struct um *machine, int fd, unsigned mask) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_POLL, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  io_uring_prep_poll_add(sqe, fd, mask);
+
+  VALUE ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op))
+    ret = INT2NUM(op.result.res);
+
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  return raise_if_exception(ret);
+  return ret;
 }
 
 VALUE um_waitpid(struct um *machine, int pid, int options) {
@@ -658,8 +706,8 @@ VALUE um_waitpid(struct um *machine, int pid, int options) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 
   return rb_ary_new_from_args(2, INT2NUM(infop.si_pid), INT2NUM(infop.si_status));
 }
@@ -688,24 +736,23 @@ VALUE statx_to_hash(struct statx *stat) {
 }
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask) {
+  static char empty_path[] = "";
+
   struct um_op op;
   um_prep_op(machine, &op, OP_STATX, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
+  char *path_ptr = NIL_P(path) ? empty_path : StringValueCStr(path);
   struct statx stat;
   memset(&stat, 0, sizeof(stat));
-
-  if (NIL_P(path))
-    path = rb_str_new_literal("");
-
-  io_uring_prep_statx(sqe, dirfd, StringValueCStr(path), flags, mask, &stat);
+  io_uring_prep_statx(sqe, dirfd, path_ptr, flags, mask, &stat);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 
   return statx_to_hash(&stat);
 }
@@ -721,8 +768,11 @@ VALUE accept_each_start(VALUE arg) {
 
   while (true) {
     VALUE ret = um_fiber_switch(ctx->machine);
-    if (!um_op_completed_p(ctx->op))
-      return raise_if_exception(ret);
+    if (!um_op_completed_p(ctx->op)) {
+      RAISE_IF_EXCEPTION(ret);
+      return ret;
+    }
+    RB_GC_GUARD(ret);
 
     int more = false;
     struct um_op_result *result = &ctx->op->result;
@@ -791,8 +841,11 @@ int um_read_each_singleshot_loop(struct op_ctx *ctx) {
       rb_yield(buf);
       RB_GC_GUARD(buf);
     }
-    else
-      return raise_if_exception(ret);
+    else {
+      RAISE_IF_EXCEPTION(ret);
+      return ret;
+    }
+    RB_GC_GUARD(ret);
   }
 }
 
@@ -840,8 +893,11 @@ VALUE read_recv_each_start(VALUE arg) {
 
   while (true) {
     VALUE ret = um_fiber_switch(ctx->machine);
-    if (!um_op_completed_p(ctx->op))
-      return raise_if_exception(ret);
+    if (!um_op_completed_p(ctx->op)) {
+      RAISE_IF_EXCEPTION(ret);
+      return ret;
+    }
+    RB_GC_GUARD(ret);
 
     int more = false;
     struct um_op_result *result = &ctx->op->result;
@@ -888,8 +944,11 @@ VALUE periodically_start(VALUE arg) {
 
   while (true) {
     VALUE ret = um_fiber_switch(ctx->machine);
-    if (!um_op_completed_p(ctx->op))
-      return raise_if_exception(ret);
+    if (!um_op_completed_p(ctx->op)) {
+      RAISE_IF_EXCEPTION(ret);
+      return ret;
+    }
+    RB_GC_GUARD(ret);
 
     int more = false;
     struct um_op_result *result = &ctx->op->result;

data/ext/um/um.h

@@ -45,7 +45,8 @@ enum op_kind {
   OP_SETSOCKOPT,
   OP_SHUTDOWN,
   OP_SHUTDOWN_ASYNC,
-  
+
+  OP_POLL,
   OP_WAITPID,
 
   OP_FUTEX_WAIT,
@@ -203,7 +204,7 @@ double um_timestamp_to_double(__s64 tv_sec, __u32 tv_nsec);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
 
-#define raise_if_exception(v) (um_value_is_exception_p(v) ? um_raise_exception(v) : v)
+#define RAISE_IF_EXCEPTION(v) if (um_value_is_exception_p(v)) { um_raise_exception(v); }
 
 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);
@@ -235,6 +236,7 @@ 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_poll(struct um *machine, int fd, unsigned mask);
 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);

data/ext/um/um_async_op.c

@@ -30,7 +30,8 @@ VALUE um_async_op_await(struct um_async_op *async_op) {
   if (!um_op_completed_p(async_op->op))
     um_cancel_and_wait(async_op->machine, async_op->op);
 
-  raise_if_exception(ret);
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
   return INT2NUM(async_op->op->result.res);
 }
 

data/ext/um/um_class.c

@@ -327,6 +327,11 @@ VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
     return fd;
 }
 
+VALUE UM_poll(VALUE self, VALUE fd, VALUE mask) {
+  struct um *machine = um_get_machine(self);
+  return um_poll(machine, NUM2INT(fd), NUM2UINT(mask));
+}
+
 VALUE UM_waitpid(VALUE self, VALUE pid, VALUE options) {
   struct um *machine = um_get_machine(self);
   return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
@@ -382,6 +387,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "write_async", UM_write_async, 2);
   rb_define_method(cUM, "statx", UM_statx, 4);
 
+  rb_define_method(cUM, "poll", UM_poll, 2);
   rb_define_method(cUM, "waitpid", UM_waitpid, 2);
 
   rb_define_method(cUM, "accept", UM_accept, 1);

data/ext/um/um_const.c

@@ -12,7 +12,7 @@
 #include <netinet/udp.h>
 #include <netdb.h>
 #include <net/if.h>
-
+#include <poll.h>
 
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
@@ -258,6 +258,10 @@ void um_define_net_constants(VALUE mod) {
 
   DEF_CONST_INT(mod, SOMAXCONN);
 
+  DEF_CONST_INT(mod, POLLIN);
+  DEF_CONST_INT(mod, POLLOUT);
+  DEF_CONST_INT(mod, POLLERR);
+
   DEF_CONST_INT(mod, EPERM);
   DEF_CONST_INT(mod, ENOENT);
   DEF_CONST_INT(mod, ESRCH);
@@ -387,5 +391,4 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, EKEYREJECTED);
   DEF_CONST_INT(mod, EOWNERDEAD);
   DEF_CONST_INT(mod, ENOTRECOVERABLE);
-
 }

data/ext/um/um_stream.c

@@ -26,7 +26,7 @@ int stream_read_more(struct um_stream *stream) {
   size_t capa = rb_str_capacity(stream->buffer);
   if (capa - stream->pos < maxlen)
     rb_str_modify_expand(stream->buffer, maxlen - (capa - stream->pos));
-  
+
   rb_str_modify(stream->buffer);
   char *ptr = RSTRING_PTR(stream->buffer) + stream->pos;
   size_t ret = um_read_raw(stream->machine, stream->fd, ptr, maxlen);
@@ -94,7 +94,7 @@ VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len) {
 
       abslen = stream->len - stream->pos;
     }
-  
+
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   stream->pos += abslen;
 
@@ -137,7 +137,7 @@ VALUE resp_get_string(struct um_stream *stream, ulong len, VALUE out_buffer) {
 
   while (stream->len - stream->pos < read_len)
     if (!stream_read_more(stream)) return Qnil;
-  
+
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   stream->pos += read_len;
 
@@ -198,7 +198,7 @@ static inline VALUE resp_decode_string_with_encoding(struct um_stream *stream, V
 
 static inline VALUE resp_decode_integer(char *ptr) {
   long value = strtol(ptr + 1, NULL, 10);
-  return LONG2NUM(value);    
+  return LONG2NUM(value);
 }
 
 static inline VALUE resp_decode_float(char *ptr) {
@@ -234,13 +234,13 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
   ulong len = RSTRING_LEN(msg);
   ulong data_len;
   if (len == 0) return Qnil;
-  
+
   switch (ptr[0]) {
     case '%': // hash
     case '|': // attributes hash
       data_len = resp_parse_length_field(ptr, len);
       return resp_decode_hash(stream, out_buffer, data_len);
-    
+
     case '*': // array
     case '~': // set
     case '>': // pub/sub push
@@ -276,7 +276,7 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
     default:
       rb_raise(rb_eRuntimeError, "Invalid character encountered");
   }
-  
+
   RB_GC_GUARD(msg);
 }
 
@@ -284,7 +284,7 @@ void write_buffer_init(struct um_write_buffer *buf, VALUE str) {
   size_t capa = 1 << 12;
   size_t len = RSTRING_LEN(str);
   while (capa < len) capa += 1 << 12;
-  
+
   rb_str_resize(str, capa);
   rb_str_set_len(str, len);
   buf->str = str;

data/ext/um/um_stream_class.c

@@ -88,7 +88,7 @@ void Init_Stream(void) {
   rb_define_alloc_func(cStream, Stream_allocate);
 
   rb_define_method(cStream, "initialize", Stream_initialize, 2);
-  
+
   rb_define_method(cStream, "get_line", Stream_get_line, 2);
   rb_define_method(cStream, "get_string", Stream_get_string, 2);
 

data/ext/um/um_sync.c

@@ -21,8 +21,8 @@ void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
       um_raise_on_error_result(op.result.res);
   }
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 }
 
 void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
@@ -38,8 +38,8 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   VALUE ret = um_fiber_switch(machine);
   um_check_completion(machine, &op);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 }
 
 void um_futex_wake_transient(struct um *machine, uint32_t *futex, uint32_t num_waiters) {

data/ext/um/um_utils.c

@@ -129,7 +129,7 @@ inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE st
   ulong count = RARRAY_LEN(strings);
   VALUE str = Qnil;
   VALUE converted = Qnil;
-  
+
   for (ulong i = 0; i < count; i++) {
     str = rb_ary_entry(strings, i);
     if (TYPE(str) != T_STRING) {

data/lib/uringmachine/fiber_scheduler.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+class UringMachine
+  class FiberScheduler
+    def initialize(machine)
+      @machine = machine
+    end
+
+    def p(o)
+      @machine.write(1, "#{o.inspect}\n")
+    rescue Errno::EINTR
+      retry
+    end
+
+    def join(*)
+      @machine.join(*)
+    end
+
+    def block(blocker, timeout)
+      p block: [blocker, timeout]
+
+    end
+
+    def unblock(blocker, fiber)
+      p unblock: [blocker, fiber]
+    end
+
+    def kernel_sleep(duration = nil)
+      # p sleep: [duration]
+      if duration
+        @machine.sleep(duration)
+      else
+        @machine.yield
+      end
+    end
+
+    def io_wait(io, events, timeout = nil)
+      timeout ||= io.timeout
+      p timeout: timeout
+      if timeout
+        p 1
+        @machine.timeout(timeout, Timeout::Error) {
+          p 2
+          @machine.poll(io.fileno, events).tap { p 3 }
+      }.tap { p 4 }
+      else
+        p 5
+        @machine.poll(io.fileno, events).tap { p 6 }
+
+      end
+    rescue => e
+      p e: e
+      raise
+    end
+
+    def fiber(&block)
+      f = @machine.spin(&block)
+      @machine.snooze
+      f
+    end
+
+    def io_write(io, buffer, length, offset)
+      p io_write: [io, buffer.get_string, length, offset]
+      @machine.write(io.fileno, buffer.get_string)
+    end
+
+    def io_read(io, buffer, length, offset)
+      # p io_read: [io, buffer, length, offset]
+      s = +''
+      length = buffer.size if length == 0
+      bytes = @machine.read(io.fileno, s, length)
+      buffer.set_string(s)
+      bytes
+    rescue SystemCallError => e
+      -e.errno
+    end
+
+    def io_pwrite(io, buffer, from, length, offset)
+      p io_pwrite: [io, buffer, from, length, offset]
+    end
+
+    def io_pread(io, buffer, from, length, offset)
+      p io_pread: [io, buffer, from, length, offset]
+    end
+
+    # def fiber(&block)
+    #   fiber = Fiber.new(blocking: false, &block)
+    #   unblock(nil, fiber)
+    #   # fiber.resume
+    #   return fiber
+    # end
+
+    # def kernel_sleep(duration = nil)
+    #   block(:sleep, duration)
+    # end
+
+    # def process_wait(pid, flags)
+    #   # This is a very simple way to implement a non-blocking wait:
+    #   Thread.new do
+    #     Process::Status.wait(pid, flags)
+    #   end.value
+    # end
+  end
+end

data/lib/uringmachine/version.rb

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

data/test/test_stream.rb

@@ -7,7 +7,7 @@ class StreamBaseTest < UMBaseTest
     super
     @rfd, @wfd = UM.pipe
     @stream = UM::Stream.new(@machine, @rfd)
-  end  
+  end
 end
 
 class StreamTest < StreamBaseTest
@@ -166,7 +166,7 @@ class StreamRespTest < StreamBaseTest
   end
 
   def test_resp_encode
-    s = UM::Stream    
+    s = UM::Stream
     assert_equal "_\r\n",             s.resp_encode(+'', nil)
     assert_equal "#t\r\n",            s.resp_encode(+'', true)
     assert_equal "#f\r\n",            s.resp_encode(+'', false)
@@ -174,7 +174,7 @@ class StreamRespTest < StreamBaseTest
     assert_equal ",42.1\r\n",         s.resp_encode(+'', 42.1)
     assert_equal "$6\r\nfoobar\r\n",  s.resp_encode(+'', 'foobar')
     assert_equal "$10\r\nפובאר\r\n",  s.resp_encode(+'', 'פובאר')
-    
+
     assert_equal "*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n",
       s.resp_encode(+'', ['foo', 'bar'])
 

data/test/test_um.rb

@@ -142,6 +142,31 @@ class ScheduleTest < UMBaseTest
     assert_kind_of TOError, e
   end
 
+  def test_timeout_stress
+    skip
+    # GC.stress = true
+    c = 0
+    fs = 100.times.map {
+      machine.spin {
+        q = UM::Queue.new
+        1000.times {
+          machine.sleep rand(0.001..0.005)
+          begin
+            machine.timeout(rand(0.001..0.06), TOError) do
+              machine.shift(q)
+            end
+          rescue => _e
+            c += 1
+            STDOUT << '*' if c % 1000 == 0
+          end
+        }
+      }
+    }
+    machine.join(*fs)
+  ensure
+    GC.stress = false    
+  end
+
   def test_timeout_with_raising_block
     e = nil
     begin
@@ -169,6 +194,17 @@ class ScheduleTest < UMBaseTest
     assert_equal 0, machine.pending_count
   end
 
+  def test_timeout_with_no_timeout
+    _r, w = UM.pipe
+    v = machine.timeout(0.1, TOError) { machine.write(w, 'foo') }
+
+    assert_equal 3, v
+
+    assert_equal 1, machine.pending_count
+    machine.sleep 0.01 # wait for cancelled CQE
+    assert_equal 0, machine.pending_count
+  end
+
   class TO2Error < RuntimeError; end
   class TO3Error < RuntimeError; end
 
@@ -1299,6 +1335,37 @@ class PipeTest < UMBaseTest
   end
 end
 
+class PollTest < UMBaseTest
+  def test_poll
+    rfd, wfd = UM.pipe
+
+    events = []
+    f1 = machine.spin do
+      events << :pre
+      events << machine.poll(rfd, UM::POLLIN)
+      events << :post
+    end
+
+    machine.snooze
+    assert_equal [:pre], events
+
+    machine.write(wfd, 'foo')
+    machine.snooze
+    assert_equal [:pre, UM::POLLIN, :post], events
+
+    ret = machine.poll(wfd, UM::POLLOUT)
+    assert_equal UM::POLLOUT, ret
+
+    machine.close(rfd)
+    ret = machine.poll(wfd, UM::POLLOUT | UM::POLLERR)
+    assert_equal UM::POLLOUT | UM::POLLERR, ret
+  end
+
+  def test_poll_bad_fd
+    assert_raises(Errno::EBADF) { machine.poll(9876, POLLIN) }
+  end
+end
+
 class WaitTest < UMBaseTest
   def test_waitpid
     skip if UM.kernel_version < 607
@@ -1396,6 +1463,17 @@ class StatxTest < UMBaseTest
     io.close
   end
 
+  def test_statx_mask
+    fd = @machine.open(__FILE__, UM::O_RDONLY)
+    ustat = machine.statx(fd, nil, UM::AT_EMPTY_PATH, UM::STATX_MTIME | UM::STATX_SIZE)
+    rstat = File.stat(__FILE__)
+
+    assert_equal rstat.size,        ustat[:size]
+    assert_equal rstat.mtime.to_i,  ustat[:mtime].to_i
+  ensure
+    @machine.close_async(fd)
+  end
+
   def test_statx_bad_path
     assert_raises(Errno::ENOENT) { machine.statx(UM::AT_FDCWD, 'foobar', 0, UM::STATX_ALL) }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: '0.18'
+  version: 0.19.1
 platform: ruby
 authors:
 - Sharon Rosner
@@ -92,6 +92,7 @@ files:
 - examples/bm_write.rb
 - examples/dns_client.rb
 - examples/echo_server.rb
+- examples/fiber_scheduler_demo.rb
 - examples/http_server.rb
 - examples/inout.rb
 - examples/nc.rb
@@ -119,6 +120,7 @@ files:
 - lib/uringmachine.rb
 - lib/uringmachine/actor.rb
 - lib/uringmachine/dns_resolver.rb
+- lib/uringmachine/fiber_scheduler.rb
 - lib/uringmachine/version.rb
 - supressions/ruby.supp
 - test/helper.rb
@@ -673,7 +675,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: A lean, mean io_uring machine
 test_files: []