uringmachine 0.4 → 0.5.1

data/ext/um/um_op.c

@@ -1,148 +1,126 @@
 #include "um.h"
 
-inline struct um_result_entry *um_result_checkout(struct um *machine) {
-  if (machine->result_freelist) {
-    struct um_result_entry *entry = machine->result_freelist;
-    machine->result_freelist = entry->next;
-    return entry;
-  }
-
-  struct um_result_entry *entry = malloc(sizeof(struct um_result_entry));
-  return entry;
-}
-
-inline void um_result_checkin(struct um *machine, struct um_result_entry *entry) {
-  entry->next = machine->result_freelist;
-  machine->result_freelist = entry;
+inline void um_op_clear(struct um *machine, struct um_op *op) {
+  memset(op, 0, sizeof(struct um_op));
+  op->fiber = Qnil;
+  op->value = Qnil;
+  op->async_op = Qnil;
 }
 
-inline void um_op_result_cleanup(struct um *machine, struct um_op *op) {
-  struct um_result_entry *entry = op->results_head;
-  while (entry) {
-    struct um_result_entry *next = entry->next;
-    um_result_checkin(machine, entry);
-    entry = next;
+inline void um_op_transient_add(struct um *machine, struct um_op *op) {
+  if (machine->transient_head) {
+    op->next = machine->transient_head;
+    machine->transient_head->prev = op;
   }
-  op->results_head = op->results_tail = NULL;
+  machine->transient_head = op;
 }
 
-inline void um_op_result_push(struct um *machine, struct um_op *op, __s32 result, __u32 flags) {
-  struct um_result_entry *entry = um_result_checkout(machine);
-  entry->next = 0;
-  entry->result = result;
-  entry->flags = flags;
-  if (op->results_tail) {
-    op->results_tail->next = entry;
-    op->results_tail = entry;
-  }
-  else {
-    op->results_head = op->results_tail = entry;
-  }
-}
+inline void um_op_transient_remove(struct um *machine, struct um_op *op) {
+  if (op->prev)
+    op->prev->next = op->next;
+  if (op->next)
+    op->next->prev = op->prev;
 
-inline int um_op_result_shift(struct um *machine, struct um_op *op, __s32 *result, __u32 *flags) {
-  if (!op->results_head) return 0;
-
-  struct um_result_entry *entry = op->results_head;
-  *result = entry->result;
-  *flags = entry->flags;
-  op->results_head = entry->next;
-  if (!op->results_head)
-    op->results_tail = NULL;
-  um_result_checkin(machine, entry);
-  return 1;
+  if (machine->transient_head == op)
+    machine->transient_head = op->next;
 }
 
-inline void um_op_clear(struct um_op *op) {
-  memset(op, 0, sizeof(struct um_op));
-  op->fiber = op->resume_value = Qnil;
+inline void um_runqueue_push(struct um *machine, struct um_op *op) {
+  if (machine->runqueue_tail) {
+    op->prev = machine->runqueue_tail;
+    machine->runqueue_tail->next = op;
+    machine->runqueue_tail = op;
+  }
+  else
+    machine->runqueue_head = machine->runqueue_tail = op;
+  op->next = NULL;
 }
 
-inline struct um_op *um_op_checkout(struct um *machine) {
-  machine->pending_count++;
-
-  struct um_op *op = machine->op_freelist;
-  if (op)
-    machine->op_freelist = op->next;
-  else
-    op = malloc(sizeof(struct um_op));
+inline struct um_op *um_runqueue_shift(struct um *machine) {
+  struct um_op *op = machine->runqueue_head;
+  if (!op) return NULL;
 
-  um_op_clear(op);
+  machine->runqueue_head = op->next;
+  if (!machine->runqueue_head)
+    machine->runqueue_tail = NULL;
   return op;
 }
 
-inline void um_op_checkin(struct um *machine, struct um_op *op) {
-  machine->pending_count--;
-
-  um_op_result_cleanup(machine, op);
-  op->next = machine->op_freelist;
-  machine->op_freelist = op;
+inline void um_op_list_mark(struct um *machine, struct um_op *head) {
+  while (head) {
+    struct um_op *next = head->next;
+    rb_gc_mark_movable(head->fiber);
+    rb_gc_mark_movable(head->value);
+    rb_gc_mark_movable(head->async_op);
+    head = next;
+  }
 }
 
-inline struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber) {
-  struct um_op *op = machine->runqueue_head;
-  while (op) {
-    if (op->fiber == fiber) return op;
-
-    op = op->next;
+inline void um_op_list_compact(struct um *machine, struct um_op *head) {
+  while (head) {
+    struct um_op *next = head->next;
+    head->fiber = rb_gc_location(head->fiber);
+    head->value = rb_gc_location(head->value);
+    head->async_op = rb_gc_location(head->async_op);
+    head = next;
   }
-  return NULL;
 }
 
-inline void um_runqueue_push(struct um *machine, struct um_op *op) {
-  if (machine->runqueue_tail) {
-    op->prev = machine->runqueue_tail;
-    machine->runqueue_tail->next = op;
-    machine->runqueue_tail = op;
-  }
-  else {
-    op->prev = NULL;
-    machine->runqueue_head = machine->runqueue_tail = op;
+inline struct um_op_result *multishot_result_alloc(struct um *machine) {  
+  if (machine->result_freelist) {
+    struct um_op_result *result = machine->result_freelist;
+    machine->result_freelist = result->next;
+    return result;
   }
-  op->next = NULL;
+  return malloc(sizeof(struct um_op_result));
 }
 
-inline void um_runqueue_unshift(struct um *machine, struct um_op *op) {
-  if (machine->runqueue_head) {
-    op->next = machine->runqueue_head;
-    machine->runqueue_head->prev = op;
-    machine->runqueue_head = op;
+inline void multishot_result_free(struct um *machine, struct um_op_result *result) {
+  result->next = machine->result_freelist;
+  machine->result_freelist = result;
+}
+
+inline void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags) {
+  if (!op->multishot_result_count) {
+    op->result.res    = res;
+    op->result.flags  = flags;
+    op->result.next   = NULL;
+    op->multishot_result_tail = &op->result;
   }
   else {
-    op->next = NULL;
-    machine->runqueue_head = machine->runqueue_tail = op;
+    struct um_op_result *result = multishot_result_alloc(machine);
+    result->res   = res;
+    result->flags = flags;
+    result->next  = NULL;
+    op->multishot_result_tail->next = result;
+    op->multishot_result_tail = result;
   }
-  op->prev = NULL;
+  op->multishot_result_count++;
 }
 
-inline struct um_op *um_runqueue_shift(struct um *machine) {
-  struct um_op *op = machine->runqueue_head;
-  if (!op) return NULL;
+inline void um_op_multishot_results_clear(struct um *machine, struct um_op *op) {
+  if (op->multishot_result_count < 1) return;
 
-  op->prev = NULL;
-  if (!op->next) {
-    machine->runqueue_head = machine->runqueue_tail = NULL;
+  struct um_op_result *result = op->result.next;
+  while (result) {
+    struct um_op_result *next = result->next;
+    multishot_result_free(machine, result);
+    result = next;
   }
-  else {
-    machine->runqueue_head = op->next;
-    op->next = NULL;
-  }
-  return op;
+  op->multishot_result_tail = NULL;
+  op->multishot_result_count = 0;
 }
 
-inline void um_free_op_linked_list(struct um *machine, struct um_op *op) {
-  while (op) {
-    struct um_op *next = op->next;
-    um_op_result_cleanup(machine, op);
-    free(op);
-    op = next;
+inline struct um_op *um_op_alloc(struct um *machine) {
+  if (machine->op_freelist) {
+    struct um_op *op = machine->op_freelist;
+    machine->op_freelist = op->next;
+    return op;
   }
+  return malloc(sizeof(struct um_op));
 }
 
-inline void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry) {
-  while (entry) {
-    struct um_result_entry *next = entry->next;
-    free(entry);
-    entry = next;
-  }
+inline void um_op_free(struct um *machine, struct um_op *op) {
+  op->next = machine->op_freelist;
+  machine->op_freelist = op;
 }

data/ext/um/um_queue_class.c

@@ -0,0 +1,58 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE cQueue;
+
+static void Queue_mark(void *ptr) {
+  struct um_queue *queue = ptr;
+  um_queue_mark(queue);
+}
+
+static void Queue_compact(void *ptr) {
+  struct um_queue *queue = ptr;
+  um_queue_compact(queue);
+}
+
+static void Queue_free(void *ptr) {
+  struct um_queue *queue = ptr;
+  um_queue_free(queue);
+}
+
+static size_t Queue_size(const void *ptr) {
+  return sizeof(struct um_queue);
+}
+
+static const rb_data_type_t Queue_type = {
+    "UringMachineQueue",
+    {Queue_mark, Queue_free, Queue_size, Queue_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE Queue_allocate(VALUE klass) {
+  struct um_queue *queue = malloc(sizeof(struct um_queue));
+  return TypedData_Wrap_Struct(klass, &Queue_type, queue);
+}
+
+inline struct um_queue *Queue_data(VALUE self) {
+  return RTYPEDDATA_DATA(self);
+}
+
+VALUE Queue_initialize(VALUE self) {
+  struct um_queue *queue = Queue_data(self);
+  RB_OBJ_WRITE(self, &queue->self, self);
+  um_queue_init(queue);
+  return self;
+}
+
+VALUE Queue_count(VALUE self) {
+  struct um_queue *queue = Queue_data(self);
+  return UINT2NUM(queue->count);
+}
+
+void Init_Queue(void) {
+  cQueue = rb_define_class_under(cUM, "Queue", rb_cObject);
+  rb_define_alloc_func(cQueue, Queue_allocate);
+
+  rb_define_method(cQueue, "initialize", Queue_initialize, 0);
+  rb_define_method(cQueue, "count", Queue_count, 0);
+}