polyphony 0.47.5.1 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4b0d95763e1c95248c83f2b649bdafa609e5a3877ea381afa1ce7253b340904
-  data.tar.gz: c25589fd2a4433d21778281a631b364b5505ce27c9fe3f349d2a357a3dd30f97
+  metadata.gz: 3a699d313072b1beba17c900491dd2a4f454bc8faea69eb157634e98cba7ee90
+  data.tar.gz: 3d8579b2c927c34876560ce878e960b9bc48a857ce43890dc069b4f0fa5ad75f
 SHA512:
-  metadata.gz: 2637f2f6aa6531e6b8bc62035a028caffd027d65668b1a1f6b957c9f89045d148b790003856ece2213ccf882e1eab12068578cce8ba0c8882213f3e8f9a125f3
-  data.tar.gz: '0009c9eae3b3fc52239d26bc836d7a1b4d2bd24d922c02f9a986fbed5d26f76b618777422efe9909aaff27164cc53de9d7083f9b784bc5534b387e6735dc7be6'
+  metadata.gz: d6efca5f42f21fe25ab5e6064675c2806dcad9d86e2e80c908987fcce855dd520ab51c4913e5a9001d3e4a84880a6606d124fa46dedff7c2e437a1ef6e156a82
+  data.tar.gz: 73ad6c59d4f7e9f8f0d317f480be1ba33c1a70dcf130a717693c2bb5a9ef3e226bfff3bdb635461b505bd2e9bbec7a2174c6a206bee2a94709ba9739ab087956

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.48.0
+
+- Implement graceful shutdown
+- Add support for `break` / `StopIteration` in `spin_loop`
+- Fix `IO#gets`, `IO#readpartial`
+
 ## 0.47.5.1
 
 - Add missing `Socket#accept_loop` method

data/Gemfile.lock

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

data/TODO.md

@@ -1,29 +1,43 @@
-- Graceful shutdown again:
+- Override stock `SizedQueue` impl with Queue with capacity
+
+- Add support for `break` and `StopIteration` in all loops (with tests)
 
-  - Fiber API:
-    - `Fiber#terminate(graceul)` - with a graceful flag
-    - `Fiber#terminate_all_children(graceful)` - with a graceful flag
-    - `Fiber#shutdown_all_children(graceful)` - with a graceful flag
+- 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)
 
-  - Set graceful termination in `@graceful_shutdown`
-  - Add `Fiber#graceful_shutdown?` method
-    - Returns `@graceful_shutdown`
 
-  And then we have:
+- Add `Backend#splice`, `Backend#splice_loop` for implementing stuff like proxying:
 
   ```ruby
-  spin do
-    loop { do_some_stuff }
-  ensure
-    shutdown_gracefully if Fiber.current.graceful_shutdown?
+  def two_way_proxy(socket1, socket2)
+    backend = Thread.current.backend
+    f1 = spin { backend.splice_loop(socket1, socket2) }
+    f2 = spin { backend.splice_loop(socket2, socket1) }
+    Fiber.await(f1, f2)
   end
   ```
 
+- Graceful shutdown again:
+  - What happens to children when doing a graceful shutdown?
+  - What are the implications of passing graceful shutdown flag to children?
+  - What about errors while doing a graceful shutdown?
+  - What about graceful restarts?
+  - Some interesting discussions:
+    - https://trio.discourse.group/search?q=graceful%20shutdown
+    - https://github.com/python-trio/trio/issues/147
+    - https://github.com/python-trio/trio/issues/143
+    - https://trio.discourse.group/t/graceful-shutdown/93/2
+    - https://250bpm.com/blog:146/
+    - https://www.rodrigoaraujo.me/posts/golang-pattern-graceful-shutdown-of-concurrent-events/
+    - https://github.com/tj/go-gracefully
   - `Fiber#finalize_children` should pass graceful shutdown flag to children
-
-- 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)
+  - A good use case is an HTTP server that on graceful shutdown:
+    - stops listening
+    - waits for all ongoing requests to finish, optionally with a timeout
 
 ## Roadmap for Polyphony 1.0
 

data/examples/io/tcp_proxy.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+server1 = TCPServer.open('127.0.0.1', 1234)
+server2 = TCPServer.open('127.0.0.1', 1235)
+
+puts "Pid: #{Process.pid}"
+puts 'Proxying port 1234 => port 1235'
+
+client1 = client2 = nil
+
+f1 = spin {
+  client1 = server1.accept
+  loop do
+    if client2
+      Thread.current.backend.splice_loop(client1, client2)
+    end
+  end
+}
+
+f2 = spin {
+  client2 = server2.accept
+  loop do
+    if client1
+      Thread.current.backend.splice_loop(client2, client1)
+    end
+  end
+}
+
+Fiber.await(f1, f2)

data/examples/performance/line_splitting.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+def slice
+  str = ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40)
+  lines = []
+  while true
+    idx = str.index("\n")
+    break unless idx
+    
+    lines << str.slice!(0, idx + 1)
+  end
+  raise unless lines.size == 4
+  raise unless str == ('*' * 40)
+end
+
+def split
+  str = ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40) + "\n" + ('*' * 40)
+  lines = str.split("\n")
+  if str[-1] == "\n"
+    str = ''
+  else
+    str = lines.pop
+  end
+  raise unless lines.size == 4
+  raise unless str == ('*' * 40)
+end
+
+Benchmark.ips do |x|
+  x.report("slice") { slice }
+  x.report("split") { split }
+  x.compare!
+end

data/examples/performance/loop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+LIMIT = 1_000_0
+
+def do_while
+  i = 0
+  while true
+    i += 1
+    break if i == LIMIT
+  end
+end
+
+def do_loop
+  i = 0
+  loop do
+    i += 1
+    break if i == LIMIT
+  end
+end
+
+GC.disable
+Benchmark.bm do |x|
+  x.report('while') do
+    LIMIT.times { do_while }
+  end
+  x.report('loop') do
+    LIMIT.times { do_loop }
+  end
+end
+

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -29,6 +29,12 @@ end
 server = TCPServer.open('0.0.0.0', 1234)
 puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 1234"
 
+spin_loop(interval: 10) do
+  p Thread.current.fiber_scheduling_stats
+end
+
+GC.disable
+
 server.accept_loop do |c|
   spin { handle_client(c) }
 end

data/ext/polyphony/backend_common.h

@@ -70,9 +70,9 @@ inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
 
 inline VALUE backend_await(Backend_t *backend) {
   VALUE ret;
-  backend->ref_count++;
+  backend->pending_count++;
   ret = Thread_switch_fiber(rb_thread_current());
-  backend->ref_count--;
+  backend->pending_count--;
   RB_GC_GUARD(ret);
   return ret;
 }

data/ext/polyphony/backend_io_uring.c

@@ -30,11 +30,14 @@ static int pidfd_open(pid_t pid, unsigned int flags) {
 VALUE SYM_io_uring;
 
 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;
   op_context_store_t  store;
-  int                 waiting_for_cqe;
-  unsigned int        ref_count;
-  unsigned int        run_no_wait_count;
   unsigned int        pending_sqes;
   unsigned int        prepared_limit;
   int                 event_fd;
@@ -65,11 +68,11 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->waiting_for_cqe = 0;
-  backend->ref_count = 0;
-  backend->run_no_wait_count = 0;
+  backend->currently_polling = 0;
+  backend->pending_count = 0;
+  backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
-  backend->prepared_limit = 1024;
+  backend->prepared_limit = 256;
 
   context_store_initialize(&backend->store);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
@@ -95,46 +98,19 @@ VALUE Backend_post_fork(VALUE self) {
   io_uring_queue_exit(&backend->ring);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
   context_store_free(&backend->store);
-  backend->waiting_for_cqe = 0;
-  backend->ref_count = 0;
-  backend->run_no_wait_count = 0;
+  backend->currently_polling = 0;
+  backend->pending_count = 0;
+  backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
 
   return self;
 }
 
-VALUE Backend_ref(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count++;
-  return self;
-}
-
-VALUE Backend_unref(VALUE self) {
+unsigned int Backend_pending_count(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->ref_count--;
-  return self;
-}
-
-int Backend_ref_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->ref_count;
-}
-
-void Backend_reset_ref_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count = 0;
-}
-
-VALUE Backend_pending_count(VALUE self) {
-  return INT2NUM(0);
+  return backend->pending_count;
 }
 
 typedef struct poll_context {
@@ -158,7 +134,7 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring) {
 
 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 == 0) return;
+  if (!ctx) return;
 
   ctx->result = cqe->res;
 
@@ -211,9 +187,9 @@ void io_uring_backend_poll(Backend_t *backend) {
     io_uring_submit(&backend->ring);
   }
 
-  backend->waiting_for_cqe = 1;
+  backend->currently_polling = 1;
   rb_thread_call_without_gvl(io_uring_backend_poll_without_gvl, (void *)&poll_ctx, RUBY_UBF_IO, 0);
-  backend->waiting_for_cqe = 0;
+  backend->currently_polling = 0;
   if (poll_ctx.result < 0) return;
 
   io_uring_backend_handle_completion(poll_ctx.cqe, backend);
@@ -226,14 +202,14 @@ VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue
   GetBackend(self, backend);
 
   if (is_nowait) {
-    backend->run_no_wait_count++;
-    if (backend->run_no_wait_count < 10) return self;
+    backend->poll_no_wait_count++;
+    if (backend->poll_no_wait_count < 10) return self;
 
     long runnable_count = Runqueue_len(runqueue);
-    if (backend->run_no_wait_count < runnable_count) return self;
+    if (backend->poll_no_wait_count < runnable_count) return self;
   }
 
-  backend->run_no_wait_count = 0;
+  backend->poll_no_wait_count = 0;
 
   if (is_nowait && backend->pending_sqes) {
     backend->pending_sqes = 0;
@@ -252,7 +228,7 @@ VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->waiting_for_cqe) {
+  if (backend->currently_polling) {
     // Since we're currently blocking while waiting for a completion, we add a
     // NOP which would cause the io_uring_enter syscall to return
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -284,12 +260,12 @@ int io_uring_backend_defer_submit_and_await(
   VALUE switchpoint_result = Qnil;
 
   io_uring_sqe_set_data(sqe, ctx);
-  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  // io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
-  backend->ref_count++;
+  backend->pending_count++;
   switchpoint_result = backend_await(backend);
-  backend->ref_count--;
+  backend->pending_count--;
 
   if (!ctx->completed) {
     ctx->result = -ECANCELED;
@@ -351,7 +327,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
 
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
-    else if (result == 0)
+    else if (!result)
       break; // EOF
     else {
       total += result;
@@ -373,7 +349,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   io_set_read_length(str, total, shrinkable);
   io_enc_str(str, fptr);
 
-  if (total == 0) return Qnil;
+  if (!total) return Qnil;
 
   return str;
 }
@@ -410,7 +386,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
 
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
-    else if (result == 0)
+    else if (!result)
       break; // EOF
     else {
       total = result;
@@ -581,7 +557,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
   io_set_read_length(str, total, shrinkable);
   io_enc_str(str, fptr);
 
-  if (total == 0) return Qnil;
+  if (!total) return Qnil;
 
   return str;
 }
@@ -618,7 +594,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
 
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
-    else if (result == 0)
+    else if (!result)
       break; // EOF
     else {
       total = result;
@@ -950,10 +926,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
   rb_define_method(cBackend, "finalize", Backend_finalize, 0);
   rb_define_method(cBackend, "post_fork", Backend_post_fork, 0);
-  rb_define_method(cBackend, "pending_count", Backend_pending_count, 0);
-
-  rb_define_method(cBackend, "ref", Backend_ref, 0);
-  rb_define_method(cBackend, "unref", Backend_unref, 0);
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
@@ -977,15 +949,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "kind", Backend_kind, 0);
 
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
-
-  __BACKEND__.pending_count   = Backend_pending_count;
-  __BACKEND__.poll            = Backend_poll;
-  __BACKEND__.ref             = Backend_ref;
-  __BACKEND__.ref_count       = Backend_ref_count;
-  __BACKEND__.reset_ref_count = Backend_reset_ref_count;
-  __BACKEND__.unref           = Backend_unref;
-  __BACKEND__.wait_event      = Backend_wait_event;
-  __BACKEND__.wakeup          = Backend_wakeup;
 }
 
 #endif // POLYPHONY_BACKEND_LIBURING

data/ext/polyphony/backend_libev.c

@@ -40,11 +40,14 @@ inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
 }
 
 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;
   struct ev_async break_async;
-  int running;
-  int ref_count;
-  int run_no_wait_count;
 } Backend_t;
 
 static size_t Backend_size(const void *ptr) {
@@ -83,9 +86,9 @@ static VALUE Backend_initialize(VALUE self) {
   ev_async_start(backend->ev_loop, &backend->break_async);
   ev_unref(backend->ev_loop); // don't count the break_async watcher
 
-  backend->running = 0;
-  backend->ref_count = 0;
-  backend->run_no_wait_count = 0;
+  backend->currently_polling = 0;
+  backend->pending_count = 0;
+  backend->poll_no_wait_count = 0;
 
   return Qnil;
 }
@@ -116,42 +119,11 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-VALUE Backend_ref(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count++;
-  return self;
-}
-
-VALUE Backend_unref(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count--;
-  return self;
-}
-
-int Backend_ref_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->ref_count;
-}
-
-void Backend_reset_ref_count(VALUE self) {
+unsigned int Backend_pending_count(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->ref_count = 0;
-}
-
-VALUE Backend_pending_count(VALUE self) {
-  int count;
-  Backend_t *backend;
-  GetBackend(self, backend);
-  count = ev_pending_count(backend->ev_loop);
-  return INT2NUM(count);
+  return backend->pending_count;
 }
 
 VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
@@ -160,19 +132,19 @@ VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue
   GetBackend(self, backend);
 
   if (is_nowait) {
-    backend->run_no_wait_count++;
-    if (backend->run_no_wait_count < 10) return self;
+    backend->poll_no_wait_count++;
+    if (backend->poll_no_wait_count < 10) return self;
 
     long runnable_count = Runqueue_len(runqueue);
-    if (backend->run_no_wait_count < runnable_count) return self;
+    if (backend->poll_no_wait_count < runnable_count) return self;
   }
 
-  backend->run_no_wait_count = 0;
+  backend->poll_no_wait_count = 0;
 
   COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  backend->running = 1;
+  backend->currently_polling = 1;
   ev_run(backend->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
-  backend->running = 0;
+  backend->currently_polling = 0;
   COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 
   return self;
@@ -182,7 +154,7 @@ VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->running) {
+  if (backend->currently_polling) {
     // Since the loop will run until at least one event has occurred, we signal
     // the selector's associated async watcher, which will cause the ev loop to
     // return. In contrast to using `ev_break` to break out of the loop, which
@@ -854,10 +826,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
   rb_define_method(cBackend, "finalize", Backend_finalize, 0);
   rb_define_method(cBackend, "post_fork", Backend_post_fork, 0);
-  rb_define_method(cBackend, "pending_count", Backend_pending_count, 0);
-
-  rb_define_method(cBackend, "ref", Backend_ref, 0);
-  rb_define_method(cBackend, "unref", Backend_unref, 0);
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
@@ -882,15 +850,6 @@ void Init_Backend() {
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));
-
-  __BACKEND__.pending_count   = Backend_pending_count;
-  __BACKEND__.poll            = Backend_poll;
-  __BACKEND__.ref             = Backend_ref;
-  __BACKEND__.ref_count       = Backend_ref_count;
-  __BACKEND__.reset_ref_count = Backend_reset_ref_count;
-  __BACKEND__.unref           = Backend_unref;
-  __BACKEND__.wait_event      = Backend_wait_event;
-  __BACKEND__.wakeup          = Backend_wakeup;
 }
 
 #endif // POLYPHONY_BACKEND_LIBEV

data/ext/polyphony/event.c

@@ -66,7 +66,7 @@ VALUE Event_await(VALUE self) {
 
   VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
-  VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+  VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
 
   RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/polyphony.c

@@ -22,8 +22,6 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-backend_interface_t backend_interface;
-
 VALUE Polyphony_snooze(VALUE self) {
   VALUE ret;
   VALUE fiber = rb_fiber_current();

data/ext/polyphony/polyphony.h

@@ -4,7 +4,6 @@
 #include <execinfo.h>
 
 #include "ruby.h"
-#include "backend.h"
 #include "runqueue_ring_buffer.h"
 
 // debugging
@@ -32,9 +31,6 @@
 // Fiber#transfer
 #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
 
-extern backend_interface_t backend_interface;
-#define __BACKEND__ (backend_interface)
-
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
@@ -92,6 +88,11 @@ void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
 
+unsigned int Backend_pending_count(VALUE self);
+VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue);
+VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);
+VALUE Backend_wakeup(VALUE self);
+
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);

data/ext/polyphony/queue.c

@@ -86,7 +86,7 @@ inline void capped_queue_block_push(Queue_t *queue) {
     if (queue->capacity > queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->push_queue, fiber);
-    switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    switchpoint_result = Backend_wait_event(backend, Qnil);
     ring_buffer_delete(&queue->push_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);
@@ -131,7 +131,7 @@ VALUE Queue_shift(VALUE self) {
     if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->shift_queue, fiber);
-    VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/thread.c

@@ -17,16 +17,6 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   return self;
 }
 
-int Thread_fiber_ref_count(VALUE self) {
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  return NUM2INT(__BACKEND__.ref_count(backend));
-}
-
-inline void Thread_fiber_reset_ref_count(VALUE self) {
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  __BACKEND__.reset_ref_count(backend);
-}
-
 static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
@@ -39,7 +29,7 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   long scheduled_count = Runqueue_len(runqueue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = __BACKEND__.pending_count(backend);
+  pending_count = Backend_pending_count(backend);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -64,7 +54,7 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
       // 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);
-      __BACKEND__.wakeup(backend);
+      Backend_wakeup(backend);
     }
   }
 }
@@ -84,25 +74,24 @@ 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);
-  int ref_count;
-  int backend_was_polled = 0;
+  unsigned int pending_count = Backend_pending_count(backend);
+  unsigned int backend_was_polled = 0;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
     TRACE(2, SYM_fiber_switchpoint, current_fiber);
 
-  ref_count = __BACKEND__.ref_count(backend);
   while (1) {
     next = Runqueue_shift(runqueue);
     if (next.fiber != Qnil) {
-      if (backend_was_polled == 0 && ref_count > 0) {
+      if (!backend_was_polled && pending_count) {
         // this prevents event starvation in case the run queue never empties
-        __BACKEND__.poll(backend, Qtrue, current_fiber, runqueue);
+        Backend_poll(backend, Qtrue, current_fiber, runqueue);
       }
       break;
     }
-    if (ref_count == 0) break;
+    if (pending_count == 0) break;
 
-    __BACKEND__.poll(backend, Qnil, current_fiber, runqueue);
+    Backend_poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;
   }
 
@@ -118,20 +107,13 @@ VALUE Thread_switch_fiber(VALUE self) {
     next.value : FIBER_TRANSFER(next.fiber, next.value);
 }
 
-VALUE Thread_reset_fiber_scheduling(VALUE self) {
-  VALUE queue = rb_ivar_get(self, ID_ivar_runqueue);
-  Runqueue_clear(queue);
-  Thread_fiber_reset_ref_count(self);
-  return self;
-}
-
 VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj) {
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (__BACKEND__.wakeup(backend) == Qnil) {
+  if (Backend_wakeup(backend) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -146,7 +128,6 @@ VALUE Thread_debug(VALUE self) {
 
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
-  rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
   rb_define_method(rb_cThread, "schedule_and_wakeup", Thread_fiber_schedule_and_wakeup, 2);
 

data/lib/polyphony/adapters/postgres.rb

@@ -11,7 +11,7 @@ module ::PG
 
   def self.connect_async(conn)
     socket_io = conn.socket_io
-    loop do
+    while true
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
@@ -23,7 +23,7 @@ module ::PG
   end
 
   def self.connect_sync(conn)
-    loop do
+    while true
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED
@@ -96,7 +96,7 @@ class ::PG::Connection
   def wait_for_notify(timeout = nil, &block)
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
-    loop do
+    while true
       Thread.current.backend.wait_io(socket_io, false)
       consume_input
       notice = notifies

data/lib/polyphony/core/global_api.rb

@@ -59,7 +59,15 @@ module Polyphony
           throttled_loop(rate: rate, interval: interval, &block)
         end
       else
-        Fiber.current.spin(tag, caller) { loop(&block) }
+        spin_looped_block(tag, caller, block)
+      end
+    end
+
+    def spin_looped_block(tag, caller, block)
+      Fiber.current.spin(tag, caller) do
+        block.call while true
+      rescue LocalJumpError, StopIteration
+        # break called or StopIteration raised
       end
     end
 
@@ -133,8 +141,12 @@ module Polyphony
       if opts[:count]
         opts[:count].times { |_i| throttler.(&block) }
       else
-        loop { throttler.(&block) }
+        while true
+          throttler.(&block)
+        end
       end
+    rescue LocalJumpError, StopIteration
+      # break called or StopIteration raised
     ensure
       throttler&.stop
     end

data/lib/polyphony/core/thread_pool.rb

@@ -45,7 +45,9 @@ module Polyphony
     end
 
     def thread_loop
-      loop { run_queued_task }
+      while true
+        run_queued_task
+      end
     end
 
     def run_queued_task

data/lib/polyphony/core/throttler.rb

@@ -15,7 +15,7 @@ module Polyphony
       Thread.current.backend.sleep(delta) if delta > 0
       yield self
 
-      loop do
+      while true
         @next_time += @min_dt
         break if @next_time > now
       end

data/lib/polyphony/extensions/fiber.rb

@@ -34,9 +34,18 @@ module Polyphony
       schedule Polyphony::Cancel.new
     end
 
-    def terminate
+    def graceful_shutdown=(graceful)
+      @graceful_shutdown = graceful
+    end
+
+    def graceful_shutdown?
+      @graceful_shutdown
+    end
+
+    def terminate(graceful = false)
       return if @running == false
 
+      @graceful_shutdown = graceful
       schedule Polyphony::Terminate.new
     end
 
@@ -66,7 +75,9 @@ module Polyphony
       @on_child_done = proc do |fiber, result|
         self << fiber unless result.is_a?(Exception)
       end
-      loop { supervise_perform(opts) }
+      while true
+        supervise_perform(opts)
+      end
     rescue Polyphony::MoveOn
       # generated in #supervise_perform to stop supervisor
     ensure
@@ -210,11 +221,14 @@ module Polyphony
       @on_child_done&.(child_fiber, result)
     end
 
-    def terminate_all_children
+    def terminate_all_children(graceful = false)
       return unless @children
 
       e = Polyphony::Terminate.new
-      @children.each_key { |c| c.raise e }
+      @children.each_key do |c|
+        c.graceful_shutdown = true if graceful
+        c.raise e
+      end
     end
 
     def await_all_children
@@ -230,8 +244,8 @@ module Polyphony
       results.values
     end
 
-    def shutdown_all_children
-      terminate_all_children
+    def shutdown_all_children(graceful = false)
+      terminate_all_children(graceful)
       await_all_children
     end
   end

data/lib/polyphony/extensions/io.rb

@@ -119,18 +119,11 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len, str = nil)
-    @read_buffer ||= +''
-    result = Thread.current.backend.read(self, @read_buffer, len, false)
+  def readpartial(len, str = +'')
+    result = Thread.current.backend.read(self, str, len, false)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
-    str
+    result
   end
 
   alias_method :orig_write, :write
@@ -154,15 +147,16 @@ class ::IO
 
     @read_buffer ||= +''
 
-    loop do
+    while true
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      data = readpartial(8192)
+      data = readpartial(8192, +'')
+      return nil unless data
       @read_buffer << data
-    rescue EOFError
-      return nil
     end
+  rescue EOFError
+    return nil
   end
 
   # def print(*args)

data/lib/polyphony/extensions/openssl.rb

@@ -25,7 +25,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_accept, :accept
   def accept
-    loop do
+    while true
       result = accept_nonblock(exception: false)
       case result
       when :wait_readable then Thread.current.backend.wait_io(io, false)
@@ -37,14 +37,14 @@ class ::OpenSSL::SSL::SSLSocket
   end
 
   def accept_loop
-    loop do
+    while true
       yield accept
     end
   end
 
   alias_method :orig_sysread, :sysread
   def sysread(maxlen, buf = +'')
-    loop do
+    while true
       case (result = read_nonblock(maxlen, buf, exception: false))
       when :wait_readable then Thread.current.backend.wait_io(io, false)
       when :wait_writable then Thread.current.backend.wait_io(io, true)
@@ -55,7 +55,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_syswrite, :syswrite
   def syswrite(buf)
-    loop do
+    while true
       case (result = write_nonblock(buf, exception: false))
       when :wait_readable then Thread.current.backend.wait_io(io, false)
       when :wait_writable then Thread.current.backend.wait_io(io, true)

data/lib/polyphony/extensions/socket.rb

@@ -33,7 +33,7 @@ class ::Socket
 
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
-    loop do
+    while true
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
       case result
       when nil then raise IOError

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.licenses    = ['MIT']
   s.summary     = 'Fine grained concurrency for Ruby'
   s.author      = 'Sharon Rosner'
-  s.email       = 'ciconia@gmail.com'
+  s.email       = 'sharon@noteflakes.com'
   s.files       = `git ls-files`.split
   s.homepage    = 'https://digital-fabric.github.io/polyphony'
   s.metadata    = {

data/test/helper.rb

@@ -4,6 +4,7 @@ require 'bundler/setup'
 
 require_relative './coverage' if ENV['COVERAGE']
 
+require 'httparty'
 require 'polyphony'
 
 require 'fileutils'

data/test/test_backend.rb

@@ -105,7 +105,7 @@ class BackendTest < MiniTest::Test
 
     clients = []
     server_fiber = spin do
-      @backend.accept_loop(server) { |c| clients << c }
+      @backend.accept_loop(server, TCPSocket) { |c| clients << c }
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)

data/test/test_fiber.rb

@@ -1038,3 +1038,67 @@ class RestartTest < MiniTest::Test
     assert_equal [f, 'foo', 'bar', :done, f2, 'baz', 42, :done], buffer
   end
 end
+
+class GracefulTerminationTest < MiniTest::Test
+  def test_graceful_termination
+    buffer = []
+    f = spin do
+      buffer << 1
+      snooze
+      buffer << 2
+      sleep 3
+      buffer << 3
+    ensure
+      buffer << 4 if Fiber.current.graceful_shutdown?
+    end
+
+    3.times { snooze }
+    f.terminate(false)
+    f.await
+    assert_equal [1, 2], buffer
+
+    buffer = []
+    f = spin do
+      buffer << 1
+      snooze
+      buffer << 2
+      sleep 3
+      buffer << 3
+    ensure
+      buffer << 4 if Fiber.current.graceful_shutdown?
+    end
+
+    3.times { snooze }
+    f.terminate(true)
+    f.await
+    assert_equal [1, 2, 4], buffer
+  end
+
+  def test_graceful_child_shutdown
+    buffer = []
+    f0 = spin do
+      f1 = spin do
+        sleep
+      ensure
+        buffer << 1 if Fiber.current.graceful_shutdown?
+      end
+
+      f2 = spin do
+        sleep
+      ensure
+        buffer << 2 if Fiber.current.graceful_shutdown?
+      end
+
+      sleep
+    ensure
+      Fiber.current.terminate_all_children(true) if Fiber.current.graceful_shutdown?
+      Fiber.current.await_all_children
+    end
+
+    3.times { snooze }
+    f0.terminate(true)
+    f0.await
+
+    assert_equal [1, 2], buffer
+  end
+end

data/test/test_global_api.rb

@@ -307,6 +307,36 @@ class SpinLoopTest < MiniTest::Test
     f.stop
     assert_in_range 1..3, counter
   end
+
+  def test_spin_loop_break
+    i = 0
+    f = spin_loop do
+      i += 1
+      snooze
+      break if i >= 5
+    end
+    f.await
+    assert_equal 5, i
+
+    i = 0
+    f = spin_loop do
+      i += 1
+      snooze
+      raise StopIteration if i >= 5
+    end
+    f.await
+    assert_equal 5, i
+  end
+
+  def test_throttled_spin_loop_break
+    i = 0
+    f = spin_loop(rate: 100) do
+      i += 1
+      break if i >= 5
+    end
+    f.await
+    assert_equal 5, i
+  end
 end
 
 class SpinScopeTest < MiniTest::Test

data/test/test_io.rb

@@ -92,6 +92,32 @@ class IOTest < MiniTest::Test
     assert_raises(EOFError) { i.readpartial(1) }    
   end
 
+  def test_gets
+    i, o = IO.pipe
+
+    buf = []
+    f = spin do
+      while (l = i.gets)
+        buf << l
+      end
+    end
+
+    snooze
+    assert_equal [], buf
+
+    o << 'fab'
+    snooze
+    assert_equal [], buf
+    
+    o << "ulous\n"
+    10.times { snooze }
+    assert_equal ["fabulous\n"], buf
+
+    o.close
+    f.await
+    assert_equal ["fabulous\n"], buf
+  end
+
   def test_getc
     i, o = IO.pipe
 

data/test/test_socket.rb

@@ -60,7 +60,6 @@ class SocketTest < MiniTest::Test
 end
 
 class HTTPClientTest < MiniTest::Test
-  require 'httparty'
   require 'json'
 
   def test_http

data/test/test_supervise.rb

@@ -20,7 +20,7 @@ class SuperviseTest < MiniTest::Test
 
     f2 << 'bar'
     f2.await
-    assert_equal :waiting, p.state
+    assert_equal :runnable, p.state
     snooze
 
     assert_equal :dead, p.state

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.47.5.1
+  version: 0.48.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2021-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -269,7 +269,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.0
 description: 
-email: ciconia@gmail.com
+email: sharon@noteflakes.com
 executables: []
 extensions:
 - ext/polyphony/extconf.rb
@@ -383,6 +383,7 @@ files:
 - examples/io/raw.rb
 - examples/io/reline.rb
 - examples/io/system.rb
+- examples/io/tcp_proxy.rb
 - examples/io/tcpserver.rb
 - examples/io/tcpsocket.rb
 - examples/io/tunnel.rb
@@ -391,6 +392,8 @@ files:
 - examples/performance/fiber_resume.rb
 - examples/performance/fiber_transfer.rb
 - examples/performance/fs_read.rb
+- examples/performance/line_splitting.rb
+- examples/performance/loop.rb
 - examples/performance/mem-usage.rb
 - examples/performance/messaging.rb
 - examples/performance/multi_snooze.rb
@@ -433,7 +436,6 @@ files:
 - ext/liburing/setup.c
 - ext/liburing/syscall.c
 - ext/liburing/syscall.h
-- ext/polyphony/backend.h
 - ext/polyphony/backend_common.h
 - ext/polyphony/backend_io_uring.c
 - ext/polyphony/backend_io_uring_context.c

data/ext/polyphony/backend.h

@@ -1,26 +0,0 @@
-#ifndef BACKEND_H
-#define BACKEND_H
-
-#include "ruby.h"
-
-typedef VALUE (* backend_pending_count_t)(VALUE self);
-typedef VALUE (*backend_poll_t)(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue);
-typedef VALUE (* backend_ref_t)(VALUE self);
-typedef int (* backend_ref_count_t)(VALUE self);
-typedef void (* backend_reset_ref_count_t)(VALUE self);
-typedef VALUE (* backend_unref_t)(VALUE self);
-typedef VALUE (* backend_wait_event_t)(VALUE self, VALUE raise_on_exception);
-typedef VALUE (* backend_wakeup_t)(VALUE self);
-
-typedef struct backend_interface {
-  backend_pending_count_t   pending_count;
-  backend_poll_t            poll;
-  backend_ref_t             ref;
-  backend_ref_count_t       ref_count;
-  backend_reset_ref_count_t reset_ref_count;
-  backend_unref_t           unref;
-  backend_wait_event_t      wait_event;
-  backend_wakeup_t          wakeup;
-} backend_interface_t;
-
-#endif /* BACKEND_H */