polyphony 0.43.3 → 0.43.9

data/examples/core/xx-channels.rb

@@ -2,10 +2,12 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/core/channel'
 
 def echo(cin, cout)
   puts 'start echoer'
   while (msg = cin.receive)
+    puts "echoer received #{msg}"
     cout << "you said: #{msg}"
   end
 ensure
@@ -20,7 +22,7 @@ spin do
   puts 'start receiver'
   while (msg = chan2.receive)
     puts msg
-    $main.resume if msg =~ /world/
+    $main.schedule if msg =~ /world/
   end
 ensure
   puts 'receiver stopped'
@@ -42,4 +44,4 @@ $main = spin do
   puts "done #{Time.now - t0}"
 end
 
-suspend
+$main.await

data/examples/core/xx-using-a-mutex.rb

@@ -2,6 +2,7 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/core/sync'
 
 def loop_it(number, lock)
   loop do
@@ -13,7 +14,7 @@ def loop_it(number, lock)
   end
 end
 
-lock = Polyphony::Sync::Mutex.new
+lock = Polyphony::Mutex.new
 spin { loop_it(1, lock) }
 spin { loop_it(2, lock) }
 spin { loop_it(3, lock) }

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

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
-# idea taken from the example given in trio:
-# https://www.youtube.com/watch?v=oLkfnc_UMcE
-
-require 'bundler/setup'
 require 'polyphony'
 
-def try_connect(target, supervisor)
-  puts "trying #{target[2]}"
-  socket = Polyphony::Net.tcp_connect(target[2], 80)
-  # connection successful
-  supervisor.stop([target[2], socket])
+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.025)
+def happy_eyeballs(hostname, port, max_wait_time: 0.010)
   targets = Socket.getaddrinfo(hostname, port, :INET, :STREAM)
   t0 = Time.now
-  cancel_after(5) do
-    success = supervise do |supervisor|
-      targets.each_with_index do |t, idx|
-        sleep(max_wait_time) if idx > 0
-        supervisor.spin { try_connect(t, supervisor) }
-      end
-    end
-    if success
-      puts format('success: %s (%.3fs)', success[0], Time.now - t0)
-    else
-      puts "timed out (#{Time.now - t0}s)"
+  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
 
-# Let's try it out:
 happy_eyeballs('debian.org', 'https')

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/mem-usage.rb

@@ -4,47 +4,53 @@ def mem_usage
   `ps -o rss #{$$}`.split.last.to_i
 end
 
-def calculate_fiber_memory_cost(count)
+def calculate_memory_cost(name, count, &block)
+  GC.enable
+  ObjectSpace.garbage_collect
+  sleep 0.5
   GC.disable
   rss0 = mem_usage
-  count.times { Fiber.new { sleep 1 } }
+  count0 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  a = []
+  count.times { a << block.call }
   rss1 = mem_usage
-  GC.start
+  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 "fiber memory cost: #{cost}KB"
+  puts "#{name} rss cost: #{cost}KB     object count: #{count_delta}"
 end
 
-calculate_fiber_memory_cost(10000)
-
-def calculate_thread_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { Thread.new { sleep 1 } }
-  sleep 0.5
-  rss1 = mem_usage
-  sleep 0.5
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = Fiber.new { |f| f.transfer }
+f.transfer Fiber.current
 
-  puts "thread memory cost: #{cost}KB"
+calculate_memory_cost('fiber', 10000) do
+  f = Fiber.new { |f| f.transfer :foo }
+  f.transfer Fiber.current
+  f
 end
 
-calculate_thread_memory_cost(500)
+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'
 
-def calculate_extended_fiber_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { spin { :foo } }
-  snooze
-  rss1 = mem_usage
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = spin { sleep 0.1 }
+f.await
 
-  puts "extended fiber memory cost: #{cost}KB"
+calculate_memory_cost('polyphony fiber', 10000) do
+  f = spin { :foo }
+  f.await
+  f
 end
-
-calculate_extended_fiber_memory_cost(10000)

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

@@ -5,19 +5,20 @@ require 'polyphony'
 
 def bm(fibers, iterations)
   count = 0
-  t0 = Time.now
-  supervise do |s|
-    fibers.times do
-      s.spin do
-        iterations.times do
-          snooze
-          count += 1
-        end
+  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} count: #{count} #{count / dt.to_f}/s"
+  puts "#{[fibers, iterations].inspect} setup: #{t0 - t_pre}s count: #{count} #{count / dt.to_f}/s"
+  Thread.current.run_queue_trace
 end
 
 GC.disable
@@ -27,5 +28,6 @@ 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/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")

data/ext/polyphony/event.c

@@ -0,0 +1,86 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+typedef struct event {
+  VALUE waiting_fiber;
+} Event_t;
+
+VALUE cEvent = Qnil;
+
+static void Event_mark(void *ptr) {
+  Event_t *event = ptr;
+  rb_gc_mark(event->waiting_fiber);
+}
+
+static void Event_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t Event_size(const void *ptr) {
+  return sizeof(Event_t);
+}
+
+static const rb_data_type_t Event_type = {
+  "Event",
+  {Event_mark, Event_free, Event_size,},
+  0, 0, 0
+};
+
+static VALUE Event_allocate(VALUE klass) {
+  Event_t *event;
+
+  event = ALLOC(Event_t);
+  return TypedData_Wrap_Struct(klass, &Event_type, event);
+}
+
+#define GetEvent(obj, event) \
+  TypedData_Get_Struct((obj), Event_t, &Event_type, (event))
+
+static VALUE Event_initialize(VALUE self) {
+  Event_t *event;
+  GetEvent(self, event);
+
+  event->waiting_fiber = Qnil;
+
+  return self;
+}
+
+VALUE Event_signal(int argc, VALUE *argv, VALUE self) {
+  VALUE value = argc > 0 ? argv[0] : Qnil;
+  Event_t *event;
+  GetEvent(self, event);
+
+  if (event->waiting_fiber != Qnil) {
+    Fiber_make_runnable(event->waiting_fiber, value);
+    event->waiting_fiber = Qnil;
+  }
+  return self;
+}
+
+VALUE Event_await(VALUE self) {
+  Event_t *event;
+  GetEvent(self, event);
+
+  if (event->waiting_fiber != Qnil)
+    rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
+
+  VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+  event->waiting_fiber = rb_fiber_current();
+  VALUE switchpoint_result = LibevAgent_wait_event(agent, Qnil);
+  event->waiting_fiber = Qnil;
+
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(agent);
+  RB_GC_GUARD(switchpoint_result);
+
+  return switchpoint_result;
+}
+
+void Init_Event() {
+  cEvent = rb_define_class_under(mPolyphony, "Event", rb_cData);
+  rb_define_alloc_func(cEvent, Event_allocate);
+
+  rb_define_method(cEvent, "initialize", Event_initialize, 0);
+  rb_define_method(cEvent, "await", Event_await, 0);
+  rb_define_method(cEvent, "signal", Event_signal, -1);
+}

data/ext/polyphony/fiber.c

@@ -9,8 +9,6 @@ ID ID_trace_runnable;
 ID ID_trace_terminate;
 ID ID_trace_wait;
 
-VALUE cEvent = Qnil;
-
 VALUE SYM_dead;
 VALUE SYM_running;
 VALUE SYM_runnable;
@@ -35,9 +33,6 @@ static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
 
 inline VALUE Fiber_auto_watcher(VALUE self) {
   VALUE watcher;
-  if (cEvent == Qnil) {
-    cEvent = rb_const_get(mPolyphony, rb_intern("Event"));
-  }
 
   watcher = rb_ivar_get(self, ID_ivar_auto_watcher);
   if (watcher == Qnil) {