polyphony 0.59 → 0.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 313e33321df0e375d128a79fccfab98e06183adbdbde7916347f6795f56ca369
-  data.tar.gz: 6428c0516544bdb955fa465bf36c40b9b2f162306f3e5689848ff487f24c4440
+  metadata.gz: 2cea172818871812ebbafcbee0a4b98d130a351f904d7732a02400ef363eac62
+  data.tar.gz: f4ef85515436a463d3732f04bbef457426f267fac01f5c5c28619e42334cd745
 SHA512:
-  metadata.gz: 40c88f5d1c2aa4307dea78dcf1a2ba8d347ef252e7e56e67d466c291066d39544d051864ccd0138dd94ca0beef7af71f5257052b3556ab0c7294b1b94b517d47
-  data.tar.gz: 109410d6b222846b0c2b3f54061358ef922b57c9b6559c37aec36f27116e7ca389ff51762e988e2e9293a7a1358d97b80ada74daa4e44d7d25c1e5335351d8c6
+  metadata.gz: 489b813f1bb2d7d97f87a60024b0665761571c4227e4fab6c733dcdb62b6ee98760473202c9154eb39a4b544663f759e4da6e70603d483e9f2ec2a64363cd4e1
+  data.tar.gz: 05b232d7d67120e0983e60855c928beac6e91271fafc87586da7cc7543128fe326be04d126154ac7e0b0c0b249bf41ca90ab902f79f4a5fbf00cad498061f7e7

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.62 2021-07-21
+
+- Add `runqueue_size` to backend stats
+
+## 0.61 2021-07-20
+
+- Add more statistics, move stats to `Backend#stats`
+
+## 0.60 2021-07-15
+
+
+- Fix linux version detection (for kernel version > 5.9)
+- Fix op ctx leak in io_uring backend (when polling for I/O readiness)
+- Add support for appending to buffer in `Backend#read`, `Backend#recv` methods
+- Improve anti-event starvation mechanism
+- Redesign fiber monitoring mechanism
+- Implement `Fiber#attach`
+- Add optional maxlen argument to `IO#read_loop`, `Socket#recv_loop` (#60)
+- Implement `Fiber#detach` (#52)
+
+## 0.59.1 2021-06-28
+
+- Accept fiber tag in `Polyphony::Timer.new`
+
 ## 0.59 2021-06-28
 
 - Redesign tracing mechanism and API - now completely separated from Ruby core

data/Gemfile.lock

@@ -1,27 +1,25 @@
 PATH
   remote: .
   specs:
-    polyphony (0.59)
+    polyphony (0.62)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ansi (1.5.0)
-    ast (2.4.0)
+    ast (2.4.2)
     builder (3.2.4)
     coderay (1.1.3)
-    docile (1.3.2)
-    hiredis (0.6.3)
-    http_parser.rb (0.6.0)
+    docile (1.4.0)
     httparty (0.17.1)
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
-    json (2.3.0)
+    json (2.5.1)
     localhost (1.1.8)
     method_source (1.0.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2020.0512)
+    mime-types-data (3.2021.0704)
     minitest (5.14.4)
     minitest-reporters (1.4.2)
       ansi
@@ -30,22 +28,18 @@ GEM
       ruby-progressbar
     msgpack (1.4.2)
     multi_xml (0.6.0)
-    mysql2 (0.5.3)
-    parallel (1.19.1)
-    parser (2.7.0.2)
-      ast (~> 2.4.0)
-    pg (1.1.4)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    rack (2.2.3)
     rainbow (3.0.0)
-    rake (13.0.3)
+    rake (13.0.6)
     rake-compiler (1.1.1)
       rake
-    redis (4.1.0)
-    regexp_parser (1.7.1)
-    rexml (3.2.4)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
     rubocop (0.85.1)
       parallel (~> 1.10)
       parser (>= 2.7.0.1)
@@ -55,37 +49,29 @@ GEM
       rubocop-ast (>= 0.0.3)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (0.0.3)
-      parser (>= 2.7.0.1)
-    ruby-progressbar (1.10.1)
-    sequel (5.34.0)
+    rubocop-ast (1.8.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
     simplecov (0.17.1)
       docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
-    unicode-display_width (1.6.1)
+    unicode-display_width (1.7.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  hiredis (= 0.6.3)
-  http_parser.rb (~> 0.6.0)
   httparty (= 0.17.1)
   localhost (~> 1.1.4)
   minitest (= 5.14.4)
   minitest-reporters (= 1.4.2)
   msgpack (= 1.4.2)
-  mysql2 (= 0.5.3)
-  pg (= 1.1.4)
   polyphony!
   pry (= 0.13.1)
-  rack (>= 2.0.8, < 2.3.0)
   rake-compiler (= 1.1.1)
-  redis (= 4.1.0)
   rubocop (= 0.85.1)
-  sequel (= 5.34.0)
   simplecov (= 0.17.1)
 
 BUNDLED WITH

data/examples/core/message_based_supervision.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+class Supervisor
+  def initialize(*fibers)
+    @fiber = spin { do_supervise }
+    @fiber.message_on_child_termination = true
+    fibers.each { |f| add(f) }
+  end
+
+  def await
+    @fiber.await
+  end
+
+  def spin(tag = nil, &block)
+    @fiber.spin(tag, &block)
+  end
+
+  def add(fiber)
+    fiber.attach(@fiber)
+  end
+
+  def do_supervise
+    loop do
+      msg = receive
+      # puts "Supervisor received #{msg.inspect}"
+      f, r = msg
+      puts "Fiber #{f.tag} terminated with #{r.inspect}, restarting..."
+      f.restart
+    end
+  end
+end
+
+def supervise(*fibers)
+  supervisor = Supervisor.new(*fibers)
+  supervisor.await
+end
+
+def start_worker(id)
+  spin_loop(:"worker#{id}") do
+    duration = rand(0.5..1.0)
+    puts "Worker #{id} sleeping for #{duration} seconds"
+    sleep duration
+    raise 'foo' if rand > 0.7
+    break if rand > 0.6
+  end  
+end
+
+supervise(start_worker(1), start_worker(2))

data/examples/io/echo_server.rb

@@ -3,16 +3,25 @@
 require 'bundler/setup'
 require 'polyphony'
 
+spin_loop(interval: 5) { p Thread.backend.stats }
+
 server = TCPServer.open('127.0.0.1', 1234)
 puts "Pid: #{Process.pid}"
 puts 'Echoing on port 1234...'
-while (client = server.accept)
-  spin do
-    while (data = client.gets)
-      # client.send("you said: #{data.chomp}!\n", 0)
-      client.write('you said: ', data.chomp, "!\n")
+begin
+  while (client = server.accept)
+    spin do
+      while (data = client.gets)
+        # client.send("you said: #{data.chomp}!\n", 0)
+        client.write('you said: ', data.chomp, "!\n")
+      end
+    rescue Errno::ECONNRESET
+      'Connection reset...'
+    ensure
+      client.shutdown
+      client.close
     end
-  rescue Errno::ECONNRESET
-    'Connection reset...'
   end
+ensure
+  server.close
 end

data/ext/polyphony/backend_common.c

@@ -8,6 +8,9 @@
 inline void backend_base_initialize(struct Backend_base *base) {
   runqueue_initialize(&base->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;
@@ -25,33 +28,37 @@ inline void backend_base_mark(struct Backend_base *base) {
   runqueue_mark(&base->runqueue);
 }
 
+const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
+
+inline void conditional_nonblocking_poll(VALUE backend, struct Backend_base *base, VALUE current, VALUE next) {
+  if ((base->switch_count % ANTI_STARVE_SWITCH_COUNT_THRESHOLD) == 0 || next == current) 
+    Backend_poll(backend, Qnil);
+}
+
 VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
   VALUE current_fiber = rb_fiber_current();
   runqueue_entry next;
   unsigned int pending_ops_count = base->pending_count;
   unsigned int backend_was_polled = 0;
   unsigned int idle_tasks_run_count = 0;
-
-  if (SHOULD_TRACE(base) && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
-    TRACE(base, 2, SYM_fiber_switchpoint, current_fiber);
+  
+  base->switch_count++;
+  COND_TRACE(base, 2, SYM_fiber_switchpoint, current_fiber);
 
   while (1) {
     next = runqueue_shift(&base->runqueue);
     if (next.fiber != Qnil) {
       // Polling for I/O op completion is normally done when the run queue is
       // empty, but if the runqueue never empties, we'll never get to process
-      // any event completions. In order to prevent this, an anti-starve
+      // any event completions. In order to prevent this, an anti-starvation
       // mechanism is employed, under the following conditions:
       // - a blocking poll was not yet performed
       // - there are pending blocking operations
-      // - the runqueue has signalled that a non-blocking poll should be
-      //   performed
-      //   - the run queue length high watermark has reached its threshold (currently 128)
-      //   - the run queue switch counter has reached its threshold (currently 64) 
-      if (!backend_was_polled && pending_ops_count && runqueue_should_poll_nonblocking(&base->runqueue)) {
-        // this prevents event starvation in case the run queue never empties
-        Backend_poll(backend, Qnil);
-      }
+      // - the runqueue shift count has reached a fixed threshold (currently 64), or
+      // - the next fiber is the same as the current fiber (a single fiber is snoozing)
+      if (!backend_was_polled && pending_ops_count)
+        conditional_nonblocking_poll(backend, base, current_fiber, next.fiber);
+
       break;
     }
     
@@ -82,7 +89,8 @@ void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_bas
   if (rb_fiber_alive_p(fiber) != Qtrue) return;
   already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
 
-  COND_TRACE(base, 3, SYM_fiber_schedule, fiber, value);
+  COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
+
   (prioritize ? runqueue_unshift : runqueue_push)(&base->runqueue, fiber, value, already_runnable);
   if (!already_runnable) {
     rb_ivar_set(fiber, ID_ivar_runnable, Qtrue);
@@ -171,7 +179,7 @@ inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-VALUE backend_await(struct Backend_base *backend) {
+inline VALUE backend_await(struct Backend_base *backend) {
   VALUE ret;
   backend->pending_count++;
   ret = Thread_switch_fiber(rb_thread_current());
@@ -180,9 +188,10 @@ VALUE backend_await(struct Backend_base *backend) {
   return ret;
 }
 
-VALUE backend_snooze() {
+inline VALUE backend_snooze() {
+  VALUE ret;
   Fiber_make_runnable(rb_fiber_current(), Qnil);
-  VALUE ret = Thread_switch_fiber(rb_thread_current());
+  ret = Thread_switch_fiber(rb_thread_current());
   return ret;
 }
 
@@ -286,3 +295,61 @@ inline void backend_run_idle_tasks(struct Backend_base *base) {
   rb_gc_start();
   rb_gc_disable();
 }
+
+inline struct backend_stats backend_base_stats(struct Backend_base *base) {
+  struct backend_stats stats = {
+    .runqueue_size = runqueue_size(&base->runqueue),
+    .runqueue_length = runqueue_len(&base->runqueue),
+    .runqueue_max_length = runqueue_max_len(&base->runqueue),
+    .op_count = base->op_count,
+    .switch_count = base->switch_count,
+    .poll_count = base->poll_count,
+    .pending_ops = base->pending_count
+  };
+
+  base->op_count = 0;
+  base->switch_count = 0;
+  base->poll_count = 0;
+  return stats;
+}
+
+VALUE SYM_runqueue_size;
+VALUE SYM_runqueue_length;
+VALUE SYM_runqueue_max_length;
+VALUE SYM_op_count;
+VALUE SYM_switch_count;
+VALUE SYM_poll_count;
+VALUE SYM_pending_ops;
+
+VALUE Backend_stats(VALUE self) {
+  struct backend_stats backend_stats = backend_get_stats(self);
+
+  VALUE stats = rb_hash_new();
+  rb_hash_aset(stats, SYM_runqueue_size, INT2NUM(backend_stats.runqueue_size));
+  rb_hash_aset(stats, SYM_runqueue_length, INT2NUM(backend_stats.runqueue_length));
+  rb_hash_aset(stats, SYM_runqueue_max_length, INT2NUM(backend_stats.runqueue_max_length));
+  rb_hash_aset(stats, SYM_op_count, INT2NUM(backend_stats.op_count));
+  rb_hash_aset(stats, SYM_switch_count, INT2NUM(backend_stats.switch_count));
+  rb_hash_aset(stats, SYM_poll_count, INT2NUM(backend_stats.poll_count));
+  rb_hash_aset(stats, SYM_pending_ops, INT2NUM(backend_stats.pending_ops));
+  RB_GC_GUARD(stats);
+  return stats;
+}
+
+void backend_setup_stats_symbols() {
+  SYM_runqueue_size       = ID2SYM(rb_intern("runqueue_size"));
+  SYM_runqueue_length     = ID2SYM(rb_intern("runqueue_length"));
+  SYM_runqueue_max_length = ID2SYM(rb_intern("runqueue_max_length"));
+  SYM_op_count            = ID2SYM(rb_intern("op_count"));
+  SYM_switch_count        = ID2SYM(rb_intern("switch_count"));
+  SYM_poll_count          = ID2SYM(rb_intern("poll_count"));
+  SYM_pending_ops         = ID2SYM(rb_intern("pending_ops"));
+  
+  rb_global_variable(&SYM_runqueue_size);
+  rb_global_variable(&SYM_runqueue_length);
+  rb_global_variable(&SYM_runqueue_max_length);
+  rb_global_variable(&SYM_op_count);
+  rb_global_variable(&SYM_switch_count);
+  rb_global_variable(&SYM_poll_count);
+  rb_global_variable(&SYM_pending_ops);
+}

data/ext/polyphony/backend_common.h

@@ -6,14 +6,21 @@
 #include "runqueue.h"
 
 struct backend_stats {
-  int scheduled_fibers;
-  int waiting_fibers;
-  int pending_ops;
+  unsigned int runqueue_size;
+  unsigned int runqueue_length;
+  unsigned int runqueue_max_length;
+  unsigned int op_count;
+  unsigned int switch_count;
+  unsigned int poll_count;
+  unsigned int pending_ops;
 };
 
 struct Backend_base {
   runqueue_t runqueue;
   unsigned int currently_polling;
+  unsigned int op_count;
+  unsigned int switch_count;
+  unsigned int poll_count;
   unsigned int pending_count;
   double idle_gc_period;
   double idle_gc_last_time;
@@ -27,6 +34,7 @@ void backend_base_mark(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_trace(struct Backend_base *base, int argc, VALUE *argv);
+struct backend_stats backend_base_stats(struct Backend_base *base);
 
 // tracing
 #define SHOULD_TRACE(base) ((base)->trace_proc != Qnil)
@@ -60,6 +68,7 @@ VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
+struct backend_stats backend_get_stats(VALUE self);
 VALUE backend_await(struct Backend_base *backend);
 VALUE backend_snooze();
 
@@ -92,7 +101,10 @@ VALUE backend_timeout_exception(VALUE exception);
 VALUE Backend_timeout_ensure_safe(VALUE arg);
 VALUE Backend_timeout_ensure_safe(VALUE arg);
 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

@@ -191,12 +191,23 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   Backend_t *backend;
   GetBackend(self, backend);
 
+  backend->base.poll_count++;
+
   if (!is_blocking && backend->pending_sqes) {
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
   }
 
   COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
+  // if (SHOULD_TRACE(&backend->base))
+  //   printf(
+  //     "io_uring_poll(blocking_mode: %d, pending: %d, taken: %d, available: %d, runqueue: %d\n",
+  //     is_blocking,
+  //     backend->base.pending_count,
+  //     backend->store.taken_count,
+  //     backend->store.available_count,
+  //     backend->base.runqueue.entries.count
+  //   );
   if (is_blocking) io_uring_backend_poll(backend);
   io_uring_backend_handle_ready_cqes(backend);
   COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
@@ -225,15 +236,11 @@ inline VALUE Backend_switch_fiber(VALUE self) {
   return backend_base_switch_fiber(self, &backend->base);
 }
 
-inline struct backend_stats Backend_stats(VALUE self) {
+inline struct backend_stats backend_get_stats(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return (struct backend_stats){
-    .scheduled_fibers = runqueue_len(&backend->base.runqueue),
-    .waiting_fibers = 0,
-    .pending_ops = backend->base.pending_count
-  };
+  return backend_base_stats(&backend->base);
 }
 
 VALUE Backend_wakeup(VALUE self) {
@@ -271,6 +278,7 @@ int io_uring_backend_defer_submit_and_await(
 {
   VALUE switchpoint_result = Qnil;
 
+  backend->base.op_count++;
   if (sqe) {
     io_uring_sqe_set_data(sqe, ctx);
     io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
@@ -302,17 +310,25 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
   io_uring_prep_poll_add(sqe, fd, write ? POLLOUT : POLLIN);
 
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resumed_value);
+  context_store_release(&backend->store, ctx);
+
   RB_GC_GUARD(resumed_value);
   return resumed_value;
 }
 
-VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
+VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
   long buffer_size = dynamic_len ? 4096 : NUM2INT(length);
-  int shrinkable = io_setstrbuf(&str, buffer_size);
-  char *buf = RSTRING_PTR(str);
+  long buf_pos = NUM2INT(pos);
+  if (str != Qnil) {
+    int current_len = RSTRING_LEN(str);
+    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  }
+  else buf_pos = 0;
+  int shrinkable = io_setstrbuf(&str, buf_pos + buffer_size);
+  char *buf = RSTRING_PTR(str) + buf_pos;
   long total = 0;
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
@@ -349,9 +365,9 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
         if (!dynamic_len) break;
 
         // resize buffer
-        rb_str_resize(str, total);
+        rb_str_resize(str, buf_pos + total);
         rb_str_modify_expand(str, buffer_size);
-        buf = RSTRING_PTR(str) + total;
+        buf = RSTRING_PTR(str) + buf_pos + total;
         shrinkable = 0;
         buffer_size += buffer_size;
       }
@@ -359,7 +375,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     }
   }
 
-  io_set_read_length(str, total, shrinkable);
+  io_set_read_length(str, buf_pos + total, shrinkable);
   io_enc_str(str, fptr);
 
   if (!total) return Qnil;
@@ -367,12 +383,12 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   return str;
 }
 
-VALUE Backend_read_loop(VALUE self, VALUE io) {
+VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = 8192;
+  long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
@@ -580,13 +596,19 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
     Backend_writev(self, argv[0], argc - 1, argv + 1);
 }
 
-VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
   long len = dynamic_len ? 4096 : NUM2INT(length);
-  int shrinkable = io_setstrbuf(&str, len);
-  char *buf = RSTRING_PTR(str);
+  long buf_pos = NUM2INT(pos);
+  if (str != Qnil) {
+    int current_len = RSTRING_LEN(str);
+    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  }
+  else buf_pos = 0;
+  int shrinkable = io_setstrbuf(&str, buf_pos + len);
+  char *buf = RSTRING_PTR(str) + buf_pos;
   long total = 0;
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
@@ -618,7 +640,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
     }
   }
 
-  io_set_read_length(str, total, shrinkable);
+  io_set_read_length(str, buf_pos + total, shrinkable);
   io_enc_str(str, fptr);
 
   if (!total) return Qnil;
@@ -626,12 +648,12 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
   return str;
 }
 
-VALUE Backend_recv_loop(VALUE self, VALUE io) {
+VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = 8192;
+  long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
@@ -1021,6 +1043,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
   io_uring_backend_defer_submit(backend);
+  backend->base.op_count++;
 
   struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
   result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
@@ -1188,6 +1211,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     sqe_count++;
   }
 
+  backend->base.op_count += sqe_count;
   ctx->ref_count = sqe_count + 1;
   io_uring_backend_defer_submit(backend);
   resume_value = backend_await((struct Backend_base *)backend);
@@ -1324,6 +1348,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   if (prefix != Qnil) {
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
     splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, prefix);
+    backend->base.op_count++;
   }
 
   while (1) {
@@ -1333,7 +1358,8 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
     splice_chunks_prep_splice(ctx, sqe, src_fptr->fd, pipefd[1], maxlen);
-    
+    backend->base.op_count++;
+
     SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
     if (chunk_len == 0) break;
     
@@ -1345,15 +1371,18 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
       chunk_prefix_str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
       splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
       splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_prefix_str);
+      backend->base.op_count++;
     }
 
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
     splice_chunks_prep_splice(ctx, sqe, pipefd[0], dest_fptr->fd, chunk_len);
+    backend->base.op_count++;
 
     if (chunk_postfix != Qnil) {
       chunk_postfix_str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
       splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
       splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_postfix_str);
+      backend->base.op_count++;
     }
 
     RB_GC_GUARD(chunk_prefix_str);
@@ -1363,6 +1392,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   if (postfix != Qnil) {
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
     splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, postfix);
+    backend->base.op_count++;
   }
   if (ctx) {
     SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, 0, &switchpoint_result);
@@ -1408,6 +1438,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "post_fork", Backend_post_fork, 0);
   rb_define_method(cBackend, "trace", Backend_trace, -1);
   rb_define_method(cBackend, "trace_proc=", Backend_trace_proc_set, 1);
+  rb_define_method(cBackend, "stats", Backend_stats, 0);
 
   rb_define_method(cBackend, "poll", Backend_poll, 1);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
@@ -1421,11 +1452,11 @@ void Init_Backend() {
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
-  rb_define_method(cBackend, "read", Backend_read, 4);
-  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "recv", Backend_recv, 3);
+  rb_define_method(cBackend, "read", Backend_read, 5);
+  rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
+  rb_define_method(cBackend, "recv", Backend_recv, 4);
   rb_define_method(cBackend, "recv_feed_loop", Backend_recv_feed_loop, 3);
-  rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 1);
+  rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 2);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
@@ -1447,6 +1478,8 @@ void Init_Backend() {
   SYM_send = ID2SYM(rb_intern("send"));
   SYM_splice = ID2SYM(rb_intern("splice"));
   SYM_write = ID2SYM(rb_intern("write"));
+
+  backend_setup_stats_symbols();
 }
 
 #endif // POLYPHONY_BACKEND_LIBURING