uringmachine 0.32.0 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 299bd9cc7810b3d67352cf1c35e1bad8228d26dc1495d2e03e8283299347836a
-  data.tar.gz: 1241fd5922a26d0223a6d345984e7548bb4486160a5f7f70cb25f4356cde4736
+  metadata.gz: b6b62f0845e3bc8044bb1a21481d44c231d07a0fa191a92c7d4916ca6005a076
+  data.tar.gz: 7d2533a8c3c7c1fcc5d03c183a39a7fb789a2f05510cfbdce5bc08d9744969f3
 SHA512:
-  metadata.gz: 0075bd142ba474e475eb53fca3eb8e88bbb5fdba8214d7832b34582f3089e2720e99e069f49d7244b2c2cd9f5536ca5113589b9a5658d3f3679e3d6352043e1d
-  data.tar.gz: fe68ab2c66601a0aa5786e86b86173b5c6b94a1f58d0a7151546c4c596b1d625912ebd32670c8230ab301886f3a6a0a35edff1cd7a472f5253cb181e0156a1f7
+  metadata.gz: a3d7b2d5ae670304d8540fd6684c3e2a8548c491866cbd3a2ddf1fb65034517f55b6faa41da4f7a8965d243cd86ae965c3ad3e6cb2d5026097ac36cdf4911d8b
+  data.tar.gz: 800d1c0fe51d8399aefd799efe3338e060c15a6a072b86b33078696f2920f84e59d138e97dd4518eb71d2a00f7ac7c5dc8860caef3d24a645486946291a09dba

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.33.0 2026-04-12
+
+- Use buffer pool for `#read_each`, `#recv_each` methods
+- Remove `#setup_buffer_group`, `#send_bundle`
+
 # 0.32.0 2026-04-03
 
 - Rename `UM::Connection` to `UM::IO`

data/TODO.md

@@ -1,28 +1,13 @@
-- Rename Connection to IO
-
-  ```ruby
-  io = machine.io(fd)
-  l = io.read_line(4)
-  io.write('foo')
-  ```
-
-- Add `IO#fd`/`IO#target` method
-
-- Add `UM#inspect` (show size, modes)
-- Add `UM::IO#inspect` (show target, mode, pending bytes)
-
-## Reimplement multishot read/recv using buffer pool
-
-- remove `#setup_buffer_ring` method
-- use buffer pool, just like UM::Connection
-
 ## immediate
 
+- Add `IO#http_xxx` methods
+  - `#http_read_request_headers()`
+  - `#http_read_body(content_length)` (-1 means chunked TE)
+
 - Add tests for support for Set in `machine#await`
 - Add tests for support for Set, Array in `machine#join`
 - Add `UM#read_file` for reading entire file
 - Add `UM#write_file` for writing entire file
-- Rename stream methods: `:fd`, `:socket`, `:ssl`
 
 ## Balancing I/O with the runqueue
 
@@ -48,7 +33,7 @@
 - debounce
 
   ```ruby
-  debouncer = machine.debounce { }
+  debouncer = machine.debounce { ... }
   ```
 
 - happy eyeballs algo for TCP connect
@@ -104,8 +89,6 @@
 When doing a `call`, we need to provide a mailbox for the response. can this be
 automatic?
 
-##
-
 ## Syntax / pattern for launching/supervising multiple operations
 
 Select (see above):
@@ -125,3 +108,38 @@ machine.shift_select(*queues) #=> [result, queue]
   #        ['1.1.1.1:80', '2.2.2.2:80']
   tcp_connect_he(*addrs)
   ```
+
+## Character scanning in UM::IO
+
+```c
+// bitmaps for character types can be generated with a bit of Ruby:
+//
+// def t(r); (0..255).map { [it].pack('c') =~ r ? 1 : 0 }; end
+// def tn(r); (0..255).map { [it].pack('c') =~ r ? 0 : 1 }; end
+// def u64(bits); bits.reverse.join.to_i(2); end
+// def p(a); a.each_slice(64).map { u64(it) }; end
+
+// usage:
+//
+//   p(t(/[a-zA-Z0-9]/)).map { format('%016X', it) }
+
+
+// /[a-zA-Z0-9]/
+uint64_t alpha_numeric[] = [
+  0x000000000000FFC0,
+  0x7FFFFFE07FFFFFE0,
+  0x0000000000000000,
+  0x0000000000000000
+];
+
+// HTTP method: /[a-zA-Z]/    (3-12 characters)
+// header-key:  /[a-zA-Z\-]/  ()
+// path:        /^($/
+
+// check if character is in bitmap
+inline int test_char(char c, uint64 *bitmap) {
+  return bitmap[c / 64] & (1UL << (c % 64));
+}
+
+
+```

data/docs/um_api.md

@@ -43,26 +43,21 @@
 - `pop(queue)` - removes and returns a value off the end of the given queue.
 - `prep_timeout(interval)` - returns a timeout AsyncOp with the given interval.
 - `push(queue, value)` - adds the given value to the end of the given queue.
-- `read_each(fd, bgid) { |data| ... }` - reads repeatedly from the given fd
-  using the given buffer group id, yielding each chunk of data to the given
-  block.
+- `read_each(fd) { |data| ... }` - reads repeatedly from the given fd, yielding
+  each chunk of data to the given block.
 - `read(fd, buffer[, maxlen[, buffer_offset[, file_offset]]])` - reads from the
   given fd int o the given buffer (String or IO::Buffer).
-- `recv_each(fd, bgid, flags)` - receives from the given fd using the given
-  buffer group id, with the given flags.
+- `recv_each(fd, flags)` - receives repeatedly from the given fd with the given
+  flags.
 - `recv(fd, buffer, maxlen, flags)` - receives from the given fd into the given
   buffer.
 - `schedule(fiber, value)` - adds the given fiber to the runqueue with the given
   resume value.
 - `select(rfds, wfds, efds)` - selects ready fds from the given readable,
   writable and exeptable fds.
-- `send_bundle(fd, bgid, *strings)` - sends a bundle of buffers to the given fd
-  using the given buffer group id.
 - `send(fd, buffer, len, flags)` - sends to the given fd from the given buffer.
 - `sendv(fd, *buffers)` - sends multiple buffers to the given fd.
 - `setsockopt(fd, level, opt, value)` - sets a socket option.
-- `setup_buffer_ring(size, count)` - sets up a buffer ring and returns the
-  buffer group id.
 - `shift(queue)` - removes and returns a value from the head of given queue.
 - `shutdown_async(fd, how)` - shuts down the given socket fd without blocking.
 - `shutdown(fd, how)` - shuts down the given socket fd.

data/ext/um/um.c

@@ -49,12 +49,6 @@ inline void um_teardown(struct um *machine) {
   if (machine->sidecar_mode) um_sidecar_teardown(machine);
   if (machine->sidecar_signal) free(machine->sidecar_signal);
 
-  for (unsigned i = 0; i < machine->buffer_ring_count; i++) {
-    struct buf_ring_descriptor *desc = machine->buffer_rings + i;
-    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, i);
-    free(desc->buf_base);
-  }
-  machine->buffer_ring_count = 0;
   io_uring_queue_exit(&machine->ring);
   machine->ring_initialized = 0;
 
@@ -523,7 +517,6 @@ struct op_ctx {
   struct um *machine;
   struct um_op *op;
   int fd;
-  int bgid;
 
   struct um_queue *queue;
   void *read_buf;
@@ -870,25 +863,6 @@ VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv) {
   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_op_acquire(machine);
-  um_prep_op(machine, op, OP_SEND_BUNDLE, 2, 0);
-  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-	io_uring_prep_send_bundle(sqe, fd, 0, MSG_NOSIGNAL | MSG_WAITALL);
-	sqe->flags |= IOSQE_BUFFER_SELECT;
-	sqe->buf_group = bgid;
-
-  VALUE ret = um_yield(machine);
-
-  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(op->result.res);
-  um_op_release(machine, op);
-
-  RAISE_IF_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags) {
   void *ptr = um_prepare_read_buffer(buffer, maxlen, 0);
   struct um_op *op = um_op_acquire(machine);
@@ -1461,72 +1435,44 @@ VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue) {
   return rb_ensure(accept_into_queue_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
-int um_read_each_singleshot_loop(struct op_ctx *ctx) {
-  struct buf_ring_descriptor *desc = ctx->machine->buffer_rings + ctx->bgid;
-  ctx->read_maxlen = desc->buf_size;
-  ctx->read_buf = malloc(desc->buf_size);
-  int total = 0;
-
-  while (1) {
-    um_prep_op(ctx->machine, ctx->op, OP_READ, 2, 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);
-
-    VALUE ret = um_yield(ctx->machine);
-
-    if (likely(um_verify_op_completion(ctx->machine, ctx->op, true))) {
-      VALUE buf = rb_str_new(ctx->read_buf, ctx->op->result.res);
-      total += ctx->op->result.res;
-      rb_yield(buf);
-      RB_GC_GUARD(buf);
-    }
-    else {
-      RAISE_IF_EXCEPTION(ret);
-      return 0;
-    }
-    RB_GC_GUARD(ret);
-  }
-  return 0;
-}
-
 // // returns true if more results are expected
-int read_recv_each_multishot_process_result(struct op_ctx *ctx, struct um_op_result *result, int *total) {
+inline int read_recv_each_multishot_process_result(struct op_ctx *ctx, struct um_op_result *result, int *total) {
   if (result->res == 0)
     return false;
 
   *total += result->res;
-  VALUE buf = um_read_from_buffer_ring(ctx->machine, ctx->bgid, result->res, result->flags);
-  rb_yield(buf);
-  RB_GC_GUARD(buf);
-
-  // TTY devices might not support multishot reads:
-  // https://github.com/axboe/liburing/issues/1185. We detect this by checking
-  // if the F_MORE flag is absent, then switch to single shot mode.
-  if (unlikely(!(result->flags & IORING_CQE_F_MORE))) {
-    *total += um_read_each_singleshot_loop(ctx);
-    return false;
+  if (likely(result->segment)) {
+    VALUE buf = rb_str_new(result->segment->ptr, result->segment->len);
+    um_segment_checkin(ctx->machine, result->segment);
+    result->segment = NULL;
+    rb_yield(buf);
+    RB_GC_GUARD(buf);
   }
 
   return true;
 }
 
-void read_recv_each_prep(struct io_uring_sqe *sqe, struct op_ctx *ctx) {
+static inline void read_recv_each_prep(struct io_uring_sqe *sqe, struct op_ctx *ctx) {
+  bp_ensure_commit_level(ctx->machine);
+  ctx->op->bp_commit_level = ctx->machine->bp_commit_level;
+
   switch (ctx->op->kind) {
     case OP_READ_MULTISHOT:
-      io_uring_prep_read_multishot(sqe, ctx->fd, 0, -1, ctx->bgid);
+      io_uring_prep_read_multishot(sqe, ctx->fd, 0, -1, BP_BGID);
       return;
     case OP_RECV_MULTISHOT:
       io_uring_prep_recv_multishot(sqe, ctx->fd, NULL, 0, 0);
-	    sqe->buf_group = ctx->bgid;
+	    sqe->buf_group = BP_BGID;
 	    sqe->flags |= IOSQE_BUFFER_SELECT;
       return;
     default:
-      return;
+      um_raise_internal_error("Invalid multishot op");
   }
 }
 
 VALUE read_recv_each_start(VALUE arg) {
   struct op_ctx *ctx = (struct op_ctx *)arg;
+
   struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
   read_recv_each_prep(sqe, ctx);
   int total = 0;
@@ -1558,19 +1504,19 @@ VALUE read_recv_each_start(VALUE arg) {
   return Qnil;
 }
 
-VALUE um_read_each(struct um *machine, int fd, int bgid) {
+VALUE um_read_each(struct um *machine, int fd) {
   struct um_op *op = um_op_acquire(machine);
-  um_prep_op(machine, op, OP_READ_MULTISHOT, 2, OP_F_MULTISHOT);
+  um_prep_op(machine, op, OP_READ_MULTISHOT, 2, OP_F_MULTISHOT | OP_F_BUFFER_POOL);
 
-  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .bgid = bgid, .read_buf = NULL };
+  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .read_buf = NULL };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
-VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
+VALUE um_recv_each(struct um *machine, int fd, int flags) {
   struct um_op *op = um_op_acquire(machine);
-  um_prep_op(machine, op, OP_RECV_MULTISHOT, 2, OP_F_MULTISHOT);
+  um_prep_op(machine, op, OP_RECV_MULTISHOT, 2, OP_F_MULTISHOT | OP_F_BUFFER_POOL);
 
-  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
+  struct op_ctx ctx = { .machine = machine, .op = op, .fd = fd, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
@@ -1623,7 +1569,6 @@ extern VALUE SYM_ops_free;
 extern VALUE SYM_ops_transient;
 extern VALUE SYM_time_total_cpu;
 extern VALUE SYM_time_total_wait;
-extern VALUE SYM_buffer_groups;
 extern VALUE SYM_buffers_allocated;
 extern VALUE SYM_buffers_free;
 extern VALUE SYM_segments_free;

data/ext/um/um.h

@@ -56,7 +56,6 @@ enum um_op_kind {
   OP_RECV,
   OP_RECVMSG,
   OP_SEND,
-  OP_SEND_BUNDLE,
   OP_SENDMSG,
   OP_SENDV,
   OP_SOCKET,
@@ -168,15 +167,6 @@ struct um_op {
   };
 };
 
-struct buf_ring_descriptor {
-  struct io_uring_buf_ring *br;
-  size_t br_size;
-  unsigned buf_count;
-  unsigned buf_size;
-  unsigned buf_mask;
-	void *buf_base;
-};
-
 struct um_metrics {
   ulong total_ops;                // total ops submitted
   ulong total_switches;           // total fiber switches
@@ -199,8 +189,6 @@ struct um_metrics {
   double time_first_cpu;          // last seen time stamp
 };
 
-#define BUFFER_RING_MAX_COUNT 10
-
 struct um {
   VALUE self;
 
@@ -216,13 +204,9 @@ struct um {
   pthread_t sidecar_thread;
   uint32_t *sidecar_signal;
 
-  uint buffer_ring_count; // number of registered buffer rings
-
   uint size; // size of SQ
   uint sqpoll_mode; // SQPOLL mode enabled
 
-  struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
-
   struct um_op *transient_head; // list of pending transient ops
   VALUE pending_fibers; // set containing pending fibers
 
@@ -351,9 +335,7 @@ void um_raise_on_error_result(int result);
 int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size, int raise_on_bad_buffer);
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
 void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result);
-int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
-VALUE um_read_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 iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *total_len);
 void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv);
 
@@ -376,7 +358,7 @@ VALUE um_sleep(struct um *machine, double duration);
 VALUE um_periodically(struct um *machine, double interval);
 VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t buffer_offset, __u64 file_offset);
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
-VALUE um_read_each(struct um *machine, int fd, int bgid);
+VALUE um_read_each(struct um *machine, int fd);
 VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t len);
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
@@ -405,9 +387,8 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
 VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags);
 size_t um_send_raw(struct um *machine, int fd, const char *buffer, size_t len, int flags);
 VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv);
-VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags);
-VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
+VALUE um_recv_each(struct um *machine, int fd, int flags);
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);
 VALUE um_listen(struct um *machine, int fd, int backlog);
 VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);

data/ext/um/um_class.c

@@ -22,7 +22,6 @@ VALUE SYM_ops_free;
 VALUE SYM_ops_transient;
 VALUE SYM_time_total_cpu;
 VALUE SYM_time_total_wait;
-VALUE SYM_buffer_groups;
 VALUE SYM_buffers_allocated;
 VALUE SYM_buffers_free;
 VALUE SYM_segments_free;
@@ -129,18 +128,6 @@ VALUE UM_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-/* Creates a buffer group (buffer ring) with the given buffer size and buffer count.
- *
- * @param size [Integer] buffer size in bytes
- * @param count [Integer] number of buffers in group
- * @return [Integer] buffer group id
- */
-VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
-  struct um *machine = um_get_machine(self);
-  int bgid = um_setup_buffer_ring(machine, NUM2UINT(size), NUM2UINT(count));
-  return INT2NUM(bgid);
-}
-
 /* Returns the SQ (submission queue) size.
  *
  * @return [Integer] SQ size
@@ -408,21 +395,19 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   machine.read_each(fd, bgid) { |data| }
+ *   machine.read_each(fd) { |data| }
  *
- * Reads repeatedly from the given `fd` using the given buffer group id. The
- * buffer group should have been previously setup using `#setup_buffer_ring`.
- * Read data is yielded in an infinite loop to the given block.
+ * Reads repeatedly from the given fd. Read data is yielded in an infinite
+ * loop to the given block.
  *
  * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_read_multishot.3.html
  *
  * @param fd [Integer] file descriptor
- * @param bgid [Integer] buffer group id
  * @return [void]
  */
-VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
+VALUE UM_read_each(VALUE self, VALUE fd) {
   struct um *machine = um_get_machine(self);
-  return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
+  return um_read_each(machine, NUM2INT(fd));
 }
 
 /* call-seq:
@@ -836,38 +821,6 @@ VALUE UM_sendv(int argc, VALUE *argv, VALUE self) {
 }
 
 
-/* call-seq:
- *   machine.send_bundle(fd, bgid, *buffers) -> bytes_sent
- *
- * Sends data on the given socket from the given buffers using a registered
- * buffer group. The buffer group should have been previously registered using
- * `#setup_buffer_ring`.
- *
- * - https://www.man7.org/linux/man-pages/man2/send.2.html
- * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_send.3.html
- *
- * @overload send_bundle(fd, bgid, *buffers)
- *   @param fd [Integer] file descriptor
- *   @param bgid [Integer] buffer group id
- *   @param *buffers [Array<String, IO::Buffer>] buffers
- *   @return [Integer] number of bytes sent
- */
-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);
-}
-
 /* call-seq:
  *   machine.recv(fd, buffer, maxlen, flags) -> bytes_received
  *
@@ -888,23 +841,20 @@ VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
 }
 
 /* call-seq:
- *   machine.recv_each(fd, bgid, flags) { |data| ... }
+ *   machine.recv_each(fd, flags) { |data| ... }
  *
- * Repeatedlty receives data from the given socket in an infinite loop using the
- * given buffer group id. The buffer group should have been previously setup
- * using `#setup_buffer_ring`.
+ * Repeatedlty receives data from the given socket in an infinite loop.
  *
  * - https://www.man7.org/linux/man-pages/man2/recv.2.html
  * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_recv.3.html
  *
  * @param fd [Integer] file descriptor
- * @param bgid [Integer] buffer group id
  * @param flags [Integer] flags mask
  * @return [void]
  */
-VALUE UM_recv_each(VALUE self, VALUE fd, VALUE bgid, VALUE flags) {
+VALUE UM_recv_each(VALUE self, VALUE fd, VALUE flags) {
   struct um *machine = um_get_machine(self);
-  return um_recv_each(machine, NUM2INT(fd), NUM2INT(bgid), NUM2INT(flags));
+  return um_recv_each(machine, NUM2INT(fd), NUM2INT(flags));
 }
 
 /* call-seq:
@@ -1512,8 +1462,6 @@ void Init_UM(void) {
   rb_define_method(cUM, "sidecar_start", UM_sidecar_start, 0);
   rb_define_method(cUM, "sidecar_stop", UM_sidecar_stop, 0);
 
-  rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
-
   rb_define_method(cUM, "schedule", UM_schedule, 2);
   rb_define_method(cUM, "snooze", UM_snooze, 0);
   rb_define_method(cUM, "timeout", UM_timeout, 2);
@@ -1527,7 +1475,7 @@ void Init_UM(void) {
   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, "read_each", UM_read_each, 1);
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
@@ -1554,11 +1502,10 @@ void Init_UM(void) {
   rb_define_method(cUM, "getsockopt", UM_getsockopt, 3);
   rb_define_method(cUM, "listen", UM_listen, 2);
   rb_define_method(cUM, "recv", UM_recv, 4);
-  rb_define_method(cUM, "recv_each", UM_recv_each, 3);
+  rb_define_method(cUM, "recv_each", UM_recv_each, 2);
   rb_define_method(cUM, "send", UM_send, 4);
   rb_define_method(cUM, "sendv", UM_sendv, -1);
 
-  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);
@@ -1595,7 +1542,6 @@ void Init_UM(void) {
   SYM_ops_transient           = ID2SYM(rb_intern("ops_transient"));
   SYM_time_total_cpu          = ID2SYM(rb_intern("time_total_cpu"));
   SYM_time_total_wait         = ID2SYM(rb_intern("time_total_wait"));
-  SYM_buffer_groups           = ID2SYM(rb_intern("buffer_groups"));
   SYM_buffers_allocated       = ID2SYM(rb_intern("buffers_allocated"));
   SYM_buffers_free            = ID2SYM(rb_intern("buffers_free"));
   SYM_segments_free           = ID2SYM(rb_intern("segments_free"));

data/ext/um/um_io.c

@@ -177,7 +177,6 @@ int io_get_more_segments_bp(struct um_io *io) {
 
         um_op_release(io->machine, io->op);
         io->op = NULL;
-        // io_multishot_op_start(io);
       }
       else {
         um_op_release(io->machine, io->op);

data/ext/um/um_op.c

@@ -20,7 +20,6 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_RECV:               return "OP_RECV";
     case OP_RECVMSG:            return "OP_RECVMSG";
     case OP_SEND:               return "OP_SEND";
-    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";

data/ext/um/um_utils.c

@@ -115,92 +115,6 @@ inline int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size
   return true;
 }
 
-int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
-  if (machine->buffer_ring_count == BUFFER_RING_MAX_COUNT)
-    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;
-  desc->buf_size = size;
-  desc->br_size = sizeof(struct io_uring_buf) * desc->buf_count;
-  desc->buf_mask = io_uring_buf_ring_mask(desc->buf_count);
-
-	void *mapped = mmap(
-    NULL, desc->br_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
-  );
-  if (mapped == MAP_FAILED)
-    um_raise_internal_error("Failed to allocate buffer ring");
-
-  desc->br = (struct io_uring_buf_ring *)mapped;
-  io_uring_buf_ring_init(desc->br);
-
-  unsigned bg_id = machine->buffer_ring_count;
-  int ret;
-  desc->br = io_uring_setup_buf_ring(&machine->ring, count, bg_id, 0, &ret);
-  if (!desc->br) {
-    munmap(desc->br, desc->br_size);
-    rb_syserr_fail(-ret, strerror(-ret));
-  }
-
-  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);
-      um_raise_internal_error("Failed to allocate buffers");
-    }
-
-    char *ptr = desc->buf_base;
-    for (unsigned i = 0; i < desc->buf_count; i++) {
-	  	io_uring_buf_ring_add(desc->br, ptr, desc->buf_size, i, desc->buf_mask, i);
-      ptr += desc->buf_size;
-	  }
-	  io_uring_buf_ring_advance(desc->br, desc->buf_count);
-  }
-  machine->buffer_ring_count++;
-  return bg_id;
-}
-
-inline VALUE um_read_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags) {
-  if (!result) return Qnil;
-
-  unsigned buf_idx = flags >> IORING_CQE_BUFFER_SHIFT;
-  struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
-  char *src = (char *)desc->buf_base + desc->buf_size * buf_idx;
-  // TODO: add support for UTF8
-  // buf = rd->utf8_encoding ? rb_utf8_str_new(src, cqe->res) : rb_str_new(src, cqe->res);
-  VALUE buf = rb_str_new(src, result);
-
-  // add buffer back to buffer ring
-  io_uring_buf_ring_add(
-    desc->br, src, desc->buf_size, buf_idx, desc->buf_mask, 0
-  );
-  io_uring_buf_ring_advance(desc->br, 1);
-
-  RB_GC_GUARD(buf);
-  return buf;
-}
-
-inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings) {
-  static ID ID_to_s = 0;
-
-  struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
-  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) {
-      if (!ID_to_s) ID_to_s = rb_intern("to_s");
-      if (NIL_P(converted)) converted = rb_ary_new();
-      str = rb_funcall(str, ID_to_s, 0);
-      rb_ary_push(converted, str);
-    }
-    io_uring_buf_ring_add(desc->br, RSTRING_PTR(str), RSTRING_LEN(str), i, desc->buf_mask, i);
-  }
-  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);
 }

data/lib/uringmachine/version.rb

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

data/test/test_io.rb

@@ -33,7 +33,7 @@ class IOTest < IOBaseTest
     )
   end
 
-  def test_connection_basic_usage
+  def test_io_basic_usage
     assert_equal [0, 0, 0, 0, 0], buffer_metrics
     machine.write(@wfd, "foobar")
     machine.close(@wfd)
@@ -53,7 +53,7 @@ class IOTest < IOBaseTest
     assert_equal 0, machine.metrics[:ops_pending]
   end
 
-  def test_connection_clear
+  def test_io_clear
     rfd, wfd = UM.pipe
     conn = UM::IO.new(machine, rfd)
 
@@ -77,7 +77,7 @@ class IOTest < IOBaseTest
     machine.close(wfd) rescue nil
   end
 
-  def test_connection_big_read
+  def test_io_big_read
     s1, s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     conn = UM::IO.new(machine, s2)
 
@@ -96,7 +96,7 @@ class IOTest < IOBaseTest
     machine.join(f)
   end
 
-  def test_connection_buffer_reuse
+  def test_io_buffer_reuse
     s1, s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     conn = UM::IO.new(machine, s2)
 
@@ -131,7 +131,7 @@ class IOTest < IOBaseTest
     machine.join(f)
   end
 
-  def test_connection_read_line
+  def test_io_read_line
     machine.write(@wfd, "foo\nbar\r\nbaz")
     machine.close(@wfd)
 
@@ -145,7 +145,7 @@ class IOTest < IOBaseTest
     assert_equal "baz", conn.read(-6)
   end
 
-  def test_connection_read_line_segmented
+  def test_io_read_line_segmented
     machine.write(@wfd, "foo\n")
     assert_equal 'foo', conn.read_line(0)
 
@@ -163,7 +163,7 @@ class IOTest < IOBaseTest
     assert_nil conn.read_line(0)
   end
 
-  def test_connection_read_line_maxlen
+  def test_io_read_line_maxlen
     machine.write(@wfd, "foobar\r\n")
 
     assert_nil conn.read_line(3)
@@ -188,7 +188,7 @@ class IOTest < IOBaseTest
     assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 17], buffer_metrics
   end
 
-  def test_connection_read
+  def test_io_read
     machine.write(@wfd, "foobarbazblahzzz")
     machine.close(@wfd)
 
@@ -198,7 +198,7 @@ class IOTest < IOBaseTest
     assert_nil conn.read(4)
   end
 
-  def test_connection_read_zero_len
+  def test_io_read_zero_len
     machine.write(@wfd, "foobar")
 
     assert_equal 'foobar', conn.read(0)
@@ -209,7 +209,7 @@ class IOTest < IOBaseTest
     assert_nil conn.read(0)
   end
 
-  def test_connection_read_negative_len
+  def test_io_read_negative_len
     machine.write(@wfd, "foobar")
 
     assert_equal 'foo', conn.read(-3)
@@ -221,7 +221,7 @@ class IOTest < IOBaseTest
     assert_nil conn.read(-3)
   end
 
-  def test_connection_read_to_delim
+  def test_io_read_to_delim
     machine.write(@wfd, "abc,def,ghi")
     machine.close(@wfd)
 
@@ -233,7 +233,7 @@ class IOTest < IOBaseTest
     assert_equal 'ghi', conn.read_to_delim(',', -3)
   end
 
-  def test_connection_read_to_delim_invalid_delim
+  def test_io_read_to_delim_invalid_delim
     machine.write(@wfd, "abc,def,ghi")
 
     assert_raises(ArgumentError) { conn.read_to_delim(:foo, 0) }
@@ -242,7 +242,7 @@ class IOTest < IOBaseTest
     assert_raises(UM::Error) { conn.read_to_delim('🙂', 0) }
   end
 
-  def test_connection_skip
+  def test_io_skip
     machine.write(@wfd, "foobarbaz")
 
     conn.skip(2)
@@ -252,7 +252,7 @@ class IOTest < IOBaseTest
     assert_equal 'az', conn.read(0)
   end
 
-  def test_connection_big_data
+  def test_io_big_data
     data = SecureRandom.random_bytes(300_000)
     fiber = machine.spin {
       machine.writev(@wfd, data)
@@ -273,7 +273,7 @@ class IOTest < IOBaseTest
     assert_equal data, received.join
   end
 
-  def test_connection_read_each
+  def test_io_read_each
     bufs = []
     f = machine.spin do
       bufs << :ready
@@ -323,7 +323,7 @@ class IOWriteTest < UMBaseTest
     super
   end
 
-  def test_connection_write_single_buf
+  def test_io_write_single_buf
     assert_equal 3, conn.write('foo')
 
     buf = +''
@@ -331,7 +331,7 @@ class IOWriteTest < UMBaseTest
     assert_equal 'foo', buf
   end
 
-  def test_connection_write_multi_buf
+  def test_io_write_multi_buf
     assert_equal 6, conn.write('foo', 'bar')
 
     buf = +''
@@ -339,7 +339,7 @@ class IOWriteTest < UMBaseTest
     assert_equal 'foobar', buf
   end
 
-  def test_connection_write_socket_mode
+  def test_io_write_socket_mode
     conn = machine.io(@s2, :socket)
 
     assert_equal 6, conn.write('foo', 'bar')
@@ -349,7 +349,7 @@ class IOWriteTest < UMBaseTest
     assert_equal 'foobar', buf
   end
 
-  def test_connection_write_ssl_mode
+  def test_io_write_ssl_mode
     ssl1 = OpenSSL::SSL::SSLSocket.new(IO.for_fd(@s1), Localhost::Authority.fetch.server_context)
     ssl1.sync_close = true
     ssl2 = OpenSSL::SSL::SSLSocket.new(IO.for_fd(@s2), OpenSSL::SSL::SSLContext.new)
@@ -380,7 +380,7 @@ class IOWriteTest < UMBaseTest
 end
 
 class IORespTest < IOBaseTest
-  def test_connection_resp_read
+  def test_io_resp_read
     machine.write(@wfd, "+foo bar\r\n")
     assert_equal "foo bar", conn.resp_read
 
@@ -443,7 +443,7 @@ class IORespTest < IOBaseTest
     assert_equal({ 'a' => 42, 'b' => ['foo', 'bar', 'baz'] }, conn.resp_read)
   end
 
-  def test_connection_resp_read_segmented
+  def test_io_resp_read_segmented
     machine.write(@wfd, "\n")
     assert_equal "", conn.read_line(0)
 
@@ -458,7 +458,7 @@ class IORespTest < IOBaseTest
     assert_equal "bazbug", conn.resp_read
   end
 
-  def test_connection_resp_write
+  def test_io_resp_write
     writer = machine.io(@wfd)
 
     writer.resp_write(nil);
@@ -489,7 +489,7 @@ class IORespTest < IOBaseTest
     assert_equal "%2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n:42\r\n", conn.read(-100)
   end
 
-  def test_connection_resp_encode
+  def test_io_resp_encode
     s = UM::IO
     assert_equal "_\r\n",             s.resp_encode(+'', nil)
     assert_equal "#t\r\n",            s.resp_encode(+'', true)
@@ -537,7 +537,7 @@ class IOStressTest < UMBaseTest
     end
   end
 
-  def test_connection_server_big_lines
+  def test_io_server_big_lines
     server_fibers = []
     server_fibers << machine.spin do
       machine.accept_each(@listen_fd) { |fd|
@@ -580,7 +580,7 @@ class IOStressTest < UMBaseTest
     assert_equal msg * client_count, @received.map { it + "\n" }.join
   end
 
-  def test_connection_server_http
+  def test_io_server_http
     server_fibers = []
     server_fibers << machine.spin do
       machine.accept_each(@listen_fd) { |fd|
@@ -621,7 +621,7 @@ class IOStressTest < UMBaseTest
 end
 
 class IODevRandomTest < UMBaseTest
-  def test_connection_dev_random_read_line
+  def test_io_dev_random_read_line
     fd = machine.open('/dev/random', UM::O_RDONLY)
     conn = UM::IO.new(machine, fd)
 
@@ -643,7 +643,7 @@ class IODevRandomTest < UMBaseTest
     n.times { acc << conn.read_line(0) }
   end
 
-  def test_connection_dev_random_read_line_concurrent
+  def test_io_dev_random_read_line_concurrent
     acc = []
     c = 1
     n = 100000
@@ -654,7 +654,7 @@ class IODevRandomTest < UMBaseTest
     assert_equal c * n, acc.size
   end
 
-  def test_connection_dev_random_read
+  def test_io_dev_random_read
     fd = machine.open('/dev/random', UM::O_RDONLY)
     conn = UM::IO.new(machine, fd)
 
@@ -677,7 +677,7 @@ class IODevRandomTest < UMBaseTest
 end
 
 class IOModeTest < UMBaseTest
-  def test_connection_default_mode
+  def test_io_default_mode
     r, w = UM.pipe
     conn = UM::IO.new(machine, r)
     assert_equal :fd, conn.mode
@@ -686,7 +686,7 @@ class IOModeTest < UMBaseTest
     machine.close(w) rescue nil
   end
 
-  def test_connection_default_mode_ssl
+  def test_io_default_mode_ssl
     authority = Localhost::Authority.fetch
     @server_ctx = authority.server_context
     sock1, sock2 = UNIXSocket.pair
@@ -699,7 +699,7 @@ class IOModeTest < UMBaseTest
     sock2&.close rescue nil
   end
 
-  def test_connection_socket_mode_non_socket
+  def test_io_socket_mode_non_socket
     r, w = UM.pipe
     machine.write(w, 'foobar')
     machine.close(w)
@@ -713,7 +713,7 @@ class IOModeTest < UMBaseTest
     machine.close(w) rescue nil
   end
 
-  def test_connection_socket_mode_socket
+  def test_io_socket_mode_socket
     r, w = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     machine.write(w, 'foobar')
     machine.close(w)
@@ -727,7 +727,7 @@ class IOModeTest < UMBaseTest
     machine.close(w) rescue nil
   end
 
-  def test_connection_ssl_mode
+  def test_io_ssl_mode
     authority = Localhost::Authority.fetch
     @server_ctx = authority.server_context
     sock1, sock2 = UNIXSocket.pair
@@ -775,7 +775,7 @@ class IOModeTest < UMBaseTest
 end
 
 class IOByteCountsTest < IOBaseTest
-  def test_connection_byte_counts
+  def test_io_byte_counts
     machine.write(@wfd, "foobar")
 
     assert_equal 0, conn.consumed

data/test/test_um.rb

@@ -653,8 +653,6 @@ class ReadEachTest < UMBaseTest
   def test_read_each
     r, w = IO.pipe
     bufs = []
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     f = Fiber.new do
       w << 'foo'
@@ -669,7 +667,7 @@ class ReadEachTest < UMBaseTest
 
     machine.schedule(f, nil)
 
-    machine.read_each(r.fileno, bgid) do |buf|
+    machine.read_each(r.fileno) do |buf|
       bufs << buf
     end
 
@@ -681,15 +679,13 @@ class ReadEachTest < UMBaseTest
   # send once and close write fd
   def test_read_each_raising_1
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
     w.close
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -704,14 +700,12 @@ class ReadEachTest < UMBaseTest
   # send once and leave write fd open
   def test_read_each_raising_2
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -728,15 +722,13 @@ class ReadEachTest < UMBaseTest
   # send twice
   def test_read_each_raising_3
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
     w << 'bar'
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -752,7 +744,6 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_break
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     t = Thread.new do
       sleep 0.1
@@ -762,7 +753,7 @@ class ReadEachTest < UMBaseTest
     end
 
     bufs = []
-    machine.read_each(r.fileno, bgid) do |b|
+    machine.read_each(r.fileno) do |b|
       bufs << b
       break
     end
@@ -779,13 +770,12 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_timeout
     r, _w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     bufs = []
     e = nil
     begin
       machine.timeout(0.01, TOError) do
-        machine.read_each(r.fileno, bgid) do |b|
+        machine.read_each(r.fileno) do |b|
           bufs << b
         end
       end
@@ -804,10 +794,9 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_bad_file
     _r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     assert_raises(Errno::EBADF) do
-      machine.read_each(w.fileno, bgid)
+      machine.read_each(w.fileno)
     end
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 256, machine.metrics[:ops_free]
@@ -1892,15 +1881,9 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
-    bgid2 = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 1, bgid2
-
     bufs = []
 
-    machine.recv_each(fd, bgid, 0) do |buf|
+    machine.recv_each(fd, 0) do |buf|
       bufs << buf
     end
     assert_equal ['abc', 'def', 'ghi'], bufs
@@ -1922,14 +1905,11 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
     bufs = []
     e = nil
     begin
       machine.timeout(0.01, TOError) do
-        machine.recv_each(fd, bgid, 0) do |buf|
+        machine.recv_each(fd, 0) do |buf|
           bufs << buf
         end
       end
@@ -1953,9 +1933,6 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
     bufs = []
     e = nil
 
@@ -1965,7 +1942,7 @@ class RecvEachTest < UMBaseTest
     }
 
     begin
-      machine.recv_each(fd, bgid, 0) do |buf|
+      machine.recv_each(fd, 0) do |buf|
         bufs << buf
       end
     rescue => e
@@ -3097,61 +3074,6 @@ class ForkTest < UMBaseTest
   end
 end
 
-class SendBundleTest < UMBaseTest
-  def setup
-    super
-    @client_fd, @server_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
-  end
-
-  def test_send_bundle_splat
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = ['foo', 'bar', 'bazzzzz']
-    len = strs.inject(0) { |len, s| len + s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, *strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.join, buf
-  end
-
-  def test_send_bundle_array
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = ['foo', 'bar', 'bazzzzz']
-    len = strs.inject(0) { |len, s| len + s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.join, buf
-  end
-
-  def test_send_bundle_non_strings
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = [42, 'bar', false]
-    len = strs.inject(0) { |len, s| len + s.to_s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.map(&:to_s).join, buf
-  end
-end
-
 class MetricsTest < UMBaseTest
   def test_metrics_empty
     assert_equal({

metadata

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