polyphony 0.52.0 → 0.55.0

data/ext/polyphony/polyphony_ext.c

@@ -6,6 +6,7 @@ void Init_Backend();
 void Init_Queue();
 void Init_Event();
 void Init_Runqueue();
+void Init_SocketExtensions();
 void Init_Thread();
 void Init_Tracing();
 
@@ -24,6 +25,8 @@ void Init_polyphony_ext() {
   Init_Thread();
   Init_Tracing();
 
+  Init_SocketExtensions();
+
   #ifdef POLYPHONY_PLAYGROUND
   playground();
   #endif

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/socket_extensions.c

@@ -0,0 +1,33 @@
+#include "polyphony.h"
+
+VALUE Socket_send(VALUE self, VALUE msg, VALUE flags) {
+  return Backend_send(BACKEND(), self, msg, flags);
+}
+
+VALUE Socket_write(int argc, VALUE *argv, VALUE self) {
+  VALUE ary = rb_ary_new_from_values(argc, argv);
+  VALUE result = Backend_sendv(BACKEND(), self, ary, INT2NUM(0));
+  RB_GC_GUARD(ary);
+  return result;
+}
+
+VALUE Socket_double_chevron(VALUE self, VALUE msg) {
+  Backend_send(BACKEND(), self, msg, INT2NUM(0));
+  return self;
+}
+
+void Init_SocketExtensions() {
+  rb_require("socket");
+
+  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+  VALUE cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+
+  rb_define_method(cSocket, "send", Socket_send, 2);
+  rb_define_method(cTCPSocket, "send", Socket_send, 2);
+
+  rb_define_method(cSocket, "write", Socket_write, -1);
+  rb_define_method(cTCPSocket, "write", Socket_write, -1);
+
+  rb_define_method(cSocket, "<<", Socket_double_chevron, 1);
+  rb_define_method(cTCPSocket, "<<", Socket_double_chevron, 1);
+}

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,7 +86,7 @@ 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;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
@@ -95,14 +95,24 @@ 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 (pending_ops_count == 0) break;
     Backend_poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;
   }
@@ -138,6 +148,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 +164,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/io.rb

@@ -247,4 +247,12 @@ class ::IO
       self
     end
   end
+
+  def splice(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  def splice_to_eof(src, chunksize = 8192)
+    Polyphony.backend_splice_to_eof(src, self, chunksize)
+  end
 end

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)
@@ -48,14 +48,17 @@ class ::Socket
     end
   end
 
-  def send(mesg, flags)
-    Polyphony.backend_send(self, mesg, flags)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
 
-  def write(*args)
-    Polyphony.backend_sendv(self, args, 0)
-  end
-  alias_method :<<, :write
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = +'')
     Polyphony.backend_recv(self, str, maxlen)
@@ -150,26 +153,22 @@ class ::TCPSocket
     Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   end
 
-  def send(mesg, flags)
-    Polyphony.backend_send(self, mesg, flags)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
 
-  def write(*args)
-    Polyphony.backend_sendv(self, args, 0)
-  end
-  alias_method :<<, :write
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
+
+  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
 
@@ -238,19 +237,15 @@ class ::UNIXSocket
   def write(*args)
     Polyphony.backend_sendv(self, args, 0)
   end
-  alias_method :<<, :write
 
-  def readpartial(maxlen, str = nil)
-    @read_buffer ||= +''
-    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
+  def <<(mesg)
+    Polyphony.backend_send(self, mesg, 0)
+  end
+
+  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.52.0'
+  VERSION = '0.55.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
 
@@ -237,4 +237,167 @@ class BackendTest < MiniTest::Test
     end
     assert_equal [1], buffer
   end
+
+  def test_splice
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    spin {
+      len = o2.splice(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foobar')
+    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 {
+      len = o2.splice_to_eof(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foo')
+    result = i2.readpartial(1000)
+    assert_equal 'foo', result
+
+    o1.write('bar')
+    result = i2.readpartial(1000)
+    assert_equal 'bar', result
+    o1.close
+    f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      f.await
+    end
+  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