polyphony 0.43.3 → 0.43.9

data/ext/polyphony/libev_agent.c

@@ -1,5 +1,8 @@
 #include <netdb.h>
 #include <sys/socket.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <fcntl.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
@@ -130,7 +133,7 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   GetLibevAgent(self, agent);
 
   if (is_nowait) {
-    long runnable_count = RARRAY_LEN(queue);
+    long runnable_count = Queue_len(queue);
     agent->run_no_wait_count++;
     if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
       return self;
@@ -277,11 +280,37 @@ VALUE libev_snooze() {
   return Thread_switch_fiber(rb_thread_current());
 }
 
+ID ID_ivar_is_nonblocking;
+
+// Since we need to ensure that fd's are non-blocking before every I/O
+// operation, here we improve upon Ruby's rb_io_set_nonblock by caching the
+// "nonblock" state in an instance variable. Calling rb_ivar_get on every read
+// is still much cheaper than doing a fcntl syscall on every read! Preliminary
+// benchmarks (with a "hello world" HTTP server) show throughput is improved
+// by 10-13%.
+inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
+#ifdef _WIN32
+  return rb_w32_set_nonblock(fptr->fd);
+#elif defined(F_GETFL)
+  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
+  if (is_nonblocking == Qnil) {
+    rb_ivar_set(io, ID_ivar_is_nonblocking, Qtrue);
+    int oflags = fcntl(fptr->fd, F_GETFL);
+    if (oflags == -1) return;
+    if (oflags & O_NONBLOCK) return;
+    oflags |= O_NONBLOCK;
+    fcntl(fptr->fd, F_SETFL, oflags);
+  }
+#endif
+  return;
+}
+
 VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
-  long len = NUM2INT(length);
+  long dynamic_len = length == Qnil;
+  long len = dynamic_len ? 4096 : NUM2INT(length);
   int shrinkable = io_setstrbuf(&str, len);
   char *buf = RSTRING_PTR(str);
   long total = 0;
@@ -293,13 +322,22 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, io);
   watcher.fiber = Qnil;
   
   OBJ_TAINT(str);
 
-  while (len > 0) {
-    ssize_t n = read(fptr->fd, buf, len);
+  // Apparently after reopening a closed file, the file position is not reset,
+  // which causes the read to fail. Fortunately we can use fptr->rbuf.len to
+  // find out if that's the case.
+  // See: https://github.com/digital-fabric/polyphony/issues/30
+  if (fptr->rbuf.len > 0) {
+    lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);
+    fptr->rbuf.len = 0;
+  }
+
+  while (1) {
+    ssize_t n = read(fptr->fd, buf, len - total);
     if (n < 0) {
       int e = errno;
       if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
@@ -312,14 +350,21 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
-
       total = total + n;
-      buf += n;
-      len -= n;
-      if (!read_to_eof || (len == 0)) break;
+      if (!read_to_eof) break;
+
+      if (total == len) {
+        if (!dynamic_len) break;
+      
+        rb_str_resize(str, total);
+        rb_str_modify_expand(str, len);
+        buf = RSTRING_PTR(str) + total;
+        shrinkable = 0;
+        len += len;
+      }
+      else buf += n;
     }
   }
-
   if (total == 0) return Qnil;
 
   io_set_read_length(str, total, shrinkable);
@@ -340,6 +385,7 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
     shrinkable = io_setstrbuf(&str, len); \
     buf = RSTRING_PTR(str); \
     total = 0; \
+    OBJ_TAINT(str); \
   }
 
   #define YIELD_STR() { \
@@ -366,10 +412,17 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, io);
   watcher.fiber = Qnil;
 
-  OBJ_TAINT(str);
+  // Apparently after reopening a closed file, the file position is not reset,
+  // which causes the read to fail. Fortunately we can use fptr->rbuf.len to
+  // find out if that's the case.
+  // See: https://github.com/digital-fabric/polyphony/issues/30
+  if (fptr->rbuf.len > 0) {
+    lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);
+    fptr->rbuf.len = 0;
+  }
 
   while (1) {
     ssize_t n = read(fptr->fd, buf, len);
@@ -410,12 +463,12 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
-
+  VALUE underlying_io;
   char *buf = StringValuePtr(str);
   long len = RSTRING_LEN(str);
   long left = len;
 
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
   GetLibevAgent(self, agent);
   io = rb_io_get_write_io(io);
@@ -427,19 +480,20 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
-
       switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = libev_snooze();
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
-
       buf += n;
       left -= n;
     }
   }
 
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = libev_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
@@ -448,6 +502,86 @@ error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
+VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  long total_length = 0;
+  long total_written = 0;
+  struct iovec *iov = 0;
+  struct iovec *iov_ptr = 0;
+  int iov_count = argc;
+
+  underlying_io = rb_iv_get(io, "@io");
+  if (underlying_io != Qnil) io = underlying_io;
+  GetLibevAgent(self, agent);
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  watcher.fiber = Qnil;
+
+  iov = malloc(iov_count * sizeof(struct iovec));
+  for (int i = 0; i < argc; i++) {
+    VALUE str = argv[i];
+    iov[i].iov_base = StringValuePtr(str);
+    iov[i].iov_len = RSTRING_LEN(str);
+    total_length += iov[i].iov_len;
+  }
+  iov_ptr = iov;
+
+  while (1) {
+    ssize_t n = writev(fptr->fd, iov_ptr, iov_count);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      total_written += n;
+      if (total_written == total_length) break;
+
+      while (n > 0) {
+        if ((size_t) n < iov_ptr[0].iov_len) {
+          iov_ptr[0].iov_base = (char *) iov_ptr[0].iov_base + n;
+          iov_ptr[0].iov_len -= n;
+          n = 0;
+        }
+        else {
+          n -= iov_ptr[0].iov_len;
+          iov_ptr += 1;
+          iov_count -= 1;
+        }
+      }
+    }
+  }
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = libev_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  free(iov);
+  return INT2NUM(total_written);
+error:
+  free(iov);
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+}
+
+VALUE LibevAgent_write_m(int argc, VALUE *argv, VALUE self) {
+  if (argc < 2)
+    // TODO: raise ArgumentError
+    rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
+  
+  return (argc == 2) ?
+    LibevAgent_write(self, argv[0], argv[1]) :
+    LibevAgent_writev(self, argv[0], argc - 1, argv + 1);                    
+}
+
 ///////////////////////////////////////////////////////////////////////////
 
 VALUE LibevAgent_accept(VALUE self, VALUE sock) {
@@ -463,7 +597,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
 
   GetLibevAgent(self, agent);
   GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -489,7 +623,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      rb_io_set_nonblock(fp);
+      io_set_nonblock(fp, socket);
       rb_io_synchronized(fp);
       
       // if (rsock_do_not_reverse_lookup) {
@@ -518,7 +652,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
 
   GetLibevAgent(self, agent);
   GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -544,7 +678,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      rb_io_set_nonblock(fp);
+      io_set_nonblock(fp, socket);
       rb_io_synchronized(fp);
 
       rb_yield(socket);
@@ -572,7 +706,7 @@ error:
 
 //   GetLibevAgent(self, agent);
 //   GetOpenFile(sock, fptr);
-//   rb_io_set_nonblock(fptr);
+//   io_set_nonblock(fptr, sock);
 //   watcher.fiber = Qnil;
 
 //   addr.sin_family = AF_INET; 
@@ -647,6 +781,7 @@ VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
   ev_timer_start(agent->ev_loop, &watcher.timer);
 
   switchpoint_result = libev_await(agent);
+
   ev_timer_stop(agent->ev_loop, &watcher.timer);
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -695,6 +830,25 @@ struct ev_loop *LibevAgent_ev_loop(VALUE self) {
   return agent->ev_loop;
 }
 
+void LibevAgent_async_callback(EV_P_ ev_async *w, int revents) { }
+
+VALUE LibevAgent_wait_event(VALUE self, VALUE raise) {
+  struct LibevAgent_t *agent;
+  struct ev_async async;
+  VALUE switchpoint_result = Qnil;
+  GetLibevAgent(self, agent);
+
+  ev_async_init(&async, LibevAgent_async_callback);
+  ev_async_start(agent->ev_loop, &async);
+  
+  switchpoint_result = libev_await(agent);
+  ev_async_stop(agent->ev_loop, &async);
+
+  if (RTEST(raise)) TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
 void Init_LibevAgent() {
   rb_require("socket");
   cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
@@ -715,11 +869,14 @@ void Init_LibevAgent() {
 
   rb_define_method(cLibevAgent, "read", LibevAgent_read, 4);
   rb_define_method(cLibevAgent, "read_loop", LibevAgent_read_loop, 1);
-  rb_define_method(cLibevAgent, "write", LibevAgent_write, 2);
+  rb_define_method(cLibevAgent, "write", LibevAgent_write_m, -1);
   rb_define_method(cLibevAgent, "accept", LibevAgent_accept, 1);
   rb_define_method(cLibevAgent, "accept_loop", LibevAgent_accept_loop, 1);
   // rb_define_method(cLibevAgent, "connect", LibevAgent_accept, 3);
   rb_define_method(cLibevAgent, "wait_io", LibevAgent_wait_io, 2);
   rb_define_method(cLibevAgent, "sleep", LibevAgent_sleep, 1);
   rb_define_method(cLibevAgent, "waitpid", LibevAgent_waitpid, 1);
+  rb_define_method(cLibevAgent, "wait_event", LibevAgent_wait_event, 1);
+
+  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
 }

data/ext/polyphony/polyphony.c

@@ -2,7 +2,6 @@
 
 VALUE mPolyphony;
 
-ID ID_await_no_raise;
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
@@ -54,7 +53,6 @@ void Init_Polyphony() {
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
 
-  ID_await_no_raise = rb_intern("await_no_raise");
   ID_call           = rb_intern("call");
   ID_caller         = rb_intern("caller");
   ID_clear          = rb_intern("clear");

data/ext/polyphony/polyphony.h

@@ -1,5 +1,5 @@
-#ifndef RUBY_EV_H
-#define RUBY_EV_H
+#ifndef POLYPHONY_H
+#define POLYPHONY_H
 
 #include "ruby.h"
 #include "ruby/io.h"
@@ -19,10 +19,9 @@
 }
 
 extern VALUE mPolyphony;
-extern VALUE cLibevQueue;
+extern VALUE cQueue;
 extern VALUE cEvent;
 
-extern ID ID_await_no_raise;
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
@@ -75,10 +74,18 @@ VALUE LibevAgent_ref(VALUE self);
 VALUE LibevAgent_unref(VALUE self);
 int LibevAgent_ref_count(VALUE self);
 void LibevAgent_reset_ref_count(VALUE self);
+VALUE LibevAgent_wait_event(VALUE self, VALUE raise);
 
-VALUE Polyphony_snooze(VALUE self);
+VALUE Queue_push(VALUE self, VALUE value);
+VALUE Queue_unshift(VALUE self, VALUE value);
+VALUE Queue_shift(VALUE self);
+VALUE Queue_shift_no_wait(VALUE self);
+VALUE Queue_clear(VALUE self);
+VALUE Queue_delete(VALUE self, VALUE value);
+long Queue_len(VALUE self);
+void Queue_trace(VALUE self);
 
-VALUE Polyphony_Queue_push(VALUE self, VALUE value);
+VALUE Polyphony_snooze(VALUE self);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
@@ -87,4 +94,4 @@ int io_setstrbuf(VALUE *str, long len);
 void io_set_read_length(VALUE str, long n, int shrinkable);
 VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
-#endif /* RUBY_EV_H */
+#endif /* POLYPHONY_H */

data/ext/polyphony/polyphony_ext.c

@@ -3,7 +3,8 @@
 void Init_Fiber();
 void Init_Polyphony();
 void Init_LibevAgent();
-void Init_LibevQueue();
+void Init_Queue();
+void Init_Event();
 void Init_Thread();
 void Init_Tracing();
 
@@ -12,7 +13,8 @@ void Init_polyphony_ext() {
 
   Init_Polyphony();
   Init_LibevAgent();
-  Init_LibevQueue();
+  Init_Queue();
+  Init_Event();
 
   Init_Fiber();
   Init_Thread();

data/ext/polyphony/queue.c

@@ -0,0 +1,187 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+typedef struct queue {
+  ring_buffer values;
+  ring_buffer shift_queue;
+} Queue_t;
+
+VALUE cQueue = Qnil;
+
+static void Queue_mark(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_mark(&queue->values);
+  ring_buffer_mark(&queue->shift_queue);
+}
+
+static void Queue_free(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_free(&queue->values);
+  ring_buffer_free(&queue->shift_queue);
+  xfree(ptr);
+}
+
+static size_t Queue_size(const void *ptr) {
+  return sizeof(Queue_t);
+}
+
+static const rb_data_type_t Queue_type = {
+  "Queue",
+  {Queue_mark, Queue_free, Queue_size,},
+  0, 0, 0
+};
+
+static VALUE Queue_allocate(VALUE klass) {
+  Queue_t *queue;
+
+  queue = ALLOC(Queue_t);
+  return TypedData_Wrap_Struct(klass, &Queue_type, queue);
+}
+
+#define GetQueue(obj, queue) \
+  TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
+
+static VALUE Queue_initialize(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_init(&queue->values);
+  ring_buffer_init(&queue->shift_queue);
+
+  return self;
+}
+
+VALUE Queue_push(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+  if (queue->shift_queue.count > 0) {
+    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
+    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
+  }
+  ring_buffer_push(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_unshift(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+  if (queue->shift_queue.count > 0) {
+    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
+    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
+  }
+  ring_buffer_unshift(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_shift(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  if (queue->values.count == 0) {
+    VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    VALUE fiber = rb_fiber_current();
+    VALUE switchpoint_result = Qnil;
+    ring_buffer_push(&queue->shift_queue, fiber);
+    switchpoint_result = LibevAgent_wait_event(agent, Qnil);
+    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
+      ring_buffer_delete(&queue->shift_queue, fiber);
+      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    }
+    RB_GC_GUARD(agent);
+    RB_GC_GUARD(switchpoint_result);
+  }
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_shift_no_wait(VALUE self) {
+    Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_delete(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_clear(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_clear(&queue->values);
+  return self;
+}
+
+long Queue_len(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->values.count;
+}
+
+VALUE Queue_shift_each(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_shift_each(&queue->values);
+  return self;
+}
+
+VALUE Queue_shift_all(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift_all(&queue->values);
+}
+
+VALUE Queue_flush_waiters(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  while(1) {
+    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
+    if (fiber == Qnil) return self;
+    
+    Fiber_make_runnable(fiber, value);
+  }
+}
+
+VALUE Queue_empty_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return (queue->values.count == 0) ? Qtrue : Qfalse;
+}
+
+VALUE Queue_size_m(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return INT2NUM(queue->values.count);
+}
+
+void Init_Queue() {
+  cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cData);
+  rb_define_alloc_func(cQueue, Queue_allocate);
+
+  rb_define_method(cQueue, "initialize", Queue_initialize, 0);
+  rb_define_method(cQueue, "push", Queue_push, 1);
+  rb_define_method(cQueue, "<<", Queue_push, 1);
+  rb_define_method(cQueue, "unshift", Queue_unshift, 1);
+
+  rb_define_method(cQueue, "shift", Queue_shift, 0);
+  rb_define_method(cQueue, "pop", Queue_shift, 0);
+  rb_define_method(cQueue, "shift_no_wait", Queue_shift_no_wait, 0);
+  rb_define_method(cQueue, "delete", Queue_delete, 1);
+
+  rb_define_method(cQueue, "shift_each", Queue_shift_each, 0);
+  rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);
+  rb_define_method(cQueue, "flush_waiters", Queue_flush_waiters, 1);
+  rb_define_method(cQueue, "empty?", Queue_empty_p, 0);
+  rb_define_method(cQueue, "size", Queue_size_m, 0);
+}