polyphony 0.52.0 → 0.53.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2056b02e3b364911ab627ffc49a7251ad2eed68ba6b5b61d380c599127c181f6
-  data.tar.gz: 440f57d240b90a255b470f405980b5fa2f806ba3ff2640f31d78b6403de7ce0e
+  metadata.gz: '0682736e3fdca0ada986f4210f1bb25d682c75a7b9d297451c186b90c8025e13'
+  data.tar.gz: 5ff46620651c056983a6f73c879ca1c49acea22c0c7abcefb1a119cbe248cb77
 SHA512:
-  metadata.gz: b5bf34a4ea7addf2b71c2e0acc75041d95f5d76ae425061bd5475e6523111a05cf969b0109ec90874f7f1a1929111182ed193b084b3388be060886145dd20567
-  data.tar.gz: 6165128a0393664c97baa494119e453db177b7d0a12c5a5ade0ab5bb8e77a4143f6156b9cb594ef2edbbe9e0ac3bb85a2c846da8e925c3a6ec1c294120c18bf2
+  metadata.gz: cfbb8141b21cc9e56cdcd9a34fd55cd3b48573dcc3011f127ece5049b13ca2c7fa8a17c8525ba5996ab97afcbfc8e46064a3d68c79d71d44d40c274ff9051d2d
+  data.tar.gz: f31d711c88fe354b8ffd63e37f30887b1bfb5c3709d3760412ee4ec4ea06d14c0a17e668ddd750958295dc12307b96cf64874b1be4ed46b8564d04236114ee67

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.53.0
+
+- Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`
+
 ## 0.52.0
 
 - Polyphony is now compatible with Ruby 3.0

data/Gemfile.lock

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

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
@@ -19,17 +18,46 @@
   - `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(
+    [sock, :<<, chunk_header(len)],
+    [sock, :splice, file, 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(
+        [sock, :<<, chunk_header(len)],
+        [sock, :splice, file, 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/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/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_io_uring.c

@@ -43,6 +43,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
 
@@ -824,6 +825,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 = OP_CONTEXT_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);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!ctx->completed) return resume_value;
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+
+    if (result == 0 || !loop) return INT2NUM(total);
+    total += result;
+  }
+
+  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;
@@ -1045,27 +1100,29 @@ 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, "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");

data/ext/polyphony/backend_io_uring_context.c

@@ -10,6 +10,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_WRITE: return "WRITE";
   case OP_RECV: return "RECV";
   case OP_SEND: return "SEND";
+  case OP_SPLICE: return "SPLICE";
   case OP_TIMEOUT: return "TIMEOUT";
   case OP_POLL: return "POLL";
   case OP_ACCEPT: return "ACCEPT";

data/ext/polyphony/backend_io_uring_context.h

@@ -10,6 +10,7 @@ enum op_type {
   OP_WRITE,
   OP_RECV,
   OP_SEND,
+  OP_SPLICE,
   OP_TIMEOUT,
   OP_POLL,
   OP_ACCEPT,

data/ext/polyphony/backend_libev.c

@@ -38,11 +38,15 @@ thread.
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 
+#ifdef POLYPHONY_LINUX
+#define _GNU_SOURCE 1
+#endif
+
+#include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
-#include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
@@ -769,6 +773,124 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+
+  #ifndef POLYPHONY_LINUX
+  rb_raise(rb_eRuntimeError, "splice not supported");
+  #endif
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_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_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+  int total = 0;
+
+  #ifndef POLYPHONY_LINUX
+  rb_raise(rb_eRuntimeError, "splice not supported");
+  #endif
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_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_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else if (len == 0) {
+      break;
+    }
+    else {
+      total += len;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -993,27 +1115,26 @@ 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, "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, "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, "recv", Backend_recv, 3);
   rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
   rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 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, "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, "kind", Backend_kind, 0);
+  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);
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));

data/ext/polyphony/extconf.rb

@@ -6,8 +6,9 @@ require 'mkmf'
 use_liburing = false
 use_pidfd_open = false
 force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+linux = RUBY_PLATFORM =~ /linux/
 
-if RUBY_PLATFORM =~ /linux/ && `uname -sr` =~ /Linux 5\.([\d+])/
+if linux && `uname -sr` =~ /Linux 5\.([\d+])/
   kernel_minor_version = $1.gsub('.', '').to_i
   use_liburing = !force_use_libev && kernel_minor_version >= 6
   use_pidfd_open = kernel_minor_version >= 3
@@ -20,6 +21,7 @@ if use_liburing
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
+  $defs << "-DPOLYPHONY_LINUX" if linux
   $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
   $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
   $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')

data/ext/polyphony/polyphony.c

@@ -46,8 +46,6 @@ VALUE Polyphony_trace(VALUE self, VALUE enabled) {
   return Qnil;
 }
 
-#define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
-
 VALUE Polyphony_backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   return Backend_accept(BACKEND(), server_socket, socket_class);
 }
@@ -96,6 +94,14 @@ VALUE Polyphony_backend_sleep(VALUE self, VALUE duration) {
   return Backend_sleep(BACKEND(), duration);
 }
 
+VALUE Polyphony_backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  return Backend_splice(BACKEND(), src, dest, maxlen);
+}
+
+VALUE Polyphony_backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
+  return Backend_splice_to_eof(BACKEND(), src, dest, chunksize);
+}
+
 VALUE Polyphony_backend_timeout(int argc,VALUE *argv, VALUE self) {
   return Backend_timeout(argc, argv, BACKEND());
 }
@@ -138,6 +144,8 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_send", Polyphony_backend_send, 3);
   rb_define_singleton_method(mPolyphony, "backend_sendv", Polyphony_backend_sendv, 3);
   rb_define_singleton_method(mPolyphony, "backend_sleep", Polyphony_backend_sleep, 1);
+  rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);
+  rb_define_singleton_method(mPolyphony, "backend_splice_to_eof", Polyphony_backend_splice_to_eof, 3);
   rb_define_singleton_method(mPolyphony, "backend_timeout", Polyphony_backend_timeout, -1);
   rb_define_singleton_method(mPolyphony, "backend_timer_loop", Polyphony_backend_timer_loop, 1);
   rb_define_singleton_method(mPolyphony, "backend_wait_event", Polyphony_backend_wait_event, 1);

data/ext/polyphony/polyphony.h

@@ -31,6 +31,8 @@
 // Fiber#transfer
 #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
 
+#define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
+
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
@@ -108,6 +110,8 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
 VALUE Backend_sleep(VALUE self, VALUE duration);
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen);
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize);
 VALUE Backend_timeout(int argc,VALUE *argv, VALUE self);
 VALUE Backend_timer_loop(VALUE self, VALUE interval);
 VALUE Backend_wait_event(VALUE self, VALUE raise);

data/ext/polyphony/polyphony_ext.c

@@ -6,6 +6,7 @@ void Init_Backend();
 void Init_Queue();
 void Init_Event();
 void Init_Runqueue();
+void Init_SocketExtensions();
 void Init_Thread();
 void Init_Tracing();
 
@@ -24,6 +25,8 @@ void Init_polyphony_ext() {
   Init_Thread();
   Init_Tracing();
 
+  Init_SocketExtensions();
+
   #ifdef POLYPHONY_PLAYGROUND
   playground();
   #endif

data/ext/polyphony/socket_extensions.c

@@ -0,0 +1,33 @@
+#include "polyphony.h"
+
+VALUE Socket_send(VALUE self, VALUE msg, VALUE flags) {
+  return Backend_send(BACKEND(), self, msg, flags);
+}
+
+VALUE Socket_write(int argc, VALUE *argv, VALUE self) {
+  VALUE ary = rb_ary_new_from_values(argc, argv);
+  VALUE result = Backend_sendv(BACKEND(), self, ary, INT2NUM(0));
+  RB_GC_GUARD(ary);
+  return result;
+}
+
+VALUE Socket_double_chevron(VALUE self, VALUE msg) {
+  Backend_send(BACKEND(), self, msg, INT2NUM(0));
+  return self;
+}
+
+void Init_SocketExtensions() {
+  rb_require("socket");
+
+  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+  VALUE cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+
+  rb_define_method(cSocket, "send", Socket_send, 2);
+  rb_define_method(cTCPSocket, "send", Socket_send, 2);
+
+  rb_define_method(cSocket, "write", Socket_write, -1);
+  rb_define_method(cTCPSocket, "write", Socket_write, -1);
+
+  rb_define_method(cSocket, "<<", Socket_double_chevron, 1);
+  rb_define_method(cTCPSocket, "<<", Socket_double_chevron, 1);
+}

data/lib/polyphony/extensions/io.rb

@@ -247,4 +247,12 @@ class ::IO
       self
     end
   end
+
+  def splice(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  def splice_to_eof(src, chunksize = 8192)
+    Polyphony.backend_splice_to_eof(src, self, chunksize)
+  end
 end

data/lib/polyphony/extensions/socket.rb

@@ -48,14 +48,17 @@ class ::Socket
     end
   end
 
-  def send(mesg, flags)
-    Polyphony.backend_send(self, mesg, flags)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
 
-  def write(*args)
-    Polyphony.backend_sendv(self, args, 0)
-  end
-  alias_method :<<, :write
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = +'')
     Polyphony.backend_recv(self, str, maxlen)
@@ -150,14 +153,17 @@ class ::TCPSocket
     Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   end
 
-  def send(mesg, flags)
-    Polyphony.backend_send(self, mesg, flags)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
 
-  def write(*args)
-    Polyphony.backend_sendv(self, args, 0)
-  end
-  alias_method :<<, :write
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''
@@ -238,7 +244,10 @@ class ::UNIXSocket
   def write(*args)
     Polyphony.backend_sendv(self, args, 0)
   end
-  alias_method :<<, :write
+
+  def <<(mesg)
+    Polyphony.backend_send(self, mesg, 0)
+  end
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -237,4 +237,40 @@ class BackendTest < MiniTest::Test
     end
     assert_equal [1], buffer
   end
+
+  def test_splice
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+
+    spin {
+      o2.splice(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foobar')
+    result = i2.read
+
+    assert_equal 'foobar', result
+  end
+
+  def test_splice_to_eof
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+
+    f = spin {
+      o2.splice_to_eof(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foo')
+    result = i2.readpartial(1000)
+    assert_equal 'foo', result
+
+    o1.write('bar')
+    result = i2.readpartial(1000)
+    assert_equal 'bar', result
+  ensure
+    f.interrupt
+    f.await
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.52.0
+  version: 0.53.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-28 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -418,6 +418,7 @@ files:
 - ext/polyphony/runqueue.c
 - ext/polyphony/runqueue_ring_buffer.c
 - ext/polyphony/runqueue_ring_buffer.h
+- ext/polyphony/socket_extensions.c
 - ext/polyphony/thread.c
 - ext/polyphony/tracing.c
 - lib/polyphony.rb