polyphony 0.55.0 → 0.59.1

data/ext/polyphony/fiber.c

@@ -1,6 +1,5 @@
 #include "polyphony.h"
 
-ID ID_fiber_trace;
 ID ID_ivar_auto_watcher;
 ID ID_ivar_mailbox;
 ID ID_ivar_result;
@@ -169,7 +168,6 @@ void Init_Fiber() {
   rb_global_variable(&SYM_runnable);
   rb_global_variable(&SYM_waiting);
 
-  ID_fiber_trace              = rb_intern("__fiber_trace__");
   ID_ivar_auto_watcher        = rb_intern("@auto_watcher");
   ID_ivar_mailbox             = rb_intern("@mailbox");
   ID_ivar_result              = rb_intern("@result");

data/ext/polyphony/polyphony.c

@@ -10,6 +10,7 @@ ID ID_each;
 ID ID_inspect;
 ID ID_invoke;
 ID ID_new;
+ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
@@ -41,11 +42,6 @@ static VALUE Polyphony_suspend(VALUE self) {
   return ret;
 }
 
-VALUE Polyphony_trace(VALUE self, VALUE enabled) {
-  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
-  return Qnil;
-}
-
 VALUE Polyphony_backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   return Backend_accept(BACKEND(), server_socket, socket_class);
 }
@@ -129,8 +125,6 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
 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);
@@ -158,19 +152,20 @@ void Init_Polyphony() {
 
   cTimeoutException = rb_define_class_under(mPolyphony, "TimeoutException", rb_eException);
 
-  ID_call           = rb_intern("call");
-  ID_caller         = rb_intern("caller");
-  ID_clear          = rb_intern("clear");
-  ID_each           = rb_intern("each");
-  ID_inspect        = rb_intern("inspect");
-  ID_invoke         = rb_intern("invoke");
-  ID_ivar_io        = rb_intern("@io");
-  ID_ivar_runnable  = rb_intern("@runnable");
-  ID_ivar_running   = rb_intern("@running");
-  ID_ivar_thread    = rb_intern("@thread");
-  ID_new            = rb_intern("new");
-  ID_signal         = rb_intern("signal");
-  ID_size           = rb_intern("size");
-  ID_switch_fiber   = rb_intern("switch_fiber");
-  ID_transfer       = rb_intern("transfer");
+  ID_call               = rb_intern("call");
+  ID_caller             = rb_intern("caller");
+  ID_clear              = rb_intern("clear");
+  ID_each               = rb_intern("each");
+  ID_inspect            = rb_intern("inspect");
+  ID_invoke             = rb_intern("invoke");
+  ID_ivar_blocking_mode = rb_intern("@blocking_mode");
+  ID_ivar_io            = rb_intern("@io");
+  ID_ivar_runnable      = rb_intern("@runnable");
+  ID_ivar_running       = rb_intern("@running");
+  ID_ivar_thread        = rb_intern("@thread");
+  ID_new                = rb_intern("new");
+  ID_signal             = rb_intern("signal");
+  ID_size               = rb_intern("size");
+  ID_switch_fiber       = rb_intern("switch_fiber");
+  ID_transfer           = rb_intern("transfer");
 }

data/ext/polyphony/polyphony.h

@@ -5,6 +5,7 @@
 
 #include "ruby.h"
 #include "runqueue_ring_buffer.h"
+#include "backend_common.h"
 
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
@@ -18,10 +19,6 @@
   free(strings); \
 }
 
-// tracing
-#define TRACE(...)  rb_funcall(rb_cObject, ID_fiber_trace, __VA_ARGS__)
-#define COND_TRACE(...) if (__tracing_enabled__) { TRACE(__VA_ARGS__); }
-
 // exceptions
 #define TEST_EXCEPTION(ret) (rb_obj_is_kind_of(ret, rb_eException) == Qtrue)
 #define RAISE_EXCEPTION(e) rb_funcall(e, ID_invoke, 0);
@@ -36,17 +33,16 @@
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
-extern VALUE cRunqueue;
 extern VALUE cTimeoutException;
 
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
-extern ID ID_fiber_trace;
 extern ID ID_inspect;
 extern ID ID_invoke;
 extern ID ID_ivar_backend;
+extern ID ID_ivar_blocking_mode;
 extern ID ID_ivar_io;
 extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
@@ -66,14 +62,6 @@ extern VALUE SYM_fiber_schedule;
 extern VALUE SYM_fiber_switchpoint;
 extern VALUE SYM_fiber_terminate;
 
-extern int __tracing_enabled__;
-
-enum {
-  FIBER_STATE_NOT_SCHEDULED = 0,
-  FIBER_STATE_WAITING       = 1,
-  FIBER_STATE_SCHEDULED     = 2
-};
-
 VALUE Fiber_auto_watcher(VALUE self);
 void Fiber_make_runnable(VALUE fiber, VALUE value);
 
@@ -120,10 +108,14 @@ 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_poll(VALUE self, VALUE blocking);
 VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);
 VALUE Backend_wakeup(VALUE self);
+VALUE Backend_run_idle_tasks(VALUE self);
+VALUE Backend_switch_fiber(VALUE self);
+void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize);
+struct backend_stats Backend_stats(VALUE self);
+void Backend_unschedule_fiber(VALUE self, VALUE fiber);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);

data/ext/polyphony/polyphony_ext.c

@@ -5,10 +5,8 @@ void Init_Polyphony();
 void Init_Backend();
 void Init_Queue();
 void Init_Event();
-void Init_Runqueue();
 void Init_SocketExtensions();
 void Init_Thread();
-void Init_Tracing();
 
 #ifdef POLYPHONY_PLAYGROUND
 extern void playground();
@@ -20,10 +18,8 @@ void Init_polyphony_ext() {
   Init_Backend();
   Init_Queue();
   Init_Event();
-  Init_Runqueue();
   Init_Fiber();
   Init_Thread();
-  Init_Tracing();
 
   Init_SocketExtensions();
 

data/ext/polyphony/runqueue.c

@@ -1,78 +1,35 @@
 #include "polyphony.h"
-#include "runqueue_ring_buffer.h"
-
-typedef struct queue {
-  runqueue_ring_buffer entries;
-  unsigned int high_watermark;
-  unsigned int switch_count;
-} Runqueue_t;
-
-VALUE cRunqueue = Qnil;
-
-static void Runqueue_mark(void *ptr) {
-  Runqueue_t *runqueue = ptr;
-  runqueue_ring_buffer_mark(&runqueue->entries);
-}
-
-static void Runqueue_free(void *ptr) {
-  Runqueue_t *runqueue = ptr;
-  runqueue_ring_buffer_free(&runqueue->entries);
-  xfree(ptr);
-}
-
-static size_t Runqueue_size(const void *ptr) {
-  return sizeof(Runqueue_t);
-}
-
-static const rb_data_type_t Runqueue_type = {
-  "Runqueue",
-  {Runqueue_mark, Runqueue_free, Runqueue_size,},
-  0, 0, 0
-};
-
-static VALUE Runqueue_allocate(VALUE klass) {
-  Runqueue_t *runqueue;
-
-  runqueue = ALLOC(Runqueue_t);
-  return TypedData_Wrap_Struct(klass, &Runqueue_type, runqueue);
-}
-
-#define GetRunqueue(obj, runqueue) \
-  TypedData_Get_Struct((obj), Runqueue_t, &Runqueue_type, (runqueue))
-
-static VALUE Runqueue_initialize(VALUE self) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+#include "runqueue.h"
 
+inline void runqueue_initialize(runqueue_t *runqueue) {
   runqueue_ring_buffer_init(&runqueue->entries);
   runqueue->high_watermark = 0;
   runqueue->switch_count = 0;
+}
 
-  return self;
+inline void runqueue_finalize(runqueue_t *runqueue) {
+  runqueue_ring_buffer_free(&runqueue->entries);
 }
 
-void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+inline void runqueue_mark(runqueue_t *runqueue) {
+  runqueue_ring_buffer_mark(&runqueue->entries);
+}
 
+inline void runqueue_push(runqueue_t *runqueue, 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) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+inline void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int reschedule) {
   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);
+inline runqueue_entry runqueue_shift(runqueue_t *runqueue) {
   runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
   if (entry.fiber == Qnil)
     runqueue->high_watermark = 0;
@@ -81,45 +38,30 @@ runqueue_entry Runqueue_shift(VALUE self) {
   return entry;
 }
 
-void Runqueue_delete(VALUE self, VALUE fiber) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+inline void runqueue_delete(runqueue_t *runqueue, VALUE fiber) {
   runqueue_ring_buffer_delete(&runqueue->entries, fiber);
 }
 
-int Runqueue_index_of(VALUE self, VALUE fiber) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+inline int runqueue_index_of(runqueue_t *runqueue, VALUE fiber) {
   return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
 }
 
-void Runqueue_clear(VALUE self) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
+inline void runqueue_clear(runqueue_t *runqueue) {
   runqueue_ring_buffer_clear(&runqueue->entries);
 }
 
-long Runqueue_len(VALUE self) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
-
+inline long runqueue_len(runqueue_t *runqueue) {
   return runqueue->entries.count;
 }
 
-int Runqueue_empty_p(VALUE self) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
-
+inline int runqueue_empty_p(runqueue_t *runqueue) {
   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);
-
+inline int runqueue_should_poll_nonblocking(runqueue_t *runqueue) {
   if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
   if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
 
@@ -127,10 +69,3 @@ int Runqueue_should_poll_nonblocking(VALUE self) {
   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);
-
-  rb_define_method(cRunqueue, "initialize", Runqueue_initialize, 0);
-}

data/ext/polyphony/runqueue.h

@@ -0,0 +1,27 @@
+#ifndef RUNQUEUE_H
+#define RUNQUEUE_H
+
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+typedef struct runqueue {
+  runqueue_ring_buffer entries;
+  unsigned int high_watermark;
+  unsigned int switch_count;
+} runqueue_t;
+
+void runqueue_initialize(runqueue_t *runqueue);
+void runqueue_finalize(runqueue_t *runqueue);
+void runqueue_mark(runqueue_t *runqueue);
+
+void runqueue_push(runqueue_t *runqueue, VALUE fiber, VALUE value, int reschedule);
+void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int reschedule);
+runqueue_entry runqueue_shift(runqueue_t *runqueue);
+void runqueue_delete(runqueue_t *runqueue, VALUE fiber);
+int runqueue_index_of(runqueue_t *runqueue, VALUE fiber);
+void runqueue_clear(runqueue_t *runqueue);
+long runqueue_len(runqueue_t *runqueue);
+int runqueue_empty_p(runqueue_t *runqueue);
+int runqueue_should_poll_nonblocking(runqueue_t *runqueue);
+
+#endif /* RUNQUEUE_H */

data/ext/polyphony/thread.c

@@ -1,19 +1,15 @@
 #include "polyphony.h"
+#include "backend_common.h"
 
 ID ID_deactivate_all_watchers_post_fork;
 ID ID_ivar_backend;
 ID ID_ivar_join_wait_queue;
 ID ID_ivar_main_fiber;
 ID ID_ivar_terminated;
-ID ID_ivar_runqueue;
 ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  VALUE runqueue = rb_funcall(cRunqueue, ID_new, 0);
-
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  rb_ivar_set(self, ID_ivar_runqueue, runqueue);
-
   return self;
 }
 
@@ -21,53 +17,20 @@ 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 stats = rb_hash_new();
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  long pending_count;
-
-  long scheduled_count = Runqueue_len(runqueue);
-  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
-
-  pending_count = Backend_pending_count(backend);
-  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
+  struct backend_stats backend_stats = Backend_stats(rb_ivar_get(self, ID_ivar_backend));
 
+  VALUE stats = rb_hash_new();
+  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(backend_stats.scheduled_fibers));
+  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(backend_stats.pending_ops));
   return stats;
 }
 
-void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
-  VALUE runqueue;
-  int already_runnable;
-
-  if (rb_fiber_alive_p(fiber) != Qtrue) return;
-  already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
-
-  COND_TRACE(3, SYM_fiber_schedule, fiber, value);
-  runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  (prioritize ? Runqueue_unshift : Runqueue_push)(runqueue, fiber, value, already_runnable);
-  if (!already_runnable) {
-    rb_ivar_set(fiber, ID_ivar_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 backend = rb_ivar_get(self, ID_ivar_backend);
-      Backend_wakeup(backend);
-    }
-  }
-}
-
-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));
+inline void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  Backend_schedule_fiber(self, rb_ivar_get(self, ID_ivar_backend), fiber, value, prioritize);
 }
 
 VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  Runqueue_delete(runqueue, fiber);
+  Backend_unschedule_fiber(rb_ivar_get(self, ID_ivar_backend), fiber);
   return self;
 }
 
@@ -82,60 +45,15 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
-  VALUE current_fiber = rb_fiber_current();
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  runqueue_entry next;
-  VALUE backend = rb_ivar_get(self, ID_ivar_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))
-    TRACE(2, SYM_fiber_switchpoint, current_fiber);
-
-  while (1) {
-    next = Runqueue_shift(runqueue);
-    if (next.fiber != Qnil) {
-      // 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_ops_count == 0) break;
-    Backend_poll(backend, Qnil, current_fiber, runqueue);
-    backend_was_polled = 1;
-  }
-
-  if (next.fiber == Qnil) return Qnil;
-
-  // run next fiber
-  COND_TRACE(3, SYM_fiber_run, next.fiber, next.value);
-
-  rb_ivar_set(next.fiber, ID_ivar_runnable, Qnil);
-  RB_GC_GUARD(next.fiber);
-  RB_GC_GUARD(next.value);
-  return (next.fiber == current_fiber) ?
-    next.value : FIBER_TRANSFER(next.fiber, next.value);
+  return Backend_switch_fiber(rb_ivar_get(self, ID_ivar_backend));
 }
 
 VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj) {
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (Backend_wakeup(backend) == Qnil) {
+  if (Backend_wakeup(rb_ivar_get(self, ID_ivar_backend)) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -161,7 +79,6 @@ 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_singleton_method(rb_cThread, "backend", Thread_class_backend, 0);
@@ -173,7 +90,6 @@ void Init_Thread() {
   ID_ivar_join_wait_queue               = rb_intern("@join_wait_queue");
   ID_ivar_main_fiber                    = rb_intern("@main_fiber");
   ID_ivar_terminated                    = rb_intern("@terminated");
-  ID_ivar_runqueue                      = rb_intern("@runqueue");
   ID_stop                               = rb_intern("stop");
 
   SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));