polyphony 0.34 → 0.41

data/ext/gyro/gyro.c

@@ -1,203 +0,0 @@
-#include "gyro.h"
-
-VALUE mGyro;
-
-ID ID_call;
-ID ID_caller;
-ID ID_clear;
-ID ID_each;
-ID ID_fiber_trace;
-ID ID_inspect;
-ID ID_new;
-ID ID_raise;
-ID ID_ivar_running;
-ID ID_ivar_thread;
-ID ID_runnable;
-ID ID_runnable_value;
-ID ID_size;
-ID ID_signal_bang;
-ID ID_switch_fiber;
-ID ID_transfer;
-ID ID_R;
-ID ID_W;
-ID ID_RW;
-
-ID ID_trace_ev_loop_enter;
-ID ID_trace_ev_loop_leave;
-ID ID_trace_run;
-ID ID_trace_runnable;
-ID ID_trace_terminate;
-ID ID_trace_wait;
-
-ID ID_empty;
-ID ID_pop;
-ID ID_push;
-
-VALUE SYM_dead;
-VALUE SYM_running;
-VALUE SYM_runnable;
-VALUE SYM_waiting;
-
-VALUE SYM_fiber_create;
-VALUE SYM_fiber_ev_loop_enter;
-VALUE SYM_fiber_ev_loop_leave;
-VALUE SYM_fiber_run;
-VALUE SYM_fiber_schedule;
-VALUE SYM_fiber_switchpoint;
-VALUE SYM_fiber_terminate;
-
-
-static VALUE Gyro_break_set(VALUE self) {
-  // break_flag = 1;
-  ev_break(Gyro_Selector_current_thread_ev_loop(), EVBREAK_ALL);
-  return Qnil;
-}
-
-// static VALUE Gyro_break_get(VALUE self) {
-//   return (break_flag == 0) ? Qfalse : Qtrue;
-// }
-
-VALUE Gyro_snooze(VALUE self) {
-  VALUE fiber = rb_fiber_current();
-  Gyro_schedule_fiber(fiber, Qnil);
-
-  VALUE ret = Thread_switch_fiber(rb_thread_current());
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  else
-    return ret;
-}
-
-static VALUE Gyro_post_fork(VALUE self) {
-  Thread_post_fork(rb_thread_current());
-  return Qnil;
-}
-
-static VALUE Gyro_ref(VALUE self) {
-  return Thread_ref(rb_thread_current());
-}
-
-static VALUE Gyro_unref(VALUE self) {
-  return Thread_unref(rb_thread_current());
-}
-
-static VALUE Gyro_suspend(VALUE self) {
-  VALUE ret = Thread_switch_fiber(rb_thread_current());
-  
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else {
-    return ret;
-  }
-}
-
-static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
-  VALUE arg = (argc == 0) ? Qnil : argv[0];
-  VALUE ret = rb_funcall(self, ID_transfer, 1, arg);
-
-  // fiber is resumed, check if resumed value is an exception
-  return RTEST(rb_obj_is_kind_of(ret, rb_eException)) ? 
-    rb_funcall(rb_mKernel, ID_raise, 1, ret) : ret;
-}
-
-static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
-  VALUE value = (argc == 0) ? Qnil : argv[0];
-  Gyro_schedule_fiber(self, value);
-  return self;
-}
-
-static VALUE Fiber_state(VALUE self) {
-  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
-    return SYM_dead;
-  if (rb_fiber_current() == self) return SYM_running;
-  if (rb_ivar_get(self, ID_runnable) != Qnil) return SYM_runnable;
-  
-  return SYM_waiting;
-}
-
-void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
-  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
-  if (thread != Qnil) {
-    Thread_schedule_fiber(thread, fiber, value);
-  }
-  else {
-    rb_warn("No thread set for fiber");
-  }
-}
-
-VALUE Gyro_trace(VALUE self, VALUE enabled) {
-  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
-  return Qnil;
-}
-
-void Init_Gyro() {
-  mGyro = rb_define_module("Gyro");
-
-  rb_define_singleton_method(mGyro, "post_fork", Gyro_post_fork, 0);
-  rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
-  rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
-  rb_define_singleton_method(mGyro, "trace", Gyro_trace, 1);
-
-  rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
-  // rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 0);
-
-  rb_define_global_function("snooze", Gyro_snooze, 0);
-  rb_define_global_function("suspend", Gyro_suspend, 0);
-
-  VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
-  rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
-  rb_define_method(cFiber, "schedule", Fiber_schedule, -1);
-  rb_define_method(cFiber, "state", Fiber_state, 0);
-
-  ID_call           = rb_intern("call");
-  ID_caller         = rb_intern("caller");
-  ID_clear          = rb_intern("clear");
-  ID_each           = rb_intern("each");
-  ID_empty          = rb_intern("empty?");
-  ID_inspect        = rb_intern("inspect");
-  ID_ivar_running   = rb_intern("@running");
-  ID_ivar_thread    = rb_intern("@thread");
-  ID_new            = rb_intern("new");
-  ID_pop            = rb_intern("pop");
-  ID_push           = rb_intern("push");
-  ID_raise          = rb_intern("raise");
-  ID_runnable       = rb_intern("runnable");
-  ID_runnable_value = rb_intern("runnable_value");
-  ID_signal_bang    = rb_intern("signal!");
-  ID_size           = rb_intern("size");
-  ID_switch_fiber   = rb_intern("switch_fiber");
-  ID_transfer       = rb_intern("transfer");
-
-  ID_R              = rb_intern("r");
-  ID_RW             = rb_intern("rw");
-  ID_W              = rb_intern("w");
-
-  ID_fiber_trace          = rb_intern("__fiber_trace__");
-
-  #define GLOBAL_SYM(sym) var = ID2SYM(rb_intern(sym)); rb_global_variable(sym)
-
-  SYM_dead = ID2SYM(rb_intern("dead"));
-  SYM_running = ID2SYM(rb_intern("running"));
-  SYM_runnable = ID2SYM(rb_intern("runnable"));
-  SYM_waiting = ID2SYM(rb_intern("waiting"));
-  rb_global_variable(&SYM_dead);
-  rb_global_variable(&SYM_running);
-  rb_global_variable(&SYM_runnable);
-  rb_global_variable(&SYM_waiting);
-
-  SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));
-  SYM_fiber_ev_loop_enter = ID2SYM(rb_intern("fiber_ev_loop_enter"));
-  SYM_fiber_ev_loop_leave = ID2SYM(rb_intern("fiber_ev_loop_leave"));
-  SYM_fiber_run           = ID2SYM(rb_intern("fiber_run"));
-  SYM_fiber_schedule      = ID2SYM(rb_intern("fiber_schedule"));
-  SYM_fiber_switchpoint   = ID2SYM(rb_intern("fiber_switchpoint"));
-  SYM_fiber_terminate     = ID2SYM(rb_intern("fiber_terminate"));
-  rb_global_variable(&SYM_fiber_create);
-  rb_global_variable(&SYM_fiber_ev_loop_enter);
-  rb_global_variable(&SYM_fiber_ev_loop_leave);
-  rb_global_variable(&SYM_fiber_run);
-  rb_global_variable(&SYM_fiber_schedule);
-  rb_global_variable(&SYM_fiber_switchpoint);
-  rb_global_variable(&SYM_fiber_terminate);
-}

data/ext/gyro/gyro_ext.c

@@ -1,31 +0,0 @@
-#include "gyro.h"
-
-void Init_Gyro();
-void Init_Gyro_Async();
-void Init_Gyro_Child();
-void Init_Gyro_IO();
-void Init_Gyro_Queue();
-void Init_Gyro_Selector();
-void Init_Gyro_Signal();
-void Init_Gyro_Timer();
-void Init_Socket();
-void Init_Thread();
-void Init_Tracing();
-
-void Init_gyro_ext() {
-  ev_set_allocator(xrealloc);
-
-  Init_Gyro();
-  Init_Gyro_Async();
-  Init_Gyro_Child();
-  Init_Gyro_IO();
-  Init_Gyro_Queue();
-  Init_Gyro_Selector();
-  Init_Gyro_Signal();
-  Init_Gyro_Timer();
-
-  Init_Socket();
-  Init_Thread();
-
-  Init_Tracing();
-}

data/ext/gyro/io.c

@@ -1,447 +0,0 @@
-#include "gyro.h"
-
-#ifdef GetReadFile
-# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
-#else
-# define FPTR_TO_FD(fptr) fptr->fd
-#endif /* GetReadFile */
-
-struct Gyro_IO {
-  struct  ev_io ev_io;
-  struct  ev_loop *ev_loop;
-  int     active;
-  int     event_mask;
-  VALUE   fiber;
-};
-
-VALUE cGyro_IO = Qnil;
-
-ID ID_ivar_read_watcher;
-ID ID_ivar_write_watcher;
-VALUE SYM_r;
-VALUE SYM_w;
-
-static void Gyro_IO_mark(void *ptr) {
-  struct Gyro_IO *io = ptr;
-  if (io->fiber != Qnil) {
-    rb_gc_mark(io->fiber);
-  }
-}
-
-static void Gyro_IO_free(void *ptr) {
-  struct Gyro_IO *io = ptr;
-  if (io->active) {
-    printf("IO watcher garbage collected while still active!\n");
-  }
-  xfree(io);
-}
-
-static size_t Gyro_IO_size(const void *ptr) {
-  return sizeof(struct Gyro_IO);
-}
-
-static const rb_data_type_t Gyro_IO_type = {
-    "Gyro_IO",
-    {Gyro_IO_mark, Gyro_IO_free, Gyro_IO_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE Gyro_IO_allocate(VALUE klass) {
-  struct Gyro_IO *io = (struct Gyro_IO *)xmalloc(sizeof(struct Gyro_IO));
-
-  return TypedData_Wrap_Struct(klass, &Gyro_IO_type, io);
-}
-
-static const char * S_IO = "IO";
-static const char * S_to_io = "to_io";
-
-void Gyro_IO_callback(struct ev_loop *ev_loop, struct ev_io *ev_io, int revents) {
-  struct Gyro_IO *io = (struct Gyro_IO*)ev_io;
-
-  ev_io_stop(io->ev_loop, ev_io);
-  io->active = 0;
-
-  if (io->fiber != Qnil) {
-    VALUE fiber = io->fiber;
-    io->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, Qnil);
-  }
-}
-
-static int Gyro_IO_symbol2event_mask(VALUE sym) {
-  ID sym_id;
-
-  if (NIL_P(sym)) {
-    return 0;
-  }
-
-  sym_id = SYM2ID(sym);
-
-  if(sym_id == ID_R) {
-    return EV_READ;
-  } else if(sym_id == ID_W) {
-    return EV_WRITE;
-  } else if(sym_id == ID_RW) {
-    return EV_READ | EV_WRITE;
-  } else {
-    rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
-      RSTRING_PTR(rb_funcall(sym, ID_inspect, 0)));
-  }
-}
-
-#define GetGyro_IO(obj, io) TypedData_Get_Struct((obj), struct Gyro_IO, &Gyro_IO_type, (io))
-
-static VALUE Gyro_IO_initialize(VALUE self, VALUE io_obj, VALUE event_mask) {
-  struct Gyro_IO *io;
-  rb_io_t *fptr;
-
-  GetGyro_IO(self, io);
-
-  io->event_mask = Gyro_IO_symbol2event_mask(event_mask);
-  io->fiber = Qnil;
-  io->active = 0;
-
-  GetOpenFile(rb_convert_type(io_obj, T_FILE, S_IO, S_to_io), fptr);
-  ev_io_init(&io->ev_io, Gyro_IO_callback, FPTR_TO_FD(fptr), io->event_mask);
-
-  return Qnil;
-}
-
-VALUE Gyro_IO_await(VALUE self) {
-  struct Gyro_IO *io;
-  VALUE ret;
-  
-  GetGyro_IO(self, io);
-
-  io->fiber = rb_fiber_current();
-  io->active = 1;
-  io->ev_loop = Gyro_Selector_current_thread_ev_loop();
-  ev_io_start(io->ev_loop, &io->ev_io);
-
-  ret = Fiber_await();
-  RB_GC_GUARD(ret);
-
-  if (io->active) {
-    io->active = 0;
-    io->fiber = Qnil;
-    ev_io_stop(io->ev_loop, &io->ev_io);
-  }
-
-  // fiber is resumed, check if resumed value is an exception
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else {
-    return Qnil;
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
-// the following is copied verbatim from the Ruby source code (io.c)
-struct io_internal_read_struct {
-    int fd;
-    int nonblock;
-    void *buf;
-    size_t capa;
-};
-
-int io_setstrbuf(VALUE *str, long len) {
-  #ifdef _WIN32
-    len = (len + 1) & ~1L;	/* round up for wide char */
-  #endif
-  if (NIL_P(*str)) {
-    *str = rb_str_new(0, len);
-    return 1;
-  }
-  else {
-    VALUE s = StringValue(*str);
-    long clen = RSTRING_LEN(s);
-    if (clen >= len) {
-      rb_str_modify(s);
-      return 0;
-    }
-    len -= clen;
-  }
-  rb_str_modify_expand(*str, len);
-  return 0;
-}
-
-#define MAX_REALLOC_GAP 4096
-static void io_shrink_read_string(VALUE str, long n) {
-  if (rb_str_capacity(str) - n > MAX_REALLOC_GAP) {
-    rb_str_resize(str, n);
-  }
-}
-
-void io_set_read_length(VALUE str, long n, int shrinkable) {
-  if (RSTRING_LEN(str) != n) {
-    rb_str_modify(str);
-    rb_str_set_len(str, n);
-    if (shrinkable) io_shrink_read_string(str, n);
-  }
-}
-
-static rb_encoding* io_read_encoding(rb_io_t *fptr) {
-    if (fptr->encs.enc) {
-	return fptr->encs.enc;
-    }
-    return rb_default_external_encoding();
-}
-
-VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
-    OBJ_TAINT(str);
-    rb_enc_associate(str, io_read_encoding(fptr));
-    return str;
-}
-
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
-
-static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
-  VALUE underlying_io = rb_iv_get(io, "@io");
-  if (!NIL_P(underlying_io)) io = underlying_io;
-
-  long len = argc == 1 ? NUM2LONG(argv[0]) : (1 << 30);
-
-  rb_io_t *fptr;
-  long n;
-  int shrinkable;
-  VALUE read_watcher = Qnil;
-
-  if (len < 0) {
-    rb_raise(rb_eArgError, "negative length %ld given", len);
-  }
-
-  VALUE str = argc >= 2 ? argv[1] : Qnil;
-
-  shrinkable = io_setstrbuf(&str, len);
-  OBJ_TAINT(str);
-  GetOpenFile(io, fptr);
-  rb_io_check_byte_readable(fptr);
-  rb_io_set_nonblock(fptr);
-
-  if (len == 0)
-  	return str;
-  
-  char *buf = RSTRING_PTR(str);
-  long total = 0;
-
-  while (1) {
-    n = read(fptr->fd, buf, len);
-    if (n < 0) {
-      int e = errno;
-      if ((e == EWOULDBLOCK || e == EAGAIN)) {
-        if (read_watcher == Qnil)
-          read_watcher = IO_read_watcher(io);
-        Gyro_IO_await(read_watcher);
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
-    }
-    else if (n == 0)
-      break;
-    else {
-      total = total + n;
-      buf += n;
-      len -= n;
-      if (len == 0)
-        break;
-    }
-  }
-
-  if (total == 0)
-    return Qnil;
-
-  io_set_read_length(str, total, shrinkable);
-  io_enc_str(str, fptr);
-
-  return str;
-}
-
-#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)
-#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(size_t)(n))
-
-static long
-read_buffered_data(char *ptr, long len, rb_io_t *fptr)
-{
-    int n;
-
-    n = READ_DATA_PENDING_COUNT(fptr);
-    if (n <= 0) return 0;
-    if (n > len) n = (int)len;
-    MEMMOVE(ptr, fptr->rbuf.ptr+fptr->rbuf.off, char, n);
-    fptr->rbuf.off += n;
-    fptr->rbuf.len -= n;
-    return n;
-}
-
-static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
-  VALUE underlying_io = rb_iv_get(io, "@io");
-  if (!NIL_P(underlying_io)) io = underlying_io;
-
-  long len = argc >= 1 ? NUM2LONG(argv[0]) : 8192;
-
-  rb_io_t *fptr;
-  long n;
-  int shrinkable;
-  VALUE read_watcher = Qnil;
-
-  if (len < 0) {
-    rb_raise(rb_eArgError, "negative length %ld given", len);
-  }
-
-  VALUE str = argc >= 2 ? argv[1] : Qnil;
-
-  shrinkable = io_setstrbuf(&str, len);
-  OBJ_TAINT(str);
-  GetOpenFile(io, fptr);
-  rb_io_set_nonblock(fptr);
-  rb_io_check_byte_readable(fptr);
-
-  if (len == 0)
-  	return str;
-
-  n = read_buffered_data(RSTRING_PTR(str), len, fptr);
-  if (n <= 0) {
-    while (1) {
-      n = read(fptr->fd, RSTRING_PTR(str), len);
-      if (n < 0) {
-        int e = errno;
-        if (e == EWOULDBLOCK || e == EAGAIN) {
-          if (read_watcher == Qnil)
-            read_watcher = IO_read_watcher(io);
-          Gyro_IO_await(read_watcher);
-        }
-        else
-          rb_syserr_fail(e, strerror(e));
-          // rb_syserr_fail_path(e, fptr->pathv);
-      }
-      else
-        break;
-    }
-  }
-
-  io_set_read_length(str, n, shrinkable);
-  io_enc_str(str, fptr);
-
-  // ensure yielding to reactor if haven't yielded while reading
-  // if (read_watcher == Qnil) {
-  //   Gyro_snooze(Qnil);
-  // }
-
-  if (n == 0)
-    return Qnil;
-
-  return str;
-}
-
-static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
-  VALUE underlying_io = rb_iv_get(io, "@io");
-  if (!NIL_P(underlying_io)) io = underlying_io;
-
-  long i;
-  long n;
-  long total = 0;
-  rb_io_t *fptr;
-
-  io = rb_io_get_write_io(io);
-  VALUE write_watcher = Qnil;
-
-  GetOpenFile(io, fptr);
-  rb_io_check_writable(fptr);
-  rb_io_set_nonblock(fptr);
-
-  for (i = 0; i < argc; i++) {
-    VALUE str = argv[i];
-    if (!RB_TYPE_P(str, T_STRING))
-	    str = rb_obj_as_string(str);
-    char *buf = RSTRING_PTR(str);
-    long len = RSTRING_LEN(str);
-    RB_GC_GUARD(str);
-    while (1) {
-      n = write(fptr->fd, buf, len);
-
-      if (n < 0) {
-        int e = errno;
-        if (e == EWOULDBLOCK || e == EAGAIN) {
-          if (write_watcher == Qnil)
-            write_watcher = IO_write_watcher(io);
-          Gyro_IO_await(write_watcher);
-        }
-        else {
-          rb_syserr_fail(e, strerror(e));
-          // rb_syserr_fail_path(e, fptr->pathv);
-        }
-      }
-      else {
-        total += n;
-        if (n < len) {
-          buf += n;
-          len -= n;
-        }
-        else break;
-      }
-    }
-  }
-
-  // ensure yielding to reactor if haven't yielded while writing
-  // if (write_watcher == Qnil) {
-  //   Gyro_snooze(Qnil);
-  // }
-
-  return LONG2FIX(total);
-}
-
-static VALUE IO_write_chevron(VALUE io, VALUE str) {
-  IO_write(1, &str, io);
-  return io;
-}
-
-VALUE IO_read_watcher(VALUE self) {
-  VALUE watcher = rb_ivar_get(self, ID_ivar_read_watcher);
-  if (watcher == Qnil) {
-    VALUE args[] = {self, SYM_r};
-    watcher = rb_class_new_instance(2, args, cGyro_IO);
-    rb_ivar_set(self, ID_ivar_read_watcher, watcher);
-  }
-  return watcher;
-}
-
-VALUE IO_write_watcher(VALUE self) {
-  VALUE watcher = rb_ivar_get(self, ID_ivar_write_watcher);
-  if (watcher == Qnil) {
-    VALUE args[] = {self, SYM_w};
-    watcher = rb_class_new_instance(2, args, cGyro_IO);
-    rb_ivar_set(self, ID_ivar_write_watcher, watcher);
-  }
-  return watcher;
-}
-
-void Init_Gyro_IO() {
-  cGyro_IO = rb_define_class_under(mGyro, "IO", rb_cData);
-  rb_define_alloc_func(cGyro_IO, Gyro_IO_allocate);
-
-  rb_define_method(cGyro_IO, "initialize", Gyro_IO_initialize, 2);
-  rb_define_method(cGyro_IO, "await", Gyro_IO_await, 0);
-
-  VALUE cIO = rb_const_get(rb_cObject, rb_intern("IO"));
-  // rb_define_method(cIO, "gets", IO_gets, -1);
-  rb_define_method(cIO, "read", IO_read, -1);
-  rb_define_method(cIO, "readpartial", IO_readpartial, -1);
-  rb_define_method(cIO, "write", IO_write, -1);
-  rb_define_method(cIO, "write_nonblock", IO_write, -1);
-  rb_define_method(cIO, "<<", IO_write_chevron, 1);
-  rb_define_method(cIO, "read_watcher", IO_read_watcher, 0);
-  rb_define_method(cIO, "write_watcher", IO_write_watcher, 0);
-
-  ID_ivar_read_watcher = rb_intern("@read_watcher");
-  ID_ivar_write_watcher = rb_intern("@write_watcher");
-  SYM_r = ID2SYM(rb_intern("r"));
-  SYM_w = ID2SYM(rb_intern("w"));
-
-  rb_global_variable(&SYM_r);
-  rb_global_variable(&SYM_w);
-}