polyphony 0.53.0 → 0.53.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0682736e3fdca0ada986f4210f1bb25d682c75a7b9d297451c186b90c8025e13'
-  data.tar.gz: 5ff46620651c056983a6f73c879ca1c49acea22c0c7abcefb1a119cbe248cb77
+  metadata.gz: b769b5e71cbfa8679a639d369817abd8e5870efec8ea21feb60bb1e46ee7ca29
+  data.tar.gz: 0b2ded84eb0e120d20dd17c9973e2cab784cdf61c20bd20fcb6a13c2b6e9f58a
 SHA512:
-  metadata.gz: cfbb8141b21cc9e56cdcd9a34fd55cd3b48573dcc3011f127ece5049b13ca2c7fa8a17c8525ba5996ab97afcbfc8e46064a3d68c79d71d44d40c274ff9051d2d
-  data.tar.gz: f31d711c88fe354b8ffd63e37f30887b1bfb5c3709d3760412ee4ec4ea06d14c0a17e668ddd750958295dc12307b96cf64874b1be4ed46b8564d04236114ee67
+  metadata.gz: e6d3a3d2c130c31483ead4d8f13cc90a87149ac6c461871a43144111cdc37e6e2544c130dc447af26e39e9519b48e3abe1a10197dd4512a7292968e4939e676b
+  data.tar.gz: dc1b53918032fc74578ca528abb5a96e423ea8e7a070047f7936720cb6553d9f247cbb625e9d82c7b9b58795a4a3a74aae566231a7a4bb8443f5352c00d10b2a

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.53.1
+
+- Remove `splice` methods on libev backend on non-Linux OS (#43)
+
 ## 0.53.0
 
 - Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`

data/Gemfile.lock

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

data/TODO.md

@@ -35,8 +35,8 @@
 
   ```ruby
   Thread.current.backend.submit(
-    [sock, :<<, chunk_header(len)],
-    [sock, :splice, file, len]
+    [:send, sock, chunk_header(len)],
+    [:splice, file, sock, len]
   )
   ```
 
@@ -51,8 +51,8 @@
       break if len == 0
       
       backend.submit(
-        [sock, :<<, chunk_header(len)],
-        [sock, :splice, file, len]
+        [:write, sock, chunk_header(len)],
+        [:splice, i, sock, len]
       )
     end
   end

data/ext/polyphony/backend_io_uring.c

@@ -150,7 +150,7 @@ 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;
 
@@ -169,7 +169,7 @@ void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *bac
 }
 
 // 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;
@@ -315,8 +315,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);
@@ -334,7 +334,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     VALUE resume_value = Qnil;
     op_context_t *ctx = OP_CONTEXT_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);
@@ -350,14 +350,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;
     }
@@ -857,8 +858,8 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
 
-    if (result == 0 || !loop) return INT2NUM(total);
     total += result;
+    if (result == 0 || !loop) return INT2NUM(total);
   }
 
   RB_GC_GUARD(resume_value);

data/ext/polyphony/backend_libev.c

@@ -58,6 +58,9 @@ thread.
 #include "ruby/io.h"
 
 VALUE SYM_libev;
+VALUE SYM_send;
+VALUE SYM_splice;
+VALUE SYM_write;
 
 ID ID_ivar_is_nonblocking;
 
@@ -773,6 +776,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+#ifndef POLYPHONY_LINUX
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -782,10 +786,6 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   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);
@@ -840,10 +840,6 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   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);
@@ -890,6 +886,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
+#endif
 
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
@@ -1103,6 +1100,31 @@ VALUE Backend_kind(VALUE self) {
   return SYM_libev;
 }
 
+VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
+  VALUE result = Qnil;
+  if (argc == 0) return result;
+
+  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)
+      result = Backend_write(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2));
+    else if (op_type == SYM_send && op_len == 4)
+      result = Backend_send(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    #ifndef POLYPHONY_LINUX
+    else if (op_type == SYM_splice && op_len == 4)
+      result = Backend_splice(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    #endif
+    else
+      rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
+  }
+  
+  RB_GC_GUARD(result);
+  return result;
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1116,6 +1138,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);
@@ -1129,6 +1152,12 @@ void Init_Backend() {
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
+
+  #ifndef POLYPHONY_LINUX
+  rb_define_method(cBackend, "splice", Backend_splice, 3);
+  rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  #endif
+
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
@@ -1138,6 +1167,10 @@ void Init_Backend() {
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));
+
+  SYM_send = ID2SYM(rb_intern("send"));
+  SYM_splice = ID2SYM(rb_intern("splice"));
+  SYM_write = ID2SYM(rb_intern("write"));
 }
 
 #endif // POLYPHONY_BACKEND_LIBEV

data/ext/polyphony/thread.c

@@ -21,7 +21,7 @@ static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
 static VALUE Thread_fiber_scheduling_stats(VALUE self) {
-  VALUE backend = rb_ivar_get(self,ID_ivar_backend);
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   VALUE stats = rb_hash_new();
   VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   long pending_count;
@@ -53,7 +53,7 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
       // event selector. Otherwise it's gonna be stuck waiting for an event to
       // happen, not knowing that it there's already a fiber ready to run in its
       // run queue.
-      VALUE backend = rb_ivar_get(self,ID_ivar_backend);
+      VALUE backend = rb_ivar_get(self, ID_ivar_backend);
       Backend_wakeup(backend);
     }
   }
@@ -138,6 +138,10 @@ VALUE Thread_debug(VALUE self) {
   return self;
 }
 
+VALUE Thread_class_backend(VALUE _self) {
+  return rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+}
+
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
@@ -150,6 +154,8 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "fiber_scheduling_index", Thread_fiber_scheduling_index, 1);
   rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
+  rb_define_singleton_method(rb_cThread, "backend", Thread_class_backend, 0);
+
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
   ID_deactivate_all_watchers_post_fork  = rb_intern("deactivate_all_watchers_post_fork");

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -241,9 +241,10 @@ class BackendTest < MiniTest::Test
   def test_splice
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe
+    len = nil
 
     spin {
-      o2.splice(i1, 1000)
+      len = o2.splice(i1, 1000)
       o2.close
     }
 
@@ -251,14 +252,16 @@ class BackendTest < MiniTest::Test
     result = i2.read
 
     assert_equal 'foobar', result
+    assert_equal 6, len
   end
 
   def test_splice_to_eof
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe
+    len = nil
 
     f = spin {
-      o2.splice_to_eof(i1, 1000)
+      len = o2.splice_to_eof(i1, 1000)
       o2.close
     }
 
@@ -269,8 +272,88 @@ class BackendTest < MiniTest::Test
     o1.write('bar')
     result = i2.readpartial(1000)
     assert_equal 'bar', result
-  ensure
-    f.interrupt
+    o1.close
     f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      f.await
+    end
+  end
+end
+
+class BackendChainTest < MiniTest::Test
+  def setup
+    super
+    @prev_backend = Thread.current.backend
+    @backend = Polyphony::Backend.new
+    Thread.current.backend = @backend
+  end
+
+  def teardown
+    @backend.finalize
+    Thread.current.backend = @prev_backend
+  end
+
+  def test_simple_write_chain
+    i, o = IO.pipe
+
+    result = Thread.backend.chain(
+      [:write, o, 'hello'],
+      [:write, o, ' world']
+    )
+
+    assert_equal 6, result
+    o.close
+    assert_equal 'hello world', i.read
+  end
+
+  def chunk_header(len)
+    "Content-Length: #{len}\r\n\r\n"
+  end
+
+  def serve_io(from, to)
+    i, o = IO.pipe
+    backend = Thread.current.backend
+    while true
+      len = o.splice(from, 8192)
+      break if len == 0
+      
+      backend.chain(
+        [:write, to, chunk_header(len)],
+        [:splice, i, to, len]
+      )
+    end
+    to.close
+  end
+
+  def test_chain_with_splice
+    from_r, from_w = IO.pipe
+    to_r, to_w = IO.pipe
+
+    result = nil
+    f = spin { serve_io(from_r, to_w) }
+
+    from_w << 'Hello world!'
+    from_w.close
+
+    assert_equal "Content-Length: 12\r\n\r\nHello world!", to_r.read
+  end
+
+  def test_invalid_op
+    i, o = IO.pipe
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:read, o]
+      )
+    }
+
+    assert_raises(TypeError) {
+      Thread.backend.chain(
+        [:write, o]
+      )
+    }
   end
 end

data/test/test_thread.rb

@@ -124,6 +124,10 @@ class ThreadTest < MiniTest::Test
     t&.join
   end
 
+  def test_backend_class_method
+    assert_equal Thread.current.backend, Thread.backend
+  end
+
   def test_that_suspend_returns_immediately_if_no_watchers
     records = []
     t = Polyphony::Trace.new(:fiber_all) do |r|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.53.0
+  version: 0.53.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-23 00:00:00.000000000 Z
+date: 2021-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler