uringmachine 0.22.1 → 0.23.0

data/ext/um/um.c

@@ -3,6 +3,7 @@
 #include <ruby/thread.h>
 #include <assert.h>
 #include <poll.h>
+#include <liburing/io_uring.h>
 
 #define DEFAULT_SIZE 4096
 
@@ -21,7 +22,7 @@ void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_mse
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
-  RB_OBJ_WRITE(self, &machine->pending_fibers, rb_hash_new());
+  RB_OBJ_WRITE(self, &machine->pending_fibers, rb_set_new());
 
   machine->size = (size > 0) ? size : DEFAULT_SIZE;
   machine->sqpoll_mode = !!sqpoll_timeout_msec;
@@ -369,9 +370,9 @@ inline VALUE um_switch(struct um *machine) {
 
 inline VALUE um_yield(struct um *machine) {
   VALUE fiber = rb_fiber_current();
-  rb_hash_aset(machine->pending_fibers, fiber, Qtrue);
+  rb_set_add(machine->pending_fibers, fiber);
   VALUE ret = um_switch(machine);
-  rb_hash_delete(machine->pending_fibers, fiber);
+  rb_set_delete(machine->pending_fibers, fiber);
   return ret;
 }
 
@@ -384,11 +385,11 @@ inline void um_cancel_and_wait(struct um *machine, struct um_op *op) {
   um_cancel_op(machine, op);
 
   VALUE fiber = rb_fiber_current();
-  rb_hash_aset(machine->pending_fibers, fiber, Qtrue);
+  rb_set_add(machine->pending_fibers, fiber);
   while (!um_op_completed_p(op)) {
     um_switch(machine);
   }
-  rb_hash_delete(machine->pending_fibers, fiber);
+  rb_set_delete(machine->pending_fibers, fiber);
 }
 
 inline int um_check_completion(struct um *machine, struct um_op *op) {
@@ -436,6 +437,7 @@ struct op_ctx {
   int fd;
   int bgid;
 
+  struct um_queue *queue;
   void *read_buf;
   int read_maxlen;
   struct __kernel_timespec ts;
@@ -561,6 +563,56 @@ VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_
   return ret;
 }
 
+VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv) {
+  __u64 file_offset = -1;
+  if (TYPE(argv[argc - 1]) == T_FIXNUM) {
+    file_offset = NUM2UINT(argv[argc - 1]);
+    argc--;
+  }
+
+  size_t total_len, len;
+  struct iovec *iovecs = um_alloc_iovecs_for_writing(argc, argv, &total_len);
+  struct iovec *iovecs_ptr = iovecs;
+  int iovecs_len = argc;
+  struct um_op op;
+  VALUE ret = Qnil;
+  int writev_res = 0;
+
+  if (unlikely(!total_len)) {
+    free(iovecs);
+    return INT2NUM(0);
+  }
+  len = total_len;
+  while (len) {
+    um_prep_op(machine, &op, OP_WRITEV, 0);
+    struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+    io_uring_prep_writev(sqe, fd, iovecs_ptr, iovecs_len, file_offset);
+
+    ret = um_yield(machine);
+
+    int completed = um_op_completed_p(&op);
+    if (unlikely(!completed)) goto cancelled;
+  
+    writev_res = op.result.res;
+    if (unlikely(writev_res < 0)) goto done;
+      
+    len -= writev_res;
+    if (len) {
+      um_advance_iovecs_for_writing(&iovecs_ptr, &iovecs_len, (size_t)writev_res);
+      if (file_offset != (__u64)-1) file_offset += writev_res;
+    }
+  }
+
+cancelled:
+  um_cancel_and_wait(machine, &op);
+done:
+  free(iovecs);
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  um_raise_on_error_result(writev_res);
+  return INT2NUM(total_len);
+}
+
 VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset) {
   const void *base;
   size_t size;
@@ -670,6 +722,35 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags) {
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+  // int ret = write(fd, base, len);
+  // return UINT2NUM(ret);
+}
+
+// for some reason we don't get this define from liburing/io_uring.h
+#define IORING_SEND_VECTORIZED		(1U << 5)
+
+VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv) {
+  struct iovec *iovecs = um_alloc_iovecs_for_writing(argc, argv, NULL);
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SEND, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+
+  io_uring_prep_send(sqe, fd, iovecs, argc, MSG_WAITALL);
+  sqe->ioprio |= IORING_SEND_VECTORIZED;
+
+  VALUE ret = um_yield(machine);
+
+  int completed = um_op_completed_p(&op);
+  if (unlikely(!completed)) um_cancel_and_wait(machine, &op);
+  free(iovecs);
+  if (likely(completed)) {
+    um_raise_on_error_result(op.result.res);
+    ret = INT2NUM(op.result.res);
+  }
+
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
@@ -1066,7 +1147,7 @@ VALUE accept_each_start(VALUE arg) {
       more = (result->flags & IORING_CQE_F_MORE);
       if (result->res < 0) {
         um_op_multishot_results_clear(ctx->machine, ctx->op);
-        return Qnil;
+        rb_syserr_fail(-result->res, strerror(-result->res));
       }
       rb_yield(INT2NUM(result->res));
       result = result->next;
@@ -1081,6 +1162,40 @@ VALUE accept_each_start(VALUE arg) {
   return Qnil;
 }
 
+VALUE accept_into_queue_start(VALUE arg) {
+  struct op_ctx *ctx = (struct op_ctx *)arg;
+  struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
+  io_uring_prep_multishot_accept(sqe, ctx->fd, NULL, NULL, 0);
+
+  while (true) {
+    VALUE ret = um_yield(ctx->machine);
+    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;
+    while (result) {
+      more = (result->flags & IORING_CQE_F_MORE);
+      if (result->res < 0) {
+        um_op_multishot_results_clear(ctx->machine, ctx->op);
+        rb_syserr_fail(-result->res, strerror(-result->res));
+      }
+      um_queue_push(ctx->machine, ctx->queue, INT2NUM(result->res));
+      result = result->next;
+    }
+    um_op_multishot_results_clear(ctx->machine, ctx->op);
+    if (more)
+      ctx->op->flags &= ~OP_F_COMPLETED;
+    else
+      break;
+  }
+
+  return Qnil;
+}
+
 VALUE multishot_complete(VALUE arg) {
   struct op_ctx *ctx = (struct op_ctx *)arg;
   if (ctx->op->multishot_result_count) {
@@ -1095,8 +1210,6 @@ VALUE multishot_complete(VALUE arg) {
   if (ctx->read_buf)
     free(ctx->read_buf);
 
-  rb_hash_delete(ctx->machine->pending_fibers, ctx->op->fiber);
-
   return Qnil;
 }
 
@@ -1108,6 +1221,16 @@ VALUE um_accept_each(struct um *machine, int fd) {
   return rb_ensure(accept_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
 
+VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_ACCEPT_MULTISHOT, OP_F_MULTISHOT);
+
+  struct op_ctx ctx = {
+    .machine = machine, .op = &op, .fd = fd, .queue = Queue_data(queue), .read_buf = NULL
+  };
+  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;

data/ext/um/um.h

@@ -43,6 +43,7 @@ enum um_op_kind {
   OP_OPEN,
   OP_READ,
   OP_WRITE,
+  OP_WRITEV,
   OP_WRITE_ASYNC,
   OP_CLOSE,
   OP_CLOSE_ASYNC,
@@ -51,6 +52,7 @@ enum um_op_kind {
   OP_ACCEPT,
   OP_RECV,
   OP_SEND,
+  OP_SENDV,
   OP_SEND_BUNDLE,
   OP_SOCKET,
   OP_CONNECT,
@@ -266,6 +268,9 @@ void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offs
 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 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);
+
 
 struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
@@ -288,6 +293,7 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
 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_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
+VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 VALUE um_close(struct um *machine, int fd);
 VALUE um_close_async(struct um *machine, int fd);
@@ -304,9 +310,11 @@ VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned in
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
+VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue);
 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, 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);

data/ext/um/um_class.c

@@ -235,6 +235,16 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   return um_write(machine, NUM2INT(fd), buffer, len_i, file_offset_i);
 }
 
+VALUE UM_writev(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = um_get_machine(self);
+  if (argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
+  int fd = NUM2INT(argv[0]);
+  if (argc < 2) return INT2NUM(0);
+
+  return um_writev(machine, fd, argc - 1, argv + 1);
+}
+
 VALUE UM_write_async(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
   VALUE fd;
@@ -274,6 +284,11 @@ VALUE UM_accept_each(VALUE self, VALUE fd) {
   return um_accept_each(machine, NUM2INT(fd));
 }
 
+VALUE UM_accept_into_queue(VALUE self, VALUE fd, VALUE queue) {
+  struct um *machine = um_get_machine(self);
+  return um_accept_into_queue(machine, NUM2INT(fd), queue);
+}
+
 VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flags) {
   struct um *machine = um_get_machine(self);
   return um_socket(machine, NUM2INT(domain), NUM2INT(type), NUM2INT(protocol), NUM2UINT(flags));
@@ -306,6 +321,18 @@ VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
   return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
 }
 
+#ifdef HAVE_IO_URING_SEND_VECTORIZED
+VALUE UM_sendv(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = um_get_machine(self);
+  if (argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
+  int fd = NUM2INT(argv[0]);
+  if (argc < 2) return INT2NUM(0);
+
+  return um_sendv(machine, fd, argc - 1, argv + 1);
+}
+#endif
+
 VALUE UM_send_bundle(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
   VALUE fd;
@@ -586,6 +613,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
+  rb_define_method(cUM, "writev", UM_writev, -1);
   rb_define_method(cUM, "write_async", UM_write_async, -1);
   rb_define_method(cUM, "statx", UM_statx, 4);
 
@@ -599,6 +627,7 @@ void Init_UM(void) {
 
   rb_define_method(cUM, "accept", UM_accept, 1);
   rb_define_method(cUM, "accept_each", UM_accept_each, 1);
+  rb_define_method(cUM, "accept_into_queue", UM_accept_into_queue, 2);
   rb_define_method(cUM, "bind", UM_bind, 3);
   rb_define_method(cUM, "connect", UM_connect, 3);
   rb_define_method(cUM, "getsockopt", UM_getsockopt, 3);
@@ -606,6 +635,11 @@ 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);
+
+  #ifdef HAVE_IO_URING_SEND_VECTORIZED
+  rb_define_method(cUM, "sendv", UM_sendv, -1);
+  #endif
+  
   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);

data/ext/um/um_const.c

@@ -425,7 +425,6 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, SIGTSTP);
   DEF_CONST_INT(mod, SIGCONT);
   DEF_CONST_INT(mod, SIGCHLD);
-  // DEF_CONST_INT(mod, SIGCLD);
   DEF_CONST_INT(mod, SIGTTIN);
   DEF_CONST_INT(mod, SIGTTOU);
   DEF_CONST_INT(mod, SIGIO);
@@ -438,5 +437,4 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, SIGUSR2);
   DEF_CONST_INT(mod, SIGPWR);
   DEF_CONST_INT(mod, SIGPOLL);
-
 }

data/ext/um/um_op.c

@@ -1,5 +1,8 @@
 #include "um.h"
 
+#define UM_OP_ALLOC_BATCH_SIZE        256
+#define UM_OP_RESULT_ALLOC_BATCH_SIZE 256
+
 const char * um_op_kind_name(enum um_op_kind kind) {
   switch (kind) {
     case OP_TIMEOUT:            return "OP_TIMEOUT";
@@ -8,6 +11,7 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_OPEN:               return "OP_OPEN";
     case OP_READ:               return "OP_READ";
     case OP_WRITE:              return "OP_WRITE";
+    case OP_WRITEV:             return "OP_WRITEV";
     case OP_WRITE_ASYNC:        return "OP_WRITE_ASYNC";
     case OP_CLOSE:              return "OP_CLOSE";
     case OP_CLOSE_ASYNC:        return "OP_CLOSE_ASYNC";
@@ -15,6 +19,7 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_ACCEPT:             return "OP_ACCEPT";
     case OP_RECV:               return "OP_RECV";
     case OP_SEND:               return "OP_SEND";
+    case OP_SENDV:              return "OP_SENDV";
     case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
     case OP_SOCKET:             return "OP_SOCKET";
     case OP_CONNECT:            return "OP_CONNECT";
@@ -113,7 +118,13 @@ inline struct um_op_result *multishot_result_alloc(struct um *machine) {
     machine->result_freelist = result->next;
     return result;
   }
-  return malloc(sizeof(struct um_op_result));
+
+  struct um_op_result *batch = malloc(sizeof(struct um_op_result) * UM_OP_RESULT_ALLOC_BATCH_SIZE);
+  for (int i = 1; i < (UM_OP_RESULT_ALLOC_BATCH_SIZE - 1); i++) {
+    batch[i].next = &batch[i + 1];
+  }
+  machine->result_freelist = batch + 1;
+  return batch;
 }
 
 inline void multishot_result_free(struct um *machine, struct um_op_result *result) {
@@ -159,7 +170,14 @@ inline struct um_op *um_op_alloc(struct um *machine) {
     machine->metrics.ops_free--;
     return op;
   }
-  return malloc(sizeof(struct um_op));
+
+  struct um_op *batch = malloc(sizeof(struct um_op) * UM_OP_ALLOC_BATCH_SIZE);
+  for (int i = 1; i < (UM_OP_ALLOC_BATCH_SIZE - 1); i++) {
+    batch[i].next = &batch[i + 1];
+  }
+  machine->op_freelist = batch + 1;
+  machine->metrics.ops_free += (UM_OP_ALLOC_BATCH_SIZE - 1);
+  return batch;
 }
 
 inline void um_op_free(struct um *machine, struct um_op *op) {

data/ext/um/um_utils.c

@@ -199,3 +199,30 @@ inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE st
 inline void um_raise_internal_error(const char *msg) {
   rb_raise(eUMError, "UringMachine error: %s", msg);
 }
+
+inline struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *total_len) {
+  struct iovec *iovecs = malloc(sizeof(struct iovec) * argc);
+  size_t len = 0;
+
+  for (int i = 0; i < argc; i++) {
+    um_get_buffer_bytes_for_writing(argv[i], (const void **)&iovecs[i].iov_base, &iovecs[i].iov_len);
+    len += iovecs[i].iov_len;
+  }
+  if (total_len) *total_len = len;
+  return iovecs;
+}
+
+inline void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv) {
+  while (adv) {
+    if (adv < (*ptr)->iov_len) {
+      (*ptr)->iov_base += adv;
+      (*ptr)->iov_len -= adv;
+      return;
+    }
+    else {
+      adv -= (*ptr)->iov_len;
+      (*ptr)++;
+      (*len)--;
+    }
+  }
+}

data/grant-2025/journal.md

@@ -55,7 +55,7 @@ Pidfds eliminate race conditions, improve cross-thread safety, and make process
 management reliably asynchronous. This enables safer job-runners, supervisors,
 and async orchestration patterns in Ruby.
 
-4. Proper fork support for Fiber Scheduler (Fiber::Scheduler#process_fork)
+4. [v] Proper fork support for Fiber Scheduler (Fiber::Scheduler#process_fork)
 
 Summary:
 
@@ -68,7 +68,7 @@ fork + async currently work inconsistently. This project makes forking
 predictable, allowing libraries and apps to do post-fork setup (e.g., reconnect
 I/O, restart loops) correctly and safely.
 
-5. Async-aware IO#close via io_uring prep_close + scheduler hook
+5. [v] Async-aware IO#close via io_uring prep_close + scheduler hook
 
 Summary:
 

data/grant-2025/tasks.md

@@ -24,8 +24,13 @@
     - [ ] max fiber switches before submitting unsubmitted SQEs
     - [ ] measure switches since last submitting / last CQE processing
 
-  - [ ] Add support for using IO::Buffer in association with io_uring registered
-    buffers / buffer rings
+  - [ ] Better buffer management buffer rings
+    - [v] Add `UM#sendv` method (see below)
+    - [v] Benchmark `#sendv` vs `#send_bundle` (in concurrent situation)
+    - [ ] Benchmark `#read_each` vs `#read` (in concurrent situation)
+    - [ ] Support for `IO::Buffer`? How's the API gonna look like?
+    - [ ] Some higher-level abstraction for managing a *pool* of buffer rings
+
   - [ ] Add some way to measure fiber CPU time.
         https://github.com/socketry/async/issues/428
 
@@ -114,16 +119,6 @@
 
     - [v] Postgres test
 
-    - [ ] Measure CPU (thread) time usage for above examples
-
-        - run each version 1M times
-        - measure total real time, total CPU time
-
-        ```ruby
-        real_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        cpu_time = Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
-        ```
-
 - [ ] Ruby Fiber::Scheduler interface
   - [v] Make a PR for resetting the scheduler and resetting the fiber non-blocking flag.
   - [v] hook for close

data/lib/uringmachine/version.rb

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

data/test/helper.rb

@@ -65,10 +65,11 @@ class UMBaseTest < Minitest::Test
   end
 
   def teardown
-    pending_fibers = @machine.pending_fibers.keys
-    if pending_fibers.size > 0
-      raise "leaked fibers: #{pending_fibers}"
-    end
+    return if !@machine
+
+    pending_fibers = @machine.pending_fibers
+    raise "leaked fibers: #{pending_fibers}" if pending_fibers.size > 0
+    
     GC.start
   end
 

data/test/test_fiber_scheduler.rb

@@ -772,22 +772,6 @@ class FiberSchedulerIOClassMethodsTest < UMBaseTest
     }, @scheduler.calls.map { it[:sym] }.tally)
   end
 
-  def test_IO_s_foreach
-    buf = []
-    Fiber.schedule do
-      IO.foreach(@fn) { buf << it }
-    end
-    @scheduler.join
-    assert_equal ['==='], buf
-    assert_equal({
-      fiber: 1,
-      io_read: 3,
-      blocking_operation_wait: 1,
-      io_close: 1,
-      join: 1
-    }, @scheduler.calls.map { it[:sym] }.tally)
-  end
-
   def test_IO_s_popen
     ret = nil
     Fiber.schedule do
@@ -1374,7 +1358,7 @@ class FiberSchedulerNetHTTPTest < UMBaseTest
     assert_equal C, calls[:fiber]
     assert_equal C, calls[:io_close]
     assert_in_range (C * 2)..(C * 4), calls[:io_wait]
-    assert_in_range (C * 7)..(C * 17), calls[:blocking_operation_wait]
+    assert_in_range (C * 7)..(C * 20), calls[:blocking_operation_wait]
   end
 end