polyphony 0.27 → 0.28

data/lib/polyphony/trace.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+export :new, :analyze
+
+require 'polyphony'
+
+STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
+
+def new
+  start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  ::TracePoint.new(*STOCK_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, self: trp.self, binding: trp.binding, event: trp.event,
+    fiber: tp_fiber(trp), lineno: trp.lineno, method_id: trp.method_id,
+    file: trp.path, parameters: tp_params(trp),
+    return_value: tp_return_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
+
+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
+  alias_method :orig_new, :new
+  def new(*args, &block)
+    polyphony_file_regexp = /^#{::Exception::POLYPHONY_DIR}/
+
+    orig_new(*args) do |tp|
+      # next unless !$watched_fiber || Fiber.current == $watched_fiber
+
+      if tp.method_id == :__fiber_trace__
+        block.(FiberTracePoint.new(tp)) if tp.event == :c_return
+      else
+        next if tp.path =~ polyphony_file_regexp
+
+        block.(tp)
+      end
+    end
+  end
+end

data/lib/polyphony/version.rb

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

data/lib/polyphony.rb

@@ -35,6 +35,7 @@ module Polyphony
     Sync:         './polyphony/core/sync',
     ThreadPool:   './polyphony/core/thread_pool',
     Throttler:    './polyphony/core/throttler',
+    Trace:        './polyphony/trace',
     Websocket:    './polyphony/websocket'
   )
 

data/polyphony.gemspec

@@ -11,7 +11,9 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://dfab.gitbook.io/polyphony/'
   s.metadata    = {
     "source_code_uri" => "https://github.com/digital-fabric/polyphony",
-    "documentation_uri" => "https://dfab.gitbook.io/polyphony/"
+    "documentation_uri" => "https://digital-fabric.github.io/polyphony/",
+    "homepage_uri" => "https://digital-fabric.github.io/polyphony/",
+    "changelog_uri" => "https://github.com/digital-fabric/polyphony/blob/master/CHANGELOG.md"
   }
   s.rdoc_options = ["--title", "polyphony", "--main", "README.md"]
   s.extra_rdoc_files = ["README.md"]
@@ -19,16 +21,23 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 2.6'
 
-  s.add_runtime_dependency      'modulation',         '~>1.0'
+  s.add_runtime_dependency      'modulation',           '~>1.0'
   
-  s.add_development_dependency  'httparty',           '0.17.0'
-  s.add_development_dependency  'localhost',          '1.1.4'
-  s.add_development_dependency  'minitest',           '5.11.3'
-  s.add_development_dependency  'minitest-reporters', '1.4.2'
-  s.add_development_dependency  'simplecov',          '0.17.1'
-  s.add_development_dependency  'pg',                 '1.1.3'
-  s.add_development_dependency  'rake-compiler',      '1.0.5'
-  s.add_development_dependency  'redis',              '4.1.0'
-  s.add_development_dependency  'hiredis',            '0.6.3'
-  s.add_development_dependency  'http_parser.rb',     '~>0.6.0'
+  s.add_development_dependency  'httparty',             '0.17.0'
+  s.add_development_dependency  'localhost',            '1.1.4'
+  s.add_development_dependency  'minitest',             '5.13.0'
+  s.add_development_dependency  'minitest-reporters',   '1.4.2'
+  s.add_development_dependency  'simplecov',            '0.17.1'
+  s.add_development_dependency  'rubocop',              '0.79.0'
+  s.add_development_dependency  'pg',                   '1.1.3'
+  s.add_development_dependency  'rake-compiler',        '1.0.5'
+  s.add_development_dependency  'redis',                '4.1.0'
+  s.add_development_dependency  'hiredis',              '0.6.3'
+  s.add_development_dependency  'http_parser.rb',       '~>0.6.0'
+
+  s.add_development_dependency  'jekyll',               '~>3.8.6'
+  s.add_development_dependency  'jekyll-remote-theme',  '~>0.4.1'
+  s.add_development_dependency  'jekyll-seo-tag',       '~>2.6.1'
+  s.add_development_dependency  'just-the-docs',        '~>0.2.7'
+
 end

data/test/helper.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+
+require_relative './coverage' if ENV['COVERAGE']
+
 require 'polyphony'
 
 require 'fileutils'
 require_relative './eg'
 
-require_relative './coverage' if ENV['COVERAGE']
-
 require 'minitest/autorun'
 require 'minitest/reporters'
 

data/test/test_fiber.rb

@@ -25,6 +25,15 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_tag
+    assert_equal :main, Fiber.current.tag
+    Fiber.current.tag = :foo
+    assert_equal :foo, Fiber.current.tag
+
+    f = Fiber.spin(:bar) { }
+    assert_equal :bar, f.tag
+  end
+
   def test_await_return_value
     f = Fiber.spin { %i[foo bar] }
     assert_equal %i[foo bar], f.await
@@ -261,13 +270,16 @@ class FiberTest < MiniTest::Test
         snooze
         counter += 1
       end
+      suspend
     end
 
-    assert_equal :scheduled, f.state
+    assert_equal :runnable, f.state
     assert_equal :running, Fiber.current.state
     snooze
-    assert_equal :scheduled, f.state
+    assert_equal :runnable, f.state
     snooze while counter < 3
+    assert_equal :waiting, f.state
+    f.stop
     assert_equal :dead, f.state
   ensure
     f&.stop
@@ -444,7 +456,7 @@ class MailboxTest < MiniTest::Test
     f = spin { :foo }
 
     expected = format(
-      '#<Fiber:%s %s:%d:in `test_inspect\' (scheduled)>',
+      '#<Fiber:%s %s:%d:in `test_inspect\' (runnable)>',
       f.object_id,
       __FILE__,
       spin_line_no
@@ -460,4 +472,42 @@ class MailboxTest < MiniTest::Test
     )
     assert_equal expected, f.inspect
   end
+
+  def test_system_exit_in_fiber
+    parent_error = nil
+    main_fiber_error = nil
+    f2 = nil
+    f1 = spin do
+      f2 = spin { raise SystemExit }
+      suspend
+    rescue Exception => parent_error
+    end
+
+    begin
+      suspend
+    rescue Exception => main_fiber_error
+    end
+
+    assert_nil parent_error
+    assert_kind_of SystemExit, main_fiber_error
+  end
+
+  def test_interrupt_in_fiber
+    parent_error = nil
+    main_fiber_error = nil
+    f2 = nil
+    f1 = spin do
+      f2 = spin { raise Interrupt }
+      suspend
+    rescue Exception => parent_error
+    end
+
+    begin
+      suspend
+    rescue Exception => main_fiber_error
+    end
+
+    assert_nil parent_error
+    assert_kind_of Interrupt, main_fiber_error
+  end
 end

data/test/test_global_api.rb

@@ -242,6 +242,18 @@ class MoveOnAfterTest < MiniTest::Test
     assert_equal :bar, v
   end
 
+  def test_spin_without_tag
+    f = spin { }
+    assert_kind_of Fiber, f
+    assert_nil f.tag
+  end
+
+  def test_spin_with_tag
+    f = spin(:foo) { }
+    assert_kind_of Fiber, f
+    assert_equal :foo, f.tag
+  end
+
   def test_spin_loop
     buffer = []
     counter = 0

data/test/test_gyro.rb

@@ -8,13 +8,13 @@ class GyroTest < MiniTest::Test
 
     f = Fiber.new {}
 
-    assert_equal :suspended, f.state
+    assert_equal :waiting, f.state
     f.resume
     assert_equal :dead, f.state
 
     f = Fiber.new { }
     f.schedule
-    assert_equal :scheduled, f.state
+    assert_equal :runnable, f.state
     snooze
     assert_equal :dead, f.state
   end

data/test/test_supervisor.rb

@@ -25,6 +25,18 @@ class SupervisorTest < MiniTest::Test
     assert_equal [10, 20, 30], result
   end
 
+  def test_new_with_block
+    supervisor = Polyphony::Supervisor.new { |s|
+      (1..3).each { |i|
+        s.spin {
+          snooze
+          i * 10
+        }
+      }
+    }
+    assert_equal [10, 20, 30], supervisor.await
+  end
+
   def test_join_multiple_fibers
     result = Polyphony::Supervisor.new.join { |s|
       (1..3).each { |i|

data/test/test_thread.rb

@@ -41,4 +41,16 @@ class ThreadTest < MiniTest::Test
     # thread's event selector, leading to a memory leak.
     t.kill if t.alive?
   end
+
+  def test_thread_inspect
+    lineno = __LINE__ + 1
+    t = Thread.new {}
+    str = format(
+      "#<Thread:%d %s:%d (run)>",
+      t.object_id,
+      __FILE__,
+      lineno,
+    )
+    assert_equal str, t.inspect
+  end
 end

data/test/test_thread_pool.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ThreadPoolTest < MiniTest::Test
+  def setup
+    super
+    @pool = Polyphony::ThreadPool.new
+  end
+
+  def test_process
+    current_thread = Thread.current
+
+    processing_thread = nil
+    result = @pool.process do
+      processing_thread = Thread.current
+      +'foo' + 'bar'
+    end
+    assert_equal 'foobar', result
+    assert processing_thread != current_thread
+  end
+
+  def test_multi_process
+    current_thread = Thread.current
+    threads = []
+    results = []
+
+    10.times do |i|
+      spin do
+        results << @pool.process do
+          threads << Thread.current
+          sleep 0.01
+          i * 10
+        end
+      end
+    end
+
+    suspend
+
+    assert_equal @pool.size, threads.uniq.size
+    assert_equal (0..9).map { |i| i * 10}, results.sort
+  end
+
+  def test_process_with_exception
+    result = nil
+    begin
+      result = @pool.process { raise 'foo' }
+    rescue => result
+    end
+
+    assert_kind_of RuntimeError, result
+    assert_equal 'foo', result.message
+  end
+
+  def test_cast
+    t0 = Time.now
+    threads = []
+    buffer = []
+    10.times do |i|
+      @pool.cast do
+        sleep 0.01
+        threads << Thread.current
+        buffer << i
+      end
+    end
+    elapsed = Time.now - t0
+
+    assert elapsed < 0.005
+    assert buffer.size < 2
+    
+    sleep 0.04
+    assert_equal @pool.size, threads.uniq.size
+    assert_equal (0..9).to_a, buffer.sort
+  end
+end

data/test/test_throttler.rb

@@ -38,4 +38,10 @@ class ThrottlerTest < MiniTest::Test
   ensure
     t.stop
   end
+
+  def test_throttler_with_invalid_argument
+    assert_raises RuntimeError do
+      Polyphony::Throttler.new(:foobar)
+    end
+  end
 end

data/test/test_trace.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+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
+    Gyro.trace(nil)
+  end
+
+  def test_tracing_enabled
+    records = []
+    t = Polyphony::Trace.new { |r| records << r if r[:event] =~ /^fiber_/ }
+    t.enable
+    Gyro.trace(true)
+    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
+  ensure
+    t.disable
+    Gyro.trace(nil)
+  end
+
+  def test_2_fiber_trace
+    records = []
+    t = Polyphony::Trace.new { |r| records << r if r[:event] =~ /^fiber_/ }
+    t.enable
+    Gyro.trace(true)
+
+    f = spin { sleep 0 }
+    suspend
+    sleep 0
+
+    events = records.map { |r| [r[:fiber], r[:event]] }
+    assert_equal [
+      [f, :fiber_create],
+      [f, :fiber_schedule],
+      [Fiber.current, :fiber_switchpoint],
+      [f, :fiber_run],
+      [f, :fiber_switchpoint],
+      [f, :fiber_ev_loop_enter],
+      [f, :fiber_schedule],
+      [f, :fiber_ev_loop_leave],
+      [f, :fiber_run],
+      [f, :fiber_terminate],
+      [Fiber.current, :fiber_switchpoint],
+      [Fiber.current, :fiber_ev_loop_enter],
+      [Fiber.current, :fiber_schedule],
+      [Fiber.current, :fiber_ev_loop_leave],
+      [Fiber.current, :fiber_run]
+    ], events
+  ensure
+    t.disable
+    Gyro.trace(nil)
+  end
+end