polyphony 0.43.8

data/examples/core/xx-at_exit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+child_pid = Polyphony.fork do
+  at_exit do
+    puts "at_exit"
+    f = spin { sleep 10 }
+    trap('SIGINT') { f.stop }
+    f.await
+  end
+  
+  f1 = spin { sleep 100 }
+  
+  puts "pid: #{Process.pid}"
+  
+  pid = Process.pid
+  
+  f1.join
+end
+
+sleep 0.1
+Process.kill('INT', child_pid)
+sleep 0.1
+Process.kill('INT', child_pid)
+Process.wait(child_pid)

data/examples/core/xx-caller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+spin {
+  spin {
+    spin {
+      pp Fiber.current.caller
+    }.await
+  }.await
+}.await

data/examples/core/xx-channels.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def echo(cin, cout)
+  puts 'start echoer'
+  while (msg = cin.receive)
+    cout << "you said: #{msg}"
+  end
+ensure
+  puts 'echoer stopped'
+end
+
+chan1, chan2 = 2.times.map { Polyphony::Channel.new }
+
+spin { echo(chan1, chan2) }
+
+spin do
+  puts 'start receiver'
+  while (msg = chan2.receive)
+    puts msg
+    $main.resume if msg =~ /world/
+  end
+ensure
+  puts 'receiver stopped'
+end
+
+$main = spin do
+  puts 'start main'
+  t0 = Time.now
+  puts 'send hello'
+  chan1 << 'hello'
+  puts 'send world'
+  chan1 << 'world'
+
+  suspend
+
+  puts 'closing channels'
+  chan1.close
+  chan2.close
+  puts "done #{Time.now - t0}"
+end
+
+suspend

data/examples/core/xx-daemon.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "pid: #{Process.pid}"
+
+Process.daemon(true, true)
+
+Polyphony::ThreadPool.process do
+  puts "Hello world from pid #{Process.pid}"
+end

data/examples/core/xx-deadlock.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+spin { sleep }
+
+sleep

data/examples/core/xx-deferring-an-operation.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+spin do
+  puts 'two'
+  spin { puts 'four' }
+  puts 'three'
+end
+
+puts 'one'
+
+suspend

data/examples/core/xx-erlang-style-genserver.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+class GenServer
+  def self.start(receiver, *args)
+    fiber = spin do
+      state = receiver.initial_state(*args)
+      loop do
+        msg = receive
+        reply, state = receiver.send(msg[:method], state, *msg[:args])
+        msg[:from] << reply unless reply == :noreply
+      end
+    end
+    build_api(fiber, receiver)
+    snooze
+    fiber
+  end
+
+  def self.build_api(fiber, receiver)
+    receiver.methods(false).each do |m|
+      if m =~ /!$/
+        fiber.define_singleton_method(m) do |*args|
+          GenServer.cast(fiber, m, *args)
+        end
+      else
+        fiber.define_singleton_method(m) do |*args|
+          GenServer.call(fiber, m, *args)
+        end
+      end
+    end
+  end
+
+  def self.cast(process, method, *args)
+    process << {
+      from:   Fiber.current,
+      method: method,
+      args:   args
+    }
+  end
+
+  def self.call(process, method, *args)
+    process << {
+      from:   Fiber.current,
+      method: method,
+      args:   args
+    }
+    receive
+  end
+end
+
+module Map
+  def self.initial_state(hash = {})
+    hash
+  end
+
+  def self.get(state, key)
+    [state[key], state]
+  end
+
+  def self.put!(state, key, value)
+    state[key] = value
+    [:noreply, state]
+  end
+end
+
+map_server = GenServer.start(Map, {foo: :bar})
+
+puts 'getting value from map server'
+v = map_server.get(:foo)
+puts "value: #{v.inspect}"
+
+puts 'putting value in map server'
+map_server.put!(:foo, :baz)
+
+puts 'getting value from map server'
+v = map_server.get(:foo)
+puts "value: #{v.inspect}"
+
+map_server.stop

data/examples/core/xx-exception-backtrace.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+class E < Exception
+  def initialize(msg)
+    super
+    # set_backtrace(caller)
+  end
+
+  alias_method :orig_backtrace, :backtrace
+  def backtrace
+    b = orig_backtrace
+    p [:backtrace, b, caller]
+    b
+  end
+end
+
+def e1
+  e2
+end
+
+def e2
+  E.new('foo')
+end
+
+def e3
+  raise E, 'bar'
+end
+
+e = e1
+p e
+puts e.backtrace&.join("\n")
+
+begin
+  e3
+rescue Exception => e
+  p e
+  puts e.backtrace.join("\n")
+end

data/examples/core/xx-fork-cleanup.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+t = Thread.new do
+  async = Gyro::Async.new
+  spin { async.await }
+  sleep 100
+end
+
+sleep 0.5
+
+Polyphony.fork do
+  puts "forked #{Process.pid}"
+  sleep 1
+  puts "done sleeping"
+end
+
+sleep 50

data/examples/core/xx-fork-spin.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "Parent pid: #{Process.pid}"
+
+i, o = IO.pipe
+
+pid = Polyphony.fork do
+  puts "Child pid: #{Process.pid}"
+  i.close
+  spin do
+    spin do
+      p :sleep
+      sleep 1
+    rescue ::Interrupt => e
+      p 1
+      # the signal should be raised only in the main fiber
+      o.puts "1-interrupt"
+    end.await
+  rescue Polyphony::Terminate
+    puts "terminate!"
+  end.await
+rescue ::Interrupt => e
+  p 2
+  o.puts "3-interrupt"
+ensure
+  p 3
+  o.close
+end
+sleep 0.2
+o.close
+watcher = Gyro::Child.new(pid)
+Process.kill('INT', pid)
+watcher.await
+buffer = i.read
+
+puts '*' * 40
+p buffer

data/examples/core/xx-fork-terminate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+pid = Polyphony.fork do
+  f = spin do
+    p 1
+    sleep 1
+    p 2
+  ensure
+    p 2.5
+  end
+  p 3
+  snooze
+  p 4
+  # f.stop
+  # f.join
+  # Fiber.current.terminate_all_children
+  # Fiber.current.await_all_children
+  p 5
+end
+
+puts "Child pid: #{pid}"
+Process.wait(pid)

data/examples/core/xx-forking.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts "parent pid: #{Process.pid}"
+
+pid = Polyphony.fork do
+  puts "child pid: #{Process.pid}"
+
+  spin do
+    puts 'child going to sleep 1...'
+    sleep 1
+    puts 'child woke up 1'
+  end
+
+  suspend
+end
+
+puts "got child pid #{pid}"
+
+puts 'parent waiting for child'
+Gyro::Child.new(pid).await
+puts 'parent done waiting'

data/examples/core/xx-move_on.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+Exception.__disable_sanitized_backtrace__ = true
+
+puts 'going to sleep...'
+move_on_after(1) do
+  sleep 60
+  puts 'woke up'
+end
+
+puts 'going to sleep...'
+move_on_after(0.5) do
+  t0 = Time.now
+  sleep(60)
+ensure
+  puts 'woke up'
+end
+
+puts 'going to sleep...'
+value = move_on_after(1, with_value: :bar) { sleep 60 }
+puts "got value #{value.inspect}"

data/examples/core/xx-pingpong.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+pong = spin_loop do
+  msg, ping = receive
+  puts msg
+  ping << 'pong'
+end
+
+ping = spin_loop do
+  pong << ['ping', Fiber.current]
+  msg = receive
+  puts msg
+end
+
+suspend

data/examples/core/xx-queue-async.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Thread.event_selector = ->(thread) { Gyro::Selector.new(thread) }
+
+def bm(sym, x)
+  t0 = Time.now
+  send(sym, x)
+  elapsed = Time.now - t0
+  STDOUT.orig_puts "#{sym} #{x / elapsed}"
+end
+
+def test_queue(x)
+  queue = Queue.new
+  async = Gyro::Async.new
+  t1 = Thread.new do
+    Thread.current.setup_fiber_scheduling
+    counter = 0
+    loop {
+      async.await if queue.empty?
+      v = queue.pop
+      counter += 1
+      break if counter == x
+    }
+  ensure
+    Thread.current.stop_event_selector
+  end
+  t2 = Thread.new do
+    Thread.current.setup_fiber_scheduling
+    x.times { |i|
+      queue.push i
+      async.signal!
+    }
+  ensure
+    Thread.current.stop_event_selector
+  end
+  t1.join
+  t2.join
+end
+
+def test_array_mutex(x)
+  queue = []
+  mutex = Mutex.new
+  async = Gyro::Async.new
+  t1 = Thread.new {
+    Thread.current.setup_fiber_scheduling
+    counter = 0
+    loop {
+      async.await if mutex.synchronize { queue.empty? }
+      v = mutex.synchronize { queue.shift }
+      counter += 1
+      break if counter == x
+    }
+  }
+  t2 = Thread.new {
+    Thread.current.setup_fiber_scheduling
+    x.times { |i|
+      mutex.synchronize { queue.push i }
+      async.signal!
+    }
+  }
+  t1.join
+  t2.join
+end
+
+# class Gyro::Queue
+#   def initialize
+#     @wait_queue = []
+#     @queue = []
+#   end
+
+#   def <<(value)
+#     async = @wait_queue.pop
+#     if async
+#       async.signal! value
+#     else
+#       @queue.push value
+#     end
+#   end
+
+#   def shift
+#     if @queue.empty?
+#       async = Gyro::Async.new
+#       @wait_queue << async
+#       async.await
+#     else
+#       @queue.shift
+#     end
+#   end
+# end
+
+def test_gyro_queue(x)
+  queue = Gyro::Queue.new
+  x.times { |i| queue << i }
+  t1 = Thread.new do
+    Thread.current.setup_fiber_scheduling
+    x.times { queue.shift }
+  ensure
+    Thread.current.stop_event_selector
+  end
+  t2 = Thread.new do
+    Thread.current.setup_fiber_scheduling
+    x.times { |i| queue << i }
+  ensure
+    Thread.current.stop_event_selector
+  end
+  t1.join
+  t2.join
+end
+
+Thread.current.setup_fiber_scheduling
+# bm(:test_array_mutex,     1000000)
+loop {
+  STDOUT.orig_puts "*" * 40
+  bm(:test_queue,           1000000)
+  bm(:test_gyro_queue,      1000000)
+}
+