polyphony 0.49.1 → 0.52.0

data/ext/polyphony/polyphony.h

@@ -23,9 +23,9 @@
 #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
@@ -84,10 +84,37 @@ 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_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/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/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

data/lib/polyphony/core/exceptions.rb

@@ -13,6 +13,7 @@ module Polyphony
     def initialize(value = nil)
       @caller_backtrace = caller
       @value = value
+      super
     end
   end
 

data/lib/polyphony/core/global_api.rb

@@ -21,7 +21,7 @@ module Polyphony
       elsif block.arity > 0
         cancel_after_with_block(Fiber.current, interval, with_exception, &block)
       else
-        Thread.current.backend.timeout(interval, with_exception, &block)
+        Polyphony.backend_timeout(interval, with_exception, &block)
       end
     end
 
@@ -29,7 +29,7 @@ module Polyphony
       spin do
         sleep interval
         exception = cancel_exception(with_exception)
-        exception.__raising_fiber__ = nil
+        exception.raising_fiber = nil
         fiber.schedule exception
       end
     end
@@ -82,7 +82,7 @@ module Polyphony
     end
 
     def every(interval, &block)
-      Thread.current.backend.timer_loop(interval, &block)
+      Polyphony.backend_timer_loop(interval, &block)
     end
 
     def move_on_after(interval, with_value: nil, &block)
@@ -91,7 +91,7 @@ module Polyphony
       elsif block.arity > 0
         move_on_after_with_block(Fiber.current, interval, with_value, &block)
       else
-        Thread.current.backend.timeout(interval, nil, with_value, &block)
+        Polyphony.backend_timeout(interval, nil, with_value, &block)
       end
     end
 
@@ -129,11 +129,11 @@ module Polyphony
     def sleep(duration = nil)
       return sleep_forever unless duration
 
-      Thread.current.backend.sleep duration
+      Polyphony.backend_sleep duration
     end
 
     def sleep_forever
-      Thread.current.backend.wait_event(true)
+      Polyphony.backend_wait_event(true)
     end
 
     def throttled_loop(rate = nil, **opts, &block)

data/lib/polyphony/core/sync.rb

@@ -46,7 +46,7 @@ module Polyphony
     def wait(mutex, _timeout = nil)
       mutex.conditional_release
       @queue << Fiber.current
-      Thread.current.backend.wait_event(true)
+      Polyphony.backend_wait_event(true)
       mutex.conditional_reacquire
     end
 

data/lib/polyphony/core/throttler.rb

@@ -12,7 +12,7 @@ module Polyphony
     def call
       now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       delta = @next_time - now
-      Thread.current.backend.sleep(delta) if delta > 0
+      Polyphony.backend_sleep(delta) if delta > 0
       yield self
 
       while true

data/lib/polyphony/core/timer.rb

@@ -11,12 +11,45 @@ module Polyphony
     def stop
       @fiber.stop
     end
+
+    def sleep(duration)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: duration,
+        target_stamp: now + duration
+      }
+      Polyphony.backend_wait_event(true)
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def after(interval, &block)
+      spin do
+        self.sleep interval
+        block.()
+      end
+    end
+
+    def every(interval)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: interval,
+        target_stamp: now + interval,
+        recurring: true
+      }
+      while true
+        Polyphony.backend_wait_event(true)
+        yield
+      end
+    ensure
+      @timeouts.delete(fiber)
+    end
   
-    def cancel_after(duration, with_exception: Polyphony::Cancel)
+    def cancel_after(interval, with_exception: Polyphony::Cancel)
       fiber = Fiber.current
       @timeouts[fiber] = {
-        duration: duration,
-        target_stamp: Time.now + duration,
+        interval: interval,
+        target_stamp: now + interval,
         exception: with_exception
       }
       yield
@@ -24,12 +57,12 @@ module Polyphony
       @timeouts.delete(fiber)
     end
 
-    def move_on_after(duration, with_value: nil)
+    def move_on_after(interval, with_value: nil)
       fiber = Fiber.current
       @timeouts[fiber] = {
-        duration: duration,
-        target_stamp: Time.now + duration,
-        value: with_value
+        interval: interval,
+        target_stamp: now + interval,
+        exception: [Polyphony::MoveOn, with_value]
       }
       yield
     rescue Polyphony::MoveOn => e
@@ -37,36 +70,46 @@ module Polyphony
     ensure
       @timeouts.delete(fiber)
     end
-  
+
     def reset
       record = @timeouts[Fiber.current]
       return unless record
   
-      record[:target_stamp] = Time.now + record[:duration]
+      record[:target_stamp] = now + record[:interval]
     end
-  
+
     private
 
+    def now
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
     def timeout_exception(record)
       case (exception = record[:exception])
-      when Class then exception.new
-      when Array then exception[0].new(exception[1])
-      when nil then Polyphony::MoveOn.new(record[:value])
-      else RuntimeError.new(exception)
+      when Array
+        exception[0].new(exception[1])
+      when Class
+        exception.new
+      else
+        RuntimeError.new(exception)
       end
     end
 
     def update
-      now = Time.now
-      # elapsed = nil
+      return if @timeouts.empty?
+
       @timeouts.each do |fiber, record|
         next if record[:target_stamp] > now
 
-        exception = timeout_exception(record)
-        # (elapsed ||= []) << fiber
-        fiber.schedule exception
+        value = record[:exception] ? timeout_exception(record) : record[:value]
+        fiber.schedule value
+
+        next unless record[:recurring]
+
+        while record[:target_stamp] <= now
+          record[:target_stamp] += record[:interval]
+        end
       end
-      # elapsed&.each { |f| @timeouts.delete(f) }
     end
   end
 end

data/lib/polyphony/extensions/core.rb

@@ -12,11 +12,11 @@ class ::Exception
     attr_accessor :__disable_sanitized_backtrace__
   end
 
-  attr_accessor :source_fiber, :__raising_fiber__
+  attr_accessor :source_fiber, :raising_fiber
 
   alias_method :orig_initialize, :initialize
   def initialize(*args)
-    @__raising_fiber__ = Fiber.current
+    @raising_fiber = Fiber.current
     orig_initialize(*args)
   end
 
@@ -31,10 +31,10 @@ class ::Exception
   end
 
   def sanitized_backtrace
-    return sanitize(orig_backtrace) unless @__raising_fiber__
+    return sanitize(orig_backtrace) unless @raising_fiber
 
     backtrace = orig_backtrace || []
-    sanitize(backtrace + @__raising_fiber__.caller)
+    sanitize(backtrace + @raising_fiber.caller)
   end
 
   POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
@@ -55,7 +55,7 @@ module ::Process
   class << self
     alias_method :orig_detach, :detach
     def detach(pid)
-      fiber = spin { Thread.current.backend.waitpid(pid) }
+      fiber = spin { Polyphony.backend_waitpid(pid) }
       fiber.define_singleton_method(:pid) { pid }
       fiber
     end