polyphony 0.55.0 → 0.59.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0f6698a072e4ba2913477d20f5884d5d7579b99cca1db0f2ffa3aeca42ebcc
-  data.tar.gz: 97fec9986f6693d685bfb0c1745995c8a85413a9b6cc1a1ff69393d55a5f3b74
+  metadata.gz: 3aba9d551e940893d6d3303d93d514b520b7b649a1db99b101bdbbcdec762501
+  data.tar.gz: 601d33709dc92bb0c029d9dba5d555441a2b5a6721b807185a36d65cb5ef8170
 SHA512:
-  metadata.gz: 053beffc7c27658d129002b5efc29f64c7fcf1ff7fbf3f2eea1d588b2a9e40e89251640bf9bb82ce478837f38c32863987d8ac0af987d374d4ac242d012363dd
-  data.tar.gz: e89df4044f09f4df64fc57622f22e70d932f2f09ea3b2a5c2090698784c286367df43d352231068b8ef96d6a7ba89e5492b4c237c9960aeb5fa79af9ee738768
+  metadata.gz: 2a7e355b5f8857093082d75759942f5d3a63ab40cf3a0f46045829e2c223ae92dbcc370ceb2dd3f26bd04e0bb036eb03ab40ef65a011cd172dd6c122698541fa
+  data.tar.gz: e8708853190d44c82f3088ba0baecf19f03110a11c2cf229f0015c800b23da01e1eb0d94af20cb2af7fd8dd7bdafde9bf218f484c57cda358c0da187dfeb4b6e

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 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)
+- 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.55.0)
+    polyphony (0.59.1)
 
 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/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/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();
+}

data/ext/polyphony/backend_common.h

@@ -1,17 +1,42 @@
-#include <time.h>
+#ifndef BACKEND_COMMON_H
+#define BACKEND_COMMON_H
 
 #include "ruby.h"
 #include "ruby/io.h"
+#include "runqueue.h"
 
+struct backend_stats {
+  int scheduled_fibers;
+  int waiting_fibers;
+  int pending_ops;
+};
 
-#ifdef POLYPHONY_USE_PIDFD_OPEN
-#ifndef __NR_pidfd_open
-#define __NR_pidfd_open 434   /* System call # on most architectures */
-#endif
+struct Backend_base {
+  runqueue_t runqueue;
+  unsigned int currently_polling;
+  unsigned int pending_count;
+  double idle_gc_period;
+  double idle_gc_last_time;
+  VALUE idle_proc;
+  VALUE trace_proc;
+};
 
-static int pidfd_open(pid_t pid, unsigned int flags) {
-  return syscall(__NR_pidfd_open, pid, flags);
-}
+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);
+
+// 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);
 #endif
 
 //////////////////////////////////////////////////////////////////////
@@ -26,75 +51,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 +86,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 */