polyphony 0.58 → 0.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8002b8c0e03afa8e915b5ed67d64c1fc288a5fa220dfb2c32d3966a78046eee
-  data.tar.gz: c3a46eeae1f048f4adee9d3130f5dd3593936e843c1874d928f742d1fa83053f
+  metadata.gz: b7056ec954b2264a15f88934d2b1e65f53c76c301453851ceadf60715570e474
+  data.tar.gz: 1cd5835b7a5a3d4036e1eabf45ded2e09efdc7cacb207fc0a1a60ac67da02d90
 SHA512:
-  metadata.gz: e6681155761daee35b73c9674e69aa505786e576814db0c909028cb576d8609f99bccc79f80b7d06d90c7658747bc2589c9837d3bdb3419782147e573d39f278
-  data.tar.gz: 90197a8db54405ca37492a54a20adf00c85f142af606cad26ad823161825ccf6bd9a414adcbbf3e27eaf93eea1d94a7cbc50a2fb5982ee4ce48969d4378400cd
+  metadata.gz: b5e32edc6bc22ba580e7c6d7d42a73982803080e9a9782326cb7b8796aa62ad6b75bccb1e6607879f0d3e5a5c4db8e5597d8407b76014f08f3945d1d8ad0097a
+  data.tar.gz: b8fe0f9419061295f830ed12ae9c8ea089a966686388cff580ddb6e1f7cd8c17a04928f9af41083019a5a11e8cccce25af404959db30a730a2ade2359a7e07ef

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.61 2021-07-20
+
+- Add more statistics, move stats to `Backend#stats`
+
+## 0.60 2021-07-15
+
+
+- Fix linux version detection (for kernel version > 5.9)
+- Fix op ctx leak in io_uring backend (when polling for I/O readiness)
+- Add support for appending to buffer in `Backend#read`, `Backend#recv` methods
+- Improve anti-event starvation mechanism
+- Redesign fiber monitoring mechanism
+- Implement `Fiber#attach`
+- Add optional maxlen argument to `IO#read_loop`, `Socket#recv_loop` (#60)
+- Implement `Fiber#detach` (#52)
+
+## 0.59.1 2021-06-28
+
+- Accept fiber tag in `Polyphony::Timer.new`
+
+## 0.59 2021-06-28
+
+- Redesign tracing mechanism and API - now completely separated from Ruby core
+  trace API
+- Refactor C code - move run queue into backend
+
 ## 0.58 2021-06-25
 
 - Implement `Thread#idle_gc_period`, `#on_idle` (#56)

data/Gemfile.lock

@@ -1,27 +1,25 @@
 PATH
   remote: .
   specs:
-    polyphony (0.58)
+    polyphony (0.61)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ansi (1.5.0)
-    ast (2.4.0)
+    ast (2.4.2)
     builder (3.2.4)
     coderay (1.1.3)
-    docile (1.3.2)
-    hiredis (0.6.3)
-    http_parser.rb (0.6.0)
+    docile (1.4.0)
     httparty (0.17.1)
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
-    json (2.3.0)
+    json (2.5.1)
     localhost (1.1.8)
     method_source (1.0.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2020.0512)
+    mime-types-data (3.2021.0704)
     minitest (5.14.4)
     minitest-reporters (1.4.2)
       ansi
@@ -30,22 +28,18 @@ GEM
       ruby-progressbar
     msgpack (1.4.2)
     multi_xml (0.6.0)
-    mysql2 (0.5.3)
-    parallel (1.19.1)
-    parser (2.7.0.2)
-      ast (~> 2.4.0)
-    pg (1.1.4)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rack (2.2.3)
     rainbow (3.0.0)
-    rake (13.0.3)
+    rake (13.0.6)
     rake-compiler (1.1.1)
       rake
-    redis (4.1.0)
-    regexp_parser (1.7.1)
-    rexml (3.2.4)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
     rubocop (0.85.1)
       parallel (~> 1.10)
       parser (>= 2.7.0.1)
@@ -55,37 +49,29 @@ GEM
       rubocop-ast (>= 0.0.3)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (0.0.3)
-      parser (>= 2.7.0.1)
-    ruby-progressbar (1.10.1)
-    sequel (5.34.0)
+    rubocop-ast (1.8.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
     simplecov (0.17.1)
       docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
-    unicode-display_width (1.6.1)
+    unicode-display_width (1.7.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  hiredis (= 0.6.3)
-  http_parser.rb (~> 0.6.0)
   httparty (= 0.17.1)
   localhost (~> 1.1.4)
   minitest (= 5.14.4)
   minitest-reporters (= 1.4.2)
   msgpack (= 1.4.2)
-  mysql2 (= 0.5.3)
-  pg (= 1.1.4)
   polyphony!
   pry (= 0.13.1)
-  rack (>= 2.0.8, < 2.3.0)
   rake-compiler (= 1.1.1)
-  redis (= 4.1.0)
   rubocop (= 0.85.1)
-  sequel (= 5.34.0)
   simplecov (= 0.17.1)
 
 BUNDLED WITH

data/examples/core/message_based_supervision.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+class Supervisor
+  def initialize(*fibers)
+    @fiber = spin { do_supervise }
+    @fiber.message_on_child_termination = true
+    fibers.each { |f| add(f) }
+  end
+
+  def await
+    @fiber.await
+  end
+
+  def spin(tag = nil, &block)
+    @fiber.spin(tag, &block)
+  end
+
+  def add(fiber)
+    fiber.attach(@fiber)
+  end
+
+  def do_supervise
+    loop do
+      msg = receive
+      # puts "Supervisor received #{msg.inspect}"
+      f, r = msg
+      puts "Fiber #{f.tag} terminated with #{r.inspect}, restarting..."
+      f.restart
+    end
+  end
+end
+
+def supervise(*fibers)
+  supervisor = Supervisor.new(*fibers)
+  supervisor.await
+end
+
+def start_worker(id)
+  spin_loop(:"worker#{id}") do
+    duration = rand(0.5..1.0)
+    puts "Worker #{id} sleeping for #{duration} seconds"
+    sleep duration
+    raise 'foo' if rand > 0.7
+    break if rand > 0.6
+  end  
+end
+
+supervise(start_worker(1), start_worker(2))

data/examples/io/echo_server.rb

@@ -3,16 +3,25 @@
 require 'bundler/setup'
 require 'polyphony'
 
+spin_loop(interval: 5) { p Thread.backend.stats }
+
 server = TCPServer.open('127.0.0.1', 1234)
 puts "Pid: #{Process.pid}"
 puts 'Echoing on port 1234...'
-while (client = server.accept)
-  spin do
-    while (data = client.gets)
-      # client.send("you said: #{data.chomp}!\n", 0)
-      client.write('you said: ', data.chomp, "!\n")
+begin
+  while (client = server.accept)
+    spin do
+      while (data = client.gets)
+        # client.send("you said: #{data.chomp}!\n", 0)
+        client.write('you said: ', data.chomp, "!\n")
+      end
+    rescue Errno::ECONNRESET
+      'Connection reset...'
+    ensure
+      client.shutdown
+      client.close
     end
-  rescue Errno::ECONNRESET
-    'Connection reset...'
   end
+ensure
+  server.close
 end

data/ext/polyphony/backend_common.c

@@ -5,12 +5,127 @@
 #include "polyphony.h"
 #include "backend_common.h"
 
-inline void initialize_backend_base(struct Backend_base *base) {
+inline void backend_base_initialize(struct Backend_base *base) {
+  runqueue_initialize(&base->runqueue);
   base->currently_polling = 0;
+  base->op_count = 0;
+  base->switch_count = 0;
+  base->poll_count = 0;
   base->pending_count = 0;
   base->idle_gc_period = 0;
   base->idle_gc_last_time = 0;
-  base->idle_block = Qnil;
+  base->idle_proc = Qnil;
+  base->trace_proc = Qnil;
+}
+
+inline void backend_base_finalize(struct Backend_base *base) {
+  runqueue_finalize(&base->runqueue);
+}
+
+inline void backend_base_mark(struct Backend_base *base) {
+  if (base->idle_proc != Qnil) rb_gc_mark(base->idle_proc);
+  if (base->trace_proc != Qnil) rb_gc_mark(base->trace_proc);
+  runqueue_mark(&base->runqueue);
+}
+
+const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
+
+inline void conditional_nonblocking_poll(VALUE backend, struct Backend_base *base, VALUE current, VALUE next) {
+  if ((base->switch_count % ANTI_STARVE_SWITCH_COUNT_THRESHOLD) == 0 || next == current) 
+    Backend_poll(backend, Qnil);
+}
+
+VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
+  VALUE current_fiber = rb_fiber_current();
+  runqueue_entry next;
+  unsigned int pending_ops_count = base->pending_count;
+  unsigned int backend_was_polled = 0;
+  unsigned int idle_tasks_run_count = 0;
+  
+  base->switch_count++;
+  COND_TRACE(base, 2, SYM_fiber_switchpoint, current_fiber);
+
+  while (1) {
+    next = runqueue_shift(&base->runqueue);
+    if (next.fiber != Qnil) {
+      // Polling for I/O op completion is normally done when the run queue is
+      // empty, but if the runqueue never empties, we'll never get to process
+      // any event completions. In order to prevent this, an anti-starvation
+      // mechanism is employed, under the following conditions:
+      // - a blocking poll was not yet performed
+      // - there are pending blocking operations
+      // - the runqueue shift count has reached a fixed threshold (currently 64), or
+      // - the next fiber is the same as the current fiber (a single fiber is snoozing)
+      if (!backend_was_polled && pending_ops_count)
+        conditional_nonblocking_poll(backend, base, current_fiber, next.fiber);
+
+      break;
+    }
+    
+    if (!idle_tasks_run_count) {
+      idle_tasks_run_count++;
+      backend_run_idle_tasks(base);
+    }
+    if (pending_ops_count == 0) break;
+    Backend_poll(backend, Qtrue);
+    backend_was_polled = 1;
+  }
+
+  if (next.fiber == Qnil) return Qnil;
+
+  // run next fiber
+  COND_TRACE(base, 3, SYM_fiber_run, next.fiber, next.value);
+
+  rb_ivar_set(next.fiber, ID_ivar_runnable, Qnil);
+  RB_GC_GUARD(next.fiber);
+  RB_GC_GUARD(next.value);
+  return (next.fiber == current_fiber) ?
+    next.value : FIBER_TRANSFER(next.fiber, next.value);
+}
+
+void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_base *base, VALUE fiber, VALUE value, int prioritize) {
+  int already_runnable;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return;
+  already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
+
+  COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
+
+  (prioritize ? runqueue_unshift : runqueue_push)(&base->runqueue, fiber, value, already_runnable);
+  if (!already_runnable) {
+    rb_ivar_set(fiber, ID_ivar_runnable, Qtrue);
+    if (rb_thread_current() != thread) {
+      // If the fiber scheduling is done across threads, we need to make sure the
+      // target thread is woken up in case it is in the middle of running its
+      // event selector. Otherwise it's gonna be stuck waiting for an event to
+      // happen, not knowing that it there's already a fiber ready to run in its
+      // run queue.
+      Backend_wakeup(backend);
+    }
+  }
+}
+
+
+inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
+  if (base->trace_proc == Qnil) return;
+
+  rb_funcallv(base->trace_proc, ID_call, argc, argv);
+}
+
+inline struct backend_stats backend_base_stats(struct Backend_base *base) {
+  struct backend_stats stats = {
+    .runqueue_length = runqueue_len(&base->runqueue),
+    .runqueue_max_length = runqueue_max_len(&base->runqueue),
+    .op_count = base->op_count,
+    .switch_count = base->switch_count,
+    .poll_count = base->poll_count,
+    .pending_ops = base->pending_count
+  };
+
+  base->op_count = 0;
+  base->switch_count = 0;
+  base->poll_count = 0;
+  return stats;
 }
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
@@ -80,7 +195,7 @@ inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-VALUE backend_await(struct Backend_base *backend) {
+inline VALUE backend_await(struct Backend_base *backend) {
   VALUE ret;
   backend->pending_count++;
   ret = Thread_switch_fiber(rb_thread_current());
@@ -89,9 +204,10 @@ VALUE backend_await(struct Backend_base *backend) {
   return ret;
 }
 
-VALUE backend_snooze() {
+inline VALUE backend_snooze() {
+  VALUE ret;
   Fiber_make_runnable(rb_fiber_current(), Qnil);
-  VALUE ret = Thread_switch_fiber(rb_thread_current());
+  ret = Thread_switch_fiber(rb_thread_current());
   return ret;
 }
 
@@ -182,8 +298,8 @@ 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_proc != Qnil)
+    rb_funcall(base->idle_proc, ID_call, 0);
 
   if (base->idle_gc_period == 0) return;
 
@@ -195,3 +311,40 @@ inline void backend_run_idle_tasks(struct Backend_base *base) {
   rb_gc_start();
   rb_gc_disable();
 }
+
+VALUE SYM_runqueue_length;
+VALUE SYM_runqueue_max_length;
+VALUE SYM_op_count;
+VALUE SYM_switch_count;
+VALUE SYM_poll_count;
+VALUE SYM_pending_ops;
+
+VALUE Backend_stats(VALUE self) {
+  struct backend_stats backend_stats = backend_get_stats(self);
+
+  VALUE stats = rb_hash_new();
+  rb_hash_aset(stats, SYM_runqueue_length, INT2NUM(backend_stats.runqueue_length));
+  rb_hash_aset(stats, SYM_runqueue_max_length, INT2NUM(backend_stats.runqueue_max_length));
+  rb_hash_aset(stats, SYM_op_count, INT2NUM(backend_stats.op_count));
+  rb_hash_aset(stats, SYM_switch_count, INT2NUM(backend_stats.switch_count));
+  rb_hash_aset(stats, SYM_poll_count, INT2NUM(backend_stats.poll_count));
+  rb_hash_aset(stats, SYM_pending_ops, INT2NUM(backend_stats.pending_ops));
+  RB_GC_GUARD(stats);
+  return stats;
+}
+
+void backend_setup_stats_symbols() {
+  SYM_runqueue_length = ID2SYM(rb_intern("runqueue_length"));
+  SYM_runqueue_max_length = ID2SYM(rb_intern("runqueue_max_length"));
+  SYM_op_count = ID2SYM(rb_intern("op_count"));
+  SYM_switch_count = ID2SYM(rb_intern("switch_count"));
+  SYM_poll_count = ID2SYM(rb_intern("poll_count"));
+  SYM_pending_ops = ID2SYM(rb_intern("pending_ops"));
+  
+  rb_global_variable(&SYM_runqueue_length);
+  rb_global_variable(&SYM_runqueue_max_length);
+  rb_global_variable(&SYM_op_count);
+  rb_global_variable(&SYM_switch_count);
+  rb_global_variable(&SYM_poll_count);
+  rb_global_variable(&SYM_pending_ops);
+}

data/ext/polyphony/backend_common.h

@@ -3,16 +3,44 @@
 
 #include "ruby.h"
 #include "ruby/io.h"
+#include "runqueue.h"
+
+struct backend_stats {
+  unsigned int runqueue_length;
+  unsigned int runqueue_max_length;
+  unsigned int op_count;
+  unsigned int switch_count;
+  unsigned int poll_count;
+  unsigned int pending_ops;
+};
 
 struct Backend_base {
+  runqueue_t runqueue;
   unsigned int currently_polling;
+  unsigned int op_count;
+  unsigned int switch_count;
+  unsigned int poll_count;
   unsigned int pending_count;
   double idle_gc_period;
   double idle_gc_last_time;
-  VALUE idle_block;
+  VALUE idle_proc;
+  VALUE trace_proc;
 };
 
-void initialize_backend_base(struct Backend_base *base);
+void backend_base_initialize(struct Backend_base *base);
+void backend_base_finalize(struct Backend_base *base);
+void backend_base_mark(struct Backend_base *base);
+VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base);
+void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_base *base, VALUE fiber, VALUE value, int prioritize);
+void backend_trace(struct Backend_base *base, int argc, VALUE *argv);
+struct backend_stats backend_base_stats(struct Backend_base *base);
+
+// tracing
+#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil)
+#define TRACE(base, ...)  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__)
+#define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
+
+
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 int pidfd_open(pid_t pid, unsigned int flags);
@@ -39,6 +67,7 @@ VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
+struct backend_stats backend_get_stats(VALUE self);
 VALUE backend_await(struct Backend_base *backend);
 VALUE backend_snooze();
 
@@ -71,7 +100,10 @@ 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);
+VALUE Backend_stats(VALUE self);
 void backend_run_idle_tasks(struct Backend_base *base);
 void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking);
 
+void backend_setup_stats_symbols();
+
 #endif /* BACKEND_COMMON_H */