polyphony 0.43.8

data/ext/polyphony/ring_buffer.h

@@ -0,0 +1,28 @@
+#ifndef RING_BUFFER_H
+#define RING_BUFFER_H
+
+#include "ruby.h"
+
+typedef struct ring_buffer {
+  VALUE *entries;
+  unsigned int size;
+  unsigned int count;
+  unsigned int head;
+  unsigned int tail;
+} ring_buffer;
+
+void ring_buffer_init(ring_buffer *buffer);
+void ring_buffer_free(ring_buffer *buffer);
+void ring_buffer_mark(ring_buffer *buffer);
+int ring_buffer_empty_p(ring_buffer *buffer);
+void ring_buffer_clear(ring_buffer *buffer);
+
+VALUE ring_buffer_shift(ring_buffer *buffer);
+void ring_buffer_unshift(ring_buffer *buffer, VALUE value);
+void ring_buffer_push(ring_buffer *buffer, VALUE value);
+
+void ring_buffer_shift_each(ring_buffer *buffer);
+VALUE ring_buffer_shift_all(ring_buffer *buffer);
+void ring_buffer_delete(ring_buffer *buffer, VALUE value);
+
+#endif /* RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -0,0 +1,208 @@
+#include "polyphony.h"
+
+ID ID_deactivate_all_watchers_post_fork;
+ID ID_ivar_agent;
+ID ID_ivar_join_wait_queue;
+ID ID_ivar_main_fiber;
+ID ID_ivar_result;
+ID ID_ivar_terminated;
+ID ID_run_queue;
+ID ID_runnable_next;
+ID ID_stop;
+
+static VALUE Thread_setup_fiber_scheduling(VALUE self) {
+  VALUE queue = rb_funcall(cQueue, ID_new, 0);
+  
+  rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
+  rb_ivar_set(self, ID_run_queue, queue);
+
+  return self;
+}
+
+int Thread_fiber_ref_count(VALUE self) {
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  return NUM2INT(LibevAgent_ref_count(agent));
+}
+
+inline void Thread_fiber_reset_ref_count(VALUE self) {
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  LibevAgent_reset_ref_count(agent);
+}
+
+static VALUE SYM_scheduled_fibers;
+static VALUE SYM_pending_watchers;
+
+static VALUE Thread_fiber_scheduling_stats(VALUE self) {
+  VALUE agent = rb_ivar_get(self,ID_ivar_agent);
+  VALUE stats = rb_hash_new();
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  long pending_count;
+
+  long scheduled_count = RARRAY_LEN(queue);
+  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
+
+  pending_count = LibevAgent_pending_count(agent);
+  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
+
+  return stats;
+}
+
+VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  VALUE queue;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
+
+  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
+  // if fiber is already scheduled, just set the scheduled value, then return
+  rb_ivar_set(fiber, ID_runnable_value, value);
+  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
+    return self;
+  }
+
+  queue = rb_ivar_get(self, ID_run_queue);
+  Queue_push(queue, fiber);
+  rb_ivar_set(fiber, ID_runnable, Qtrue);
+
+  if (rb_thread_current() != self) {
+    // if the fiber scheduling is done across threads, we need to make sure the
+    // target thread is woken up in case it is in the middle of running its
+    // 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 agent = rb_ivar_get(self,ID_ivar_agent);
+    LibevAgent_break(agent);
+  }
+  return self;
+}
+
+VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
+  VALUE queue;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
+
+  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
+  rb_ivar_set(fiber, ID_runnable_value, value);
+
+  queue = rb_ivar_get(self, ID_run_queue);
+
+  // if fiber is already scheduled, remove it from the run queue
+  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
+    Queue_delete(queue, fiber);
+  } else {
+    rb_ivar_set(fiber, ID_runnable, Qtrue);
+  }
+
+  // the fiber is given priority by putting it at the front of the run queue
+  Queue_unshift(queue, fiber);
+
+  if (rb_thread_current() != self) {
+    // if the fiber scheduling is done across threads, we need to make sure the
+    // target thread is woken up in case it is in the middle of running its
+    // event loop. 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 agent = rb_ivar_get(self, ID_ivar_agent);
+    LibevAgent_break(agent);
+  }
+  return self;
+}
+
+VALUE Thread_switch_fiber(VALUE self) {
+  VALUE current_fiber = rb_fiber_current();
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  VALUE next_fiber;
+  VALUE value;
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  int ref_count;
+  int agent_was_polled = 0;1;
+
+  if (__tracing_enabled__) {
+    if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
+      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_switchpoint, current_fiber);
+    }
+  }
+
+  ref_count = LibevAgent_ref_count(agent);
+  while (1) {
+    next_fiber = Queue_shift_no_wait(queue);
+    if (next_fiber != Qnil) {
+      if (agent_was_polled == 0 && ref_count > 0) {
+        // this mechanism prevents event starvation in case the run queue never
+        // empties
+        LibevAgent_poll(agent, Qtrue, current_fiber, queue);
+      }
+      break;
+    }
+    if (ref_count == 0) break;
+
+    LibevAgent_poll(agent, Qnil, current_fiber, queue);
+    agent_was_polled = 1;
+  }
+
+  if (next_fiber == Qnil) return Qnil;
+
+  // run next fiber
+  value = rb_ivar_get(next_fiber, ID_runnable_value);
+  FIBER_TRACE(3, SYM_fiber_run, next_fiber, value);
+
+  rb_ivar_set(next_fiber, ID_runnable, Qnil);
+  RB_GC_GUARD(next_fiber);
+  RB_GC_GUARD(value);
+  return (next_fiber == current_fiber) ? 
+    value : rb_funcall(next_fiber, ID_transfer, 1, value);
+}
+
+VALUE Thread_run_queue_trace(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  Queue_trace(queue);
+  return self;
+}
+
+VALUE Thread_reset_fiber_scheduling(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  Queue_clear(queue);
+  Thread_fiber_reset_ref_count(self);
+  return self;
+}
+
+VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_obj) {
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  if (fiber != Qnil) {
+    Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
+  }
+
+  if (LibevAgent_break(agent) == Qnil) {
+    // we're not inside the ev_loop, so we just do a switchpoint
+    Thread_switch_fiber(self);
+  }
+
+  return self;
+}
+
+void Init_Thread() {
+  rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
+  rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
+  rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
+  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 2);
+
+  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
+  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, "run_queue_trace", Thread_run_queue_trace, 0);
+
+  ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
+  ID_ivar_agent               = rb_intern("@agent");
+  ID_ivar_join_wait_queue     = rb_intern("@join_wait_queue");
+  ID_ivar_main_fiber          = rb_intern("@main_fiber");
+  ID_ivar_result              = rb_intern("@result");
+  ID_ivar_terminated          = rb_intern("@terminated");
+  ID_run_queue                = rb_intern("run_queue");
+  ID_runnable_next            = rb_intern("runnable_next");
+  ID_stop                     = rb_intern("stop");
+
+  SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
+  SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));
+  rb_global_variable(&SYM_scheduled_fibers);
+  rb_global_variable(&SYM_pending_watchers);
+}

data/ext/polyphony/tracing.c

@@ -0,0 +1,11 @@
+#include "polyphony.h"
+
+int __tracing_enabled__ = 0;
+
+VALUE __fiber_trace__(int argc, VALUE *argv, VALUE self) {
+  return rb_ary_new4(argc, argv);
+}
+
+void Init_Tracing() {
+  rb_define_global_function("__fiber_trace__", __fiber_trace__, -1);
+}

data/lib/polyphony.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'fiber'
+require_relative './polyphony_ext'
+
+module Polyphony
+  # replace core Queue class with our own
+  verbose = $VERBOSE
+  $VERBOSE = nil
+  Object.const_set(:Queue, Polyphony::Queue)
+  $VERBOSE = verbose
+end
+
+require_relative './polyphony/extensions/core'
+require_relative './polyphony/extensions/thread'
+require_relative './polyphony/extensions/fiber'
+require_relative './polyphony/extensions/io'
+
+Thread.current.setup_fiber_scheduling
+Thread.current.agent = Polyphony::LibevAgent.new
+
+require_relative './polyphony/core/global_api'
+require_relative './polyphony/core/resource_pool'
+require_relative './polyphony/net'
+require_relative './polyphony/adapters/process'
+require_relative './polyphony/event'
+
+# Main Polyphony API
+module Polyphony
+  class << self
+    def wait_for_signal(sig)
+      raise "should be reimplemented"
+
+      fiber = Fiber.current
+      # Polyphony.ref
+      old_trap = trap(sig) do
+        # Polyphony.unref
+        fiber.schedule(sig)
+        trap(sig, old_trap)
+      end
+      suspend
+
+    end
+
+    def fork(&block)
+      Kernel.fork do
+        # # Since the fiber doing the fork will become the main fiber of the
+        # # forked process, we leave it behind by transferring to a new fiber
+        # # created in the context of the forked process, which rescues *all*
+        # # exceptions, including Interrupt and SystemExit.
+        spin_forked_block(&block).transfer
+      end
+    end
+
+    def spin_forked_block(&block)
+      Fiber.new do
+        run_forked_block(&block)
+      rescue SystemExit
+        # fall through to ensure
+      rescue Exception => e
+        e.full_message
+        exit!
+      ensure
+        exit_forked_process
+      end
+    end
+
+    def run_forked_block(&block)
+      # A race condition can arise if a TERM or INT signal is received before
+      # the forked process has finished initializing. To prevent this we restore
+      # the default signal handlers, and then reinstall the custom Polyphony
+      # handlers just before running the given block.
+      trap('SIGTERM', 'DEFAULT')
+      trap('SIGINT', 'DEFAULT')
+
+      Thread.current.setup
+      Fiber.current.setup_main_fiber
+      Thread.current.agent.post_fork
+
+      install_terminating_signal_handlers
+
+      block.()
+    end
+
+    def exit_forked_process
+      terminate_threads
+      Fiber.current.shutdown_all_children
+
+      # Since fork could be called from any fiber, we explicitly call exit here.
+      # Otherwise, the fiber might want to pass execution to another fiber that
+      # previously transferred execution to the forking fiber, but doesn't exist
+      # anymore...
+      exit
+    end
+
+    def watch_process(cmd = nil, &block)
+      Polyphony::Process.watch(cmd, &block)
+    end
+
+    def install_terminating_signal_handlers
+      trap('SIGTERM', SystemExit)
+      orig_trap('SIGINT') do
+        orig_trap('SIGINT') { exit! }
+        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, Interrupt.new)
+      end
+    end
+
+    def terminate_threads
+      threads = Thread.list - [Thread.current]
+      return if threads.empty?
+
+      threads.each(&:kill)
+      threads.each(&:join)
+    end
+
+    attr_accessor :original_pid
+
+    def install_at_exit_handler
+      @original_pid = ::Process.pid
+
+      # This at_exit handler is needed only when the original process exits. Due to
+      # the behaviour of fibers on fork (and especially on exit from forked
+      # processes,) we use a separate mechanism to terminate fibers in forked
+      # processes (see Polyphony.fork).
+      at_exit do
+        next unless @original_pid == ::Process.pid
+      
+        Polyphony.terminate_threads
+        Fiber.current.shutdown_all_children
+      end
+    end
+  end
+end
+
+Polyphony.install_terminating_signal_handlers
+Polyphony.install_at_exit_handler

data/lib/polyphony/adapters/fs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative './core/thread_pool'
+
+::File.singleton_class.instance_eval do
+  alias_method :orig_stat, :stat
+  def stat(path)
+    ThreadPool.process { orig_stat(path) }
+  end
+end
+
+::IO.singleton_class.instance_eval do
+  alias_method :orig_read, :read
+  def read(path)
+    ThreadPool.process { orig_read(path) }
+  end
+end

data/lib/polyphony/adapters/irb.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'polyphony'
+
+if Object.constants.include?(:Reline)
+  class Reline::ANSI
+    def self.select(read_ios = [], write_ios = [], error_ios = [], timeout = nil)
+      p [:select, read_ios]
+      raise if read_ios.size > 1
+      raise if write_ios.size > 0
+      raise if error_ios.size > 0
+
+      fiber = Fiber.current
+      timer = spin do
+        sleep timeout
+        fiber.cancel
+      end
+      read_ios.each do |io|
+        Thread.current.agent.wait_io(io, false)
+        return [io]
+      end
+    rescue Polyphony::Cancel
+      return nil
+    ensure
+      timer.stop
+    end
+  end
+else
+  # readline blocks the current thread, so we offload it to the blocking-ops
+  # thread pool. That way, the reactor loop can keep running while waiting for
+  # readline to return
+  module ::Readline
+    alias_method :orig_readline, :readline
+
+    Workers = Polyphony::ThreadPool.new
+
+    def readline(*args)
+      p :readline
+      # caller.each do |l|
+      #   STDOUT.orig_puts l
+      # end
+      Workers.process { orig_readline(*args) }
+    end
+  end
+
+  # RubyLex patches
+  class ::RubyLex
+    class TerminateLineInput2 < RuntimeError
+    end
+    const_set(:TerminateLineInput, TerminateLineInput2)
+  end
+end