polyphony 0.55.0 → 0.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0f6698a072e4ba2913477d20f5884d5d7579b99cca1db0f2ffa3aeca42ebcc
-  data.tar.gz: 97fec9986f6693d685bfb0c1745995c8a85413a9b6cc1a1ff69393d55a5f3b74
+  metadata.gz: c6c9247de0e5049128fffb31879fd0a79ba6fe304e3802a5b7fa69baa4445ecf
+  data.tar.gz: f2e432fb0f9d6362b7d38834a0e37c7907328c6a27d6544e1dad5363ba4f715c
 SHA512:
-  metadata.gz: 053beffc7c27658d129002b5efc29f64c7fcf1ff7fbf3f2eea1d588b2a9e40e89251640bf9bb82ce478837f38c32863987d8ac0af987d374d4ac242d012363dd
-  data.tar.gz: e89df4044f09f4df64fc57622f22e70d932f2f09ea3b2a5c2090698784c286367df43d352231068b8ef96d6a7ba89e5492b4c237c9960aeb5fa79af9ee738768
+  metadata.gz: 3d69bdb3f12cb65cf580cc243ea0a4f479b5306cf087bcfc5e9d8def1fee49b998528f881844649bc01b501ea22371632fd1f4f08d1f8118692bdf2331f698e6
+  data.tar.gz: d49152bd9c9be94835a020f829c7ddc7f3766fcac9fca8e652bd8df43daab7a6eda90c94b40e57b3cef064d1ff2a957f42030aedefae1b2d1ad6a6587cf6fa86

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.56.0 2021-06-22
+
+- Implement fake `Backend#splice`, `Backend#splice_to_eof` methods for non-Linux
+  OS
+
 ## 0.55.0 2021-06-17
 
 - Finish io_uring implementation of Backend#chain

data/Gemfile.lock

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

data/examples/core/idle_gc.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'polyphony'
+
+GC.disable
+
+p count: GC.count
+snooze
+p count_after_snooze: GC.count
+sleep 0.1
+p count_after_sleep: GC.count
+
+Thread.current.backend.idle_gc_period = 60
+
+p count: GC.count
+snooze
+p count_after_snooze: GC.count
+sleep 0.1
+p count_after_sleep: GC.count

data/examples/io/pipe.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+i, o = IO.pipe
+f = spin { p i.read }
+
+o << 'hello'
+o.close
+f.await

data/ext/polyphony/backend_common.c

@@ -0,0 +1,186 @@
+#include <time.h>
+#include <fcntl.h>
+#include "ruby.h"
+#include "ruby/io.h"
+#include "polyphony.h"
+#include "backend_common.h"
+
+#ifdef POLYPHONY_USE_PIDFD_OPEN
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434   /* System call # on most architectures */
+#endif
+
+inline int pidfd_open(pid_t pid, unsigned int flags) {
+  return syscall(__NR_pidfd_open, pid, flags);
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+// the following is copied verbatim from the Ruby source code (io.c)
+
+inline int io_setstrbuf(VALUE *str, long len) {
+  #ifdef _WIN32
+    len = (len + 1) & ~1L;	/* round up for wide char */
+  #endif
+  if (*str == Qnil) {
+    *str = rb_str_new(0, len);
+    return 1;
+  }
+  else {
+    VALUE s = StringValue(*str);
+    long clen = RSTRING_LEN(s);
+    if (clen >= len) {
+      rb_str_modify(s);
+      return 0;
+    }
+    len -= clen;
+  }
+  rb_str_modify_expand(*str, len);
+  return 0;
+}
+
+#define MAX_REALLOC_GAP 4096
+
+inline void io_shrink_read_string(VALUE str, long n) {
+  if (rb_str_capacity(str) - n > MAX_REALLOC_GAP) {
+    rb_str_resize(str, n);
+  }
+}
+
+inline void io_set_read_length(VALUE str, long n, int shrinkable) {
+  if (RSTRING_LEN(str) != n) {
+    rb_str_modify(str);
+    rb_str_set_len(str, n);
+    if (shrinkable) io_shrink_read_string(str, n);
+  }
+}
+
+inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
+  if (fptr->encs.enc) {
+	  return fptr->encs.enc;
+  }
+  return rb_default_external_encoding();
+}
+
+inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
+  OBJ_TAINT(str);
+  rb_enc_associate(str, io_read_encoding(fptr));
+  return str;
+}
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+VALUE backend_await(struct Backend_base *backend) {
+  VALUE ret;
+  backend->pending_count++;
+  ret = Thread_switch_fiber(rb_thread_current());
+  backend->pending_count--;
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+VALUE backend_snooze() {
+  Fiber_make_runnable(rb_fiber_current(), Qnil);
+  VALUE ret = Thread_switch_fiber(rb_thread_current());
+  return ret;
+}
+
+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
+  // find out if that's the case.
+  // See: https://github.com/digital-fabric/polyphony/issues/30
+  if (fptr->rbuf.len > 0) {
+    lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);
+    fptr->rbuf.len = 0;
+  }
+}
+
+inline double current_time() {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  long long ns = ts.tv_sec;
+  ns = ns * 1e9 + ts.tv_nsec;
+  double t = ns;
+  return t / 1e9;
+}
+
+inline VALUE backend_timeout_exception(VALUE exception) {
+  if (rb_obj_is_kind_of(exception, rb_cArray) == Qtrue)
+    return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
+  else if (rb_obj_is_kind_of(exception, rb_cClass) == Qtrue)
+    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);
+}
+
+static VALUE empty_string = Qnil;
+
+VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
+  switch (RARRAY_LEN(ary)) {
+  case 0:
+    return Qnil;
+  case 1:
+    return Backend_send(self, io, RARRAY_AREF(ary, 0), flags);
+  default:
+    if (empty_string == Qnil) {
+      empty_string = rb_str_new_literal("");
+      rb_global_variable(&empty_string);
+    }
+    VALUE joined = rb_ary_join(ary, empty_string);
+    VALUE result = Backend_send(self, io, joined, flags);
+    RB_GC_GUARD(joined);
+    return result;
+  }
+}
+
+inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
+  VALUE blocking_mode = rb_ivar_get(io, ID_ivar_blocking_mode);
+  if (blocking == blocking_mode) return;
+
+  rb_ivar_set(io, ID_ivar_blocking_mode, blocking);
+
+#ifdef _WIN32
+  if (blocking != Qtrue)
+    rb_w32_set_nonblock(fptr->fd);
+#elif defined(F_GETFL)
+  int flags = fcntl(fptr->fd, F_GETFL);
+  if (flags == -1) return;
+  int is_nonblocking = flags & O_NONBLOCK;
+  
+  if (blocking == Qtrue) {
+    if (!is_nonblocking) return;
+    flags &= ~O_NONBLOCK;
+  } else {
+    if (is_nonblocking) return;
+    flags |= O_NONBLOCK;
+  }
+  fcntl(fptr->fd, F_SETFL, flags);
+#endif
+}
+
+inline void backend_run_idle_tasks(struct Backend_base *base) {
+  if (base->idle_gc_period == 0) return;
+
+  double now = current_time();
+  if (now - base->idle_gc_last_time < base->idle_gc_period) return;
+
+  base->idle_gc_last_time = now;
+  rb_gc_enable();
+  rb_gc_start();
+  rb_gc_disable();
+}

data/ext/polyphony/backend_common.h

@@ -1,17 +1,18 @@
-#include <time.h>
+#ifndef BACKEND_COMMON_H
+#define BACKEND_COMMON_H
 
 #include "ruby.h"
 #include "ruby/io.h"
 
+struct Backend_base {
+  unsigned int currently_polling;
+  unsigned int pending_count;
+  double idle_gc_period;
+  double idle_gc_last_time;
+};
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
-#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);
-}
+int pidfd_open(pid_t pid, unsigned int flags);
 #endif
 
 //////////////////////////////////////////////////////////////////////
@@ -26,75 +27,19 @@ struct io_internal_read_struct {
 
 #define StringValue(v) rb_string_value(&(v))
 
-inline int io_setstrbuf(VALUE *str, long len) {
-  #ifdef _WIN32
-    len = (len + 1) & ~1L;	/* round up for wide char */
-  #endif
-  if (*str == Qnil) {
-    *str = rb_str_new(0, len);
-    return 1;
-  }
-  else {
-    VALUE s = StringValue(*str);
-    long clen = RSTRING_LEN(s);
-    if (clen >= len) {
-      rb_str_modify(s);
-      return 0;
-    }
-    len -= clen;
-  }
-  rb_str_modify_expand(*str, len);
-  return 0;
-}
-
-#define MAX_REALLOC_GAP 4096
-
-inline void io_shrink_read_string(VALUE str, long n) {
-  if (rb_str_capacity(str) - n > MAX_REALLOC_GAP) {
-    rb_str_resize(str, n);
-  }
-}
-
-inline void io_set_read_length(VALUE str, long n, int shrinkable) {
-  if (RSTRING_LEN(str) != n) {
-    rb_str_modify(str);
-    rb_str_set_len(str, n);
-    if (shrinkable) io_shrink_read_string(str, n);
-  }
-}
-
-inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
-  if (fptr->encs.enc) {
-	  return fptr->encs.enc;
-  }
-  return rb_default_external_encoding();
-}
-
-inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
-  OBJ_TAINT(str);
-  rb_enc_associate(str, io_read_encoding(fptr));
-  return str;
-}
+int io_setstrbuf(VALUE *str, long len);
+void io_shrink_read_string(VALUE str, long n);
+void io_set_read_length(VALUE str, long n, int shrinkable);
+rb_encoding* io_read_encoding(rb_io_t *fptr);
+VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-inline VALUE backend_await(Backend_t *backend) {
-  VALUE ret;
-  backend->pending_count++;
-  ret = Thread_switch_fiber(rb_thread_current());
-  backend->pending_count--;
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
-inline VALUE backend_snooze() {
-  Fiber_make_runnable(rb_fiber_current(), Qnil);
-  return Thread_switch_fiber(rb_thread_current());
-}
+VALUE backend_await(struct Backend_base *backend);
+VALUE backend_snooze();
 
 // macros for doing read loops
-
 #define READ_LOOP_PREPARE_STR() { \
   str = Qnil; \
   shrinkable = io_setstrbuf(&str, len); \
@@ -117,63 +62,13 @@ inline VALUE backend_snooze() {
   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
-  // find out if that's the case.
-  // See: https://github.com/digital-fabric/polyphony/issues/30
-  if (fptr->rbuf.len > 0) {
-    lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);
-    fptr->rbuf.len = 0;
-  }
-}
-
-inline double current_time() {
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  long long ns = ts.tv_sec;
-  ns = ns * 1e9 + ts.tv_nsec;
-  double t = ns;
-  return t / 1e9;
-}
-
-inline VALUE backend_timeout_exception(VALUE exception) {
-  if (rb_obj_is_kind_of(exception, rb_cArray) == Qtrue)
-    return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
-  else if (rb_obj_is_kind_of(exception, rb_cClass) == Qtrue)
-    return rb_funcall(exception, ID_new, 0);
-  else
-    return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
-}
+void rectify_io_file_pos(rb_io_t *fptr);
+double current_time();
+VALUE backend_timeout_exception(VALUE exception);
+VALUE Backend_timeout_ensure_safe(VALUE arg);
+VALUE Backend_timeout_ensure_safe(VALUE arg);
+VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
+void backend_run_idle_tasks(struct Backend_base *base);
+void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking);
 
-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);
-}
-
-static VALUE empty_string = Qnil;
-
-VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
-  switch (RARRAY_LEN(ary)) {
-  case 0:
-    return Qnil;
-  case 1:
-    return Backend_send(self, io, RARRAY_AREF(ary, 0), flags);
-  default:
-    if (empty_string == Qnil) {
-      empty_string = rb_str_new_literal("");
-      rb_global_variable(&empty_string);
-    }
-    VALUE joined = rb_ary_join(ary, empty_string);
-    VALUE result = Backend_send(self, io, joined, flags);
-    RB_GC_GUARD(joined);
-    return result;
-  }
-}
+#endif /* BACKEND_COMMON_H */

data/ext/polyphony/backend_io_uring.c

@@ -4,7 +4,6 @@
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
-#include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
@@ -19,6 +18,7 @@
 #include "backend_io_uring_context.h"
 #include "ruby/thread.h"
 #include "ruby/io.h"
+#include "backend_common.h"
 
 VALUE SYM_io_uring;
 VALUE SYM_send;
@@ -26,34 +26,13 @@ VALUE SYM_splice;
 VALUE SYM_write;
 
 #ifdef POLYPHONY_UNSET_NONBLOCK
-ID ID_ivar_is_nonblocking;
-
-// One of the changes introduced in Ruby 3.0 as part of the work on the
-// FiberScheduler interface is that all created sockets are marked as
-// non-blocking. This prevents the io_uring backend from working correctly,
-// since it will return an EAGAIN error just like a normal syscall. So here
-// instead of setting O_NONBLOCK (which is required for the libev backend), we
-// unset it.
-inline void io_unset_nonblock(rb_io_t *fptr, VALUE io) {
-  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
-  if (is_nonblocking == Qfalse) return;
-
-  rb_ivar_set(io, ID_ivar_is_nonblocking, Qfalse);
-
-  int oflags = fcntl(fptr->fd, F_GETFL);
-  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
-  oflags &= !O_NONBLOCK;
-  fcntl(fptr->fd, F_SETFL, oflags);
-}
+#define io_unset_nonblock(fptr, io) io_verify_blocking_mode(fptr, io, Qtrue)
 #else
-// NOP
 #define io_unset_nonblock(fptr, io)
 #endif
 
 typedef struct Backend_t {
-  // common fields
-  unsigned int        currently_polling;
-  unsigned int        pending_count;
+  struct Backend_base base;
 
   // implementation-specific fields
   struct io_uring     ring;
@@ -63,8 +42,6 @@ typedef struct Backend_t {
   int                 event_fd;
 } Backend_t;
 
-#include "backend_common.h"
-
 static size_t Backend_size(const void *ptr) {
   return sizeof(Backend_t);
 }
@@ -88,8 +65,11 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->currently_polling = 0;
-  backend->pending_count = 0;
+  backend->base.currently_polling = 0;
+  backend->base.pending_count = 0;
+  backend->base.idle_gc_period = 0;
+  backend->base.idle_gc_last_time = 0;
+
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -117,8 +97,8 @@ 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->currently_polling = 0;
-  backend->pending_count = 0;
+  backend->base.currently_polling = 0;
+  backend->base.pending_count = 0;
   backend->pending_sqes = 0;
 
   return self;
@@ -128,7 +108,7 @@ unsigned int Backend_pending_count(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return backend->pending_count;
+  return backend->base.pending_count;
 }
 
 typedef struct poll_context {
@@ -197,9 +177,9 @@ void io_uring_backend_poll(Backend_t *backend) {
     io_uring_submit(&backend->ring);
   }
 
-  backend->currently_polling = 1;
+  backend->base.currently_polling = 1;
   rb_thread_call_without_gvl(io_uring_backend_poll_without_gvl, (void *)&poll_ctx, RUBY_UBF_IO, 0);
-  backend->currently_polling = 0;
+  backend->base.currently_polling = 0;
   if (poll_ctx.result < 0) return;
 
   io_uring_backend_handle_completion(poll_ctx.cqe, backend);
@@ -228,7 +208,7 @@ VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->currently_polling) {
+  if (backend->base.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);
@@ -263,7 +243,7 @@ int io_uring_backend_defer_submit_and_await(
   io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   if (ctx->ref_count > 1) {
     // op was not completed (an exception was raised), so we need to cancel it
@@ -1177,7 +1157,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
 
   ctx->ref_count = sqe_count + 1;
   io_uring_backend_defer_submit(backend);
-  resume_value = backend_await(backend);
+  resume_value = backend_await((struct Backend_base *)backend);
   int result = ctx->result;
   int completed = context_store_release(&backend->store, ctx);
   if (!completed) {
@@ -1195,6 +1175,21 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   return INT2NUM(result);
 }
 
+VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_gc_period = NUM2DBL(period);
+  backend->base.idle_gc_last_time = current_time();
+  return self;
+}
+
+inline VALUE Backend_run_idle_tasks(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_run_idle_tasks(&backend->base);
+  return self;
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -1207,6 +1202,7 @@ void Init_Backend() {
   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, "idle_gc_period=", Backend_idle_gc_period_set, 1);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);

data/ext/polyphony/backend_libev.c

@@ -42,7 +42,6 @@ thread.
 #define _GNU_SOURCE 1
 #endif
 
-#include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
@@ -52,44 +51,22 @@ thread.
 #include <stdnoreturn.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <fcntl.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
+#include "../libev/ev.h"
+#include "backend_common.h"
+
 VALUE SYM_libev;
 VALUE SYM_send;
 VALUE SYM_splice;
 VALUE SYM_write;
 
-ID ID_ivar_is_nonblocking;
-
-// Since we need to ensure that fd's are non-blocking before every I/O
-// operation, here we improve upon Ruby's rb_io_set_nonblock by caching the
-// "nonblock" state in an instance variable. Calling rb_ivar_get on every read
-// is still much cheaper than doing a fcntl syscall on every read! Preliminary
-// benchmarks (with a "hello world" HTTP server) show throughput is improved
-// by 10-13%.
-inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
-  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
-  if (is_nonblocking == Qtrue) return;
-
-  rb_ivar_set(io, ID_ivar_is_nonblocking, Qtrue);
-
-#ifdef _WIN32
-  rb_w32_set_nonblock(fptr->fd);
-#elif defined(F_GETFL)
-  int oflags = fcntl(fptr->fd, F_GETFL);
-  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
-  oflags |= O_NONBLOCK;
-  fcntl(fptr->fd, F_SETFL, oflags);
-#endif
-}
-
 typedef struct Backend_t {
-  // common fields
-  unsigned int        currently_polling;
-  unsigned int        pending_count;
+  struct Backend_base base;
 
   // implementation-specific fields
   struct ev_loop *ev_loop;
@@ -142,8 +119,10 @@ static VALUE Backend_initialize(VALUE self) {
   // block when no other watcher is active
   ev_unref(backend->ev_loop);
 
-  backend->currently_polling = 0;
-  backend->pending_count = 0;
+  backend->base.currently_polling = 0;
+  backend->base.pending_count = 0;
+  backend->base.idle_gc_period = 0;
+  backend->base.idle_gc_last_time = 0;
 
   return Qnil;
 }
@@ -174,11 +153,11 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-unsigned int Backend_pending_count(VALUE self) {
+inline unsigned int Backend_pending_count(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return backend->pending_count;
+  return backend->base.pending_count;
 }
 
 VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
@@ -186,9 +165,9 @@ VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue
   GetBackend(self, backend);
 
   COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  backend->currently_polling = 1;
+  backend->base.currently_polling = 1;
   ev_run(backend->ev_loop, nowait == Qtrue ? EVRUN_NOWAIT : EVRUN_ONCE);
-  backend->currently_polling = 0;
+  backend->base.currently_polling = 0;
   COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 
   return self;
@@ -198,7 +177,7 @@ VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->currently_polling) {
+  if (backend->base.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
@@ -211,10 +190,6 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
-#include "../libev/ev.h"
-
-#include "backend_common.h"
-
 struct libev_io {
   struct ev_io io;
   VALUE fiber;
@@ -235,7 +210,7 @@ VALUE libev_wait_fd_with_watcher(Backend_t *backend, int fd, struct libev_io *wa
   }
   ev_io_start(backend->ev_loop, &watcher->io);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_io_stop(backend->ev_loop, &watcher->io);
   RB_GC_GUARD(switchpoint_result);
@@ -271,7 +246,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
   OBJ_TAINT(str);
@@ -288,7 +263,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     }
     else {
       switchpoint_result = backend_snooze();
-
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
@@ -343,7 +317,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
 
@@ -395,7 +369,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
 
@@ -443,7 +417,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   while (left > 0) {
@@ -493,7 +467,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   iov = malloc(iov_count * sizeof(struct iovec));
@@ -574,7 +548,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
 
   GetBackend(self, backend);
   GetOpenFile(server_socket, fptr);
-  io_set_nonblock(fptr, server_socket);
+  io_verify_blocking_mode(fptr, server_socket, Qfalse);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -602,7 +576,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      io_set_nonblock(fp, socket);
+      io_verify_blocking_mode(fp, socket, Qfalse);
       rb_io_synchronized(fp);
 
       // if (rsock_do_not_reverse_lookup) {
@@ -631,7 +605,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
 
   GetBackend(self, backend);
   GetOpenFile(server_socket, fptr);
-  io_set_nonblock(fptr, server_socket);
+  io_verify_blocking_mode(fptr, server_socket, Qfalse);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -659,7 +633,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      io_set_nonblock(fp, socket);
+      io_verify_blocking_mode(fp, socket, Qfalse);
       rb_io_synchronized(fp);
 
       rb_yield(socket);
@@ -687,7 +661,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
 
   GetBackend(self, backend);
   GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  io_verify_blocking_mode(fptr, sock, Qfalse);
   watcher.fiber = Qnil;
 
   addr.sin_family = AF_INET;
@@ -730,7 +704,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   while (left > 0) {
@@ -778,13 +752,13 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   underlying_io = rb_ivar_get(src, ID_ivar_io);
   if (underlying_io != Qnil) src = underlying_io;
   GetOpenFile(src, src_fptr);
-  io_set_nonblock(src_fptr, src);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
 
   underlying_io = rb_ivar_get(dest, ID_ivar_io);
   if (underlying_io != Qnil) dest = underlying_io;
   dest = rb_io_get_write_io(dest);
   GetOpenFile(dest, dest_fptr);
-  io_set_nonblock(dest_fptr, dest);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
   watcher.fiber = Qnil;
   while (1) {
@@ -832,13 +806,13 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   underlying_io = rb_ivar_get(src, ID_ivar_io);
   if (underlying_io != Qnil) src = underlying_io;
   GetOpenFile(src, src_fptr);
-  io_set_nonblock(src_fptr, src);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
 
   underlying_io = rb_ivar_get(dest, ID_ivar_io);
   if (underlying_io != Qnil) dest = underlying_io;
   dest = rb_io_get_write_io(dest);
   GetOpenFile(dest, dest_fptr);
-  io_set_nonblock(dest_fptr, dest);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
   watcher.fiber = Qnil;
   while (1) {
@@ -875,6 +849,157 @@ error:
 }
 #endif
 
+VALUE Backend_fake_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len = NUM2INT(maxlen);
+  VALUE str = rb_str_new(0, len);
+  char *buf = RSTRING_PTR(str);
+  int left = 0;
+  int total = 0;
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
+
+  watcher.fiber = Qnil;
+  
+  while (1) {
+    ssize_t n = read(src_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, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      total = left = n;
+      break;
+    }
+  }
+
+  while (left > 0) {
+    ssize_t n = write(dest_fptr->fd, buf, left);
+    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, dest_fptr->fd, &watcher, EV_WRITE);
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+  RB_GC_GUARD(str);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_fake_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len = NUM2INT(maxlen);
+  VALUE str = rb_str_new(0, len);
+  char *buf = RSTRING_PTR(str);
+  int left = 0;
+  int total = 0;
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
+
+  watcher.fiber = Qnil;
+
+  while (1) { 
+    char *ptr = buf;
+    while (1) {
+      ssize_t n = read(src_fptr->fd, ptr, 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, src_fptr->fd, &watcher, EV_READ);
+        if (TEST_EXCEPTION(switchpoint_result)) goto error;
+      }
+      else if (n == 0) goto done;
+      else {
+        total += n;
+        left = n;
+        break;
+      }
+    }
+
+    while (left > 0) {
+      ssize_t n = write(dest_fptr->fd, ptr, left);
+      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, dest_fptr->fd, &watcher, EV_WRITE);
+        if (TEST_EXCEPTION(switchpoint_result)) goto error;
+      }
+      else {
+        ptr += n;
+        left -= n;
+      }
+    }
+  }
+
+done:
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+  RB_GC_GUARD(str);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -908,7 +1033,7 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
   ev_timer_init(&watcher.timer, Backend_timer_callback, NUM2DBL(duration), 0.);
   ev_timer_start(backend->ev_loop, &watcher.timer);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_timer_stop(backend->ev_loop, &watcher.timer);
   RAISE_IF_EXCEPTION(switchpoint_result);
@@ -936,7 +1061,7 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     VALUE switchpoint_result = Qnil;    
     ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
     ev_timer_start(backend->ev_loop, &watcher.timer);
-    switchpoint_result = backend_await(backend);
+    switchpoint_result = backend_await((struct Backend_base *)backend);
     ev_timer_stop(backend->ev_loop, &watcher.timer);
     RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
@@ -1053,7 +1178,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
   ev_child_start(backend->ev_loop, &watcher.child);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_child_stop(backend->ev_loop, &watcher.child);
   RAISE_IF_EXCEPTION(switchpoint_result);
@@ -1075,7 +1200,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
   ev_async_init(&async, Backend_async_callback);
   ev_async_start(backend->ev_loop, &async);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_async_stop(backend->ev_loop, &async);
   if (RTEST(raise)) RAISE_IF_EXCEPTION(switchpoint_result);
@@ -1112,6 +1237,21 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   return result;
 }
 
+VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_gc_period = NUM2DBL(period);
+  backend->base.idle_gc_last_time = current_time();
+  return self;
+}
+
+inline VALUE Backend_run_idle_tasks(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_run_idle_tasks(&backend->base);
+  return self;
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1126,6 +1266,7 @@ void Init_Backend() {
   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, "idle_gc_period=", Backend_idle_gc_period_set, 1);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
@@ -1143,6 +1284,9 @@ void Init_Backend() {
   #ifdef POLYPHONY_LINUX
   rb_define_method(cBackend, "splice", Backend_splice, 3);
   rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  #else
+  rb_define_method(cBackend, "splice", Backend_fake_splice, 3);
+  rb_define_method(cBackend, "splice_to_eof", Backend_fake_splice_to_eof, 3);
   #endif
 
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
@@ -1152,7 +1296,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "write", Backend_write_m, -1);
 
-  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));
 
   SYM_send = ID2SYM(rb_intern("send"));

data/ext/polyphony/polyphony.c

@@ -10,6 +10,7 @@ ID ID_each;
 ID ID_inspect;
 ID ID_invoke;
 ID ID_new;
+ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
@@ -158,19 +159,20 @@ void Init_Polyphony() {
 
   cTimeoutException = rb_define_class_under(mPolyphony, "TimeoutException", rb_eException);
 
-  ID_call           = rb_intern("call");
-  ID_caller         = rb_intern("caller");
-  ID_clear          = rb_intern("clear");
-  ID_each           = rb_intern("each");
-  ID_inspect        = rb_intern("inspect");
-  ID_invoke         = rb_intern("invoke");
-  ID_ivar_io        = rb_intern("@io");
-  ID_ivar_runnable  = rb_intern("@runnable");
-  ID_ivar_running   = rb_intern("@running");
-  ID_ivar_thread    = rb_intern("@thread");
-  ID_new            = rb_intern("new");
-  ID_signal         = rb_intern("signal");
-  ID_size           = rb_intern("size");
-  ID_switch_fiber   = rb_intern("switch_fiber");
-  ID_transfer       = rb_intern("transfer");
+  ID_call               = rb_intern("call");
+  ID_caller             = rb_intern("caller");
+  ID_clear              = rb_intern("clear");
+  ID_each               = rb_intern("each");
+  ID_inspect            = rb_intern("inspect");
+  ID_invoke             = rb_intern("invoke");
+  ID_ivar_blocking_mode = rb_intern("@blocking_mode");
+  ID_ivar_io            = rb_intern("@io");
+  ID_ivar_runnable      = rb_intern("@runnable");
+  ID_ivar_running       = rb_intern("@running");
+  ID_ivar_thread        = rb_intern("@thread");
+  ID_new                = rb_intern("new");
+  ID_signal             = rb_intern("signal");
+  ID_size               = rb_intern("size");
+  ID_switch_fiber       = rb_intern("switch_fiber");
+  ID_transfer           = rb_intern("transfer");
 }

data/ext/polyphony/polyphony.h

@@ -47,6 +47,7 @@ extern ID ID_fiber_trace;
 extern ID ID_inspect;
 extern ID ID_invoke;
 extern ID ID_ivar_backend;
+extern ID ID_ivar_blocking_mode;
 extern ID ID_ivar_io;
 extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
@@ -124,6 +125,7 @@ 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 Backend_run_idle_tasks(VALUE self);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);

data/ext/polyphony/thread.c

@@ -88,6 +88,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   unsigned int pending_ops_count = Backend_pending_count(backend);
   unsigned int backend_was_polled = 0;
+  unsigned int idle_tasks_run_count = 0;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
     TRACE(2, SYM_fiber_switchpoint, current_fiber);
@@ -112,6 +113,10 @@ VALUE Thread_switch_fiber(VALUE self) {
       break;
     }
     
+    if (!idle_tasks_run_count) {
+      idle_tasks_run_count++;
+      Backend_run_idle_tasks(backend);
+    }
     if (pending_ops_count == 0) break;
     Backend_poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -281,6 +281,33 @@ class BackendTest < MiniTest::Test
       f.await
     end
   end
+
+  def test_idle_gc
+    GC.disable
+
+    count = GC.count
+    snooze
+    assert_equal count, GC.count
+    sleep 0.01
+    assert_equal count, GC.count
+
+    @backend.idle_gc_period = 0.1
+    snooze
+    assert_equal count, GC.count
+    sleep 0.05
+    assert_equal count, GC.count
+    # The idle tasks are ran at most once per fiber switch, before the backend
+    # is polled. Therefore, the second sleep will not have triggered a GC, since
+    # only 0.05s have passed since the gc period was set.
+    sleep 0.07
+    assert_equal count, GC.count
+    # Upon the third sleep the GC should be triggered, at 0.12s post setting the
+    # GC period.
+    sleep 0.05
+    assert_equal count + 1, GC.count
+  ensure
+    GC.enable
+  end
 end
 
 class BackendChainTest < MiniTest::Test

data/test/test_timer.rb

@@ -48,7 +48,7 @@ class TimerMoveOnAfterTest < MiniTest::Test
     t1 = Time.now
 
     assert_nil v
-    assert_in_range 0.015..0.03, t1 - t0
+    assert_in_range 0.015..0.04, t1 - t0
   end
 end
 
@@ -76,17 +76,17 @@ class TimerCancelAfterTest < MiniTest::Test
 
   def test_timer_cancel_after_with_reset
     buf = []
-    @timer.cancel_after(0.01) do
-      sleep 0.005
+    @timer.cancel_after(0.13) do
+      sleep 0.05
       buf << 1
       @timer.reset
-      sleep 0.005
+      sleep 0.05
       buf << 2
       @timer.reset
-      sleep 0.005
+      sleep 0.05
       buf << 3
       @timer.reset
-      sleep 0.005
+      sleep 0.05
       buf << 4
     end
     assert_equal [1, 2, 3, 4], buf
@@ -158,6 +158,6 @@ class TimerMiscTest < MiniTest::Test
     end
     sleep 0.05
     f.stop
-    assert_in_range 4..6, buffer.size
+    assert_in_range 3..7, buffer.size
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.55.0
+  version: 0.56.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-17 00:00:00.000000000 Z
+date: 2021-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -324,6 +324,7 @@ files:
 - examples/core/erlang-style-genserver.rb
 - examples/core/forking.rb
 - examples/core/handling-signals.rb
+- examples/core/idle_gc.rb
 - examples/core/interrupt.rb
 - examples/core/nested.rb
 - examples/core/pingpong.rb
@@ -355,6 +356,7 @@ files:
 - examples/io/irb.rb
 - examples/io/net-http.rb
 - examples/io/open.rb
+- examples/io/pipe.rb
 - examples/io/pry.rb
 - examples/io/rack_server.rb
 - examples/io/raw.rb
@@ -414,6 +416,7 @@ files:
 - ext/liburing/setup.c
 - ext/liburing/syscall.c
 - ext/liburing/syscall.h
+- ext/polyphony/backend_common.c
 - ext/polyphony/backend_common.h
 - ext/polyphony/backend_io_uring.c
 - ext/polyphony/backend_io_uring_context.c