polyphony 0.46.0 → 0.47.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 890abc2b84ed305f591c697764ea16255059aeb3cd4ddd23195b81f78f5f6daf
-  data.tar.gz: a02442318f82682ba1fa3a87e2b4e7ad8ae06d365a7d4a4b5c45689b2e55472f
+  metadata.gz: 89890bc8a81fd4f0a80f6d84c7f5138cfda12bc99848e74ef8140abf681640e2
+  data.tar.gz: d18e210b24f3d0eb2f83c1dcb188e7c1c691f949231ef0b3d07bd926c988f4d6
 SHA512:
-  metadata.gz: 506a2fdbdee9e6c5bb94b976489537792941326080441f3d93924cd9657db5188b29e4ced6e1c8a6f8db06ae211da0522b3ac042e45365be1af2e68f8b157b0e
-  data.tar.gz: cbc0e333731e035c2094abfa72d425e649c210a8c9d3aec467446f615315cfc6e1f6de664321099ccdf93ddd6e1bb0ba484b2b8b53922725b2df8483aedefeab
+  metadata.gz: c95bef00de396f601f91937c780202a26d0e9c5a3eb48f564d1dcb70d89b30c12ebbbc89c9ddb10b81b013f9a89398468b8b3b4c1d3158d00110e3e6ea5355a6
+  data.tar.gz: 3c31dac6a239e73b6dbf028edfeced82ac6b2d17ba2f5f2960a41aa9d74e57336082bbe038a8ed6701a2ceefaf68cacb74764f9f71c81ce1e36d5868702e5346

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.47.3
+
+* Enable I/O in signal handlers (#45)
+* Accept `:interval` argument in `#spin_loop`
+
+## 0.47.2
+
+* Fix API compatibility between TCPSocket and IO
+
+## 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)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.46.0)
+    polyphony (0.47.3)
 
 GEM
   remote: https://rubygems.org/

data/TODO.md

@@ -1,16 +1,56 @@
-- change fiber_trace method to return nil, change trace logic to use provided
-  arguments instead of return values for fiber events
-- allow backend selection at runtime
-- add Backend#timer_loop that does what throttled_loop does, on lower level
-- Adapter for io/console (what does `IO#raw` do?)
-- Adapter for Pry and IRB (Which fixes #5 and #6)
+Graceful shutdown again:
+
+- Add `Polyphony::GracefulShutdown` exception
+- Two exceptions for stopping fibers:
+  - `Polyphony::GracefulShutdown` - graceful shutdown
+  - `Polyphony::Terminate` - ungraceful shutdown
+- Fiber API:
+  - `Fiber#shutdown_children` - graceful shutdown of all children
+  - `Fiber#terminate_children` - ungraceful shutdown of all children
+
+- Add `Fiber#graceful_shutdown?` method
+  - Returns false unless a `Polyphony::GracefulShutdown` was raised
+- Override `Polyphony::Terminate#invoke` to reset the `@graceful_shutdown` fiber
+  flag
+
+And then we have:
+
+```ruby
+spin do
+  loop { do_some_stuff }
+ensure
+  return unless Fiber.current.graceful_shutdown?
+
+shutdown_gracefully
+end
+```
+
+- When a fiber is stopped it should use `Polyphony::Terminate` to stop child
+  fibers, *unless* it was stopped with a `Polyphony::GracefulShutdown` (which it
+  can check with `@graceful_shutdown`).
+
+
+## Roadmap for Polyphony 1.0
+
+- 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.47
+- 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
@@ -148,6 +188,11 @@
   - `IO.foreach`
   - `Process.waitpid`
 
+### Quic / HTTP/3
+
+- Python impl: https://github.com/aiortc/aioquic/
+- Go impl: https://github.com/lucas-clemente/quic-go
+
 ### DNS client
 
 ```ruby
@@ -179,17 +224,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/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/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

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

@@ -0,0 +1,33 @@
+require 'eventmachine'
+require 'http/parser'
+require 'socket'
+
+module HTTPServer
+  def post_init
+    @parser = Http::Parser.new
+    @pending_requests = []
+    @parser.on_message_complete = proc { @pending_requests << @parser }
+  end
+
+  def receive_data(data)
+    @parser << data
+    write_response while @pending_requests.shift
+  end
+
+  def write_response
+    status_code = "200 OK"
+    data = "Hello world!\n"
+    headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
+    send_data "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
+  end
+end
+
+EventMachine::run do
+  EventMachine::start_server(
+    '0.0.0.0',
+    1236,
+    HTTPServer
+  )
+  puts "pid #{Process.pid} EventMachine listening on port 1236"
+
+end

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

@@ -4,41 +4,31 @@ require 'bundler/setup'
 require 'polyphony'
 require 'http/parser'
 
-$connection_count = 0
-
 def handle_client(socket)
-  $connection_count += 1
+  pending_requests = []
   parser = Http::Parser.new
-  reqs = []
-  parser.on_message_complete = proc do |env|
-    reqs << Object.new # parser
-  end
+  parser.on_message_complete = proc { pending_requests << parser }
+
   socket.recv_loop do |data|
     parser << data
-    while (req = reqs.shift)
-      handle_request(socket, req)
-      req = nil
-    end
+    write_response(socket) while pending_requests.shift
   end
 rescue IOError, SystemCallError => e
   # do nothing
 ensure
-  $connection_count -= 1
   socket&.close
 end
 
-def handle_request(client, parser)
+def write_response(socket)
   status_code = "200 OK"
   data = "Hello world!\n"
   headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
-  client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
+  socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
 server = TCPServer.open('0.0.0.0', 1234)
-puts "pid #{Process.pid}"
-puts "listening on port 1234"
+puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 1234"
 
-loop do
-  client = server.accept
-  spin { handle_client(client) }
+server.accept_loop do |c|
+  spin { handle_client(c) }
 end

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

@@ -1,23 +1,30 @@
-require 'thread'
 require 'http/parser'
 require 'socket'
 
-def handle_client(client)
-  Thread.new do
-    parser = Http::Parser.new
-    parser.on_message_complete = proc do |env|
-      status_code = 200
-      data = "Hello world!\n"
-      headers = "Content-Length: #{data.bytesize}\r\n"
-      client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
-    end
-    client.read_loop { |data| parser << data }
-    client.close
+def handle_client(socket)
+  pending_requests = []
+  parser = Http::Parser.new
+  parser.on_message_complete = proc { pending_requests << parser }
+
+  while (data = socket.recv(8192))
+    parser << data
+    write_response(socket) while pending_requests.shift
   end
+rescue IOError, SystemCallError => e
+  # ignore
+ensure
+  socket.close
+end
+
+def write_response(socket)
+  status_code = "200 OK"
+  data = "Hello world!\n"
+  headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
+  socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-server = TCPServer.open(1234)
-puts "Listening on port 1234"
+server = TCPServer.open(1235)
+puts "pid #{Process.pid} threaded listening on port 1235"
 while socket = server.accept
-  handle_client(socket)
+  Thread.new { handle_client(socket) }
 end