polyphony 0.57.0 → 0.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e350937221c476548465a2881e64689042137eab59571a0940f63236a249563f
-  data.tar.gz: 14870d9e38e7aa9f300d09cdfa0693929edb59756e0d17e7b3e7ae2d4a9dab0d
+  metadata.gz: e8002b8c0e03afa8e915b5ed67d64c1fc288a5fa220dfb2c32d3966a78046eee
+  data.tar.gz: c3a46eeae1f048f4adee9d3130f5dd3593936e843c1874d928f742d1fa83053f
 SHA512:
-  metadata.gz: 8087b84c7a583c8f3905c20d06aa4ad119fd2901be2594e66f56b577c1fa141f9e203971aedd27ad7c57b9c184adad1b97d0fbe4024702bfe3ef6bdaa861ac92
-  data.tar.gz: 6943231ef2b29dac3e33cfee865dbc6b3b35549c62e04dd1ed08d40fbd90a5c179417baf3b27b965e80c3ee7e137cbe167be9e8187dff46d89892978beb8a40d
+  metadata.gz: e6681155761daee35b73c9674e69aa505786e576814db0c909028cb576d8609f99bccc79f80b7d06d90c7658747bc2589c9837d3bdb3419782147e573d39f278
+  data.tar.gz: 90197a8db54405ca37492a54a20adf00c85f142af606cad26ad823161825ccf6bd9a414adcbbf3e27eaf93eea1d94a7cbc50a2fb5982ee4ce48969d4378400cd

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.58 2021-06-25
+
+- Implement `Thread#idle_gc_period`, `#on_idle` (#56)
+- Implement `Backend#idle_block=` (#56)
+
 ## 0.57.0 2021-06-23
 
 - Implement `Backend#splice_chunks` method for both libev and io_uring backends

data/Gemfile.lock

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

data/ext/polyphony/backend_common.c

@@ -5,6 +5,14 @@
 #include "polyphony.h"
 #include "backend_common.h"
 
+inline void initialize_backend_base(struct Backend_base *base) {
+  base->currently_polling = 0;
+  base->pending_count = 0;
+  base->idle_gc_period = 0;
+  base->idle_gc_last_time = 0;
+  base->idle_block = Qnil;
+}
+
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 #ifndef __NR_pidfd_open
 #define __NR_pidfd_open 434   /* System call # on most architectures */
@@ -174,6 +182,9 @@ inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
 }
 
 inline void backend_run_idle_tasks(struct Backend_base *base) {
+  if (base->idle_block != Qnil)
+    rb_funcall(base->idle_block, ID_call, 0);
+
   if (base->idle_gc_period == 0) return;
 
   double now = current_time();

data/ext/polyphony/backend_common.h

@@ -9,8 +9,11 @@ struct Backend_base {
   unsigned int pending_count;
   double idle_gc_period;
   double idle_gc_last_time;
+  VALUE idle_block;
 };
 
+void initialize_backend_base(struct Backend_base *base);
+
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 int pidfd_open(pid_t pid, unsigned int flags);
 #endif

data/ext/polyphony/backend_io_uring.c

@@ -42,13 +42,19 @@ typedef struct Backend_t {
   int                 event_fd;
 } Backend_t;
 
+static void Backend_mark(void *ptr) {
+  Backend_t *backend = ptr;
+  if (backend->base.idle_block != Qnil)
+    rb_gc_mark(backend->base.idle_block);
+}
+
 static size_t Backend_size(const void *ptr) {
   return sizeof(Backend_t);
 }
 
 static const rb_data_type_t Backend_type = {
     "IOUringBackend",
-    {0, 0, Backend_size,},
+    {Backend_mark, 0, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -65,11 +71,7 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->base.currently_polling = 0;
-  backend->base.pending_count = 0;
-  backend->base.idle_gc_period = 0;
-  backend->base.idle_gc_last_time = 0;
-
+  initialize_backend_base(&backend->base);
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -134,6 +136,7 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   op_context_t *ctx = io_uring_cqe_get_data(cqe);
   if (!ctx) return;
 
+  // printf("cqe ctx %p id: %d result: %d (%s, ref_count: %d)\n", ctx, ctx->id, cqe->res, op_type_to_str(ctx->type), ctx->ref_count);
   ctx->result = cqe->res;
   if (ctx->ref_count == 2 && ctx->result != -ECANCELED && ctx->fiber)
     Fiber_make_runnable(ctx->fiber, ctx->resume_value);
@@ -908,7 +911,6 @@ int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duratio
   
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
-
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
   return context_store_release(&backend->store, ctx);
 }
@@ -1185,6 +1187,13 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
+VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_block = block;
+  return self;
+}
+
 inline VALUE Backend_run_idle_tasks(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1359,6 +1368,7 @@ void Init_Backend() {
   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, "idle_block=", Backend_idle_block_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);

data/ext/polyphony/backend_io_uring_context.c

@@ -37,8 +37,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
     ctx = malloc(sizeof(op_context_t));
   }
   ctx->id = (++store->last_id);
-  // printf("acquire %d (%s)\n", ctx->id, op_type_to_str(type));
-  
+  // printf("acquire %p %d (%s)\n", ctx, ctx->id, op_type_to_str(type));
   ctx->prev = NULL;
   ctx->next = store->taken;
   if (store->taken) store->taken->prev = ctx;
@@ -55,7 +54,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
 
 // returns true if ctx was released
 inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
-  // printf("release %d (%s, ref_count: %d)\n", ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
+  // printf("release %p %d (%s, ref_count: %d)\n", ctx, ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
 
   assert(ctx->ref_count);
   

data/ext/polyphony/backend_libev.c

@@ -73,13 +73,19 @@ typedef struct Backend_t {
   struct ev_async break_async;
 } Backend_t;
 
+static void Backend_mark(void *ptr) {
+  Backend_t *backend = ptr;
+  if (backend->base.idle_block != Qnil)
+    rb_gc_mark(backend->base.idle_block);
+}
+
 static size_t Backend_size(const void *ptr) {
   return sizeof(Backend_t);
 }
 
 static const rb_data_type_t Backend_type = {
     "LibevBackend",
-    {0, 0, Backend_size,},
+    {Backend_mark, 0, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -110,6 +116,8 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   
   GetBackend(self, backend);
+
+  initialize_backend_base(&backend->base);
   backend->ev_loop = libev_new_loop();
 
   // start async watcher used for breaking a poll op (from another thread)
@@ -119,11 +127,6 @@ static VALUE Backend_initialize(VALUE self) {
   // block when no other watcher is active
   ev_unref(backend->ev_loop);
 
-  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;
 }
 
@@ -1290,6 +1293,13 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
+VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_block = block;
+  return self;
+}
+
 inline VALUE Backend_run_idle_tasks(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1448,6 +1458,7 @@ void Init_Backend() {
   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, "idle_block=", Backend_idle_block_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);

data/lib/polyphony/extensions/thread.rb

@@ -105,4 +105,12 @@ class ::Thread
     main_fiber << value
   end
   alias_method :send, :<<
+
+  def idle_gc_period=(period)
+    backend.idle_gc_period = period
+  end
+
+  def on_idle(&block)
+    backend.idle_block = block
+  end
 end

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -340,9 +340,38 @@ class BackendTest < MiniTest::Test
     # GC period.
     sleep 0.05
     assert_equal count + 1, GC.count
+
+    @backend.idle_gc_period = 0
+    count = GC.count
+    sleep 0.001
+    sleep 0.002
+    sleep 0.003
+    assert_equal count, GC.count
   ensure
     GC.enable
   end
+
+  def test_idle_block
+    counter = 0
+
+    @backend.idle_block = proc { counter += 1 }
+    
+    3.times { snooze }
+    assert_equal 0, counter
+
+    sleep 0.01
+    assert_equal 1, counter
+    sleep 0.01
+    assert_equal 2, counter
+
+    assert_equal 2, counter
+    3.times { snooze }
+    assert_equal 2, counter
+
+    @backend.idle_block = nil
+    sleep 0.01
+    assert_equal 2, counter
+  end
 end
 
 class BackendChainTest < MiniTest::Test

data/test/test_thread.rb

@@ -171,4 +171,56 @@ class ThreadTest < MiniTest::Test
     t&.kill
     t&.join
   end
+
+  def test_idle_gc
+    GC.disable
+
+    count = GC.count
+    snooze
+    assert_equal count, GC.count
+    sleep 0.01
+    assert_equal count, GC.count
+
+    Thread.current.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
+
+    Thread.current.idle_gc_period = 0
+    count = GC.count
+    sleep 0.001
+    sleep 0.002
+    sleep 0.003
+    assert_equal count, GC.count
+  ensure
+    GC.enable
+  end
+
+  def test_on_idle
+    counter = 0
+
+    Thread.current.on_idle { counter += 1 }
+    
+    3.times { snooze }
+    assert_equal 0, counter
+
+    sleep 0.01
+    assert_equal 1, counter
+    sleep 0.01
+    assert_equal 2, counter
+
+    assert_equal 2, counter
+    3.times { snooze }
+    assert_equal 2, counter
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.57.0
+  version: '0.58'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-23 00:00:00.000000000 Z
+date: 2021-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler