polyphony 0.72 → 0.75

data/ext/polyphony/backend_io_uring_context.c

@@ -17,6 +17,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_ACCEPT: return "ACCEPT";
   case OP_CONNECT: return "CONNECT";
   case OP_CHAIN: return "CHAIN";
+  case OP_CLOSE: return "CLOSE";
   default: return "";
   };
 }

data/ext/polyphony/backend_io_uring_context.h

@@ -15,7 +15,8 @@ enum op_type {
   OP_POLL,
   OP_ACCEPT,
   OP_CONNECT,
-  OP_CHAIN
+  OP_CHAIN,
+  OP_CLOSE
 };
 
 typedef struct op_context {

data/ext/polyphony/backend_libev.c

@@ -287,7 +287,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
-  OBJ_TAINT(str);
 
   while (1) {
     backend->base.op_count++;
@@ -698,10 +697,13 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
-  struct sockaddr_in addr;
-  char *host_buf = StringValueCStr(host);
+  struct sockaddr *ai_addr;
+  int ai_addrlen;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
+
+  ai_addrlen = backend_getaddrinfo(host, port, &ai_addr);
+
   if (underlying_sock != Qnil) sock = underlying_sock;
 
   GetBackend(self, backend);
@@ -709,12 +711,8 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   io_verify_blocking_mode(fptr, sock, Qfalse);
   watcher.fiber = Qnil;
 
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = inet_addr(host_buf);
-  addr.sin_port = htons(NUM2INT(port));
-
   backend->base.op_count++;
-  int result = connect(fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
+  int result = connect(fptr->fd, ai_addr, ai_addrlen);
   if (result < 0) {
     int e = errno;
     if (e != EINPROGRESS) rb_syserr_fail(e, strerror(e));
@@ -1147,33 +1145,39 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
 noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   Backend_t *backend;
   struct libev_timer watcher;
-  double interval_d = NUM2DBL(interval);
-
-  GetBackend(self, backend);
   watcher.fiber = rb_fiber_current();
+  uint64_t interval_ns = NUM2DBL(interval) * 1e9;
+  uint64_t next_time_ns = 0;
+  VALUE resume_value = Qnil;
 
-  double next_time = 0.;
+  GetBackend(self, backend);
 
   while (1) {
-    double now = current_time();
-    if (next_time == 0.) next_time = current_time() + interval_d;
-    double sleep_duration = next_time - now;
-    if (sleep_duration < 0) sleep_duration = 0;
-
-    VALUE switchpoint_result = Qnil;
-    ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
-    ev_timer_start(backend->ev_loop, &watcher.timer);
-    backend->base.op_count++;
-    switchpoint_result = backend_await((struct Backend_base *)backend);
-    ev_timer_stop(backend->ev_loop, &watcher.timer);
-    RAISE_IF_EXCEPTION(switchpoint_result);
-    RB_GC_GUARD(switchpoint_result);
+    uint64_t now_ns = current_time_ns();
+    if (next_time_ns == 0) next_time_ns = now_ns + interval_ns;
+
+    if (next_time_ns > now_ns) {
+      double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
+      ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
+      ev_timer_start(backend->ev_loop, &watcher.timer);
+      backend->base.op_count++;
+      resume_value = backend_await((struct Backend_base *)backend);
+      ev_timer_stop(backend->ev_loop, &watcher.timer);
+      RAISE_IF_EXCEPTION(resume_value);
+    }
+    else {
+      resume_value = backend_snooze();
+      RAISE_IF_EXCEPTION(resume_value);
+    }
 
     rb_yield(Qnil);
-    do {
-      next_time += interval_d;
-    } while (next_time <= now);
+
+    while (1) {
+      next_time_ns += interval_ns;
+      if (next_time_ns > now_ns) break;
+    }
   }
+  RB_GC_GUARD(resume_value);
 }
 
 struct libev_timeout {
@@ -1364,7 +1368,7 @@ inline VALUE Backend_run_idle_tasks(VALUE self) {
   return self;
 }
 
-inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
+static inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
   char *buf = RSTRING_PTR(str);
   int len = RSTRING_LEN(str);
   int left = len;

data/ext/polyphony/event.c

@@ -59,14 +59,17 @@ VALUE Event_signal(int argc, VALUE *argv, VALUE self) {
 
 VALUE Event_await(VALUE self) {
   Event_t *event;
+  VALUE switchpoint_result;
+  VALUE backend;
+
   GetEvent(self, event);
 
   if (event->waiting_fiber != Qnil)
     rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
 
-  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
-  VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
+  switchpoint_result = Backend_wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
 
   RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/extconf.rb

@@ -51,6 +51,7 @@ $defs << '-DPOLYPHONY_PLAYGROUND' if ENV['POLYPHONY_PLAYGROUND']
 
 CONFIG['optflags'] << ' -fno-strict-aliasing' unless RUBY_PLATFORM =~ /mswin/
 
+have_func('rb_fiber_transfer', 'ruby.h')
 
 dir_config 'polyphony_ext'
 create_makefile 'polyphony_ext'

data/ext/polyphony/polyphony.c

@@ -9,16 +9,18 @@ ID ID_clear;
 ID ID_each;
 ID ID_inspect;
 ID ID_invoke;
-ID ID_new;
 ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
 ID ID_ivar_parked;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
+ID ID_new;
+ID ID_raise;
 ID ID_size;
 ID ID_signal;
 ID ID_switch_fiber;
+ID ID_to_s;
 ID ID_transfer;
 ID ID_R;
 ID ID_W;
@@ -123,6 +125,10 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_backend_close(VALUE self, VALUE io) {
+  return Backend_close(BACKEND(), io);
+}
+
 void Init_Polyphony() {
   mPolyphony = rb_define_module("Polyphony");
 
@@ -147,6 +153,8 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_wait_io", Polyphony_backend_wait_io, 2);
   rb_define_singleton_method(mPolyphony, "backend_waitpid", Polyphony_backend_waitpid, 1);
   rb_define_singleton_method(mPolyphony, "backend_write", Polyphony_backend_write, -1);
+  rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
+  rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Backend_verify_blocking_mode, 2);
 
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
@@ -166,8 +174,10 @@ void Init_Polyphony() {
   ID_ivar_running       = rb_intern("@running");
   ID_ivar_thread        = rb_intern("@thread");
   ID_new                = rb_intern("new");
+  ID_raise              = rb_intern("raise");
   ID_signal             = rb_intern("signal");
   ID_size               = rb_intern("size");
   ID_switch_fiber       = rb_intern("switch_fiber");
+  ID_to_s               = rb_intern("to_s");
   ID_transfer           = rb_intern("transfer");
 }

data/ext/polyphony/polyphony.h

@@ -10,7 +10,8 @@
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
-#define TRACE_CALLER() { VALUE c = rb_funcall(rb_mKernel, rb_intern("caller"), 0); INSPECT("caller: ", c); }
+#define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
+#define TRACE_CALLER() INSPECT("caller: ", CALLER())
 #define TRACE_C_STACK() { \
   void *entries[10]; \
   size_t size = backtrace(entries, 10); \
@@ -26,7 +27,11 @@
 #define RAISE_IF_NOT_NIL(ret) if (ret != Qnil) { RAISE_EXCEPTION(ret); }
 
 // Fiber#transfer
-#define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
+#if HAVE_RB_FIBER_TRANSFER
+  #define FIBER_TRANSFER(fiber, value) rb_fiber_transfer(fiber, 1, &value)
+#else
+  #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
+#endif
 
 #define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
 
@@ -53,6 +58,7 @@ extern ID ID_raise;
 extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
+extern ID ID_to_s;
 extern ID ID_transfer;
 
 extern VALUE SYM_fiber_create;
@@ -108,6 +114,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise);
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write);
 VALUE Backend_waitpid(VALUE self, VALUE pid);
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self);
+VALUE Backend_close(VALUE self, VALUE io);
 
 VALUE Backend_poll(VALUE self, VALUE blocking);
 VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);

data/ext/polyphony/queue.c

@@ -121,24 +121,27 @@ VALUE Queue_unshift(VALUE self, VALUE value) {
 
 VALUE Queue_shift(VALUE self) {
   Queue_t *queue;
-  GetQueue(self, queue);
-
   VALUE fiber = rb_fiber_current();
   VALUE thread = rb_thread_current();
   VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
+  VALUE value;
+
+  GetQueue(self, queue);
 
   while (1) {
+    VALUE switchpoint_result;
+
     if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->shift_queue, fiber);
-    VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
+    switchpoint_result = Backend_wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
     if (queue->values.count) break;
   }
-  VALUE value = ring_buffer_shift(&queue->values);
+  value = ring_buffer_shift(&queue->values);
   if ((queue->capacity) && (queue->capacity > queue->values.count))
     queue_schedule_first_blocked_fiber(&queue->push_queue);
   RB_GC_GUARD(value);
@@ -206,9 +209,11 @@ VALUE Queue_shift_each(VALUE self) {
 
 VALUE Queue_shift_all(VALUE self) {
   Queue_t *queue;
+  VALUE result;
+
   GetQueue(self, queue);
 
-  VALUE result = ring_buffer_shift_all(&queue->values);
+  result = ring_buffer_shift_all(&queue->values);
   if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return result;
 }

data/ext/polyphony/runqueue_ring_buffer.c

@@ -24,9 +24,11 @@ inline void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
 static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
 
 inline runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+  runqueue_entry value;
+
   if (buffer->count == 0) return nil_runqueue_entry;
 
-  runqueue_entry value = buffer->entries[buffer->head];
+  value = buffer->entries[buffer->head];
   buffer->head = (buffer->head + 1) % buffer->size;
   buffer->count--;
   return value;

data/ext/polyphony/socket_extensions.c

@@ -17,10 +17,13 @@ VALUE Socket_double_chevron(VALUE self, VALUE msg) {
 }
 
 void Init_SocketExtensions() {
+  VALUE cSocket;
+  VALUE cTCPSocket;
+
   rb_require("socket");
 
-  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
-  VALUE cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+  cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+  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);

data/ext/polyphony/thread.c

@@ -40,7 +40,7 @@ VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj
   }
 
   if (Backend_wakeup(rb_ivar_get(self, ID_ivar_backend)) == Qnil) {
-    // we're not inside the ev_loop, so we just do a switchpoint
+    // we're not inside Backend_poll, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
 

data/lib/polyphony/core/global_api.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../extensions/core'
-require_relative '../extensions/fiber'
-require_relative './exceptions'
 require_relative './throttler'
 
 module Polyphony

data/lib/polyphony/extensions/exception.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Exeption overrides
+class ::Exception
+  class << self
+    attr_accessor :__disable_sanitized_backtrace__
+  end
+
+  attr_accessor :source_fiber, :raising_fiber
+
+  alias_method :orig_initialize, :initialize
+  def initialize(*args)
+    @raising_fiber = Fiber.current
+    orig_initialize(*args)
+  end
+
+  alias_method :orig_backtrace, :backtrace
+  def backtrace
+    unless @backtrace_called
+      @backtrace_called = true
+      return orig_backtrace
+    end
+
+    sanitized_backtrace
+  end
+
+  def sanitized_backtrace
+    return sanitize(orig_backtrace) unless @raising_fiber
+
+    backtrace = orig_backtrace || []
+    sanitize(backtrace + @raising_fiber.caller)
+  end
+
+  POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
+
+  def sanitize(backtrace)
+    return backtrace if ::Exception.__disable_sanitized_backtrace__
+
+    backtrace.reject { |l| l[POLYPHONY_DIR] }
+  end
+
+  def invoke
+    Kernel.raise(self)
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -1,22 +1,44 @@
 # frozen_string_literal: true
 
-require 'fiber'
 require_relative '../core/exceptions'
 
 module Polyphony
   # Fiber control API
   module FiberControl
+    # Returns the fiber's monitoring mailbox queue, used for receiving fiber
+    # monitoring messages.
+    #
+    # @return [Polyphony::Queue] Monitoring mailbox queue
     def monitor_mailbox
       @monitor_mailbox ||= Polyphony::Queue.new
     end
 
+    # call-seq:
+    #   fiber.stop(value = nil) -> fiber
+    #   Fiber.interrupt(value = nil) -> fiber
+    #
+    # Stops the fiber by raising a Polyphony::MoveOn exception. The given value
+    # will become the fiber's return value.
+    #
+    # @param value [any] Fiber's eventual return value
+    # @return [Fiber] fiber
     def interrupt(value = nil)
       return if @running == false
 
       schedule Polyphony::MoveOn.new(value)
+      self
     end
     alias_method :stop, :interrupt
 
+    # call-seq:
+    #   fiber.reset(value = nil) -> fiber
+    #   fiber.restart(value = nil) -> fiber
+    #
+    # Restarts the fiber, with the given value serving as the first value passed
+    # to the fiber's block.
+    #
+    # @param value [any] value passed to fiber block
+    # @return [Fiber] restarted fiber
     def restart(value = nil)
       raise "Can't restart main fiber" if @main
 
@@ -32,32 +54,58 @@ module Polyphony
     end
     alias_method :reset, :restart
 
+    # Stops a fiber by raising a Polyphony::Cancel exception.
+    #
+    # @return [Fiber] fiber
     def cancel
       return if @running == false
 
       schedule Polyphony::Cancel.new
+      self
     end
 
+    # Sets the graceful shutdown flag for the fiber.
+    #
+    # @param graceful [bool] Whether or not to perform a graceful shutdown
     def graceful_shutdown=(graceful)
       @graceful_shutdown = graceful
     end
 
+    # Returns the graceful shutdown flag for the fiber.
+    #
+    # @return [bool]
     def graceful_shutdown?
       @graceful_shutdown
     end
 
+    # Terminates the fiber, optionally setting the graceful shutdown flag.
+    #
+    # @param graceful [bool] Whether to perform a graceful shutdown
+    # @return [Fiber]
     def terminate(graceful = false)
       return if @running == false
 
       @graceful_shutdown = graceful
       schedule Polyphony::Terminate.new
+      self
     end
 
+    # call-seq:
+    #   fiber.raise(message) -> fiber
+    #   fiber.raise(exception_class) -> fiber
+    #   fiber.raise(exception_class, exception_message) -> fiber
+    #   fiber.raise(exception) -> fiber
+    #
+    # Raises an exception in the context of the fiber.
+    #
+    # @return [Fiber]
     def raise(*args)
       error = error_from_raise_args(args)
       schedule(error)
+      self
     end
 
+    # :no-doc:
     def error_from_raise_args(args)
       case (arg = args.shift)
       when String then RuntimeError.new(arg)
@@ -118,6 +166,17 @@ module Polyphony
 
   # Class methods for controlling fibers (namely await and select)
   module FiberControlClassMethods
+    # call-seq:
+    #   Fiber.await(*fibers) -> [*results]
+    #   Fiber.join(*fibers) -> [*results]
+    #
+    # Waits for all given fibers to terminate, then returns the respective
+    # return values for all terminated fibers. If any of the awaited fibers
+    # terminates with an uncaught exception, `Fiber.await` will await all the
+    # other fibers to terminate, then reraise the exception.
+    #
+    # @param *fibers [Array<Fiber>] fibers to wait for
+    # @return [Array<any>] return values of given fibers
     def await(*fibers)
       return [] if fibers.empty?
 
@@ -151,6 +210,12 @@ module Polyphony
     end
     alias_method :join, :await
 
+    # Waits for at least one of the given fibers to terminate, returning an
+    # array containing the first terminated fiber and its return value. If an
+    # exception occurs in one of the given fibers, it will be reraised.
+    #
+    # @param *fibers [Array<Fiber>] Fibers to wait for
+    # @return [Array] Array containing the first terminated fiber and its return value
     def select(*fibers)
       return nil if fibers.empty?
 
@@ -185,10 +250,18 @@ module Polyphony
     def schedule_priority_oob_fiber(&block)
       f = Fiber.new do
         Fiber.current.setup_raw
-        block.call
+        result = block.call
       rescue Exception => e
         Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
+        result = e
+      ensure
+        Thread.backend.trace(:fiber_terminate, f, result)
+        suspend
       end
+      f.oob = true
+      location = block.source_location
+      f.set_caller(["#{location.join(':')}"])
+      Thread.backend.trace(:fiber_create, f)
       Thread.current.schedule_and_wakeup(f, nil)
     end
   end
@@ -384,7 +457,7 @@ class ::Fiber
 
   extend Polyphony::FiberControlClassMethods
 
-  attr_accessor :tag, :thread, :parent
+  attr_accessor :tag, :thread, :parent, :oob
   attr_reader :result
 
   def running?
@@ -401,7 +474,11 @@ class ::Fiber
   alias_method :to_s, :inspect
 
   def location
-    @caller ? @caller[0] : '(root)'
+    if @oob
+      "#{@caller[0]} (oob)"
+    else
+      @caller ? @caller[0] : '(root)'
+    end
   end
 
   def caller
@@ -413,6 +490,10 @@ class ::Fiber
     end
   end
 
+  def set_caller(o)
+    @caller = o
+  end
+
   def main?
     @main
   end

data/lib/polyphony/extensions/{core.rb → kernel.rb}

@@ -1,73 +1,7 @@
 # frozen_string_literal: true
 
-require 'fiber'
-require 'timeout'
 require 'open3'
 
-require_relative '../core/exceptions'
-
-# Exeption overrides
-class ::Exception
-  class << self
-    attr_accessor :__disable_sanitized_backtrace__
-  end
-
-  attr_accessor :source_fiber, :raising_fiber
-
-  alias_method :orig_initialize, :initialize
-  def initialize(*args)
-    @raising_fiber = Fiber.current
-    orig_initialize(*args)
-  end
-
-  alias_method :orig_backtrace, :backtrace
-  def backtrace
-    unless @backtrace_called
-      @backtrace_called = true
-      return orig_backtrace
-    end
-
-    sanitized_backtrace
-  end
-
-  def sanitized_backtrace
-    return sanitize(orig_backtrace) unless @raising_fiber
-
-    backtrace = orig_backtrace || []
-    sanitize(backtrace + @raising_fiber.caller)
-  end
-
-  POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
-
-  def sanitize(backtrace)
-    return backtrace if ::Exception.__disable_sanitized_backtrace__
-
-    backtrace.reject { |l| l[POLYPHONY_DIR] }
-  end
-
-  def invoke
-    Kernel.raise(self)
-  end
-end
-
-# Overrides for Process
-module ::Process
-  class << self
-    alias_method :orig_detach, :detach
-    def detach(pid)
-      fiber = spin { Polyphony.backend_waitpid(pid) }
-      fiber.define_singleton_method(:pid) { pid }
-      fiber
-    end
-
-    alias_method :orig_daemon, :daemon
-    def daemon(*args)
-      orig_daemon(*args)
-      Polyphony.original_pid = Process.pid
-    end
-  end
-end
-
 # Kernel extensions (methods available to all objects / call sites)
 module ::Kernel
   alias_method :orig_sleep, :sleep
@@ -159,10 +93,3 @@ module ::Kernel
     end
   end
 end
-
-# Override Timeout to use cancel scope
-module ::Timeout
-  def self.timeout(sec, klass = Timeout::Error, message = 'execution expired', &block)
-    cancel_after(sec, with_exception: [klass, message], &block)
-  end
-end

data/lib/polyphony/extensions/openssl.rb

@@ -38,8 +38,10 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_sysread, :sysread
   def sysread(maxlen, buf = +'')
+    # ensure socket is non blocking
+    Polyphony.backend_verify_blocking_mode(io, false)
     while true
-      case (result = read_nonblock(maxlen, buf, exception: false))
+      case (result = sysread_nonblock(maxlen, buf, exception: false))
       when :wait_readable then Polyphony.backend_wait_io(io, false)
       when :wait_writable then Polyphony.backend_wait_io(io, true)
       else return result
@@ -49,6 +51,8 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_syswrite, :syswrite
   def syswrite(buf)
+    # ensure socket is non blocking
+    Polyphony.backend_verify_blocking_mode(io, false)
     while true
       case (result = write_nonblock(buf, exception: false))
       when :wait_readable then Polyphony.backend_wait_io(io, false)