polyphony 0.43.8

data/examples/core/xx-readpartial.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+buffer = +''
+socket = TCPSocket.new('google.com', 80)
+socket.send("GET /?q=time HTTP/1.1\r\nHost: google.com\r\n\r\n", 0)
+move_on_after(5) {
+  while (data = socket.readpartial(8192))
+    buffer << data
+  end
+}
+
+puts "*" * 40
+p buffer

data/examples/core/xx-recurrent-timer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+move_on_after(3) do
+  puts 'Start...'
+  every(1) do
+    puts Time.now
+  end
+end
+puts 'done!'

data/examples/core/xx-resource_delegate.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+class Number
+  def initialize(id)
+    @id = id
+  end
+
+  def greet(other)
+    puts "You are number #{other}, I am number #{@id}"
+    sleep(0.05 + rand * 0.2)
+  end
+end
+
+resource_count = 0
+Pool = Polyphony::ResourcePool.new(limit: 3) do
+  Number.new(resource_count += 1)
+end
+
+def meet(number)
+  loop do
+    Pool.greet(number)
+  end
+end
+
+3.times { |x| spin { meet(x) } }
+
+t0 = Time.now
+every(10) { puts "uptime: #{Time.now - t0}" }

data/examples/core/xx-signals.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+waiter = spin do
+  puts 'Waiting for HUP'
+  Polyphony.wait_for_signal('SIGHUP')
+  puts 'Got HUP'
+end
+
+sleep 1
+puts 'Sending HUP'
+Process.kill('SIGHUP', Process.pid)
+
+suspend

data/examples/core/xx-sleep-forever.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "press Ctrl-C!"
+sleep

data/examples/core/xx-sleeping.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+# spin {
+#   10.times {
+#     STDOUT << '.'
+#     sleep 0.1
+#   }
+# }
+
+puts 'going to sleep...'
+sleep 1
+puts 'woke up'
+
+counter = 0
+t = Polyphony::Throttler.new(5)
+t.process do
+  p counter
+  counter += 1
+  t.stop if counter > 5
+end

data/examples/core/xx-snooze-starve.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+f = spin_loop {
+  snooze
+}
+
+puts 'going to sleep...'
+sleep 1
+puts 'woke up'
+f.stop
+

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "Parent pid: #{Process.pid}"
+
+def start_worker
+  Polyphony.fork do
+    p :sleep
+    sleep 5
+    p :done_sleeping
+  ensure
+    p :start_worker_fork_ensure
+  end
+end
+
+f = spin do
+  Polyphony::ProcessSupervisor.supervise do
+    spin do
+      spin do
+        p :sleep
+        sleep 5
+        p :done_sleeping
+      end.await
+    end.await
+  ensure
+    p :start_worker_fork_ensure
+  end
+  # spin do
+  #   pid = start_worker
+  #   p [:before_child_await, pid]
+  #   Gyro::Child.new(pid).await
+  #   p :after_child_await
+  # ensure
+  #   puts "child done"
+  # end
+  # supervise
+# ensure
+#   puts "kill child"
+#   Process.kill('TERM', pid) rescue nil
+end
+
+sleep 1
+puts "terminate worker"
+f.terminate
+f.await

data/examples/core/xx-spin_error_backtrace.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def error(t)
+  raise "hello #{t}"
+end
+
+def deferred_error(t)
+  puts "deferred_error"
+  spin { de2(t) }
+end
+
+def de2(t)
+  snooze
+  error(t)
+end
+
+def spin_with_error
+  spin { error(4) }
+end
+
+spin do
+  spin do
+    spin do
+      deferred_error(3)
+    end.await
+  end.await
+end.await
+
+suspend
+suspend

data/examples/core/xx-state-machine.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# require 'bundler/setup'
+# require 'polyphony'
+
+require 'fiber'
+
+class StateMachine < ::Fiber
+  def initialize(state, rules)
+    @state = state
+    @rules = rules
+    super() { |input| state_loop(input) }
+  end
+
+  attr_reader :state
+  def state_loop(input)
+    loop do
+      @state = apply(input)
+      input = Fiber.yield(@state)
+    end
+  end
+
+  def apply(input)
+    f = @rules[@state][input]
+    return f.(@state) if f.is_a?(Proc)
+
+    raise 'Invalid input'
+  rescue => e
+    @state
+  end
+
+  def transition(input)
+    state = self.resume(input)
+    # state.is_a?(Exception) ? (raise state) : state
+  end
+end
+
+o = StateMachine.new(
+  :off,
+  {
+    off: { turnon: ->(s) { :on } },
+    on: { turnoff: ->(s) { :off } }
+  }
+)
+
+loop do
+  STDOUT << "#{o.state}: "
+  input = gets.strip.to_sym
+  # puts "  command: #{input.inspect}"
+  o.transition(input)
+end

data/examples/core/xx-stop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+f1 = spin do
+  f2 = spin { sleep 60 }
+  f3 = spin { sleep 60 }
+  sleep 60
+ensure
+  p 1
+  f2.stop
+  p 2
+  f3.stop
+  p "should reach here!"
+end
+
+sleep 0.1
+f1.stop
+snooze

data/examples/core/xx-supervise-process.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+supervisor = spin do
+  puts "parent pid #{Process.pid}"
+
+  Polyphony::ProcessSupervisor.supervise do
+    puts "child pid #{Process.pid}"
+    puts "go to sleep"
+    sleep 5
+  rescue Interrupt
+    puts "child got INT"
+  rescue SystemExit
+    puts "child got TERM"
+  ensure
+    puts "done sleeping"
+  end
+end
+
+begin
+  supervisor.await
+rescue Interrupt
+  exit!
+  # supervisor.terminate
+  # supervisor.await
+end

data/examples/core/xx-supervisors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def my_sleep(t)
+  puts "#{t} start"
+  sleep(t)
+  puts "#{t} done"
+end
+
+puts "#{Time.now} waiting..."
+supervise do |s|
+  s.spin { my_sleep(1) }
+  s.spin { my_sleep(2) }
+  s.spin { my_sleep(3) }
+  s.spin do
+    puts "fiber count: #{Fiber.count}"
+  end
+end
+puts "#{Time.now} done waiting"

data/examples/core/xx-thread-selector-sleep.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+# Thread.event_selector = Gyro::Selector
+# Thread.current.setup_fiber_scheduling
+
+t = Gyro::Timer.new(1, 1)
+s = spin {
+  last = Time.now
+  loop do
+    t.await
+    now = Time.now
+    puts "elapsed: #{now - last}"
+    last = now
+  end
+}
+s.await
+exit!
+
+p :go_to_sleep
+sleep 1
+p :wake_up
+
+puts "*" * 60
+
+t = Thread.new {
+  Thread.current.setup_fiber_scheduling
+
+  spin {
+    p :go_to_sleep1
+    sleep 1
+    p :wake_up1
+  }
+
+  spin {
+    p :go_to_sleep2
+    sleep 2
+    p :wake_up2
+  }
+
+  p :waiting
+  suspend
+}
+
+t.join
+
+at_exit {
+  p :at_exit
+}

data/examples/core/xx-thread-selector-snooze.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+Thread.event_selector = Gyro::Selector
+Thread.current.setup_fiber_scheduling
+
+def bm(fibers, iterations)
+  count = {}
+
+  t0 = Time.now
+  threads = (1..1).map do |i|
+    Thread.new do
+      count[i] = 0
+      supervise do |s|
+        fibers.times do
+          s.spin do
+            iterations.times do
+              snooze
+              count[i] += 1
+            end
+          end
+        end
+      end
+    end
+  end
+  threads.each(&:join)
+  dt = Time.now - t0
+  count = count.values.inject(0, &:+)
+  puts "#{[fibers, iterations].inspect} count: #{count} #{count / dt.to_f}/s"
+end
+
+# GC.disable
+
+loop {
+  puts "*" * 60
+  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)
+}