polyphony 0.60 → 0.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 515e9a5686bb0eedb02ad626e491b3e8acb350a765a468029e0b5357673f443c
-  data.tar.gz: 94fd7eaedd37c01f1ebc33ba78ffb00d3e8fc42f4a0266bf63ba8eedb83d008c
+  metadata.gz: b7056ec954b2264a15f88934d2b1e65f53c76c301453851ceadf60715570e474
+  data.tar.gz: 1cd5835b7a5a3d4036e1eabf45ded2e09efdc7cacb207fc0a1a60ac67da02d90
 SHA512:
-  metadata.gz: a546bcf43f556dc7d6bbc3c04b9448141a539e91d2d893441a161eecf9246ff516a54cf94cae476ef9358470e5475c98577c807fd1cef1f712f342337d3c8cc8
-  data.tar.gz: e0bb07cc0028c3205f3c2d87a59699e35e3d4d0e797eff63258892475548086125ed40e63152c56253a1c596b680eacc7080bf08f7d152576c34dc57df0206ab
+  metadata.gz: b5e32edc6bc22ba580e7c6d7d42a73982803080e9a9782326cb7b8796aa62ad6b75bccb1e6607879f0d3e5a5c4db8e5597d8407b76014f08f3945d1d8ad0097a
+  data.tar.gz: b8fe0f9419061295f830ed12ae9c8ea089a966686388cff580ddb6e1f7cd8c17a04928f9af41083019a5a11e8cccce25af404959db30a730a2ade2359a7e07ef

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.61 2021-07-20
+
+- Add more statistics, move stats to `Backend#stats`
+
 ## 0.60 2021-07-15
 
 

data/Gemfile.lock

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

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,8 +28,10 @@ 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 (runqueue_should_poll_nonblocking(&base->runqueue) || next == current) 
+  if ((base->switch_count % ANTI_STARVE_SWITCH_COUNT_THRESHOLD) == 0 || next == current) 
     Backend_poll(backend, Qnil);
 }
 
@@ -36,7 +41,8 @@ VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
   unsigned int pending_ops_count = base->pending_count;
   unsigned int backend_was_polled = 0;
   unsigned int idle_tasks_run_count = 0;
-
+  
+  base->switch_count++;
   COND_TRACE(base, 2, SYM_fiber_switchpoint, current_fiber);
 
   while (1) {
@@ -106,6 +112,22 @@ inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
   rb_funcallv(base->trace_proc, ID_call, argc, argv);
 }
 
+inline struct backend_stats backend_base_stats(struct Backend_base *base) {
+  struct backend_stats stats = {
+    .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;
+}
+
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 #ifndef __NR_pidfd_open
 #define __NR_pidfd_open 434   /* System call # on most architectures */
@@ -289,3 +311,40 @@ inline void backend_run_idle_tasks(struct Backend_base *base) {
   rb_gc_start();
   rb_gc_disable();
 }
+
+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_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_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_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,13 +6,20 @@
 #include "runqueue.h"
 
 struct backend_stats {
-  int scheduled_fibers;
-  int pending_ops;
+  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;
@@ -26,6 +33,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)
@@ -59,6 +67,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();
 
@@ -91,7 +100,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,6 +191,8 @@ 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);
@@ -234,14 +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),
-    .pending_ops = backend->base.pending_count
-  };
+  return backend_base_stats(&backend->base);
 }
 
 VALUE Backend_wakeup(VALUE self) {
@@ -279,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);
@@ -1043,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);
@@ -1210,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);
@@ -1346,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) {
@@ -1355,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;
     
@@ -1367,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);
@@ -1385,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);
@@ -1430,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);
@@ -1469,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

data/ext/polyphony/backend_libev.c

@@ -164,6 +164,8 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   Backend_t *backend;
   GetBackend(self, backend);
 
+  backend->base.poll_count++;
+
   COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
   backend->base.currently_polling = 1;
   ev_run(backend->ev_loop, blocking == Qtrue ? EVRUN_ONCE : EVRUN_NOWAIT);
@@ -211,14 +213,11 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
-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),
-    .pending_ops = backend->base.pending_count
-  };
+  return backend_base_stats(&backend->base);
 }
 
 struct libev_io {
@@ -289,6 +288,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   OBJ_TAINT(str);
 
   while (1) {
+    backend->base.op_count++;
     ssize_t n = read(fptr->fd, buf, len - total);
     if (n < 0) {
       int e = errno;
@@ -359,6 +359,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   watcher.fiber = Qnil;
 
   while (1) {
+    backend->base.op_count++;
     ssize_t n = read(fptr->fd, buf, len);
     if (n < 0) {
       int e = errno;
@@ -411,6 +412,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   watcher.fiber = Qnil;
 
   while (1) {
+    backend->base.op_count++;
     ssize_t n = read(fptr->fd, buf, len);
     if (n < 0) {
       int e = errno;
@@ -458,6 +460,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   watcher.fiber = Qnil;
 
   while (left > 0) {
+    backend->base.op_count++;
     ssize_t n = write(fptr->fd, buf, left);
     if (n < 0) {
       int e = errno;
@@ -517,6 +520,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   iov_ptr = iov;
 
   while (1) {
+    backend->base.op_count++;
     ssize_t n = writev(fptr->fd, iov_ptr, iov_count);
     if (n < 0) {
       int e = errno;
@@ -588,6 +592,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   io_verify_blocking_mode(fptr, server_socket, Qfalse);
   watcher.fiber = Qnil;
   while (1) {
+    backend->base.op_count++;
     fd = accept(fptr->fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
@@ -646,6 +651,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   watcher.fiber = Qnil;
 
   while (1) {
+    backend->base.op_count++;
     fd = accept(fptr->fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
@@ -705,6 +711,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   addr.sin_addr.s_addr = inet_addr(host_buf);
   addr.sin_port = htons(NUM2INT(port));
 
+  backend->base.op_count++;
   int result = connect(fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
   if (result < 0) {
     int e = errno;
@@ -745,6 +752,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   watcher.fiber = Qnil;
 
   while (left > 0) {
+    backend->base.op_count++;
     ssize_t n = send(fptr->fd, buf, left, flags_int);
     if (n < 0) {
       int e = errno;
@@ -852,6 +860,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   watcher.ctx.fiber = Qnil;
   while (1) {
+    backend->base.op_count++;
     len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
@@ -903,6 +912,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   watcher.ctx.fiber = Qnil;
   while (1) {
+    backend->base.op_count++;
     len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
@@ -962,6 +972,7 @@ VALUE Backend_fake_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   watcher.fiber = Qnil;
   
   while (1) {
+    backend->base.op_count++;
     ssize_t n = read(src_fptr->fd, buf, len);
     if (n < 0) {
       int e = errno;
@@ -977,6 +988,7 @@ VALUE Backend_fake_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   }
 
   while (left > 0) {
+    backend->base.op_count++;
     ssize_t n = write(dest_fptr->fd, buf, left);
     if (n < 0) {
       int e = errno;
@@ -1037,6 +1049,7 @@ VALUE Backend_fake_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen
   while (1) { 
     char *ptr = buf;
     while (1) {
+      backend->base.op_count++;
       ssize_t n = read(src_fptr->fd, ptr, len);
       if (n < 0) {
         int e = errno;
@@ -1054,6 +1067,7 @@ VALUE Backend_fake_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen
     }
 
     while (left > 0) {
+      backend->base.op_count++;
       ssize_t n = write(dest_fptr->fd, ptr, left);
       if (n < 0) {
         int e = errno;
@@ -1093,6 +1107,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   GetBackend(self, backend);
   GetOpenFile(io, fptr);
 
+  backend->base.op_count++;
   return libev_wait_fd(backend, fptr->fd, events, 1);
 }
 
@@ -1116,6 +1131,7 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
   watcher.fiber = rb_fiber_current();
   ev_timer_init(&watcher.timer, Backend_timer_callback, NUM2DBL(duration), 0.);
   ev_timer_start(backend->ev_loop, &watcher.timer);
+  backend->base.op_count++;
 
   switchpoint_result = backend_await((struct Backend_base *)backend);
 
@@ -1145,6 +1161,7 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     VALUE switchpoint_result = Qnil;    
     ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
     ev_timer_start(backend->ev_loop, &watcher.timer);
+    backend->base.op_count++;
     switchpoint_result = backend_await((struct Backend_base *)backend);
     ev_timer_stop(backend->ev_loop, &watcher.timer);
     RAISE_IF_EXCEPTION(switchpoint_result);
@@ -1196,6 +1213,7 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
   watcher.resume_value = timeout;
   ev_timer_init(&watcher.timer, Backend_timeout_callback, NUM2DBL(duration), 0.);
   ev_timer_start(backend->ev_loop, &watcher.timer);
+  backend->base.op_count++;
 
   struct Backend_timeout_ctx timeout_ctx = {backend, &watcher};
   result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
@@ -1218,6 +1236,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   if (fd >= 0) {
     Backend_t *backend;
     GetBackend(self, backend);
+    backend->base.op_count++;
 
     VALUE resume_value = libev_wait_fd(backend, fd, EV_READ, 0);
     close(fd);
@@ -1261,6 +1280,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   watcher.fiber = rb_fiber_current();
   ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
   ev_child_start(backend->ev_loop, &watcher.child);
+  backend->base.op_count++;
 
   switchpoint_result = backend_await((struct Backend_base *)backend);
 
@@ -1283,6 +1303,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
 
   ev_async_init(&async, Backend_async_callback);
   ev_async_start(backend->ev_loop, &async);
+  backend->base.op_count++;
 
   switchpoint_result = backend_await((struct Backend_base *)backend);
 
@@ -1346,6 +1367,7 @@ inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct lib
   int len = RSTRING_LEN(str);
   int left = len;
   while (left > 0) {
+    backend->base.op_count++;
     ssize_t n = write(fd, buf, left);
     if (n < 0) {
       int err = errno;
@@ -1406,6 +1428,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     int chunk_len;
     // splice to pipe
     while (1) {
+      backend->base.op_count++;
       chunk_len = splice(src_fptr->fd, 0, pipefd[1], 0, maxlen, 0);
       if (chunk_len < 0) {
         err = errno;
@@ -1431,6 +1454,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     int left = chunk_len;
     while (1) {
+      backend->base.op_count++;
       int n = splice(pipefd[0], 0, dest_fptr->fd, 0, left, 0);
       if (n < 0) {
         err = errno;
@@ -1503,6 +1527,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);
@@ -1545,6 +1570,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_LIBEV

data/ext/polyphony/polyphony.h

@@ -114,7 +114,6 @@ VALUE Backend_wakeup(VALUE self);
 VALUE Backend_run_idle_tasks(VALUE self);
 VALUE Backend_switch_fiber(VALUE self);
 void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize);
-struct backend_stats Backend_stats(VALUE self);
 void Backend_unschedule_fiber(VALUE self, VALUE fiber);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);

data/ext/polyphony/runqueue.c

@@ -4,7 +4,6 @@
 inline void runqueue_initialize(runqueue_t *runqueue) {
   runqueue_ring_buffer_init(&runqueue->entries);
   runqueue->high_watermark = 0;
-  runqueue->switch_count = 0;
 }
 
 inline void runqueue_finalize(runqueue_t *runqueue) {
@@ -30,12 +29,7 @@ inline void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int
 }
 
 inline runqueue_entry runqueue_shift(runqueue_t *runqueue) {
-  runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
-  if (entry.fiber == Qnil)
-    runqueue->high_watermark = 0;
-  else
-    runqueue->switch_count += 1;
-  return entry;
+  return runqueue_ring_buffer_shift(&runqueue->entries);
 }
 
 inline void runqueue_delete(runqueue_t *runqueue, VALUE fiber) {
@@ -54,15 +48,12 @@ inline long runqueue_len(runqueue_t *runqueue) {
   return runqueue->entries.count;
 }
 
-inline int runqueue_empty_p(runqueue_t *runqueue) {
-  return (runqueue->entries.count == 0);
+inline long runqueue_max_len(runqueue_t *runqueue) {
+  unsigned int max_len = runqueue->high_watermark;
+  runqueue->high_watermark = 0;
+  return max_len;
 }
 
-static const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
-
-inline int runqueue_should_poll_nonblocking(runqueue_t *runqueue) {
-  if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
-
-  runqueue->switch_count = 0;
-  return 1;
+inline int runqueue_empty_p(runqueue_t *runqueue) {
+  return (runqueue->entries.count == 0);
 }

data/ext/polyphony/runqueue.h

@@ -7,7 +7,6 @@
 typedef struct runqueue {
   runqueue_ring_buffer entries;
   unsigned int high_watermark;
-  unsigned int switch_count;
 } runqueue_t;
 
 void runqueue_initialize(runqueue_t *runqueue);
@@ -21,7 +20,7 @@ void runqueue_delete(runqueue_t *runqueue, VALUE fiber);
 int runqueue_index_of(runqueue_t *runqueue, VALUE fiber);
 void runqueue_clear(runqueue_t *runqueue);
 long runqueue_len(runqueue_t *runqueue);
+long runqueue_max_len(runqueue_t *runqueue);
 int runqueue_empty_p(runqueue_t *runqueue);
-int runqueue_should_poll_nonblocking(runqueue_t *runqueue);
 
 #endif /* RUNQUEUE_H */

data/ext/polyphony/thread.c

@@ -13,18 +13,6 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   return self;
 }
 
-static VALUE SYM_scheduled_fibers;
-static VALUE SYM_pending_watchers;
-
-static VALUE Thread_fiber_scheduling_stats(VALUE self) {
-  struct backend_stats backend_stats = Backend_stats(rb_ivar_get(self, ID_ivar_backend));
-
-  VALUE stats = rb_hash_new();
-  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(backend_stats.scheduled_fibers));
-  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(backend_stats.pending_ops));
-  return stats;
-}
-
 inline void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
   Backend_schedule_fiber(self, rb_ivar_get(self, ID_ivar_backend), fiber, value, prioritize);
 }
@@ -72,7 +60,6 @@ VALUE Thread_class_backend(VALUE _self) {
 
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
-  rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
   rb_define_method(rb_cThread, "schedule_and_wakeup", Thread_fiber_schedule_and_wakeup, 2);
 
   rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
@@ -91,9 +78,4 @@ void Init_Thread() {
   ID_ivar_main_fiber                    = rb_intern("@main_fiber");
   ID_ivar_terminated                    = rb_intern("@terminated");
   ID_stop                               = rb_intern("stop");
-
-  SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
-  SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));
-  rb_global_variable(&SYM_scheduled_fibers);
-  rb_global_variable(&SYM_pending_watchers);
 }

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.60'
+  VERSION = '0.61'
 end

data/test/test_backend.rb

@@ -26,7 +26,7 @@ class BackendTest < MiniTest::Test
       @backend.sleep 0.01
       count += 1
     }.await
-    assert_in_delta 0.03, Time.now - t0, 0.01
+    assert_in_range 0.02..0.04, Time.now - t0
     assert_equal 3, count
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.60'
+  version: '0.61'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2021-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -419,7 +419,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Fine grained concurrency for Ruby