polyphony 0.13 → 0.14

data/examples/core/spawn_cancel.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+spawn do
+  puts "going to sleep..."
+  cancel_after(1) do
+    async {
+      sleep(2)
+    }.await
+  end
+rescue Polyphony::Cancel => e
+  puts "got error: #{e}"
+ensure
+  puts "woke up"
+end
+

data/examples/core/spawn_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+Polyphony.debug = true
+
+def error(t)
+  raise "hello #{t}"
+end
+
+def spawn_with_error
+  spawn { error(2) }
+end
+
+spawn do
+  error(1)
+rescue => e
+  e.cleanup_backtrace
+  puts "error: #{e.inspect}"
+  puts "backtrace:"
+  puts e.backtrace.reverse.join("\n")
+  puts
+end
+
+spawn_with_error
+
+puts "done spawning"

data/examples/core/supervisor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+async def my_sleep(t)
+  puts "#{t} start"
+  sleep(t)
+  puts "#{t} done"
+end
+
+puts "#{Time.now} waiting..."
+supervise do |s|
+  s.spawn my_sleep(1)
+  s.spawn my_sleep(2)
+  s.spawn my_sleep(3)
+  s.spawn {
+    puts "fiber count: #{Polyphony::FiberPool.size}"
+  }
+end
+puts "#{Time.now} done waiting"

data/examples/core/supervisor_with_cancel_scope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+async def my_sleep(t)
+  puts "start: #{t}"
+  r = sleep(t)
+  puts "my_sleep result #{r.inspect}"
+  puts "done: #{t}"
+end
+
+puts "#{Time.now} going to sleep..."
+move_on_after(0.5) do
+  supervise do |s|
+    puts "supervise block"
+    s.spawn my_sleep(1)
+    s.spawn my_sleep(2)
+    s.spawn my_sleep(3)
+  end
+  puts "supervisor done"
+end
+puts "#{Time.now} woke up"

data/examples/core/supervisor_with_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+async def my_sleep(t)
+  sleep(t)
+  raise "blah"
+end
+
+spawn do
+  puts "#{Time.now} going to sleep..."
+  supervise do |s|
+    s.spawn my_sleep(1)
+    s.spawn my_sleep(2)
+    s.spawn my_sleep(3)
+  end
+rescue => e
+  puts "exception from supervisor: #{e}"
+ensure
+  puts "#{Time.now} woke up"
+end

data/examples/core/supervisor_with_manual_move_on.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+async def my_sleep(t)
+  puts "start: #{t}"
+  sleep(t)
+  puts "done: #{t}"
+end
+
+puts "#{Time.now} going to sleep..."
+result = supervise do |s|
+  fiber = Fiber.current
+  spawn do
+    sleep(0.5)
+    puts "stopping supervisor..."
+    s.stop!
+  end
+  s.spawn my_sleep(1)
+  s.spawn my_sleep(2)
+  s.spawn my_sleep(3)
+end
+puts "#{Time.now} woke up with #{result.inspect}"

data/examples/core/thread.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'digest'
+require 'socket'
+
+Polyphony     = import('../../lib/polyphony')
+
+def lengthy_op
+  IO.read('../../docs/reality-ui.bmpr')
+end
+
+X = 100
+
+def blocking
+  t0 = Time.now
+  data = lengthy_op
+  X.times { lengthy_op }
+  puts "read blocking #{data.bytesize} bytes (#{Time.now - t0}s)"
+end
+
+def threaded
+  t0 = Time.now
+  data = Polyphony::Thread.spawn { lengthy_op }.await
+  X.times { Polyphony::Thread.spawn { lengthy_op }.await }
+  puts "read threaded #{data.bytesize} bytes (#{Time.now - t0}s)"
+end
+
+blocking
+threaded

data/examples/core/thread_cancel.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'digest'
+require 'socket'
+
+Polyphony     = import('../../lib/polyphony')
+
+@op_count = 0
+
+def lengthy_op
+  @op_count += 1
+  acc = 0
+  count = 0
+  100.times { acc += IO.read('../../docs/reality-ui.bmpr').bytesize; count += 1; p count }
+  acc / count
+end
+
+spawn do
+  t0 = Time.now
+  cancel_after(0.01) do
+    data = Polyphony::Thread.spawn { lengthy_op }.await
+    puts "read #{data.bytesize} bytes (#{Time.now - t0}s)"
+  end
+rescue Exception => e
+  puts "error: #{e}"
+ensure
+  p @op_count
+end
+

data/examples/core/thread_pool.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'digest'
+require 'socket'
+
+Polyphony = import('../../lib/polyphony')
+
+def lengthy_op
+  data = IO.read('../../docs/reality-ui.bmpr')
+  data.clear
+  # Socket.getaddrinfo('debian.org', 80)
+  #Digest::SHA256.digest(IO.read('doc/Promise.html'))
+end
+
+X = 1000
+
+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 "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.spawn 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 "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
+
+spawn { compare_performance }

data/examples/core/throttle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+spawn {
+  throttled_loop(3) { STDOUT << '.' }
+}
+
+spawn {
+  throttled_loop(rate: 2) { STDOUT << '?' }
+}
+
+spawn {
+  throttled_loop(interval: 1) { STDOUT << '*' }
+}

data/examples/fs/read.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+PATH = File.expand_path('../../../../docs/dev-journal.md', __dir__)
+
+def raw_read_file(x)
+  t0 = Time.now
+  x.times { IO.orig_read(PATH) }
+  puts "raw_read_file: #{Time.now - t0}"
+end
+
+X = 100
+Y = 10
+
+async def async_read_file
+  X.times { IO.read(PATH) }
+end
+
+def do_read(supervisor, x)
+  x.times { nexus << async { read_file } }
+end
+
+raw_read_file(X * Y)
+
+spawn do
+  t0 = Time.now
+  supervise do |s|
+    4.times { s.spawn async_read_file }
+  end
+  puts "thread_pool_read_file: #{Time.now - t0}"
+rescue Exception => e
+  p e
+  puts e.backtrace.join("\n")
+end

data/examples/interfaces/pg_client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+Postgres =  import('../../lib/polyphony/extensions/postgres')
+
+def get_records
+  res = $db.query("select 1 as test")
+  # puts "got #{res.ntuples} records: #{res.to_a}"
+rescue => e
+  puts "got error: #{e.inspect}"
+  puts e.backtrace.join("\n")
+end
+
+time_printer = spawn do
+  last = Time.now
+  throttled_loop(10) do
+    now = Time.now
+    puts now - last
+    last = now
+  end
+end
+
+$db = PG.connect(
+  host:     '/tmp',
+  user:     'reality',
+  password: nil,
+  dbname:   'reality',
+  sslmode:  'require'
+)
+
+X = 10000
+t0 = Time.now
+X.times { get_records }
+puts "query rate: #{X / (Time.now - t0)} reqs/s"
+
+time_printer.stop

data/examples/interfaces/pg_pool.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+Postgres =  import('../../lib/polyphony/extensions/postgres')
+
+PGOPTS = {
+  host:     '/tmp',
+  user:     'reality',
+  password: nil,
+  dbname:   'reality',
+  sslmode:  'require'
+}
+
+DBPOOL = Polyphony::ResourcePool.new(limit: 8) { PG.connect(PGOPTS) }
+
+def get_records(db)
+  res = db.query("select pg_sleep(0.0001) as test")
+  # puts "got #{res.ntuples} records: #{res.to_a}"
+rescue => e
+  puts "got error: #{e.inspect}"
+  puts e.backtrace.join("\n")
+end
+
+CONCURRENCY = ARGV.first ? ARGV.first.to_i : 10
+puts "concurrency: #{CONCURRENCY}"
+
+DBPOOL.preheat!
+t0 = Time.now
+count = 0
+coprocs = CONCURRENCY.times.map {
+  spawn { loop { DBPOOL.acquire { |db| get_records(db); count += 1 } } }
+}
+sleep 3
+puts "count: #{count} query rate: #{count / (Time.now - t0)} queries/s"
+coprocs.each(&:interrupt)

data/examples/interfaces/pg_query.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+Postgres =  import('../../lib/polyphony/extensions/postgres')
+
+DB = PG.connect(
+  host:     '/tmp',
+  user:     'reality',
+  password: nil,
+  dbname:   'reality',
+  sslmode:  'require'
+)
+
+def perform(error)
+  puts "*" * 40
+  DB.transaction do
+    res = DB.query("select 1 as test")
+    puts "result: #{res.to_a}"
+    raise 'hello' if error
+    DB.transaction do
+      res = DB.query("select 2 as test")
+      puts "result: #{res.to_a}"
+    end
+  end
+rescue => e
+  puts "error: #{e.inspect}"
+end
+
+perform(true)
+perform(false)

data/examples/interfaces/redis_channels.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+import('../../lib/polyphony/extensions/redis')
+
+class RedisChannel < Polyphony::Channel
+  def self.publish_connection
+    @publish_connection ||= Redis.new
+  end
+
+  def self.subscribe_connection
+    @subscribe_connection ||= Redis.new
+  end
+
+  CHANNEL_MASTER_TOPIC = 'channel_master'
+
+  def self.start_monitor
+    @channels = {}
+    @monitor = spawn do
+      subscribe_connection.subscribe(CHANNEL_MASTER_TOPIC) do |on|
+        on.message do |topic, message|
+          message = Marshal.load(message)
+          topic == CHANNEL_MASTER_TOPIC ? handle_master_message(message) :
+                                          handle_channel_message(topic, message)
+        end
+      end
+    end
+  end
+
+  def self.stop_monitor
+    @monitor&.interrupt
+  end
+
+  def self.handle_master_message(message)
+    case message[:kind]
+    when :subscribe
+      subscribe_connection.subscribe(message[:topic])
+    when :unsubscribe
+      subscribe_connection.unsubscribe(message[:topic])
+    end
+  end
+
+  def self.handle_channel_message(topic, message)
+    channel = @channels[topic]
+    channel&.did_receive(message)
+  end
+
+  def self.watch(channel)
+    @channels[channel.topic] = channel
+    spawn do
+      publish_connection.publish(CHANNEL_MASTER_TOPIC, Marshal.dump({
+        kind: :subscribe,
+        topic: channel.topic
+      }))
+    end
+  end
+
+  def self.unwatch(channel)
+    @channels.delete(channel.topic)
+    spawn do
+      publish_connection.publish(CHANNEL_MASTER_TOPIC, Marshal.dump({
+        kind: :unsubscribe,
+        topic: channel.topic
+      }))
+    end
+  end
+
+  def self.channel_topic(channel)
+    "channel_#{channel.object_id}"
+  end
+
+  attr_reader :topic
+
+  def initialize(topic)
+    @topic = topic
+    @waiting_queue = []
+    RedisChannel.watch(self)
+  end
+
+  def close
+    super
+    RedisChannel.unwatch(self)
+  end
+
+  def <<(o)
+    RedisChannel.publish_connection.publish(@topic, Marshal.dump(o))
+  end
+
+  def did_receive(o)
+    @waiting_queue.shift&.schedule(o)
+  end
+
+  def receive
+    @waiting_queue << Fiber.current
+    suspend
+  end
+end
+
+RedisChannel.start_monitor
+channel = RedisChannel.new('channel1')
+
+spawn do
+  loop do
+    message = channel.receive
+    puts "got message: #{message}"
+  end
+end
+
+spawn do
+  move_on_after(3) do
+    throttled_loop(1) do
+      channel << Time.now
+    end
+  end
+  channel.close
+  RedisChannel.stop_monitor
+end