polyphony 0.43.8

data/examples/performance/snooze_raw.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+def worker_loop(tag)
+  loop do
+    puts "#{Time.now} #{tag}"
+    snooze
+  end
+end
+
+f1 = Fiber.new { worker_loop(:a) }
+f2 = Fiber.new { worker_loop(:b) }
+
+$reactor = Fiber.new do
+  loop do
+    # sleep 0.001
+    handle_next_tick
+  end
+end
+
+$next_tick_items = []
+
+def handle_next_tick
+  items = $next_tick_items
+  $next_tick_items = []
+  items.each(&:transfer)
+end
+
+module Kernel
+  def snooze
+    $next_tick_items << Fiber.current
+    $reactor.transfer
+  end
+end
+
+$next_tick_items << f1
+$next_tick_items << f2
+$reactor.transfer

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+
+class Http::Parser
+  def setup_async
+    self.on_message_complete = proc { @request_complete = true }
+  end
+
+  def parse(data)
+    self << data
+    return nil unless @request_complete
+
+    @request_complete = nil
+    self
+  end
+end
+
+def handle_client(socket)
+  parser = Http::Parser.new
+  reqs = []
+  parser.on_message_complete = proc do |env|
+    reqs << Object.new # parser
+  end
+  while (data = socket.readpartial(8192)) do
+    parser << data
+    while (req = reqs.shift)
+      handle_request(socket, req)
+      req = nil
+      # snooze
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  socket&.close
+  parser.reset!
+end
+
+def handle_request(client, parser)
+  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
+
+$incoming = Polyphony::Queue.new
+
+$threads = (1..4).map {
+  Thread.new {
+    Thread.current.setup_fiber_scheduling
+    loop {
+      conn = $incoming.pop
+      puts "#{Thread.current.inspect} pop #{conn.inspect}"
+      spin { handle_client(conn) }
+    }
+  }
+}
+
+spin do
+  server = TCPServer.open('0.0.0.0', 1234)
+  puts "listening on port 1234"
+
+  loop do
+    client = server.accept
+    $incoming << client
+    # spin { handle_client(client) }
+  end
+end
+
+puts "pid #{Process.pid}"
+suspend

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+
+$connection_count = 0
+
+def handle_client(socket)
+  $connection_count += 1
+  parser = Http::Parser.new
+  reqs = []
+  parser.on_message_complete = proc do |env|
+    reqs << Object.new # parser
+  end
+  while (data = socket.readpartial(8192)) do
+    parser << data
+    while (req = reqs.shift)
+      handle_request(socket, req)
+      req = nil
+      snooze
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  $connection_count -= 1
+  socket&.close
+end
+
+def handle_request(client, parser)
+  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}"
+end
+
+server = TCPServer.open('0.0.0.0', 1234)
+puts "pid #{Process.pid}"
+puts "listening on port 1234"
+
+loop do
+  client = server.accept
+  spin { handle_client(client) }
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+
+$connection_count = 0
+
+def handle_client(socket)
+  $connection_count += 1
+  parser = Http::Parser.new
+  reqs = []
+  parser.on_message_complete = proc do |env|
+    reqs << Object.new # parser
+  end
+  socket.read_loop do |data|
+    parser << data
+    while (req = reqs.shift)
+      handle_request(socket, req)
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  $connection_count -= 1
+  socket&.close
+end
+
+def handle_request(client, parser)
+  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}"
+end
+
+spin do
+  server = TCPServer.open('0.0.0.0', 1234)
+  puts "listening on port 1234"
+
+  Thread.current.agent.accept_loop(server) do |client|
+    spin { handle_client(client) }
+  end
+  # loop do
+  #   client = server.accept
+  #   spin { handle_client(client) }
+  # end
+ensure
+  server&.close
+end
+
+# every(1) {
+#   stats = Thread.current.fiber_scheduling_stats
+#   stats[:connection_count] = $connection_count
+#   puts "#{Time.now} #{stats}"
+# }
+
+puts "pid #{Process.pid}"
+suspend

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

@@ -0,0 +1,27 @@
+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
+    loop do
+      while data = client.readpartial(8192) rescue nil
+        parser << data
+      end
+    end
+    client.close
+  end
+end
+
+server = TCPServer.open(1234)
+puts "Listening on port 1234"
+while socket = server.accept
+  handle_client(socket)
+end

data/examples/performance/thread-vs-fiber/xx-httparty_multi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'httparty'
+
+URL = 'http://worldtimeapi.org/api/timezone/Europe/Paris'
+
+def get_time(results)
+  loop do
+    STDOUT << '!'
+    if (res = HTTParty.get(URL))
+      results << res
+      STDOUT << '.'
+    end
+  rescue StandardError => e
+    p e
+  end
+end
+
+t0 = Time.now
+results = []
+move_on_after(3) do
+  supervise do |s|
+    10.times do
+      s.spin { get_time(results) }
+    end
+  end
+  puts 'done'
+end
+
+puts format(
+  'got %<count>d (%<rate>0.1f reqs/s)',
+  count: results.size,
+  rate:  results.size / (Time.now - t0)
+)

data/examples/performance/thread-vs-fiber/xx-httparty_threaded.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+URL = 'http://worldtimeapi.org/api/timezone/Europe/Paris'
+results = Queue.new
+
+t0 = Time.now
+threads = []
+10.times do
+  threads << Thread.new do
+    loop do
+      STDOUT << '!'
+      if (result = HTTParty.get(URL))
+        results << result
+        STDOUT << '.'
+      end
+    end
+  end
+end
+
+sleep 3
+threads.each(&:kill)
+puts 'done'
+puts format(
+  'got %<count>d (%<rate>0.1f reqs/s)',
+  count: results.size,
+  rate:  results.size / (Time.now - t0)
+)

data/examples/performance/thread_pool_perf.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def lengthy_op
+  data = IO.orig_read(__FILE__)
+  data.clear
+  # Socket.getaddrinfo('debian.org', 80)
+  # Digest::SHA256.digest(IO.read('doc/Promise.html'))
+end
+
+X = 100
+
+def compare_performance
+  t0 = Time.now
+  X.times { lengthy_op }
+  native_perf = X / (Time.now - t0)
+  puts "native performance: #{native_perf}"
+  # puts "*" * 40
+
+  begin
+    1.times do
+      t0 = Time.now
+      X.times do
+        Polyphony::ThreadPool.process { lengthy_op }
+      end
+      async_perf = X / (Time.now - t0)
+      puts format(
+        'seq thread pool performance: %g (X %0.2f)',
+        async_perf,
+        async_perf / native_perf
+      )
+    end
+
+    acc = 0
+    count = 0
+    10.times do |_i|
+      t0 = Time.now
+      supervise do |s|
+        X.times do
+          s.spin { Polyphony::ThreadPool.process { lengthy_op } }
+        end
+      end
+      thread_pool_perf = X / (Time.now - t0)
+      acc += thread_pool_perf
+      count += 1
+    end
+    avg_perf = acc / count
+    puts format(
+      'avg thread pool performance: %g (X %0.2f)',
+      avg_perf,
+      avg_perf / native_perf
+    )
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+  end
+end
+
+spin { compare_performance }
+
+suspend

data/examples/performance/xx-array.rb

@@ -0,0 +1,11 @@
+X = ARGV[0] ? ARGV[0].to_i : 10
+a = (1..X).to_a
+
+Y = 1_000_000
+t0 = Time.now
+Y.times do
+  i = a.shift
+  a.push i
+end
+
+puts "rate: #{Y / (Time.now - t0)}"

data/examples/performance/xx-fiber-switch.rb

@@ -0,0 +1,9 @@
+X = 1_000_000
+f = Fiber.new do
+  loop { Fiber.yield }
+end
+
+t0 = Time.now
+X.times { f.resume }
+dt = Time.now - t0
+puts "#{X / dt.to_f}/s"

data/examples/performance/xx-snooze.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'polyphony'
+
+Y = ARGV[0] ? ARGV[0].to_i : 1
+
+count = 0
+Y.times do
+  spin { loop { count += 1; snooze } }
+end
+
+t0 = Time.now
+sleep 10
+elapsed = Time.now - t0
+rate = count / elapsed
+puts "concurrency: #{Y} rate: #{rate} switchpoints per second"

data/examples/xx-spin.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts "pid: #{Process.pid}"
+GC.disable
+
+def mem_usage
+  # orig_backtick('ps -o rss #{$$}').split.last.to_i
+  `ps -o rss #{$$}`.split.last.to_i
+end
+
+f = File.open('spin.log', 'w+')
+
+m0 = mem_usage
+
+X = ARGV[0] ? ARGV[0].to_i : 10
+STDOUT.orig_write "Starting #{X} fibers...\n"
+t0 = Time.now
+x = nil
+X.times do |i|
+  spin { p i; suspend }
+end
+
+suspend
+f.close
+t1 = Time.now
+m1 = mem_usage
+rate = X / (t1 - t0)
+mem_cost = (m1 - m0) / X.to_f
+STDOUT.orig_write("#{ { time: t1 - t0, spin_rate: rate, fiber_mem_cost: mem_cost }.inspect }\n")