polyphony 0.64 → 0.68

data/ext/polyphony/backend_io_uring_context.c

@@ -50,6 +50,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
   ctx->resume_value = Qnil;
   ctx->ref_count = 2;
   ctx->result = 0;
+  ctx->buffer_count = 0;
 
   store->taken_count++;
 
@@ -67,6 +68,8 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 
+  if (ctx->buffer_count > 1) free(ctx->buffers);
+
   store->taken_count--;
   store->available_count++;
 
@@ -93,3 +96,42 @@ void context_store_free(op_context_store_t *store) {
     store->taken = next;
   }
 }
+
+inline void context_store_mark_taken_buffers(op_context_store_t *store) {
+  op_context_t *ctx = store->taken;
+  while (ctx) {
+    for (unsigned int i = 0; i < ctx->buffer_count; i++)
+      rb_gc_mark(i == 0 ? ctx->buffer0 : ctx->buffers[i - 1]);
+    ctx = ctx->next;
+  }
+}
+
+inline void context_attach_buffers(op_context_t *ctx, unsigned int count, VALUE *buffers) {
+  // attaching buffers to the context is done in order to ensure that any GC
+  // pass done before the context is released will mark those buffers, even if
+  // the fiber has already been resumed and the buffers are not in use anymore.
+  // This is done in order to prevent a possible race condition where on the
+  // kernel side the buffers are still in use, but in userspace they have
+  // effectively been freed after a GC pass.
+  ctx->buffer_count = count;
+  if (count > 1)
+    ctx->buffers = malloc(sizeof(VALUE) * (count - 1));
+  for (unsigned int i = 0; i < count; i++)
+    if (!i) ctx->buffer0 = buffers[0];
+    else    ctx->buffers[i - 1] = buffers[i];
+}
+
+inline void context_attach_buffers_v(op_context_t *ctx, unsigned int count, ...) {
+  va_list values;
+
+  va_start(values, count);
+
+  ctx->buffer_count = count;
+  if (count > 1)
+    ctx->buffers = malloc(sizeof(VALUE) * (count - 1));
+  for (unsigned int i = 0; i < count; i++)
+    if (!i) ctx->buffer0 = va_arg(values, VALUE);
+    else    ctx->buffers[i - 1] = va_arg(values, VALUE);
+
+  va_end(values);
+}

data/ext/polyphony/backend_io_uring_context.h

@@ -27,6 +27,9 @@ typedef struct op_context {
   int               result;
   VALUE             fiber;
   VALUE             resume_value;
+  unsigned int      buffer_count;
+  VALUE             buffer0;
+  VALUE             *buffers;
 } op_context_t;
 
 typedef struct op_context_store {
@@ -43,14 +46,8 @@ void context_store_initialize(op_context_store_t *store);
 op_context_t *context_store_acquire(op_context_store_t *store, enum op_type type);
 int context_store_release(op_context_store_t *store, op_context_t *ctx);
 void context_store_free(op_context_store_t *store);
-
-inline unsigned int OP_CONTEXT_RELEASE(op_context_store_t *store, op_context_t *ctx) {
-  int completed = !ctx->ref_count;
-  if (ctx->ref_count)
-    ctx->ref_count -= 1;
-  else
-    context_store_release(store, ctx);
-  return completed;
-}
+void context_store_mark_taken_buffers(op_context_store_t *store);
+void context_attach_buffers(op_context_t *ctx, unsigned int count, VALUE *buffers);
+void context_attach_buffers_v(op_context_t *ctx, unsigned int count, ...);
 
 #endif /* BACKEND_IO_URING_CONTEXT_H */

data/ext/polyphony/backend_libev.c

@@ -941,9 +941,8 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
-#endif
-
-VALUE Backend_fake_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+#else
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   VALUE switchpoint_result = Qnil;
@@ -1018,7 +1017,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE Backend_fake_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   VALUE switchpoint_result = Qnil;
@@ -1097,6 +1096,7 @@ done:
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
+#endif
 
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
@@ -1384,6 +1384,64 @@ inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct lib
   return 0;
 }
 
+static inline int splice_chunks_splice(Backend_t *backend, int src_fd, int dest_fd, int maxlen, 
+  struct libev_rw_io *watcher, VALUE *result, int *chunk_len) {
+#ifdef POLYPHONY_LINUX
+  backend->base.op_count++;
+  while (1) {
+    *chunk_len = splice(src_fd, 0, dest_fd, 0, maxlen, 0);
+    if (*chunk_len >= 0) return 0;
+    
+    int err = errno;
+    if (err != EWOULDBLOCK && err != EAGAIN) return err;
+
+    *result = libev_wait_rw_fd_with_watcher(backend, src_fd, dest_fd, watcher);
+    if (TEST_EXCEPTION(*result)) return -1;
+  }
+#else
+  char *buf = malloc(maxlen);
+  int ret;
+
+  backend->base.op_count++;
+  while (1) {
+    *chunk_len = read(src_fd, buf, maxlen);
+    if (*chunk_len >= 0) break;
+
+    ret = errno;
+    if ((ret != EWOULDBLOCK && ret != EAGAIN)) goto done;
+
+    *result = libev_wait_rw_fd_with_watcher(backend, src_fd, -1, watcher);
+    if (TEST_EXCEPTION(*result)) goto exception;
+  }
+
+  backend->base.op_count++;
+  char *ptr = buf;
+  int left = *chunk_len;
+  while (left > 0) {
+    ssize_t n = write(dest_fd, ptr, left);
+    if (n < 0) {
+      ret = errno;
+      if ((ret != EWOULDBLOCK && ret != EAGAIN)) goto done;
+
+      *result = libev_wait_rw_fd_with_watcher(backend, -1, dest_fd, watcher);
+
+      if (TEST_EXCEPTION(*result)) goto exception;
+    }
+    else {
+      ptr += n;
+      left -= n;
+    }
+  }
+  ret = 0;
+  goto done;
+exception:
+  ret = -1;
+done:
+  free(buf);
+  return ret;
+#endif
+}
+
 VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VALUE postfix, VALUE chunk_prefix, VALUE chunk_postfix, VALUE chunk_size) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1421,26 +1479,13 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   fcntl(pipefd[1], F_SETFL, O_NONBLOCK);
 
   if (prefix != Qnil) {
-    int err = splice_chunks_write(backend, dest_fptr->fd, prefix, &watcher, &result);
+    err = splice_chunks_write(backend, dest_fptr->fd, prefix, &watcher, &result);
     if (err == -1) goto error; else if (err) goto syscallerror;
   }
   while (1) {
-    int chunk_len;
-    // splice to pipe
-    while (1) {
-      backend->base.op_count++;
-      chunk_len = splice(src_fptr->fd, 0, pipefd[1], 0, maxlen, 0);
-      if (chunk_len < 0) {
-        err = errno;
-        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
-
-        result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, pipefd[1], &watcher);
-        if (TEST_EXCEPTION(result)) goto error;
-      }
-      else {
-        break;
-      }
-    }
+    int chunk_len = 0;
+    err = splice_chunks_splice(backend, src_fptr->fd, pipefd[1], maxlen, &watcher, &result, &chunk_len);
+    if (err == -1) goto error; else if (err) goto syscallerror;
     if (chunk_len == 0) break;
     
     total += chunk_len;
@@ -1453,20 +1498,12 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     }
 
     int left = chunk_len;
-    while (1) {
-      backend->base.op_count++;
-      int n = splice(pipefd[0], 0, dest_fptr->fd, 0, left, 0);
-      if (n < 0) {
-        err = errno;
-        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
+    while (left > 0) {
+      int len;
+      err = splice_chunks_splice(backend, pipefd[0], dest_fptr->fd, left, &watcher, &result, &len);
+      if (err == -1) goto error; else if (err) goto syscallerror;
 
-        result = libev_wait_rw_fd_with_watcher(backend, pipefd[0], dest_fptr->fd, &watcher);
-        if (TEST_EXCEPTION(result)) goto error;
-      }
-      else {
-        left -= n;
-        if (left == 0) break;
-      }
+      left -= len;
     }
 
     if (chunk_postfix != Qnil) {
@@ -1516,6 +1553,20 @@ VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
   return self;
 }
 
+void Backend_park_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_park_fiber(&backend->base, fiber);
+}
+
+void Backend_unpark_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_unpark_fiber(&backend->base, fiber);
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1550,13 +1601,8 @@ void Init_Backend() {
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
 
-  #ifdef POLYPHONY_LINUX
   rb_define_method(cBackend, "splice", Backend_splice, 3);
   rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
-  #else
-  rb_define_method(cBackend, "splice", Backend_fake_splice, 3);
-  rb_define_method(cBackend, "splice_to_eof", Backend_fake_splice_to_eof, 3);
-  #endif
 
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);

data/ext/polyphony/fiber.c

@@ -114,6 +114,22 @@ VALUE Fiber_receive_all_pending(VALUE self) {
   return (mailbox == Qnil) ? rb_ary_new() : Queue_shift_all(mailbox);
 }
 
+VALUE Fiber_park(VALUE self) {
+  rb_ivar_set(self, ID_ivar_parked, Qtrue);
+  Backend_park_fiber(BACKEND(), self);
+  return self;
+}
+
+VALUE Fiber_unpark(VALUE self) {
+  rb_ivar_set(self, ID_ivar_parked, Qnil);
+  Backend_unpark_fiber(BACKEND(), self);
+  return self;
+}
+
+VALUE Fiber_parked_p(VALUE self) {
+  return rb_ivar_get(self, ID_ivar_parked);
+}
+
 void Init_Fiber() {
   VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
   rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
@@ -128,6 +144,10 @@ void Init_Fiber() {
   rb_define_method(cFiber, "receive_all_pending", Fiber_receive_all_pending, 0);
   rb_define_method(cFiber, "mailbox", Fiber_mailbox, 0);
 
+  rb_define_method(cFiber, "__park__", Fiber_park, 0);
+  rb_define_method(cFiber, "__unpark__", Fiber_unpark, 0);
+  rb_define_method(cFiber, "__parked__?", Fiber_parked_p, 0);
+
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));
   SYM_runnable = ID2SYM(rb_intern("runnable"));

data/ext/polyphony/polyphony.c

@@ -12,6 +12,7 @@ ID ID_invoke;
 ID ID_new;
 ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
+ID ID_ivar_parked;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
@@ -160,6 +161,7 @@ void Init_Polyphony() {
   ID_invoke             = rb_intern("invoke");
   ID_ivar_blocking_mode = rb_intern("@blocking_mode");
   ID_ivar_io            = rb_intern("@io");
+  ID_ivar_parked        = rb_intern("@parked");
   ID_ivar_runnable      = rb_intern("@runnable");
   ID_ivar_running       = rb_intern("@running");
   ID_ivar_thread        = rb_intern("@thread");

data/ext/polyphony/polyphony.h

@@ -44,6 +44,7 @@ extern ID ID_invoke;
 extern ID ID_ivar_backend;
 extern ID ID_ivar_blocking_mode;
 extern ID ID_ivar_io;
+extern ID ID_ivar_parked;
 extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
@@ -115,9 +116,11 @@ 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);
+void Backend_park_fiber(VALUE self, VALUE fiber);
+void Backend_unpark_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);
+void Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+void Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
 
 VALUE Polyphony_snooze(VALUE self);

data/ext/polyphony/queue.c

@@ -78,7 +78,7 @@ inline void queue_schedule_blocked_fibers_to_capacity(Queue_t *queue) {
   }
 }
 
-inline void capped_queue_block_push(Queue_t *queue) {
+static 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;

data/ext/polyphony/runqueue.c

@@ -40,19 +40,23 @@ inline int runqueue_index_of(runqueue_t *runqueue, VALUE fiber) {
   return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
 }
 
+inline void runqueue_migrate(runqueue_t *src, runqueue_t *dest, VALUE fiber) {
+  runqueue_ring_buffer_migrate(&src->entries, &dest->entries, fiber);
+}
+
 inline void runqueue_clear(runqueue_t *runqueue) {
   runqueue_ring_buffer_clear(&runqueue->entries);
 }
 
-inline long runqueue_size(runqueue_t *runqueue) {
+inline unsigned int runqueue_size(runqueue_t *runqueue) {
   return runqueue->entries.size;
 }
 
-inline long runqueue_len(runqueue_t *runqueue) {
+inline unsigned int runqueue_len(runqueue_t *runqueue) {
   return runqueue->entries.count;
 }
 
-inline long runqueue_max_len(runqueue_t *runqueue) {
+inline unsigned int runqueue_max_len(runqueue_t *runqueue) {
   unsigned int max_len = runqueue->high_watermark;
   runqueue->high_watermark = 0;
   return max_len;

data/ext/polyphony/runqueue.h

@@ -18,10 +18,11 @@ void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int resche
 runqueue_entry runqueue_shift(runqueue_t *runqueue);
 void runqueue_delete(runqueue_t *runqueue, VALUE fiber);
 int runqueue_index_of(runqueue_t *runqueue, VALUE fiber);
+void runqueue_migrate(runqueue_t *src, runqueue_t *dest, VALUE fiber);
 void runqueue_clear(runqueue_t *runqueue);
-long runqueue_size(runqueue_t *runqueue);
-long runqueue_len(runqueue_t *runqueue);
-long runqueue_max_len(runqueue_t *runqueue);
+unsigned int runqueue_size(runqueue_t *runqueue);
+unsigned int runqueue_len(runqueue_t *runqueue);
+unsigned int runqueue_max_len(runqueue_t *runqueue);
 int runqueue_empty_p(runqueue_t *runqueue);
 
 #endif /* RUNQUEUE_H */

data/ext/polyphony/runqueue_ring_buffer.c

@@ -1,7 +1,7 @@
 #include "polyphony.h"
 #include "runqueue_ring_buffer.h"
 
-void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
   buffer->size = 1;
   buffer->count = 0;
   buffer->entries = malloc(buffer->size * sizeof(runqueue_entry));
@@ -9,17 +9,21 @@ void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
   buffer->tail = 0;
 }
 
-void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
   free(buffer->entries);
 }
 
-int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
+inline int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
   return buffer->count == 0;
 }
 
+inline void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
+  buffer->count = buffer->head = buffer->tail = 0;
+}
+
 static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
 
-runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+inline 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];
@@ -28,7 +32,7 @@ runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
   return value;
 }
 
-void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
+inline 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));
@@ -37,7 +41,7 @@ void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
   buffer->tail = buffer->head + buffer->count;
 }
 
-void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+inline 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;
@@ -46,7 +50,7 @@ void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VAL
   buffer->count++;
 }
 
-void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+inline 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;
@@ -55,14 +59,14 @@ void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE
   buffer->count++;
 }
 
-void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
+inline 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) {
+inline 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];
   }
@@ -70,7 +74,7 @@ void runqueue_ring_buffer_delete_at(runqueue_ring_buffer *buffer, unsigned int i
   buffer->tail = (buffer->tail - 1) % buffer->size;
 }
 
-void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
+inline 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) {
@@ -80,7 +84,7 @@ void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   }
 }
 
-int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
+inline int runqueue_ring_buffer_index_of(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)
@@ -89,6 +93,13 @@ int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
   return -1;
 }
 
-void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
-  buffer->count = buffer->head = buffer->tail = 0;
-}
+inline void runqueue_ring_buffer_migrate(runqueue_ring_buffer *src, runqueue_ring_buffer *dest, VALUE fiber) {
+  for (unsigned int i = 0; i < src->count; i++) {
+    unsigned int idx = (src->head + i) % src->size;
+    if (src->entries[idx].fiber == fiber) {
+      runqueue_ring_buffer_push(dest, src->entries[idx].fiber, src->entries[idx].value);
+      runqueue_ring_buffer_delete_at(src, idx);
+      return;
+    }
+  }
+}