polyphony 0.47.4 → 0.49.1

data/Gemfile.lock

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

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Sharon Rosner
+Copyright (c) 2021 Sharon Rosner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/TODO.md

@@ -1,49 +1,58 @@
-- Graceful shutdown again:
+- 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
 
-  - Add `Polyphony::GracefulShutdown` exception
-  - Two exceptions for stopping fibers:
-    - `Polyphony::GracefulShutdown` - graceful shutdown
-    - `Polyphony::Terminate` - ungraceful shutdown
-  - Fiber API:
-    - `Fiber#shutdown_children` - graceful shutdown of all children
-    - `Fiber#terminate_children` - ungraceful shutdown of all children
+- Override stock `::SizedQueue` impl with Queue with capacity
 
-  - Add `Fiber#graceful_shutdown?` method
-    - Returns false unless a `Polyphony::GracefulShutdown` was raised
-  - Override `Polyphony::Terminate#invoke` to reset the `@graceful_shutdown` fiber
-    flag
+- Add support for `break` and `StopIteration` in all loops (with tests)
 
-  And then we have:
+- 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)
 
-  ```ruby
-  spin do
-    loop { do_some_stuff }
-  ensure
-    return unless Fiber.current.graceful_shutdown?
 
-  shutdown_gracefully
+- Add `Backend#splice`, `Backend#splice_loop` 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) }
+    Fiber.await(f1, f2)
   end
   ```
 
-  - When a fiber is stopped it should use `Polyphony::Terminate` to stop child
-    fibers, *unless* it was stopped with a `Polyphony::GracefulShutdown` (which it
-    can check with `@graceful_shutdown`).
-
-- 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)
+- 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
+  - 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
 
 - check integration with rb-inotify
 
-- Check why worker-thread example doesn't work.
+- Improve `#supervise`. It does not work as advertised, and seems to exhibit an
+  inconsistent behaviour (see supervisor example).
+
 - Add test that mimics the original design for Monocrono:
   - 256 fibers each waiting for a message
   - When message received do some blocking work using a `ThreadPool`
   - Send messages, collect responses, check for correctness
-- Improve `#supervise`. It does not work as advertised, and seems to exhibit an
-  inconsistent behaviour (see supervisor example).
 
 - io_uring
   - Use playground.c to find out why we when submitting and waiting for

data/examples/core/supervisor.rb

@@ -9,9 +9,9 @@ def my_sleep(t)
   puts "#{t} done"
 end
 
-spin { my_sleep(1) }
-spin { my_sleep(2) }
-spin { my_sleep(3) }
+spin { my_sleep(0.1) }
+spin { my_sleep(0.2) }
+spin { my_sleep(0.3) }
 spin { puts "fiber count: #{Fiber.current.children.count}" }
 snooze
 

data/examples/core/worker-thread.rb

@@ -13,11 +13,9 @@ end
 $worker = Thread.new do
   Fiber.current.tag = :worker
   loop do
-    client, block = receive
+    (client, block) = receive
     do_work(client, &block)
   end
-rescue Exception => e
-  p e
 end
 
 def process(&block)
@@ -27,4 +25,5 @@ end
 
 sleep 0.1
 
-p process { 1 + 1 }
+p process { 1 + 1 }
+p process { 42 ** 2 }

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

@@ -3,26 +3,6 @@
 #include "ruby.h"
 #include "ruby/io.h"
 
-VALUE cTCPSocket;
-VALUE cTCPServer;
-VALUE cUNIXSocket;
-VALUE cUNIXServer;
-
-void Init_SocketClasses() {
-  rb_require("socket");
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
-  cTCPServer = rb_const_get(rb_cObject, rb_intern("TCPServer"));
-  cUNIXSocket = rb_const_get(rb_cObject, rb_intern("UNIXSocket"));
-  cUNIXServer = rb_const_get(rb_cObject, rb_intern("UNIXServer"));
-}
-
-VALUE ConnectionSocketClass(VALUE server) {
-  if (RTEST(rb_obj_is_kind_of(server, cTCPServer))) return cTCPSocket;
-  if (RTEST(rb_obj_is_kind_of(server, cUNIXServer))) return cUNIXSocket;
-
-  rb_raise(rb_eRuntimeError, "Invalid server class");
-}
-
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -90,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 = 2048;
 
   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) {
-  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) {
-  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;
@@ -668,12 +644,11 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str) {
   return INT2NUM(len);
 }
 
-VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, int loop) {
+VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
   rb_io_t *fptr;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE socket = Qnil;
-  VALUE socket_class = ConnectionSocketClass(server_socket);
   VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
   if (underlying_sock != Qnil) server_socket = underlying_sock;
 
@@ -718,16 +693,16 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, int loop)
   return Qnil;
 }
 
-VALUE Backend_accept(VALUE self, VALUE sock) {
+VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   GetBackend(self, backend);
-  return io_uring_backend_accept(backend, sock, 0);
+  return io_uring_backend_accept(backend, server_socket, socket_class, 0);
 }
 
-VALUE Backend_accept_loop(VALUE self, VALUE sock) {
+VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   GetBackend(self, backend);
-  io_uring_backend_accept(backend, sock, 1);
+  io_uring_backend_accept(backend, server_socket, socket_class, 1);
   return self;
 }
 
@@ -945,18 +920,12 @@ VALUE Backend_kind(VALUE self) {
 }
 
 void Init_Backend() {
-  Init_SocketClasses();
-
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
   rb_define_alloc_func(cBackend, Backend_allocate);
 
   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);
@@ -967,8 +936,8 @@ void Init_Backend() {
   rb_define_method(cBackend, "recv", Backend_recv, 3);
   rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 1);
   rb_define_method(cBackend, "send", Backend_send, 2);
-  rb_define_method(cBackend, "accept", Backend_accept, 1);
-  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 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, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
@@ -980,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