polyphony 0.58 → 0.61

data/ext/polyphony/backend_io_uring.c

@@ -44,8 +44,12 @@ typedef struct Backend_t {
 
 static void Backend_mark(void *ptr) {
   Backend_t *backend = ptr;
-  if (backend->base.idle_block != Qnil)
-    rb_gc_mark(backend->base.idle_block);
+  backend_base_mark(&backend->base);
+}
+
+static void Backend_free(void *ptr) {
+  Backend_t *backend = ptr;
+  backend_base_finalize(&backend->base);
 }
 
 static size_t Backend_size(const void *ptr) {
@@ -54,7 +58,7 @@ static size_t Backend_size(const void *ptr) {
 
 static const rb_data_type_t Backend_type = {
     "IOUringBackend",
-    {Backend_mark, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -71,7 +75,7 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  initialize_backend_base(&backend->base);
+  backend_base_initialize(&backend->base);
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -106,13 +110,6 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-unsigned int Backend_pending_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->base.pending_count;
-}
-
 typedef struct poll_context {
   struct io_uring     *ring;
   struct io_uring_cqe *cqe;
@@ -189,24 +186,63 @@ void io_uring_backend_poll(Backend_t *backend) {
   io_uring_cqe_seen(&backend->ring, poll_ctx.cqe);
 }
 
-VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
-  int is_nowait = nowait == Qtrue;
+inline VALUE Backend_poll(VALUE self, VALUE blocking) {
+  int is_blocking = blocking == Qtrue;
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait && backend->pending_sqes) {
+  backend->base.poll_count++;
+
+  if (!is_blocking && backend->pending_sqes) {
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
   }
 
-  COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  if (!is_nowait) io_uring_backend_poll(backend);
+  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(2, SYM_fiber_event_poll_leave, current_fiber);
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
   
   return self;
 }
 
+inline void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_schedule_fiber(thread, self, &backend->base, fiber, value, prioritize);
+}
+
+inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  runqueue_delete(&backend->base.runqueue, fiber);  
+}
+
+inline VALUE Backend_switch_fiber(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_switch_fiber(self, &backend->base);
+}
+
+inline struct backend_stats backend_get_stats(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_stats(&backend->base);
+}
+
 VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -242,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);
@@ -273,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);
@@ -320,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;
       }
@@ -330,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;
@@ -338,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);
@@ -551,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);
 
@@ -589,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;
@@ -597,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);
@@ -992,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);
@@ -1159,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);
@@ -1187,10 +1240,10 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
-VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+VALUE Backend_idle_proc_set(VALUE self, VALUE block) {
   Backend_t *backend;
   GetBackend(self, backend);
-  backend->base.idle_block = block;
+  backend->base.idle_proc = block;
   return self;
 }
 
@@ -1295,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) {
@@ -1304,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;
     
@@ -1316,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);
@@ -1334,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);
@@ -1355,6 +1414,21 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_trace(&backend->base, argc, argv);
+  return self;
+}
+
+VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend->base.trace_proc = block;
+  return self;
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -1362,24 +1436,27 @@ void Init_Backend() {
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
   rb_define_method(cBackend, "finalize", Backend_finalize, 0);
   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, 3);
+  rb_define_method(cBackend, "poll", Backend_poll, 1);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
-  rb_define_method(cBackend, "idle_block=", Backend_idle_block_set, 1);
+  rb_define_method(cBackend, "idle_proc=", Backend_idle_proc_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   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);
@@ -1401,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_io_uring_context.c

@@ -25,6 +25,8 @@ void context_store_initialize(op_context_store_t *store) {
   store->last_id = 0;
   store->available = NULL;
   store->taken = NULL;
+  store->available_count = 0;
+  store->taken_count = 0;
 }
 
 inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_type type) {
@@ -32,12 +34,12 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
   if (ctx) {
     if (ctx->next) ctx->next->prev = NULL;
     store->available = ctx->next;
+    store->available_count--;
   }
   else {
     ctx = malloc(sizeof(op_context_t));
   }
   ctx->id = (++store->last_id);
-  // printf("acquire %p %d (%s)\n", ctx, ctx->id, op_type_to_str(type));
   ctx->prev = NULL;
   ctx->next = store->taken;
   if (store->taken) store->taken->prev = ctx;
@@ -49,6 +51,10 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
   ctx->ref_count = 2;
   ctx->result = 0;
 
+  store->taken_count++;
+
+  // printf("acquire %p %d (%s, ref_count: %d) taken: %d\n", ctx, ctx->id, op_type_to_str(type), ctx->ref_count, store->taken_count);
+
   return ctx;
 }
 
@@ -61,6 +67,9 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 
+  store->taken_count--;
+  store->available_count++;
+
   if (ctx->next) ctx->next->prev = ctx->prev;
   if (ctx->prev) ctx->prev->next = ctx->next;
   if (store->taken == ctx) store->taken = ctx->next;

data/ext/polyphony/backend_io_uring_context.h

@@ -22,7 +22,7 @@ typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;
   enum op_type      type: 16;
-  unsigned int      ref_count : 16;         
+  unsigned int      ref_count : 16;       
   int               id;
   int               result;
   VALUE             fiber;
@@ -31,8 +31,10 @@ typedef struct op_context {
 
 typedef struct op_context_store {
   int           last_id;
-  op_context_t *available;
-  op_context_t *taken;
+  op_context_t  *available;
+  op_context_t  *taken;
+  int           available_count;
+  int           taken_count;
 } op_context_store_t;
 
 const char *op_type_to_str(enum op_type type);

data/ext/polyphony/backend_libev.c

@@ -75,8 +75,12 @@ typedef struct Backend_t {
 
 static void Backend_mark(void *ptr) {
   Backend_t *backend = ptr;
-  if (backend->base.idle_block != Qnil)
-    rb_gc_mark(backend->base.idle_block);
+  backend_base_mark(&backend->base);
+}
+
+static void Backend_free(void *ptr) {
+  Backend_t *backend = ptr;
+  backend_base_finalize(&backend->base);
 }
 
 static size_t Backend_size(const void *ptr) {
@@ -85,7 +89,7 @@ static size_t Backend_size(const void *ptr) {
 
 static const rb_data_type_t Backend_type = {
     "LibevBackend",
-    {Backend_mark, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -117,7 +121,7 @@ static VALUE Backend_initialize(VALUE self) {
   
   GetBackend(self, backend);
 
-  initialize_backend_base(&backend->base);
+  backend_base_initialize(&backend->base);
   backend->ev_loop = libev_new_loop();
 
   // start async watcher used for breaking a poll op (from another thread)
@@ -156,24 +160,40 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-inline unsigned int Backend_pending_count(VALUE self) {
+inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return backend->base.pending_count;
+  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);
+  backend->base.currently_polling = 0;
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
+
+  return self;
 }
 
-VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
+inline void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  backend->base.currently_polling = 1;
-  ev_run(backend->ev_loop, nowait == Qtrue ? EVRUN_NOWAIT : EVRUN_ONCE);
-  backend->base.currently_polling = 0;
-  COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
+  backend_base_schedule_fiber(thread, self, &backend->base, fiber, value, prioritize);
+}
 
-  return self;
+inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  runqueue_delete(&backend->base.runqueue, fiber);  
+}
+
+inline VALUE Backend_switch_fiber(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_switch_fiber(self, &backend->base);
 }
 
 VALUE Backend_wakeup(VALUE self) {
@@ -193,6 +213,13 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
+inline struct backend_stats backend_get_stats(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_stats(&backend->base);
+}
+
 struct libev_io {
   struct ev_io io;
   VALUE fiber;
@@ -232,14 +259,20 @@ VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception)
   return switchpoint_result;
 }
 
-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;
   struct libev_io watcher;
   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 switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
@@ -255,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;
@@ -275,9 +309,9 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
       if (total == len) {
         if (!dynamic_len) break;
 
-        rb_str_resize(str, total);
+        rb_str_resize(str, buf_pos + total);
         rb_str_modify_expand(str, len);
-        buf = RSTRING_PTR(str) + total;
+        buf = RSTRING_PTR(str) + buf_pos + total;
         shrinkable = 0;
         len += len;
       }
@@ -285,7 +319,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 == 0) return Qnil;
@@ -298,17 +332,17 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
-  return Backend_read(self, io, str, length, Qnil);
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
+  return Backend_read(self, io, str, length, Qnil, pos);
 }
 
-VALUE Backend_read_loop(VALUE self, VALUE io) {
+VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = 8192;
+  long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
@@ -325,6 +359,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   watcher.fiber = Qnil;
 
   while (1) {
+    backend->base.op_count++;
     ssize_t n = read(fptr->fd, buf, len);
     if (n < 0) {
       int e = errno;
@@ -377,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;
@@ -424,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;
@@ -483,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;
@@ -554,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;
@@ -612,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;
@@ -671,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;
@@ -711,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;
@@ -818,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;
@@ -869,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;
@@ -928,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;
@@ -943,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;
@@ -1003,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;
@@ -1020,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;
@@ -1059,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);
 }
 
@@ -1082,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);
 
@@ -1111,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);
@@ -1162,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);
@@ -1184,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);
@@ -1227,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);
 
@@ -1249,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);
 
@@ -1293,10 +1348,10 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
-VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+VALUE Backend_idle_proc_set(VALUE self, VALUE block) {
   Backend_t *backend;
   GetBackend(self, backend);
-  backend->base.idle_block = block;
+  backend->base.idle_proc = block;
   return self;
 }
 
@@ -1312,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;
@@ -1372,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;
@@ -1397,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;
@@ -1443,6 +1501,21 @@ error:
   return RAISE_EXCEPTION(result);
 }
 
+VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_trace(&backend->base, argc, argv);
+  return self;
+}
+
+VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend->base.trace_proc = block;
+  return self;
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1452,23 +1525,26 @@ void Init_Backend() {
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
   rb_define_method(cBackend, "finalize", Backend_finalize, 0);
   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, 3);
+  rb_define_method(cBackend, "poll", Backend_poll, 1);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
-  rb_define_method(cBackend, "idle_block=", Backend_idle_block_set, 1);
+  rb_define_method(cBackend, "idle_proc=", Backend_idle_proc_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   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, "recv_loop", Backend_read_loop, 1);
+  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_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
@@ -1494,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