polyphony 0.52.0 → 0.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2056b02e3b364911ab627ffc49a7251ad2eed68ba6b5b61d380c599127c181f6
-  data.tar.gz: 440f57d240b90a255b470f405980b5fa2f806ba3ff2640f31d78b6403de7ce0e
+  metadata.gz: 2f0f6698a072e4ba2913477d20f5884d5d7579b99cca1db0f2ffa3aeca42ebcc
+  data.tar.gz: 97fec9986f6693d685bfb0c1745995c8a85413a9b6cc1a1ff69393d55a5f3b74
 SHA512:
-  metadata.gz: b5bf34a4ea7addf2b71c2e0acc75041d95f5d76ae425061bd5475e6523111a05cf969b0109ec90874f7f1a1929111182ed193b084b3388be060886145dd20567
-  data.tar.gz: 6165128a0393664c97baa494119e453db177b7d0a12c5a5ade0ab5bb8e77a4143f6156b9cb594ef2edbbe9e0ac3bb85a2c846da8e925c3a6ec1c294120c18bf2
+  metadata.gz: 053beffc7c27658d129002b5efc29f64c7fcf1ff7fbf3f2eea1d588b2a9e40e89251640bf9bb82ce478837f38c32863987d8ac0af987d374d4ac242d012363dd
+  data.tar.gz: e89df4044f09f4df64fc57622f22e70d932f2f09ea3b2a5c2090698784c286367df43d352231068b8ef96d6a7ba89e5492b4c237c9960aeb5fa79af9ee738768

data/.github/workflows/test.yml

@@ -26,6 +26,6 @@ jobs:
     - name: Show Linux kernel version
       run: uname -r
     - name: Compile C-extension
-      run: bundle exec rake compile
+      run: POLYPHONY_USE_LIBEV=1 bundle exec rake compile
     - name: Run tests
       run:  bundle exec rake test

data/.gitignore

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

data/CHANGELOG.md

@@ -1,4 +1,27 @@
-## 0.52.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)
+- Add missing SSLServer#accept_loop method (#53)
+- Fix SSLSocket buffering behaviour
+- Add recv_loop alias for SSLSocket (#54)
+
+## 0.53.2 2021-05-10
+
+- Remove `splice` methods on libev backend on non-Linux OS (#43)
+
+## 0.53.0 2021-04-23
+
+- Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`
+
+## 0.52.0 2021-02-28
 
 - Polyphony is now compatible with Ruby 3.0
 - Add `Backend#sendv` method for sending multiple strings
@@ -8,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`
@@ -28,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
@@ -79,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
@@ -99,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
@@ -124,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.52.0)
+    polyphony (0.55.0)
 
 GEM
   remote: https://rubygems.org/
@@ -17,6 +17,7 @@ GEM
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
     json (2.3.0)
+    localhost (1.1.8)
     method_source (1.0.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
@@ -72,6 +73,7 @@ DEPENDENCIES
   hiredis (= 0.6.3)
   http_parser.rb (~> 0.6.0)
   httparty (= 0.17.1)
+  localhost (~> 1.1.4)
   minitest (= 5.14.4)
   minitest-reporters (= 1.4.2)
   msgpack (= 1.4.2)

data/TODO.md

@@ -1,8 +1,7 @@
-- Implement io_uring Backend_send with variable arity.
-- Implement a buffer store for use in:
-  - io_uring Backend_send_m
-  - io_uring Backend_writev (for iov)
-  - libvev Backend_writev (for iov)
+- Add support for IPv6:
+  https://www.reddit.com/r/ruby/comments/lyen23/understanding_ipv6_and_why_its_important_to_you/
+
+- Add support for UDP sockets
 
 - Check segfault when resetting a `cancel_after` timeout lots of times at very high rate
 - Check why `throttled_loop` inside of `move_on_after` fails to stop
@@ -11,25 +10,51 @@
 
 - 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)
 
 
-- Add `Backend#splice`, `Backend#splice_loop` for implementing stuff like proxying:
+- Add `Backend#splice`, `Backend#splice_to_eof` for implementing stuff like proxying:
 
   ```ruby
   def two_way_proxy(socket1, socket2)
     backend = Thread.current.backend
-    f1 = spin { backend.splice_loop(socket1, socket2) }
-    f2 = spin { backend.splice_loop(socket2, socket1) }
+    f1 = spin { backend.splice_to_eof(socket1, socket2) }
+    f2 = spin { backend.splice_to_eof(socket2, socket1) }
     Fiber.await(f1, f2)
   end
   ```
 
+- Add support for `close` to io_uring backend
+
+- Add support for submission of multiple requests to io_uring backend:
+
+  ```ruby
+  Thread.current.backend.submit(
+    [:send, sock, chunk_header(len)],
+    [:splice, file, sock, len]
+  )
+  ```
+
+  Full example (for writing chunks from a file to an HTTP response):
+
+  ```ruby
+  def serve_io(io)
+    i, o = IO.pipe
+    backend = Thread.current.backend
+    while true
+      len = o.splice(io, 8192)
+      break if len == 0
+      
+      backend.submit(
+        [:write, sock, chunk_header(len)],
+        [:splice, i, sock, len]
+      )
+    end
+  end
+  ```
+
 - Graceful shutdown again:
   - What happens to children when doing a graceful shutdown?
   - What are the implications of passing graceful shutdown flag to children?

data/examples/core/queue.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+queue = Queue.new
+
+4.times { |i|
+  spin_loop {
+    job = queue.pop
+    puts("worker %d job %s" % [i, job.inspect])
+  }
+}
+
+(1..10).each do |i|
+  queue << "job#{i}"
+end
+
+sleep 0.1 until queue.empty?

data/examples/io/echo_server.rb

@@ -9,6 +9,7 @@ puts 'Echoing on port 1234...'
 while (client = server.accept)
   spin do
     while (data = client.gets)
+      # client.send("you said: #{data.chomp}!\n", 0)
       client.write('you said: ', data.chomp, "!\n")
     end
   rescue Errno::ECONNRESET

data/examples/io/https_server.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'localhost/authority'
+
+authority = Localhost::Authority.fetch
+opts = {
+  reuse_addr:     true,
+  dont_linger:    true,
+  secure_context: authority.server_context
+}
+
+server = Polyphony::Net.tcp_listen('localhost', 1234, opts)
+
+puts 'Serving HTTPS on port 1234'
+
+spin_loop(interval: 1) { STDOUT << '.' }
+
+# server.accept_loop do |socket|
+while (socket = server.accept)
+  spin do
+    while (data = socket.gets("\n", 8192))
+      if data.chomp.empty?
+        socket << "HTTP/1.1 200 OK\nConnection: close\nContent-Length: 4\n\nfoo\n"
+        break
+      end
+    end
+  end
+end

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/examples/io/tcp_proxy.rb

@@ -15,7 +15,7 @@ f1 = spin {
   client1 = server1.accept
   loop do
     if client2
-      Thread.current.backend.splice_loop(client1, client2)
+      Thread.current.backend.splice_to_eof(client1, client2)
     end
   end
 }
@@ -24,7 +24,7 @@ f2 = spin {
   client2 = server2.accept
   loop do
     if client1
-      Thread.current.backend.splice_loop(client2, client1)
+      Thread.current.backend.splice_to_eof(client2, client1)
     end
   end
 }

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;
@@ -43,6 +46,7 @@ inline void io_unset_nonblock(rb_io_t *fptr, VALUE io) {
   fcntl(fptr->fd, F_SETFL, oflags);
 }
 #else
+// NOP
 #define io_unset_nonblock(fptr, io)
 #endif
 
@@ -50,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;
@@ -87,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;
 
@@ -117,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;
@@ -149,26 +150,18 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring) {
 	return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
 }
 
-void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
+static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
   op_context_t *ctx = io_uring_cqe_get_data(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 
-// this peeks at cqes and for each one 
+// this peeks at cqes and handles each available cqe
 void io_uring_backend_handle_ready_cqes(Backend_t *backend) {
   struct io_uring *ring = &backend->ring;
 	bool overflow_checked = false;
@@ -218,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);
@@ -282,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;
@@ -299,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);
@@ -314,8 +296,8 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   Backend_t *backend;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
-  int shrinkable = io_setstrbuf(&str, len);
+  long buffer_size = dynamic_len ? 4096 : NUM2INT(length);
+  int shrinkable = io_setstrbuf(&str, buffer_size);
   char *buf = RSTRING_PTR(str);
   long total = 0;
   int read_to_eof = RTEST(to_eof);
@@ -331,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, len - total, -1);
+    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)
@@ -349,14 +331,15 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
       total += result;
       if (!read_to_eof) break;
 
-      if (total == len) {
+      if (total == buffer_size) {
         if (!dynamic_len) break;
 
+        // resize buffer
         rb_str_resize(str, total);
-        rb_str_modify_expand(str, len);
+        rb_str_modify_expand(str, buffer_size);
         buf = RSTRING_PTR(str) + total;
         shrinkable = 0;
-        len += len;
+        buffer_size += buffer_size;
       }
       else buf += result;
     }
@@ -391,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)
@@ -438,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)
@@ -481,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)
@@ -530,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;
     }
@@ -603,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)
@@ -650,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)
@@ -696,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)
@@ -739,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)
@@ -773,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)
@@ -824,6 +807,60 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   return self;
 }
 
+VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen, int loop) {
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  VALUE underlying_io;
+  int total = 0;
+
+  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);
+
+  VALUE resume_value = Qnil;
+
+  while (1) {
+    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);
+    int completed = context_store_release(&backend->store, ctx);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!completed) return resume_value;
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+
+    total += result;
+    if (result == 0 || !loop) return INT2NUM(total);
+  }
+
+  RB_GC_GUARD(resume_value);
+}
+
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return io_uring_backend_splice(backend, src, dest, maxlen, 0);
+}
+
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return io_uring_backend_splice(backend, src, dest, chunksize, 1);
+}
+
+
 VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -841,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));
@@ -887,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) {
@@ -940,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
@@ -949,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;
 }
 
@@ -967,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);
@@ -1035,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);
@@ -1045,33 +1205,39 @@ 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);
+  rb_define_method(cBackend, "connect", Backend_connect, 3);
+  rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "read", Backend_read, 4);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
-  rb_define_method(cBackend, "write", Backend_write_m, -1);
   rb_define_method(cBackend, "recv", Backend_recv, 3);
-  rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 1);
   rb_define_method(cBackend, "recv_feed_loop", Backend_recv_feed_loop, 3);
+  rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 1);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
-  rb_define_method(cBackend, "accept", Backend_accept, 2);
-  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
-  rb_define_method(cBackend, "connect", Backend_connect, 3);
-  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
-  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "splice", Backend_splice, 3);
+  rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
-  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
+  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "write", Backend_write_m, -1);
 
-  rb_define_method(cBackend, "kind", Backend_kind, 0);
 
   #ifdef POLYPHONY_UNSET_NONBLOCK
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   #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