polyphony 0.49.0 → 0.51.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 444ffbf8eb00cbd5e6948d6e3347e244fb8ea548aa1ad302d266e2f16c1a91b9
-  data.tar.gz: 2ac2f6ba1b51e71f1f138ad8eae665cc12e5458e836a0ef4f2df30d9ab95b679
+  metadata.gz: 72f11d867863c51f1fc1ab3ec85fe575cca9ee53a5047f4d3f7b76cea3b650b7
+  data.tar.gz: c29354b2de2f207185fc06fd86421b53d328aaf67d611109a6f95e9130ac5967
 SHA512:
-  metadata.gz: 65924d13d191fc7c6d7b9fc2f7df997218396cf7ff9933564296ee50100441279387b01dc046797378973514dc45b25afd7eda92e19aac9dde3d7f2a13a9901e
-  data.tar.gz: a419d45a69c4a12a468277068ed792cc82d0384b2d620497c4c132fa27b9155ce05ce6662c062766ae5204c8c09a490bb1e95164c7a4bf0baa9f3166ac57d348
+  metadata.gz: 93351a3c4007145ff317257f82b764708b445e94b848d31f783f4d72071b097a8309322c4bedfdb7f321b0613ef436a314ad4e650928d0855143d3a5b98d9c13
+  data.tar.gz: 9119039548264867fa012bcbb90999f4ad82170c28539d43b0145687a761d508630da538ac87b75f9bf32f6b33cb0e13c22f50143248b85cc90289d5d3451d3f

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 0.51.0
+
+- Implement `IO#feed_loop`, `Socket#feed_loop`
+- Fix error handling in `Process.kill_and_await`
+
+## 0.50.1
+
+- Set `IOSQE_ASYNC` flag in io_uring backend
+- Fix error handling in `Backend#waitpid`
+- Reimplement libev backend's `#waitpid` by using pidfd_open (in similar manner
+  to the io_uring backend)
+
+## 0.50.0
+
+- Use `Process::CLOCK_MONOTONIC` in Timer
+- Add `Timer#sleep`, `Timer#after`, `Timer#every`
+- Prevent fiber from being resumed after terminating
+- Add `Thread#fiber_index_of` method
+- Use `Backend#wait_event` in `Fiber#await`
+
+## 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.49.0)
+    polyphony (0.51.0)
 
 GEM
   remote: https://rubygems.org/
@@ -72,6 +72,7 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    msgpack (1.4.2)
     multi_xml (0.6.0)
     mysql2 (0.5.3)
     parallel (1.19.1)
@@ -136,6 +137,7 @@ DEPENDENCIES
   just-the-docs (~> 0.3.0)
   minitest (= 5.13.0)
   minitest-reporters (= 1.4.2)
+  msgpack (= 1.4.2)
   mysql2 (= 0.5.3)
   pg (= 1.1.4)
   polyphony!

data/TODO.md

@@ -1,6 +1,10 @@
-- Check segfault when doing lots of `cancel_after` calls
+- 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
+- Commented out `io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);` in `io_uring_backend_defer_submit_and_await`:
+  - This flag should be set for I/O ops, not for other stuff
+
+- Override stock `::SizedQueue` impl with Queue with capacity
 
 - Add support for `break` and `StopIteration` in all loops (with tests)
 

data/examples/core/nested.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def process
+  p :b_start
+  sleep 1
+  p :b_stop
+end
+
+spin do
+  p :a_start
+  spin { process }
+  sleep 60
+  p :a_stop
+end
+
+p :main_start
+sleep 120
+p :main_stop

data/examples/core/suspend.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+main = Fiber.current
+spin do
+  sleep 0.1
+  main.schedule(:foo)
+end
+
+v = suspend
+puts "v => #{v.inspect}"

data/examples/core/terminate_main_fiber.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+main = Fiber.current
+spin do
+  sleep 0.1
+  main.terminate
+end
+
+sleep

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

@@ -26,15 +26,13 @@ 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
 
-GC.disable
-
 server.accept_loop do |c|
   spin { handle_client(c) }
 end

data/ext/polyphony/backend_common.h

@@ -3,6 +3,14 @@
 #include "ruby.h"
 #include "ruby/io.h"
 
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434   /* System call # on most architectures */
+#endif
+
+static int pidfd_open(pid_t pid, unsigned int flags) {
+  return syscall(__NR_pidfd_open, pid, flags);
+}
+
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -99,6 +107,13 @@ inline VALUE backend_snooze() {
   READ_LOOP_PREPARE_STR(); \
 }
 
+#define READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id) { \
+  io_set_read_length(str, total, shrinkable); \
+  io_enc_str(str, fptr); \
+  rb_funcall_passing_block(receiver, method_id, 1, &str); \
+  READ_LOOP_PREPARE_STR(); \
+}
+
 inline void rectify_io_file_pos(rb_io_t *fptr) {
   // Apparently after reopening a closed file, the file position is not reset,
   // which causes the read to fail. Fortunately we can use fptr->rbuf.len to
@@ -114,7 +129,7 @@ inline double current_time() {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
   long long ns = ts.tv_sec;
-  ns = ns * 1000000000 + ts.tv_nsec;
+  ns = ns * 1e9 + ts.tv_nsec;
   double t = ns;
   return t / 1e9;
 }
@@ -126,4 +141,16 @@ inline VALUE backend_timeout_exception(VALUE exception) {
     return rb_funcall(exception, ID_new, 0);
   else
     return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
-}
+}
+
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}

data/ext/polyphony/backend_io_uring.c

@@ -19,14 +19,6 @@
 #include "ruby/thread.h"
 #include "backend_io_uring_context.h"
 
-#ifndef __NR_pidfd_open
-#define __NR_pidfd_open 434   /* System call # on most architectures */
-#endif
-
-static int pidfd_open(pid_t pid, unsigned int flags) {
-  return syscall(__NR_pidfd_open, pid, flags);
-}
-
 VALUE SYM_io_uring;
 
 typedef struct Backend_t {
@@ -72,7 +64,7 @@ static VALUE Backend_initialize(VALUE self) {
   backend->pending_count = 0;
   backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
-  backend->prepared_limit = 256;
+  backend->prepared_limit = 2048;
 
   context_store_initialize(&backend->store);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
@@ -260,12 +252,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->pending_count++;
   switchpoint_result = backend_await(backend);
-  backend->pending_count--;
 
   if (!ctx->completed) {
     ctx->result = -ECANCELED;
@@ -399,6 +389,52 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   return io;
 }
 
+VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  rb_io_t *fptr;
+  VALUE str;
+  long total;
+  long len = 8192;
+  int shrinkable;
+  char *buf;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  ID method_id = SYM2ID(method);
+
+  READ_LOOP_PREPARE_STR();
+
+  GetBackend(self, backend);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+  rectify_io_file_pos(fptr);
+
+  while (1) {
+    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, -1);
+    
+    ssize_t 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;
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else if (!result)
+      break; // EOF
+    else {
+      total = result;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+
+  return io;
+}
+
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -606,6 +642,51 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
   return io;
 }
 
+VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  rb_io_t *fptr;
+  VALUE str;
+  long total;
+  long len = 8192;
+  int shrinkable;
+  char *buf;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  ID method_id = SYM2ID(method);
+
+  READ_LOOP_PREPARE_STR();
+
+  GetBackend(self, backend);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+  rectify_io_file_pos(fptr);
+
+  while (1) {
+    VALUE resume_value = Qnil;
+    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_recv(sqe, fptr->fd, buf, len, 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;
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else if (!result)
+      break; // EOF
+    else {
+      total = result;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+  return io;
+}
+
 VALUE Backend_send(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -813,18 +894,6 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct Backend_timeout_ctx {
   Backend_t *backend;
   op_context_t *ctx;
@@ -863,7 +932,6 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
-  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
   struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
@@ -881,19 +949,28 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  Backend_t *backend;
   int pid_int = NUM2INT(pid);
   int fd = pidfd_open(pid_int, 0);
-  GetBackend(self, backend);
-  
-  VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
-  close(fd);
 
-  RAISE_IF_EXCEPTION(resume_value);
-  RB_GC_GUARD(resume_value);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
 
+    VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
+  
   int status;
   pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    if (e == ECHILD)
+      ret = pid_int;
+    else
+      rb_syserr_fail(e, strerror(e));
+  }
   return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 
@@ -932,9 +1009,11 @@ void Init_Backend() {
 
   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, "send", Backend_send, 2);
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);

data/ext/polyphony/backend_libev.c

@@ -8,6 +8,8 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
@@ -332,6 +334,58 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE str;
+  long total;
+  long len = 8192;
+  int shrinkable;
+  char *buf;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  ID method_id = SYM2ID(method);
+
+  READ_LOOP_PREPARE_STR();
+
+  GetBackend(self, backend);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+  io_set_nonblock(fptr, io);
+  rectify_io_file_pos(fptr);
+  watcher.fiber = Qnil;
+
+  while (1) {
+    ssize_t n = read(fptr->fd, buf, len);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      switchpoint_result = backend_snooze();
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      if (n == 0) break; // EOF
+      total = n;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return io;
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -685,26 +739,12 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     RB_GC_GUARD(switchpoint_result);
 
     rb_yield(Qnil);
-
-    while (1) {
+    do {
       next_time += interval_d;
-      if (next_time > now) break;
-    }
+    } while (next_time <= now);
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct libev_timeout {
   struct ev_timer timer;
   VALUE fiber;
@@ -759,38 +799,29 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
   return result;
 }
 
-struct libev_child {
-  struct ev_child child;
-  VALUE fiber;
-};
-
-void Backend_child_callback(EV_P_ ev_child *w, int revents)
-{
-  struct libev_child *watcher = (struct libev_child *)w;
-  int exit_status = WEXITSTATUS(w->rstatus);
-  VALUE status;
-
-  status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
-  Fiber_make_runnable(watcher->fiber, status);
-}
-
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  Backend_t *backend;
-  struct libev_child watcher;
-  VALUE switchpoint_result = Qnil;
-  GetBackend(self, backend);
-
-  watcher.fiber = rb_fiber_current();
-  ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
-  ev_child_start(backend->ev_loop, &watcher.child);
-
-  switchpoint_result = backend_await(backend);
+  int pid_int = NUM2INT(pid);
+  int fd = pidfd_open(pid_int, 0);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
+
+    VALUE resume_value = libev_wait_fd(backend, fd, EV_READ, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
 
-  ev_child_stop(backend->ev_loop, &watcher.child);
-  RAISE_IF_EXCEPTION(switchpoint_result);
-  RB_GC_GUARD(watcher.fiber);
-  RB_GC_GUARD(switchpoint_result);
-  return switchpoint_result;
+  int status = 0;
+  pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    if (e == ECHILD)
+      ret = pid_int;
+    else
+      rb_syserr_fail(e, strerror(e));
+  }
+  return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 
 void Backend_async_callback(EV_P_ ev_async *w, int revents) { }
@@ -832,12 +863,14 @@ void Init_Backend() {
 
   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, "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_write, 2);
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);