polyphony 0.43.8

data/ext/polyphony/polyphony.c

@@ -0,0 +1,71 @@
+#include "polyphony.h"
+
+VALUE mPolyphony;
+
+ID ID_call;
+ID ID_caller;
+ID ID_clear;
+ID ID_each;
+ID ID_inspect;
+ID ID_new;
+ID ID_raise;
+ID ID_ivar_running;
+ID ID_ivar_thread;
+ID ID_runnable;
+ID ID_runnable_value;
+ID ID_size;
+ID ID_signal;
+ID ID_switch_fiber;
+ID ID_transfer;
+ID ID_R;
+ID ID_W;
+ID ID_RW;
+
+VALUE Polyphony_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(rb_thread_current());
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+static VALUE Polyphony_suspend(VALUE self) {
+  VALUE ret = Thread_switch_fiber(rb_thread_current());
+
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+VALUE Polyphony_trace(VALUE self, VALUE enabled) {
+  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
+  return Qnil;
+}
+
+void Init_Polyphony() {
+  mPolyphony = rb_define_module("Polyphony");
+
+  rb_define_singleton_method(mPolyphony, "trace", Polyphony_trace, 1);
+
+  rb_define_global_function("snooze", Polyphony_snooze, 0);
+  rb_define_global_function("suspend", Polyphony_suspend, 0);
+
+  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_ivar_running   = rb_intern("@running");
+  ID_ivar_thread    = rb_intern("@thread");
+  ID_new            = rb_intern("new");
+  ID_raise          = rb_intern("raise");
+  ID_runnable       = rb_intern("runnable");
+  ID_runnable_value = rb_intern("runnable_value");
+  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

@@ -0,0 +1,97 @@
+#ifndef POLYPHONY_H
+#define POLYPHONY_H
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include "libev.h"
+
+// debugging
+#define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
+#define INSPECT(obj) { VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf("%s\n", StringValueCStr(s));}
+#define FIBER_TRACE(...) if (__tracing_enabled__) { \
+  rb_funcall(rb_cObject, ID_fiber_trace, __VA_ARGS__); \
+}
+
+#define TEST_EXCEPTION(ret) (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
+
+#define TEST_RESUME_EXCEPTION(ret) if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) { \
+  return rb_funcall(rb_mKernel, ID_raise, 1, ret); \
+}
+
+extern VALUE mPolyphony;
+extern VALUE cQueue;
+extern VALUE cEvent;
+
+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_ivar_agent;
+extern ID ID_ivar_running;
+extern ID ID_ivar_thread;
+extern ID ID_new;
+extern ID ID_raise;
+extern ID ID_runnable;
+extern ID ID_runnable_value;
+extern ID ID_signal;
+extern ID ID_size;
+extern ID ID_switch_fiber;
+extern ID ID_transfer;
+
+extern VALUE SYM_fiber_create;
+extern VALUE SYM_fiber_ev_loop_enter;
+extern VALUE SYM_fiber_ev_loop_leave;
+extern VALUE SYM_fiber_run;
+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
+};
+
+// watcher flags
+enum {
+  // a watcher's active field will be set to this after fork
+  GYRO_WATCHER_POST_FORK = 0xFF
+};
+
+VALUE Fiber_auto_watcher(VALUE self);
+void Fiber_make_runnable(VALUE fiber, VALUE value);
+
+VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
+VALUE LibevAgent_break(VALUE self);
+VALUE LibevAgent_pending_count(VALUE self);
+VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write);
+
+VALUE LibevAgent_ref(VALUE self);
+VALUE LibevAgent_unref(VALUE self);
+int LibevAgent_ref_count(VALUE self);
+void LibevAgent_reset_ref_count(VALUE self);
+VALUE LibevAgent_wait_event(VALUE self, VALUE raise);
+
+VALUE Queue_push(VALUE self, VALUE value);
+VALUE Queue_unshift(VALUE self, VALUE value);
+VALUE Queue_shift(VALUE self);
+VALUE Queue_shift_no_wait(VALUE self);
+VALUE Queue_clear(VALUE self);
+VALUE Queue_delete(VALUE self, VALUE value);
+long Queue_len(VALUE self);
+void Queue_trace(VALUE self);
+
+VALUE Polyphony_snooze(VALUE self);
+
+VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+VALUE Thread_switch_fiber(VALUE thread);
+
+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 /* POLYPHONY_H */

data/ext/polyphony/polyphony_ext.c

@@ -0,0 +1,21 @@
+#include "polyphony.h"
+
+void Init_Fiber();
+void Init_Polyphony();
+void Init_LibevAgent();
+void Init_Queue();
+void Init_Thread();
+void Init_Tracing();
+
+void Init_polyphony_ext() {
+  ev_set_allocator(xrealloc);
+
+  Init_Polyphony();
+  Init_LibevAgent();
+  Init_Queue();
+
+  Init_Fiber();
+  Init_Thread();
+
+  Init_Tracing();
+}

data/ext/polyphony/queue.c

@@ -0,0 +1,168 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+typedef struct queue {
+  ring_buffer values;
+  ring_buffer shift_queue;
+} Queue_t;
+
+VALUE cQueue = Qnil;
+
+static void Queue_mark(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_mark(&queue->values);
+  ring_buffer_mark(&queue->shift_queue);
+}
+
+static void Queue_free(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_free(&queue->values);
+  ring_buffer_free(&queue->shift_queue);
+  xfree(ptr);
+}
+
+static size_t Queue_size(const void *ptr) {
+  return sizeof(Queue_t);
+}
+
+static const rb_data_type_t Queue_type = {
+  "Queue",
+  {Queue_mark, Queue_free, Queue_size,},
+  0, 0, 0
+};
+
+static VALUE Queue_allocate(VALUE klass) {
+  Queue_t *queue;
+
+  queue = ALLOC(Queue_t);
+  return TypedData_Wrap_Struct(klass, &Queue_type, queue);
+}
+
+#define GetQueue(obj, queue) \
+  TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
+
+static VALUE Queue_initialize(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_init(&queue->values);
+  ring_buffer_init(&queue->shift_queue);
+
+  return self;
+}
+
+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);
+  }
+  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);
+  }
+  ring_buffer_unshift(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_shift(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  if (queue->values.count == 0) {
+    VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    VALUE fiber = rb_fiber_current();
+    VALUE switchpoint_result = Qnil;
+    ring_buffer_push(&queue->shift_queue, fiber);
+    switchpoint_result = LibevAgent_wait_event(agent, Qnil);
+    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
+      ring_buffer_delete(&queue->shift_queue, fiber);
+      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    }
+    RB_GC_GUARD(agent);
+    RB_GC_GUARD(switchpoint_result);
+  }
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_shift_no_wait(VALUE self) {
+    Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_delete(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_clear(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_clear(&queue->values);
+  return self;
+}
+
+long Queue_len(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->values.count;
+}
+
+VALUE Queue_shift_each(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_shift_each(&queue->values);
+  return self;
+}
+
+VALUE Queue_shift_all(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift_all(&queue->values);
+}
+
+VALUE Queue_empty_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return (queue->values.count == 0) ? Qtrue : Qfalse;
+}
+
+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, "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, "shift_each", Queue_shift_each, 0);
+  rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);
+  rb_define_method(cQueue, "empty?", Queue_empty_p, 0);
+}
+
+

data/ext/polyphony/ring_buffer.c

@@ -0,0 +1,96 @@
+#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;
+}
+
+VALUE ring_buffer_shift(ring_buffer *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) {
+  unsigned int old_size = buffer->size;
+  buffer->size = old_size == 1 ? 4 : old_size * 2;
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  buffer->count = buffer->head = buffer->tail = 0;
+}