polyphony 0.49.2 → 0.53.0

data/ext/polyphony/event.c

@@ -77,7 +77,7 @@ VALUE Event_await(VALUE self) {
 }
 
 void Init_Event() {
-  cEvent = rb_define_class_under(mPolyphony, "Event", rb_cData);
+  cEvent = rb_define_class_under(mPolyphony, "Event", rb_cObject);
   rb_define_alloc_func(cEvent, Event_allocate);
 
   rb_define_method(cEvent, "initialize", Event_initialize, 0);

data/ext/polyphony/extconf.rb

@@ -4,18 +4,24 @@ require 'rubygems'
 require 'mkmf'
 
 use_liburing = false
+use_pidfd_open = false
 force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+linux = RUBY_PLATFORM =~ /linux/
 
-if !force_use_libev && RUBY_PLATFORM =~ /linux/ && `uname -sr` =~ /Linux 5\.([\d+])/
+if linux && `uname -sr` =~ /Linux 5\.([\d+])/
   kernel_minor_version = $1.gsub('.', '').to_i
-  use_liburing = kernel_minor_version >= 6
+  use_liburing = !force_use_libev && kernel_minor_version >= 6
+  use_pidfd_open = kernel_minor_version >= 3
 end
 
+$defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if use_pidfd_open
 if use_liburing
   $defs << "-DPOLYPHONY_BACKEND_LIBURING"
+  $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
+  $defs << "-DPOLYPHONY_LINUX" if linux
   $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
   $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
   $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
@@ -23,6 +29,7 @@ else
   $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
   $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
   $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')  
+
   $CFLAGS << " -Wno-comment"
   $CFLAGS << " -Wno-unused-result"
   $CFLAGS << " -Wno-dangling-else"

data/ext/polyphony/fiber.c

@@ -101,7 +101,8 @@ VALUE Fiber_await(VALUE self) {
   }
   rb_hash_aset(waiting_fibers, fiber, Qtrue);
 
-  result = Thread_switch_fiber(rb_thread_current());
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  result = Backend_wait_event(backend, Qnil);
 
   rb_hash_delete(waiting_fibers, fiber);
   RAISE_IF_EXCEPTION(result);

data/ext/polyphony/polyphony.c

@@ -46,11 +46,113 @@ VALUE Polyphony_trace(VALUE self, VALUE enabled) {
   return Qnil;
 }
 
+VALUE Polyphony_backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
+  return Backend_accept(BACKEND(), server_socket, socket_class);
+}
+
+VALUE Polyphony_backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
+  return Backend_accept_loop(BACKEND(), server_socket, socket_class);
+}
+
+VALUE Polyphony_backend_connect(VALUE self, VALUE io, VALUE addr, VALUE port) {
+  return Backend_connect(BACKEND(), io, addr, port);
+}
+
+VALUE Polyphony_backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  return Backend_feed_loop(BACKEND(), io, receiver, method);
+}
+
+VALUE Polyphony_backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
+  return Backend_read(BACKEND(), io, str, length, to_eof);
+}
+
+VALUE Polyphony_backend_read_loop(VALUE self, VALUE io) {
+  return Backend_read_loop(BACKEND(), io);
+}
+
+VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
+  return Backend_recv(BACKEND(), io, str, length);
+}
+
+VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io) {
+  return Backend_recv_loop(BACKEND(), io);
+}
+
+VALUE Polyphony_backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  return Backend_recv_feed_loop(BACKEND(), io, receiver, method);
+}
+
+VALUE Polyphony_backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags) {
+  return Backend_send(BACKEND(), io, msg, flags);
+}
+
+VALUE Polyphony_backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
+  return Backend_sendv(BACKEND(), io, ary, flags);
+}
+
+VALUE Polyphony_backend_sleep(VALUE self, VALUE duration) {
+  return Backend_sleep(BACKEND(), duration);
+}
+
+VALUE Polyphony_backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  return Backend_splice(BACKEND(), src, dest, maxlen);
+}
+
+VALUE Polyphony_backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
+  return Backend_splice_to_eof(BACKEND(), src, dest, chunksize);
+}
+
+VALUE Polyphony_backend_timeout(int argc,VALUE *argv, VALUE self) {
+  return Backend_timeout(argc, argv, BACKEND());
+}
+
+VALUE Polyphony_backend_timer_loop(VALUE self, VALUE interval) {
+  return Backend_timer_loop(BACKEND(), interval);
+}
+
+VALUE Polyphony_backend_wait_event(VALUE self, VALUE raise) {
+  return Backend_wait_event(BACKEND(), raise);
+}
+
+VALUE Polyphony_backend_wait_io(VALUE self, VALUE io, VALUE write) {
+  return Backend_wait_io(BACKEND(), io, write);
+}
+
+VALUE Polyphony_backend_waitpid(VALUE self, VALUE pid) {
+  return Backend_waitpid(BACKEND(), pid);
+}
+
+VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
+  return Backend_write_m(argc, argv, BACKEND());
+}
+
 void Init_Polyphony() {
   mPolyphony = rb_define_module("Polyphony");
 
   rb_define_singleton_method(mPolyphony, "trace", Polyphony_trace, 1);
 
+  // backend methods
+  rb_define_singleton_method(mPolyphony, "backend_accept", Polyphony_backend_accept, 2);
+  rb_define_singleton_method(mPolyphony, "backend_accept_loop", Polyphony_backend_accept_loop, 2);
+  rb_define_singleton_method(mPolyphony, "backend_connect", Polyphony_backend_connect, 3);
+  rb_define_singleton_method(mPolyphony, "backend_feed_loop", Polyphony_backend_feed_loop, 3);
+  rb_define_singleton_method(mPolyphony, "backend_read", Polyphony_backend_read, 4);
+  rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 1);
+  rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 3);
+  rb_define_singleton_method(mPolyphony, "backend_recv_loop", Polyphony_backend_recv_loop, 1);
+  rb_define_singleton_method(mPolyphony, "backend_recv_feed_loop", Polyphony_backend_recv_feed_loop, 3);
+  rb_define_singleton_method(mPolyphony, "backend_send", Polyphony_backend_send, 3);
+  rb_define_singleton_method(mPolyphony, "backend_sendv", Polyphony_backend_sendv, 3);
+  rb_define_singleton_method(mPolyphony, "backend_sleep", Polyphony_backend_sleep, 1);
+  rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);
+  rb_define_singleton_method(mPolyphony, "backend_splice_to_eof", Polyphony_backend_splice_to_eof, 3);
+  rb_define_singleton_method(mPolyphony, "backend_timeout", Polyphony_backend_timeout, -1);
+  rb_define_singleton_method(mPolyphony, "backend_timer_loop", Polyphony_backend_timer_loop, 1);
+  rb_define_singleton_method(mPolyphony, "backend_wait_event", Polyphony_backend_wait_event, 1);
+  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_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
 

data/ext/polyphony/polyphony.h

@@ -23,14 +23,16 @@
 #define COND_TRACE(...) if (__tracing_enabled__) { TRACE(__VA_ARGS__); }
 
 // exceptions
-#define TEST_EXCEPTION(ret) (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
+#define TEST_EXCEPTION(ret) (rb_obj_is_kind_of(ret, rb_eException) == Qtrue)
 #define RAISE_EXCEPTION(e) rb_funcall(e, ID_invoke, 0);
-#define RAISE_IF_EXCEPTION(ret) if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) { RAISE_EXCEPTION(ret); }
+#define RAISE_IF_EXCEPTION(ret) if (rb_obj_is_kind_of(ret, rb_eException) == Qtrue) { RAISE_EXCEPTION(ret); }
 #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)
 
+#define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
+
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
@@ -84,10 +86,39 @@ void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule);
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule);
 runqueue_entry Runqueue_shift(VALUE self);
 void Runqueue_delete(VALUE self, VALUE fiber);
+int Runqueue_index_of(VALUE self, VALUE fiber);
 void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
 
+#ifdef POLYPHONY_BACKEND_LIBEV
+#define Backend_recv_loop Backend_read_loop
+#define Backend_recv_feed_loop Backend_feed_loop
+#endif
+
+// Backend public interface
+
+VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class);
+VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class);
+VALUE Backend_connect(VALUE self, VALUE io, VALUE addr, VALUE port);
+VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
+VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof);
+VALUE Backend_read_loop(VALUE self, VALUE io);
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length);
+VALUE Backend_recv_loop(VALUE self, VALUE io);
+VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
+VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
+VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
+VALUE Backend_sleep(VALUE self, VALUE duration);
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen);
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize);
+VALUE Backend_timeout(int argc,VALUE *argv, VALUE self);
+VALUE Backend_timer_loop(VALUE self, VALUE interval);
+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);
+
 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);

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

@@ -247,7 +247,7 @@ VALUE Queue_size_m(VALUE self) {
 }
 
 void Init_Queue() {
-  cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cData);
+  cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cObject);
   rb_define_alloc_func(cQueue, Queue_allocate);
 
   rb_define_method(cQueue, "initialize", Queue_initialize, -1);

data/ext/polyphony/runqueue.c

@@ -74,6 +74,12 @@ void Runqueue_delete(VALUE self, VALUE fiber) {
   runqueue_ring_buffer_delete(&runqueue->entries, fiber);
 }
 
+int Runqueue_index_of(VALUE self, VALUE fiber) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
+}
+
 void Runqueue_clear(VALUE self) {
   Runqueue_t *runqueue;
   GetRunqueue(self, runqueue);
@@ -95,7 +101,7 @@ int Runqueue_empty_p(VALUE self) {
 }
 
 void Init_Runqueue() {
-  cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cData);
+  cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cObject);
   rb_define_alloc_func(cRunqueue, Runqueue_allocate);
 
   rb_define_method(cRunqueue, "initialize", Runqueue_initialize, 0);

data/ext/polyphony/runqueue_ring_buffer.c

@@ -80,6 +80,15 @@ void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   }
 }
 
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx].fiber == fiber)
+      return i;
+  }
+  return -1;
+}
+
 void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
   buffer->count = buffer->head = buffer->tail = 0;
 }

data/ext/polyphony/runqueue_ring_buffer.h

@@ -27,5 +27,6 @@ void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VAL
 void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value);
 
 void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber);
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber);
 
 #endif /* RUNQUEUE_RING_BUFFER_H */

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

@@ -59,6 +59,18 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
   }
 }
 
+VALUE Thread_fiber_scheduling_index(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+
+  return INT2NUM(Runqueue_index_of(runqueue, fiber));
+}
+
+VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+  Runqueue_delete(runqueue, fiber);
+  return self;
+}
+
 VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   schedule_fiber(self, fiber, value, 0);
   return self;
@@ -135,6 +147,8 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "schedule_fiber_with_priority",
     Thread_schedule_fiber_with_priority, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
+  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_method(rb_cThread, "debug!", Thread_debug, 0);
 

data/lib/polyphony/adapters/irb.rb

@@ -16,7 +16,7 @@ if Object.constants.include?(:Reline)
         fiber.cancel
       end
       read_ios.each do |io|
-        Thread.current.backend.wait_io(io, false)
+        Polyphony.backend_wait_io(io, false)
         return [io]
       end
     rescue Polyphony::Cancel

data/lib/polyphony/adapters/mysql2.rb

@@ -13,7 +13,7 @@ Mysql2::Client.prepend(Module.new do
 
   def query(sql, **options)
     super
-    Thread.current.backend.wait_io(@io, false)
+    Polyphony.backend_wait_io(@io, false)
     async_result
   end
 end)

data/lib/polyphony/adapters/postgres.rb

@@ -15,8 +15,8 @@ module ::PG
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
-      when PGRES_POLLING_READING  then Thread.current.backend.wait_io(socket_io, false)
-      when PGRES_POLLING_WRITING  then Thread.current.backend.wait_io(socket_io, true)
+      when PGRES_POLLING_READING  then Polyphony.backend_wait_io(socket_io, false)
+      when PGRES_POLLING_WRITING  then Polyphony.backend_wait_io(socket_io, true)
       when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
@@ -42,7 +42,7 @@ class ::PG::Connection
 
   def get_result(&block)
     while is_busy
-      Thread.current.backend.wait_io(socket_io, false)
+      Polyphony.backend_wait_io(socket_io, false)
       consume_input
     end
     orig_get_result(&block)
@@ -59,7 +59,7 @@ class ::PG::Connection
 
   def block(_timeout = 0)
     while is_busy
-      Thread.current.backend.wait_io(socket_io, false)
+      Polyphony.backend_wait_io(socket_io, false)
       consume_input
     end
   end
@@ -97,7 +97,7 @@ class ::PG::Connection
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
     while true
-      Thread.current.backend.wait_io(socket_io, false)
+      Polyphony.backend_wait_io(socket_io, false)
       consume_input
       notice = notifies
       next unless notice

data/lib/polyphony/adapters/process.rb

@@ -7,7 +7,7 @@ module Polyphony
       def watch(cmd = nil, &block)
         terminated = nil
         pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-        Thread.current.backend.waitpid(pid)
+        Polyphony.backend_waitpid(pid)
         terminated = true
       ensure
         kill_process(pid) unless terminated || pid.nil?
@@ -23,9 +23,9 @@ module Polyphony
 
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
-        Thread.current.backend.waitpid(pid)
-      rescue Errno::ERSCH
-        # ignore
+        Polyphony.backend_waitpid(pid)
+      rescue Errno::ESRCH
+        # process doesn't exist
       end
     end
   end