uringmachine 0.29.0 → 0.29.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a6a6d78b632e43c1ac15e8745ede898e531ff9a731822fd22c5991ca0222d69
-  data.tar.gz: 0acd35ee028ea519c2788c720336dbcb1c2fa8317912459b7a81f4afbe6b3747
+  metadata.gz: 248a2f0e2a780904f26f0183d08237039e18b76b736e7b3563c2699e30041d65
+  data.tar.gz: 2020b0c8cc9be25becddef80fa4c66f0bc49e30d0791ec2b2b2e618fbf3ab0b6
 SHA512:
-  metadata.gz: ed9f7684132ee1e1aae9c7783131fd927e88604444d44bc889cdf8c362b0a5dd85b3e887873c0512946af2c08dd8189e6c3bf972f19f90a7f12daee4c44c5ccd
-  data.tar.gz: f5bff069de535e906543a679266700bacbb715d0e72b14d4bf7cd042ab8d77e58d8c69feb1dbd65f16026aa4bcec20d024acffd2e2f18ac255f5b70190c25788
+  metadata.gz: 543a8adf2c628f080f9ec249e11ff7e4bd969f0eca9e47285ba0ef20c28575ddd6d1902a3890d49ccb1ccf5100d13cd721bbd03c472bde15205344524fd7795c
+  data.tar.gz: 4afbe860f29187507c57a8e319d02f2f843d27aa7d65176f0e0040914bf4d8e68ce894d4663b13d3ace530bf2aa4fe3ca547e58d5cbcb1daf5d89f6d5bb94ae2

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.29.1 2026-03-14
+
+- Add support for exception instance in `#timeout`
+- Improve buffer commit level handling
+
 # 0.29.0 2026-03-11
 
 - Reimplement streams based on buffer pool

data/benchmark/gets_concurrent.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+end
+
+require 'benchmark'
+require 'uringmachine'
+
+C = 10
+N = 1000
+
+CMD = <<~EOF
+  bash -c "for i in {1..#{C*2}}; do nc -l -p 1234 </dev/random & done; wait $(jobs -p)"
+EOF
+
+def start_server
+  @pid = fork {
+    p :server_launch
+    `#{CMD}`
+    puts
+    p :server_done
+    puts
+  }
+  sleep(0.5)
+end
+
+def stop_server
+  Process.kill('SIGINT', @pid)
+  Process.wait(@pid)
+end
+
+def io_gets
+  start_server
+  tt = C.times.map {
+    Thread.new do
+      s = TCPSocket.new('localhost', 1234)
+      # io = File.open('/dev/random', 'r')
+      N.times { s.gets }
+    ensure
+      s.close
+    end
+  }
+  tt.each(&:join)
+ensure
+  stop_server
+end
+
+@machine = UM.new
+
+def buf_gets(fd, buffer)
+  while true
+    idx = buffer.byteindex("\n")
+    if idx
+      line = buffer[0..(idx - 1)]
+
+      buffer = buffer[(idx + 1)..-1]
+      return line
+    end
+    @machine.read(fd, buffer, 65536, -1)
+  end
+end
+
+def um_read
+  start_server
+  ff = C.times.map {
+    @machine.spin do
+      # fd = @machine.open('/dev/random', UM::O_RDONLY)
+      fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+      @machine.connect(fd, '127.0.0.1', 1234)
+      buffer = +''.encode(Encoding::US_ASCII)
+      N.times { buf_gets(fd, buffer) }
+    ensure
+      @machine.close(fd)
+    end
+  }
+  @machine.await(ff)
+ensure
+  stop_server
+end
+
+@total_stream = 0
+def um_stream_do
+  # fd = @machine.open('/dev/random', UM::O_RDONLY)
+  fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.connect(fd, '127.0.0.1', 1234)
+  stream = UM::Stream.new(@machine, fd)
+  N.times { @total_stream += stream.get_line(0)&.bytesize || 0 }
+rescue => e
+  p e
+  p e.backtrace
+ensure
+  stream.clear
+  @machine.close(fd)
+end
+
+def um_stream
+  start_server
+  ff = C.times.map {
+    @machine.snooze
+    @machine.spin { um_stream_do }
+  }
+  @machine.await(ff)
+  pp total: @total_stream
+ensure
+  stop_server
+end
+
+p(C:, N:)
+um_stream
+pp @machine.metrics
+exit
+
+Benchmark.bm do
+  it.report('Thread/IO#gets')    { io_gets }
+  it.report('Fiber/UM#read+buf') { um_read }
+  it.report('Fiber/UM::Stream')  { um_stream }
+end

data/ext/um/um.c

@@ -540,15 +540,19 @@ VALUE um_timeout_complete(VALUE arg) {
   return Qnil;
 }
 
-VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
+VALUE um_timeout(struct um *machine, VALUE interval, VALUE obj) {
   static ID ID_new = 0;
-  if (unlikely(!ID_new)) ID_new = rb_intern("new");
+
+  if (TYPE(obj) == T_CLASS) {
+    if (unlikely(!ID_new)) ID_new = rb_intern("new");
+    obj = rb_funcall(obj, ID_new, 0);
+  }
 
   struct um_op *op = um_op_acquire(machine);
   um_prep_op(machine, op, OP_TIMEOUT, 2, 0);
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
-  RB_OBJ_WRITE(machine->self, &op->value, rb_funcall(class, ID_new, 0));
+  RB_OBJ_WRITE(machine->self, &op->value, obj);
   RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
@@ -556,6 +560,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
 
   struct op_ctx ctx = { .machine = machine, .op = op };
   return rb_ensure(rb_yield, Qnil, um_timeout_complete, (VALUE)&ctx);
+  RB_GC_GUARD(obj);
 }
 
 /*******************************************************************************

data/ext/um/um.h

@@ -111,12 +111,10 @@ enum um_stream_mode {
 
 #define BP_BGID                     0xF00B
 #define BP_BR_ENTRIES               1024
-
 #define BP_INITIAL_BUFFER_SIZE      (1U << 14) // 16KB
-#define BP_INITIAL_COMMIT_THRESHOLD (1U << 16) // 64KB
+#define BP_INITIAL_COMMIT_LEVEL     (BP_INITIAL_BUFFER_SIZE * 16) // 256KB
 #define BP_MAX_BUFFER_SIZE          (1U << 20) // 1MB
-
-#define BP_MAX_COMMIT_THRESHOLD     (BP_MAX_BUFFER_SIZE * BP_BR_ENTRIES) // 1GB
+#define BP_MAX_COMMIT_LEVEL         (BP_MAX_BUFFER_SIZE * BP_BR_ENTRIES) // 1GB
 #define BP_AVAIL_BID_BITMAP_WORDS   (BP_BR_ENTRIES / 64)
 
 struct um_buffer {
@@ -163,7 +161,7 @@ struct um_op {
     struct iovec *iovecs; // used for vectorized write/send
     siginfo_t siginfo; // used for waitid
     int int_value; // used for getsockopt
-    size_t bp_commit_threshold; // buffer pool commit threshold
+    size_t bp_commit_level; // buffer pool commit threshold
   };
 };
 
@@ -234,7 +232,7 @@ struct um {
 
   struct io_uring_buf_ring *bp_br;
   size_t bp_buffer_size;
-  size_t bp_commit_threshold;
+  size_t bp_commit_level;
   struct um_buffer **bp_commited_buffers;
   uint64_t bp_avail_bid_bitmap[BP_AVAIL_BID_BITMAP_WORDS];
 
@@ -437,7 +435,7 @@ void stream_teardown(struct um_stream *stream);
 void stream_clear(struct um_stream *stream);
 VALUE stream_get_line(struct um_stream *stream, VALUE buf, size_t maxlen);
 VALUE stream_get_string(struct um_stream *stream, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
-VALUE stream_skip(struct um_stream *stream, size_t len);
+void stream_skip(struct um_stream *stream, size_t inc, int safe_inc);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);

data/ext/um/um_buffer_pool.c

@@ -31,7 +31,6 @@ inline struct um_buffer *bp_buffer_checkout(struct um *machine) {
   buffer->ref_count++;
   buffer->pos = 0;
   buffer->next = NULL;
-
   return buffer;
 }
 
@@ -76,7 +75,7 @@ inline void bp_setup(struct um *machine) {
   if (unlikely(!machine->bp_br)) rb_syserr_fail(ret, strerror(ret));
 
   machine->bp_buffer_size = BP_INITIAL_BUFFER_SIZE;
-  machine->bp_commit_threshold = BP_INITIAL_COMMIT_THRESHOLD;
+  machine->bp_commit_level = BP_INITIAL_COMMIT_LEVEL;
   machine->bp_commited_buffers = malloc(sizeof(struct um_buffer) * BP_BR_ENTRIES);
   memset(machine->bp_commited_buffers, 0, sizeof(struct um_buffer) * BP_BR_ENTRIES);
   memset(machine->bp_avail_bid_bitmap, 0xFF, sizeof(machine->bp_avail_bid_bitmap));
@@ -160,10 +159,13 @@ inline struct um_buffer *get_buffer(struct um *machine, int bid) {
 
 inline int should_commit_more_p(struct um *machine) {
   return (machine->bp_buffer_count < BP_BR_ENTRIES) &&
-         (machine->bp_total_commited < machine->bp_commit_threshold);
+         (machine->bp_total_commited < machine->bp_commit_level);
 }
 
 inline void bp_ensure_commit_level(struct um *machine) {
+  if (machine->bp_total_commited > (machine->bp_commit_level / 2))
+    return;
+
   int added = 0;
   while (should_commit_more_p(machine)) {
     if (likely(commit_buffer(machine, added))) added++;
@@ -178,11 +180,11 @@ inline void bp_ensure_commit_level(struct um *machine) {
 }
 
 inline void bp_handle_enobufs(struct um *machine) {
-  if (unlikely(machine->bp_commit_threshold >= BP_MAX_COMMIT_THRESHOLD))
+  if (unlikely(machine->bp_commit_level >= BP_MAX_COMMIT_LEVEL))
     rb_raise(eUMError, "Buffer starvation");
 
-  machine->bp_commit_threshold *= 2;
-  while (machine->bp_buffer_size < machine->bp_commit_threshold / 4)
+  machine->bp_commit_level *= 2;
+  while (machine->bp_buffer_size < machine->bp_commit_level / 4)
     machine->bp_buffer_size *= 2;
   bp_discard_buffer_freelist(machine);
 }

data/ext/um/um_class.c

@@ -334,17 +334,17 @@ VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
 }
 
 /* Runs the given block, interrupting its execution if its runtime exceeds the
- * given timeout interval (in seconds).
+ * given timeout interval (in seconds), raising the specified exception.
  *
  * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_timeoute.3.html
  *
  * @param interval [Number] timeout interval in seconds
- * @param exception_class [any] timeout exception class
+ * @param exception [any] timeout exception class or instance
  * @return [any] block's return value
  */
-VALUE UM_timeout(VALUE self, VALUE interval, VALUE exception_class) {
+VALUE UM_timeout(VALUE self, VALUE interval, VALUE exception) {
   struct um *machine = um_get_machine(self);
-  return um_timeout(machine, interval, exception_class);
+  return um_timeout(machine, interval, exception);
 }
 
 /* Puts the current fiber to sleep for the given time duration (in seconds),

data/ext/um/um_stream.c

@@ -50,7 +50,7 @@ void stream_multishot_op_start(struct um_stream *stream) {
     default:
       um_raise_internal_error("Invalid multishot op");
   }
-  stream->op->bp_commit_threshold = stream->machine->bp_commit_threshold;
+  stream->op->bp_commit_level = stream->machine->bp_commit_level;
 }
 
 void stream_multishot_op_stop(struct um_stream *stream) {
@@ -157,15 +157,26 @@ int stream_get_more_segments_bp(struct um_stream *stream) {
     um_op_multishot_results_clear(stream->machine, stream->op);
     if (unlikely(enobufs)) {
       int should_restart = stream->pending_len < (stream->machine->bp_buffer_size * 4);
+      // int same_threshold = stream->op->bp_commit_level == stream->machine->bp_commit_level;
+
+      // fprintf(stderr, "%p enobufs total: %ld pending: %ld threshold: %ld bc: %d (same: %d, restart: %d)\n",
+      //   stream,
+      //   total_bytes, stream->pending_len, stream->machine->bp_commit_level,
+      //   stream->machine->bp_buffer_count,
+      //   same_threshold, should_restart
+      // );
 
       // If multiple stream ops are happening at the same time, they'll all get
       // ENOBUFS! We track the commit threshold in the op in order to prevent
       // running bp_handle_enobufs() more than once.
 
       if (should_restart) {
-        if (stream->op->bp_commit_threshold == stream->machine->bp_commit_threshold)
+        if (stream->op->bp_commit_level == stream->machine->bp_commit_level)
           bp_handle_enobufs(stream->machine);
-        stream_multishot_op_start(stream);
+  
+        um_op_release(stream->machine, stream->op);
+        stream->op = NULL;
+        // stream_multishot_op_start(stream);
       }
       else {
         um_op_release(stream->machine, stream->op);
@@ -215,6 +226,44 @@ int stream_get_more_segments(struct um_stream *stream) {
 
 ///////////////////////////////////////////////////////////////////////////////////////
 
+inline void stream_shift_head(struct um_stream *stream) {
+  struct um_segment *consumed = stream->head;
+  stream->head = consumed->next;
+  if (!stream->head) stream->tail = NULL;
+  um_segment_checkin(stream->machine, consumed);
+  stream->pos = 0;
+}
+
+inline void stream_skip(struct um_stream *stream, size_t inc, int safe_inc) {
+  while (inc) {
+    size_t segment_len = stream->head->len - stream->pos;
+    size_t inc_len = (segment_len <= inc) ? segment_len : inc;
+    inc -= inc_len;
+    stream->pos += inc_len;
+    stream->pending_len -= inc_len;
+    if (stream->pos == stream->head->len) {
+      stream_shift_head(stream);
+      if (inc && safe_inc && !stream->head) {
+        if (!stream_get_more_segments(stream)) break;
+      }
+    }
+  }
+}
+
+inline void stream_copy(struct um_stream *stream, char *dest, size_t len) {
+  while (len) {
+    char *segment_ptr = stream->head->ptr + stream->pos;
+    size_t segment_len = stream->head->len - stream->pos;
+    size_t cpy_len = (segment_len <= len) ? segment_len : len;
+    memcpy(dest, segment_ptr, cpy_len);
+
+    len -= cpy_len;
+    stream->pos += cpy_len;
+    stream->pending_len -= cpy_len;
+    dest += cpy_len;
+    if (stream->pos == stream->head->len) stream_shift_head(stream);
+  }
+}
 
 VALUE stream_consume_string(struct um_stream *stream, VALUE out_buffer, size_t len, size_t inc, int safe_inc) {
   VALUE str = Qnil;
@@ -228,69 +277,22 @@ VALUE stream_consume_string(struct um_stream *stream, VALUE out_buffer, size_t l
   }
   else
     str = rb_str_new(NULL, len);
-  char *str_ptr = RSTRING_PTR(str);
-  while (len) {
-    char *segment_ptr = stream->head->ptr + stream->pos;
-    size_t segment_len = stream->head->len - stream->pos;
-    size_t cpy_len = (segment_len <= len) ? segment_len : len;
-    memcpy(str_ptr, segment_ptr, cpy_len);
+  char *dest = RSTRING_PTR(str);
 
-    len -= cpy_len;
-    stream->pos += cpy_len;
-    stream->pending_len -= cpy_len;
-    str_ptr += cpy_len;
-    if (stream->pos == stream->head->len) {
-      struct um_segment *consumed = stream->head;
-      stream->head = consumed->next;
-      if (!stream->head) stream->tail = NULL;
-      um_segment_checkin(stream->machine, consumed);
-      stream->pos = 0;
-    }
-  }
-
-  while (inc) {
-    size_t segment_len = stream->head->len - stream->pos;
-    size_t inc_len = (segment_len <= inc) ? segment_len : inc;
-    inc -= inc_len;
-    stream->pos += inc_len;
-    stream->pending_len -= inc_len;
-    if (stream->pos == stream->head->len) {
-      struct um_segment *consumed = stream->head;
-      stream->head = consumed->next;
-      um_segment_checkin(stream->machine, consumed);
-      if (!stream->head) {
-        stream->tail = NULL;
-        if (inc && safe_inc) {
-          if (!stream_get_more_segments(stream)) break;
-        }
-      }
-      stream->pos = 0;
-    }
-  }
+  stream_copy(stream, dest, len);
+  stream_skip(stream, inc, safe_inc);
   return str;
   RB_GC_GUARD(str);
 }
 
-// inline void stream_advance(struct um_stream *stream, size_t inc) {
-//   while (inc) {
-//     size_t segment_len = stream->head->len - stream->pos;
-//     size_t inc_len = (segment_len <= inc) ? segment_len : inc;
-//     inc -= inc_len;
-//     stream->pos += inc_len;
-//     if (stream->pos == stream->head->len) {
-//       struct um_segment *consumed = stream->head;
-//       stream->head = consumed->next;
-//       um_segment_checkin(stream->machine, consumed);
-//       if (!stream->head) {
-//         stream->tail = NULL;
-//         if (!stream_get_more_segments(stream)) return;
-//       }
-//       stream->pos = 0;
-//     }
-//   }
-// }
-
 VALUE stream_get_line(struct um_stream *stream, VALUE out_buffer, size_t maxlen) {
+  // if (stream->head) {
+  //   fprintf(stderr, "head: %p pos: %ld: %.*s\n",
+  //     stream->head, stream->pos,
+  //     (int)(stream->head->len - stream->pos), stream->head->ptr + stream->pos
+  //   );
+  // }
+
   if (unlikely(stream->eof && !stream->head)) return Qnil;
   if (!stream->tail && !stream_get_more_segments(stream)) return Qnil;
 

data/grant-2025/tasks.md

@@ -35,8 +35,9 @@
       - [v] Data processing through a rewritten stream implementation.
 
   - [ ] More benchmarks
-    - Different reading methods in concurrent setting
-    - SSL vs SSL-custom-BIO vs SSL-stream
+    - [ ] Different reading methods in concurrent setting
+    - [ ] SSL vs SSL-custom-BIO vs SSL-stream in concurrent setting
+    - [ ] stream resp client vs redis gem in concurrent setting
 
   - [v] Sidecar mode
     - [v] Convert `UM#initialize` to take kwargs

data/lib/uringmachine/version.rb

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

data/test/helper.rb

@@ -103,3 +103,5 @@ class UMBaseTest < Minitest::Test
     dir
   end
 end
+
+puts "Ruby: #{RUBY_VERSION}\nKernel: #{UringMachine.kernel_version}"

data/test/test_fiber_scheduler.rb

@@ -6,6 +6,7 @@ require 'securerandom'
 require 'socket'
 require 'net/http'
 require 'json'
+require 'timeout'
 
 class MethodCallAuditor
   attr_reader :calls
@@ -722,12 +723,11 @@ class FiberSchedulerTest < UMBaseTest
         sleep 1
       end
       res = true
-    rescue => e
-      res = e
+    rescue => res
     end
     @scheduler.join
-    assert_equal 3, machine.metrics[:total_ops]
     assert_kind_of Timeout::Error, res
+    assert_equal 3, machine.metrics[:total_ops]
     assert_equal({
       fiber: 1,
       timeout_after: 1,

data/test/test_stream.rb

@@ -46,7 +46,10 @@ class StreamTest < StreamBaseTest
     assert stream.eof?
 
     stream.clear
-    assert_equal [5, 0, 256, 16384 * 5, 16384 * 5 - 6], buffer_metrics
+
+    # initial buffer size: 6BKV, initial buffers commited: 16 (256KB)
+    # (plus an additional buffer commited after first usage)
+    assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 6], buffer_metrics
     assert_equal 0, machine.metrics[:ops_pending]
   end
 
@@ -68,7 +71,7 @@ class StreamTest < StreamBaseTest
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 256, machine.metrics[:segments_free]
 
-    assert_equal [5, 0, 256, 16384 * 5, 16384 * 5 - 6], buffer_metrics
+    assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 6], buffer_metrics
   ensure
     machine.close(rfd) rescue nil
     machine.close(wfd) rescue nil
@@ -118,11 +121,11 @@ class StreamTest < StreamBaseTest
     buf = stream.get_string(msg.bytesize)
     assert_equal msg, buf
 
-    assert_equal 16, machine.metrics[:buffers_allocated]
-    assert_equal 11, machine.metrics[:buffers_free]
+    stream.clear
+    # numbers may vary with different kernel versions
+    assert_in_range 24..32, machine.metrics[:buffers_allocated]
+    assert_in_range 10..18, machine.metrics[:buffers_free]
     assert_equal 256, machine.metrics[:segments_free]
-    assert_equal 65536 * 4, machine.metrics[:buffer_space_allocated]
-
   ensure
     machine.terminate(f)
     machine.join(f)
@@ -136,7 +139,7 @@ class StreamTest < StreamBaseTest
 
     assert_equal 'foo', stream.get_line(0)
 
-    assert_equal [5, 0, 255, 16384 * 5, 16384 * 5 - 12], buffer_metrics
+    assert_equal [16, 0, 255, 16384 * 16, 16384 * 16 - 12], buffer_metrics
     assert_equal 'bar', stream.get_line(0)
     assert_nil stream.get_line(0)
     assert_equal "baz", stream.get_string(-6)
@@ -152,11 +155,11 @@ class StreamTest < StreamBaseTest
     machine.close(@wfd)
 
     # three segments received
-    assert_equal [5, 0, 253, 16384 * 5, 16384 * 5 - 13], buffer_metrics
+    assert_equal [16, 0, 253, 16384 * 16, 16384 * 16 - 13], buffer_metrics
     assert_equal 'bar', stream.get_line(0)
-    assert_equal [5, 0, 255, 16384 * 5, 16384 * 5 - 13], buffer_metrics
+    assert_equal [16, 0, 255, 16384 * 16, 16384 * 16 - 13], buffer_metrics
     assert_equal 'baz', stream.get_line(0)
-    assert_equal [5, 0, 256, 16384 * 5, 16384 * 5 - 13], buffer_metrics
+    assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 13], buffer_metrics
     assert_nil stream.get_line(0)
   end
 
@@ -182,7 +185,7 @@ class StreamTest < StreamBaseTest
     assert_equal 'bizz', stream.get_line(5)
 
     assert_nil stream.get_line(8)
-    assert_equal [5, 0, 256, 16384 * 5, 16384 * 5 - 17], buffer_metrics
+    assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 17], buffer_metrics
   end
 
   def test_stream_get_string
@@ -467,6 +470,23 @@ class StreamDevRandomTest < UMBaseTest
     machine.close(fd) rescue nil
   end
 
+  def get_line_do(n, acc)
+    fd = @machine.open('/dev/random', UM::O_RDONLY)
+    stream = UM::Stream.new(@machine, fd)
+    n.times { acc << stream.get_line(0) }
+  end
+
+  def test_stream_dev_random_get_line_concurrent
+    acc = []
+    c = 1
+    n = 100000
+    ff = c.times.map {
+      machine.spin { get_line_do(n, acc) }
+    }
+    machine.await(ff)
+    assert_equal c * n, acc.size
+  end
+
   def test_stream_dev_random_get_string
     fd = machine.open('/dev/random', UM::O_RDONLY)
     stream = UM::Stream.new(machine, fd)

data/test/test_um.rb

@@ -292,6 +292,20 @@ class ScheduleTest < UMBaseTest
     assert_kind_of TOError, e
   end
 
+  def test_timeout_with_exception_instance
+    res = nil
+    e = TOError.new
+    begin
+      res = machine.timeout(0.01, e) {
+        machine.sleep(1)
+        :foo
+      }
+    rescue => res
+    end
+
+    assert_equal e, res
+  end
+
   def test_timeout_with_raising_block
     e = nil
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.29.1
 platform: ruby
 authors:
 - Sharon Rosner
@@ -67,6 +67,7 @@ files:
 - benchmark/common.rb
 - benchmark/dns_client.rb
 - benchmark/gets.rb
+- benchmark/gets_concurrent.rb
 - benchmark/http_parse.rb
 - benchmark/http_server_accept_queue.rb
 - benchmark/http_server_multi_accept.rb