polyphony 0.43.8

data/examples/io/xx-happy-eyeballs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'polyphony'
+
+def try_connect(ip_address, port, supervisor)
+  puts "trying #{ip_address}"
+  sleep rand * 0.2
+  socket = TCPSocket.new(ip_address, port)
+  puts "connected to #{ip_address}"
+  supervisor.schedule [ip_address, socket]
+rescue IOError, SystemCallError
+  # ignore error
+end
+
+def happy_eyeballs(hostname, port, max_wait_time: 0.010)
+  targets = Socket.getaddrinfo(hostname, port, :INET, :STREAM)
+  t0 = Time.now
+  fibers = []
+  supervisor = Fiber.current
+  spin do
+    targets.each do |t|
+      spin { try_connect(t[2], t[1], supervisor) }
+      sleep(max_wait_time)
+    end
+    suspend
+  end
+  target, socket = move_on_after(5) { suspend }
+  supervisor.shutdown_all_children
+  if target
+    puts format('success: %s (%.3fs)', target, Time.now - t0)
+  else
+    puts 'timed out'
+  end
+end
+
+happy_eyeballs('debian.org', 'https')

data/examples/io/xx-httparty.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'httparty'
+require 'json'
+
+def get_time(tzone)
+  res = HTTParty.get("http://worldtimeapi.org/api/timezone/#{tzone}")
+  return '- failed -' unless res.ok?
+
+  json = JSON.parse(res.body)
+  Time.parse(json['datetime'])
+end
+
+zones = %w{
+  Europe/London Europe/Paris Europe/Bucharest America/New_York Asia/Bangkok
+}
+# zones.each do |tzone|
+#   spin do
+#     time = get_time(tzone)
+#     puts "Time in #{tzone}: #{time}"
+#   end
+# end
+
+# suspend
+
+def get_times(zones)
+  Polyphony::Supervisor.new do |s|
+    zones.each do |tzone|
+      s.spin { [tzone, get_time(tzone)] }
+    end
+  end
+end
+
+get_times(zones).await.each do |tzone, time|
+  puts "Time in #{tzone}: #{time}"
+end

data/examples/io/xx-irb.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'irb'
+require 'polyphony/adapters/irb'
+
+$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'
+IRB.start

data/examples/io/xx-net-http.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'net/http'
+
+uri = URI('http://realiteq.net/?q=time')
+
+begin
+  puts Net::HTTP.get(uri)
+rescue StandardError => e
+  p e
+  puts '*' * 40
+  puts e.backtrace[0..4].join("\n")
+end

data/examples/io/xx-open.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+stdin = IO.open(STDIN.to_i)
+
+loop do
+  print 'Say something: '
+  cancel_after(3) do
+    line = stdin.gets
+    puts "You said: #{line}"
+  end
+rescue Polyphony::Cancel
+  puts '<got nothing>'
+end

data/examples/io/xx-switch.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+X = 10_000_000
+
+main = Fiber.current
+f = Fiber.new do
+  loop { main.transfer }
+end
+
+t0 = Time.now
+X.times { f.transfer }
+dt = Time.now - t0
+puts "#{X / dt.to_f}/s"

data/examples/io/xx-system.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+timer = spin do
+  throttled_loop(5) { STDOUT << '.' }
+end
+
+puts system('ruby -e "sleep 1; puts :done; STDOUT.close"')
+timer.stop

data/examples/io/xx-tcpserver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+server = TCPServer.new('127.0.0.1', 1234)
+
+puts 'echoing on port 1234'
+while (socket = server.accept)
+  spin do
+    while (data = socket.gets(8192))
+      socket << "you said: #{data}"
+    end
+  end
+end

data/examples/io/xx-tcpsocket.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+socket = TCPSocket.new('google.com', 80)
+
+timer = spin { throttled_loop(20) { STDOUT << '.' } }
+
+5.times do
+  socket.send("GET /?q=time HTTP/1.1\r\nHost: google.com\r\n\r\n", 0)
+  socket.recv(8192)
+  STDOUT << '*'
+end
+
+timer.stop
+socket.close
+puts

data/examples/io/xx-zip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'zlib'
+
+i, o = IO.pipe
+
+w = Zlib::GzipWriter.new(o)
+
+s = (1..1000).map { (65 + rand(26)).chr }.join
+puts "full length: #{s.bytesize}"
+w << s
+w.close
+o.close
+
+
+z = i.read
+puts "zipped length: #{z.bytesize}"

data/examples/performance/fiber_transfer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance 
+
+def run(num_fibers)
+  count = 0
+
+  GC.disable
+
+  first = nil
+  last = nil
+  supervisor = Fiber.current
+  num_fibers.times do
+    fiber = Fiber.new do
+      loop do
+        count += 1
+        if count == 1_000_000
+          supervisor.transfer
+        else
+          Fiber.current.next.transfer
+        end
+      end
+    end
+    first ||= fiber
+    last.next = fiber if last
+    last = fiber
+  end
+
+  last.next = first
+  
+  t0 = Time.now
+  first.transfer
+  elapsed = Time.now - t0
+
+  puts "fibers: #{num_fibers} count: #{count} rate: #{count / elapsed}"
+  GC.start
+end
+
+run(100)
+run(1000)
+run(10000)

data/examples/performance/fs_read.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'polyphony/fs'
+
+def raw_read_file(x)
+  t0 = Time.now
+  x.times { IO.orig_read(__FILE__) }
+  puts "raw_read_file: #{Time.now - t0}"
+end
+
+def threaded_read_file(x, y)
+  t0 = Time.now
+  threads = []
+  y.times do
+    threads << Thread.new { x.times { IO.orig_read(PATH) } }
+  end
+  threads.each(&:join)
+  puts "threaded_read_file: #{Time.now - t0}"
+end
+
+def thread_pool_read_file(x, y)
+  t0 = Time.now
+  supervise do |s|
+    y.times do
+      s.spin { x.times { IO.read(PATH) } }
+    end
+  end
+  puts "thread_pool_read_file: #{Time.now - t0}"
+end
+
+Y = ARGV[0] ? ARGV[0].to_i : 10
+X = ARGV[1] ? ARGV[1].to_i : 100
+
+raw_read_file(X * Y)
+threaded_read_file(X, Y)
+thread_pool_read_file(X, Y)

data/examples/performance/mem-usage.rb

@@ -0,0 +1,56 @@
+require 'fiber'
+
+def mem_usage
+  `ps -o rss #{$$}`.split.last.to_i
+end
+
+def calculate_memory_cost(name, count, &block)
+  GC.enable
+  ObjectSpace.garbage_collect
+  sleep 0.5
+  GC.disable
+  rss0 = mem_usage
+  count0 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  a = []
+  count.times { a << block.call }
+  rss1 = mem_usage
+  count1 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  p [count0, count1]
+  # sleep 0.5
+  cost = (rss1 - rss0).to_f / count
+  count_delta = (count1 - count0) / count
+
+  puts "#{name} rss cost: #{cost}KB     object count: #{count_delta}"
+end
+
+f = Fiber.new { |f| f.transfer }
+f.transfer Fiber.current
+
+calculate_memory_cost('fiber', 10000) do
+  f = Fiber.new { |f| f.transfer :foo }
+  f.transfer Fiber.current
+  f
+end
+
+t = Thread.new { sleep 1}
+t.kill
+t.join
+
+calculate_memory_cost('thread', 500) do
+  t = Thread.new { sleep 1 }
+  sleep 0.001
+  t
+end
+(Thread.list - [Thread.current]).each(&:kill).each(&:join)
+
+require 'bundler/setup'
+require 'polyphony'
+
+f = spin { sleep 0.1 }
+f.await
+
+calculate_memory_cost('polyphony fiber', 10000) do
+  f = spin { :foo }
+  f.await
+  f
+end

data/examples/performance/messaging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+X = 1_000_000
+
+GC.disable
+
+count = 0
+
+pong = spin_loop do
+  msg, ping = receive
+  count += 1
+  ping << 'pong'
+end
+
+ping = spin do
+  X.times do
+    pong << ['ping', Fiber.current]
+    msg = receive
+    count += 1
+  end
+end
+
+t0 = Time.now
+ping.await
+dt = Time.now - t0
+puts format('message rate: %d/s', (X / dt))

data/examples/performance/multi_snooze.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def bm(fibers, iterations)
+  count = 0
+  t_pre = Time.now
+  fibers.times do
+    spin do
+      iterations.times do
+        snooze
+        count += 1
+      end
+    end
+  end
+  t0 = Time.now
+  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
+
+bm(1, 1_000_000)
+bm(10, 100_000)
+bm(100, 10_000)
+bm(1_000, 1_000)
+bm(10_000, 100)
+
+# bm(100_000,    10)
+# bm(1_000_000,   1)

data/examples/performance/snooze.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+X = 1_000_000
+
+GC.disable
+
+STDOUT << 'Fiber.yield:      '
+f = Fiber.new do
+  loop { Fiber.yield }
+end
+t0 = Time.now
+X.times { f.resume }
+dt = Time.now - t0
+puts format('%d/s', (X / dt))
+
+STDOUT << 'Fiber.transfer:   '
+main = Fiber.current
+f = Fiber.new do
+  loop { main.transfer }
+end
+t0 = Time.now
+X.times { f.transfer }
+dt = Time.now - t0
+puts format('%d/s', (X / dt))
+
+STDOUT << 'Kernel#snooze:    '
+t0 = Time.now
+X.times { snooze }
+dt = Time.now - t0
+puts format('%d/s', (X / dt))
+
+# STDOUT << 'Kernel#sleep:     '
+# t0 = Time.now
+# X.times { sleep(0) }
+# dt = Time.now - t0
+# puts "%d/s" % (X / dt)