polyphony 0.26 → 0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d97b4ef9db1f6463947a3d5e0e300ee0155bd576ee878a4866557a2cc97cf785
-  data.tar.gz: 8fa0f7e075ce3c7bd9cf28270d06b0fbfe399657571aeaa23773400cb6535f58
+  metadata.gz: f3c496d74c1fb5545a3111d9a116c55268cde00298feaea546dab8ba199fb359
+  data.tar.gz: 57810b0cac851c5364ed831549a5d06beef73b13f9f6615d2d9ee0558397ccfd
 SHA512:
-  metadata.gz: ac3eb507f068f54f70f5e1a79d964c39943f7ac7cfa945da02847f59ec53fc23739b2633428258d0caaf91bfdacc25cfcb6fa73175f8d43c7ed38fdd81f0a360
-  data.tar.gz: 75402a0ca525da7aa02fbe933c4f76328d9272ecb9dd7e404003b85a92e327882ca50d63eed49140593628cf0989d1a8cf7aac6abab5ad766124b1e5e7d00348
+  metadata.gz: b0df4d81349f7226544a158e4f46b2e24f71db9496c5ccee0911634f848d0bdaaebc7ac9ae231e8a29892858212f6782a4f4d8a639121249b13cf4793c133482
+  data.tar.gz: 9ac4943327e356c2bf8f6a5a72d75787d1e71983c2aec6784eb6daa242bee3f79c49c379e716b2fb8fc235bf48fc7d2a50825f24a541c129dab12d0b34b1da9b

data/.rubocop.yml

@@ -62,7 +62,7 @@ Style/ClassVars:
   Exclude:
     - lib/polyphony/core/coprocess.rb
 
-Layout/AlignHash:
+Layout/HashAlignment:
   EnforcedColonStyle: table
   EnforcedHashRocketStyle: table
 
@@ -76,7 +76,7 @@ Naming/MethodName:
   Exclude:
     - test/test_signal.rb
 
-Lint/HandleExceptions:
+Lint/SuppressedException:
   Exclude:
     - lib/polyphony/http/server/http1.rb
     - lib/polyphony/http/server/http2.rb
@@ -126,7 +126,7 @@ Style/FormatStringToken:
     - test/**/*.rb
     - examples/**/*.rb
 
-Naming/UncommunicativeMethodParamName:
+Naming/MethodParameterName:
   Exclude:
     - test/**/*.rb
     - examples/**/*.rb

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+0.27 2020-01-19
+---------------
+
+* Reimplement `Throttler` using recurring timer
+* Add `Gyro::Selector` for wrapping libev
+* Add `Gyro::Queue`, a fiber-aware thread-safe queue
+* Implement multithreaded fiber scheduling
+
 0.26 2020-01-12
 ---------------
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.26)
+    polyphony (0.27)
       modulation (~> 1.0)
 
 GEM

data/TODO.md

@@ -1,20 +1,16 @@
-## 0.26 Real IO#gets and IO#read
+## 0.27 Multithreaded fiber scheduling
 
-- More tests
-- Implement some basic stuff missing:
-  - override `IO#eof?` since it too reads into buffer
-  - real `IO#gets` (with buffering)
-  - `IO#read` (read to EOF)
-  - `IO.foreach`
-  - `Process.waitpid`
+- `Gyro_schedule_fiber` - schedule using fiber's associated thread (store thread
+  ref in fiber), instead of current thread
+- Check why first call to `#sleep` returns too early in tests. Check the
+  sleep behaviour in a spawned thread.
 
-## 0.27 Working Sinatra application
+## 0.28 Working Sinatra application
 
-- Pull out redis/postgres code, put into new `polyphony-xxx` gems
 - app with database access (postgresql)
 - benchmarks!
 
-## 0.28 Sidekick
+## 0.29 Sidekick
 
 Plan of action:
 
@@ -22,11 +18,35 @@ Plan of action:
 - test performance
 - proceed from there
 
-## 0.29 Testing && Docs
+## 0.30 Testing && Docs
+
+- Pull out redis/postgres code, put into new `polyphony-xxx` gems
+
+## 0.31 Integration
+
+## 0.32 Real IO#gets and IO#read
+
+- More tests
+- Implement some basic stuff missing:
+  - override `IO#eof?` since it too reads into buffer
+  - real `IO#gets` (with buffering)
+  - `IO#read` (read to EOF)
+  - `IO.foreach`
+  - `Process.waitpid`
+
+## 0.32 Support for multithreaded apps
+
+- Move fiber scheduling to the `Thread` class
+- Gyro selector conforming to the selector interface:
+  
+  ```ruby
+  class Selector
+    def wait
+  end
+  ```
 
-## 0.30 Integration
+- Better separation between 
 
-- Sidekick
 - Rails?
 
 # DNS

data/examples/core/xx-mt-scheduler.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+## An experiment to see if the Coprocess class could be implemented as an
+## extension for the stock Fiber (since it's already enhanced)
+
+class Thread
+  attr_accessor :main_fiber
+
+  alias_method :orig_initialize, :initialize
+  def initialize(*args, &block)
+    orig_initialize do
+      Fiber.current.setup_main_fiber
+      block.(*args)
+    end
+  end
+
+  def fiber_scheduler
+    @fiber_scheduler ||= Scheduler.new
+  end
+end
+
+class Scheduler
+  def initialize
+    # @mutex = Mutex.new
+    @queue = Queue.new
+  end
+
+  def <<(fiber)
+    @queue << fiber
+    # @mutex.synchronize do
+    #   if @head
+    #     @tail.__scheduled_next__ = @tail = fiber
+    #   else
+    #     @head = @tail = fiber
+    #   end
+    # end
+  end
+
+  def switch
+    next_fiber = nil
+    while true
+      next_fiber = @queue.empty? ? Thread.current.main_fiber : @queue.pop# unless @queue.empty?
+      # next_fiber = @queue.empty? ? nil : @queue.pop
+      # puts "next_fiber: #{next_fiber.inspect}"
+      # next_fiber = @mutex.synchronize { @head }
+      break if next_fiber
+      sleep 0
+    end
+
+    # next_next_fiber = next_fiber.__scheduled_next__
+    # next_fiber.__scheduled_next__ = nil
+    next_fiber.__scheduled__ = nil
+    # @mutex.synchronize { @head = next_next_fiber || (@tail = nil) }
+    next_fiber.transfer(next_fiber.__scheduled_value__)
+  end
+
+  def handle_events
+  end
+end
+
+class Fiber
+  def self.spin(&block)
+    new(&wrap_block(block)).setup(block)
+  end
+
+  attr_accessor :__block__
+  attr_reader :scheduler
+
+  def self.wrap_block(block)
+    calling_fiber = Fiber.current
+    proc { |v| Fiber.current.run(v, calling_fiber, &block) }
+  end
+
+  def run(v, calling_fiber)
+    raise v if v.is_a?(Exception)
+
+    @running = true
+    result = yield v
+    @running = nil
+    schedule_waiting_fibers(result)
+    @scheduler.switch
+  rescue Exception => e
+    @running = nil
+    parent_fiber = calling_fiber.running? ? calling_fiber : Thread.current.main_fiber
+    parent_fiber.transfer(e)
+  end
+
+  def running?
+    @running
+  end
+
+  def setup(block)
+    @scheduler = Thread.current.fiber_scheduler
+    @__block__ = block
+    schedule
+    self
+  end
+
+  def setup_main_fiber
+    @scheduler = Thread.current.fiber_scheduler
+    Thread.current.main_fiber = self
+  end
+
+  Fiber.current.setup_main_fiber
+
+  attr_reader :__scheduled_value__
+  # attr_accessor :__scheduled_next__
+  attr_accessor :__scheduled__
+
+  def inspect
+    if @__block__
+      "<Fiber:#{object_id} #{@__block__.source_location.join(':')} (#{@__scheduled_value__.inspect})>"
+    else
+      "<Fiber:#{object_id} (main) (#{@__scheduled_value__.inspect})>"
+    end
+  end
+  alias_method :to_s, :inspect
+
+  def self.snooze
+    current.schedule
+    yield_to_next
+  end
+
+  def self.suspend
+    yield_to_next
+  end
+
+  def self.yield_to_next
+    v = current.scheduler.switch
+    v.is_a?(Exception) ? (raise v) : v
+  end
+
+  def schedule(value = nil)
+    return if @__scheduled__
+
+    @__scheduled__ = true
+    @__scheduled_value__ = value
+    @scheduler << self
+  end
+
+  def await
+    current_fiber = Fiber.current
+    if @waiting_fiber
+      if @waiting_fiber.is_a?(Array)
+        @waiting_fiber << current_fiber
+      else
+        @waiting_fiber = [@waiting_fiber, current_fiber]
+      end
+    else
+      @waiting_fiber = current_fiber
+    end
+    Fiber.suspend
+  end
+
+  def schedule_waiting_fibers(v)
+    case @waiting_fiber
+    when Array then @waiting_fiber.each { |f| f.schedule(v) }
+    when Fiber then @waiting_fiber.schedule(v)
+    end
+  end
+end
+
+# f1 = Fiber.spin {
+#   p Fiber.current
+#   Fiber.snooze
+#   3.times {
+#     STDOUT << '*'
+#     Fiber.snooze
+#   }
+#   :foo
+# }
+
+# f2 = Fiber.spin {
+#   p Fiber.current
+#   Fiber.snooze
+#   10.times {
+#     STDOUT << '.'
+#     Fiber.snooze
+#   }
+#   puts
+# }
+
+# v = f1.await
+# puts "done waiting #{v.inspect}"
+
+def test_single_thread(x, y)
+  x.times {
+    Fiber.spin {
+      y.times { |i| Fiber.snooze }
+    }
+  }
+
+  Fiber.suspend
+end
+
+def spin_char(char)
+  Fiber.spin {
+    loop {
+      STDOUT << char
+      Fiber.snooze
+    }
+  }
+end
+
+def test_two_threads
+  Thread.new {
+    spin_char('.')
+    spin_char(':')
+    Fiber.suspend
+  }
+
+  Thread.new {
+    spin_char('*')
+    spin_char('@')
+    Fiber.suspend
+  }
+end
+
+# test_two_threads
+# sleep
+
+def test_perf(x, y)
+  puts "* #{x} fibers #{y} times"
+  3.times do
+    t0 = Time.now
+    # test_single_thread(1, 1000)
+    test_single_thread(x, y)
+    elapsed = Time.now - t0
+    rate = (x * y / (Time.now - t0)).to_i
+    puts "#{rate} switches/sec"
+  end
+end
+
+loop {
+  test_perf(1, 100000)
+}
+test_perf(10, 10000)
+test_perf(100, 1000)
+test_perf(1000, 100)
+test_perf(10000, 10)
+exit!
+
+def ping_pong
+  STDOUT.sync = true
+  f1 = nil
+  f2 = nil
+  count1 = 0
+  count2 = 0
+
+  Thread.new do
+    f1 = Fiber.spin {
+      loop {
+        count1 += 1
+        # STDOUT << '.'
+        f2&.schedule
+        Fiber.suspend
+      }
+    }
+    Fiber.suspend
+  end
+
+  Thread.new do
+    f2 = Fiber.spin {
+      loop {
+        count2 += 1
+        # STDOUT << '*'
+        f1&.schedule
+        Fiber.suspend
+      }
+    }
+    Fiber.suspend
+  end
+
+  Thread.new do
+    last_count1 = 0
+    last_count2 = 0
+    last_t = Time.now
+    loop {
+      sleep 1
+      t = Time.now
+      e = t - last_t
+      c1 = count1
+      c2 = count2
+      delta1 = c1 - last_count1
+      delta2 = c2 - last_count2
+      rate1 = (delta1.to_f / e).to_i
+      rate2 = (delta2.to_f / e).to_i
+      puts "#{rate1} #{rate2} (#{rate1 + rate2})"
+      last_count1 = c1
+      last_count2 = c2
+      last_t = t
+    }
+  end
+end
+
+ping_pong
+sleep
+exit!
+
+def ping_pong_st
+  STDOUT.sync = true
+  f1 = nil
+  f2 = nil
+  count1 = 0
+  count2 = 0
+
+  f1 = Fiber.spin {
+    loop {
+      count1 += 1
+      # STDOUT << '.'
+      f2&.schedule
+      Fiber.suspend
+    }
+  }
+
+  f2 = Fiber.spin {
+    last_count1 = 0
+    last_count2 = 0
+    last_t = Time.now
+
+    loop {
+      count2 += 1
+      # STDOUT << '*'
+      f1&.schedule
+      Fiber.suspend
+
+      next unless count2 % 100000 == 0
+
+      t = Time.now
+      e = t - last_t
+      c1 = count1
+      c2 = count2
+      delta1 = c1 - last_count1
+      delta2 = c2 - last_count2
+      rate1 = (delta1.to_f / e).to_i
+      rate2 = (delta2.to_f / e).to_i
+      puts "#{rate1} #{rate2} (#{rate1 + rate2})"
+      last_count1 = c1
+      last_count2 = c2
+      last_t = t
+    }
+  }
+
+end
+
+ping_pong_st
+Fiber.suspend