polyphony 0.69 → 0.73

data/ext/polyphony/backend_common.c

@@ -31,10 +31,28 @@ inline void backend_base_mark(struct Backend_base *base) {
   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;
 
 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) 
+  if ((base->switch_count % ANTI_STARVE_SWITCH_COUNT_THRESHOLD) == 0 || next == current)
     Backend_poll(backend, Qnil);
 }
 
@@ -44,7 +62,7 @@ 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);
 
@@ -64,7 +82,7 @@ VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
 
       break;
     }
-    
+
     if (!idle_tasks_run_count) {
       idle_tasks_run_count++;
       backend_run_idle_tasks(base);
@@ -94,7 +112,7 @@ void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_bas
 
   COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
 
-  runqueue_t *runqueue = rb_ivar_get(fiber, ID_ivar_parked) == Qtrue ? 
+  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);
@@ -184,7 +202,6 @@ inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
 }
 
 inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
-  OBJ_TAINT(str);
   rb_enc_associate(str, io_read_encoding(fptr));
   return str;
 }
@@ -228,6 +245,13 @@ inline double current_time() {
   return t / 1e9;
 }
 
+inline uint64_t current_time_ns() {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  uint64_t ns = ts.tv_sec;
+  return ns * 1e9 + ts.tv_nsec;
+}
+
 inline VALUE backend_timeout_exception(VALUE exception) {
   if (rb_obj_is_kind_of(exception, rb_cArray) == Qtrue)
     return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
@@ -282,7 +306,7 @@ inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
   int flags = fcntl(fptr->fd, F_GETFL);
   if (flags == -1) return;
   int is_nonblocking = flags & O_NONBLOCK;
-  
+
   if (blocking == Qtrue) {
     if (!is_nonblocking) return;
     flags &= ~O_NONBLOCK;
@@ -357,7 +381,7 @@ void backend_setup_stats_symbols() {
   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);

data/ext/polyphony/backend_common.h

@@ -32,6 +32,7 @@ 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);
@@ -81,7 +82,6 @@ VALUE backend_snooze();
   shrinkable = io_setstrbuf(&str, len); \
   buf = RSTRING_PTR(str); \
   total = 0; \
-  OBJ_TAINT(str); \
 }
 
 #define READ_LOOP_YIELD_STR() { \
@@ -100,6 +100,7 @@ VALUE backend_snooze();
 
 void rectify_io_file_pos(rb_io_t *fptr);
 double current_time();
+uint64_t current_time_ns();
 VALUE backend_timeout_exception(VALUE exception);
 VALUE Backend_timeout_ensure_safe(VALUE arg);
 VALUE Backend_timeout_ensure_safe(VALUE arg);

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;
 }
@@ -129,7 +127,7 @@ void *io_uring_backend_poll_without_gvl(void *ptr) {
 
 // copied from queue.c
 static inline bool cq_ring_needs_flush(struct io_uring *ring) {
-	return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
+  return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
 }
 
 static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
@@ -143,13 +141,13 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   context_store_release(&backend->store, ctx);
 }
 
-// adapted from io_uring_peek_batch_cqe in queue.c 
+// adapted from io_uring_peek_batch_cqe in queue.c
 // this peeks at cqes and handles each available cqe
 void io_uring_backend_handle_ready_cqes(Backend_t *backend) {
   struct io_uring *ring = &backend->ring;
-	bool overflow_checked = false;
+  bool overflow_checked = false;
   struct io_uring_cqe *cqe;
-	unsigned head;
+  unsigned head;
   unsigned cqe_count;
 
 again:
@@ -160,16 +158,16 @@ again:
   }
   io_uring_cq_advance(ring, cqe_count);
 
-	if (overflow_checked) goto done;
+  if (overflow_checked) goto done;
 
-	if (cq_ring_needs_flush(ring)) {
-		__sys_io_uring_enter(ring->ring_fd, 0, 0, IORING_ENTER_GETEVENTS, NULL);
-		overflow_checked = true;
-		goto again;
-	}
+  if (cq_ring_needs_flush(ring)) {
+    __sys_io_uring_enter(ring->ring_fd, 0, 0, IORING_ENTER_GETEVENTS, NULL);
+    overflow_checked = true;
+    goto again;
+  }
 
 done:
-	return;
+  return;
 }
 
 void io_uring_backend_poll(Backend_t *backend) {
@@ -202,19 +200,12 @@ inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   }
 
   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());
   
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
+
   return self;
 }
 
@@ -257,7 +248,7 @@ VALUE Backend_wakeup(VALUE self) {
     io_uring_prep_nop(sqe);
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
-    
+
     return Qtrue;
   }
 
@@ -342,7 +333,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   rb_io_check_byte_readable(fptr);
   io_unset_nonblock(fptr, io);
   rectify_io_file_pos(fptr);
-  OBJ_TAINT(str);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -413,7 +403,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
-    
+
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -463,7 +453,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
-    
+
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -509,7 +499,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -518,7 +508,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
       return resume_value;
     }
     RB_GC_GUARD(resume_value);
-    
+
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
@@ -561,7 +551,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_writev(sqe, fptr->fd, iov_ptr, iov_count, -1);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -630,14 +620,13 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   rb_io_check_byte_readable(fptr);
   io_unset_nonblock(fptr, io);
   rectify_io_file_pos(fptr);
-  OBJ_TAINT(str);
 
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -687,7 +676,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -736,7 +725,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -782,7 +771,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     if (!completed) {
@@ -819,7 +808,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
     op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_accept(sqe, fptr->fd, &addr, &len, 0);
-    
+
     int fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
@@ -840,7 +829,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
       rb_io_synchronized(fp);
 
       // if (rsock_do_not_reverse_lookup) {
-	    //   fp->mode |= FMODE_NOREVLOOKUP;
+      //   fp->mode |= FMODE_NOREVLOOKUP;
       // }
       if (loop) {
         rb_yield(socket);
@@ -890,7 +879,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
-    
+
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
@@ -946,7 +935,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   RAISE_IF_EXCEPTION(resume_value);
   if (!completed) return resume_value;
   RB_GC_GUARD(resume_value);
-  
+
   if (result < 0) rb_syserr_fail(-result, strerror(-result));
   return sock;
 }
@@ -971,7 +960,7 @@ inline struct __kernel_timespec double_to_timespec(double duration) {
   double duration_fraction = modf(duration, &duration_integral);
   struct __kernel_timespec ts;
   ts.tv_sec = duration_integral;
-	ts.tv_nsec = floor(duration_fraction * 1000000000);
+  ts.tv_nsec = floor(duration_fraction * 1000000000);
   return ts;
 }
 
@@ -983,7 +972,7 @@ inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
 int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
   struct __kernel_timespec ts = double_to_timespec(duration);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-  
+
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
@@ -1003,29 +992,34 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
 
 VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   Backend_t *backend;
-  double interval_d = NUM2DBL(interval);
+  uint64_t interval_ns = NUM2DBL(interval) * 1e9;
+  uint64_t next_time_ns = 0;
+  VALUE resume_value = Qnil;
+
   GetBackend(self, backend);
-  double next_time = 0.;
 
   while (1) {
-    double now = current_time();
-    if (next_time == 0.) next_time = current_time() + interval_d;
-    double sleep_duration = next_time - now;
-    if (sleep_duration < 0) sleep_duration = 0;
-    
-    VALUE resume_value = Qnil;
-    int completed = io_uring_backend_submit_timeout_and_await(backend, sleep_duration, &resume_value);
-    RAISE_IF_EXCEPTION(resume_value);
-    if (!completed) return resume_value;
-    RB_GC_GUARD(resume_value);
+    double now_ns = current_time_ns();
+    if (next_time_ns == 0) next_time_ns = now_ns + interval_ns;
+    if (next_time_ns > now_ns) {
+      double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
+      int completed = io_uring_backend_submit_timeout_and_await(backend, sleep_duration, &resume_value);
+      RAISE_IF_EXCEPTION(resume_value);
+      if (!completed) return resume_value;
+    }
+    else {
+      resume_value = backend_snooze();
+      RAISE_IF_EXCEPTION(resume_value);
+    }
 
     rb_yield(Qnil);
 
     while (1) {
-      next_time += interval_d;
-      if (next_time > now) break;
+      next_time_ns += interval_ns;
+      if (next_time_ns > now_ns) break;
     }
   }
+  RB_GC_GUARD(resume_value);
 }
 
 struct Backend_timeout_ctx {
@@ -1053,7 +1047,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   VALUE exception;
   VALUE move_on_value = Qnil;
   rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
-  
+
   struct __kernel_timespec ts = duration_to_timespec(duration);
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1061,7 +1055,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-  
+
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1096,7 +1090,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     RAISE_IF_EXCEPTION(resume_value);
     RB_GC_GUARD(resume_value);
   }
-  
+
   int status;
   pid_t ret = waitpid(pid_int, &status, WNOHANG);
   if (ret < 0) {
@@ -1246,7 +1240,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
       }
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
     }
-    
+
     io_uring_sqe_set_data(last_sqe, ctx);
     unsigned int flags = (i == (argc - 1)) ? IOSQE_ASYNC : IOSQE_ASYNC | IOSQE_IO_LINK;
     io_uring_sqe_set_flags(last_sqe, flags);
@@ -1261,7 +1255,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   int completed = context_store_release(&backend->store, ctx);
   if (!completed) {
     Backend_chain_ctx_attach_buffers(ctx, argc, argv);
-    
+
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -1271,7 +1265,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     RAISE_IF_EXCEPTION(resume_value);
     return resume_value;
   }
-  
+
   RB_GC_GUARD(resume_value);
   return INT2NUM(result);
 }
@@ -1406,7 +1400,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
     if (chunk_len == 0) break;
-    
+
     total += chunk_len;
     chunk_len_value = INT2NUM(chunk_len);
 
@@ -1528,10 +1522,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "write", Backend_write_m, -1);
 
-  #ifdef POLYPHONY_UNSET_NONBLOCK
-  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
-  #endif
-
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
   SYM_send = ID2SYM(rb_intern("send"));
   SYM_splice = ID2SYM(rb_intern("splice"));

data/ext/polyphony/backend_io_uring_context.c

@@ -64,7 +64,7 @@ inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
   // printf("release %p %d (%s, ref_count: %d)\n", ctx, ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
 
   assert(ctx->ref_count);
-  
+
   ctx->ref_count--;
   if (ctx->ref_count) return 0;
 

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;

data/ext/polyphony/backend_libev.c

@@ -118,7 +118,7 @@ inline struct ev_loop *libev_new_loop() {
 
 static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
-  
+
   GetBackend(self, backend);
 
   backend_base_initialize(&backend->base);
@@ -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;
 }
 
@@ -186,7 +188,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) {
@@ -285,7 +287,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
-  OBJ_TAINT(str);
 
   while (1) {
     backend->base.op_count++;
@@ -969,7 +970,7 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
   watcher.fiber = Qnil;
-  
+
   while (1) {
     backend->base.op_count++;
     ssize_t n = read(src_fptr->fd, buf, len);
@@ -1045,7 +1046,7 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   watcher.fiber = Qnil;
 
-  while (1) { 
+  while (1) {
     char *ptr = buf;
     while (1) {
       backend->base.op_count++;
@@ -1145,33 +1146,40 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
 noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   Backend_t *backend;
   struct libev_timer watcher;
-  double interval_d = NUM2DBL(interval);
-
-  GetBackend(self, backend);
   watcher.fiber = rb_fiber_current();
+  uint64_t interval_ns = NUM2DBL(interval) * 1e9;
+  uint64_t next_time_ns = 0;
+  VALUE resume_value = Qnil;
 
-  double next_time = 0.;
+  GetBackend(self, backend);
 
   while (1) {
-    double now = current_time();
-    if (next_time == 0.) next_time = current_time() + interval_d;
-    double sleep_duration = next_time - now;
-    if (sleep_duration < 0) sleep_duration = 0;
-    
-    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);
-    RB_GC_GUARD(switchpoint_result);
+    uint64_t now_ns = current_time_ns();
+    if (next_time_ns == 0) next_time_ns = now_ns + interval_ns;
+    double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
+
+    if (next_time_ns > now_ns) {
+      double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
+      ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
+      ev_timer_start(backend->ev_loop, &watcher.timer);
+      backend->base.op_count++;
+      resume_value = backend_await((struct Backend_base *)backend);
+      ev_timer_stop(backend->ev_loop, &watcher.timer);
+      RAISE_IF_EXCEPTION(resume_value);
+    }
+    else {
+      resume_value = backend_snooze();
+      RAISE_IF_EXCEPTION(resume_value);
+    }
 
     rb_yield(Qnil);
-    do {
-      next_time += interval_d;
-    } while (next_time <= now);
+
+    while (1) {
+      next_time_ns += interval_ns;
+      if (next_time_ns > now_ns) break;
+    }
   }
+  RB_GC_GUARD(resume_value);
 }
 
 struct libev_timeout {
@@ -1217,7 +1225,7 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
 
   struct Backend_timeout_ctx timeout_ctx = {backend, &watcher};
   result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
-  
+
   if (result == timeout) {
     if (exception == Qnil) return move_on_value;
     RAISE_EXCEPTION(backend_timeout_exception(exception));
@@ -1335,7 +1343,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     else
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
   }
-  
+
   RB_GC_GUARD(result);
   return result;
 }
@@ -1384,14 +1392,14 @@ inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct lib
   return 0;
 }
 
-static inline int splice_chunks_splice(Backend_t *backend, int src_fd, int dest_fd, int maxlen, 
+static inline int splice_chunks_splice(Backend_t *backend, int src_fd, int dest_fd, int maxlen,
   struct libev_rw_io *watcher, VALUE *result, int *chunk_len) {
 #ifdef POLYPHONY_LINUX
   backend->base.op_count++;
   while (1) {
     *chunk_len = splice(src_fd, 0, dest_fd, 0, maxlen, 0);
     if (*chunk_len >= 0) return 0;
-    
+
     int err = errno;
     if (err != EWOULDBLOCK && err != EAGAIN) return err;
 
@@ -1487,7 +1495,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     err = splice_chunks_splice(backend, src_fptr->fd, pipefd[1], maxlen, &watcher, &result, &chunk_len);
     if (err == -1) goto error; else if (err) goto syscallerror;
     if (chunk_len == 0) break;
-    
+
     total += chunk_len;
     chunk_len_value = INT2NUM(chunk_len);