polyphony 0.46.1 → 0.47.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 831c85a16a22fe3877044430a4d1cc4a270d18dc73e9ceca8d4826623ab0ddc8
-  data.tar.gz: f0432473abb769be2805ad354dddf44465789ebe2d5220f194660e4c6521ec87
+  metadata.gz: 606d74c424178b9e8bb17cd7b2848e0e1c1b092e77eeb98ce1026fd7d1f38c61
+  data.tar.gz: 9e003833af5f2c8505ea41d2ebe728fbf776f428f47d925b0185fd592d102737
 SHA512:
-  metadata.gz: 9bfecbed04a8052c3a885dfde73975694313801d2a8341260041be84e4910ac459af71766f7df6fa96e5afad66a737b97e36531811bd47cab407ad43b239e073
-  data.tar.gz: 2caa40f7193cf1954b69adc5810844ad4e578a4472382602a6ee4204d548e8327344f913bc0aef076030e7deacb911cab1733b281f7a2e8849ffcbd009a00ebc
+  metadata.gz: 1cfb1c81d3b38a545ceb856d4619c11386407081ecd43a6e6209d2ed4efb1c436242aa016657d379f0a0331ca24944f5e51c5359ad44afc3a88d53af1de7976b
+  data.tar.gz: 9b47ba16c7de942bea952f9f12d225aed86a505c2fd6cf7740a88d5d398af0e91e37a16e3ee9af2129ad88c8ff17c2b5aba7dcf6630811af62202e4b2585d6dc

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.47.0
+
+* Implement `#spin_scope` used for creating blocking fiber scopes 
+* Reimplement `move_on_after`, `cancel_after`, `Timeout.timeout` using
+  `Backend#timeout` (avoids creating canceller fiber for most common use case)
+* Implement `Backend#timeout` API
+* Implemented capped queues
+
 ## 0.46.1
 
 * Add `TCPServer#accept_loop`, `OpenSSL::SSL::SSLSocket#accept_loop` method

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.46.1)
+    polyphony (0.47.0)
 
 GEM
   remote: https://rubygems.org/

data/TODO.md

@@ -192,17 +192,3 @@ Prior art:
 
 - https://github.com/socketry/async-dns
 
-## Work on API
-
-- Add option for setting the exception raised on cancelling using `#cancel_after`:
-
-```ruby
-cancel_after(3, with_error: MyErrorClass) do
-  do_my_thing
-end
-# or a RuntimeError with message
-cancel_after(3, with_error: 'Cancelled due to timeout') do
-  do_my_thing
-end
-```
-

data/examples/core/enumerable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+module Enumerable
+  def map_concurrently(&block)
+    spin do
+      results = []
+      each_with_index do |i, idx|
+        spin { results[idx] = block.(i) }
+      end
+      Fiber.current.await_all_children
+      results
+    end.await
+  end
+
+  def each_concurrently(max_fibers: nil, &block)
+    return each_concurrently_with_fiber_pool(max_fibers, &block) if max_fibers
+
+    spin do
+      results = []
+      each do |i|
+        spin(&block).schedule(i)
+      end
+      Fiber.current.await_all_children
+    end.await
+    self
+  end
+
+  def each_concurrently_with_fiber_pool(max_fibers, &block)
+    spin do
+      fiber_count = 0
+      workers = []
+      each do |i|
+        if fiber_count < max_fibers
+          workers << spin do
+            loop do
+              item = receive
+              break if item == :__stop__
+              block.(item)
+            end
+          end
+        end
+
+        fiber = workers.shift
+        fiber << i
+        workers << fiber
+      end
+      workers.each { |f| f << :__stop__ }
+      Fiber.current.await_all_children
+    end.await
+    self
+  end
+end
+
+o = 1..3
+o.each_concurrently(max_fibers: 2) do |i|
+  puts "#{Fiber.current} sleep #{i}"
+  sleep(i)
+  puts "wakeup #{i}"
+end

data/examples/performance/fiber_resume.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance of Fiber.transfer degrades as the fiber
+# count increases
+
+def run(num_fibers)
+  count = 0
+
+  GC.start
+  GC.disable
+
+  fibers = []
+  num_fibers.times do
+    fibers << Fiber.new { loop { Fiber.yield } }
+  end
+
+  t0 = Time.now
+
+  while count < 1000000
+    fibers.each do |f|
+      count += 1
+      f.resume
+    end
+  end
+
+  elapsed = Time.now - t0
+
+  puts "fibers: #{num_fibers} count: #{count} rate: #{count / elapsed}"
+rescue Exception => e
+  puts "Stopped at #{count} fibers"
+  p e
+end
+
+run(100)
+run(1000)
+run(10000)
+run(100000)

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

@@ -0,0 +1,59 @@
+SERVERS = {
+  polyphony: {
+    port: 1234,
+    cmd: 'ruby examples/performance/thread-vs-fiber/polyphony_server.rb'
+  },
+  threaded: {
+    port: 1235,
+    cmd: 'ruby examples/performance/thread-vs-fiber/threaded_server.rb'
+  },
+  em: {
+    port: 1236,
+    cmd: 'ruby examples/performance/thread-vs-fiber/em_server.rb'
+  }
+}
+SETTINGS = [
+  '-t1 -c1',
+  '-t4 -c8',
+  '-t8 -c64',
+  '-t16 -c512',
+  '-t32 -c4096',
+  '-t64 -c8192',
+  '-t128 -c16384',
+  '-t256 -c32768'
+]
+
+def run_test(name, port, cmd, setting)
+  puts "*" * 80
+  puts "Run #{name} (#{port}): #{setting}"
+  puts "*" * 80
+  
+  pid = spawn("#{cmd} > /dev/null 2>&1")
+  sleep 1
+
+  output = `wrk -d60 #{setting} \"http://127.0.0.1:#{port}/\"`
+  puts output
+  (output =~ /Requests\/sec:\s+(\d+)/) && $1.to_i
+ensure
+  Process.kill('KILL', pid)
+  Process.wait(pid)
+  3.times { puts }
+end
+
+def perform_benchmark
+  results = []
+  SETTINGS.each do |s|
+    results << SERVERS.inject({}) do |h, (n, o)|
+      h[n] = run_test(n, o[:port], o[:cmd], s)
+      h
+    end
+  end
+  results
+end
+
+results = []
+3.times { results << perform_benchmark }
+
+require 'pp'
+puts "results:"
+pp results

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

@@ -0,0 +1,33 @@
+require 'eventmachine'
+require 'http/parser'
+require 'socket'
+
+module HTTPServer
+  def post_init
+    @parser = Http::Parser.new
+    @pending_requests = []
+    @parser.on_message_complete = proc { @pending_requests << @parser }
+  end
+
+  def receive_data(data)
+    @parser << data
+    write_response while @pending_requests.shift
+  end
+
+  def write_response
+    status_code = "200 OK"
+    data = "Hello world!\n"
+    headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
+    send_data "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
+  end
+end
+
+EventMachine::run do
+  EventMachine::start_server(
+    '0.0.0.0',
+    1236,
+    HTTPServer
+  )
+  puts "pid #{Process.pid} EventMachine listening on port 1236"
+
+end

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

@@ -27,7 +27,8 @@ def write_response(socket)
 end
 
 server = TCPServer.open('0.0.0.0', 1234)
-puts "pid #{Process.pid}"
-puts "listening on port 1234"
+puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 1234"
 
-server.accept_loop { |c| handle_client(c) }
+server.accept_loop do |c|
+  spin { handle_client(c) }
+end

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

@@ -1,23 +1,30 @@
-require 'thread'
 require 'http/parser'
 require 'socket'
 
-def handle_client(client)
-  Thread.new do
-    parser = Http::Parser.new
-    parser.on_message_complete = proc do |env|
-      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
-    client.read_loop { |data| parser << data }
-    client.close
+def handle_client(socket)
+  pending_requests = []
+  parser = Http::Parser.new
+  parser.on_message_complete = proc { pending_requests << parser }
+
+  while (data = socket.recv(8192))
+    parser << data
+    write_response(socket) while pending_requests.shift
   end
+rescue IOError, SystemCallError => e
+  # ignore
+ensure
+  socket.close
+end
+
+def write_response(socket)
+  status_code = "200 OK"
+  data = "Hello world!\n"
+  headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
+  socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-server = TCPServer.open(1234)
-puts "Listening on port 1234"
+server = TCPServer.open(1235)
+puts "pid #{Process.pid} threaded listening on port 1235"
 while socket = server.accept
-  handle_client(socket)
+  Thread.new { handle_client(socket) }
 end

data/examples/performance/thread_switch.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance of Fiber.transfer degrades as the fiber
+# count increases
+
+def run(num_threads)
+  count = 0
+
+  GC.start
+  GC.disable
+
+  threads = []
+  t0 = Time.now
+  limit = 10_000_000 / num_threads
+  num_threads.times do
+    threads << Thread.new do
+      individual_count = 0
+      loop do
+        individual_count += 1
+        count += 1
+        break if individual_count == limit
+      end
+    end
+  end
+
+  threads.each(&:join)
+  elapsed = Time.now - t0
+
+  puts "threads: #{num_threads} count: #{count} rate: #{count / elapsed}"
+rescue Exception => e
+  puts "Stopped at #{count} threads"
+  p e
+end
+
+run(100)
+run(1000)
+run(10000)
+run(100000)

data/ext/polyphony/backend_common.h

@@ -118,3 +118,12 @@ inline double current_time() {
   double t = ns;
   return t / 1e9;
 }
+
+inline VALUE backend_timeout_exception(VALUE exception) {
+  if (RTEST(rb_obj_is_kind_of(exception, rb_cArray)))
+    return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
+  else if (RTEST(rb_obj_is_kind_of(exception, rb_cClass)))
+    return rb_funcall(exception, ID_new, 0);
+  else
+    return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
+}

data/ext/polyphony/backend_io_uring.c

@@ -171,7 +171,7 @@ void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *bac
     // otherwise, we mark it as completed, schedule the fiber and let it deal
     // with releasing the context
     ctx->completed = 1;
-    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, Qnil);
+    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, ctx->resume_value);
   }
 }
 
@@ -774,15 +774,23 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   return self;
 }
 
-// returns true if completed, 0 otherwise
-int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
+inline struct __kernel_timespec double_to_timespec(double duration) {
   double duration_integral;
   double duration_fraction = modf(duration, &duration_integral);
   struct __kernel_timespec ts;
-
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   ts.tv_sec = duration_integral;
 	ts.tv_nsec = floor(duration_fraction * 1000000000);
+  return ts;
+}
+
+inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
+  return double_to_timespec(NUM2DBL(duration));
+}
+
+// returns true if completed, 0 otherwise
+int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
+  struct __kernel_timespec ts = double_to_timespec(duration);
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
   op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -830,6 +838,73 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}
+
+struct Backend_timeout_ctx {
+  Backend_t *backend;
+  op_context_t *ctx;
+};
+
+VALUE Backend_timeout_ensure(VALUE arg) {
+    struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
+    if (!timeout_ctx->ctx->completed) {
+    timeout_ctx->ctx->result = -ECANCELED;
+
+    // op was not completed, so we need to cancel it
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&timeout_ctx->backend->ring);
+    io_uring_prep_cancel(sqe, timeout_ctx->ctx, 0);
+    timeout_ctx->backend->pending_sqes = 0;
+    io_uring_submit(&timeout_ctx->backend->ring);
+  }
+  OP_CONTEXT_RELEASE(&timeout_ctx->backend->store, timeout_ctx->ctx);
+  return Qnil;
+}
+
+VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
+  VALUE duration;
+  VALUE exception;
+  VALUE move_on_value = Qnil;
+  rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
+  
+  struct __kernel_timespec ts = duration_to_timespec(duration);
+  Backend_t *backend;
+  GetBackend(self, backend);
+  VALUE result = Qnil;
+  VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  
+  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  ctx->resume_value = timeout;
+  io_uring_prep_timeout(sqe, &ts, 0, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  io_uring_backend_defer_submit(backend);
+
+  struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
+  result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
+
+  if (result == timeout) {
+    if (exception == Qnil) return move_on_value;
+    RAISE_EXCEPTION(backend_timeout_exception(exception));
+  }
+
+  RAISE_IF_EXCEPTION(result);
+  RB_GC_GUARD(result);
+  RB_GC_GUARD(timeout);
+  return result;
+}
+
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
   Backend_t *backend;
   int pid_int = NUM2INT(pid);
@@ -899,6 +974,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);