polyphony 0.45.2 → 0.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2fa4fa731ff52272d3aed456f7a26751e76c63b4335366919bffaf089bf96dd
-  data.tar.gz: 1afe67258c5c73d9cc1082ca238eb358dac0f5b7a975f90a77b4f6de6a23b2a4
+  metadata.gz: 606d74c424178b9e8bb17cd7b2848e0e1c1b092e77eeb98ce1026fd7d1f38c61
+  data.tar.gz: 9e003833af5f2c8505ea41d2ebe728fbf776f428f47d925b0185fd592d102737
 SHA512:
-  metadata.gz: 175edf315d759f85d2c0d934be36b9fcacd68342206d984ad64f800120a8b65668e9ea81595f47cbbb439402c256b47fde78f0cdad4b42e0c3b1d6ee321135b9
-  data.tar.gz: 01cfe1d8b51d60a736adb80062eb22e7983a1879a5491cb7a2e47ec4ad5734e0c8bd8664653870a4393276b42fa912953721658ecff634521a672419c8d3cab6
+  metadata.gz: 1cfb1c81d3b38a545ceb856d4619c11386407081ecd43a6e6209d2ed4efb1c436242aa016657d379f0a0331ca24944f5e51c5359ad44afc3a88d53af1de7976b
+  data.tar.gz: 9b47ba16c7de942bea952f9f12d225aed86a505c2fd6cf7740a88d5d398af0e91e37a16e3ee9af2129ad88c8ff17c2b5aba7dcf6630811af62202e4b2585d6dc

data/.github/workflows/test.yml

@@ -23,6 +23,8 @@ jobs:
       run: |
         gem install bundler
         bundle install
+    - name: Show Linux kernel version
+      run: uname -r
     - name: Compile C-extension
       run: bundle exec rake compile
     - name: Run tests

data/CHANGELOG.md

@@ -1,3 +1,42 @@
+## 0.47.0
+
+* Implement `#spin_scope` used for creating blocking fiber scopes 
+* Reimplement `move_on_after`, `cancel_after`, `Timeout.timeout` using
+  `Backend#timeout` (avoids creating canceller fiber for most common use case)
+* Implement `Backend#timeout` API
+* Implemented capped queues
+
+## 0.46.1
+
+* Add `TCPServer#accept_loop`, `OpenSSL::SSL::SSLSocket#accept_loop` method
+* Fix compilation error on MacOS (#43)
+* Fix backtrace for `Timeout.timeout`
+* Add `Backend#timer_loop`
+
+## 0.46.0
+
+* Implement [io_uring backend](https://github.com/digital-fabric/polyphony/pull/44)
+
+## 0.45.5
+
+* Fix compilation error (#43)
+* Add support for resetting move_on_after, cancel_after timeouts
+* Optimize anti-event starvation polling
+* Implement optimized runqueue for better performance
+* Schedule parent with priority on uncaught exception
+* Fix race condition in `Mutex#synchronize` (#41)
+
+## 0.45.4
+
+* Improve signal trapping mechanism
+
+## 0.45.3
+
+* Don't swallow error in `Process#kill_and_await`
+* Add `Fiber#mailbox` attribute reader
+* Fix bug in `Fiber.await`
+* Implement `IO#getc`, `IO#getbyte`
+
 ## 0.45.2
 
 * Rewrite `Fiber#<<`, `Fiber#await`, `Fiber#receive` in C

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.45.2)
+    polyphony (0.47.0)
 
 GEM
   remote: https://rubygems.org/
@@ -87,7 +87,7 @@ GEM
     rack (2.2.3)
     rainbow (3.0.0)
     rake (12.3.3)
-    rake-compiler (1.0.5)
+    rake-compiler (1.1.1)
       rake
     rb-fsevent (0.10.3)
     rb-inotify (0.10.1)
@@ -141,7 +141,7 @@ DEPENDENCIES
   polyphony!
   pry (= 0.13.1)
   rack (>= 2.0.8, < 2.3.0)
-  rake-compiler (= 1.0.5)
+  rake-compiler (= 1.1.1)
   redis (= 4.1.0)
   rubocop (= 0.85.1)
   sequel (= 5.34.0)

data/README.md

@@ -35,9 +35,9 @@
 Polyphony is a library for building concurrent applications in Ruby. Polyphony
 harnesses the power of [Ruby fibers](https://ruby-doc.org/core-2.5.1/Fiber.html)
 to provide a cooperative, sequential coroutine-based concurrency model. Under
-the hood, Polyphony uses [libev](https://github.com/enki/libev) as a
-high-performance event reactor that provides timers, I/O watchers and other
-asynchronous event primitives.
+the hood, Polyphony uses
+[io_uring](https://unixism.net/loti/what_is_io_uring.html) or
+[libev](https://github.com/enki/libev) to maximize I/O performance.
 
 ## Features
 

data/Rakefile

@@ -23,4 +23,4 @@ task :docs do
   exec 'RUBYOPT=-W0 jekyll serve -s docs -H ec2-18-156-117-172.eu-central-1.compute.amazonaws.com'
 end
 
-CLEAN.include "**/*.o", "**/*.so", "**/*.bundle", "**/*.jar", "pkg", "tmp"
+CLEAN.include "**/*.o", "**/*.so", "**/*.so.*", "**/*.a", "**/*.bundle", "**/*.jar", "pkg", "tmp"

data/TODO.md

@@ -1,15 +1,24 @@
-0.45.2
+## Roadmap for Polyphony 1.0
 
-- Adapter for Pry and IRB (Which fixes #5 and #6)
-- Redesign signal handling - the current mechanism is problematic in that it
-  does not address signals that do not kill, for instance HUP or USR1.
+- Check why worker-thread example doesn't work.
+- Add test that mimics the original design for Monocrono:
+  - 256 fibers each waiting for a message
+  - When message received do some blocking work using a `ThreadPool`
+  - Send messages, collect responses, check for correctness
 - Improve `#supervise`. It does not work as advertised, and seems to exhibit an
   inconsistent behaviour (see supervisor example).
-- Fix backtrace for `Timeout.timeout` API (see timeout example).
-- Check why worker-thread example doesn't work.
 
-0.46.0
+- io_uring
+  - Use playground.c to find out why we when submitting and waiting for
+    completion in single syscall signals seem to be blocked until the syscall
+    returns. Is this a bug in io_uring/liburing?
+
+-----------------------------------------------------
 
+- Add `Backend#splice(in, out, nbytes)` API
+- Adapter for io/console (what does `IO#raw` do?)
+- Adapter for Pry and IRB (Which fixes #5 and #6)
+- allow backend selection at runtime
 - Debugging
   - Eat your own dogfood: need a good tool to check what's going on when some
     test fails
@@ -122,8 +131,6 @@
   - discuss using `snooze` for ensuring responsiveness when executing CPU-bound work
 
 
-## 0.47
-
 ### Some more API work, more docs
 
 - sintra app with database access (postgresql)
@@ -135,14 +142,10 @@
   - proceed from there
 
 
-## 0.48
-
 ### Sinatra / Sidekiq
 
 - Pull out redis/postgres code, put into new `polyphony-xxx` gems
 
-## 0.49
-
 ### Testing && Docs
 
 - More tests
@@ -153,7 +156,10 @@
   - `IO.foreach`
   - `Process.waitpid`
 
-## 0.50 DNS
+### Quic / HTTP/3
+
+- Python impl: https://github.com/aiortc/aioquic/
+- Go impl: https://github.com/lucas-clemente/quic-go
 
 ### DNS client
 
@@ -186,17 +192,3 @@ Prior art:
 
 - https://github.com/socketry/async-dns
 
-## Work on API
-
-- Add option for setting the exception raised on cancelling using `#cancel_after`:
-
-```ruby
-cancel_after(3, with_error: MyErrorClass) do
-  do_my_thing
-end
-# or a RuntimeError with message
-cancel_after(3, with_error: 'Cancelled due to timeout') do
-  do_my_thing
-end
-```
-

data/bin/test

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -e
+clear && POLYPHONY_USE_LIBEV=1 rake recompile && ruby test/run.rb
+clear && rake recompile && ruby test/run.rb

data/examples/core/enumerable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+module Enumerable
+  def map_concurrently(&block)
+    spin do
+      results = []
+      each_with_index do |i, idx|
+        spin { results[idx] = block.(i) }
+      end
+      Fiber.current.await_all_children
+      results
+    end.await
+  end
+
+  def each_concurrently(max_fibers: nil, &block)
+    return each_concurrently_with_fiber_pool(max_fibers, &block) if max_fibers
+
+    spin do
+      results = []
+      each do |i|
+        spin(&block).schedule(i)
+      end
+      Fiber.current.await_all_children
+    end.await
+    self
+  end
+
+  def each_concurrently_with_fiber_pool(max_fibers, &block)
+    spin do
+      fiber_count = 0
+      workers = []
+      each do |i|
+        if fiber_count < max_fibers
+          workers << spin do
+            loop do
+              item = receive
+              break if item == :__stop__
+              block.(item)
+            end
+          end
+        end
+
+        fiber = workers.shift
+        fiber << i
+        workers << fiber
+      end
+      workers.each { |f| f << :__stop__ }
+      Fiber.current.await_all_children
+    end.await
+    self
+  end
+end
+
+o = 1..3
+o.each_concurrently(max_fibers: 2) do |i|
+  puts "#{Fiber.current} sleep #{i}"
+  sleep(i)
+  puts "wakeup #{i}"
+end

data/examples/io/raw.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'io/console'
+
+c = STDIN.raw(min: 1, tim: 0, &:getbyte)
+p result: c
+exit
+
+puts '?' * 40
+c = STDIN.getbyte
+puts '*' * 40
+p c

data/examples/io/reline.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'polyphony/adapters/readline'
+require 'pry'
+
+$counter = 0
+timer = spin do
+  throttled_loop(5) do
+    $counter += 1
+  end
+end
+
+at_exit { timer.stop }
+
+puts 'try typing $counter to see the counter incremented in the background'
+binding.pry

data/examples/performance/fiber_resume.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance of Fiber.transfer degrades as the fiber
+# count increases
+
+def run(num_fibers)
+  count = 0
+
+  GC.start
+  GC.disable
+
+  fibers = []
+  num_fibers.times do
+    fibers << Fiber.new { loop { Fiber.yield } }
+  end
+
+  t0 = Time.now
+
+  while count < 1000000
+    fibers.each do |f|
+      count += 1
+      f.resume
+    end
+  end
+
+  elapsed = Time.now - t0
+
+  puts "fibers: #{num_fibers} count: #{count} rate: #{count / elapsed}"
+rescue Exception => e
+  puts "Stopped at #{count} fibers"
+  p e
+end
+
+run(100)
+run(1000)
+run(10000)
+run(100000)

data/examples/performance/fiber_transfer.rb

@@ -12,6 +12,7 @@ end
 def run(num_fibers)
   count = 0
 
+  GC.start
   GC.disable
 
   first = nil
@@ -36,13 +37,21 @@ def run(num_fibers)
   last.next = first
   
   t0 = Time.now
+  puts "start transfer..."
   first.transfer
   elapsed = Time.now - t0
 
-  puts "fibers: #{num_fibers} count: #{count} rate: #{count / elapsed}"
-  GC.start
+  rss = `ps -o rss= -p #{Process.pid}`.to_i
+
+  puts "fibers: #{num_fibers} rss: #{rss} count: #{count} rate: #{count / elapsed}"
+rescue Exception => e
+  puts "Stopped at #{count} fibers"
+  p e
 end
 
+puts "pid: #{Process.pid}"
 run(100)
-run(1000)
-run(10000)
+# run(1000)
+# run(10000)
+# run(100000)
+# run(400000)

data/examples/performance/multi_snooze.rb

@@ -18,7 +18,6 @@ def bm(fibers, iterations)
   Fiber.current.await_all_children
   dt = Time.now - t0
   puts "#{[fibers, iterations].inspect} setup: #{t0 - t_pre}s count: #{count} #{count / dt.to_f}/s"
-  Thread.current.run_queue_trace
 end
 
 GC.disable

data/examples/performance/thread-vs-fiber/compare.rb

@@ -0,0 +1,59 @@
+SERVERS = {
+  polyphony: {
+    port: 1234,
+    cmd: 'ruby examples/performance/thread-vs-fiber/polyphony_server.rb'
+  },
+  threaded: {
+    port: 1235,
+    cmd: 'ruby examples/performance/thread-vs-fiber/threaded_server.rb'
+  },
+  em: {
+    port: 1236,
+    cmd: 'ruby examples/performance/thread-vs-fiber/em_server.rb'
+  }
+}
+SETTINGS = [
+  '-t1 -c1',
+  '-t4 -c8',
+  '-t8 -c64',
+  '-t16 -c512',
+  '-t32 -c4096',
+  '-t64 -c8192',
+  '-t128 -c16384',
+  '-t256 -c32768'
+]
+
+def run_test(name, port, cmd, setting)
+  puts "*" * 80
+  puts "Run #{name} (#{port}): #{setting}"
+  puts "*" * 80
+  
+  pid = spawn("#{cmd} > /dev/null 2>&1")
+  sleep 1
+
+  output = `wrk -d60 #{setting} \"http://127.0.0.1:#{port}/\"`
+  puts output
+  (output =~ /Requests\/sec:\s+(\d+)/) && $1.to_i
+ensure
+  Process.kill('KILL', pid)
+  Process.wait(pid)
+  3.times { puts }
+end
+
+def perform_benchmark
+  results = []
+  SETTINGS.each do |s|
+    results << SERVERS.inject({}) do |h, (n, o)|
+      h[n] = run_test(n, o[:port], o[:cmd], s)
+      h
+    end
+  end
+  results
+end
+
+results = []
+3.times { results << perform_benchmark }
+
+require 'pp'
+puts "results:"
+pp results