polyphony 0.78 → 0.79

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51eecc20956cb4f1a35a7f6510dea2730652700e99d29c7d42ade201a119ea2e
-  data.tar.gz: bc2b57dc2cc5a8918bba1d8bf526cdbe23f44d134f9bdca5018b9e9e66930f91
+  metadata.gz: 34ed5a7685a8986f1fe5fd6cd714ee049633952746ecb8bced1aee73553c6c99
+  data.tar.gz: 03ded408e8849a921d0cfbbe1a232c5cea83cfbd58710efade4900f6240f511c
 SHA512:
-  metadata.gz: 21c446f9a6fa032577b245e6de5155832c8e6932d6c17e58824a55923c82be014453b64b29ccbb66fe5d01cde8622d3275664acda403637954f1e7e6851e93c7
-  data.tar.gz: a57831fe861ac51fa43692b66175291a457077822cdb5f795a093fca1e44bf95fb2b6a312cfe8a6c2b3c3e873319ffd03436e6236874a6acdd45843a21bc4981
+  metadata.gz: 91fe5a0979c0158315e942bba88f563a47926e78ad3da0ff8e483ee91aff1482af1f2fc3e3aa4cacd49e787531627bfc3295d45439e99d8400b4736b1a749443
+  data.tar.gz: 3c1eaaccec661c4f3e4c07853fbaaaab19222837d5ac25b4098856bd1b1367833cbc35a58602fb9c30ff8e7cd63d04f79206bf07438a1e842eb86871c8036063

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.79)
 
 GEM
   remote: https://rubygems.org/

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/ext/polyphony/backend_common.c

@@ -65,7 +65,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 +96,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 +110,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;
 
@@ -244,15 +242,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

@@ -80,7 +80,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

@@ -216,12 +216,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;
 }
@@ -1108,7 +1108,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 +1591,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) {

data/ext/polyphony/polyphony.h

@@ -61,13 +61,13 @@ extern ID ID_switch_fiber;
 extern ID ID_to_s;
 extern ID ID_transfer;
 
-extern VALUE SYM_fiber_create;
-extern VALUE SYM_fiber_event_poll_enter;
-extern VALUE SYM_fiber_event_poll_leave;
-extern VALUE SYM_fiber_run;
-extern VALUE SYM_fiber_schedule;
-extern VALUE SYM_fiber_switchpoint;
-extern VALUE SYM_fiber_terminate;
+extern VALUE SYM_spin;
+extern VALUE SYM_enter_poll;
+extern VALUE SYM_leave_poll;
+extern VALUE SYM_unblock;
+extern VALUE SYM_schedule;
+extern VALUE SYM_block;
+extern VALUE SYM_terminate;
 
 VALUE Fiber_auto_watcher(VALUE self);
 void Fiber_make_runnable(VALUE fiber, VALUE value);
@@ -121,11 +121,14 @@ VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);
 VALUE Backend_wakeup(VALUE self);
 VALUE Backend_run_idle_tasks(VALUE self);
 VALUE Backend_switch_fiber(VALUE self);
+
 void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize);
 void Backend_unschedule_fiber(VALUE self, VALUE fiber);
 void Backend_park_fiber(VALUE self, VALUE fiber);
 void Backend_unpark_fiber(VALUE self, VALUE fiber);
 
+VALUE Backend_snooze(VALUE self);
+
 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);

data/ext/polyphony/thread.c

@@ -23,11 +23,15 @@ VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
 }
 
 inline void Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
-  schedule_fiber(self, fiber, value, 0);
+  Backend_schedule_fiber(self, rb_ivar_get(self, ID_ivar_backend), fiber, value, 0);
+
+  // schedule_fiber(self, fiber, value, 0);
 }
 
 inline void Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
-  schedule_fiber(self, fiber, value, 1);
+  Backend_schedule_fiber(self, rb_ivar_get(self, ID_ivar_backend), fiber, value, 1);
+
+  // schedule_fiber(self, fiber, value, 1);
 }
 
 VALUE Thread_switch_fiber(VALUE self) {

data/lib/polyphony/core/debug.rb

@@ -13,3 +13,147 @@ module ::Kernel
     end
   end
 end
+
+module Polyphony
+  module Trace
+    class << self
+      def start_event_firehose(io = nil, &block)
+        Thread.backend.trace_proc = firehose_proc(io, block)
+      end
+
+      private
+
+      def firehose_proc(io, block)
+        if io
+          ->(*e) { io.orig_write("#{trace_event_info(e).inspect}\n") }
+        elsif block
+          ->(*e) { block.(trace_event_info(e)) }
+        else
+          raise "Please provide an io or a block"
+        end
+      end
+
+      def trace_event_info(e)
+        {
+          stamp: format_current_time,
+          event: e[0]
+        }.merge(
+          send(:"event_props_#{e[0]}", e)
+        )
+      end
+      
+      def format_trace_event_message(e)
+        props = send(:"event_props_#{e[0]}", e).merge(
+          timestamp: format_current_time,
+          event: e[0]
+        )
+        # templ = send(:"event_format_#{e[0]}", e)
+
+        # msg = format("%<timestamp>s #{templ}\n", **props)
+      end
+
+      def format_current_time
+        Time.now.strftime('%Y-%m-%d %H:%M:%S')
+      end
+
+      def generic_event_format
+        '%<event>-12.12s'
+      end
+
+      def fiber_event_format
+        "#{generic_event_format} %<fiber>-44.44s"
+      end
+
+      def event_props_enter_poll(e)
+        {}
+      end
+
+      def event_format_enter_poll(e)
+        generic_event_format
+      end
+
+      def event_props_leave_poll(e)
+        {}
+      end
+
+      def event_format_leave_poll(e)
+        generic_event_format
+      end
+
+      def event_props_schedule(e)
+        {
+          fiber: e[1],
+          value: e[2],
+          caller: e[4],
+          source_fiber: Fiber.current
+        }
+      end
+
+      def event_format_schedule(e)
+        "#{fiber_event_format} %<value>-24.24p %<caller>-120.120s <= %<origin_fiber>s"
+      end
+
+      def event_props_unblock(e)
+        {
+          fiber: e[1],
+          value: e[2],
+          caller: e[3],
+        }
+      end
+
+      def event_format_unblock(e)
+        "#{fiber_event_format} %<value>-24.24p %<caller>-120.120s"
+      end
+
+      def event_props_terminate(e)
+        {
+          fiber: e[1],
+          value: e[2],
+        }
+      end
+
+      def event_format_terminate(e)
+        "#{fiber_event_format} %<value>-24.24p"
+      end
+
+      def event_props_block(e)
+        {
+          fiber: e[1],
+          caller: e[2]
+        }
+      end
+
+      def event_format_block(e)
+        "#{fiber_event_format} #{' ' * 24} %<caller>-120.120s"
+      end
+
+      def event_props_spin(e)
+        {
+          fiber: e[1],
+          caller: e[2],
+          source_fiber: Fiber.current
+        }
+      end
+
+      def event_format_spin(e)
+        "#{fiber_event_format} #{' ' * 24} %<caller>-120.120s <= %<origin_fiber>s"
+      end
+
+      def fibe_repr(fiber)
+        format("%-6x %-20.20s %-10.10s", fiber.object_id, fiber.tag, "(#{fiber.state})")
+      end
+
+      def fiber_compact_repr(fiber)
+        if fiber.tag
+          format("%-6x %-.20s %-.10s", fiber.object_id, fiber.tag, "(#{fiber.state})")
+        else
+          format("%-6x %-.10s", fiber.object_id, "(#{fiber.state})")
+        end
+      end
+
+      def caller_repr(c)
+       c.map { |i| i.gsub('/home/sharon/repo/polyphony/lib/polyphony', '') }.join('  ')
+      end
+    end
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -250,16 +250,17 @@ module Polyphony
     def schedule_priority_oob_fiber(&block)
       oob_fiber = Fiber.new do
         Fiber.current.setup_raw
+        Thread.backend.trace(:unblock, oob_fiber, nil, @caller)
         result = block.call
       rescue Exception => e
         Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
         result = e
       ensure
-        Thread.backend.trace(:fiber_terminate, Fiber.current, result)
+        Thread.backend.trace(:terminate, Fiber.current, result)
         suspend
       end
       prepare_oob_fiber(oob_fiber, block)
-      Thread.backend.trace(:fiber_create, oob_fiber)
+      Thread.backend.trace(:spin, oob_fiber, caller)
       oob_fiber.schedule_with_priority(nil)
     end
 
@@ -355,12 +356,13 @@ module Polyphony
       @parent = parent
       @caller = caller
       @block = block
-      Thread.backend.trace(:fiber_create, self)
+      Thread.backend.trace(:spin, self, Kernel.caller[1..-1])
       schedule
     end
 
     def run(first_value)
       setup first_value
+      Thread.backend.trace(:unblock, self, first_value, @caller)
       result = @block.(first_value)
       finalize result
     rescue Polyphony::Restart => e
@@ -402,7 +404,7 @@ module Polyphony
 
     def finalize(result, uncaught_exception = false)
       result, uncaught_exception = finalize_children(result, uncaught_exception)
-      Thread.backend.trace(:fiber_terminate, self, result)
+      Thread.backend.trace(:terminate, self, result)
       @result = result
 
       inform_monitors(result, uncaught_exception)

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.78'
+  VERSION = '0.79'
 end

data/test/test_io.rb

@@ -309,13 +309,13 @@ class IOClassMethodsTest < MiniTest::Test
     assert_equal BIN_DATA, s
   end
 
-  def test_foreach
-    skip 'IO.foreach is not yet implemented'
-    lines = []
-    IO.foreach(__FILE__) { |l| lines << l }
-    assert_equal "# frozen_string_literal: true\n", lines[0]
-    assert_equal "end\n", lines[-1]
-  end
+  # def test_foreach
+  #   skip 'IO.foreach is not yet implemented'
+  #   lines = []
+  #   IO.foreach(__FILE__) { |l| lines << l }
+  #   assert_equal "# frozen_string_literal: true\n", lines[0]
+  #   assert_equal "end\n", lines[-1]
+  # end
 
   def test_read_class_method
     s = IO.read(__FILE__)

data/test/test_signal.rb

@@ -33,24 +33,24 @@ class SignalTrapTest < Minitest::Test
     Fiber.current.tag = :main
 
     expected = [
-      [:fiber_switchpoint, :main],
-      [:fiber_event_poll_enter, :main],
-      [:fiber_create, :oob],
-      [:fiber_schedule, :oob],
-      [:fiber_event_poll_leave, :main],
-      [:fiber_run, :oob],
-      [:fiber_terminate, :oob],
-      [:fiber_switchpoint, :oob],
-      [:fiber_event_poll_enter, :oob],
-      [:fiber_schedule, :main],
-      [:fiber_event_poll_leave, :oob],
-      [:fiber_run, :main]
+      [:block, :main],
+      [:enter_poll, :main],
+      [:spin, :oob],
+      [:schedule, :oob],
+      [:leave_poll, :main],
+      [:unblock, :oob],
+      [:terminate, :oob],
+      [:block, :oob],
+      [:enter_poll, :oob],
+      [:schedule, :main],
+      [:leave_poll, :oob],
+      [:unblock, :main]
     ]
     if Thread.backend.kind == :libev
       expected += [
-        [:fiber_schedule, :main],
-        [:fiber_switchpoint, :main],
-        [:fiber_run, :main]
+        [:schedule, :main],
+        [:block, :main],
+        [:unblock, :main]
       ]
     end
 

data/test/test_thread.rb

@@ -132,7 +132,7 @@ class ThreadTest < MiniTest::Test
     Thread.backend.trace_proc = proc {|*r| records << r }
     suspend
     assert_equal [
-      [:fiber_switchpoint, Fiber.current, ["#{__FILE__}:#{__LINE__ - 2}:in `test_that_suspend_returns_immediately_if_no_watchers'"] + caller]
+      [:block, Fiber.current, ["#{__FILE__}:#{__LINE__ - 2}:in `test_that_suspend_returns_immediately_if_no_watchers'"] + caller]
     ], records
   ensure
     Thread.backend.trace_proc = nil

data/test/test_trace.rb

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
+require 'polyphony/core/debug'
 
 class TraceTest < MiniTest::Test
   def test_tracing_enabled
     events = []
-    Thread.backend.trace_proc = proc { |*e| events << e }
+
+    Thread.backend.trace_proc = proc { |*e|
+      case e[0]
+      when :schedule
+        e = e[0..3]
+      when :block
+        e = e[0..1]
+      when :unblock
+        e = e[0..2]
+      end
+      events << e
+    }
     snooze
 
     assert_equal [
-      [:fiber_schedule, Fiber.current, nil, false],
-      [:fiber_switchpoint, Fiber.current, ["#{__FILE__}:#{__LINE__ - 4}:in `test_tracing_enabled'"] + caller],
-      [:fiber_run, Fiber.current, nil]
+      [:schedule, Fiber.current, nil, false],
+      [:block, Fiber.current],
+      [:unblock, Fiber.current, nil]
     ], events
   ensure
     Thread.backend.trace_proc = nil
@@ -19,7 +31,17 @@ class TraceTest < MiniTest::Test
 
   def test_2_fiber_trace
     events = []
-    Thread.backend.trace_proc = proc { |*e| events << e }
+    Thread.backend.trace_proc = proc { |*e|
+      case e[0]
+      when :schedule
+        e = e[0..3]
+      when :spin, :block
+        e = e[0..1]
+      when :unblock
+        e = e[0..2]
+      end
+      events << e
+    }
 
     f = spin { sleep 0; :byebye }
     l0 = __LINE__ + 1
@@ -28,28 +50,84 @@ class TraceTest < MiniTest::Test
 
     Thread.backend.trace_proc = nil
     
-    # remove caller info for :fiber_switchpoint events
-    events.each {|e| e.pop if e[0] == :fiber_switchpoint }
-
     assert_equal [
-      [:fiber_create, f],
-      [:fiber_schedule, f, nil, false],
-      [:fiber_switchpoint, Fiber.current],
-      [:fiber_run, f, nil],
-      [:fiber_switchpoint, f],
-      [:fiber_event_poll_enter, f],
-      [:fiber_schedule, f, nil, false],
-      [:fiber_event_poll_leave, f],
-      [:fiber_run, f, nil],
-      [:fiber_terminate, f, :byebye],
-      [:fiber_switchpoint, f],
-      [:fiber_switchpoint, Fiber.current],
-      [:fiber_event_poll_enter, Fiber.current],
-      [:fiber_schedule, Fiber.current, nil, false],
-      [:fiber_event_poll_leave, Fiber.current],
-      [:fiber_run, Fiber.current, nil]
+      [:spin, f],
+      [:schedule, f, nil, false],
+      [:block, Fiber.current],
+      [:unblock, f, nil],
+      [:block, f],
+      [:enter_poll, f],
+      [:schedule, f, nil, false],
+      [:leave_poll, f],
+      [:unblock, f, nil],
+      [:terminate, f, :byebye],
+      [:block, f],
+      [:block, Fiber.current],
+      [:enter_poll, Fiber.current],
+      [:schedule, Fiber.current, nil, false],
+      [:leave_poll, Fiber.current],
+      [:unblock, Fiber.current, nil]
     ], events
   ensure
     Thread.backend.trace_proc = nil
   end
+
+  def test_event_firehose
+    buffer = []
+    Polyphony::Trace.start_event_firehose { |e| buffer << e }
+
+    f1 = spin(:f1) do
+      receive
+    end
+
+    f1 << :foo
+    f1.await
+
+    Thread.backend.trace_proc = nil
+
+    buffer.each { |e| e.delete(:stamp); e.delete(:caller) }
+
+    main = Fiber.current
+    assert_equal(
+      [
+        { event: :spin,       fiber: f1,                  source_fiber: main  },
+        { event: :schedule,   fiber: f1,    value: nil,   source_fiber: main  },
+        { event: :block,      fiber: main                                     },
+        { event: :unblock,    fiber: f1,    value: nil                        },
+        { event: :schedule,   fiber: f1,    value: nil,   source_fiber: f1    },
+        { event: :block,      fiber: f1,                                      },
+        { event: :enter_poll                                                  },
+        { event: :leave_poll                                                  },
+        { event: :unblock,    fiber: f1,    value: nil                        },
+        { event: :terminate,  fiber: f1,    value: :foo                       },
+        { event: :schedule,   fiber: main,  value: nil,   source_fiber: f1    },
+        { event: :block,      fiber: f1                                       },
+        { event: :unblock,    fiber: main,  value: nil                        }
+      ], buffer
+    )
+  ensure
+    Thread.backend.trace_proc = nil
+  end
+
+  def test_event_firehose_with_io
+    r, w = IO.pipe
+    Polyphony::Trace.start_event_firehose(w)
+
+    f1 = spin(:f1) do
+      receive
+    end
+
+    f1 << :foo
+    f1.await
+
+    Thread.backend.trace_proc = nil
+    w.close
+
+    log = r.read
+    assert_equal 13, log.lines.size
+
+    # TODO: make sure log is formatted correctly
+  ensure
+    Thread.backend.trace_proc = nil
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.78'
+  version: '0.79'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler