polyphony 0.26 → 0.27

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)
+}
+

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-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)
+}

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+t = Thread.new {
+  t0 = Time.now
+  puts "sleep"
+  sleep 0.01
+  puts "wake up #{Time.now - t0}"
+}
+
+t0 = Time.now
+t.join
+puts "elapsed: #{Time.now - t0}"

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+def work
+  puts "creating fibers..."
+  100000.times {
+    spin {
+      loop { snooze }
+    }
+  }
+
+  puts "done"
+  suspend
+end
+
+def work_thread
+  t = Thread.new { work }
+  t.join
+end
+
+main = Fiber.current
+p [:main, main]
+
+# trap('SIGINT') do
+#   p [:SIGINT, Fiber.current]
+#   p caller
+#   exit!
+# end
+
+work

data/examples/performance/snooze.rb

@@ -32,8 +32,8 @@ 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)
+# STDOUT << 'Kernel#sleep:     '
+# t0 = Time.now
+# X.times { sleep(0) }
+# dt = Time.now - t0
+# puts "%d/s" % (X / dt)

data/examples/performance/thread-vs-fiber/polyphony_mt_server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+
+class Http::Parser
+  def setup_async
+    self.on_message_complete = proc { @request_complete = true }
+  end
+
+  def parse(data)
+    self << data
+    return nil unless @request_complete
+
+    @request_complete = nil
+    self
+  end
+end
+
+def handle_client(socket)
+  parser = Http::Parser.new
+  req = nil
+  parser.on_message_complete = proc do |env|
+    req = parser
+  end
+  while (data = socket.readpartial(8192)) do
+    parser << data
+    if req
+      handle_request(socket, req)
+      req = nil
+      snooze
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  socket.close rescue nil
+  parser.reset!
+end
+
+def handle_request(client, parser)
+  status_code = 200
+  data = "Hello world!\n"
+  headers = "Content-Length: #{data.bytesize}\r\n"
+  client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
+end
+
+$incoming = Gyro::Queue.new
+
+$threads = (1..4).map {
+  Thread.new {
+    Thread.current.setup_fiber_scheduling
+    loop {
+      conn = $incoming.pop
+      spin { handle_client(conn) }
+    }
+  }
+}
+
+spin do
+  server = TCPServer.open('0.0.0.0', 1234)
+  puts "listening on port 1234"
+
+  loop do
+    client = server.accept
+    $incoming << client
+    # spin { handle_client(client) }
+  end
+end
+
+puts "pid #{Process.pid}"
+suspend

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -20,16 +20,16 @@ end
 
 def handle_client(socket)
   parser = Http::Parser.new
-  req = nil
+  reqs = []
   parser.on_message_complete = proc do |env|
-    req = parser
+    reqs << Object.new # parser
   end
   while (data = socket.readpartial(8192)) do
     parser << data
-    if req
+    while (req = reqs.shift)
       handle_request(socket, req)
       req = nil
-      snooze
+      # snooze
     end
   end
 rescue IOError, SystemCallError => e
@@ -53,6 +53,14 @@ spin do
   loop do
     client = server.accept
     spin { handle_client(client) }
+    # snooze
+  end
+end
+
+spin do
+  loop do
+    sleep 1
+    puts "#{Time.now} #{Thread.current.fiber_scheduling_stats}"
   end
 end
 

data/ext/gyro/async.c

@@ -2,35 +2,34 @@
 
 struct Gyro_Async {
   struct  ev_async ev_async;
+  struct  ev_loop *ev_loop;
   int     active;
   VALUE   fiber;
   VALUE   value;
 };
 
-static VALUE cGyro_Async = Qnil;
+VALUE cGyro_Async = Qnil;
 
-/* Allocator/deallocator */
-static VALUE Gyro_Async_allocate(VALUE klass);
-static void Gyro_Async_mark(void *ptr);
-static void Gyro_Async_free(void *ptr);
-static size_t Gyro_Async_size(const void *ptr);
-
-/* Methods */
-static VALUE Gyro_Async_initialize(VALUE self);
-
-static VALUE Gyro_Async_signal(int argc, VALUE *argv, VALUE self);
-static VALUE Gyro_Async_await(VALUE self);
-
-void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents);
+static void Gyro_Async_mark(void *ptr) {
+  struct Gyro_Async *async = ptr;
+  if (async->fiber != Qnil) {
+    rb_gc_mark(async->fiber);
+  }
+  if (async->value != Qnil) {
+    rb_gc_mark(async->value);
+  }
+}
 
-/* async encapsulates an async watcher */
-void Init_Gyro_Async() {
-  cGyro_Async = rb_define_class_under(mGyro, "Async", rb_cData);
-  rb_define_alloc_func(cGyro_Async, Gyro_Async_allocate);
+static void Gyro_Async_free(void *ptr) {
+  struct Gyro_Async *async = ptr;
+  if (async->active) {
+    printf("Async watcher garbage collected while still active!\n");
+  }
+  xfree(async);
+}
 
-  rb_define_method(cGyro_Async, "initialize", Gyro_Async_initialize, 0);
-  rb_define_method(cGyro_Async, "signal!", Gyro_Async_signal, -1);
-  rb_define_method(cGyro_Async, "await", Gyro_Async_await, 0);
+static size_t Gyro_Async_size(const void *ptr) {
+  return sizeof(struct Gyro_Async);
 }
 
 static const rb_data_type_t Gyro_Async_type = {
@@ -45,24 +44,17 @@ static VALUE Gyro_Async_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Async_type, async);
 }
 
-static void Gyro_Async_mark(void *ptr) {
-  struct Gyro_Async *async = ptr;
-  if (async->fiber != Qnil) {
-    rb_gc_mark(async->fiber);
-  }
-  if (async->value != Qnil) {
-    rb_gc_mark(async->value);
-  }
-}
+void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
 
-static void Gyro_Async_free(void *ptr) {
-  struct Gyro_Async *async = ptr;
-  ev_async_stop(EV_DEFAULT, &async->ev_async);
-  xfree(async);
-}
+  ev_async_stop(async->ev_loop, ev_async);
+  async->active = 0;
 
-static size_t Gyro_Async_size(const void *ptr) {
-  return sizeof(struct Gyro_Async);
+  if (async->fiber != Qnil) {
+    Gyro_schedule_fiber(async->fiber, async->value);
+    async->fiber = Qnil;
+    async->value = Qnil;
+  }
 }
 
 #define GetGyro_Async(obj, async) \
@@ -77,34 +69,27 @@ static VALUE Gyro_Async_initialize(VALUE self) {
   async->active = 0;
 
   ev_async_init(&async->ev_async, Gyro_Async_callback);
+  async->ev_loop = 0;
 
   return Qnil;
 }
 
-void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
-  struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
-
-  ev_async_stop(EV_DEFAULT, ev_async);
-  async->active = 0;
-
-  if (async->fiber != Qnil) {
-    Gyro_schedule_fiber(async->fiber, async->value);
-    async->fiber = Qnil;
-    async->value = Qnil;
-  }
-}
-
 static VALUE Gyro_Async_signal(int argc, VALUE *argv, VALUE self) {
   struct Gyro_Async *async;
   GetGyro_Async(self, async);
 
+  if (!async->ev_loop) {
+    // printf("signal! called before await\n");
+    return Qnil;
+  }
+
   async->value = (argc == 1) ? argv[0] : Qnil;
-  ev_async_send(EV_DEFAULT, &async->ev_async);
+  ev_async_send(async->ev_loop, &async->ev_async);
 
   return Qnil;
 }
 
-static VALUE Gyro_Async_await(VALUE self) {
+VALUE Gyro_Async_await(VALUE self) {
   struct Gyro_Async *async;
   VALUE ret;
   
@@ -113,22 +98,34 @@ static VALUE Gyro_Async_await(VALUE self) {
   async->fiber = rb_fiber_current();
   if (!async->active) {
     async->active = 1;
-    ev_async_start(EV_DEFAULT, &async->ev_async);
+    async->ev_loop = Gyro_Selector_current_thread_ev_loop();
+    ev_async_start(async->ev_loop, &async->ev_async);
   }
 
-  ret = Gyro_await();
+  ret = Fiber_await();
+  RB_GC_GUARD(ret);
+
+  if (async->active) {
+    async->active = 0;
+    async->fiber = Qnil;
+    ev_async_stop(async->ev_loop, &async->ev_async);
+    async->value = Qnil;
+  }
 
   // fiber is resumed
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    if (async->active) {
-      async->active = 0;
-      ev_async_stop(EV_DEFAULT, &async->ev_async);
-      async->fiber = Qnil;
-      async->value = Qnil;
-    }
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
   else {
     return ret;
   }
-}
+}
+
+void Init_Gyro_Async() {
+  cGyro_Async = rb_define_class_under(mGyro, "Async", rb_cData);
+  rb_define_alloc_func(cGyro_Async, Gyro_Async_allocate);
+
+  rb_define_method(cGyro_Async, "initialize", Gyro_Async_initialize, 0);
+  rb_define_method(cGyro_Async, "signal!", Gyro_Async_signal, -1);
+  rb_define_method(cGyro_Async, "await", Gyro_Async_await, 0);
+}