polyphony 0.43 → 0.43.5

data/ext/polyphony/libev_queue.c

@@ -1,4 +1,5 @@
 #include "polyphony.h"
+#include "ring_buffer.h"
 
 struct async_watcher {
   ev_async async;
@@ -6,48 +7,65 @@ struct async_watcher {
   VALUE fiber;
 };
 
-struct async_queue {
+struct async_watcher_queue {
   struct async_watcher **queue;
-  unsigned int len;
+  unsigned int length;
   unsigned int count;
   unsigned int push_idx;
-  unsigned int pop_idx;
+  unsigned int shift_idx;
 };
 
-void async_queue_init(struct async_queue *queue) {
-  queue->len = 4;
+void async_watcher_queue_init(struct async_watcher_queue *queue) {
+  queue->length = 1;
   queue->count = 0;
-  queue->queue = malloc(sizeof(struct async_watcher *) * queue->len);
+  queue->queue = malloc(sizeof(struct async_watcher *) * queue->length);
   queue->push_idx = 0;
-  queue->pop_idx = 0;
+  queue->shift_idx = 0;
 }
 
-void async_queue_free(struct async_queue *queue) {
+void async_watcher_queue_free(struct async_watcher_queue *queue) {
   free(queue->queue);
 }
 
-void async_queue_push(struct async_queue *queue, struct async_watcher *watcher) {
-  if (queue->push_idx == queue->len) {
-    queue->len = queue->len * 2;
-    queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->len);
-  }
+void async_watcher_queue_realign(struct async_watcher_queue *queue) {
+  memmove(
+    queue->queue,
+    queue->queue + queue->shift_idx,
+    queue->count * sizeof(struct async_watcher *)
+  );
+  queue->push_idx = queue->push_idx - queue->shift_idx;
+  queue->shift_idx = 0;
+}
+
+#define QUEUE_REALIGN_THRESHOLD 32
+
+void async_watcher_queue_push(struct async_watcher_queue *queue, struct async_watcher *watcher) {
   if (queue->count == 0) {
     queue->push_idx = 0;
-    queue->pop_idx = 0;
+    queue->shift_idx = 0;
+  }
+  if (queue->push_idx == queue->length) {
+    // prevent shift idx moving too much away from zero
+    if (queue->length >= QUEUE_REALIGN_THRESHOLD && queue->shift_idx >= (queue->length / 2))
+      async_watcher_queue_realign(queue);
+    else {
+      queue->length = (queue->length == 1) ? 4 : queue->length * 2;
+      queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->length);
+    }
   }
   queue->count++;
   queue->queue[queue->push_idx++] = watcher;
 }
 
-struct async_watcher *async_queue_pop(struct async_queue *queue) {
+struct async_watcher *async_watcher_queue_shift(struct async_watcher_queue *queue) {
   if (queue->count == 0) return 0;
 
   queue->count--;
 
-  return queue->queue[queue->pop_idx++];
+  return queue->queue[queue->shift_idx++];
 }
 
-void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_idx) {
+void async_watcher_queue_remove_at_idx(struct async_watcher_queue *queue, unsigned int remove_idx) {
   queue->count--;
   queue->push_idx--;
   if (remove_idx < queue->push_idx)
@@ -58,33 +76,33 @@ void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_id
     );
 }
 
-void async_queue_remove_by_fiber(struct async_queue *queue, VALUE fiber) {
+void async_watcher_queue_remove_by_fiber(struct async_watcher_queue *queue, VALUE fiber) {
   if (queue->count == 0) return;
 
-  for (unsigned idx = queue->pop_idx; idx < queue->push_idx; idx++) {
+  for (unsigned idx = queue->shift_idx; idx < queue->push_idx; idx++) {
     if (queue->queue[idx]->fiber == fiber) {
-      async_queue_remove_at_idx(queue, idx);
+      async_watcher_queue_remove_at_idx(queue, idx);
       return; 
     }
   }
 }
 
 typedef struct queue {
-  VALUE items;
-  struct async_queue shift_queue;
+  ring_buffer values;
+  struct async_watcher_queue shift_queue;
 } LibevQueue_t;
 
-
 VALUE cLibevQueue = Qnil;
 
 static void LibevQueue_mark(void *ptr) {
   LibevQueue_t *queue = ptr;
-  rb_gc_mark(queue->items);
+  ring_buffer_mark(&queue->values);
 }
 
 static void LibevQueue_free(void *ptr) {
   LibevQueue_t *queue = ptr;
-  async_queue_free(&queue->shift_queue);
+  ring_buffer_free(&queue->values);
+  async_watcher_queue_free(&queue->shift_queue);
   xfree(ptr);
 }
 
@@ -112,27 +130,41 @@ static VALUE LibevQueue_initialize(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  queue->items = rb_ary_new();
-  async_queue_init(&queue->shift_queue);
+  ring_buffer_init(&queue->values);
+  async_watcher_queue_init(&queue->shift_queue);
 
   return self;
 }
 
 VALUE LibevQueue_push(VALUE self, VALUE value) {
   LibevQueue_t *queue;
-  struct async_watcher *watcher;
   GetQueue(self, queue);
-  watcher = async_queue_pop(&queue->shift_queue);
-  if (watcher) {
-    ev_async_send(watcher->ev_loop, &watcher->async);
+  if (queue->shift_queue.count > 0) {
+    struct async_watcher *watcher = async_watcher_queue_shift(&queue->shift_queue);
+    if (watcher) {
+      ev_async_send(watcher->ev_loop, &watcher->async);
+    }
   }
-  rb_ary_push(queue->items, value);
+  ring_buffer_push(&queue->values, value);
+  return self;
+}
+
+VALUE LibevQueue_unshift(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+  if (queue->shift_queue.count > 0) {
+    struct async_watcher *watcher = async_watcher_queue_shift(&queue->shift_queue);
+    if (watcher) {
+      ev_async_send(watcher->ev_loop, &watcher->async);
+    }
+  }
+  ring_buffer_unshift(&queue->values, value);
   return self;
 }
 
 struct ev_loop *LibevAgent_ev_loop(VALUE self);
 
-void async_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+void async_watcher_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
   struct async_watcher *watcher = (struct async_watcher *)ev_async;
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
@@ -143,22 +175,22 @@ VALUE LibevQueue_shift(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  if (RARRAY_LEN(queue->items) == 0) {
+  if (queue->values.count == 0) {
     struct async_watcher watcher;
     VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
     VALUE switchpoint_result = Qnil;
 
     watcher.ev_loop = LibevAgent_ev_loop(agent);
     watcher.fiber = rb_fiber_current();    
-    async_queue_push(&queue->shift_queue, &watcher);
-    ev_async_init(&watcher.async, async_queue_callback);
+    async_watcher_queue_push(&queue->shift_queue, &watcher);
+    ev_async_init(&watcher.async, async_watcher_queue_callback);
     ev_async_start(watcher.ev_loop, &watcher.async);
     
     switchpoint_result = libev_agent_await(agent);
     ev_async_stop(watcher.ev_loop, &watcher.async);
 
     if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
-      async_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
+      async_watcher_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
       return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
     }
     RB_GC_GUARD(watcher.fiber);
@@ -166,36 +198,72 @@ VALUE LibevQueue_shift(VALUE self) {
     RB_GC_GUARD(switchpoint_result);
   }
 
-  return rb_ary_shift(queue->items);
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE LibevQueue_shift_no_wait(VALUE self) {
+    LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE LibevQueue_delete(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_delete(&queue->values, value);
+  return self;
+}
+
+VALUE LibevQueue_clear(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_clear(&queue->values);
+  return self;
+}
+
+long LibevQueue_len(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->values.count;
 }
 
 VALUE LibevQueue_shift_each(VALUE self) {
   LibevQueue_t *queue;
-  VALUE old_queue;
   GetQueue(self, queue);
-  old_queue = queue->items;
-  queue->items = rb_ary_new();
-
-  if (rb_block_given_p()) {
-    long len = RARRAY_LEN(old_queue);
-    long i;
-    for (i = 0; i < len; i++) {
-      rb_yield(RARRAY_AREF(old_queue, i));
-    }
-    RB_GC_GUARD(old_queue);
-    return self;
-  }
-  else {
-    RB_GC_GUARD(old_queue);
-    return old_queue;
-  }
+
+  ring_buffer_shift_each(&queue->values);
+  return self;
+}
+
+VALUE LibevQueue_shift_all(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift_all(&queue->values);
 }
 
 VALUE LibevQueue_empty_p(VALUE self) {
   LibevQueue_t *queue;
   GetQueue(self, queue);
 
-  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
+  return (queue->values.count == 0) ? Qtrue : Qfalse;
+}
+
+void LibevQueue_trace(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  printf(
+    "queue size: %d count: %d head: %d tail: %d\n",
+    queue->values.size,
+    queue->values.count,
+    queue->values.head,
+    queue->values.tail
+  );
 }
 
 void Init_LibevQueue() {
@@ -205,11 +273,15 @@ void Init_LibevQueue() {
   rb_define_method(cLibevQueue, "initialize", LibevQueue_initialize, 0);
   rb_define_method(cLibevQueue, "push", LibevQueue_push, 1);
   rb_define_method(cLibevQueue, "<<", LibevQueue_push, 1);
+  rb_define_method(cLibevQueue, "unshift", LibevQueue_unshift, 1);
 
-  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
   rb_define_method(cLibevQueue, "shift", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "shift_no_wait", LibevQueue_shift_no_wait, 0);
+  rb_define_method(cLibevQueue, "delete", LibevQueue_delete, 1);
 
   rb_define_method(cLibevQueue, "shift_each", LibevQueue_shift_each, 0);
+  rb_define_method(cLibevQueue, "shift_all", LibevQueue_shift_all, 0);
   rb_define_method(cLibevQueue, "empty?", LibevQueue_empty_p, 0);
 }
 

data/ext/polyphony/polyphony.c

@@ -7,11 +7,8 @@ ID ID_call;
 ID ID_caller;
 ID ID_clear;
 ID ID_each;
-ID ID_empty;
 ID ID_inspect;
 ID ID_new;
-ID ID_pop;
-ID ID_push;
 ID ID_raise;
 ID ID_ivar_running;
 ID ID_ivar_thread;
@@ -62,13 +59,10 @@ void Init_Polyphony() {
   ID_caller         = rb_intern("caller");
   ID_clear          = rb_intern("clear");
   ID_each           = rb_intern("each");
-  ID_empty          = rb_intern("empty?");
   ID_inspect        = rb_intern("inspect");
   ID_ivar_running   = rb_intern("@running");
   ID_ivar_thread    = rb_intern("@thread");
   ID_new            = rb_intern("new");
-  ID_pop            = rb_intern("pop");
-  ID_push           = rb_intern("push");
   ID_raise          = rb_intern("raise");
   ID_runnable       = rb_intern("runnable");
   ID_runnable_value = rb_intern("runnable_value");

data/ext/polyphony/polyphony.h

@@ -1,5 +1,5 @@
-#ifndef RUBY_EV_H
-#define RUBY_EV_H
+#ifndef POLYPHONY_H
+#define POLYPHONY_H
 
 #include "ruby.h"
 #include "ruby/io.h"
@@ -76,9 +76,16 @@ VALUE LibevAgent_unref(VALUE self);
 int LibevAgent_ref_count(VALUE self);
 void LibevAgent_reset_ref_count(VALUE self);
 
-VALUE Polyphony_snooze(VALUE self);
+VALUE LibevQueue_push(VALUE self, VALUE value);
+VALUE LibevQueue_unshift(VALUE self, VALUE value);
+VALUE LibevQueue_shift(VALUE self);
+VALUE LibevQueue_shift_no_wait(VALUE self);
+VALUE LibevQueue_clear(VALUE self);
+VALUE LibevQueue_delete(VALUE self, VALUE value);
+long LibevQueue_len(VALUE self);
+void LibevQueue_trace(VALUE self);
 
-VALUE Polyphony_Queue_push(VALUE self, VALUE value);
+VALUE Polyphony_snooze(VALUE self);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
@@ -87,4 +94,4 @@ int io_setstrbuf(VALUE *str, long len);
 void io_set_read_length(VALUE str, long n, int shrinkable);
 VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
-#endif /* RUBY_EV_H */
+#endif /* POLYPHONY_H */

data/ext/polyphony/polyphony_ext.c

@@ -4,7 +4,6 @@ void Init_Fiber();
 void Init_Polyphony();
 void Init_LibevAgent();
 void Init_LibevQueue();
-void Init_Socket();
 void Init_Thread();
 void Init_Tracing();
 
@@ -16,7 +15,6 @@ void Init_polyphony_ext() {
   Init_LibevQueue();
 
   Init_Fiber();
-  Init_Socket();
   Init_Thread();
 
   Init_Tracing();

data/ext/polyphony/ring_buffer.c

@@ -0,0 +1,120 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+void ring_buffer_init(ring_buffer *buffer) {
+  buffer->size = 1;
+  buffer->count = 0;
+  buffer->entries = malloc(buffer->size * sizeof(VALUE));
+  buffer->head = 0;
+  buffer->tail = 0;
+}
+
+void ring_buffer_free(ring_buffer *buffer) {
+  free(buffer->entries);
+}
+
+int ring_buffer_empty_p(ring_buffer *buffer) {
+  return buffer->count == 0;
+}
+
+#define TRACE_RING_BUFFER(func, buffer) printf( \
+  "%s size: %d count: %d head: %d tail: %d\n", \
+  func, \
+  buffer->size, \
+  buffer->count, \
+  buffer->head, \
+  buffer->tail \
+)
+
+VALUE ring_buffer_shift(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_shift", buffer);
+
+  VALUE value;
+  if (buffer->count == 0) return Qnil;
+
+  value = buffer->entries[buffer->head];
+  buffer->head = (buffer->head + 1) % buffer->size;
+  buffer->count--;
+  // INSPECT(value);
+  return value;
+}
+
+void ring_buffer_resize(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_resize", buffer);
+
+  unsigned int old_size = buffer->size;
+  buffer->size = old_size == 1 ? 4 : old_size * 2;
+  // printf("new size: %d\n", buffer->size);
+  buffer->entries = realloc(buffer->entries, buffer->size * sizeof(VALUE));
+  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 ring_buffer_unshift(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_unshift", buffer);
+  // INSPECT(value);
+
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->head = (buffer->head - 1) % buffer->size;
+  buffer->entries[buffer->head] = value;
+  buffer->count++;
+}
+
+void ring_buffer_push(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_push", buffer);
+  // INSPECT(value);
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->entries[buffer->tail] = value;
+  buffer->tail = (buffer->tail + 1) % buffer->size;
+  buffer->count++;
+}
+
+void ring_buffer_mark(ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size]);
+}
+
+void ring_buffer_shift_each(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_shift_each", buffer);
+
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_yield(buffer->entries[(buffer->head + i) % buffer->size]);
+
+  buffer->count = buffer->head = buffer->tail = 0;
+}
+
+VALUE ring_buffer_shift_all(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_all", buffer);
+  VALUE array = rb_ary_new_capa(buffer->count);
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_ary_push(array, buffer->entries[(buffer->head + i) % buffer->size]);
+  buffer->count = buffer->head = buffer->tail = 0;
+  return array;
+}
+
+void ring_buffer_delete_at(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 ring_buffer_delete(ring_buffer *buffer, VALUE value) {
+  // TRACE_RING_BUFFER("ring_buffer_delete", buffer);
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx] == value) {
+      ring_buffer_delete_at(buffer, idx);
+      return;
+    }
+  }
+}
+
+void ring_buffer_clear(ring_buffer *buffer) {
+  // TRACE_RING_BUFFER("ring_buffer_clear", buffer);
+  buffer->count = buffer->head = buffer->tail = 0;
+}