polyphony 0.34 → 0.41

data/examples/core/xx-agent.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+class Test
+  def test_sleep
+    puts "going to sleep"
+    sleep 1
+    puts "done sleeping"
+  end
+  
+  def test_spin
+    spin {
+      10.times {
+        STDOUT << '.'
+        sleep 0.1
+      }
+    }
+    
+    puts "going to sleep\n"
+    sleep 1
+    puts 'woke up'
+  end
+  
+  def test_file
+    f = File.open(__FILE__, 'r')
+    puts Thread.current.agent.read(f, +'', 10000, true)
+    
+    Thread.current.agent.write(STDOUT, "Write something: ")
+    str = +''
+    Thread.current.agent.read(STDIN, str, 5, false)
+    puts str
+  end
+  
+  def test_fork
+    pid = fork do
+      Thread.current.agent.post_fork
+      puts 'child going to sleep'
+      sleep 1
+      puts 'child done sleeping'
+      exit(42)
+    end
+    
+    puts "Waiting for pid #{pid}"
+    result = Thread.current.agent.waitpid(pid)
+    puts "Done waiting"
+    p result
+  end
+  
+  def test_async
+    async = Polyphony::Event.new
+    
+    spin {
+      puts "signaller starting"
+      sleep 1
+      puts "signal"
+      async.signal(:foo)
+    }
+    
+    puts "awaiting event"
+    p async.await
+  end
+  
+  def test_queue
+    q = Gyro::Queue.new
+    spin {
+      10.times {
+        q << Time.now.to_f
+        sleep 0.2
+      }
+      q << :STOP
+    }
+    
+    loop do
+      value = q.shift
+      break if value == :STOP
+      
+      p value
+    end
+  end
+  
+  def test_thread
+    t = Thread.new do
+      puts "thread going to sleep"
+      sleep 0.2
+      puts "thread done sleeping"
+    end
+    
+    t.await
+  end
+end
+
+t = Test.new
+
+t.methods.select { |m| m =~ /^test_/ }.each do |m|
+  puts '*' * 40
+  puts m
+  t.send(m)
+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-sleeping.rb

@@ -5,13 +5,21 @@ require 'polyphony'
 
 Exception.__disable_sanitized_backtrace__ = true
 
-spin {
-  10.times {
-    STDOUT << '.'
-    sleep 0.1
-  }
-}
+# 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-timer-gc.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+timers = 10.times.map do
+  spin do
+    t = Gyro::Timer.new(1, 1)
+    t.await
+  end
+end
+
+sleep 0.1
+GC.start
+sleep 0.1

data/examples/io/tunnel.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Ports = ARGV[0..1]
+EndPoints = []
+
+def log(msg)
+  puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S.%3N')} #{msg}"
+end
+
+def endpoint_loop(idx, peer_idx)
+  port = Ports[idx]
+  server = Polyphony::Net.tcp_listen(
+    '0.0.0.0',
+    port,
+    reuse_addr: true
+  ) 
+  # server = TCPServer.open('0.0.0.0', port)
+  log "Listening on port #{port}"
+  loop do
+    conn = server.accept
+    conn.binmode
+    EndPoints[idx] = conn
+    log "Client connected on port #{port} (#{conn.remote_address.inspect})"
+    while data = conn.readpartial(8192)
+      peer = EndPoints[peer_idx]
+      if peer
+        peer << data
+        log "#{idx} => #{peer_idx} #{data.inspect}"
+      else
+        log "#{idx}: #{data.inspect}"
+      end
+    end
+    EndPoints[idx] = nil
+    log "Connection closed on port #{port}"
+  rescue => e
+    log "Error on port #{port}: #{e.inspect}"
+  end
+end
+
+spin { endpoint_loop(0, 1) }
+spin { endpoint_loop(1, 0) }
+
+log "Tunneling port #{Ports[0]} to port #{Ports[1]}..."
+sleep
+

data/examples/io/xx-irb.rb

@@ -2,7 +2,7 @@
 
 require 'bundler/setup'
 require 'irb'
-require 'polyphony/irb'
+require 'polyphony/adapters/irb'
 
 $counter = 0
 timer = spin do

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

@@ -20,22 +20,22 @@ 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
   # do nothing
 ensure
-  socket.close rescue nil
+  socket&.close
   parser.reset!
 end
 
@@ -46,13 +46,14 @@ def handle_request(client, parser)
   client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-$incoming = Gyro::Queue.new
+$incoming = Polyphony::Queue.new
 
 $threads = (1..4).map {
   Thread.new {
     Thread.current.setup_fiber_scheduling
     loop {
       conn = $incoming.pop
+      puts "#{Thread.current.inspect} pop #{conn.inspect}"
       spin { handle_client(conn) }
     }
   }

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

@@ -4,21 +4,10 @@ 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
+$connection_count = 0
 
 def handle_client(socket)
+  $connection_count += 1
   parser = Http::Parser.new
   reqs = []
   parser.on_message_complete = proc do |env|
@@ -29,20 +18,20 @@ def handle_client(socket)
     while (req = reqs.shift)
       handle_request(socket, req)
       req = nil
-      # snooze
+      snooze
     end
   end
 rescue IOError, SystemCallError => e
   # do nothing
 ensure
-  socket.close rescue nil
-  parser.reset!
+  $connection_count -= 1
+  socket&.close
 end
 
 def handle_request(client, parser)
-  status_code = 200
+  status_code = "200 OK"
   data = "Hello world!\n"
-  headers = "Content-Length: #{data.bytesize}\r\n"
+  headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
   client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
@@ -53,16 +42,16 @@ spin do
   loop do
     client = server.accept
     spin { handle_client(client) }
-    # snooze
   end
+ensure
+  server&.close
 end
 
-spin do
-  loop do
-    sleep 1
-    puts "#{Time.now} #{Thread.current.fiber_scheduling_stats}"
-  end
-end
+# every(1) {
+#   stats = Thread.current.fiber_scheduling_stats
+#   stats[:connection_count] = $connection_count
+#   puts "#{Time.now} #{stats}"
+# }
 
 puts "pid #{Process.pid}"
 suspend

data/ext/{gyro → polyphony}/extconf.rb

@@ -16,5 +16,5 @@ $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 
 CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
-dir_config "gyro_ext"
-create_makefile "gyro_ext"
+dir_config "polyphony_ext"
+create_makefile "polyphony_ext"

data/ext/polyphony/fiber.c

@@ -0,0 +1,112 @@
+#include "polyphony.h"
+
+ID ID_fiber_trace;
+ID ID_ivar_auto_watcher;
+ID ID_trace_ev_loop_enter;
+ID ID_trace_ev_loop_leave;
+ID ID_trace_run;
+ID ID_trace_runnable;
+ID ID_trace_terminate;
+ID ID_trace_wait;
+
+VALUE cEvent = Qnil;
+
+VALUE SYM_dead;
+VALUE SYM_running;
+VALUE SYM_runnable;
+VALUE SYM_waiting;
+
+VALUE SYM_fiber_create;
+VALUE SYM_fiber_ev_loop_enter;
+VALUE SYM_fiber_ev_loop_leave;
+VALUE SYM_fiber_run;
+VALUE SYM_fiber_schedule;
+VALUE SYM_fiber_switchpoint;
+VALUE SYM_fiber_terminate;
+
+static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
+  VALUE arg = (argc == 0) ? Qnil : argv[0];
+  VALUE ret = rb_funcall(self, ID_transfer, 1, arg);
+
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+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) {
+    watcher = rb_funcall(cEvent, ID_new, 0);
+    rb_ivar_set(self, ID_ivar_auto_watcher, watcher);
+  }
+  return watcher;
+}
+
+static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
+  VALUE value = (argc == 0) ? Qnil : argv[0];
+  Fiber_make_runnable(self, value);
+  return self;
+}
+
+static VALUE Fiber_state(VALUE self) {
+  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
+    return SYM_dead;
+  if (rb_fiber_current() == self) return SYM_running;
+  if (rb_ivar_get(self, ID_runnable) != Qnil) return SYM_runnable;
+
+  return SYM_waiting;
+}
+
+void Fiber_make_runnable(VALUE fiber, VALUE value) {
+  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
+  if (thread != Qnil) {
+    Thread_schedule_fiber(thread, fiber, value);
+  }
+  else {
+    VALUE caller;
+    rb_warn("No thread set for fiber (fiber, value, caller):");
+    caller = rb_funcall(rb_cObject, rb_intern("caller"), 0);
+    INSPECT(3, fiber, value, caller);
+  }
+}
+
+void Init_Fiber() {
+  VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+  rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
+  rb_define_method(cFiber, "schedule", Fiber_schedule, -1);
+  rb_define_method(cFiber, "state", Fiber_state, 0);
+  rb_define_method(cFiber, "auto_watcher", Fiber_auto_watcher, 0);
+
+  SYM_dead = ID2SYM(rb_intern("dead"));
+  SYM_running = ID2SYM(rb_intern("running"));
+  SYM_runnable = ID2SYM(rb_intern("runnable"));
+  SYM_waiting = ID2SYM(rb_intern("waiting"));
+  rb_global_variable(&SYM_dead);
+  rb_global_variable(&SYM_running);
+  rb_global_variable(&SYM_runnable);
+  rb_global_variable(&SYM_waiting);
+
+  ID_fiber_trace          = rb_intern("__fiber_trace__");
+  ID_ivar_auto_watcher    = rb_intern("@auto_watcher");
+
+  SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));
+  SYM_fiber_ev_loop_enter = ID2SYM(rb_intern("fiber_ev_loop_enter"));
+  SYM_fiber_ev_loop_leave = ID2SYM(rb_intern("fiber_ev_loop_leave"));
+  SYM_fiber_run           = ID2SYM(rb_intern("fiber_run"));
+  SYM_fiber_schedule      = ID2SYM(rb_intern("fiber_schedule"));
+  SYM_fiber_switchpoint   = ID2SYM(rb_intern("fiber_switchpoint"));
+  SYM_fiber_terminate     = ID2SYM(rb_intern("fiber_terminate"));
+
+  rb_global_variable(&SYM_fiber_create);
+  rb_global_variable(&SYM_fiber_ev_loop_enter);
+  rb_global_variable(&SYM_fiber_ev_loop_leave);
+  rb_global_variable(&SYM_fiber_run);
+  rb_global_variable(&SYM_fiber_schedule);
+  rb_global_variable(&SYM_fiber_switchpoint);
+  rb_global_variable(&SYM_fiber_terminate);
+}