polyphony 0.53.0 → 0.56.0

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;
@@ -90,6 +91,7 @@ int Runqueue_index_of(VALUE self, VALUE fiber);
 void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
+int Runqueue_should_poll_nonblocking(VALUE self);
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 #define Backend_recv_loop Backend_read_loop
@@ -123,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/runqueue.c

@@ -3,6 +3,8 @@
 
 typedef struct queue {
   runqueue_ring_buffer entries;
+  unsigned int high_watermark;
+  unsigned int switch_count;
 } Runqueue_t;
 
 VALUE cRunqueue = Qnil;
@@ -43,6 +45,8 @@ static VALUE Runqueue_initialize(VALUE self) {
   GetRunqueue(self, runqueue);
 
   runqueue_ring_buffer_init(&runqueue->entries);
+  runqueue->high_watermark = 0;
+  runqueue->switch_count = 0;
 
   return self;
 }
@@ -53,6 +57,8 @@ void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
 
   if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
   runqueue_ring_buffer_push(&runqueue->entries, fiber, value);
+  if (runqueue->entries.count > runqueue->high_watermark)
+    runqueue->high_watermark = runqueue->entries.count;
 }
 
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
@@ -60,12 +66,19 @@ void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
   GetRunqueue(self, runqueue);
   if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
   runqueue_ring_buffer_unshift(&runqueue->entries, fiber, value);
+  if (runqueue->entries.count > runqueue->high_watermark)
+    runqueue->high_watermark = runqueue->entries.count;
 }
 
 runqueue_entry Runqueue_shift(VALUE self) {
   Runqueue_t *runqueue;
   GetRunqueue(self, runqueue);
-  return runqueue_ring_buffer_shift(&runqueue->entries);
+  runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
+  if (entry.fiber == Qnil)
+    runqueue->high_watermark = 0;
+  else
+    runqueue->switch_count += 1;
+  return entry;
 }
 
 void Runqueue_delete(VALUE self, VALUE fiber) {
@@ -100,6 +113,21 @@ int Runqueue_empty_p(VALUE self) {
   return (runqueue->entries.count == 0);
 }
 
+static const unsigned int ANTI_STARVE_HIGH_WATERMARK_THRESHOLD = 128;
+static const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
+
+int Runqueue_should_poll_nonblocking(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
+  if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
+
+  // the 
+  runqueue->switch_count = 0;
+  return 1;
+}
+
 void Init_Runqueue() {
   cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cObject);
   rb_define_alloc_func(cRunqueue, Runqueue_allocate);

data/ext/polyphony/thread.c

@@ -21,7 +21,7 @@ static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
 static VALUE Thread_fiber_scheduling_stats(VALUE self) {
-  VALUE backend = rb_ivar_get(self,ID_ivar_backend);
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   VALUE stats = rb_hash_new();
   VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   long pending_count;
@@ -53,7 +53,7 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
       // 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.
-      VALUE backend = rb_ivar_get(self,ID_ivar_backend);
+      VALUE backend = rb_ivar_get(self, ID_ivar_backend);
       Backend_wakeup(backend);
     }
   }
@@ -86,8 +86,9 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   runqueue_entry next;
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  unsigned int pending_count = Backend_pending_count(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);
@@ -95,14 +96,28 @@ VALUE Thread_switch_fiber(VALUE self) {
   while (1) {
     next = Runqueue_shift(runqueue);
     if (next.fiber != Qnil) {
-      if (!backend_was_polled && pending_count) {
+      // 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(runqueue)) {
         // this prevents event starvation in case the run queue never empties
         Backend_poll(backend, Qtrue, current_fiber, runqueue);
       }
       break;
     }
-    if (pending_count == 0) 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;
   }
@@ -138,6 +153,10 @@ VALUE Thread_debug(VALUE self) {
   return self;
 }
 
+VALUE Thread_class_backend(VALUE _self) {
+  return rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+}
+
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
@@ -150,6 +169,8 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "fiber_scheduling_index", Thread_fiber_scheduling_index, 1);
   rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
+  rb_define_singleton_method(rb_cThread, "backend", Thread_class_backend, 0);
+
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
   ID_deactivate_all_watchers_post_fork  = rb_intern("deactivate_all_watchers_post_fork");

data/lib/polyphony/core/sync.rb

@@ -35,6 +35,14 @@ module Polyphony
       @token = @store.shift
       @holding_fiber = Fiber.current
     end
+
+    def owned?
+      @holding_fiber == Fiber.current
+    end
+
+    def locked?
+      @holding_fiber
+    end
   end
 
   # Implements a fiber-aware ConditionVariable

data/lib/polyphony/extensions/openssl.rb

@@ -3,7 +3,7 @@
 require 'openssl'
 require_relative './socket'
 
-# Open ssl socket helper methods (to make it compatible with Socket API)
+# OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
 class ::OpenSSL::SSL::SSLSocket
   alias_method :orig_initialize, :initialize
   def initialize(socket, context = nil)
@@ -23,22 +23,12 @@ class ::OpenSSL::SSL::SSLSocket
     io.reuse_addr
   end
 
-  alias_method :orig_accept, :accept
-  def accept
-    while true
-      result = accept_nonblock(exception: false)
-      case result
-      when :wait_readable then Polyphony.backend_wait_io(io, false)
-      when :wait_writable then Polyphony.backend_wait_io(io, true)
-      else
-        return result
-      end
-    end
-  end
-
-  def accept_loop
-    while true
-      yield accept
+  def fill_rbuff
+    data = self.sysread(BLOCK_SIZE)
+    if data
+      @rbuffer << data
+    else
+      @eof = true
     end
   end
 
@@ -84,4 +74,21 @@ class ::OpenSSL::SSL::SSLSocket
       yield data
     end
   end
+  alias_method :recv_loop, :read_loop
+
+  alias_method :orig_peeraddr, :peeraddr
+  def peeraddr(_ = nil)
+    orig_peeraddr
+  end
+end
+
+# OpenSSL socket helper methods (to make it compatible with Socket API) and overrides
+class ::OpenSSL::SSL::SSLServer
+  def accept_loop(ignore_errors = true)
+    loop do
+      yield accept
+    rescue SystemCallError, StandardError => e
+      raise e unless ignore_errors
+    end
+  end
 end

data/lib/polyphony/extensions/socket.rb

@@ -36,9 +36,9 @@ class ::Socket
   end
 
   def recvfrom(maxlen, flags = 0)
-    @read_buffer ||= +''
+    buf = +''
     while true
-      result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
+      result = recvfrom_nonblock(maxlen, flags, buf, **NO_EXCEPTION)
       case result
       when nil then raise IOError
       when :wait_readable then Polyphony.backend_wait_io(self, false)
@@ -165,17 +165,10 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  def readpartial(maxlen, str = +'')
+    result = Polyphony.backend_recv(self, str, maxlen)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
     str
   end
 
@@ -249,17 +242,10 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  def readpartial(maxlen, str = +'')
+    result = Polyphony.backend_recv(self, str, maxlen)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
     str
   end
 

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -37,6 +37,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'mysql2',               '0.5.3'
   s.add_development_dependency  'sequel',               '5.34.0'
   s.add_development_dependency  'httparty',             '0.17.1'
+  s.add_development_dependency  'localhost',            '~>1.1.4'
 
   # s.add_development_dependency  'jekyll',               '~>3.8.6'
   # s.add_development_dependency  'jekyll-remote-theme',  '~>0.4.1'

data/test/helper.rb

@@ -15,9 +15,9 @@ require 'minitest/reporters'
 
 ::Exception.__disable_sanitized_backtrace__ = true
 
-Minitest::Reporters.use! [
-  Minitest::Reporters::SpecReporter.new
-]
+# Minitest::Reporters.use! [
+#   Minitest::Reporters::SpecReporter.new
+# ]
 
 class ::Fiber
   attr_writer :auto_watcher

data/test/test_backend.rb

@@ -26,7 +26,7 @@ class BackendTest < MiniTest::Test
       @backend.sleep 0.01
       count += 1
     }.await
-    assert_in_delta 0.03, Time.now - t0, 0.005
+    assert_in_delta 0.03, Time.now - t0, 0.01
     assert_equal 3, count
   end
 
@@ -241,9 +241,10 @@ class BackendTest < MiniTest::Test
   def test_splice
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe
+    len = nil
 
     spin {
-      o2.splice(i1, 1000)
+      len = o2.splice(i1, 1000)
       o2.close
     }
 
@@ -251,14 +252,16 @@ class BackendTest < MiniTest::Test
     result = i2.read
 
     assert_equal 'foobar', result
+    assert_equal 6, len
   end
 
   def test_splice_to_eof
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe
+    len = nil
 
     f = spin {
-      o2.splice_to_eof(i1, 1000)
+      len = o2.splice_to_eof(i1, 1000)
       o2.close
     }
 
@@ -269,8 +272,159 @@ class BackendTest < MiniTest::Test
     o1.write('bar')
     result = i2.readpartial(1000)
     assert_equal 'bar', result
-  ensure
-    f.interrupt
+    o1.close
     f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      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
+  def setup
+    super
+    @prev_backend = Thread.current.backend
+    @backend = Polyphony::Backend.new
+    Thread.current.backend = @backend
+  end
+
+  def teardown
+    @backend.finalize
+    Thread.current.backend = @prev_backend
+  end
+
+  def test_simple_write_chain
+    i, o = IO.pipe
+
+    result = Thread.backend.chain(
+      [:write, o, 'hello'],
+      [:write, o, ' world']
+    )
+
+    assert_equal 6, result
+    o.close
+    assert_equal 'hello world', i.read
+  end
+
+  def test_simple_send_chain
+    port = rand(1234..5678)
+    server = TCPServer.new('127.0.0.1', port)
+
+    server_fiber = spin do
+      while (socket = server.accept)
+        spin do
+          while (data = socket.gets(8192))
+            socket << data
+          end
+        end
+      end
+    end
+
+    snooze
+    client = TCPSocket.new('127.0.0.1', port)
+    
+    result = Thread.backend.chain(
+      [:send, client, 'hello', 0],
+      [:send, client, " world\n", 0]
+    )
+    sleep 0.1
+    assert_equal "hello world\n", client.recv(8192)
+    client.close
+  ensure
+    server_fiber&.stop
+    server_fiber&.await
+    server&.close
+  end
+
+  def chunk_header(len)
+    "Content-Length: #{len}\r\n\r\n"
+  end
+
+  def serve_io(from, to)
+    i, o = IO.pipe
+    backend = Thread.current.backend
+    while true
+      len = o.splice(from, 8192)
+      break if len == 0
+      
+      backend.chain(
+        [:write, to, chunk_header(len)],
+        [:splice, i, to, len]
+      )
+    end
+    to.close
+  end
+
+  def test_chain_with_splice
+    from_r, from_w = IO.pipe
+    to_r, to_w = IO.pipe
+
+    result = nil
+    f = spin { serve_io(from_r, to_w) }
+
+    from_w << 'Hello world!'
+    from_w.close
+
+    assert_equal "Content-Length: 12\r\n\r\nHello world!", to_r.read
+  end
+
+  def test_invalid_op
+    i, o = IO.pipe
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:read, i]
+      )
+    }
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:write, o, 'abc'],
+        [:write, o, 'abc'],
+        [:write, o, 'abc'],
+        [:read, i]
+      )
+    }
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:write, o]
+      )
+    }
+
+    # Eventually we should add some APIs to the io_uring backend to query the
+    # contxt store, then add some tests here to verify that the chain op ctx is
+    # released properly before raising the error (for the time being this has
+    # been verified manually).
   end
 end