polyphony 0.66 → 0.70

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8e2aa3d011286dda93222164cbf66f1ec4c18b9c212ee7a70dbebd4bc523943
-  data.tar.gz: 99b5fb95c682dfad8df33f07d98bfab7f2109b9d4ec0e24720869c2d331f23fb
+  metadata.gz: 65be64df5933c24a4afb38b24c139213dcc71a7fbde7689c46c862d7bb04eef3
+  data.tar.gz: 3feec6f48ea17b15468790c91a790438d163b1d905d5ef6c7a2ffd6d3e47bac8
 SHA512:
-  metadata.gz: 27c65b6e340d1aad41d38b4b322b98d282f96fe6d136c897ab8de14651b2da3cfc392650600d63983f76b5fb1dc70e4e49116efb289a790a509bec63caa9b9e4
-  data.tar.gz: 94e62ac7fbcb6d085af7475d987eca45be191aaf7654c3bacb07c4f7793d450281d3da1b08b12636a49398e97c1043c3a2cd628018925bdc082e02a0859743bc
+  metadata.gz: 3417d863dcd7e99c3123fbc81923627a77c6a5b45ed20d6e84148eabb945ecb38f429873be01fc53d5c35f36a225045c42e51b2c36f543fb3539ebc7d91f8bcf
+  data.tar.gz: be39ff1ec9616998fc2a5df0bd9af368687e3424cf4b97776466e803624953440bbf75fc166cd273f8f3d4502eefee4a13283c4129c3ed02113cc2015d314428

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.70 2021-08-19
+
+- New implementation for `#supervise`
+- Reset backend state and runqueue on fork
+
+## 0.69 2021-08-16
+
+- Rename `#__polyphony_read_method__` to `#__parser_read_method__`
+
+## 0.68 2021-08-13
+
+- Fix missing default value in socket classes' `#readpartial`
+- Fix linking of operations in `Backend#chain` (io_uring version)
+- Rename `Fiber#attach` to `Fiber#attach_to`
+- Expose original `SSLServer#accept`
+
+## 0.67 2021-08-06
+
+- Improve fiber monitoring
+- Add fiber parking (a parked fiber is prevented from running). This is in
+  preparation for the upcoming work on an integrated debugger.
+
 ## 0.66 2021-08-01
 
 - Fix all splicing APIs on non-linux OSes (#63)
@@ -5,7 +27,7 @@
 
 ## 0.65 2021-07-29
 
-- Add `#__polyphony_read_method__` method for read method detection
+- Add `#__parser_read_method__` method for read method detection
 
 ## 0.64 2021-07-26
 

data/Gemfile.lock

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

data/TODO.md

@@ -1,3 +1,13 @@
+- io_uring backend:
+  - if `io_uring_get_sqe` returns null, call `io_uring_submit`, (snooze fiber)?
+    and try again
+
+- Tracing:
+  - Emit events on I/O ops, e.g.:
+    - [:op_read_submit, id, io, len]
+    - [:op_read_complete, id, io, len, buffer]
+  - Prevent tracing while an event is being emitted (to allow the trace proc to perform I/O)
+
 - Add support for IPv6:
   https://www.reddit.com/r/ruby/comments/lyen23/understanding_ipv6_and_why_its_important_to_you/
 
@@ -14,72 +24,10 @@
   - `IO#gets_loop`, `Socket#gets_loop`, `OpenSSL::Socket#gets_loop` (medium effort)
   - `Fiber#receive_loop` (very little effort, should be implemented in C)
 
-
-- Add `Backend#splice`, `Backend#splice_to_eof` for implementing stuff like proxying:
-
-  ```ruby
-  def two_way_proxy(socket1, socket2)
-    backend = Thread.current.backend
-    f1 = spin { backend.splice_to_eof(socket1, socket2) }
-    f2 = spin { backend.splice_to_eof(socket2, socket1) }
-    Fiber.await(f1, f2)
-  end
-  ```
-
 - Add support for `close` to io_uring backend
 
-- Add support for submission of multiple requests to io_uring backend:
-
-  ```ruby
-  Thread.current.backend.submit(
-    [:send, sock, chunk_header(len)],
-    [:splice, file, sock, len]
-  )
-  ```
-
-  Full example (for writing chunks from a file to an HTTP response):
-
-  ```ruby
-  def serve_io(io)
-    i, o = IO.pipe
-    backend = Thread.current.backend
-    while true
-      len = o.splice(io, 8192)
-      break if len == 0
-      
-      backend.submit(
-        [:write, sock, chunk_header(len)],
-        [:splice, i, sock, len]
-      )
-    end
-  end
-  ```
-
-- Graceful shutdown again:
-  - What happens to children when doing a graceful shutdown?
-  - What are the implications of passing graceful shutdown flag to children?
-  - What about errors while doing a graceful shutdown?
-  - What about graceful restarts?
-  - Some interesting discussions:
-    - https://trio.discourse.group/search?q=graceful%20shutdown
-    - https://github.com/python-trio/trio/issues/147
-    - https://github.com/python-trio/trio/issues/143
-    - https://trio.discourse.group/t/graceful-shutdown/93/2
-    - https://250bpm.com/blog:146/
-    - https://www.rodrigoaraujo.me/posts/golang-pattern-graceful-shutdown-of-concurrent-events/
-    - https://github.com/tj/go-gracefully
-  - `Fiber#finalize_children` should pass graceful shutdown flag to children
-  - A good use case is an HTTP server that on graceful shutdown:
-    - stops listening
-    - waits for all ongoing requests to finish, optionally with a timeout
-
 ## Roadmap for Polyphony 1.0
 
-- check integration with rb-inotify
-
-- Improve `#supervise`. It does not work as advertised, and seems to exhibit an
-  inconsistent behaviour (see supervisor example).
-
 - Add test that mimics the original design for Monocrono:
   - 256 fibers each waiting for a message
   - When message received do some blocking work using a `ThreadPool`
@@ -92,7 +40,6 @@
 
 -----------------------------------------------------
 
-- Add `Backend#splice(in, out, nbytes)` API
 - Adapter for io/console (what does `IO#raw` do?)
 - Adapter for Pry and IRB (Which fixes #5 and #6)
 - allow backend selection at runtime

data/bin/pdbg

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+UNIX_SOCKET_PATH = '/tmp/pdbg.sock'
+
+cmd = ARGV.join(' ')
+injected_lib_path = File.expand_path('../lib/polyphony/debugger/server_inject.rb', __dir__)
+pid = fork { exec("env POLYPHONY_DEBUG_SOCKET_PATH=#{UNIX_SOCKET_PATH} ruby #{cmd}") }
+puts "Started debugged process (#{pid})"
+
+socket = nil
+while !socket
+  socket = UNIXSocket.new(UNIX_SOCKET_PATH) rescue nil
+end
+
+def parse_command(cmd)
+  case cmd
+  when /^(step|s)$/
+    { cmd: :step }
+  when /^(state|st)$/
+    { cmd: :state }
+  when /^(help|h)$/
+    { cmd: :help }
+  when /^(list|l)$/
+    { cmd: :list }
+  else
+    nil
+  end
+end
+
+def display_info(info)
+  info = eval(info)
+  case (info && info[:kind])
+  when :listing
+    print_listing(info)
+  when :state
+    print_state(info)
+  else
+    p info
+  end
+rescue SyntaxError
+  puts "Failed to eval:"
+  p info
+end
+
+FILE_LINES_CACHE = {}
+
+def self.get_snippet(path, lineno)
+  lines = FILE_LINES_CACHE[path] ||= IO.read(path).lines
+  start_idx = lineno - 5
+  stop_idx = lineno + 3
+  stop_idx = lines.size - 1 if stop_idx >= lines.size
+  start_idx = 0 if start_idx < 0
+  (start_idx..stop_idx).map { |idx| [idx + 1, lines[idx]]}
+end
+
+def print_snippet(info, snippet, cur_line)
+  places = FILE_LINES_CACHE[info[:path]].size.to_s.size
+  snippet.each do |(lineno, line)|
+    is_cur = lineno == cur_line
+    formatted = format("%s% #{places}d %s", is_cur ? '=> ' : '   ', lineno, line)
+    puts formatted
+  end
+end
+
+def print_listing(info)
+  snippet = get_snippet(info[:path], info[:lineno])
+  puts "Fiber: #{info[:fiber]} Location: #{info[:path]}:#{info[:lineno]}"
+  puts
+  print_snippet(info, snippet, info[:lineno])
+  puts
+end
+
+def print_help
+  puts
+  puts "Here's some help..."
+  puts
+end
+
+def print_state(info)
+  p info
+end
+
+def get_user_cmd
+  while true
+    STDOUT << "(pdbg) "
+    cmd = parse_command(STDIN.gets)
+    next unless cmd
+    
+    if cmd[:cmd] == :help
+      print_help
+    else
+      return cmd if cmd
+    end
+  end
+end
+
+socket.puts 'pdbg'
+response = socket.gets
+if response.chomp == 'pdbg'
+  puts 'Connected to process'
+end
+loop do
+  info = socket.gets.chomp
+  display_info(info)
+
+  cmd = get_user_cmd
+  socket.puts cmd.inspect
+end

data/examples/core/await.rb

@@ -2,7 +2,11 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/extensions/debug'
 
+Exception.__disable_sanitized_backtrace__ = true
+
+puts '----- start await example ------'
 sleeper = spin do
   puts 'going to sleep'
   sleep 1
@@ -17,4 +21,8 @@ waiter = spin do
   puts 'done waiting'
 end
 
-waiter.await
+trace :before_await
+
+sleep 2
+waiter.await
+trace :after_await

data/ext/polyphony/backend_common.c

@@ -7,6 +7,7 @@
 
 inline void backend_base_initialize(struct Backend_base *base) {
   runqueue_initialize(&base->runqueue);
+  runqueue_initialize(&base->parked_runqueue);
   base->currently_polling = 0;
   base->op_count = 0;
   base->switch_count = 0;
@@ -20,12 +21,32 @@ inline void backend_base_initialize(struct Backend_base *base) {
 
 inline void backend_base_finalize(struct Backend_base *base) {
   runqueue_finalize(&base->runqueue);
+  runqueue_finalize(&base->parked_runqueue);
 }
 
 inline void backend_base_mark(struct Backend_base *base) {
   if (base->idle_proc != Qnil) rb_gc_mark(base->idle_proc);
   if (base->trace_proc != Qnil) rb_gc_mark(base->trace_proc);
   runqueue_mark(&base->runqueue);
+  runqueue_mark(&base->parked_runqueue);
+}
+
+void backend_base_reset(struct Backend_base *base) {
+  runqueue_finalize(&base->runqueue);
+  runqueue_finalize(&base->parked_runqueue);
+  
+  runqueue_initialize(&base->runqueue);
+  runqueue_initialize(&base->parked_runqueue);
+
+  base->currently_polling = 0;
+  base->op_count = 0;
+  base->switch_count = 0;
+  base->poll_count = 0;
+  base->pending_count = 0;
+  base->idle_gc_period = 0;
+  base->idle_gc_last_time = 0;
+  base->idle_proc = Qnil;
+  base->trace_proc = Qnil;  
 }
 
 const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
@@ -91,7 +112,10 @@ void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_bas
 
   COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
 
-  (prioritize ? runqueue_unshift : runqueue_push)(&base->runqueue, fiber, value, already_runnable);
+  runqueue_t *runqueue = rb_ivar_get(fiber, ID_ivar_parked) == Qtrue ? 
+    &base->parked_runqueue : &base->runqueue;
+
+  (prioritize ? runqueue_unshift : runqueue_push)(runqueue, fiber, value, already_runnable);
   if (!already_runnable) {
     rb_ivar_set(fiber, ID_ivar_runnable, Qtrue);
     if (rb_thread_current() != thread) {
@@ -105,6 +129,13 @@ void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_bas
   }
 }
 
+inline void backend_base_park_fiber(struct Backend_base *base, VALUE fiber) {
+  runqueue_migrate(&base->runqueue, &base->parked_runqueue, fiber);
+}
+
+inline void backend_base_unpark_fiber(struct Backend_base *base, VALUE fiber) {
+  runqueue_migrate(&base->parked_runqueue, &base->runqueue, fiber);
+}
 
 inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
   if (base->trace_proc == Qnil) return;

data/ext/polyphony/backend_common.h

@@ -17,6 +17,7 @@ struct backend_stats {
 
 struct Backend_base {
   runqueue_t runqueue;
+  runqueue_t parked_runqueue;
   unsigned int currently_polling;
   unsigned int op_count;
   unsigned int switch_count;
@@ -31,8 +32,11 @@ struct Backend_base {
 void backend_base_initialize(struct Backend_base *base);
 void backend_base_finalize(struct Backend_base *base);
 void backend_base_mark(struct Backend_base *base);
+void backend_base_reset(struct Backend_base *base);
 VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base);
 void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_base *base, VALUE fiber, VALUE value, int prioritize);
+void backend_base_park_fiber(struct Backend_base *base, VALUE fiber);
+void backend_base_unpark_fiber(struct Backend_base *base, VALUE fiber);
 void backend_trace(struct Backend_base *base, int argc, VALUE *argv);
 struct backend_stats backend_base_stats(struct Backend_base *base);
 
@@ -104,7 +108,6 @@ VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
 VALUE Backend_stats(VALUE self);
 void backend_run_idle_tasks(struct Backend_base *base);
 void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking);
-
 void backend_setup_stats_symbols();
 
 #endif /* BACKEND_COMMON_H */

data/ext/polyphony/backend_io_uring.c

@@ -106,9 +106,7 @@ VALUE Backend_post_fork(VALUE self) {
   io_uring_queue_exit(&backend->ring);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
   context_store_free(&backend->store);
-  backend->base.currently_polling = 0;
-  backend->base.pending_count = 0;
-  backend->pending_sqes = 0;
+  backend_base_reset(&backend->base);
 
   return self;
 }
@@ -229,7 +227,7 @@ inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  runqueue_delete(&backend->base.runqueue, fiber);  
+  runqueue_delete(&backend->base.runqueue, fiber);
 }
 
 inline VALUE Backend_switch_fiber(VALUE self) {
@@ -1248,7 +1246,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     }
     
     io_uring_sqe_set_data(last_sqe, ctx);
-    unsigned int flags = (i == argc - 1) ? IOSQE_ASYNC : IOSQE_ASYNC & IOSQE_IO_LINK;
+    unsigned int flags = (i == (argc - 1)) ? IOSQE_ASYNC : IOSQE_ASYNC | IOSQE_IO_LINK;
     io_uring_sqe_set_flags(last_sqe, flags);
     sqe_count++;
   }
@@ -1474,6 +1472,20 @@ VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
   return self;
 }
 
+void Backend_park_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_park_fiber(&backend->base, fiber);
+}
+
+void Backend_unpark_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_unpark_fiber(&backend->base, fiber);
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);

data/ext/polyphony/backend_libev.c

@@ -157,6 +157,8 @@ VALUE Backend_post_fork(VALUE self) {
   ev_loop_destroy(backend->ev_loop);
   backend->ev_loop = EV_DEFAULT;
 
+  backend_base_reset(&backend->base);
+
   return self;
 }
 
@@ -1553,6 +1555,20 @@ VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
   return self;
 }
 
+void Backend_park_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_park_fiber(&backend->base, fiber);
+}
+
+void Backend_unpark_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_unpark_fiber(&backend->base, fiber);
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);