polyphony 0.54.0 → 0.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c88e804739b62a55f7647c57e55582d2ae5cf6a73bca55160aa90138b80217a
-  data.tar.gz: ecbeb0aeed96a7b6f21f8d41b67195574213b8b01b51bccd0f1bcf59165ab9f6
+  metadata.gz: 2f0f6698a072e4ba2913477d20f5884d5d7579b99cca1db0f2ffa3aeca42ebcc
+  data.tar.gz: 97fec9986f6693d685bfb0c1745995c8a85413a9b6cc1a1ff69393d55a5f3b74
 SHA512:
-  metadata.gz: 93ff227cab8891c79bc4447c25359df03cd675ada579d13c5dc09d1f18e42fd00ed1b3ce5e433bd5addf83076af3a45c29cdd49ae8cb2cb9f19892cb27a40476
-  data.tar.gz: 1e1f39c19d2edbd49406c3a3917848951914c48b81316fff6ff78f381fb7db70b407dc5428b94a45292261e202df1c91da5d4e971ab19ba91e7c96e0bbbb91bc
+  metadata.gz: 053beffc7c27658d129002b5efc29f64c7fcf1ff7fbf3f2eea1d588b2a9e40e89251640bf9bb82ce478837f38c32863987d8ac0af987d374d4ac242d012363dd
+  data.tar.gz: e89df4044f09f4df64fc57622f22e70d932f2f09ea3b2a5c2090698784c286367df43d352231068b8ef96d6a7ba89e5492b4c237c9960aeb5fa79af9ee738768

data/.gitignore

@@ -56,4 +56,6 @@ lib/*.bundle
 lib/*.so
 
 _site
-.sass-cache
+.sass-cache
+
+log

data/CHANGELOG.md

@@ -1,4 +1,11 @@
-## 0.54.0
+## 0.55.0 2021-06-17
+
+- Finish io_uring implementation of Backend#chain
+- Reimplement io_uring op_context acquire/release algorithm (using ref count) 
+- Fix #gets on sockets
+- Redesign event anti-starvation mechanism
+
+## 0.54.0 2021-06-14
 
 - Implement Mutex#owned?, #locked? (#50)
 - Fix arity for SSLSocket#peeraddr (#55)
@@ -6,15 +13,15 @@
 - Fix SSLSocket buffering behaviour
 - Add recv_loop alias for SSLSocket (#54)
 
-## 0.53.2
+## 0.53.2 2021-05-10
 
 - Remove `splice` methods on libev backend on non-Linux OS (#43)
 
-## 0.53.0
+## 0.53.0 2021-04-23
 
 - Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`
 
-## 0.52.0
+## 0.52.0 2021-02-28
 
 - Polyphony is now compatible with Ruby 3.0
 - Add `Backend#sendv` method for sending multiple strings
@@ -24,19 +31,19 @@
 - libev backend: Use` pidfd_open` for Linux 5.3+, otherwise use a libev child watcher
 - Use `:call` as default method in `#feed_loop`
 
-## 0.51.0
+## 0.51.0 2021-02-02
 
 - Implement `IO#feed_loop`, `Socket#feed_loop`
 - Fix error handling in `Process.kill_and_await`
 
-## 0.50.1
+## 0.50.1 2021-01-31
 
 - Set `IOSQE_ASYNC` flag in io_uring backend
 - Fix error handling in `Backend#waitpid`
 - Reimplement libev backend's `#waitpid` by using pidfd_open (in similar manner
   to the io_uring backend)
 
-## 0.50.0
+## 0.50.0 2021-01-28
 
 - Use `Process::CLOCK_MONOTONIC` in Timer
 - Add `Timer#sleep`, `Timer#after`, `Timer#every`
@@ -44,50 +51,50 @@
 - Add `Thread#fiber_index_of` method
 - Use `Backend#wait_event` in `Fiber#await`
 
-## 0.49.2
+## 0.49.2 2021-01-19
 
 - Fix hang with 100s or more child fibers when terminating
 - Fix double pending_count increment in io_uring backend
 
-## 0.49.1
+## 0.49.1 2021-01-13
 
 - Use `TCPSocket` instead of `Socket` in `Net.tcp_connect`
 - Catch `Errno::ERSCH` in `Process.kill_and_await`
 - Set io_uring queue size to 2048
 
-## 0.49.0
+## 0.49.0 2021-01-11
 
 - Implement `Polyphony::Timer` for performant timeouts
 
-## 0.48.0
+## 0.48.0 2021-01-05
 
 - Implement graceful shutdown
 - Add support for `break` / `StopIteration` in `spin_loop`
 - Fix `IO#gets`, `IO#readpartial`
 
-## 0.47.5.1
+## 0.47.5.1 2020-11-20
 
 - Add missing `Socket#accept_loop` method
 
-## 0.47.5
+## 0.47.5 2020-11-20
 
 - Add `socket_class` argument to `Backend#accept`, `Backend#accept_loop`
 - Fix `#supervise` to stop when all children fibers are done
 
-## 0.47.4
+## 0.47.4 2020-11-14
 
 - Add support for Unix sockets
 
-## 0.47.3
+## 0.47.3 2020-11-12
 
 - Enable I/O in signal handlers (#45)
 - Accept `:interval` argument in `#spin_loop`
 
-## 0.47.2
+## 0.47.2 2020-11-10
 
 - Fix API compatibility between TCPSocket and IO
 
-## 0.47.0
+## 0.47.0 2020-11-10
 
 - Implement `#spin_scope` used for creating blocking fiber scopes 
 - Reimplement `move_on_after`, `cancel_after`, `Timeout.timeout` using
@@ -95,18 +102,18 @@
 - Implement `Backend#timeout` API
 - Implemented capped queues
 
-## 0.46.1
+## 0.46.1 2020-11-04
 
 - Add `TCPServer#accept_loop`, `OpenSSL::SSL::SSLSocket#accept_loop` method
 - Fix compilation error on MacOS (#43)
 - Fix backtrace for `Timeout.timeout`
 - Add `Backend#timer_loop`
 
-## 0.46.0
+## 0.46.0 2020-10-08
 
 - Implement [io_uring backend](https://github.com/digital-fabric/polyphony/pull/44)
 
-## 0.45.5
+## 0.45.5 2020-10-04
 
 - Fix compilation error (#43)
 - Add support for resetting move_on_after, cancel_after timeouts
@@ -115,22 +122,22 @@
 - Schedule parent with priority on uncaught exception
 - Fix race condition in `Mutex#synchronize` (#41)
 
-## 0.45.4
+## 0.45.4 2020-09-06
 
 - Improve signal trapping mechanism
 
-## 0.45.3
+## 0.45.3 2020-09-02
 
 - Don't swallow error in `Process#kill_and_await`
 - Add `Fiber#mailbox` attribute reader
 - Fix bug in `Fiber.await`
 - Implement `IO#getc`, `IO#getbyte`
 
-## 0.45.2
+## 0.45.2 2020-08-03
 
 - Rewrite `Fiber#<<`, `Fiber#await`, `Fiber#receive` in C
 
-## 0.45.1
+## 0.45.1 2020-08-01
 
 - Fix Net::HTTP compatibility
 - Fix fs adapter
@@ -140,7 +147,7 @@
 - Cleanup code
 - Improve support for Ruby 3 keyword args
 
-## 0.45.0
+## 0.45.0 2020-07-29
 
 - Cleanup code
 - Rename `Agent` to `Backend`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.54.0)
+    polyphony (0.55.0)
 
 GEM
   remote: https://rubygems.org/

data/TODO.md

@@ -10,9 +10,6 @@
 
 - Add support for `break` and `StopIteration` in all loops (with tests)
 
-- Change `IO#gets` to use `String#split` to cut into lines, much faster (see
-  examples/performance/line_splitting.rb)
-
 - More tight loops
   - `IO#gets_loop`, `Socket#gets_loop`, `OpenSSL::Socket#gets_loop` (medium effort)
   - `Fiber#receive_loop` (very little effort, should be implemented in C)

data/examples/io/stdio.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts 'Please enter your name:'
+name = gets.chomp
+puts "Hello, #{name}!"

data/ext/polyphony/backend_common.h

@@ -26,7 +26,7 @@ struct io_internal_read_struct {
 
 #define StringValue(v) rb_string_value(&(v))
 
-int io_setstrbuf(VALUE *str, long len) {
+inline int io_setstrbuf(VALUE *str, long len) {
   #ifdef _WIN32
     len = (len + 1) & ~1L;	/* round up for wide char */
   #endif
@@ -55,7 +55,7 @@ inline void io_shrink_read_string(VALUE str, long n) {
   }
 }
 
-void io_set_read_length(VALUE str, long n, int shrinkable) {
+inline void io_set_read_length(VALUE str, long n, int shrinkable) {
   if (RSTRING_LEN(str) != n) {
     rb_str_modify(str);
     rb_str_set_len(str, n);
@@ -64,16 +64,16 @@ void io_set_read_length(VALUE str, long n, int shrinkable) {
 }
 
 inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
-    if (fptr->encs.enc) {
-	return fptr->encs.enc;
-    }
-    return rb_default_external_encoding();
+  if (fptr->encs.enc) {
+	  return fptr->encs.enc;
+  }
+  return rb_default_external_encoding();
 }
 
-VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
-    OBJ_TAINT(str);
-    rb_enc_associate(str, io_read_encoding(fptr));
-    return str;
+inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
+  OBJ_TAINT(str);
+  rb_enc_associate(str, io_read_encoding(fptr));
+  return str;
 }
 
 //////////////////////////////////////////////////////////////////////

data/ext/polyphony/backend_io_uring.c

@@ -21,6 +21,9 @@
 #include "ruby/io.h"
 
 VALUE SYM_io_uring;
+VALUE SYM_send;
+VALUE SYM_splice;
+VALUE SYM_write;
 
 #ifdef POLYPHONY_UNSET_NONBLOCK
 ID ID_ivar_is_nonblocking;
@@ -51,7 +54,6 @@ typedef struct Backend_t {
   // common fields
   unsigned int        currently_polling;
   unsigned int        pending_count;
-  unsigned int        poll_no_wait_count;
 
   // implementation-specific fields
   struct io_uring     ring;
@@ -88,7 +90,6 @@ static VALUE Backend_initialize(VALUE self) {
 
   backend->currently_polling = 0;
   backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -118,7 +119,6 @@ VALUE Backend_post_fork(VALUE self) {
   context_store_free(&backend->store);
   backend->currently_polling = 0;
   backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
 
   return self;
@@ -155,17 +155,9 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   if (!ctx) return;
 
   ctx->result = cqe->res;
-
-  if (ctx->completed)
-    // already marked as deleted as result of fiber resuming before op
-    // completion, so we can release the context
-    context_store_release(&backend->store, ctx);
-  else {
-    // otherwise, we mark it as completed, schedule the fiber and let it deal
-    // with releasing the context
-    ctx->completed = 1;
-    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, ctx->resume_value);
-  }
+  if (ctx->ref_count == 2 && ctx->result != -ECANCELED && ctx->fiber)
+    Fiber_make_runnable(ctx->fiber, ctx->resume_value);
+  context_store_release(&backend->store, ctx);
 }
 
 // adapted from io_uring_peek_batch_cqe in queue.c 
@@ -219,16 +211,6 @@ VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait) {
-    backend->poll_no_wait_count++;
-    if (backend->poll_no_wait_count < 10) return self;
-
-    long runnable_count = Runqueue_len(runqueue);
-    if (backend->poll_no_wait_count < runnable_count) return self;
-  }
-
-  backend->poll_no_wait_count = 0;
-
   if (is_nowait && backend->pending_sqes) {
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
@@ -283,10 +265,9 @@ int io_uring_backend_defer_submit_and_await(
 
   switchpoint_result = backend_await(backend);
 
-  if (!ctx->completed) {
+  if (ctx->ref_count > 1) {
+    // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
-
-    // op was not completed, so we need to cancel it
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_cancel(sqe, ctx, 0);
     backend->pending_sqes = 0;
@@ -300,7 +281,7 @@ int io_uring_backend_defer_submit_and_await(
 }
 
 VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_POLL);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_POLL);
   VALUE resumed_value = Qnil;
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -332,14 +313,14 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, buffer_size - total, -1);
 
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -393,14 +374,14 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
     
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -440,14 +421,14 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
     
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -483,14 +464,14 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
 
   while (left > 0) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_WRITE);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_write(sqe, fptr->fd, buf, left, -1);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
     
     if (result < 0)
@@ -532,17 +513,17 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_WRITEV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_writev(sqe, fptr->fd, iov_ptr, iov_count, -1);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     if (TEST_EXCEPTION(resume_value)) {
       free(iov);
       RAISE_EXCEPTION(resume_value);
     }
-    if (!ctx->completed) {
+    if (!completed) {
       free(iov);
       return resume_value;
     }
@@ -605,14 +586,14 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -652,14 +633,14 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -698,14 +679,14 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -741,14 +722,14 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   while (left > 0) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SEND);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -775,14 +756,14 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_ACCEPT);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_accept(sqe, fptr->fd, &addr, &len, 0);
     
     int fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (fd < 0)
@@ -846,14 +827,14 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
   VALUE resume_value = Qnil;
 
   while (1) {
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SPLICE);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
 
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
@@ -897,13 +878,13 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   addr.sin_port = htons(NUM2INT(port));
 
   VALUE resume_value = Qnil;
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_CONNECT);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_CONNECT);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   io_uring_prep_connect(sqe, fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
   int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-  OP_CONTEXT_RELEASE(&backend->store, ctx);
+  int completed = context_store_release(&backend->store, ctx);
   RAISE_IF_EXCEPTION(resume_value);
-  if (!ctx->completed) return resume_value;
+  if (!completed) return resume_value;
   RB_GC_GUARD(resume_value);
   
   if (result < 0) rb_syserr_fail(-result, strerror(-result));
@@ -943,12 +924,11 @@ int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duratio
   struct __kernel_timespec ts = double_to_timespec(duration);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
 
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
-  OP_CONTEXT_RELEASE(&backend->store, ctx);
-  return ctx->completed;
+  return context_store_release(&backend->store, ctx);
 }
 
 VALUE Backend_sleep(VALUE self, VALUE duration) {
@@ -996,7 +976,7 @@ struct Backend_timeout_ctx {
 
 VALUE Backend_timeout_ensure(VALUE arg) {
     struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
-    if (!timeout_ctx->ctx->completed) {
+    if (timeout_ctx->ctx->ref_count) {
     timeout_ctx->ctx->result = -ECANCELED;
 
     // op was not completed, so we need to cancel it
@@ -1005,7 +985,7 @@ VALUE Backend_timeout_ensure(VALUE arg) {
     timeout_ctx->backend->pending_sqes = 0;
     io_uring_submit(&timeout_ctx->backend->ring);
   }
-  OP_CONTEXT_RELEASE(&timeout_ctx->backend->store, timeout_ctx->ctx);
+  context_store_release(&timeout_ctx->backend->store, timeout_ctx->ctx);
   return Qnil;
 }
 
@@ -1023,7 +1003,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
@@ -1091,6 +1071,130 @@ VALUE Backend_kind(VALUE self) {
   return SYM_io_uring;
 }
 
+struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, VALUE str) {
+  rb_io_t *fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
+
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_write(sqe, fptr->fd, buf, len, -1);
+  return sqe;
+}
+
+struct io_uring_sqe *Backend_chain_prepare_send(Backend_t *backend, VALUE io, VALUE str, VALUE flags) {
+  rb_io_t *fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
+
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+  int flags_int = NUM2INT(flags);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_send(sqe, fptr->fd, buf, len, flags_int);
+  return sqe;
+}
+
+struct io_uring_sqe *Backend_chain_prepare_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen) {
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_unset_nonblock(src_fptr, src);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_unset_nonblock(dest_fptr, dest);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
+  return sqe;
+}
+
+VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
+  VALUE resume_value = Qnil;
+  unsigned int sqe_count = 0;
+  struct io_uring_sqe *last_sqe = 0;
+  Backend_t *backend;
+  GetBackend(self, backend);
+  if (argc == 0) return resume_value;
+
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_CHAIN);
+  for (int i = 0; i < argc; i++) {
+    VALUE op = argv[i];
+    VALUE op_type = RARRAY_AREF(op, 0);
+    VALUE op_len = RARRAY_LEN(op);
+
+    if (op_type == SYM_write && op_len == 3) {
+      last_sqe = Backend_chain_prepare_write(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2));
+    }
+    else if (op_type == SYM_send && op_len == 4)
+      last_sqe = Backend_chain_prepare_send(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    else if (op_type == SYM_splice && op_len == 4)
+      last_sqe = Backend_chain_prepare_splice(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    else {
+      if (sqe_count) {
+        io_uring_sqe_set_data(last_sqe, ctx);
+        io_uring_sqe_set_flags(last_sqe, IOSQE_ASYNC);
+
+        ctx->ref_count = sqe_count;
+        ctx->result = -ECANCELED;
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+        io_uring_prep_cancel(sqe, ctx, 0);
+        backend->pending_sqes = 0;
+        io_uring_submit(&backend->ring);
+      }
+      else {
+        ctx->ref_count = 1;
+        context_store_release(&backend->store, ctx);
+      }
+      rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
+    }
+    
+    io_uring_sqe_set_data(last_sqe, ctx);
+    unsigned int flags = (i == argc - 1) ? IOSQE_ASYNC : IOSQE_ASYNC & IOSQE_IO_LINK;
+    io_uring_sqe_set_flags(last_sqe, flags);
+    sqe_count++;
+  }
+
+  ctx->ref_count = sqe_count + 1;
+  io_uring_backend_defer_submit(backend);
+  resume_value = backend_await(backend);
+  int result = ctx->result;
+  int completed = context_store_release(&backend->store, ctx);
+  if (!completed) {
+    // op was not completed (an exception was raised), so we need to cancel it
+    ctx->result = -ECANCELED;
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_cancel(sqe, ctx, 0);
+    backend->pending_sqes = 0;
+    io_uring_submit(&backend->ring);
+    RAISE_IF_EXCEPTION(resume_value);
+    return resume_value;
+  }
+  
+  RB_GC_GUARD(resume_value);
+  return INT2NUM(result);
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -1102,6 +1206,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
   rb_define_method(cBackend, "kind", Backend_kind, 0);
+  rb_define_method(cBackend, "chain", Backend_chain, -1);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
@@ -1130,6 +1235,9 @@ void Init_Backend() {
   #endif
 
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
+  SYM_send = ID2SYM(rb_intern("send"));
+  SYM_splice = ID2SYM(rb_intern("splice"));
+  SYM_write = ID2SYM(rb_intern("write"));
 }
 
 #endif // POLYPHONY_BACKEND_LIBURING

data/ext/polyphony/backend_io_uring_context.c

@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <assert.h>
 #include "ruby.h"
 #include "polyphony.h"
 #include "backend_io_uring_context.h"
@@ -15,6 +16,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_POLL: return "POLL";
   case OP_ACCEPT: return "ACCEPT";
   case OP_CONNECT: return "CONNECT";
+  case OP_CHAIN: return "CHAIN";
   default: return "";
   };
 }
@@ -35,6 +37,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
     ctx = malloc(sizeof(op_context_t));
   }
   ctx->id = (++store->last_id);
+  // printf("acquire %d (%s)\n", ctx->id, op_type_to_str(type));
   
   ctx->prev = NULL;
   ctx->next = store->taken;
@@ -44,13 +47,21 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
   ctx->type = type;
   ctx->fiber = rb_fiber_current();
   ctx->resume_value = Qnil;
-  ctx->completed = 0;
+  ctx->ref_count = 2;
   ctx->result = 0;
 
   return ctx;
 }
 
-inline void context_store_release(op_context_store_t *store, op_context_t *ctx) {
+// returns true if ctx was released
+inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
+  // printf("release %d (%s, ref_count: %d)\n", ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
+
+  assert(ctx->ref_count);
+  
+  ctx->ref_count--;
+  if (ctx->ref_count) return 0;
+
   if (ctx->next) ctx->next->prev = ctx->prev;
   if (ctx->prev) ctx->prev->next = ctx->next;
   if (store->taken == ctx) store->taken = ctx->next;
@@ -59,6 +70,7 @@ inline void context_store_release(op_context_store_t *store, op_context_t *ctx)
   ctx->next = store->available;
   if (ctx->next) ctx->next->prev = ctx;
   store->available = ctx;
+  return 1;
 }
 
 void context_store_free(op_context_store_t *store) {

data/ext/polyphony/backend_io_uring_context.h

@@ -14,14 +14,15 @@ enum op_type {
   OP_TIMEOUT,
   OP_POLL,
   OP_ACCEPT,
-  OP_CONNECT
+  OP_CONNECT,
+  OP_CHAIN
 };
 
 typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;
   enum op_type      type: 16;
-  int               completed : 16;
+  unsigned int      ref_count : 16;         
   int               id;
   int               result;
   VALUE             fiber;
@@ -38,17 +39,16 @@ const char *op_type_to_str(enum op_type type);
 
 void context_store_initialize(op_context_store_t *store);
 op_context_t *context_store_acquire(op_context_store_t *store, enum op_type type);
-void context_store_release(op_context_store_t *store, op_context_t *ctx);
+int context_store_release(op_context_store_t *store, op_context_t *ctx);
 void context_store_free(op_context_store_t *store);
 
-#define OP_CONTEXT_ACQUIRE(store, op_type) context_store_acquire(store, op_type)
-#define OP_CONTEXT_RELEASE(store, ctx) { \
-  if (ctx->completed) {\
-    context_store_release(store, ctx); \
-  } \
-  else { \
-    ctx->completed = 1; \
-  } \
+inline unsigned int OP_CONTEXT_RELEASE(op_context_store_t *store, op_context_t *ctx) {
+  int completed = !ctx->ref_count;
+  if (ctx->ref_count)
+    ctx->ref_count -= 1;
+  else
+    context_store_release(store, ctx);
+  return completed;
 }
 
 #endif /* BACKEND_IO_URING_CONTEXT_H */

data/ext/polyphony/backend_libev.c

@@ -90,7 +90,6 @@ typedef struct Backend_t {
   // common fields
   unsigned int        currently_polling;
   unsigned int        pending_count;
-  unsigned int        poll_no_wait_count;
 
   // implementation-specific fields
   struct ev_loop *ev_loop;
@@ -145,7 +144,6 @@ static VALUE Backend_initialize(VALUE self) {
 
   backend->currently_polling = 0;
   backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
 
   return Qnil;
 }
@@ -184,23 +182,12 @@ unsigned int Backend_pending_count(VALUE self) {
 }
 
 VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
-  int is_nowait = nowait == Qtrue;
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait) {
-    backend->poll_no_wait_count++;
-    if (backend->poll_no_wait_count < 10) return self;
-
-    long runnable_count = Runqueue_len(runqueue);
-    if (backend->poll_no_wait_count < runnable_count) return self;
-  }
-
-  backend->poll_no_wait_count = 0;
-
   COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
   backend->currently_polling = 1;
-  ev_run(backend->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
+  ev_run(backend->ev_loop, nowait == Qtrue ? EVRUN_NOWAIT : EVRUN_ONCE);
   backend->currently_polling = 0;
   COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 

data/ext/polyphony/polyphony.h

@@ -90,6 +90,7 @@ int Runqueue_index_of(VALUE self, VALUE fiber);
 void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
+int Runqueue_should_poll_nonblocking(VALUE self);
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 #define Backend_recv_loop Backend_read_loop

data/ext/polyphony/runqueue.c

@@ -3,6 +3,8 @@
 
 typedef struct queue {
   runqueue_ring_buffer entries;
+  unsigned int high_watermark;
+  unsigned int switch_count;
 } Runqueue_t;
 
 VALUE cRunqueue = Qnil;
@@ -43,6 +45,8 @@ static VALUE Runqueue_initialize(VALUE self) {
   GetRunqueue(self, runqueue);
 
   runqueue_ring_buffer_init(&runqueue->entries);
+  runqueue->high_watermark = 0;
+  runqueue->switch_count = 0;
 
   return self;
 }
@@ -53,6 +57,8 @@ void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
 
   if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
   runqueue_ring_buffer_push(&runqueue->entries, fiber, value);
+  if (runqueue->entries.count > runqueue->high_watermark)
+    runqueue->high_watermark = runqueue->entries.count;
 }
 
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
@@ -60,12 +66,19 @@ void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
   GetRunqueue(self, runqueue);
   if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
   runqueue_ring_buffer_unshift(&runqueue->entries, fiber, value);
+  if (runqueue->entries.count > runqueue->high_watermark)
+    runqueue->high_watermark = runqueue->entries.count;
 }
 
 runqueue_entry Runqueue_shift(VALUE self) {
   Runqueue_t *runqueue;
   GetRunqueue(self, runqueue);
-  return runqueue_ring_buffer_shift(&runqueue->entries);
+  runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
+  if (entry.fiber == Qnil)
+    runqueue->high_watermark = 0;
+  else
+    runqueue->switch_count += 1;
+  return entry;
 }
 
 void Runqueue_delete(VALUE self, VALUE fiber) {
@@ -100,6 +113,21 @@ int Runqueue_empty_p(VALUE self) {
   return (runqueue->entries.count == 0);
 }
 
+static const unsigned int ANTI_STARVE_HIGH_WATERMARK_THRESHOLD = 128;
+static const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
+
+int Runqueue_should_poll_nonblocking(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
+  if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
+
+  // the 
+  runqueue->switch_count = 0;
+  return 1;
+}
+
 void Init_Runqueue() {
   cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cObject);
   rb_define_alloc_func(cRunqueue, Runqueue_allocate);

data/ext/polyphony/thread.c

@@ -86,7 +86,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   runqueue_entry next;
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  unsigned int pending_count = Backend_pending_count(backend);
+  unsigned int pending_ops_count = Backend_pending_count(backend);
   unsigned int backend_was_polled = 0;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
@@ -95,14 +95,24 @@ VALUE Thread_switch_fiber(VALUE self) {
   while (1) {
     next = Runqueue_shift(runqueue);
     if (next.fiber != Qnil) {
-      if (!backend_was_polled && pending_count) {
+      // Polling for I/O op completion is normally done when the run queue is
+      // empty, but if the runqueue never empties, we'll never get to process
+      // any event completions. In order to prevent this, an anti-starve
+      // mechanism is employed, under the following conditions:
+      // - a blocking poll was not yet performed
+      // - there are pending blocking operations
+      // - the runqueue has signalled that a non-blocking poll should be
+      //   performed
+      //   - the run queue length high watermark has reached its threshold (currently 128)
+      //   - the run queue switch counter has reached its threshold (currently 64) 
+      if (!backend_was_polled && pending_ops_count && Runqueue_should_poll_nonblocking(runqueue)) {
         // this prevents event starvation in case the run queue never empties
         Backend_poll(backend, Qtrue, current_fiber, runqueue);
       }
       break;
     }
-    if (pending_count == 0) break;
-
+    
+    if (pending_ops_count == 0) break;
     Backend_poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;
   }

data/lib/polyphony/extensions/socket.rb

@@ -36,9 +36,9 @@ class ::Socket
   end
 
   def recvfrom(maxlen, flags = 0)
-    @read_buffer ||= +''
+    buf = +''
     while true
-      result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
+      result = recvfrom_nonblock(maxlen, flags, buf, **NO_EXCEPTION)
       case result
       when nil then raise IOError
       when :wait_readable then Polyphony.backend_wait_io(self, false)
@@ -165,17 +165,10 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  def readpartial(maxlen, str = +'')
+    result = Polyphony.backend_recv(self, str, maxlen)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
     str
   end
 
@@ -249,17 +242,10 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  def readpartial(maxlen, str = +'')
+    result = Polyphony.backend_recv(self, str, maxlen)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
     str
   end
 

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.54.0'
+  VERSION = '0.55.0'
 end

data/test/helper.rb

@@ -15,9 +15,9 @@ require 'minitest/reporters'
 
 ::Exception.__disable_sanitized_backtrace__ = true
 
-Minitest::Reporters.use! [
-  Minitest::Reporters::SpecReporter.new
-]
+# Minitest::Reporters.use! [
+#   Minitest::Reporters::SpecReporter.new
+# ]
 
 class ::Fiber
   attr_writer :auto_watcher

data/test/test_backend.rb

@@ -26,7 +26,7 @@ class BackendTest < MiniTest::Test
       @backend.sleep 0.01
       count += 1
     }.await
-    assert_in_delta 0.03, Time.now - t0, 0.005
+    assert_in_delta 0.03, Time.now - t0, 0.01
     assert_equal 3, count
   end
 
@@ -309,6 +309,36 @@ class BackendChainTest < MiniTest::Test
     assert_equal 'hello world', i.read
   end
 
+  def test_simple_send_chain
+    port = rand(1234..5678)
+    server = TCPServer.new('127.0.0.1', port)
+
+    server_fiber = spin do
+      while (socket = server.accept)
+        spin do
+          while (data = socket.gets(8192))
+            socket << data
+          end
+        end
+      end
+    end
+
+    snooze
+    client = TCPSocket.new('127.0.0.1', port)
+    
+    result = Thread.backend.chain(
+      [:send, client, 'hello', 0],
+      [:send, client, " world\n", 0]
+    )
+    sleep 0.1
+    assert_equal "hello world\n", client.recv(8192)
+    client.close
+  ensure
+    server_fiber&.stop
+    server_fiber&.await
+    server&.close
+  end
+
   def chunk_header(len)
     "Content-Length: #{len}\r\n\r\n"
   end
@@ -346,7 +376,16 @@ class BackendChainTest < MiniTest::Test
 
     assert_raises(RuntimeError) {
       Thread.backend.chain(
-        [:read, o]
+        [:read, i]
+      )
+    }
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:write, o, 'abc'],
+        [:write, o, 'abc'],
+        [:write, o, 'abc'],
+        [:read, i]
       )
     }
 
@@ -355,5 +394,10 @@ class BackendChainTest < MiniTest::Test
         [:write, o]
       )
     }
+
+    # Eventually we should add some APIs to the io_uring backend to query the
+    # contxt store, then add some tests here to verify that the chain op ctx is
+    # released properly before raising the error (for the time being this has
+    # been verified manually).
   end
 end

data/test/test_fiber.rb

@@ -132,7 +132,6 @@ class FiberTest < MiniTest::Test
     event = Polyphony::Event.new
 
     t = Thread.new do
-      f = spin_loop { snooze }
       sleep 0.001
       event.signal(:foo)
     end

data/test/test_io.rb

@@ -98,8 +98,10 @@ class IOTest < MiniTest::Test
 
     buf = []
     f = spin do
+      peer = receive
       while (l = i.gets)
         buf << l
+        peer << true
       end
     end
 
@@ -107,11 +109,12 @@ class IOTest < MiniTest::Test
     assert_equal [], buf
 
     o << 'fab'
-    snooze
+    f << Fiber.current
+    sleep 0.05
     assert_equal [], buf
     
     o << "ulous\n"
-    sleep 0.01
+    receive
     assert_equal ["fabulous\n"], buf
 
     o.close
@@ -287,7 +290,7 @@ class IOClassMethodsTest < MiniTest::Test
   end
 
   def test_foreach
-    skip "IO.foreach is not yet implemented"
+    skip 'IO.foreach is not yet implemented'
     lines = []
     IO.foreach(__FILE__) { |l| lines << l }
     assert_equal "# frozen_string_literal: true\n", lines[0]

data/test/test_signal.rb

@@ -50,7 +50,7 @@ class SignalTrapTest < Minitest::Test
     ensure
       o.close
     end
-    sleep 0.02
+    sleep 0.1
     o.close
     Process.kill('INT', pid)
     Thread.current.backend.waitpid(pid)

data/test/test_thread_pool.rb

@@ -65,7 +65,7 @@ class ThreadPoolTest < MiniTest::Test
     end
     elapsed = Time.now - t0
 
-    assert elapsed < 0.007
+    assert_in_range 0.0..0.009, elapsed
     assert buffer.size < 2
     
     sleep 0.1 # allow time for threads to spawn

data/test/test_timer.rb

@@ -31,7 +31,7 @@ class TimerMoveOnAfterTest < MiniTest::Test
     end
     t1 = Time.now
 
-    assert_in_range 0.01..0.025, t1 - t0
+    assert_in_range 0.01..0.05, t1 - t0
     assert_equal :bar, v
   end
 
@@ -75,14 +75,21 @@ class TimerCancelAfterTest < MiniTest::Test
   end
 
   def test_timer_cancel_after_with_reset
-    t0 = Time.now
+    buf = []
     @timer.cancel_after(0.01) do
-      sleep 0.007
+      sleep 0.005
+      buf << 1
       @timer.reset
-      sleep 0.007
+      sleep 0.005
+      buf << 2
+      @timer.reset
+      sleep 0.005
+      buf << 3
+      @timer.reset
+      sleep 0.005
+      buf << 4
     end
-    t1 = Time.now
-    assert_in_range 0.012..0.024, t1 - t0
+    assert_equal [1, 2, 3, 4], buf
   end
 
   class CustomException < Exception
@@ -140,7 +147,6 @@ class TimerMiscTest < MiniTest::Test
     snooze
     assert_equal [], buffer
     sleep 0.1
-    p :post_sleep
     assert_equal [2], buffer
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.54.0
+  version: 0.55.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-14 00:00:00.000000000 Z
+date: 2021-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -359,6 +359,7 @@ files:
 - examples/io/rack_server.rb
 - examples/io/raw.rb
 - examples/io/reline.rb
+- examples/io/stdio.rb
 - examples/io/system.rb
 - examples/io/tcp_proxy.rb
 - examples/io/tcpserver.rb