uringmachine 0.32.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 299bd9cc7810b3d67352cf1c35e1bad8228d26dc1495d2e03e8283299347836a
-  data.tar.gz: 1241fd5922a26d0223a6d345984e7548bb4486160a5f7f70cb25f4356cde4736
+  metadata.gz: 8704dd734601efec57a8bb095c43dc44f752cd01b0cbe04c550fbc321fb2fbfa
+  data.tar.gz: 86d5a99e31296951b2fb565bd12a60b64f6ef43ba331c16bb1307d5a27b27971
 SHA512:
-  metadata.gz: 0075bd142ba474e475eb53fca3eb8e88bbb5fdba8214d7832b34582f3089e2720e99e069f49d7244b2c2cd9f5536ca5113589b9a5658d3f3679e3d6352043e1d
-  data.tar.gz: fe68ab2c66601a0aa5786e86b86173b5c6b94a1f58d0a7151546c4c596b1d625912ebd32670c8230ab301886f3a6a0a35edff1cd7a472f5253cb181e0156a1f7
+  metadata.gz: e83aece1507a0be85ccbcc7bd229dbe2976fab489a59bb07814e147f51de5a9e526a4a4fbc08ddc5b3b01d96bfd132ad79de40acb58bcfca31eaab2b1516df01
+  data.tar.gz: 0d5572ccc1822cf50d9c0d3e1ad0fccb39f80640b753a9962a737a58ca6ea0024cb3342fe3c91d097f4f785186ded75f3cde587463409a2148ddb81bfef8de8f

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 1.0.0 2026-04-27
+
+- Remove custom -Wxxx CFLAGS
+
+# 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/README.md

@@ -37,7 +37,7 @@ implementation that allows integration with the entire Ruby ecosystem.
 - Excellent performance characteristics for concurrent I/O-bound applications.
 - `Fiber::Scheduler` implementation to automatically integrate with the Ruby
   ecosystem in a transparent fashion.
-- [IO](#io-api) class with automatic buffer management for reading.
+- [UM::IO](#io-higher-level-api) class with automatic buffer management for reading.
 - Optimized I/O for encrypted SSL connections.
 
 ## Design
@@ -286,7 +286,7 @@ fiber = Fiber.schedule do
 end
 ```
 
-## IO API
+## IO Higher-level API
 
 `UringMachine::IO` is a class designed for efficiently read from and write to a
 socket or other file descriptor. The IO class is ideal for implementing

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,36 @@ 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/benchmark/bm_redis_client.rb

@@ -4,7 +4,7 @@ require_relative './common'
 require 'securerandom'
 
 C = ENV['C']&.to_i || 50
-I = 10
+I = 100
 puts "C=#{C}"
 
 class UMBenchmark
@@ -12,6 +12,7 @@ class UMBenchmark
 
   def start_redis_server
     `docker run --name #{CONTAINER_NAME} -d -p 6379:6379 redis:latest`
+    create_redis_conn
   end
 
   def stop_redis_server
@@ -22,7 +23,7 @@ class UMBenchmark
     Redis.new
   rescue
     if retries < 3
-      sleep 0.5
+      sleep 0.2
       create_redis_conn(retries + 1)
     else
     raise
@@ -31,7 +32,7 @@ class UMBenchmark
 
   def query_redis(conn)
     conn.set('abc', 'def')
-    p conn.get('abc')
+    conn.get('abc')
   end
 
   def with_container
@@ -45,25 +46,33 @@ class UMBenchmark
   stop_redis_server
   end
 
+  def create_redis_conn(retries = 0)
+    Redis.new
+  rescue
+    raise if retries >= 3
+
+    sleep 0.5
+    create_redis_conn(retries + 1)
+  end
+
   def benchmark
     with_container {
       Benchmark.bm { run_benchmarks(it) }
     }
   end
 
-  # def do_threads(threads, ios)
-  #   C.times.map do
-  #     threads << Thread.new do
-  #       conn = create_redis_conn
-  #       I.times { query_redis(conn) }
-  #     ensure
-  #       conn.close
-  #     end
-  #   end
-  # end
+  def do_threads(threads, ios)
+    C.times.map do
+      threads << Thread.new do
+        conn = create_redis_conn
+        I.times { query_redis(conn) }
+      ensure
+        conn.close
+      end
+    end
+  end
 
   def do_scheduler(scheduler, ios)
-    return if !scheduler.is_a?(UM::FiberScheduler)
     C.times do
       Fiber.schedule do
         conn = create_redis_conn

data/benchmark/common.rb

@@ -62,7 +62,7 @@ class UMBenchmark
     # baseline_um:  [:baseline_um,  "UM no concurrency"],
     # thread_pool:  [:thread_pool,  "ThreadPool"],
 
-    # threads:        [:threads,      "Threads"],
+    threads:        [:threads,      "Threads"],
 
     # async_uring:    [:scheduler,    "Async uring"],
     # async_uring_x2: [:scheduler_x,  "Async uring x2"],
@@ -70,10 +70,10 @@ class UMBenchmark
     # async_epoll:    [:scheduler,    "Async epoll"],
     # async_epoll_x2: [:scheduler_x,  "Async epoll x2"],
 
-    # um_fs:          [:scheduler,    "UM FS"],
-    # um_fs_x2:       [:scheduler_x,  "UM FS x2"],
+    um_fs:          [:scheduler,    "UM FS"],
+    um_fs_x2:       [:scheduler_x,  "UM FS x2"],
 
-    # um:             [:um,           "UM"],
+    um:             [:um,           "UM"],
     # um_sidecar:     [:um,           "UM sidecar"],
     # um_sqpoll:      [:um,           "UM sqpoll"],
     um_x2:          [:um_x,         "UM x2"],

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/extconf.rb

@@ -74,11 +74,4 @@ $defs << '-DHAVE_IO_URING_PREP_BIND'            if config[:prep_bind]
 $defs << '-DHAVE_IO_URING_PREP_LISTEN'          if config[:prep_listen]
 $defs << '-DHAVE_IO_URING_SEND_VECTORIZED'      if config[:send_vectoized]
 
-$CFLAGS << ' -Werror -Wall -Wextra'
-
-if ENV['SANITIZE']
-  $CFLAGS << ' -fsanitize=undefined,address -lasan'
-  $LDFLAGS << ' -fsanitize=undefined,address -lasan'
-end
-
 create_makefile 'um_ext'

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;
 
@@ -68,8 +62,7 @@ inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
     machine->metrics.ops_unsubmitted, machine->metrics.ops_pending, machine->metrics.total_ops
   );
 
-  struct io_uring_sqe *sqe;
-  sqe = io_uring_get_sqe(&machine->ring);
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
 
   um_raise_internal_error("Submission queue full. Consider raising the machine size.");
@@ -288,22 +281,22 @@ void *um_wait_for_cqe_without_gvl(void *ptr) {
   return NULL;
 }
 
-inline void um_profile_wait_cqe_pre(struct um *machine, double *time_monotonic0, VALUE *fiber) {
-  // *fiber = rb_fiber_current();
-  *time_monotonic0 = um_get_time_monotonic();
-  // double time_cpu = um_get_time_cpu();
-  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
-  // um_update_fiber_time_run(fiber, time_monotonic0, elapsed);
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_wait_cqe_pre(struct um *machine, double *time_monotonic0, VALUE *fiber) {
+//   VALUE fiber = rb_fiber_current();
+//   *time_monotonic0 = um_get_time_monotonic();
+//   double time_cpu = um_get_time_cpu();
+//   double elapsed = time_cpu - machine->metrics.time_last_cpu;
+//   um_update_fiber_time_run(fiber, time_monotonic0, elapsed);
+//   machine->metrics.time_last_cpu = time_cpu;
+// }
 
-inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0, VALUE fiber) {
-  // double time_cpu = um_get_time_cpu();
-  double elapsed = um_get_time_monotonic() - time_monotonic0;
-  // um_update_fiber_last_time(fiber, cpu_time1);
-  machine->metrics.time_total_wait += elapsed;
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0, VALUE fiber) {
+//   // double time_cpu = um_get_time_cpu();
+//   double elapsed = um_get_time_monotonic() - time_monotonic0;
+//   // um_update_fiber_last_time(fiber, cpu_time1);
+//   machine->metrics.time_total_wait += elapsed;
+//   // machine->metrics.time_last_cpu = time_cpu;
+// }
 
 inline void *um_wait_for_sidecar_signal(void *ptr) {
   struct um *machine = ptr;
@@ -335,11 +328,11 @@ static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wa
     // fprintf(stderr, "<< sidecar wait cqes\n");
   }
   else {
-    double time_monotonic0 = 0.0;
-    VALUE fiber;
-    if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
+    // double time_monotonic0 = 0.0;
+    // VALUE fiber;
+    // if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
     rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
-    if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
+    // if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
 
     if (unlikely(ctx.result < 0)) {
       // the internal calls to (maybe submit) and wait for cqes may fail with:
@@ -363,14 +356,14 @@ static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wa
   }
 }
 
-inline void um_profile_switch(struct um *machine, VALUE next_fiber) {
-  // *current_fiber = rb_fiber_current();
-  // double time_cpu = um_get_time_cpu();
-  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
-  // um_update_fiber_time_run(cur_fiber, time_cpu, elapsed);
-  // um_update_fiber_time_wait(next_fiber, time_cpu);
-  // machine->metrics.time_last_cpu = time_cpu;
-}
+// inline void um_profile_switch(struct um *machine, VALUE next_fiber) {
+//   VALUE current_fiber = rb_fiber_current();
+//   double time_cpu = um_get_time_cpu();
+//   double elapsed = time_cpu - machine->metrics.time_last_cpu;
+//   um_update_fiber_time_run(cur_fiber, time_cpu, elapsed);
+//   um_update_fiber_time_wait(next_fiber, time_cpu);
+//   machine->metrics.time_last_cpu = time_cpu;
+// }
 
 inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   DEBUG_PRINTF("* process_runqueue_op: op=%p kind=%s ref_count=%d flags=%x\n",
@@ -384,7 +377,7 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   op->flags &= ~OP_F_SCHEDULED;
   um_op_release(machine, op);
 
-  if (machine->profile_mode) um_profile_switch(machine, fiber);
+  // if (machine->profile_mode) um_profile_switch(machine, fiber);
   VALUE ret = rb_fiber_transfer(fiber, 1, &value);
   RB_GC_GUARD(value);
   RB_GC_GUARD(ret);
@@ -523,7 +516,6 @@ struct op_ctx {
   struct um *machine;
   struct um_op *op;
   int fd;
-  int bgid;
 
   struct um_queue *queue;
   void *read_buf;
@@ -870,25 +862,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 +1434,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 +1503,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 +1568,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);