polyphony 0.45.2 → 0.47.0

data/ext/polyphony/polyphony_ext.c

@@ -2,21 +2,29 @@
 
 void Init_Fiber();
 void Init_Polyphony();
-void Init_LibevBackend();
+void Init_Backend();
 void Init_Queue();
 void Init_Event();
+void Init_Runqueue();
 void Init_Thread();
 void Init_Tracing();
 
-void Init_polyphony_ext() {
-  ev_set_allocator(xrealloc);
+#ifdef POLYPHONY_PLAYGROUND
+extern void playground();
+#endif
 
+void Init_polyphony_ext() {
   Init_Polyphony();
 
-  Init_LibevBackend();
+  Init_Backend();
   Init_Queue();
   Init_Event();
+  Init_Runqueue();
   Init_Fiber();
   Init_Thread();
   Init_Tracing();
+
+  #ifdef POLYPHONY_PLAYGROUND
+  playground();
+  #endif
 }

data/ext/polyphony/queue.c

@@ -4,6 +4,8 @@
 typedef struct queue {
   ring_buffer values;
   ring_buffer shift_queue;
+  ring_buffer push_queue;
+  unsigned int capacity;
 } Queue_t;
 
 VALUE cQueue = Qnil;
@@ -12,12 +14,14 @@ static void Queue_mark(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_mark(&queue->values);
   ring_buffer_mark(&queue->shift_queue);
+  ring_buffer_mark(&queue->push_queue);
 }
 
 static void Queue_free(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_free(&queue->values);
   ring_buffer_free(&queue->shift_queue);
+  ring_buffer_free(&queue->push_queue);
   xfree(ptr);
 }
 
@@ -41,36 +45,77 @@ static VALUE Queue_allocate(VALUE klass) {
 #define GetQueue(obj, queue) \
   TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
 
-static VALUE Queue_initialize(VALUE self) {
+static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_init(&queue->values);
   ring_buffer_init(&queue->shift_queue);
+  ring_buffer_init(&queue->push_queue);
+  queue->capacity = (argc == 1) ?  NUM2UINT(argv[0]) : 0;
 
   return self;
 }
 
+inline void queue_resume_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) {
+  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) {
+  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);
+  }
+}
+
+inline void capped_queue_block_push(Queue_t *queue) {
+  VALUE fiber = rb_fiber_current();
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  VALUE switchpoint_result;
+  while (1) {
+    if (queue->capacity > queue->values.count) Fiber_make_runnable(fiber, Qnil);
+
+    ring_buffer_push(&queue->push_queue, fiber);
+    switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    ring_buffer_delete(&queue->push_queue, fiber);
+
+    RAISE_IF_EXCEPTION(switchpoint_result);
+    RB_GC_GUARD(switchpoint_result);
+    if (queue->capacity > queue->values.count) break;
+  }
+}
+
 VALUE Queue_push(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
+
   return self;
 }
 
 VALUE Queue_unshift(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
+
   return self;
 }
 
@@ -83,42 +128,63 @@ VALUE Queue_shift(VALUE self) {
   VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
 
   while (1) {
-    ring_buffer_push(&queue->shift_queue, fiber);
-    if (queue->values.count > 0) Fiber_make_runnable(fiber, Qnil);
+    if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
+    ring_buffer_push(&queue->shift_queue, fiber);
     VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
-    TEST_RESUME_EXCEPTION(switchpoint_result);
+    RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
-
-    if (queue->values.count > 0)
-      return ring_buffer_shift(&queue->values);
+    if (queue->values.count) break;
   }
-
-  return Qnil;
+  VALUE value = ring_buffer_shift(&queue->values);
+  if ((queue->capacity) && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+  RB_GC_GUARD(value);
+  return value;
 }
 
-VALUE Queue_shift_no_wait(VALUE self) {
-    Queue_t *queue;
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift(&queue->values);
+  ring_buffer_delete(&queue->values, value);
+
+  if (queue->capacity && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+
+  return self;
 }
 
-VALUE Queue_delete(VALUE self, VALUE value) {
+VALUE Queue_cap(VALUE self, VALUE cap) {
+  unsigned int new_capacity = NUM2UINT(cap);
   Queue_t *queue;
   GetQueue(self, queue);
-
-  ring_buffer_delete(&queue->values, value);
+  queue->capacity = new_capacity;
+  
+  if (queue->capacity)
+    queue_resume_blocked_fibers_to_capacity(queue);
+  else
+    queue_resume_all_blocked_fibers(&queue->push_queue);
+  
   return self;
 }
 
+VALUE Queue_capped_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->capacity ? UINT2NUM(queue->capacity) : Qnil;
+}
+
 VALUE Queue_clear(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+
   return self;
 }
 
@@ -134,6 +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);
   return self;
 }
 
@@ -141,7 +208,9 @@ VALUE Queue_shift_all(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift_all(&queue->values);
+  VALUE result = ring_buffer_shift_all(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  return result;
 }
 
 VALUE Queue_flush_waiters(VALUE self, VALUE value) {
@@ -160,14 +229,14 @@ VALUE Queue_empty_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->values.count == 0) ? Qtrue : Qfalse;
+  return (!queue->values.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_pending_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->shift_queue.count > 0) ? Qtrue : Qfalse;
+  return (queue->shift_queue.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_size_m(VALUE self) {
@@ -177,26 +246,22 @@ VALUE Queue_size_m(VALUE self) {
   return INT2NUM(queue->values.count);
 }
 
-void Queue_trace(VALUE self) {
-  Queue_t *queue;
-  GetQueue(self, queue);
-
-  printf("run queue size: %d count: %d\n", queue->values.size, queue->values.count);
-}
-
 void Init_Queue() {
   cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cData);
   rb_define_alloc_func(cQueue, Queue_allocate);
 
-  rb_define_method(cQueue, "initialize", Queue_initialize, 0);
+  rb_define_method(cQueue, "initialize", Queue_initialize, -1);
   rb_define_method(cQueue, "push", Queue_push, 1);
   rb_define_method(cQueue, "<<", Queue_push, 1);
   rb_define_method(cQueue, "unshift", Queue_unshift, 1);
 
   rb_define_method(cQueue, "shift", Queue_shift, 0);
   rb_define_method(cQueue, "pop", Queue_shift, 0);
-  rb_define_method(cQueue, "shift_no_wait", Queue_shift_no_wait, 0);
   rb_define_method(cQueue, "delete", Queue_delete, 1);
+  rb_define_method(cQueue, "clear", Queue_clear, 0);
+
+  rb_define_method(cQueue, "cap", Queue_cap, 1);
+  rb_define_method(cQueue, "capped?", Queue_capped_p, 0);
 
   rb_define_method(cQueue, "shift_each", Queue_shift_each, 0);
   rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);

data/ext/polyphony/runqueue.c

@@ -0,0 +1,102 @@
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+typedef struct queue {
+  runqueue_ring_buffer entries;
+} 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);
+
+  runqueue_ring_buffer_init(&runqueue->entries);
+
+  return self;
+}
+
+void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+  runqueue_ring_buffer_push(&runqueue->entries, fiber, value);
+}
+
+void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+  runqueue_ring_buffer_unshift(&runqueue->entries, fiber, value);
+}
+
+runqueue_entry Runqueue_shift(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  return runqueue_ring_buffer_shift(&runqueue->entries);
+}
+
+void Runqueue_delete(VALUE self, VALUE fiber) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+}
+
+void Runqueue_clear(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  runqueue_ring_buffer_clear(&runqueue->entries);
+}
+
+long Runqueue_len(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  return runqueue->entries.count;
+}
+
+int Runqueue_empty_p(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  return (runqueue->entries.count == 0);
+}
+
+void Init_Runqueue() {
+  cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cData);
+  rb_define_alloc_func(cRunqueue, Runqueue_allocate);
+
+  rb_define_method(cRunqueue, "initialize", Runqueue_initialize, 0);
+}

data/ext/polyphony/runqueue_ring_buffer.c

@@ -0,0 +1,85 @@
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
+  buffer->size = 1;
+  buffer->count = 0;
+  buffer->entries = malloc(buffer->size * sizeof(runqueue_entry));
+  buffer->head = 0;
+  buffer->tail = 0;
+}
+
+void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
+  free(buffer->entries);
+}
+
+int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
+  return buffer->count == 0;
+}
+
+static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
+
+runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+  if (buffer->count == 0) return nil_runqueue_entry;
+
+  runqueue_entry value = buffer->entries[buffer->head];
+  buffer->head = (buffer->head + 1) % buffer->size;
+  buffer->count--;
+  return value;
+}
+
+void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
+  unsigned int old_size = buffer->size;
+  buffer->size = old_size == 1 ? 4 : old_size * 2;
+  buffer->entries = realloc(buffer->entries, buffer->size * sizeof(runqueue_entry));
+  for (unsigned int idx = 0; idx < buffer->head && idx < buffer->tail; idx++)
+    buffer->entries[old_size + idx] = buffer->entries[idx];
+  buffer->tail = buffer->head + buffer->count;
+}
+
+void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+  if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
+
+  buffer->head = (buffer->head - 1) % buffer->size;
+  buffer->entries[buffer->head].fiber = fiber;
+  buffer->entries[buffer->head].value = value;
+  buffer->count++;
+}
+
+void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+  if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
+
+  buffer->entries[buffer->tail].fiber = fiber;
+  buffer->entries[buffer->tail].value = value;
+  buffer->tail = (buffer->tail + 1) % buffer->size;
+  buffer->count++;
+}
+
+void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].fiber);
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].value);
+  }
+}
+
+void runqueue_ring_buffer_delete_at(runqueue_ring_buffer *buffer, unsigned int idx) {
+  for (unsigned int idx2 = idx; idx2 != buffer->tail; idx2 = (idx2 + 1) % buffer->size) {
+    buffer->entries[idx2] = buffer->entries[(idx2 + 1) % buffer->size];
+  }
+  buffer->count--;
+  buffer->tail = (buffer->tail - 1) % buffer->size;
+}
+
+void runqueue_ring_buffer_delete(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) {
+      runqueue_ring_buffer_delete_at(buffer, idx);
+      return;
+    }
+  }
+}
+
+void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
+  buffer->count = buffer->head = buffer->tail = 0;
+}