polyphony 0.58 → 0.59

data/lib/polyphony/extensions/fiber.rb

@@ -262,7 +262,7 @@ module Polyphony
       @parent = parent
       @caller = caller
       @block = block
-      __fiber_trace__(:fiber_create, self)
+      Thread.backend.trace(:fiber_create, self)
       schedule
     end
 
@@ -311,7 +311,7 @@ module Polyphony
 
     def finalize(result, uncaught_exception = false)
       result, uncaught_exception = finalize_children(result, uncaught_exception)
-      __fiber_trace__(:fiber_terminate, self, result)
+      Thread.backend.trace(:fiber_terminate, self, result)
       @result = result
       @running = false
       inform_dependants(result, uncaught_exception)

data/lib/polyphony/extensions/thread.rb

@@ -111,6 +111,6 @@ class ::Thread
   end
 
   def on_idle(&block)
-    backend.idle_block = block
+    backend.idle_proc = block
   end
 end

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -351,10 +351,10 @@ class BackendTest < MiniTest::Test
     GC.enable
   end
 
-  def test_idle_block
+  def test_idle_proc
     counter = 0
 
-    @backend.idle_block = proc { counter += 1 }
+    @backend.idle_proc = proc { counter += 1 }
     
     3.times { snooze }
     assert_equal 0, counter
@@ -368,7 +368,7 @@ class BackendTest < MiniTest::Test
     3.times { snooze }
     assert_equal 2, counter
 
-    @backend.idle_block = nil
+    @backend.idle_proc = nil
     sleep 0.01
     assert_equal 2, counter
   end

data/test/test_thread.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
-require 'polyphony/adapters/trace'
 
 class ThreadTest < MiniTest::Test
   def test_thread_spin
@@ -130,18 +129,13 @@ class ThreadTest < MiniTest::Test
 
   def test_that_suspend_returns_immediately_if_no_watchers
     records = []
-    t = Polyphony::Trace.new(:fiber_all) do |r|
-      records << r if r[:event] =~ /^fiber_/
-    end
-    t.enable
-    Polyphony.trace(true)
-
+    Thread.backend.trace_proc = proc {|*r| records << r }
     suspend
-    t.disable
-    assert_equal [:fiber_switchpoint], records.map { |r| r[:event] }
+    assert_equal [
+      [:fiber_switchpoint, Fiber.current]
+    ], records
   ensure
-    t&.disable
-    Polyphony.trace(false)
+    Thread.backend.trace_proc = nil
   end
 
   def test_thread_child_fiber_termination

data/test/test_trace.rb

@@ -1,70 +1,48 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
-require 'polyphony/adapters/trace'
 
 class TraceTest < MiniTest::Test
-  def test_tracing_disabled
-    records = []
-    t = Polyphony::Trace.new { |r| records << r if r[:event] =~ /^fiber_/ }
-    t.enable
-    snooze
-    assert_equal 0, records.size
-  ensure
-    t&.disable
-    Polyphony.trace(nil)
-  end
-
   def test_tracing_enabled
-    records = []
-    t = Polyphony::Trace.new(:fiber_all) { |r| records << r if r[:event] =~ /^fiber_/ }
-    Polyphony.trace(true)
-    t.enable
+    events = []
+    Thread.backend.trace_proc = proc { |*e| events << e }
     snooze
-    t.disable
     
-    assert_equal 3, records.size
-    events = records.map { |r| r[:event] }
-    assert_equal [:fiber_schedule, :fiber_switchpoint, :fiber_run], events
-    assert_equal [Fiber.current], records.map { |r| r[:fiber] }.uniq
+    assert_equal [
+      [:fiber_schedule, Fiber.current, nil],
+      [:fiber_switchpoint, Fiber.current],
+      [:fiber_run, Fiber.current, nil]
+    ], events
   ensure
-    t&.disable
-    Polyphony.trace(nil)
+    Thread.backend.trace_proc = nil
   end
 
   def test_2_fiber_trace
-    records = []
-    thread = Thread.current
-    t = Polyphony::Trace.new(:fiber_all) do |r|
-      records << r if Thread.current == thread && r[:event] =~ /^fiber_/
-    end
-    t.enable
-    Polyphony.trace(true)
+    events = []
+    Thread.backend.trace_proc = proc { |*e| events << e }
 
-    f = spin { sleep 0 }
+    f = spin { sleep 0; :byebye }
     suspend
     sleep 0
 
-    events = records.map { |r| [r[:fiber] == f ? :f : :current, r[:event]] }
     assert_equal [
-      [:f, :fiber_create],
-      [:f, :fiber_schedule],
-      [:current, :fiber_switchpoint],
-      [:f, :fiber_run],
-      [:f, :fiber_switchpoint],
-      [:f, :fiber_event_poll_enter],
-      [:f, :fiber_schedule],
-      [:f, :fiber_event_poll_leave],
-      [:f, :fiber_run],
-      [:f, :fiber_terminate],
-      [:current, :fiber_switchpoint],
-      [:current, :fiber_event_poll_enter],
-      [:current, :fiber_schedule],
-      [:current, :fiber_event_poll_leave],
-      [:current, :fiber_run]
+      [:fiber_create, f],
+      [:fiber_schedule, f, nil],
+      [:fiber_switchpoint, Fiber.current],
+      [:fiber_run, f, nil],
+      [:fiber_switchpoint, f],
+      [:fiber_event_poll_enter, f],
+      [:fiber_schedule, f, nil],
+      [:fiber_event_poll_leave, f],
+      [:fiber_run, f, nil],
+      [:fiber_terminate, f, :byebye],
+      [:fiber_switchpoint, Fiber.current],
+      [:fiber_event_poll_enter, Fiber.current],
+      [:fiber_schedule, Fiber.current, nil],
+      [:fiber_event_poll_leave, Fiber.current],
+      [:fiber_run, Fiber.current, nil]
     ], events
   ensure
-    t&.disable
-    Polyphony.trace(nil)
+    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.58'
+  version: '0.59'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-25 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -437,11 +437,11 @@ files:
 - ext/polyphony/ring_buffer.c
 - ext/polyphony/ring_buffer.h
 - ext/polyphony/runqueue.c
+- ext/polyphony/runqueue.h
 - ext/polyphony/runqueue_ring_buffer.c
 - ext/polyphony/runqueue_ring_buffer.h
 - ext/polyphony/socket_extensions.c
 - ext/polyphony/thread.c
-- ext/polyphony/tracing.c
 - lib/polyphony.rb
 - lib/polyphony/adapters/fs.rb
 - lib/polyphony/adapters/irb.rb
@@ -451,7 +451,6 @@ files:
 - lib/polyphony/adapters/readline.rb
 - lib/polyphony/adapters/redis.rb
 - lib/polyphony/adapters/sequel.rb
-- lib/polyphony/adapters/trace.rb
 - lib/polyphony/core/channel.rb
 - lib/polyphony/core/exceptions.rb
 - lib/polyphony/core/global_api.rb

data/ext/polyphony/tracing.c

@@ -1,11 +0,0 @@
-#include "polyphony.h"
-
-int __tracing_enabled__ = 0;
-
-VALUE __fiber_trace__(int argc, VALUE *argv, VALUE self) {
-  return rb_ary_new4(argc, argv);
-}
-
-void Init_Tracing() {
-  rb_define_global_function("__fiber_trace__", __fiber_trace__, -1);
-}

data/lib/polyphony/adapters/trace.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../polyphony'
-
-STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
-
-module Polyphony
-  # Tracing functionality for Polyphony
-  module Trace
-    class << self
-      def new(*events)
-        start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        events = STOCK_EVENTS if events.empty?
-        ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
-      end
-
-      def trace_record(trp, start_stamp)
-        stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
-
-        { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
-          self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
-          lineno: trp.lineno, method_id: trp.method_id,
-          path: trp.path, parameters: tp_params(trp),
-          return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
-          exception: tp_raised_exception(trp) }
-      end
-
-      def tp_fiber(trp)
-        trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
-      end
-
-      PARAMS_EVENTS = %i[call c_call b_call].freeze
-
-      def tp_params(trp)
-        PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
-      end
-
-      RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
-
-      def tp_return_value(trp)
-        RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
-      end
-
-      SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
-
-      def tp_schedule_value(trp)
-        SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
-      end
-
-      def tp_raised_exception(trp)
-        trp.event == :raise && trp.raised_exception
-      end
-
-      def analyze(records)
-        by_fiber = Hash.new { |h, f| h[f] = [] }
-        records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
-        { by_fiber: by_fiber }
-      end
-
-      # Implements fake TracePoint instances for fiber-related events
-      class FiberTracePoint
-        attr_reader :event, :fiber, :value
-
-        def initialize(tpoint)
-          @tp = tpoint
-          @event = tpoint.return_value[0]
-          @fiber = tpoint.return_value[1]
-          @value = tpoint.return_value[2]
-        end
-
-        def lineno
-          @tp.lineno
-        end
-
-        def method_id
-          @tp.method_id
-        end
-
-        def path
-          @tp.path
-        end
-
-        def self
-          @tp.self
-        end
-
-        def binding
-          @tp.binding
-        end
-      end
-
-      class << ::TracePoint
-        POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
-
-        alias_method :orig_new, :new
-        def new(*args, &block)
-          events_mask, fiber_events_mask = event_masks(args)
-
-          orig_new(*events_mask) do |tp|
-            handle_tp_event(tp, fiber_events_mask, &block)
-          end
-        end
-
-        def handle_tp_event(tpoint, fiber_events_mask)
-          # next unless !$watched_fiber || Fiber.current == $watched_fiber
-
-          if tpoint.method_id == :__fiber_trace__
-            return if tpoint.event != :c_return
-            return unless fiber_events_mask.include?(tpoint.return_value[0])
-
-            tpoint = FiberTracePoint.new(tpoint)
-          elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
-            return
-          end
-
-          yield tpoint
-        end
-
-        ALL_FIBER_EVENTS = %i[
-          fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-          fiber_event_poll_enter fiber_event_poll_leave
-        ].freeze
-
-        def event_masks(events)
-          events.each_with_object([[], []]) do |e, masks|
-            case e
-            when /^fiber_/
-              masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
-              masks[0] << :c_return unless masks[0].include?(:c_return)
-            else
-              masks[0] << e
-            end
-          end
-        end
-      end
-    end
-  end
-end