polyphony 0.78 → 0.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51eecc20956cb4f1a35a7f6510dea2730652700e99d29c7d42ade201a119ea2e
-  data.tar.gz: bc2b57dc2cc5a8918bba1d8bf526cdbe23f44d134f9bdca5018b9e9e66930f91
+  metadata.gz: aef5f8ee7585e1ae6a6632099329ba35b7dc6959dba5041f4cdcbaf92caded72
+  data.tar.gz: b168b56f080029e4167e2528e66b83186a635ea4bda8dc74882dfe70639421fc
 SHA512:
-  metadata.gz: 21c446f9a6fa032577b245e6de5155832c8e6932d6c17e58824a55923c82be014453b64b29ccbb66fe5d01cde8622d3275664acda403637954f1e7e6851e93c7
-  data.tar.gz: a57831fe861ac51fa43692b66175291a457077822cdb5f795a093fca1e44bf95fb2b6a312cfe8a6c2b3c3e873319ffd03436e6236874a6acdd45843a21bc4981
+  metadata.gz: aa7bd86706d5879c884b4f5bdc7a10556cbe28e6737ff89e5107589e1630028098dd815424ef357e51879a7e689cd5127ea30105eb1c36a174da7385b8f6f433
+  data.tar.gz: 3c4b35eed6900d55c5295c366803b944a6e423775ca5278f4b2600a309cb547cda12a2167ae40a4ef8e0001a1b6a8b8ea936129246f24d87b0eec59c9d31a3b4

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.81 2022-03-03
+
+- Restore public visibility for `Polyphony::Process.kill_process`
+- Restore public visibility for `Polyphony::Net.setup_alpn`
+
+## 0.80 2022-02-28
+
+- Prevent reentry into `trace_proc`
+- Rename `__parser_read_method__` to `__read_method__`
+- Rename `ResourcePool#preheat!` to `#fill`.
+- Remove ability to use `#cancel_after` or `#move_on` without a block
+- Add #move_on alias to `Fiber#interrupt`
+- Allow specifying exception in `Fiber#cancel`
+- Remove deprecated `Polyphony::Channel` class
+
+## 0.79 2022-02-19
+
+- Overhaul trace events system (#73)
+
 ## 0.78 2022-02-16
 
 - Fix Polyphony::Queue API compatibility (#72)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.78)
+    polyphony (0.81)
 
 GEM
   remote: https://rubygems.org/
@@ -60,6 +60,7 @@ GEM
     unicode-display_width (1.8.0)
 
 PLATFORMS
+  ruby
   universal-darwin
   universal-freebsd
   universal-linux

data/examples/core/pingpong.rb

@@ -3,18 +3,21 @@
 require 'bundler/setup'
 require 'polyphony'
 
-pong = spin_loop do
+require 'polyphony/core/debug'
+Polyphony::Trace.start_event_firehose(STDOUT)
+
+pong = spin_loop(:pong) do
   msg, ping = receive
   puts msg
   ping << 'pong'
 end
 
-ping = spin do
-  3.times do
+ping = spin(:ping) do
+  1.times do
     pong << ['ping', Fiber.current]
     msg = receive
     puts msg
   end
 end
 
-ping.await
+ping.await

data/examples/core/zlib_stream.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'zlib'
+
+r, w = IO.pipe
+writer = Zlib::GzipWriter.new(w)
+
+writer << 'chunk'
+writer.flush
+p pos: writer.pos
+w.close
+
+p r.read

data/ext/polyphony/backend_common.c

@@ -17,6 +17,7 @@ inline void backend_base_initialize(struct Backend_base *base) {
   base->idle_gc_last_time = 0;
   base->idle_proc = Qnil;
   base->trace_proc = Qnil;
+  base->in_trace_proc = 0;
 }
 
 inline void backend_base_finalize(struct Backend_base *base) {
@@ -65,7 +66,7 @@ VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
 
   base->switch_count++;
   if (SHOULD_TRACE(base))
-    TRACE(base, 3, SYM_fiber_switchpoint, current_fiber, CALLER());
+    TRACE(base, 3, SYM_block, current_fiber, CALLER());
 
   while (1) {
     next = runqueue_shift(&base->runqueue);
@@ -96,8 +97,6 @@ VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
   if (next.fiber == Qnil) return Qnil;
 
   // run next fiber
-  COND_TRACE(base, 3, SYM_fiber_run, next.fiber, next.value);
-
   rb_ivar_set(next.fiber, ID_ivar_runnable, Qnil);
   RB_GC_GUARD(next.fiber);
   RB_GC_GUARD(next.value);
@@ -112,7 +111,7 @@ void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_bas
   if (rb_fiber_alive_p(fiber) != Qtrue) return;
   already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
 
-  COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
+  COND_TRACE(base, 5, SYM_schedule, fiber, value, prioritize ? Qtrue : Qfalse, CALLER());
 
   runqueue = rb_ivar_get(fiber, ID_ivar_parked) == Qtrue ? &base->parked_runqueue : &base->runqueue;
 
@@ -139,7 +138,7 @@ inline void backend_base_unpark_fiber(struct Backend_base *base, VALUE fiber) {
 }
 
 inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
-  if (base->trace_proc == Qnil) return;
+  if (base->trace_proc == Qnil || base->in_trace_proc) return;
 
   rb_funcallv(base->trace_proc, ID_call, argc, argv);
 }
@@ -244,15 +243,24 @@ inline VALUE backend_await(struct Backend_base *backend) {
   VALUE ret;
   backend->pending_count++;
   ret = Thread_switch_fiber(rb_thread_current());
+
+  // run next fiber
+  COND_TRACE(backend, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
+
   backend->pending_count--;
   RB_GC_GUARD(ret);
   return ret;
 }
 
-inline VALUE backend_snooze() {
+inline VALUE backend_snooze(struct Backend_base *backend) {
   VALUE ret;
-  Fiber_make_runnable(rb_fiber_current(), Qnil);
-  ret = Thread_switch_fiber(rb_thread_current());
+  VALUE fiber = rb_fiber_current();
+  VALUE thread = rb_thread_current();
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(thread);
+
+  COND_TRACE(backend, 4, SYM_unblock, fiber, ret, CALLER());
+  
   return ret;
 }
 

data/ext/polyphony/backend_common.h

@@ -9,6 +9,7 @@
 #include "ruby.h"
 #include "ruby/io.h"
 #include "runqueue.h"
+#include "polyphony.h"
 
 struct backend_stats {
   unsigned int runqueue_size;
@@ -32,6 +33,7 @@ struct Backend_base {
   double idle_gc_last_time;
   VALUE idle_proc;
   VALUE trace_proc;
+  unsigned int in_trace_proc;
 };
 
 void backend_base_initialize(struct Backend_base *base);
@@ -46,8 +48,12 @@ void backend_trace(struct Backend_base *base, int argc, VALUE *argv);
 struct backend_stats backend_base_stats(struct Backend_base *base);
 
 // tracing
-#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil)
-#define TRACE(base, ...)  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__)
+#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil && !(base)->in_trace_proc)
+#define TRACE(base, ...) { \
+  (base)->in_trace_proc = 1; \
+  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__); \
+  (base)->in_trace_proc = 0; \
+}
 #define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
 
 
@@ -80,7 +86,7 @@ void fptr_finalize(rb_io_t *fptr);
 
 struct backend_stats backend_get_stats(VALUE self);
 VALUE backend_await(struct Backend_base *backend);
-VALUE backend_snooze();
+VALUE backend_snooze(struct Backend_base *backend);
 
 // macros for doing read loops
 #define READ_LOOP_PREPARE_STR() { \

data/ext/polyphony/backend_io_uring.c

@@ -102,6 +102,24 @@ static VALUE Backend_initialize(VALUE self) {
   return self;
 }
 
+static inline struct io_buffer get_io_buffer(VALUE in) {
+  if (FIXNUM_P(in)) {
+    struct raw_buffer *raw = (struct raw_buffer *)(FIX2LONG(in));
+    return (struct io_buffer){ raw->base, raw->size, 1 };
+  }
+  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+}
+
+static inline VALUE coerce_io_string_or_buffer(VALUE buf) {
+  switch (TYPE(buf)) {
+    case T_STRING:
+    case T_FIXNUM:
+      return buf;
+    default:
+      return StringValue(buf);
+  }
+}
+
 VALUE Backend_finalize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -216,12 +234,12 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
     io_uring_submit(&backend->ring);
   }
 
-  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
+  COND_TRACE(&backend->base, 2, SYM_enter_poll, rb_fiber_current());
   
   if (is_blocking) io_uring_backend_poll(backend);
   io_uring_backend_handle_ready_cqes(backend);
   
-  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
+  COND_TRACE(&backend->base, 2, SYM_leave_poll, rb_fiber_current());
 
   return self;
 }
@@ -332,23 +350,37 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long buffer_size = dynamic_len ? 4096 : NUM2INT(length);
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  int shrinkable;
-  char *buf;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
-
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
+    buffer.base += buf_pos;
+    buffer.size -= buf_pos;
+  }
+  else {
+    expandable_buffer = length == Qnil;
+    long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(str);
+    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
+
+    if (string_cap < expected_read_length + buf_pos) {
+      shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
+      buffer.base = RSTRING_PTR(str) + buf_pos;
+      buffer.size = expected_read_length;
+    }
+    else {
+      buffer.base += buf_pos;
+      buffer.size = string_cap - buf_pos;
+      if (buffer.size > expected_read_length)
+        buffer.size = expected_read_length;
+    }
   }
-  else buf_pos = 0;
-  shrinkable = io_setstrbuf(&str, buf_pos + buffer_size);
-  buf = RSTRING_PTR(str) + buf_pos;
 
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
@@ -364,7 +396,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
     int result;
     int completed;
     
-    io_uring_prep_read(sqe, fptr->fd, buf, buffer_size - total, -1);
+    io_uring_prep_read(sqe, fptr->fd, buffer.base, buffer.size - total, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -383,22 +415,28 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       total += result;
       if (!read_to_eof) break;
 
-      if (total == buffer_size) {
-        if (!dynamic_len) break;
+      if (total == buffer.size) {
+        if (!expandable_buffer) break;
 
         // resize buffer
-        rb_str_resize(str, buf_pos + total);
-        rb_str_modify_expand(str, buffer_size);
-        buf = RSTRING_PTR(str) + buf_pos + total;
-        shrinkable = 0;
-        buffer_size += buffer_size;
+        rb_str_resize(str, total + buf_pos);
+        rb_str_modify_expand(str, buffer.size);
+        shrinkable_string = 0;
+        buffer.base = RSTRING_PTR(str) + total + buf_pos;
+        buffer.size = buffer.size;
+      }
+      else {
+        buffer.base += result;
+        buffer.size -= result;
+        if (!buffer.size) break;
       }
-      else buf += result;
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    io_enc_str(str, fptr);
+  }
 
   if (!total) return Qnil;
 
@@ -514,9 +552,9 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.size;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -532,7 +570,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
+    io_uring_prep_write(sqe, fptr->fd, buffer.base, left, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -546,12 +584,12 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.base += result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.size);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
@@ -1108,7 +1146,7 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
       if (!completed) return resume_value;
     }
     else {
-      resume_value = backend_snooze();
+      resume_value = backend_snooze(&backend->base);
       RAISE_IF_EXCEPTION(resume_value);
     }
 
@@ -1591,6 +1629,22 @@ VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
   return self;
 }
 
+VALUE Backend_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(rb_thread_current());
+
+  COND_TRACE(&backend->base, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
 void Backend_park_fiber(VALUE self, VALUE fiber) {
   Backend_t *backend;
   GetBackend(self, backend);

data/ext/polyphony/backend_libev.c

@@ -168,7 +168,7 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
 
   backend->base.poll_count++;
 
-  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
+  COND_TRACE(&backend->base, 2, SYM_enter_poll, rb_fiber_current());
   
 ev_run:
   backend->base.currently_polling = 1;
@@ -177,7 +177,7 @@ ev_run:
   backend->base.currently_polling = 0;
   if (errno == EINTR && runqueue_empty_p(&backend->base.runqueue)) goto ev_run;
   
-  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
+  COND_TRACE(&backend->base, 2, SYM_leave_poll, rb_fiber_current());
 
   return self;
 }
@@ -305,7 +305,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = backend_snooze();
+      switchpoint_result = backend_snooze(&backend->base);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
@@ -375,7 +375,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = backend_snooze();
+      switchpoint_result = backend_snooze(&backend->base);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
@@ -428,7 +428,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = backend_snooze();
+      switchpoint_result = backend_snooze(&backend->base);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
@@ -483,7 +483,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   }
 
   if (watcher.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -558,7 +558,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     }
   }
   if (watcher.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -611,7 +611,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
     else {
       VALUE socket;
       rb_io_t *fp;
-      switchpoint_result = backend_snooze();
+      switchpoint_result = backend_snooze(&backend->base);
 
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
@@ -669,7 +669,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
     }
     else {
       rb_io_t *fp;
-      switchpoint_result = backend_snooze();
+      switchpoint_result = backend_snooze(&backend->base);
 
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
@@ -727,7 +727,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
   else {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -774,7 +774,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   }
 
   if (watcher.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -880,7 +880,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   }
 
   if (watcher.ctx.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -935,7 +935,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   }
 
   if (watcher.ctx.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -1009,7 +1009,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   }
 
   if (watcher.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -1089,7 +1089,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
 done:
   if (watcher.fiber == Qnil) {
-    switchpoint_result = backend_snooze();
+    switchpoint_result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -1171,7 +1171,7 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
       RAISE_IF_EXCEPTION(resume_value);
     }
     else {
-      resume_value = backend_snooze();
+      resume_value = backend_snooze(&backend->base);
       RAISE_IF_EXCEPTION(resume_value);
     }
 
@@ -1530,7 +1530,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   }
 
   if (watcher.ctx.fiber == Qnil) {
-    result = backend_snooze();
+    result = backend_snooze(&backend->base);
     if (TEST_EXCEPTION(result)) goto error;
   }
   RB_GC_GUARD(str);
@@ -1564,6 +1564,22 @@ VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
   return self;
 }
 
+VALUE Backend_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(rb_thread_current());
+
+  COND_TRACE(&backend->base, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
 void Backend_park_fiber(VALUE self, VALUE fiber) {
   Backend_t *backend;
   GetBackend(self, backend);

data/ext/polyphony/fiber.c

@@ -10,13 +10,13 @@ VALUE SYM_running;
 VALUE SYM_runnable;
 VALUE SYM_waiting;
 
-VALUE SYM_fiber_create;
-VALUE SYM_fiber_event_poll_enter;
-VALUE SYM_fiber_event_poll_leave;
-VALUE SYM_fiber_run;
-VALUE SYM_fiber_schedule;
-VALUE SYM_fiber_switchpoint;
-VALUE SYM_fiber_terminate;
+VALUE SYM_spin;
+VALUE SYM_enter_poll;
+VALUE SYM_leave_poll;
+VALUE SYM_unblock;
+VALUE SYM_schedule;
+VALUE SYM_block;
+VALUE SYM_terminate;
 
 static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
   VALUE arg = (argc == 0) ? Qnil : argv[0];
@@ -157,24 +157,24 @@ void Init_Fiber() {
   rb_global_variable(&SYM_runnable);
   rb_global_variable(&SYM_waiting);
 
-  ID_ivar_auto_watcher        = rb_intern("@auto_watcher");
-  ID_ivar_mailbox             = rb_intern("@mailbox");
-  ID_ivar_result              = rb_intern("@result");
-  ID_ivar_waiting_fibers      = rb_intern("@waiting_fibers");
-
-  SYM_fiber_create            = ID2SYM(rb_intern("fiber_create"));
-  SYM_fiber_event_poll_enter  = ID2SYM(rb_intern("fiber_event_poll_enter"));
-  SYM_fiber_event_poll_leave  = ID2SYM(rb_intern("fiber_event_poll_leave"));
-  SYM_fiber_run               = ID2SYM(rb_intern("fiber_run"));
-  SYM_fiber_schedule          = ID2SYM(rb_intern("fiber_schedule"));
-  SYM_fiber_switchpoint       = ID2SYM(rb_intern("fiber_switchpoint"));
-  SYM_fiber_terminate         = ID2SYM(rb_intern("fiber_terminate"));
-
-  rb_global_variable(&SYM_fiber_create);
-  rb_global_variable(&SYM_fiber_event_poll_enter);
-  rb_global_variable(&SYM_fiber_event_poll_leave);
-  rb_global_variable(&SYM_fiber_run);
-  rb_global_variable(&SYM_fiber_schedule);
-  rb_global_variable(&SYM_fiber_switchpoint);
-  rb_global_variable(&SYM_fiber_terminate);
+  ID_ivar_auto_watcher    = rb_intern("@auto_watcher");
+  ID_ivar_mailbox         = rb_intern("@mailbox");
+  ID_ivar_result          = rb_intern("@result");
+  ID_ivar_waiting_fibers  = rb_intern("@waiting_fibers");
+
+  SYM_spin                = ID2SYM(rb_intern("spin"));
+  SYM_enter_poll          = ID2SYM(rb_intern("enter_poll"));
+  SYM_leave_poll          = ID2SYM(rb_intern("leave_poll"));
+  SYM_unblock             = ID2SYM(rb_intern("unblock"));
+  SYM_schedule            = ID2SYM(rb_intern("schedule"));
+  SYM_block               = ID2SYM(rb_intern("block"));
+  SYM_terminate           = ID2SYM(rb_intern("terminate"));
+
+  rb_global_variable(&SYM_spin);
+  rb_global_variable(&SYM_enter_poll);
+  rb_global_variable(&SYM_leave_poll);
+  rb_global_variable(&SYM_unblock);
+  rb_global_variable(&SYM_schedule);
+  rb_global_variable(&SYM_block);
+  rb_global_variable(&SYM_terminate);
 }

data/ext/polyphony/polyphony.c

@@ -27,14 +27,7 @@ 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());
-  RAISE_IF_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  return ret;
+  return Backend_snooze(BACKEND());
 }
 
 static VALUE Polyphony_suspend(VALUE self) {
@@ -125,6 +118,12 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_backend_test(VALUE self, VALUE io, VALUE str) {
+  struct raw_buffer buffer = { RSTRING_PTR(str), RSTRING_LEN(str) };
+  VALUE args[2] = { io, LONG2FIX((long)&buffer) };
+  return Polyphony_backend_write(2, args, self);
+}
+
 // VALUE Polyphony_backend_close(VALUE self, VALUE io) {
 //   return Backend_close(BACKEND(), io);
 // }
@@ -156,6 +155,8 @@ void Init_Polyphony() {
   // rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
   rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Backend_verify_blocking_mode, 2);
 
+  rb_define_singleton_method(mPolyphony, "backend_test", Polyphony_backend_test, 2);
+
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);