polyphony 0.68 → 0.72

data/ext/polyphony/backend_io_uring.c

@@ -106,9 +106,7 @@ VALUE Backend_post_fork(VALUE self) {
   io_uring_queue_exit(&backend->ring);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
   context_store_free(&backend->store);
-  backend->base.currently_polling = 0;
-  backend->base.pending_count = 0;
-  backend->pending_sqes = 0;
+  backend_base_reset(&backend->base);
 
   return self;
 }
@@ -143,7 +141,7 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   context_store_release(&backend->store, ctx);
 }
 
-// adapted from io_uring_peek_batch_cqe in queue.c 
+// adapted from io_uring_peek_batch_cqe in queue.c
 // this peeks at cqes and handles each available cqe
 void io_uring_backend_handle_ready_cqes(Backend_t *backend) {
   struct io_uring *ring = &backend->ring;
@@ -202,19 +200,12 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   }
 
   COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
-  // if (SHOULD_TRACE(&backend->base))
-  //   printf(
-  //     "io_uring_poll(blocking_mode: %d, pending: %d, taken: %d, available: %d, runqueue: %d\n",
-  //     is_blocking,
-  //     backend->base.pending_count,
-  //     backend->store.taken_count,
-  //     backend->store.available_count,
-  //     backend->base.runqueue.entries.count
-  //   );
+  
   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_fiber_event_poll_leave, rb_fiber_current());
+
   return self;
 }
 
@@ -257,7 +248,7 @@ VALUE Backend_wakeup(VALUE self) {
     io_uring_prep_nop(sqe);
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
-    
+
     return Qtrue;
   }
 
@@ -413,7 +404,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
-    
+
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -463,7 +454,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
-    
+
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -509,7 +500,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -518,7 +509,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
       return resume_value;
     }
     RB_GC_GUARD(resume_value);
-    
+
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
@@ -561,7 +552,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_writev(sqe, fptr->fd, iov_ptr, iov_count, -1);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -637,7 +628,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -687,7 +678,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -736,7 +727,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -782,7 +773,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -819,7 +810,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
     op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_accept(sqe, fptr->fd, &addr, &len, 0);
-    
+
     int fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
@@ -890,7 +881,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
@@ -946,7 +937,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   RAISE_IF_EXCEPTION(resume_value);
   if (!completed) return resume_value;
   RB_GC_GUARD(resume_value);
-  
+
   if (result < 0) rb_syserr_fail(-result, strerror(-result));
   return sock;
 }
@@ -983,7 +974,7 @@ inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
 int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
   struct __kernel_timespec ts = double_to_timespec(duration);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-  
+
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
@@ -1012,7 +1003,7 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     if (next_time == 0.) next_time = current_time() + interval_d;
     double sleep_duration = next_time - now;
     if (sleep_duration < 0) sleep_duration = 0;
-    
+
     VALUE resume_value = Qnil;
     int completed = io_uring_backend_submit_timeout_and_await(backend, sleep_duration, &resume_value);
     RAISE_IF_EXCEPTION(resume_value);
@@ -1053,7 +1044,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   VALUE exception;
   VALUE move_on_value = Qnil;
   rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
-  
+
   struct __kernel_timespec ts = duration_to_timespec(duration);
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1061,7 +1052,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-  
+
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1096,7 +1087,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     RAISE_IF_EXCEPTION(resume_value);
     RB_GC_GUARD(resume_value);
   }
-  
+
   int status;
   pid_t ret = waitpid(pid_int, &status, WNOHANG);
   if (ret < 0) {
@@ -1246,7 +1237,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
       }
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
     }
-    
+
     io_uring_sqe_set_data(last_sqe, ctx);
     unsigned int flags = (i == (argc - 1)) ? IOSQE_ASYNC : IOSQE_ASYNC | IOSQE_IO_LINK;
     io_uring_sqe_set_flags(last_sqe, flags);
@@ -1261,7 +1252,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   int completed = context_store_release(&backend->store, ctx);
   if (!completed) {
     Backend_chain_ctx_attach_buffers(ctx, argc, argv);
-    
+
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -1271,7 +1262,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     RAISE_IF_EXCEPTION(resume_value);
     return resume_value;
   }
-  
+
   RB_GC_GUARD(resume_value);
   return INT2NUM(result);
 }
@@ -1406,7 +1397,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
     if (chunk_len == 0) break;
-    
+
     total += chunk_len;
     chunk_len_value = INT2NUM(chunk_len);
 
@@ -1528,10 +1519,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "write", Backend_write_m, -1);
 
-  #ifdef POLYPHONY_UNSET_NONBLOCK
-  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
-  #endif
-
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
   SYM_send = ID2SYM(rb_intern("send"));
   SYM_splice = ID2SYM(rb_intern("splice"));

data/ext/polyphony/backend_io_uring_context.c

@@ -64,7 +64,7 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
   // printf("release %p %d (%s, ref_count: %d)\n", ctx, ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
 
   assert(ctx->ref_count);
-  
+
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 

data/ext/polyphony/backend_io_uring_context.h

@@ -22,7 +22,7 @@ typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;
   enum op_type      type: 16;
-  unsigned int      ref_count : 16;       
+  unsigned int      ref_count : 16;
   int               id;
   int               result;
   VALUE             fiber;

data/ext/polyphony/backend_libev.c

@@ -118,7 +118,7 @@ inline struct ev_loop *libev_new_loop() {
 
 static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
-  
+
   GetBackend(self, backend);
 
   backend_base_initialize(&backend->base);
@@ -157,6 +157,8 @@ VALUE Backend_post_fork(VALUE self) {
   ev_loop_destroy(backend->ev_loop);
   backend->ev_loop = EV_DEFAULT;
 
+  backend_base_reset(&backend->base);
+
   return self;
 }
 
@@ -186,7 +188,7 @@ inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  runqueue_delete(&backend->base.runqueue, fiber);  
+  runqueue_delete(&backend->base.runqueue, fiber);
 }
 
 inline VALUE Backend_switch_fiber(VALUE self) {
@@ -969,7 +971,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
   watcher.fiber = Qnil;
-  
+
   while (1) {
     backend->base.op_count++;
     ssize_t n = read(src_fptr->fd, buf, len);
@@ -1045,7 +1047,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   watcher.fiber = Qnil;
 
-  while (1) { 
+  while (1) {
     char *ptr = buf;
     while (1) {
       backend->base.op_count++;
@@ -1157,8 +1159,8 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     if (next_time == 0.) next_time = current_time() + interval_d;
     double sleep_duration = next_time - now;
     if (sleep_duration < 0) sleep_duration = 0;
-    
-    VALUE switchpoint_result = Qnil;    
+
+    VALUE switchpoint_result = Qnil;
     ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
     ev_timer_start(backend->ev_loop, &watcher.timer);
     backend->base.op_count++;
@@ -1217,7 +1219,7 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
 
   struct Backend_timeout_ctx timeout_ctx = {backend, &watcher};
   result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
-  
+
   if (result == timeout) {
     if (exception == Qnil) return move_on_value;
     RAISE_EXCEPTION(backend_timeout_exception(exception));
@@ -1335,7 +1337,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     else
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
   }
-  
+
   RB_GC_GUARD(result);
   return result;
 }
@@ -1384,14 +1386,14 @@ 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, 
+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;
 
@@ -1487,7 +1489,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     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;
     chunk_len_value = INT2NUM(chunk_len);
 

data/ext/polyphony/extconf.rb

@@ -3,32 +3,43 @@
 require 'rubygems'
 require 'mkmf'
 
-use_liburing = false
-use_pidfd_open = false
-force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
-linux = RUBY_PLATFORM =~ /linux/
-
-if linux && `uname -sr` =~ /Linux 5\.(\d+)/
-  kernel_minor_version = $1.to_i
-  use_liburing = !force_use_libev && kernel_minor_version >= 6
-  use_pidfd_open = kernel_minor_version >= 3
+
+KERNEL_INFO_RE = /Linux (\d)\.(\d+)\.(?:\d+)\-(?:\d+\-)?(\w+)/
+def get_config
+  config = { linux: !!(RUBY_PLATFORM =~ /linux/) }
+  return config if !config[:linux]
+
+  kernel_info = `uname -sr`
+  m = kernel_info.match(KERNEL_INFO_RE)
+  raise "Could not parse Linux kernel information (#{kernel_info.inspect})" if !m
+
+  version, major_revision, distribution = m[1].to_i, m[2].to_i, m[3]
+  config[:pidfd_open] = (version == 5) && (major_revision >= 3)
+
+  force_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+  config[:io_uring] = !force_libev &&
+    (version == 5) && (major_revision >= 6) && (distribution != 'linuxkit')
+  config
 end
 
-$defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if use_pidfd_open
-if use_liburing
+config = get_config
+puts "Building Polyphony... (#{config.inspect})"
+
+$defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if config[:pidfd_open]
+if config[:io_uring]
   $defs << "-DPOLYPHONY_BACKEND_LIBURING"
   $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
-  $defs << "-DPOLYPHONY_LINUX" if linux
+  $defs << "-DPOLYPHONY_LINUX" if config[:linux]
   $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
   $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
   $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
   $defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
   $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
   $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
-  $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')  
+  $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
   $CFLAGS << " -Wno-comment"
   $CFLAGS << " -Wno-unused-result"

data/ext/polyphony/queue.c

@@ -162,12 +162,12 @@ VALUE Queue_cap(VALUE self, VALUE cap) {
   Queue_t *queue;
   GetQueue(self, queue);
   queue->capacity = new_capacity;
-  
+
   if (queue->capacity)
     queue_schedule_blocked_fibers_to_capacity(queue);
   else
     queue_schedule_all_blocked_fibers(&queue->push_queue);
-  
+
   return self;
 }
 

data/ext/polyphony/runqueue_ring_buffer.c

@@ -61,8 +61,9 @@ inline void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber,
 
 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);
+    runqueue_entry entry = buffer->entries[(buffer->head + i) % buffer->size];
+    rb_gc_mark(entry.fiber);
+    rb_gc_mark(entry.value);
   }
 }
 

data/lib/polyphony/adapters/irb.rb

@@ -3,26 +3,36 @@
 require 'polyphony'
 
 if Object.constants.include?(:Reline)
+  puts "reline"
   class Reline::ANSI
     def self.select(read_ios = [], write_ios = [], error_ios = [], timeout = nil)
-      p [:select, read_ios]
+      # p [:select, read_ios, timeout]
+      # puts caller.join("\n")
       raise if read_ios.size > 1
       raise if write_ios.size > 0
       raise if error_ios.size > 0
 
+      # p 1
       fiber = Fiber.current
       timer = spin do
         sleep timeout
         fiber.cancel
       end
+      # p 2
       read_ios.each do |io|
+        # p wait: io
         Polyphony.backend_wait_io(io, false)
+        # p :done_wait
         return [io]
       end
+      # p 3
     rescue Polyphony::Cancel
+      # p :cancel
       return nil
     ensure
+      # p :ensure
       timer.stop
+      # p :ensure_done      
     end
   end
 else

data/lib/polyphony/core/global_api.rb

@@ -73,7 +73,7 @@ module Polyphony
 
     def spin_scope
       raise unless block_given?
-    
+
       spin do
         result = yield
         Fiber.current.await_all_children
@@ -122,8 +122,8 @@ module Polyphony
       Fiber.current.receive_all_pending
     end
 
-    def supervise(*args, &block)
-      Fiber.current.supervise(*args, &block)
+    def supervise(*args, **opts, &block)
+      Fiber.current.supervise(*args, **opts, &block)
     end
 
     def sleep(duration = nil)

data/lib/polyphony/core/timer.rb

@@ -44,7 +44,7 @@ module Polyphony
     ensure
       @timeouts.delete(fiber)
     end
-  
+
     def cancel_after(interval, with_exception: Polyphony::Cancel)
       fiber = Fiber.current
       @timeouts[fiber] = {
@@ -74,7 +74,7 @@ module Polyphony
     def reset
       record = @timeouts[Fiber.current]
       return unless record
-  
+
       record[:target_stamp] = now + record[:interval]
     end
 

data/lib/polyphony/debugger.rb

@@ -9,11 +9,11 @@ module Polyphony
     :return,
     :b_call,
     :b_return
-  ]    
+  ]
 
   def self.start_debug_server(socket_path)
     server = DebugServer.new(socket_path)
-    controller = DebugController.new(server)      
+    controller = DebugController.new(server)
     trace = TracePoint.new(*TP_EVENTS) { |tp| controller.handle_tp(trace, tp) }
     trace.enable
 
@@ -124,7 +124,7 @@ module Polyphony
         h
       end
     end
-    
+
     def cmd_step(cmd)
       tp = nil
       fiber = nil

data/lib/polyphony/extensions/fiber.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'fiber'
-
 require_relative '../core/exceptions'
 
 module Polyphony
@@ -19,7 +18,7 @@ module Polyphony
     alias_method :stop, :interrupt
 
     def restart(value = nil)
-      raise "Can''t restart main fiber" if @main
+      raise "Can't restart main fiber" if @main
 
       if @running
         schedule Polyphony::Restart.new(value)
@@ -27,6 +26,7 @@ module Polyphony
       end
 
       fiber = parent.spin(@tag, @caller, &@block)
+      @monitors&.each_key { |f| fiber.monitor(f) }
       fiber.schedule(value) unless value.nil?
       fiber
     end
@@ -80,10 +80,10 @@ module Polyphony
   # Fiber supervision
   module FiberSupervision
     def supervise(*fibers, **opts, &block)
-      block ||= opts[:on_done] ||
-                (opts[:on_error] && supervise_on_error_proc(opts[:on_error]))
-      raise "No block given" unless block
+      block ||= supervise_opts_to_block(opts)
 
+      @supervise_mode = true
+      fibers = children if fibers.empty?
       fibers.each do |f|
         f.attach_to(self) unless f.parent == self
         f.monitor(self)
@@ -95,10 +95,24 @@ module Polyphony
         (fiber, result) = mailbox.shift
         block&.call(fiber, result)
       end
+    ensure
+      @supervise_mode = false
     end
 
-    def supervise_on_error_proc(on_error)
-      ->(f, r) { opts[:on_error].(f, r) if r.is_a?(Exception) }
+    def supervise_opts_to_block(opts)
+      block = opts[:on_done] || opts[:on_error]
+      restart = opts[:restart]
+      return nil unless block || restart
+
+      error_only = !!opts[:on_error]
+      restart_always = (restart == :always) || (restart == true)
+      restart_on_error = restart == :on_error
+
+      ->(f, r) do
+        is_error = r.is_a?(Exception)
+        block.(f, r) if block && (!error_only || is_error)
+        f.restart if restart_always || (restart_on_error && is_error)
+      end
     end
   end
 
@@ -139,7 +153,7 @@ module Polyphony
 
     def select(*fibers)
       return nil if fibers.empty?
-  
+
       current_fiber = self.current
       mailbox = current_fiber.monitor_mailbox
       fibers.each do |f|
@@ -153,7 +167,7 @@ module Polyphony
       while true
         (fiber, result) = mailbox.shift
         next unless fibers.include?(fiber)
-  
+
         fibers.each { |f| f.unmonitor(current_fiber) }
         if result.is_a?(Exception)
           raise result
@@ -187,6 +201,7 @@ module Polyphony
 
     def add_child(child_fiber)
       (@children ||= {})[child_fiber] = true
+      child_fiber.monitor(self) if @supervise_mode
     end
 
     def remove_child(child_fiber)
@@ -197,6 +212,7 @@ module Polyphony
       f = Fiber.new { |v| f.run(v) }
       f.prepare(tag, block, orig_caller, self)
       (@children ||= {})[f] = true
+      f.monitor(self) if @supervise_mode
       f
     end
 
@@ -225,19 +241,17 @@ module Polyphony
         c.terminate(graceful)
         c.await
       end
-      reap_dead_children
     end
 
-    def reap_dead_children
-      return unless @children
-
-      @children.reject! { |f| f.dead? }
+    def attach_all_children_to(fiber)
+      @children&.keys.each { |c| c.attach_to(fiber) }
     end
 
     def detach
       @parent.remove_child(self)
       @parent = @thread.main_fiber
       @parent.add_child(self)
+      self
     end
 
     def attach_to(fiber)
@@ -315,6 +329,7 @@ module Polyphony
       inform_monitors(result, uncaught_exception)
       @running = false
     ensure
+      @parent&.remove_child(self)
       # Prevent fiber from being resumed after terminating
       @thread.fiber_unschedule(self)
       Thread.current.switch_fiber
@@ -324,7 +339,7 @@ module Polyphony
     # the children are shut down, it is returned along with the uncaught_exception
     # flag set. Otherwise, it returns the given arguments.
     def finalize_children(result, uncaught_exception)
-      shutdown_all_children
+      shutdown_all_children(graceful_shutdown?)
       [result, uncaught_exception]
     rescue Exception => e
       [e, true]