uringmachine 0.16 → 0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31417b87cc8d871a492fccfd525b4f991b7ab69546503797c675bdaa07dfe00d
-  data.tar.gz: b64826a1efb663adad00c61733c37234ace8637725447d85a7b5819cde652cf8
+  metadata.gz: 2e4b4b986a75268a9de9dbafacd7d2a5c31cc08058b86a9681757be698fe697e
+  data.tar.gz: 99007eb49069d9cfebc70ce6da9c45cbbd5e7c4d518892869ddcb55c401b1cdb
 SHA512:
-  metadata.gz: eb438c42b59e8c601bc1a591e9d750fd475bf416e5e44945c6492a4ef46bf20daf89ed6af002e36a9df7f4f2f9d79689976080262cc479723cd5b963e7de4e4f
-  data.tar.gz: 69503b7a95f2316e4847b1f65b667c2f023df4a4388c3f15fffad5b16fc6577ab537d579523ec48a69a79f282cefab926a00821e96d63e274edebfa4cc663e57
+  metadata.gz: f7c55065ac4aef687f91236bf5cb55be4756dee002e61e627775a93d74d069a8ca45372c43cc71d31efce4b33cfb623443a7ef53b929563b48ec8a0e59cbdf92
+  data.tar.gz: 066a85ff0f7218e410abdc89e63cc20ae1ff858ecbc857a84f83ab812286fb1f6dd099d44e254452f466d66569046de3cffe0ba9d7d4f52bb1717670a34c5398

data/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: noteflakes

data/.gitmodules

@@ -1,3 +1,7 @@
 [submodule "vendor/liburing"]
 	path = vendor/liburing
 	url = https://github.com/axboe/liburing
+
+[submodule "vendor/libressl"]
+	path = vendor/libressl
+	url = https://github.com/libressl/portable

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 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
+
+# 0.17 2025-07-15
+
+- Add `#send_bundle` method
+
 # 2025-07-06 Version 0.16
 
 - Load UM version on require

data/TODO.md

@@ -1,13 +1,22 @@
-# ops
+## useful concurrency tools
+
+- debounce
+
+  ```ruby
+  debouncer = UM.debounce { }
+  ```
+
+## ops
 
 - [ ] multishot timeout
   - [v] machine.periodically(interval) { ... }
   - [ ] machine.prep_timeout_multishot(interval)
 
+- writev
 - splice / - tee
 - sendto
 - recvfrom
-- poll_add / poll_remove / poll_multishot / poll_update
+- poll_multishot
 - fsync
 - mkdir / mkdirat
 - link / linkat / unlink / unlinkat / symlink
@@ -17,12 +26,12 @@
 - getxattr / setxattr
 - send_bundle / recv_bundle (kernel >= 6.10)
 
-# actors
+## actors
 
 When doing a `call`, we need to provide a mailbox for the response. can this be
 automatic?
 
-# streams
+## streams
 
 We're still missing:
 

data/examples/bm_send.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+
+@machine = UM.new
+
+make_socket_pair = -> do
+  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
+
+@client_fd, @server_fd = make_socket_pair.()
+
+@read_buf = +''
+@read_fiber = @machine.spin do
+  while true
+    @machine.read(@client_fd, @read_buf, 65536, 0)
+  end
+end
+
+STR_COUNT = ARGV[0]&.to_i || 3
+STR_SIZE = ARGV[1]&.to_i || 100
+
+@parts = ['*' * STR_SIZE] * STR_COUNT
+
+@server_io = IO.new(@server_fd)
+@server_io.sync = true
+def io_write
+  @server_io.write(*@parts)
+  @machine.snooze
+end
+
+def um_write
+  str = @parts.join
+  len = str.bytesize
+
+  while len > 0
+    ret = @machine.write(@server_fd, str, len)
+    len -= ret
+    str = str[ret..-1] if len > 0
+  end
+end
+
+def um_send
+  str = @parts.join
+  @machine.send(@server_fd, str, str.bytesize, UM::MSG_WAITALL)
+end
+
+@bgid = @machine.setup_buffer_ring(0, 8)
+def um_send_bundle
+  @machine.send_bundle(@server_fd, @bgid, @parts)
+end
+
+# um_send_bundle
+# 10.times { @machine.snooze }
+# exit
+
+p(STR_COUNT:, STR_SIZE:)
+
+Benchmark.ips do |x|
+  x.report('IO#write')       { io_write }
+  x.report('UM#write')       { um_write }
+  x.report('UM#send')        { um_send }
+  x.report('UM#send_bundle') { um_send_bundle }
+  x.compare!
+end

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

@@ -74,6 +74,9 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
   // );
 
   if (op->flags & OP_F_FREE_ON_COMPLETE) {
+    if (op->flags & OP_F_TRANSIENT)
+      um_op_transient_remove(machine, op);
+
     um_op_free(machine, op);
     return;
   }
@@ -249,8 +252,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) {
@@ -337,8 +342,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) {
@@ -354,10 +360,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) {
@@ -372,7 +379,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;
 }
 
@@ -390,17 +398,21 @@ 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_FREE_ON_COMPLETE);
+  um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_TRANSIENT | 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);
+  um_op_transient_add(machine, op);
+
   return str;
 }
 
@@ -414,8 +426,9 @@ 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) {
@@ -438,8 +451,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) {
@@ -452,8 +466,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) {
@@ -466,8 +481,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) {
@@ -481,8 +497,30 @@ 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 ret;
+}
+
+VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
+  um_add_strings_to_buffer_ring(machine, bgid, strings);
+
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SEND_BUNDLE, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+
+	io_uring_prep_send_bundle(sqe, fd, 0, MSG_WAITALL);
+	sqe->flags |= IOSQE_BUFFER_SELECT;
+	sqe->buf_group = bgid;
+
+  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_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
@@ -499,8 +537,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) {
@@ -513,8 +553,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) {
@@ -527,8 +568,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) {
@@ -552,8 +594,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) {
@@ -575,8 +618,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) {
@@ -591,14 +635,14 @@ 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);
-
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_shutdown(sqe, fd, how);
 
@@ -615,8 +659,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) {
@@ -631,8 +691,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));
 }
@@ -661,24 +721,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);
 }
@@ -694,8 +753,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;
@@ -764,8 +826,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);
   }
 }
 
@@ -813,8 +878,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;
@@ -861,8 +929,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

@@ -36,6 +36,7 @@ enum op_kind {
   OP_ACCEPT,
   OP_RECV,
   OP_SEND,
+  OP_SEND_BUNDLE,
   OP_SOCKET,
   OP_CONNECT,
   OP_BIND,
@@ -44,7 +45,8 @@ enum op_kind {
   OP_SETSOCKOPT,
   OP_SHUTDOWN,
   OP_SHUTDOWN_ASYNC,
-  
+
+  OP_POLL,
   OP_WAITPID,
 
   OP_FUTEX_WAIT,
@@ -202,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);
@@ -210,6 +212,7 @@ 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);
+void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
 
 struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
@@ -233,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);
@@ -242,6 +246,7 @@ VALUE um_accept_each(struct um *machine, int fd);
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags);
 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_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 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);

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

@@ -193,6 +193,22 @@ VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
   return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
 }
 
+VALUE UM_send_bundle(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = um_get_machine(self);
+  VALUE fd;
+  VALUE bgid;
+  VALUE strings;
+  rb_scan_args(argc, argv, "2*", &fd, &bgid, &strings);
+
+  if (RARRAY_LEN(strings) == 1) {
+    VALUE first = rb_ary_entry(strings, 0);
+    if (TYPE(first) == T_ARRAY)
+      strings = first;
+  }
+
+  return um_send_bundle(machine, NUM2INT(fd), NUM2INT(bgid), strings);
+}
+
 VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
   struct um *machine = um_get_machine(self);
   return um_recv(machine, NUM2INT(fd), buffer, NUM2INT(maxlen), NUM2INT(flags));
@@ -311,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));
@@ -366,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);
@@ -377,6 +399,7 @@ void Init_UM(void) {
   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, "send_bundle", UM_send_bundle, -1);
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
   rb_define_method(cUM, "socket", UM_socket, 4);
   rb_define_method(cUM, "shutdown", UM_shutdown, 2);