polyphony 0.47.5 → 0.49.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4343a37f26793e76528ea8e87287e2f3fbc4c8182064e820eedfc131d4308729
-  data.tar.gz: 89273660342f647e3e016290ef48ac10f33b040a3ca6538b1fdd29aab13519da
+  metadata.gz: 18278f9c013191fd5a96520a07e3b6e5c4bc088665a1b1a769b02552bd0e5448
+  data.tar.gz: 4e1e42fa5e2a6ddc6dcff7982415dd16246a0d75212aa2eb9ae7a97e030a2bdb
 SHA512:
-  metadata.gz: 7aa6b9f5e9ea61b682a112b30286b1e66f71088da67f96827d6415a6be12de4874de79ccd2236f36ba4da1bf5e9c078735bd07ac32520268c12cadfe60cd8565
-  data.tar.gz: e564dfed776907921bdceafcdb47e78fe5655d345812f3484d7493df74f3485d09bf32e756c766cc45efe45591524c6a24d55c19530fa14ededbb4f481e80977
+  metadata.gz: 483158709045a9dc59fa75c912067c4fafbb02885e15f3fa57f482b97903a0c919abbb5ad19bea85837222a44d5ec2778f1e1421839c2e6a595a64e84f2d707d
+  data.tar.gz: c1162de70de5aa2d92804e7c4ccb3a372c5839d5600a7f68ae6f84363677a52f23923dbe8e407a84607ac4f0145736c7a5b9ada8b4956fd9c742cec182ed3a70

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.49.2
+
+- Fix hang with 100s or more child fibers when terminating
+- Fix double pending_count increment in io_uring backend
+
+## 0.49.1
+
+- 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
+
+- Implement `Polyphony::Timer` for performant timeouts
+
+## 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
+
 ## 0.47.5
 
 - Add `socket_class` argument to `Backend#accept`, `Backend#accept_loop`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.47.5)
+    polyphony (0.49.2)
 
 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,29 +1,46 @@
-- 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
+
+- Override stock `::SizedQueue` impl with Queue with capacity
+
+- 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)
 
-  - 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
+- 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

@@ -26,8 +26,12 @@ def write_response(socket)
   socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-server = TCPServer.open('0.0.0.0', 1234)
-puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 1234"
+server = TCPServer.open('0.0.0.0', 4411)
+puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 4411"
+
+spin_loop(interval: 10) do
+  p Thread.current.fiber_scheduling_stats
+end
 
 server.accept_loop do |c|
   spin { handle_client(c) }

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 = 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) {
+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,10 @@ 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++;
   switchpoint_result = backend_await(backend);
-  backend->ref_count--;
 
   if (!ctx->completed) {
     ctx->result = -ECANCELED;
@@ -351,7 +325,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 +347,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 +384,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 +555,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 +592,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 +924,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 +947,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