polyphony 0.59.1 → 0.60

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;
@@ -31,8 +31,10 @@ typedef struct op_context {
 
 typedef struct op_context_store {
   int           last_id;
-  op_context_t *available;
-  op_context_t *taken;
+  op_context_t  *available;
+  op_context_t  *taken;
+  int           available_count;
+  int           taken_count;
 } op_context_store_t;
 
 const char *op_type_to_str(enum op_type type);

data/ext/polyphony/backend_libev.c

@@ -217,7 +217,6 @@ inline struct backend_stats Backend_stats(VALUE self) {
 
   return (struct backend_stats){
     .scheduled_fibers = runqueue_len(&backend->base.runqueue),
-    .waiting_fibers = 0,
     .pending_ops = backend->base.pending_count
   };
 }
@@ -261,14 +260,20 @@ VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception)
   return switchpoint_result;
 }
 
-VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
+VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
   long len = dynamic_len ? 4096 : NUM2INT(length);
-  int shrinkable = io_setstrbuf(&str, len);
-  char *buf = RSTRING_PTR(str);
+  long buf_pos = NUM2INT(pos);
+  if (str != Qnil) {
+    int current_len = RSTRING_LEN(str);
+    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  }
+  else buf_pos = 0;
+  int shrinkable = io_setstrbuf(&str, buf_pos + len);
+  char *buf = RSTRING_PTR(str) + buf_pos;
   long total = 0;
   VALUE switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
@@ -304,9 +309,9 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
       if (total == len) {
         if (!dynamic_len) break;
 
-        rb_str_resize(str, total);
+        rb_str_resize(str, buf_pos + total);
         rb_str_modify_expand(str, len);
-        buf = RSTRING_PTR(str) + total;
+        buf = RSTRING_PTR(str) + buf_pos + total;
         shrinkable = 0;
         len += len;
       }
@@ -314,7 +319,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     }
   }
 
-  io_set_read_length(str, total, shrinkable);
+  io_set_read_length(str, buf_pos + total, shrinkable);
   io_enc_str(str, fptr);
 
   if (total == 0) return Qnil;
@@ -327,17 +332,17 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
-  return Backend_read(self, io, str, length, Qnil);
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
+  return Backend_read(self, io, str, length, Qnil, pos);
 }
 
-VALUE Backend_read_loop(VALUE self, VALUE io) {
+VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = 8192;
+  long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
@@ -1511,10 +1516,10 @@ void Init_Backend() {
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
-  rb_define_method(cBackend, "read", Backend_read, 4);
-  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "recv", Backend_recv, 3);
-  rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
+  rb_define_method(cBackend, "read", Backend_read, 5);
+  rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
+  rb_define_method(cBackend, "recv", Backend_recv, 4);
+  rb_define_method(cBackend, "recv_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);

data/ext/polyphony/extconf.rb

@@ -8,8 +8,8 @@ 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.gsub('.', '').to_i
+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
 end

data/ext/polyphony/fiber.c

@@ -81,34 +81,6 @@ static VALUE Fiber_state(VALUE self) {
   return SYM_waiting;
 }
 
-VALUE Fiber_await(VALUE self) {
-  VALUE result;
-
-  // we compare with false, since a fiber that has not yet started will have
-  // @running set to nil
-  if (rb_ivar_get(self, ID_ivar_running) == Qfalse) {
-    result = rb_ivar_get(self, ID_ivar_result);
-    RAISE_IF_EXCEPTION(result);
-    return result;
-  }
-
-  VALUE fiber = rb_fiber_current();
-  VALUE waiting_fibers = rb_ivar_get(self, ID_ivar_waiting_fibers);
-  if (waiting_fibers == Qnil) {
-    waiting_fibers = rb_hash_new();
-    rb_ivar_set(self, ID_ivar_waiting_fibers, waiting_fibers);
-  }
-  rb_hash_aset(waiting_fibers, fiber, Qtrue);
-
-  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
-  result = Backend_wait_event(backend, Qnil);
-
-  rb_hash_delete(waiting_fibers, fiber);
-  RAISE_IF_EXCEPTION(result);
-  RB_GC_GUARD(result);
-  return result;
-}
-
 VALUE Fiber_send(VALUE self, VALUE value) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   if (mailbox == Qnil) {
@@ -125,7 +97,7 @@ VALUE Fiber_receive(VALUE self) {
     mailbox = rb_funcall(cQueue, ID_new, 0);
     rb_ivar_set(self, ID_ivar_mailbox, mailbox);
   }
-  return Queue_shift(mailbox);  
+  return Queue_shift(mailbox);
 }
 
 VALUE Fiber_mailbox(VALUE self) {
@@ -150,9 +122,6 @@ void Init_Fiber() {
   rb_define_method(cFiber, "state", Fiber_state, 0);
   rb_define_method(cFiber, "auto_watcher", Fiber_auto_watcher, 0);
 
-  rb_define_method(cFiber, "await", Fiber_await, 0);
-  rb_define_method(cFiber, "join", Fiber_await, 0);
-
   rb_define_method(cFiber, "<<", Fiber_send, 1);
   rb_define_method(cFiber, "send", Fiber_send, 1);
   rb_define_method(cFiber, "receive", Fiber_receive, 0);

data/ext/polyphony/polyphony.c

@@ -58,20 +58,20 @@ VALUE Polyphony_backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE me
   return Backend_feed_loop(BACKEND(), io, receiver, method);
 }
 
-VALUE Polyphony_backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
-  return Backend_read(BACKEND(), io, str, length, to_eof);
+VALUE Polyphony_backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
+  return Backend_read(BACKEND(), io, str, length, to_eof, pos);
 }
 
-VALUE Polyphony_backend_read_loop(VALUE self, VALUE io) {
-  return Backend_read_loop(BACKEND(), io);
+VALUE Polyphony_backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
+  return Backend_read_loop(BACKEND(), io, maxlen);
 }
 
-VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
-  return Backend_recv(BACKEND(), io, str, length);
+VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
+  return Backend_recv(BACKEND(), io, str, length, pos);
 }
 
-VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io) {
-  return Backend_recv_loop(BACKEND(), io);
+VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
+  return Backend_recv_loop(BACKEND(), io, maxlen);
 }
 
 VALUE Polyphony_backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
@@ -130,10 +130,10 @@ void Init_Polyphony() {
   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);
-  rb_define_singleton_method(mPolyphony, "backend_read", Polyphony_backend_read, 4);
-  rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 1);
-  rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 3);
-  rb_define_singleton_method(mPolyphony, "backend_recv_loop", Polyphony_backend_recv_loop, 1);
+  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);
+  rb_define_singleton_method(mPolyphony, "backend_recv_loop", Polyphony_backend_recv_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_recv_feed_loop", Polyphony_backend_recv_feed_loop, 3);
   rb_define_singleton_method(mPolyphony, "backend_send", Polyphony_backend_send, 3);
   rb_define_singleton_method(mPolyphony, "backend_sendv", Polyphony_backend_sendv, 3);

data/ext/polyphony/polyphony.h

@@ -91,10 +91,10 @@ 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);
-VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof);
-VALUE Backend_read_loop(VALUE self, VALUE io);
-VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length);
-VALUE Backend_recv_loop(VALUE self, VALUE io);
+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);
+VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
 VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);

data/ext/polyphony/queue.c

@@ -57,21 +57,21 @@ static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-inline void queue_resume_first_blocked_fiber(ring_buffer *queue) {
+inline void queue_schedule_first_blocked_fiber(ring_buffer *queue) {
   if (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_all_blocked_fibers(ring_buffer *queue) {
+inline void queue_schedule_all_blocked_fibers(ring_buffer *queue) {
   while (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_blocked_fibers_to_capacity(Queue_t *queue) {
+inline void queue_schedule_blocked_fibers_to_capacity(Queue_t *queue) {
   for (unsigned int i = queue->values.count; (i < queue->capacity) && queue->push_queue.count; i++) {
     VALUE fiber = ring_buffer_shift(&queue->push_queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
@@ -101,7 +101,7 @@ VALUE Queue_push(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
 
   return self;
@@ -113,7 +113,7 @@ VALUE Queue_unshift(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
 
   return self;
@@ -140,7 +140,7 @@ VALUE Queue_shift(VALUE self) {
   }
   VALUE value = ring_buffer_shift(&queue->values);
   if ((queue->capacity) && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
   RB_GC_GUARD(value);
   return value;
 }
@@ -152,7 +152,7 @@ VALUE Queue_delete(VALUE self, VALUE value) {
   ring_buffer_delete(&queue->values, value);
 
   if (queue->capacity && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
 
   return self;
 }
@@ -164,9 +164,9 @@ VALUE Queue_cap(VALUE self, VALUE cap) {
   queue->capacity = new_capacity;
   
   if (queue->capacity)
-    queue_resume_blocked_fibers_to_capacity(queue);
+    queue_schedule_blocked_fibers_to_capacity(queue);
   else
-    queue_resume_all_blocked_fibers(&queue->push_queue);
+    queue_schedule_all_blocked_fibers(&queue->push_queue);
   
   return self;
 }
@@ -183,7 +183,7 @@ VALUE Queue_clear(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
 
   return self;
 }
@@ -200,7 +200,7 @@ VALUE Queue_shift_each(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_shift_each(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return self;
 }
 
@@ -209,7 +209,7 @@ VALUE Queue_shift_all(VALUE self) {
   GetQueue(self, queue);
 
   VALUE result = ring_buffer_shift_all(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return result;
 }
 

data/ext/polyphony/runqueue.c

@@ -58,14 +58,11 @@ inline int runqueue_empty_p(runqueue_t *runqueue) {
   return (runqueue->entries.count == 0);
 }
 
-static const unsigned int ANTI_STARVE_HIGH_WATERMARK_THRESHOLD = 128;
 static const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
 
 inline int runqueue_should_poll_nonblocking(runqueue_t *runqueue) {
-  if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
   if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
 
-  // the 
   runqueue->switch_count = 0;
   return 1;
 }

data/lib/polyphony/extensions/fiber.rb

@@ -22,9 +22,9 @@ module Polyphony
         return self
       end
 
-      parent.spin(@tag, @caller, &@block).tap do |f|
-        f.schedule(value) unless value.nil?
-      end
+      fiber = parent.spin(@tag, @caller, &@block)
+      fiber.schedule(value) unless value.nil?
+      fiber
     end
     alias_method :reset, :restart
 
@@ -66,6 +66,11 @@ module Polyphony
     def interject(&block)
       raise Polyphony::Interjection.new(block)
     end
+
+    def await
+      Fiber.await(self).first
+    end
+    alias_method :join, :await
   end
 
   # Fiber supervision
@@ -78,7 +83,7 @@ module Polyphony
       while true
         supervise_perform(opts)
       end
-    rescue Polyphony::MoveOn
+  rescue Polyphony::MoveOn
       # generated in #supervise_perform to stop supervisor
     ensure
       @on_child_done = nil
@@ -119,72 +124,62 @@ module Polyphony
     def await(*fibers)
       return [] if fibers.empty?
 
-      state = setup_await_select_state(fibers)
-      await_setup_monitoring(fibers, state)
-      suspend
-      fibers.map(&:result)
-    ensure
-      await_select_cleanup(state) if state
-    end
-    alias_method :join, :await
-
-    def setup_await_select_state(fibers)
-      {
-        awaiter: Fiber.current,
-        pending: fibers.each_with_object({}) { |f, h| h[f] = true }
-      }
-    end
-
-    def await_setup_monitoring(fibers, state)
+      Fiber.current.message_on_child_termination = true
+      results = {}
       fibers.each do |f|
-        f.when_done { |r| await_fiber_done(f, r, state) }
+        results[f] = nil
+        if f.dead?
+          # fiber already terminated, so queue message
+          Fiber.current.send [f, f.result]
+        else
+          f.monitor
+        end
       end
-    end
-
-    def await_fiber_done(fiber, result, state)
-      state[:pending].delete(fiber)
-
-      if state[:cleanup]
-        state[:awaiter].schedule if state[:pending].empty?
-      elsif !state[:done] && (result.is_a?(Exception) || state[:pending].empty?)
-        state[:awaiter].schedule(result)
-        state[:done] = true
+      exception = nil
+      while !fibers.empty?
+        (fiber, result) = receive
+        next unless fibers.include?(fiber)
+
+        fibers.delete(fiber)
+        if result.is_a?(Exception)
+          exception ||= result
+          fibers.each { |f| f.terminate }
+        else
+          results[fiber] = result
+        end
       end
-    end
-
-    def await_select_cleanup(state)
-      return if state[:pending].empty?
-
-      terminate = Polyphony::Terminate.new
-      state[:cleanup] = true
-      state[:pending].each_key { |f| f.schedule(terminate) }
-      suspend
-    end
-
-    def select(*fibers)
-      state = setup_await_select_state(fibers)
-      select_setup_monitoring(fibers, state)
-      suspend
+      results.values
     ensure
-      await_select_cleanup(state)
+      Fiber.current.message_on_child_termination = false
+      raise exception if exception
     end
+    alias_method :join, :await
 
-    def select_setup_monitoring(fibers, state)
+    def select(*fibers)
+      return nil if fibers.empty?
+  
       fibers.each do |f|
-        f.when_done { |r| select_fiber_done(f, r, state) }
+        if f.dead?
+          result = f.result
+          result.is_a?(Exception) ? (raise result) : (return [f, result])
+        end
       end
-    end
 
-    def select_fiber_done(fiber, result, state)
-      state[:pending].delete(fiber)
-      if state[:cleanup]
-        # in cleanup mode the selector is resumed if no more pending fibers
-        state[:awaiter].schedule if state[:pending].empty?
-      elsif !state[:selected]
-        # first fiber to complete, we schedule the result
-        state[:awaiter].schedule([fiber, result])
-        state[:selected] = true
+      Fiber.current.message_on_child_termination = true
+      fibers.each { |f| f.monitor }
+      while true
+        (fiber, result) = receive
+        next unless fibers.include?(fiber)
+  
+        fibers.each { |f| f.unmonitor }
+        if result.is_a?(Exception)
+          raise result
+        else
+          return [fiber, result]
+        end
       end
+    ensure
+      Fiber.current.message_on_child_termination = false
     end
 
     # Creates and schedules with priority an out-of-band fiber that runs the
@@ -209,6 +204,14 @@ module Polyphony
       (@children ||= {}).keys
     end
 
+    def add_child(child_fiber)
+      (@children ||= {})[child_fiber] = true
+    end
+
+    def remove_child(child_fiber)
+      @children.delete(child_fiber) if @children
+    end
+
     def spin(tag = nil, orig_caller = Kernel.caller, &block)
       f = Fiber.new { |v| f.run(v) }
       f.prepare(tag, block, orig_caller, self)
@@ -218,7 +221,10 @@ module Polyphony
 
     def child_done(child_fiber, result)
       @children.delete(child_fiber)
-      @on_child_done&.(child_fiber, result)
+
+      if result.is_a?(Exception) && !@message_on_child_termination
+        schedule_with_priority(result)
+      end
     end
 
     def terminate_all_children(graceful = false)
@@ -234,14 +240,7 @@ module Polyphony
     def await_all_children
       return unless @children && !@children.empty?
 
-      results = @children.dup
-      @on_child_done = proc do |c, r|
-        results[c] = r
-        schedule if @children.empty?
-      end
-      suspend
-      @on_child_done = nil
-      results.values
+      Fiber.await(*@children.keys)
     end
 
     def shutdown_all_children(graceful = false)
@@ -252,6 +251,18 @@ module Polyphony
         c.await
       end
     end
+
+    def detach
+      @parent.remove_child(self)
+      @parent = @thread.main_fiber
+      @parent.add_child(self)
+    end
+
+    def attach(parent)
+      @parent.remove_child(self)
+      @parent = parent
+      @parent.add_child(self)
+    end
   end
 
   # Fiber life cycle methods
@@ -304,8 +315,6 @@ module Polyphony
 
     def restart_self(first_value)
       @mailbox = nil
-      @when_done_procs = nil
-      @waiting_fibers = nil
       run(first_value)
     end
 
@@ -313,8 +322,9 @@ module Polyphony
       result, uncaught_exception = finalize_children(result, uncaught_exception)
       Thread.backend.trace(:fiber_terminate, self, result)
       @result = result
-      @running = false
+
       inform_dependants(result, uncaught_exception)
+      @running = false
     ensure
       # Prevent fiber from being resumed after terminating
       @thread.fiber_unschedule(self)
@@ -332,17 +342,27 @@ module Polyphony
     end
 
     def inform_dependants(result, uncaught_exception)
+      if @monitors
+        msg = [self, result]
+        @monitors.each { |f| f << msg }
+      end
+
       @parent&.child_done(self, result)
-      @when_done_procs&.each { |p| p.(result) }
-      @waiting_fibers&.each_key { |f| f.schedule(result) }
-      
-      # propagate unaught exception to parent
-      @parent&.schedule_with_priority(result) if uncaught_exception && !@waiting_fibers
     end
 
-    def when_done(&block)
-      @when_done_procs ||= []
-      @when_done_procs << block
+    attr_accessor :message_on_child_termination 
+
+    def monitor
+      @monitors ||= []
+      @monitors << Fiber.current
+    end
+
+    def unmonitor
+      @monitors.delete(Fiber.current) if @monitors
+    end
+
+    def dead?
+      state == :dead
     end
   end
 end