polyphony 0.19 → 0.20

data/examples/io/echo_server.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
-server = TCPServer.open(1234)
-puts "Echoing on port 1234..."
-while client = server.accept
+server = TCPServer.open('127.0.0.1', 1234)
+puts 'Echoing on port 1234...'
+while (client = server.accept)
   spin do
-    while data = client.readpartial(8192) rescue nil
-      client.write("you said: ", data.chomp, "!\n")
+    while (data = client.gets)
+      client.write('you said: ', data.chomp, "!\n")
     end
+  rescue Errno::ECONNRESET
+    'Connection reset...'
   end
 end

data/examples/io/echo_server_with_timeout.rb

@@ -1,25 +1,28 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
 begin
-  server = Polyphony::Net.tcp_listen(nil, 1234, reuse_addr: true, dont_linger: true)
-  puts "listening on port 1234..."
+  server = Polyphony::Net.tcp_listen(
+    nil, 1234, reuse_addr: true, dont_linger: true
+  )
+  puts 'listening on port 1234...'
 
   loop do
     client = server.accept
+    client.write "Hi there\n"
     spin do
-      cancel_scope = nil
-      move_on_after(5) do |s|
-        cancel_scope = s
+      move_on_after(5) do |scope|
+        scope.when_cancelled do
+          client.write "Disconnecting due to inactivity\n"
+        end
         while (data = client.readpartial(8192))
-          s.reset_timeout
-          client.write(data)
+          scope.reset_timeout
+          client.write "You said: #{data}"
         end
       end
-      client.write "Disconnecting due to inactivity\n" if cancel_scope.cancelled?
-    rescue => e
+    rescue StandardError => e
       puts "client error: #{e.inspect}"
     ensure
       client.close

data/examples/io/echo_stdin.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
-puts "Write something..."
+puts 'Write something...'
 move_on_after(5) do |scope|
   loop do
     data = STDIN.gets
@@ -11,4 +11,4 @@ move_on_after(5) do |scope|
     puts "you wrote: #{data}"
   end
 end
-puts "quitting due to inactivity"
+puts 'quitting due to inactivity'

data/examples/io/httparty.rb

@@ -6,5 +6,5 @@ require 'httparty'
 
 timer = spin { throttled_loop(10) { STDOUT << '.' } }
 
-puts HTTParty.get('http://realiteq.net/?q=time')
-timer.stop
+puts HTTParty.get('http://google.com/')
+timer.stop

data/examples/io/httparty_multi.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 require 'httparty'
 
 url = 'http://127.0.0.1:4411/?q=time'
@@ -18,12 +18,16 @@ move_on_after(3) do
             results << result
             STDOUT << '.'
           end
-        rescue => e
+        rescue StandardError => e
           p e
         end
       end
     end
   end
-  puts "done"
+  puts 'done'
 end
-puts "got #{results.size} (#{results.size / (Time.now - t0)}/s)"
+puts format(
+  'got %<count>d (%<rate>0.1f reqs/s)',
+  count: results.size,
+  rate:  results.size / (Time.now - t0)
+)

data/examples/io/httparty_threaded.rb

@@ -21,5 +21,9 @@ end
 
 sleep 3
 threads.each(&:kill)
-puts "done"
-puts "got #{results.size} (#{results.size / (Time.now - t0)}/s)"
+puts 'done'
+puts format(
+  'got %<count>d (%<rate>0.1f reqs/s)',
+  count: results.size,
+  rate:  results.size / (Time.now - t0)
+)

data/examples/io/io_read.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
 s = IO.read(__FILE__)
 puts "encoding: #{s.encoding.inspect}"
 puts s
-puts
+puts

data/examples/io/irb.rb

@@ -1,15 +1,27 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 require 'irb'
 
 $counter = 0
-
 timer = spin do
-  throttled_loop(10) { $counter += 1 }
+  throttled_loop(5) do
+    $counter += 1
+  end
+end
+
+# readline blocks the current thread, so we offload it to the blocking-ops
+# thread pool. That way, the reactor loop can keep running while waiting for
+# readline to return
+module ::Readline
+  alias_method :orig_readline, :readline
+  def readline(*args)
+    Polyphony::ThreadPool.process { orig_readline(*args) }
+  end
 end
 
 at_exit { timer.stop }
 
-IRB.start
+puts 'try typing $counter to see the counter incremented in the background'
+IRB.start

data/examples/io/net-http.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 require 'net/http'
 
 uri = URI('http://realiteq.net/?q=time')
 
 begin
   puts Net::HTTP.get(uri)
-rescue => e
+rescue StandardError => e
   p e
-  puts "*" * 40
+  puts '*' * 40
   puts e.backtrace[0..4].join("\n")
 end

data/examples/io/open.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/auto_run'
+require 'irb'
+
+stdin = IO.open(STDIN.to_i)
+
+loop do
+  print 'Say something: '
+  cancel_after(3) do
+    line = stdin.gets
+    puts "You said: #{line}"
+  end
+rescue Polyphony::Cancel
+  puts '<got nothing>'
+end

data/examples/io/system.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
-timer = spin {
+timer = spin do
   throttled_loop(5) { STDOUT << '.' }
-}
+end
 
 puts system('ruby -e "sleep 1; puts :done; STDOUT.close"')
 timer.stop

data/examples/io/tcpserver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/auto_run'
+
+server = TCPServer.new('127.0.0.1', 1234)
+
+puts 'echoing on port 1234'
+while (socket = server.accept)
+  spin do
+    while (data = socket.gets(8192))
+      socket << "you said: #{data}"
+    end
+  end
+end

data/examples/io/tcpsocket.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
+require 'polyphony/extensions/backtrace'
 
-socket = TCPSocket.new('realiteq.net', 80)
+socket = TCPSocket.new('google.com', 80)
 
 timer = spin { throttled_loop(20) { STDOUT << '.' } }
 
 5.times do
-  socket.send("GET /?q=time HTTP/1.1\r\nHost: realiteq.net\r\n\r\n", 0)
+  socket.send("GET /?q=time HTTP/1.1\r\nHost: google.com\r\n\r\n", 0)
   socket.recv(8192)
-  STDOUT << "*"
+  STDOUT << '*'
 end
 
 timer.stop
 socket.close
-puts
+puts

data/examples/performance/multi_snooze.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/auto_run'
+
+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
+      end
+    end
+  end
+  dt = Time.now - t0
+  puts "#{[fibers, iterations].inspect} count: #{count} #{count / dt.to_f}/s"
+end
+
+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/performance/{perf_snooze.rb → snooze.rb}

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'polyphony'
+require 'polyphony/auto_run'
 
 X = 1_000_000
 
-STDOUT << "Fiber.yield: "
+STDOUT << 'Fiber.yield:   '
 f = Fiber.new do
   loop { Fiber.yield }
 end
 t0 = Time.now
 X.times { f.resume }
 dt = Time.now - t0
-puts "%d/s" % (X / dt)
+puts format('%d/s', (X / dt))
 
 # STDOUT << "Kernel#sleep: "
 # t0 = Time.now
@@ -20,8 +20,10 @@ puts "%d/s" % (X / dt)
 # dt = Time.now - t0
 # puts "%d/s" % (X / dt)
 
-STDOUT << "Kernel#snooze: "
+trap('SIGINT') { exit! }
+
+STDOUT << 'Kernel#snooze: '
 t0 = Time.now
 X.times { snooze }
 dt = Time.now - t0
-puts "%d/s" % (X / dt)
+puts format('%d/s', (X / dt))

data/examples/performance/snooze_raw.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+def worker_loop(tag)
+  loop do
+    puts "#{Time.now} #{tag}"
+    snooze
+  end
+end
+
+f1 = Fiber.new { worker_loop(:a) }
+f2 = Fiber.new { worker_loop(:b) }
+
+$reactor = Fiber.new do
+  loop do
+    # sleep 0.001
+    handle_next_tick
+  end
+end
+
+$next_tick_items = []
+
+def handle_next_tick
+  items = $next_tick_items
+  $next_tick_items = []
+  items.each(&:transfer)
+end
+
+module Kernel
+  def snooze
+    $next_tick_items << Fiber.current
+    $reactor.transfer
+  end
+end
+
+$next_tick_items << f1
+$next_tick_items << f2
+$reactor.transfer

data/ext/gyro/async.c

@@ -0,0 +1,165 @@
+#include "gyro.h"
+
+struct Gyro_Async {
+  struct  ev_async ev_async;
+  int     active;
+  VALUE   callback;
+  VALUE   fiber;
+};
+
+static 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_start(VALUE self);
+static VALUE Gyro_Async_stop(VALUE self);
+static VALUE Gyro_Async_signal(VALUE self);
+static VALUE Gyro_Async_await(VALUE self);
+
+void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents);
+
+/* 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);
+
+  rb_define_method(cGyro_Async, "initialize", Gyro_Async_initialize, 0);
+  rb_define_method(cGyro_Async, "start", Gyro_Async_start, 0);
+  rb_define_method(cGyro_Async, "stop", Gyro_Async_stop, 0);
+  rb_define_method(cGyro_Async, "signal!", Gyro_Async_signal, 0);
+  rb_define_method(cGyro_Async, "await", Gyro_Async_await, 0);
+}
+
+static const rb_data_type_t Gyro_Async_type = {
+    "Gyro_Async",
+    {Gyro_Async_mark, Gyro_Async_free, Gyro_Async_size,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE Gyro_Async_allocate(VALUE klass) {
+  struct Gyro_Async *async = (struct Gyro_Async *)xmalloc(sizeof(struct Gyro_Async));
+  return TypedData_Wrap_Struct(klass, &Gyro_Async_type, async);
+}
+
+static void Gyro_Async_mark(void *ptr) {
+  struct Gyro_Async *async = ptr;
+  if (async->callback != Qnil) {
+    rb_gc_mark(async->callback);
+  }
+  if (async->fiber != Qnil) {
+    rb_gc_mark(async->fiber);
+  }
+}
+
+static void Gyro_Async_free(void *ptr) {
+  struct Gyro_Async *async = ptr;
+  ev_async_stop(EV_DEFAULT, &async->ev_async);
+  xfree(async);
+}
+
+static size_t Gyro_Async_size(const void *ptr) {
+  return sizeof(struct Gyro_Async);
+}
+
+#define GetGyro_Async(obj, async) \
+  TypedData_Get_Struct((obj), struct Gyro_Async, &Gyro_Async_type, (async))
+
+static VALUE Gyro_Async_initialize(VALUE self) {
+  struct Gyro_Async *async;
+  GetGyro_Async(self, async);
+
+  if (rb_block_given_p()) {
+    async->callback = rb_block_proc();
+  }
+  async->fiber = Qnil;
+
+  ev_async_init(&async->ev_async, Gyro_Async_callback);
+
+  async->active = 1;
+  ev_async_start(EV_DEFAULT, &async->ev_async);
+
+  return Qnil;
+}
+
+void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  VALUE fiber;
+  struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
+
+  if (async->fiber != Qnil) {
+    async->active = 0;
+    fiber = async->fiber;
+    async->fiber = Qnil;
+    SCHEDULE_FIBER(fiber, 0);
+  }
+  else if (async->callback != Qnil) {
+    rb_funcall(async->callback, ID_call, 1, Qtrue);
+  }
+}
+
+static VALUE Gyro_Async_start(VALUE self) {
+  struct Gyro_Async *async;
+  GetGyro_Async(self, async);
+
+  if (!async->active) {
+    ev_async_start(EV_DEFAULT, &async->ev_async);
+    async->active = 1;
+  }
+
+  return self;
+}
+
+static VALUE Gyro_Async_stop(VALUE self) {
+  struct Gyro_Async *async;
+  GetGyro_Async(self, async);
+
+  if (async->active) {
+    ev_async_stop(EV_DEFAULT, &async->ev_async);
+    async->active = 0;
+  }
+
+  return self;
+}
+
+static VALUE Gyro_Async_signal(VALUE self) {
+  struct Gyro_Async *async;
+  GetGyro_Async(self, async);
+
+  ev_async_send(EV_DEFAULT, &async->ev_async);
+
+  return Qnil;
+}
+
+static VALUE Gyro_Async_await(VALUE self) {
+  struct Gyro_Async *async;
+  VALUE ret;
+  
+  GetGyro_Async(self, async);
+
+  async->fiber = rb_fiber_current();
+  if (!async->active) {
+    async->active = 1;
+    ev_async_start(EV_DEFAULT, &async->ev_async);
+  }
+
+  ret = YIELD_TO_REACTOR();
+
+  // 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);
+    }
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return Qnil;
+  }
+}