polyphony 0.58 → 0.61

data/ext/polyphony/extconf.rb

@@ -8,8 +8,8 @@ use_pidfd_open = false
 force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
 linux = RUBY_PLATFORM =~ /linux/
 
-if linux && `uname -sr` =~ /Linux 5\.([\d+])/
-  kernel_minor_version = $1.gsub('.', '').to_i
+if linux && `uname -sr` =~ /Linux 5\.(\d+)/
+  kernel_minor_version = $1.to_i
   use_liburing = !force_use_libev && kernel_minor_version >= 6
   use_pidfd_open = kernel_minor_version >= 3
 end

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;
@@ -82,34 +81,6 @@ static VALUE Fiber_state(VALUE self) {
   return SYM_waiting;
 }
 
-VALUE Fiber_await(VALUE self) {
-  VALUE result;
-
-  // we compare with false, since a fiber that has not yet started will have
-  // @running set to nil
-  if (rb_ivar_get(self, ID_ivar_running) == Qfalse) {
-    result = rb_ivar_get(self, ID_ivar_result);
-    RAISE_IF_EXCEPTION(result);
-    return result;
-  }
-
-  VALUE fiber = rb_fiber_current();
-  VALUE waiting_fibers = rb_ivar_get(self, ID_ivar_waiting_fibers);
-  if (waiting_fibers == Qnil) {
-    waiting_fibers = rb_hash_new();
-    rb_ivar_set(self, ID_ivar_waiting_fibers, waiting_fibers);
-  }
-  rb_hash_aset(waiting_fibers, fiber, Qtrue);
-
-  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);
-  RB_GC_GUARD(result);
-  return result;
-}
-
 VALUE Fiber_send(VALUE self, VALUE value) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   if (mailbox == Qnil) {
@@ -126,7 +97,7 @@ VALUE Fiber_receive(VALUE self) {
     mailbox = rb_funcall(cQueue, ID_new, 0);
     rb_ivar_set(self, ID_ivar_mailbox, mailbox);
   }
-  return Queue_shift(mailbox);  
+  return Queue_shift(mailbox);
 }
 
 VALUE Fiber_mailbox(VALUE self) {
@@ -151,9 +122,6 @@ void Init_Fiber() {
   rb_define_method(cFiber, "state", Fiber_state, 0);
   rb_define_method(cFiber, "auto_watcher", Fiber_auto_watcher, 0);
 
-  rb_define_method(cFiber, "await", Fiber_await, 0);
-  rb_define_method(cFiber, "join", Fiber_await, 0);
-
   rb_define_method(cFiber, "<<", Fiber_send, 1);
   rb_define_method(cFiber, "send", Fiber_send, 1);
   rb_define_method(cFiber, "receive", Fiber_receive, 0);
@@ -169,7 +137,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

@@ -42,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);
 }
@@ -63,20 +58,20 @@ VALUE Polyphony_backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE me
   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(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
+  return Backend_read(BACKEND(), io, str, length, to_eof, pos);
 }
 
-VALUE Polyphony_backend_read_loop(VALUE self, VALUE io) {
-  return Backend_read_loop(BACKEND(), io);
+VALUE Polyphony_backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
+  return Backend_read_loop(BACKEND(), io, maxlen);
 }
 
-VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
-  return Backend_recv(BACKEND(), io, str, length);
+VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
+  return Backend_recv(BACKEND(), io, str, length, pos);
 }
 
-VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io) {
-  return Backend_recv_loop(BACKEND(), io);
+VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
+  return Backend_recv_loop(BACKEND(), io, maxlen);
 }
 
 VALUE Polyphony_backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
@@ -130,17 +125,15 @@ 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);
   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_read", Polyphony_backend_read, 5);
+  rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 2);
+  rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 4);
+  rb_define_singleton_method(mPolyphony, "backend_recv_loop", Polyphony_backend_recv_loop, 2);
   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);

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,14 +33,12 @@
 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;
@@ -67,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);
 
@@ -104,10 +91,10 @@ 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_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos);
+VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen);
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos);
+VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen);
 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);
@@ -121,11 +108,13 @@ 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);
+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/queue.c

@@ -57,21 +57,21 @@ static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-inline void queue_resume_first_blocked_fiber(ring_buffer *queue) {
+inline void queue_schedule_first_blocked_fiber(ring_buffer *queue) {
   if (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_all_blocked_fibers(ring_buffer *queue) {
+inline void queue_schedule_all_blocked_fibers(ring_buffer *queue) {
   while (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_blocked_fibers_to_capacity(Queue_t *queue) {
+inline void queue_schedule_blocked_fibers_to_capacity(Queue_t *queue) {
   for (unsigned int i = queue->values.count; (i < queue->capacity) && queue->push_queue.count; i++) {
     VALUE fiber = ring_buffer_shift(&queue->push_queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
@@ -101,7 +101,7 @@ VALUE Queue_push(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
 
   return self;
@@ -113,7 +113,7 @@ VALUE Queue_unshift(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
 
   return self;
@@ -140,7 +140,7 @@ VALUE Queue_shift(VALUE self) {
   }
   VALUE value = ring_buffer_shift(&queue->values);
   if ((queue->capacity) && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
   RB_GC_GUARD(value);
   return value;
 }
@@ -152,7 +152,7 @@ VALUE Queue_delete(VALUE self, VALUE value) {
   ring_buffer_delete(&queue->values, value);
 
   if (queue->capacity && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
 
   return self;
 }
@@ -164,9 +164,9 @@ VALUE Queue_cap(VALUE self, VALUE cap) {
   queue->capacity = new_capacity;
   
   if (queue->capacity)
-    queue_resume_blocked_fibers_to_capacity(queue);
+    queue_schedule_blocked_fibers_to_capacity(queue);
   else
-    queue_resume_all_blocked_fibers(&queue->push_queue);
+    queue_schedule_all_blocked_fibers(&queue->push_queue);
   
   return self;
 }
@@ -183,7 +183,7 @@ VALUE Queue_clear(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
 
   return self;
 }
@@ -200,7 +200,7 @@ VALUE Queue_shift_each(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_shift_each(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return self;
 }
 
@@ -209,7 +209,7 @@ VALUE Queue_shift_all(VALUE self) {
   GetQueue(self, queue);
 
   VALUE result = ring_buffer_shift_all(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return result;
 }
 

data/ext/polyphony/runqueue.c

@@ -1,136 +1,59 @@
 #include "polyphony.h"
-#include "runqueue_ring_buffer.h"
+#include "runqueue.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);
+inline void runqueue_initialize(runqueue_t *runqueue) {
+  runqueue_ring_buffer_init(&runqueue->entries);
+  runqueue->high_watermark = 0;
 }
 
-static void Runqueue_free(void *ptr) {
-  Runqueue_t *runqueue = ptr;
+inline void runqueue_finalize(runqueue_t *runqueue) {
   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);
-
-  runqueue_ring_buffer_init(&runqueue->entries);
-  runqueue->high_watermark = 0;
-  runqueue->switch_count = 0;
-
-  return self;
+inline void runqueue_mark(runqueue_t *runqueue) {
+  runqueue_ring_buffer_mark(&runqueue->entries);
 }
 
-void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
-  Runqueue_t *runqueue;
-  GetRunqueue(self, runqueue);
-
+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);
-  runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
-  if (entry.fiber == Qnil)
-    runqueue->high_watermark = 0;
-  else
-    runqueue->switch_count += 1;
-  return entry;
+inline runqueue_entry runqueue_shift(runqueue_t *runqueue) {
+  return runqueue_ring_buffer_shift(&runqueue->entries);
 }
 
-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);
-
-  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);
-
-  if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
-  if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
-
-  // the 
-  runqueue->switch_count = 0;
-  return 1;
+inline long runqueue_max_len(runqueue_t *runqueue) {
+  unsigned int max_len = runqueue->high_watermark;
+  runqueue->high_watermark = 0;
+  return max_len;
 }
 
-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);
+inline int runqueue_empty_p(runqueue_t *runqueue) {
+  return (runqueue->entries.count == 0);
 }