polyphony 0.71 → 0.74

data/ext/polyphony/backend_common.c

@@ -34,7 +34,7 @@ inline void backend_base_mark(struct Backend_base *base) {
 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);
 
@@ -46,13 +46,13 @@ void backend_base_reset(struct Backend_base *base) {
   base->idle_gc_period = 0;
   base->idle_gc_last_time = 0;
   base->idle_proc = Qnil;
-  base->trace_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);
 }
 
@@ -62,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);
 
@@ -82,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);
@@ -106,14 +106,14 @@ 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) {
   int already_runnable;
+  runqueue_t *runqueue;
 
   if (rb_fiber_alive_p(fiber) != Qtrue) return;
   already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
 
   COND_TRACE(base, 4, SYM_fiber_schedule, fiber, value, prioritize ? Qtrue : Qfalse);
 
-  runqueue_t *runqueue = rb_ivar_get(fiber, ID_ivar_parked) == Qtrue ? 
-    &base->parked_runqueue : &base->runqueue;
+  runqueue = rb_ivar_get(fiber, ID_ivar_parked) == Qtrue ? &base->parked_runqueue : &base->runqueue;
 
   (prioritize ? runqueue_unshift : runqueue_push)(runqueue, fiber, value, already_runnable);
   if (!already_runnable) {
@@ -202,11 +202,40 @@ 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;
 }
 
+static inline void free_io_buffer(rb_io_buffer_t *buf)
+{
+  if (buf->ptr) {
+    ruby_xfree(buf->ptr);
+    buf->ptr = NULL;
+  }
+}
+
+static inline void clear_codeconv(rb_io_t *fptr) {
+  if (fptr->readconv) {
+    rb_econv_close(fptr->readconv);
+    fptr->readconv = NULL;
+  }
+  free_io_buffer(&fptr->cbuf);
+
+  if (fptr->writeconv) {
+    rb_econv_close(fptr->writeconv);
+    fptr->writeconv = NULL;
+  }
+  fptr->writeconv_initialized = 0;
+}
+
+void fptr_finalize(rb_io_t *fptr) {
+  fptr->fd = -1;
+  fptr->stdio_file = 0;
+  free_io_buffer(&fptr->rbuf);
+  free_io_buffer(&fptr->wbuf);
+  clear_codeconv(fptr);
+}
+
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
@@ -239,13 +268,25 @@ inline void rectify_io_file_pos(rb_io_t *fptr) {
 
 inline double current_time() {
   struct timespec ts;
+  double t;
+  uint64_t ns;
+  
   clock_gettime(CLOCK_MONOTONIC, &ts);
-  long long ns = ts.tv_sec;
+  ns = ts.tv_sec;
   ns = ns * 1e9 + ts.tv_nsec;
-  double t = ns;
+  t = ns;
   return t / 1e9;
 }
 
+inline uint64_t current_time_ns() {
+  struct timespec ts;
+  uint64_t ns;
+
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  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));
@@ -270,6 +311,9 @@ VALUE Backend_timeout_ensure_safe(VALUE arg) {
 static VALUE empty_string = Qnil;
 
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
+  VALUE joined;
+  VALUE result;
+
   switch (RARRAY_LEN(ary)) {
   case 0:
     return Qnil;
@@ -280,14 +324,16 @@ VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
       empty_string = rb_str_new_literal("");
       rb_global_variable(&empty_string);
     }
-    VALUE joined = rb_ary_join(ary, empty_string);
-    VALUE result = Backend_send(self, io, joined, flags);
+    joined = rb_ary_join(ary, empty_string);
+    result = Backend_send(self, io, joined, flags);
     RB_GC_GUARD(joined);
     return result;
   }
 }
 
 inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
+  int flags;
+  int is_nonblocking;
   VALUE blocking_mode = rb_ivar_get(io, ID_ivar_blocking_mode);
   if (blocking == blocking_mode) return;
 
@@ -297,10 +343,10 @@ inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
   if (blocking != Qtrue)
     rb_w32_set_nonblock(fptr->fd);
 #elif defined(F_GETFL)
-  int flags = fcntl(fptr->fd, F_GETFL);
+  flags = fcntl(fptr->fd, F_GETFL);
   if (flags == -1) return;
-  int is_nonblocking = flags & O_NONBLOCK;
-  
+  is_nonblocking = flags & O_NONBLOCK;
+
   if (blocking == Qtrue) {
     if (!is_nonblocking) return;
     flags &= ~O_NONBLOCK;
@@ -313,12 +359,14 @@ inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
 }
 
 inline void backend_run_idle_tasks(struct Backend_base *base) {
+  double now;
+
   if (base->idle_proc != Qnil)
     rb_funcall(base->idle_proc, ID_call, 0);
 
   if (base->idle_gc_period == 0) return;
 
-  double now = current_time();
+  now = current_time();
   if (now - base->idle_gc_last_time < base->idle_gc_period) return;
 
   base->idle_gc_last_time = now;
@@ -375,7 +423,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);
@@ -383,4 +431,26 @@ void backend_setup_stats_symbols() {
   rb_global_variable(&SYM_switch_count);
   rb_global_variable(&SYM_poll_count);
   rb_global_variable(&SYM_pending_ops);
-}
+}
+
+int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr) {
+  VALUE port_string;
+  struct addrinfo hints;
+  struct addrinfo *addrinfo_result;
+  int ret;
+
+  memset(&hints, 0, sizeof(struct addrinfo));
+  hints.ai_family = AF_UNSPEC; /* allow IPv4 or IPv6 */
+  hints.ai_socktype = SOCK_STREAM;
+
+  port_string = rb_funcall(port, ID_to_s, 0);
+  ret = getaddrinfo(StringValueCStr(host), StringValueCStr(port_string), &hints, &addrinfo_result);
+  RB_GC_GUARD(port_string);
+  if (ret != 0) {
+    VALUE msg = rb_str_new2(gai_strerror(ret));
+    rb_funcall(rb_mKernel, ID_raise, 1, msg);
+    RB_GC_GUARD(msg);
+  }
+  *ai_addr = addrinfo_result->ai_addr;
+  return addrinfo_result->ai_addrlen;
+}

data/ext/polyphony/backend_common.h

@@ -1,6 +1,11 @@
 #ifndef BACKEND_COMMON_H
 #define BACKEND_COMMON_H
 
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
 #include "ruby.h"
 #include "ruby/io.h"
 #include "runqueue.h"
@@ -68,6 +73,7 @@ void io_shrink_read_string(VALUE str, long n);
 void io_set_read_length(VALUE str, long n, int shrinkable);
 rb_encoding* io_read_encoding(rb_io_t *fptr);
 VALUE io_enc_str(VALUE str, rb_io_t *fptr);
+void fptr_finalize(rb_io_t *fptr);
 
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
@@ -82,7 +88,6 @@ VALUE backend_snooze();
   shrinkable = io_setstrbuf(&str, len); \
   buf = RSTRING_PTR(str); \
   total = 0; \
-  OBJ_TAINT(str); \
 }
 
 #define READ_LOOP_YIELD_STR() { \
@@ -101,6 +106,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);
@@ -109,5 +115,6 @@ 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();
+int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr);
 
 #endif /* BACKEND_COMMON_H */