polyphony 0.54.0 → 0.59

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c88e804739b62a55f7647c57e55582d2ae5cf6a73bca55160aa90138b80217a
-  data.tar.gz: ecbeb0aeed96a7b6f21f8d41b67195574213b8b01b51bccd0f1bcf59165ab9f6
+  metadata.gz: 313e33321df0e375d128a79fccfab98e06183adbdbde7916347f6795f56ca369
+  data.tar.gz: 6428c0516544bdb955fa465bf36c40b9b2f162306f3e5689848ff487f24c4440
 SHA512:
-  metadata.gz: 93ff227cab8891c79bc4447c25359df03cd675ada579d13c5dc09d1f18e42fd00ed1b3ce5e433bd5addf83076af3a45c29cdd49ae8cb2cb9f19892cb27a40476
-  data.tar.gz: 1e1f39c19d2edbd49406c3a3917848951914c48b81316fff6ff78f381fb7db70b407dc5428b94a45292261e202df1c91da5d4e971ab19ba91e7c96e0bbbb91bc
+  metadata.gz: 40c88f5d1c2aa4307dea78dcf1a2ba8d347ef252e7e56e67d466c291066d39544d051864ccd0138dd94ca0beef7af71f5257052b3556ab0c7294b1b94b517d47
+  data.tar.gz: 109410d6b222846b0c2b3f54061358ef922b57c9b6559c37aec36f27116e7ca389ff51762e988e2e9293a7a1358d97b80ada74daa4e44d7d25c1e5335351d8c6

data/.gitignore

@@ -56,4 +56,6 @@ lib/*.bundle
 lib/*.so
 
 _site
-.sass-cache
+.sass-cache
+
+log

data/CHANGELOG.md

@@ -1,4 +1,33 @@
-## 0.54.0
+## 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)
+- Implement `Backend#idle_block=` (#56)
+
+## 0.57.0 2021-06-23
+
+- Implement `Backend#splice_chunks` method for both libev and io_uring backends
+- Improve waiting for readiness in libev `Backend#splice`, `#splice_to_eof`
+- Enable splice op in libev `Backend#chain` for non-Linux OS
+
+## 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
+- Reimplement io_uring op_context acquire/release algorithm (using ref count) 
+- Fix #gets on sockets
+- Redesign event anti-starvation mechanism
+
+## 0.54.0 2021-06-14
 
 - Implement Mutex#owned?, #locked? (#50)
 - Fix arity for SSLSocket#peeraddr (#55)
@@ -6,15 +35,15 @@
 - Fix SSLSocket buffering behaviour
 - Add recv_loop alias for SSLSocket (#54)
 
-## 0.53.2
+## 0.53.2 2021-05-10
 
 - Remove `splice` methods on libev backend on non-Linux OS (#43)
 
-## 0.53.0
+## 0.53.0 2021-04-23
 
 - Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`
 
-## 0.52.0
+## 0.52.0 2021-02-28
 
 - Polyphony is now compatible with Ruby 3.0
 - Add `Backend#sendv` method for sending multiple strings
@@ -24,19 +53,19 @@
 - libev backend: Use` pidfd_open` for Linux 5.3+, otherwise use a libev child watcher
 - Use `:call` as default method in `#feed_loop`
 
-## 0.51.0
+## 0.51.0 2021-02-02
 
 - Implement `IO#feed_loop`, `Socket#feed_loop`
 - Fix error handling in `Process.kill_and_await`
 
-## 0.50.1
+## 0.50.1 2021-01-31
 
 - 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
+## 0.50.0 2021-01-28
 
 - Use `Process::CLOCK_MONOTONIC` in Timer
 - Add `Timer#sleep`, `Timer#after`, `Timer#every`
@@ -44,50 +73,50 @@
 - Add `Thread#fiber_index_of` method
 - Use `Backend#wait_event` in `Fiber#await`
 
-## 0.49.2
+## 0.49.2 2021-01-19
 
 - Fix hang with 100s or more child fibers when terminating
 - Fix double pending_count increment in io_uring backend
 
-## 0.49.1
+## 0.49.1 2021-01-13
 
 - 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
+## 0.49.0 2021-01-11
 
 - Implement `Polyphony::Timer` for performant timeouts
 
-## 0.48.0
+## 0.48.0 2021-01-05
 
 - Implement graceful shutdown
 - Add support for `break` / `StopIteration` in `spin_loop`
 - Fix `IO#gets`, `IO#readpartial`
 
-## 0.47.5.1
+## 0.47.5.1 2020-11-20
 
 - Add missing `Socket#accept_loop` method
 
-## 0.47.5
+## 0.47.5 2020-11-20
 
 - Add `socket_class` argument to `Backend#accept`, `Backend#accept_loop`
 - Fix `#supervise` to stop when all children fibers are done
 
-## 0.47.4
+## 0.47.4 2020-11-14
 
 - Add support for Unix sockets
 
-## 0.47.3
+## 0.47.3 2020-11-12
 
 - Enable I/O in signal handlers (#45)
 - Accept `:interval` argument in `#spin_loop`
 
-## 0.47.2
+## 0.47.2 2020-11-10
 
 - Fix API compatibility between TCPSocket and IO
 
-## 0.47.0
+## 0.47.0 2020-11-10
 
 - Implement `#spin_scope` used for creating blocking fiber scopes 
 - Reimplement `move_on_after`, `cancel_after`, `Timeout.timeout` using
@@ -95,18 +124,18 @@
 - Implement `Backend#timeout` API
 - Implemented capped queues
 
-## 0.46.1
+## 0.46.1 2020-11-04
 
 - Add `TCPServer#accept_loop`, `OpenSSL::SSL::SSLSocket#accept_loop` method
 - Fix compilation error on MacOS (#43)
 - Fix backtrace for `Timeout.timeout`
 - Add `Backend#timer_loop`
 
-## 0.46.0
+## 0.46.0 2020-10-08
 
 - Implement [io_uring backend](https://github.com/digital-fabric/polyphony/pull/44)
 
-## 0.45.5
+## 0.45.5 2020-10-04
 
 - Fix compilation error (#43)
 - Add support for resetting move_on_after, cancel_after timeouts
@@ -115,22 +144,22 @@
 - Schedule parent with priority on uncaught exception
 - Fix race condition in `Mutex#synchronize` (#41)
 
-## 0.45.4
+## 0.45.4 2020-09-06
 
 - Improve signal trapping mechanism
 
-## 0.45.3
+## 0.45.3 2020-09-02
 
 - Don't swallow error in `Process#kill_and_await`
 - Add `Fiber#mailbox` attribute reader
 - Fix bug in `Fiber.await`
 - Implement `IO#getc`, `IO#getbyte`
 
-## 0.45.2
+## 0.45.2 2020-08-03
 
 - Rewrite `Fiber#<<`, `Fiber#await`, `Fiber#receive` in C
 
-## 0.45.1
+## 0.45.1 2020-08-01
 
 - Fix Net::HTTP compatibility
 - Fix fs adapter
@@ -140,7 +169,7 @@
 - Cleanup code
 - Improve support for Ruby 3 keyword args
 
-## 0.45.0
+## 0.45.0 2020-07-29
 
 - Cleanup code
 - Rename `Agent` to `Backend`

data/Gemfile.lock

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

data/TODO.md

@@ -10,9 +10,6 @@
 
 - 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)
-
 - 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)

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/examples/io/splice_chunks.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+i, o = IO.pipe
+
+f = spin do
+  i.read_loop { |data| STDOUT << data }
+end
+
+result = nil
+# File.open(__FILE__, 'r') do |f|
+File.open('../tipi/log', 'r') do |f|
+  result = Thread.current.backend.splice_chunks(
+    f,
+    o,
+    "Content-Type: ruby\n\n",
+    "0\r\n\r\n",
+    ->(len) { "#{len.to_s(16)}\r\n" },
+    "\r\n",
+    16384
+  )
+end
+
+
+o.close
+f.await
+p result: result

data/examples/io/stdio.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts 'Please enter your name:'
+name = gets.chomp
+puts "Hello, #{name}!"

data/ext/polyphony/backend_common.c

@@ -0,0 +1,288 @@
+#include <time.h>
+#include <fcntl.h>
+#include "ruby.h"
+#include "ruby/io.h"
+#include "polyphony.h"
+#include "backend_common.h"
+
+inline void backend_base_initialize(struct Backend_base *base) {
+  runqueue_initialize(&base->runqueue);
+  base->currently_polling = 0;
+  base->pending_count = 0;
+  base->idle_gc_period = 0;
+  base->idle_gc_last_time = 0;
+  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);
+}
+
+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;
+
+  if (SHOULD_TRACE(base) && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
+    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-starve
+      // mechanism is employed, under the following conditions:
+      // - a blocking poll was not yet performed
+      // - there are pending blocking operations
+      // - the runqueue has signalled that a non-blocking poll should be
+      //   performed
+      //   - the run queue length high watermark has reached its threshold (currently 128)
+      //   - the run queue switch counter has reached its threshold (currently 64) 
+      if (!backend_was_polled && pending_ops_count && runqueue_should_poll_nonblocking(&base->runqueue)) {
+        // this prevents event starvation in case the run queue never empties
+        Backend_poll(backend, Qnil);
+      }
+      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, 3, SYM_fiber_schedule, fiber, value);
+  (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);
+}
+
+#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_proc != Qnil)
+    rb_funcall(base->idle_proc, ID_call, 0);
+
+  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();
+}