polyphony 0.19 → 0.20

data/examples/core/nested_async.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-spin do
-  puts "going to sleep"
-  result = async do
-    async do
-      async do
-        puts "Fiber count: #{Polyphony::FiberPool.size}"
-        sleep(1)
-      end.await
-    end.await
-  end.await
-  puts "result: #{result}"
-end

data/examples/core/next_tick.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-next_tick do
-  puts "two"
-  next_tick { puts "four" }
-  puts "three"
-end
-
-puts "one"

data/examples/core/sleep_spawn.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-spin {
-  10.times { |i|
-    sleep 0.1;
-    p i
-  }
-}
-
-spin {
-  puts "going to sleep..."
-  sleep 1
-  puts "woke up"
-}.await
-
-puts "done"

data/examples/core/spawn.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-def my_sleep(t)
-  puts "going to sleep..."
-  sleep t
-  puts "woke up"
-end
-
-spin do
-  async { my_sleep(1) }.await
-end

data/examples/core/spawn_error.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-Polyphony.debug = true
-
-def error(t)
-  raise "hello #{t}"
-end
-
-def spin_with_error
-  spin { error(2) }
-end
-
-spin do
-  error(1)
-rescue => e
-  e.cleanup_backtrace
-  puts "error: #{e.inspect}"
-  puts "backtrace:"
-  puts e.backtrace.reverse.join("\n")
-  puts
-end
-
-spin_with_error
-
-puts "done coprocing"

data/examples/performance/perf_multi_snooze.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-ITERATIONS  = 1_000
-FIBERS      = 1_000
-
-spin do
-  count = 0
-  t0 = Time.now
-  supervise do |s|
-    FIBERS.times do
-      s.spin do
-        ITERATIONS.times { snooze; count += 1 }
-      end
-    end
-  end
-  dt = Time.now - t0
-  puts "count: #{count} #{count / dt.to_f}/s"
-end

data/ext/ev/async.c

@@ -1,168 +0,0 @@
-#include "ev.h"
-
-struct EV_Async {
-  struct  ev_async ev_async;
-  int     active;
-  VALUE   callback;
-  VALUE   fiber;
-};
-
-static VALUE mEV = Qnil;
-static VALUE cEV_Async = Qnil;
-
-/* Allocator/deallocator */
-static VALUE EV_Async_allocate(VALUE klass);
-static void EV_Async_mark(void *ptr);
-static void EV_Async_free(void *ptr);
-static size_t EV_Async_size(const void *ptr);
-
-/* Methods */
-static VALUE EV_Async_initialize(VALUE self);
-
-static VALUE EV_Async_start(VALUE self);
-static VALUE EV_Async_stop(VALUE self);
-static VALUE EV_Async_signal(VALUE self);
-static VALUE EV_Async_await(VALUE self);
-
-void EV_Async_callback(ev_loop *ev_loop, struct ev_async *async, int revents);
-
-/* async encapsulates an async watcher */
-void Init_EV_Async() {
-  mEV = rb_define_module("EV");
-  
-  cEV_Async = rb_define_class_under(mEV, "Async", rb_cData);
-  rb_define_alloc_func(cEV_Async, EV_Async_allocate);
-
-  rb_define_method(cEV_Async, "initialize", EV_Async_initialize, 0);
-  rb_define_method(cEV_Async, "start", EV_Async_start, 0);
-  rb_define_method(cEV_Async, "stop", EV_Async_stop, 0);
-  rb_define_method(cEV_Async, "signal!", EV_Async_signal, 0);
-  rb_define_method(cEV_Async, "await", EV_Async_await, 0);
-}
-
-static const rb_data_type_t EV_Async_type = {
-    "EV_Async",
-    {EV_Async_mark, EV_Async_free, EV_Async_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE EV_Async_allocate(VALUE klass) {
-  struct EV_Async *async = (struct EV_Async *)xmalloc(sizeof(struct EV_Async));
-  return TypedData_Wrap_Struct(klass, &EV_Async_type, async);
-}
-
-static void EV_Async_mark(void *ptr) {
-  struct EV_Async *async = ptr;
-  if (async->callback != Qnil) {
-    rb_gc_mark(async->callback);
-  }
-  if (async->fiber != Qnil) {
-    rb_gc_mark(async->fiber);
-  }
-}
-
-static void EV_Async_free(void *ptr) {
-  struct EV_Async *async = ptr;
-  ev_async_stop(EV_DEFAULT, &async->ev_async);
-  xfree(async);
-}
-
-static size_t EV_Async_size(const void *ptr) {
-  return sizeof(struct EV_Async);
-}
-
-#define GetEV_Async(obj, async) \
-  TypedData_Get_Struct((obj), struct EV_Async, &EV_Async_type, (async))
-
-static VALUE EV_Async_initialize(VALUE self) {
-  struct EV_Async *async;
-  GetEV_Async(self, async);
-
-  if (rb_block_given_p()) {
-    async->callback = rb_block_proc();
-  }
-  async->fiber = Qnil;
-
-  ev_async_init(&async->ev_async, EV_Async_callback);
-
-  async->active = 1;
-  ev_async_start(EV_DEFAULT, &async->ev_async);
-
-  return Qnil;
-}
-
-void EV_Async_callback(ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
-  VALUE fiber;
-  struct EV_Async *async = (struct EV_Async*)ev_async;
-
-  if (async->fiber != Qnil) {
-    async->active = 0;
-    fiber = async->fiber;
-    async->fiber = Qnil;
-    SCHEDULE_FIBER(fiber, 0);
-  }
-  else if (async->callback != Qnil) {
-    rb_funcall(async->callback, ID_call, 1, Qtrue);
-  }
-}
-
-static VALUE EV_Async_start(VALUE self) {
-  struct EV_Async *async;
-  GetEV_Async(self, async);
-
-  if (!async->active) {
-    ev_async_start(EV_DEFAULT, &async->ev_async);
-    async->active = 1;
-  }
-
-  return self;
-}
-
-static VALUE EV_Async_stop(VALUE self) {
-  struct EV_Async *async;
-  GetEV_Async(self, async);
-
-  if (async->active) {
-    ev_async_stop(EV_DEFAULT, &async->ev_async);
-    async->active = 0;
-  }
-
-  return self;
-}
-
-static VALUE EV_Async_signal(VALUE self) {
-  struct EV_Async *async;
-  GetEV_Async(self, async);
-
-  ev_async_send(EV_DEFAULT, &async->ev_async);
-
-  return Qnil;
-}
-
-static VALUE EV_Async_await(VALUE self) {
-  struct EV_Async *async;
-  VALUE ret;
-  
-  GetEV_Async(self, async);
-
-  async->fiber = rb_fiber_current();
-  if (!async->active) {
-    async->active = 1;
-    ev_async_start(EV_DEFAULT, &async->ev_async);
-  }
-
-  ret = YIELD_TO_REACTOR();
-
-  // fiber is resumed
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    if (async->active) {
-      async->active = 0;
-      ev_async_stop(EV_DEFAULT, &async->ev_async);
-    }
-    return rb_funcall(ret, ID_raise, 1, ret);
-  }
-  else {
-    return Qnil;
-  }
-}

data/ext/ev/child.c

@@ -1,169 +0,0 @@
-#include "ev.h"
-
-struct EV_Child {
-  struct  ev_child ev_child;
-  int     active;
-  int     pid;
-  VALUE   self;
-  VALUE   callback;
-  VALUE   fiber;
-};
-
-static VALUE mEV = Qnil;
-static VALUE cEV_Child = Qnil;
-
-/* Allocator/deallocator */
-static VALUE EV_Child_allocate(VALUE klass);
-static void EV_Child_mark(void *ptr);
-static void EV_Child_free(void *ptr);
-static size_t EV_Child_size(const void *ptr);
-
-/* Methods */
-static VALUE EV_Child_initialize(VALUE self, VALUE pid);
-
-static VALUE EV_Child_start(VALUE self);
-static VALUE EV_Child_stop(VALUE self);
-static VALUE EV_Child_await(VALUE self);
-
-void EV_Child_callback(ev_loop *ev_loop, struct ev_child *child, int revents);
-
-/* Child encapsulates an child watcher */
-void Init_EV_Child() {
-  mEV = rb_define_module("EV");
-  cEV_Child = rb_define_class_under(mEV, "Child", rb_cData);
-  rb_define_alloc_func(cEV_Child, EV_Child_allocate);
-
-  rb_define_method(cEV_Child, "initialize", EV_Child_initialize, 1);
-  rb_define_method(cEV_Child, "start", EV_Child_start, 0);
-  rb_define_method(cEV_Child, "stop", EV_Child_stop, 0);
-  rb_define_method(cEV_Child, "await", EV_Child_await, 0);
-}
-
-static const rb_data_type_t EV_Child_type = {
-    "EV_Child",
-    {EV_Child_mark, EV_Child_free, EV_Child_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE EV_Child_allocate(VALUE klass) {
-  struct EV_Child *child = (struct EV_Child *)xmalloc(sizeof(struct EV_Child));
-  return TypedData_Wrap_Struct(klass, &EV_Child_type, child);
-}
-
-static void EV_Child_mark(void *ptr) {
-  struct EV_Child *child = ptr;
-  if (child->callback != Qnil) {
-    rb_gc_mark(child->callback);
-  }
-  if (child->fiber != Qnil) {
-    rb_gc_mark(child->fiber);
-  }
-}
-
-static void EV_Child_free(void *ptr) {
-  struct EV_Child *child = ptr;
-  if (child->active) {
-    ev_child_stop(EV_DEFAULT, &child->ev_child);
-  }
-  xfree(child);
-}
-
-static size_t EV_Child_size(const void *ptr) {
-  return sizeof(struct EV_Child);
-}
-
-#define GetEV_Child(obj, child) \
-  TypedData_Get_Struct((obj), struct EV_Child, &EV_Child_type, (child))
-
-static VALUE EV_Child_initialize(VALUE self, VALUE pid) {
-  struct EV_Child *child;
-
-  GetEV_Child(self, child);
-
-  child->self     = self;
-  child->callback = Qnil;
-  child->fiber    = Qnil;
-  child->pid      = NUM2INT(pid);
-  child->active   = 0;
-  
-  ev_child_init(&child->ev_child, EV_Child_callback, child->pid, 0);
-
-  return Qnil;
-}
-
-void EV_Child_callback(ev_loop *ev_loop, struct ev_child *ev_child, int revents) {
-  VALUE fiber;
-  VALUE resume_value;
-  struct EV_Child *child = (struct EV_Child*)ev_child;
-  resume_value = INT2NUM(child->pid);
-
-  child->active = 0;
-  ev_child_stop(EV_DEFAULT, ev_child);
-  EV_del_watcher_ref(child->self);
-
-  if (child->fiber != Qnil) {
-    fiber = child->fiber;
-    child->fiber = Qnil;
-    SCHEDULE_FIBER(fiber, 1, resume_value);
-  }
-  else if (child->callback != Qnil) {
-    rb_funcall(child->callback, ID_call, 1, resume_value);
-  }
-}
-
-static VALUE EV_Child_start(VALUE self) {
-  struct EV_Child *child;
-  GetEV_Child(self, child);
-
-  if (rb_block_given_p()) {
-    child->callback = rb_block_proc();
-  }
-
-  if (!child->active) {
-    ev_child_start(EV_DEFAULT, &child->ev_child);
-    child->active = 1;
-    EV_add_watcher_ref(self);
-  }
-
-  return self;
-}
-
-static VALUE EV_Child_stop(VALUE self) {
-  struct EV_Child *child;
-  GetEV_Child(self, child);
-
-  if (child->active) {
-    ev_child_stop(EV_DEFAULT, &child->ev_child);
-    child->active = 0;
-    EV_del_watcher_ref(self);
-  }
-
-  return self;
-}
-
-static VALUE EV_Child_await(VALUE self) {
-  struct EV_Child *child;
-  VALUE ret;
-  
-  GetEV_Child(self, child);
-
-  child->fiber = rb_fiber_current();
-  child->active = 1;
-  ev_child_start(EV_DEFAULT, &child->ev_child);
-  EV_add_watcher_ref(self);
-
-  ret = YIELD_TO_REACTOR();
-
-  // fiber is resumed, check if resumed value is an exception
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    if (child->active) {
-      child->active = 0;
-      ev_child_stop(EV_DEFAULT, &child->ev_child);
-    }
-    return rb_funcall(ret, ID_raise, 1, ret);
-  }
-  else {
-    return ret;
-  }
-}