polyphony 1.4 → 1.6

data/ext/polyphony/backend_io_uring_context.c

@@ -6,20 +6,23 @@
 
 const char *op_type_to_str(enum op_type type) {
   switch (type) {
-  case OP_ACCEPT:   return "ACCEPT";
-  case OP_CHAIN:    return "CHAIN";
-  case OP_CLOSE:    return "CLOSE";
-  case OP_CONNECT:  return "CONNECT";
-  case OP_POLL:     return "POLL";
-  case OP_READ:     return "READ";
-  case OP_RECV:     return "RECV";
-  case OP_RECVMSG:  return "RECVMSG";
-  case OP_SEND:     return "SEND";
-  case OP_SENDMSG:  return "SENDMSG";
-  case OP_SPLICE:   return "SPLICE";
-  case OP_TIMEOUT:  return "TIMEOUT";
-  case OP_WRITEV:   return "WRITEV";
-  case OP_WRITE:    return "WRITE";
+  case OP_ACCEPT:             return "ACCEPT";
+  case OP_CHAIN:              return "CHAIN";
+  case OP_CLOSE:              return "CLOSE";
+  case OP_CONNECT:            return "CONNECT";
+  case OP_POLL:               return "POLL";
+  case OP_READ:               return "READ";
+  case OP_RECV:               return "RECV";
+  case OP_RECVMSG:            return "RECVMSG";
+  case OP_SEND:               return "SEND";
+  case OP_SENDMSG:            return "SENDMSG";
+  case OP_SPLICE:             return "SPLICE";
+  case OP_TIMEOUT:            return "TIMEOUT";
+  case OP_WRITEV:             return "WRITEV";
+  case OP_WRITE:              return "WRITE";
+
+  case OP_MULTISHOT_ACCEPT:   return "ACCEPT MULTISHOT";
+  case OP_MULTISHOT_TIMEOUT:  return "ACCEPT MULTISHOT";
 
   default: return "";
   };
@@ -71,14 +74,15 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
 
   // If a multishot ctx is released, we pretend its ref count is 1, so it will
   // be returned to the store.
-  if (ctx->ref_count == MULTISHOT_REFCOUNT) {
-    ctx->ref_count = 1;
-  }
+  if (ctx->ref_count == MULTISHOT_REFCOUNT) ctx->ref_count = 1;
 
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 
-  if (ctx->buffer_count > 1) free(ctx->buffers);
+  if (ctx->buffer_count > 1) {
+    TRACE_FREE(ctx->buffers);
+    free(ctx->buffers);
+  }
 
   store->taken_count--;
   store->available_count++;
@@ -97,11 +101,13 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
 void context_store_free(op_context_store_t *store) {
   while (store->available) {
     op_context_t *next = store->available->next;
+    TRACE_FREE(store->available);
     free(store->available);
     store->available = next;
   }
   while (store->taken) {
     op_context_t *next = store->taken->next;
+    TRACE_FREE(store->taken);
     free(store->taken);
     store->taken = next;
   }

data/ext/polyphony/backend_io_uring_context.h

@@ -8,7 +8,6 @@ enum op_type {
   OP_CHAIN,
   OP_CLOSE,
   OP_CONNECT,
-  OP_MULTISHOT_ACCEPT,
   OP_NONE,
   OP_POLL,
   OP_READ,
@@ -19,7 +18,9 @@ enum op_type {
   OP_SPLICE,
   OP_TIMEOUT,
   OP_WRITEV,
-  OP_WRITE
+  OP_WRITE,
+  OP_MULTISHOT_ACCEPT,
+  OP_MULTISHOT_TIMEOUT
 };
 
 #define MULTISHOT_REFCOUNT 0xFFFF
@@ -36,6 +37,7 @@ typedef struct op_context {
   unsigned int      buffer_count;
   VALUE             buffer0;
   VALUE             *buffers;
+  double            ts; // timestamp for tracing
 } op_context_t;
 
 typedef struct op_context_store {

data/ext/polyphony/backend_libev.c

@@ -42,21 +42,24 @@ thread.
 #define _GNU_SOURCE 1
 #endif
 
-#include <netdb.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
 #include <unistd.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
 #include <stdnoreturn.h>
 #include <sys/types.h>
+
+#ifdef POLYPHONY_USE_PIDFD_OPEN
 #include <sys/wait.h>
+#endif
+
 #include <fcntl.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
+#ifndef POLYPHONY_WINDOWS
+#include <sys/uio.h>
+#endif
+
 #include "../libev/ev.h"
 #include "backend_common.h"
 
@@ -267,21 +270,25 @@ VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception)
 }
 
 static inline int fd_from_io(VALUE io, rb_io_t **fptr, int write_mode, int rectify_file_pos) {
+  if (TYPE(io) == T_FIXNUM) {
+    *fptr = NULL;
+    return FIX2INT(io);
+  }
+  
   if (rb_obj_class(io) == cPipe) {
     *fptr = NULL;
     Pipe_verify_blocking_mode(io, Qfalse);
     return Pipe_get_fd(io, write_mode);
   }
-  else {
-    VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
-    if (underlying_io != Qnil) io = underlying_io;
-
-    GetOpenFile(io, *fptr);
-    int fd = rb_io_descriptor(io);
-    io_verify_blocking_mode(io, fd, Qfalse);
-    if (rectify_file_pos) rectify_io_file_pos(*fptr);
-    return fd;
-  }
+
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+
+  GetOpenFile(io, *fptr);
+  int fd = rb_io_descriptor(io);
+  io_verify_blocking_mode(io, fd, Qfalse);
+  if (rectify_file_pos) rectify_io_file_pos(*fptr);
+  return fd;
 }
 
 VALUE Backend_read(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE to_eof, VALUE pos) {
@@ -558,6 +565,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+#ifndef POLYPHONY_WINDOWS
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -629,15 +637,23 @@ error:
   free(iov);
   return RAISE_EXCEPTION(switchpoint_result);
 }
+#endif
 
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
   if (argc < 2)
     // TODO: raise ArgumentError
     rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
 
+#ifdef POLYPHONY_WINDOWS
+  int total = 0;
+  for (int i = 1; i < argc; i++)
+    total += FIX2INT(Backend_write(self, argv[0], argv[i]));
+  return INT2FIX(total);
+#else
   return (argc == 2) ?
     Backend_write(self, argv[0], argv[1]) :
     Backend_writev(self, argv[0], argc - 1, argv + 1);
+#endif
 }
 
 VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
@@ -1155,7 +1171,7 @@ VALUE Backend_close(VALUE self, VALUE io) {
   RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
 
-  fptr_finalize(fptr);
+  if (fptr) fptr_finalize(fptr);
   // fd = -1;
   return io;
 }
@@ -1309,7 +1325,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     int e = errno;
     rb_syserr_fail(e, strerror(e));
   }
-  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(WEXITSTATUS(status)));
+  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(status));
 }
 #else
 struct libev_child {
@@ -1317,16 +1333,18 @@ struct libev_child {
   VALUE fiber;
 };
 
+#ifndef POLYPHONY_WINDOWS
 void Backend_child_callback(EV_P_ ev_child *w, int revents) {
   struct libev_child *watcher = (struct libev_child *)w;
-  int exit_status = WEXITSTATUS(w->rstatus);
-  VALUE status;
-
-  status = rb_ary_new_from_args(2, INT2FIX(w->rpid), INT2FIX(exit_status));
+  VALUE status = rb_ary_new_from_args(2, INT2FIX(w->rpid), INT2FIX(w->rstatus));
   Fiber_make_runnable(watcher->fiber, status);
 }
+#endif
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
+#ifdef POLYPHONY_WINDOWS
+  rb_raise(rb_eStandardError, "Not implemented");
+#else
   Backend_t *backend;
   struct libev_child watcher;
   VALUE switchpoint_result = Qnil;
@@ -1344,8 +1362,9 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
+#endif // #ifdef POLYPHONY_WINDOWS
 }
-#endif
+#endif // #ifdef POLYPHONY_USE_PIDFD_OPEN
 
 void Backend_async_callback(EV_P_ ev_async *w, int revents) { }
 
@@ -1497,6 +1516,7 @@ done:
 #endif
 }
 
+#ifdef POLYPHONY_LINUX
 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);
@@ -1586,6 +1606,7 @@ error:
   if (pipefd[1] != -1) close(pipefd[1]);
   return RAISE_EXCEPTION(result);
 }
+#endif
 
 VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
   Backend_t *backend;
@@ -1651,7 +1672,10 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
   rb_define_method(cBackend, "idle_proc=", Backend_idle_proc_set, 1);
+  
+  #ifdef POLYPHONY_LINUX
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
+  #endif
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);

data/ext/polyphony/event.c

@@ -3,6 +3,8 @@
 
 typedef struct event {
   VALUE waiting_fiber;
+  int signaled;
+  VALUE result;
 } Event_t;
 
 VALUE cEvent = Qnil;
@@ -10,6 +12,7 @@ VALUE cEvent = Qnil;
 static void Event_mark(void *ptr) {
   Event_t *event = ptr;
   rb_gc_mark(event->waiting_fiber);
+  rb_gc_mark(event->result);
 }
 
 static void Event_free(void *ptr) {
@@ -41,6 +44,8 @@ static VALUE Event_initialize(VALUE self) {
   GetEvent(self, event);
 
   event->waiting_fiber = Qnil;
+  event->signaled = 0;
+  event->result = Qnil;
 
   return self;
 }
@@ -50,10 +55,17 @@ VALUE Event_signal(int argc, VALUE *argv, VALUE self) {
   Event_t *event;
   GetEvent(self, event);
 
+  if (event->signaled) goto done;
+
+  event->signaled = 1;
+  event->result = value;
+
   if (event->waiting_fiber != Qnil) {
     Fiber_make_runnable(event->waiting_fiber, value);
     event->waiting_fiber = Qnil;
   }
+
+done:
   return self;
 }
 
@@ -67,10 +79,19 @@ VALUE Event_await(VALUE self) {
   if (event->waiting_fiber != Qnil)
     rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
 
+  if (event->signaled) {
+    VALUE result = event->result;
+    event->signaled = 0;
+    event->result = Qnil;
+    return result;
+  }
+
   backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
   switchpoint_result = Backend_wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
+  event->signaled = 0;
+  event->result = Qnil;
 
   RAISE_IF_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(backend);

data/ext/polyphony/extconf.rb

@@ -2,12 +2,14 @@
 
 require 'rubygems'
 require 'mkmf'
+require 'rbconfig'
 
 dir_config 'polyphony_ext'
 
 KERNEL_INFO_RE = /Linux (\d)\.(\d+)(?:\.)?((?:\d+\.?)*)(?:\-)?([\w\-]+)?/
 def get_config
   config = { linux: !!(RUBY_PLATFORM =~ /linux/) }
+  config[:windows] = !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
   return config if !config[:linux]
 
   kernel_info = `uname -sr`
@@ -17,11 +19,13 @@ def get_config
   version, major_revision, distribution = m[1].to_i, m[2].to_i, m[4]
 
   combined_version = version.to_i * 100 + major_revision.to_i
-
+  
+  config[:kernel_version]     = combined_version
   config[:pidfd_open]         = combined_version > 503
+  config[:multishot_accept]   = combined_version >= 519
   config[:multishot_recv]     = combined_version >= 600
   config[:multishot_recvmsg]  = combined_version >= 600
-  config[:multishot_accept]   = combined_version >= 519
+  config[:multishot_timeout]  = combined_version >= 640
   config[:submit_all_flag]    = combined_version >= 518
   config[:coop_taskrun_flag]  = combined_version >= 519
 
@@ -31,7 +35,7 @@ def get_config
 end
 
 config = get_config
-puts "Building Polyphony... (#{config.inspect})"
+puts "Building Polyphony (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"
 
 require_relative 'zlib_conf'
 
@@ -59,20 +63,22 @@ end
 
 $defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if config[:pidfd_open]
 if config[:io_uring]
-  $defs << "-DPOLYPHONY_BACKEND_LIBURING"
-  $defs << "-DPOLYPHONY_LINUX"
-  $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
-  $defs << "-DHAVE_IO_URING_PREP_MULTISHOT_ACCEPT" if config[:multishot_accept]
-  $defs << "-DHAVE_IO_URING_PREP_RECV_MULTISHOT" if config[:multishot_recv]
-  $defs << "-DHAVE_IO_URING_PREP_RECVMSG_MULTISHOT" if config[:multishot_recvmsg]
-  $defs << "-DHAVE_IORING_SETUP_SUBMIT_ALL" if config[:submit_all_flag]
-  $defs << "-DHAVE_IORING_SETUP_COOP_TASKRUN" if config[:coop_taskrun_flag]
-  $CFLAGS << " -Wno-pointer-arith"
+  $defs << '-DPOLYPHONY_BACKEND_LIBURING'
+  $defs << '-DPOLYPHONY_LINUX'
+  $defs << '-DPOLYPHONY_UNSET_NONBLOCK' if RUBY_VERSION =~ /^3/
+  $defs << '-DHAVE_IO_URING_PREP_MULTISHOT_ACCEPT'  if config[:multishot_accept]
+  $defs << '-DHAVE_IO_URING_PREP_RECV_MULTISHOT'    if config[:multishot_recv]
+  $defs << '-DHAVE_IO_URING_PREP_RECVMSG_MULTISHOT' if config[:multishot_recvmsg]
+  $defs << '-DHAVE_IO_URING_TIMEOUT_MULTISHOT'      if config[:multishot_timeout]
+  $defs << '-DHAVE_IORING_SETUP_SUBMIT_ALL'         if config[:submit_all_flag]
+  $defs << '-DHAVE_IORING_SETUP_COOP_TASKRUN'       if config[:coop_taskrun_flag]
+  $CFLAGS << ' -Wno-pointer-arith'
 else
-  $defs << "-DPOLYPHONY_BACKEND_LIBEV"
-  $defs << "-DPOLYPHONY_LINUX" if config[:linux]
+  $defs << '-DPOLYPHONY_BACKEND_LIBEV'
+  $defs << '-DPOLYPHONY_LINUX' if config[:linux]
+  $defs << '-DPOLYPHONY_WINDOWS' if config[:windows]
 
-  $defs << "-DEV_STANDALONE" # prevent libev from assuming "config.h" exists
+  $defs << '-DEV_STANDALONE' # prevent libev from assuming "config.h" exists
 
   define_bool('EV_USE_EPOLL', have_header('sys/epoll.h'))
   define_bool('EV_USE_KQUEUE', have_header('sys/event.h') && have_header('sys/queue.h'))
@@ -84,10 +90,10 @@ else
 
   $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
-  $CFLAGS << " -Wno-comment"
-  $CFLAGS << " -Wno-unused-result"
-  $CFLAGS << " -Wno-dangling-else"
-  $CFLAGS << " -Wno-parentheses"
+  $CFLAGS << ' -Wno-comment'
+  $CFLAGS << ' -Wno-unused-result'
+  $CFLAGS << ' -Wno-dangling-else'
+  $CFLAGS << ' -Wno-parentheses'
 end
 
 $defs << '-DPOLYPHONY_PLAYGROUND' if ENV['POLYPHONY_PLAYGROUND']

data/ext/polyphony/fiber.c

@@ -3,7 +3,6 @@
 
 ID ID_ivar_auto_watcher;
 ID ID_ivar_mailbox;
-ID ID_ivar_result;
 ID ID_ivar_waiting_fibers;
 
 VALUE SYM_dead;
@@ -239,7 +238,6 @@ void Init_Fiber(void) {
 
   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"));

data/ext/polyphony/pipe.c

@@ -97,8 +97,8 @@ VALUE Pipe_close(VALUE self) {
   if (pipe->w_closed)
     rb_raise(rb_eRuntimeError, "Pipe is already closed for writing");
 
+  Backend_close(BACKEND(), INT2FIX(pipe->fds[1]));
   pipe->w_closed = 1;
-  close(pipe->fds[1]);
   return self;
 }
 

data/ext/polyphony/polyphony.c

@@ -13,6 +13,7 @@ ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
 ID ID_ivar_multishot_accept_queue;
 ID ID_ivar_parked;
+ID ID_ivar_result;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
@@ -80,20 +81,6 @@ VALUE Polyphony_backend_accept_loop(VALUE self, VALUE server_socket, VALUE socke
   return Backend_accept_loop(BACKEND(), server_socket, socket_class);
 }
 
-#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-/* Starts a multishot accept operation on the given server socket. This API is
- * available only for the io_uring backend.
- *
- * @param server_socket [Socket] socket to accept on
- * @return [any] block return value
- */
-
-VALUE Polyphony_backend_multishot_accept(VALUE self, VALUE server_socket) {
-  return Backend_multishot_accept(BACKEND(), server_socket);
-}
-#endif
-
-
 /* Connects the given socket to the given address and port.
  *
  * @param io [Socket] socket to connect
@@ -433,12 +420,6 @@ void Init_Polyphony(void) {
   rb_define_singleton_method(mPolyphony, "backend_accept_loop", Polyphony_backend_accept_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_connect", Polyphony_backend_connect, 3);
   rb_define_singleton_method(mPolyphony, "backend_feed_loop", Polyphony_backend_feed_loop, 3);
-
-  #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-  rb_define_singleton_method(mPolyphony, "backend_multishot_accept", Polyphony_backend_multishot_accept, 1);
-  #endif
-
-
   rb_define_singleton_method(mPolyphony, "backend_read", Polyphony_backend_read, 5);
   rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 4);
@@ -494,6 +475,7 @@ void Init_Polyphony(void) {
   ID_ivar_io                      = rb_intern("@io");
   ID_ivar_multishot_accept_queue  = rb_intern("@multishot_accept_queue");
   ID_ivar_parked                  = rb_intern("@parked");
+  ID_ivar_result                  = rb_intern("@result");
   ID_ivar_runnable                = rb_intern("@runnable");
   ID_ivar_running                 = rb_intern("@running");
   ID_ivar_thread                  = rb_intern("@thread");

data/ext/polyphony/polyphony.h

@@ -10,6 +10,7 @@
 #define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
 #define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
 #define TRACE_CALLER() INSPECT("caller: ", CALLER())
+#define TRACE_FREE(ptr) //printf("Free %p %s:%d\n", ptr, __FILE__, __LINE__)
 
 // exceptions
 #define TEST_EXCEPTION(ret) (rb_obj_is_kind_of(ret, rb_eException) == Qtrue)
@@ -47,6 +48,7 @@ extern ID ID_ivar_blocking_mode;
 extern ID ID_ivar_io;
 extern ID ID_ivar_multishot_accept_queue;
 extern ID ID_ivar_parked;
+extern ID ID_ivar_result;
 extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
@@ -101,11 +103,6 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_connect(VALUE self, VALUE io, VALUE addr, VALUE port);
 VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
-
-#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-VALUE Backend_multishot_accept(VALUE self, VALUE io);
-#endif
-
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos);
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos);
@@ -152,6 +149,9 @@ 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 Event_signal(int argc, VALUE *argv, VALUE event);
+VALUE Event_await(VALUE event);
+
 VALUE Polyphony_snooze(VALUE self);
 
 #endif /* POLYPHONY_H */

data/ext/polyphony/ring_buffer.c

@@ -10,6 +10,7 @@ void ring_buffer_init(ring_buffer *buffer) {
 }
 
 void ring_buffer_free(ring_buffer *buffer) {
+  TRACE_FREE(buffer->entries);
   free(buffer->entries);
 }
 

data/ext/polyphony/runqueue_ring_buffer.c

@@ -10,6 +10,7 @@ inline void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
 }
 
 inline void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
+  TRACE_FREE(buffer->entries);
   free(buffer->entries);
 }
 

data/ext/polyphony/thread.c

@@ -3,9 +3,12 @@
 
 ID ID_deactivate_all_watchers_post_fork;
 ID ID_ivar_backend;
+ID ID_ivar_done;
 ID ID_ivar_join_wait_queue;
 ID ID_ivar_main_fiber;
+ID ID_ivar_ready;
 ID ID_ivar_terminated;
+ID ID_ivar_waiters;
 ID ID_stop;
 
 /* :nop-doc: */
@@ -83,20 +86,80 @@ VALUE Thread_class_backend(VALUE _self) {
   return rb_ivar_get(rb_thread_current(), ID_ivar_backend);
 }
 
+
+VALUE Thread_done_p(VALUE self)
+{
+  return rb_ivar_get(self, ID_ivar_done);
+}
+
+VALUE Thread_kill_safe(VALUE self)
+{
+  static VALUE eTerminate = Qnil;
+  if (rb_ivar_get(self, ID_ivar_done) == Qtrue) return self;
+
+  if (eTerminate == Qnil)
+    eTerminate = rb_const_get(mPolyphony, rb_intern("Terminate"));
+
+  while (rb_ivar_get(self, ID_ivar_ready) != Qtrue)
+    rb_thread_schedule();
+
+  VALUE main_fiber = rb_ivar_get(self, ID_ivar_main_fiber);
+  VALUE exception = rb_funcall(eTerminate, ID_new, 0);
+  Thread_schedule_fiber(self, main_fiber, exception);
+  return self;
+}
+
+VALUE Thread_mark_as_done(VALUE self, VALUE result)
+{
+  rb_ivar_set(self, ID_ivar_done, Qtrue);
+  VALUE waiters = rb_ivar_get(self, ID_ivar_waiters);
+  if (waiters == Qnil) return self;
+
+  int len = RARRAY_LEN(waiters);
+  for (int i = 0; i < len; i++) {
+    VALUE waiter = RARRAY_AREF(waiters, i);
+    Event_signal(1, &result, waiter);
+  }
+  return self;
+}
+
+VALUE Thread_await_done(VALUE self)
+{
+  if (Thread_done_p(self) == Qtrue) return rb_ivar_get(self, ID_ivar_result);
+
+  VALUE waiter = Fiber_auto_watcher(rb_fiber_current());
+  VALUE waiters = rb_ivar_get(self, ID_ivar_waiters);
+  if (waiters == Qnil) {
+    waiters = rb_ary_new();
+    rb_ivar_set(self, ID_ivar_waiters, waiters);
+  }
+  rb_ary_push(waiters, waiter);
+
+  return Event_await(waiter);
+}
+
 void Init_Thread(void) {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "schedule_and_wakeup", Thread_fiber_schedule_and_wakeup, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
   rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
+  rb_define_method(rb_cThread, "done?", Thread_done_p, 0);
+  rb_define_method(rb_cThread, "kill_safe", Thread_kill_safe, 0);
+  rb_define_method(rb_cThread, "mark_as_done", Thread_mark_as_done, 1);
+  rb_define_method(rb_cThread, "await_done", Thread_await_done, 0);
+
   rb_define_singleton_method(rb_cThread, "backend", Thread_class_backend, 0);
 
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
   ID_deactivate_all_watchers_post_fork  = rb_intern("deactivate_all_watchers_post_fork");
   ID_ivar_backend                       = rb_intern("@backend");
+  ID_ivar_done                          = rb_intern("@done");
   ID_ivar_join_wait_queue               = rb_intern("@join_wait_queue");
   ID_ivar_main_fiber                    = rb_intern("@main_fiber");
+  ID_ivar_ready                         = rb_intern("@ready");
   ID_ivar_terminated                    = rb_intern("@terminated");
+  ID_ivar_waiters                       = rb_intern("@waiters");
   ID_stop                               = rb_intern("stop");
 }

data/ext/polyphony/win_uio.h

@@ -0,0 +1,18 @@
+// source: https://stackoverflow.com/questions/57897314/fatal-error-when-compiling-include-sys-uio-h-on-project-windows
+
+#ifndef SYS_UIO_H
+#define SYS_UIO_H
+
+#include <inttypes.h>
+#include <unistd.h>
+
+struct iovec
+{
+    void    *iov_base;  /* Base address of a memory region for input or output */
+    size_t   iov_len;   /* The size of the memory pointed to by iov_base */
+};
+
+ ssize_t readv(int fildes, const struct iovec *iov, int iovcnt);
+ssize_t writev(int fildes, const struct iovec *iov, int iovcnt);
+
+#endif /* SYS_UIO_H */