polyphony 0.36 → 0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1baba43b46fa48ea13ec33667390b5b6dafb8323d250f2df5e5ee6930e939680
-  data.tar.gz: 465c329841226252b1fe7fc3d48904b912323370083b4925d89531e45a4bd34d
+  metadata.gz: b952f96f313866e5b61e200093fcb1eb8111b2d48bb2a736e36b62f06772786c
+  data.tar.gz: 03ffbc7481d3e20cfd5d50cc0c7e1e28749da15a6c9d65c89e83a0370b61b2d2
 SHA512:
-  metadata.gz: d9b863d0231a5ccea65aa015d5a1d3432d0b513be1a60b2d20040bd06ed9d253c6be8391176ceba472300beac8059e27c334aca3bb6bafd51c3dabfd1e105301
-  data.tar.gz: 29eba3a894084f20d21bab00840cef76a5094f73aee4521947685883dc717811a274ed723deb72433cc0f358715549d79215286aad0ba62d14ee97308ee1415b
+  metadata.gz: 8fb34d135a0ab50a3e3ae722dd3f9ae70ba8ee83534c199f98611f5fa273b424fcedab548929a2dedcdaddec73a9aa6b652fa97a924dd5400155cf57a1cdcaf0
+  data.tar.gz: caacb6a006f52abf888a9f4a3f1ef2c917a73422abaf1cba7d1ae1b0c7db07a3bc62a5a6b6abbe22e46fd6e679e82d7a048ec2d9ac7ec7dee54453600c688597

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.38 2020-04-13
+
+* Fix post-fork segfault if parent process has multiple threads with active watchers
+
+## 0.37 2020-04-07
+
+* Explicitly kill threads on exit to prevent possible segfault
+* Remove Modulation dependency
+
 ## 0.36 2020-03-31
 
 * More docs

data/Gemfile

@@ -1,14 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-# gem "jekyll", "~> 3.8.6"
-# gem "jekyll-remote-theme"
-# gem "jekyll-seo-tag"
-# gem "just-the-docs"
-
-# # gem "github-pages", group: :jekyll_plugins
-
-# group :jekyll_plugins do
-#   gem "jekyll-feed", "~> 0.6"
-# end

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.36)
-      modulation (~> 1.0)
+    polyphony (0.38)
 
 GEM
   remote: https://rubygems.org/
@@ -73,7 +72,6 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
-    modulation (1.0)
     multi_xml (0.6.0)
     parallel (1.19.1)
     parser (2.7.0.2)

data/Rakefile

@@ -15,6 +15,10 @@ task :test do
   exec 'ruby test/run.rb'
 end
 
+task :stress_test do
+  exec 'ruby test/stress.rb'
+end
+
 task :docs do
   exec 'RUBYOPT=-W0 jekyll serve -s docs'
 end

data/TODO.md

@@ -32,7 +32,11 @@
   Fiber.current.add_child_fiber(t.main_fiber)
   ```
 
-## 0.36 Some more API work, more docs
+
+
+
+
+## 0.40 Some more API work, more docs
 
 - Debugging
   - Eat your own dogfood: need a good tool to check what's going on when some
@@ -142,17 +146,15 @@
 - Docs
   - landing page:
     - links to the interesting stuff
-      - concurrency overview
-      - faq
       - benchmarks
   - explain difference between `sleep` and `suspend`
-  - add explanation about async vs sync
+  - add explanation about async vs sync, blocking vs non-blocking
   - discuss using `snooze` for ensuring responsiveness when executing CPU-bound work
 
 - Check why first call to `#sleep` returns too early in tests. Check the
   sleep behaviour in a spawned thread.
 
-## 0.37 Sinatra / Sidekiq
+## 0.41 Sinatra / Sidekiq
 
 - sintra app with database access (postgresql)
 
@@ -162,13 +164,13 @@
   - test performance
   - proceed from there
 
-## 0.38 Testing && Docs
+## 0.42 Testing && Docs
 
 - Pull out redis/postgres code, put into new `polyphony-xxx` gems
 
-## 0.39 Integration
+## 0.43 Integration
 
-## 0.40 Real IO#gets and IO#read
+## 0.44 Real IO#gets and IO#read
 
 - More tests
 - Implement some basic stuff missing:
@@ -178,11 +180,11 @@
   - `IO.foreach`
   - `Process.waitpid`
 
-## 0.41 Rails
+## 0.45 Rails
 
 - Rails?
 
-## 0.42 DNS
+## 0.46 DNS
 
 ### DNS client
 

data/docs/index.md

@@ -14,8 +14,9 @@ implements a comprehensive
 using [libev](https://github.com/enki/libev) as a high-performance event reactor
 for I/O, timers, and other asynchronous events.
 
-[FAQ](faq){: .btn .btn-green .text-gamma }
 [Take the tutorial](getting-started/tutorial){: .btn .btn-blue .text-gamma }
+[Main Concepts](main-concepts/concurrency/){: .btn .btn-green .text-gamma }
+[FAQ](faq){: .btn .btn-green .text-gamma }
 [Source code](https://github.com/digital-fabric/polyphony){: .btn .btn-purple .text-gamma target="_blank" }
 {: .mt-6 .h-align-center }
 

data/examples/core/xx-fork-cleanup.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+t = Thread.new do
+  async = Gyro::Async.new
+  spin { async.await }
+  sleep 100
+end
+
+sleep 0.5
+
+Polyphony.fork do
+  puts "forked #{Process.pid}"
+  sleep 1
+  puts "done sleeping"
+end
+
+sleep 50

data/ext/gyro/async.c

@@ -27,11 +27,15 @@ static void Gyro_Async_mark(void *ptr) {
 
 static void Gyro_Async_free(void *ptr) {
   struct Gyro_Async *async = ptr;
-  if (async->active) {
-    ev_clear_pending(async->ev_loop, &async->ev_async);
-    ev_async_stop(async->ev_loop, &async->ev_async);
+  switch (async->active) {
+    case GYRO_WATCHER_POST_FORK:
+      return;
+    case 1:
+      ev_clear_pending(async->ev_loop, &async->ev_async);
+      ev_async_stop(async->ev_loop, &async->ev_async);
+    default:
+      xfree(async);
   }
-  xfree(async);
 }
 
 static size_t Gyro_Async_size(const void *ptr) {
@@ -49,7 +53,7 @@ static VALUE Gyro_Async_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Async_type, async);
 }
 
-inline void Gyro_Async_activate(struct Gyro_Async *async) {
+inline void async_activate(struct Gyro_Async *async) {
   if (async->active) return;
 
   async->active = 1;
@@ -60,7 +64,7 @@ inline void Gyro_Async_activate(struct Gyro_Async *async) {
   ev_async_start(async->ev_loop, &async->ev_async);
 }
 
-inline void Gyro_Async_deactivate(struct Gyro_Async *async) {
+inline void async_deactivate(struct Gyro_Async *async) {
   if (!async->active) return;
 
   ev_async_stop(async->ev_loop, &async->ev_async);
@@ -76,7 +80,7 @@ void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int
   struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
 
   Fiber_make_runnable(async->fiber, async->value);
-  Gyro_Async_deactivate(async);
+  async_deactivate(async);
 }
 
 #define GetGyro_Async(obj, async) \
@@ -117,22 +121,31 @@ VALUE Gyro_Async_await(VALUE self) {
   struct Gyro_Async *async;
   GetGyro_Async(self, async);
 
-  Gyro_Async_activate(async);
+  async_activate(async);
   VALUE ret = Gyro_switchpoint();
-  Gyro_Async_deactivate(async);
+  async_deactivate(async);
 
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
+VALUE Gyro_Async_deactivate_post_fork(VALUE self) {
+  struct Gyro_Async *async;
+  GetGyro_Async(self, async);
+
+  if (async->active)
+    async->active = GYRO_WATCHER_POST_FORK;
+  return self;
+}
+
 VALUE Gyro_Async_await_no_raise(VALUE self) {
   struct Gyro_Async *async;
   GetGyro_Async(self, async);
 
-  Gyro_Async_activate(async);
+  async_activate(async);
   VALUE ret = Gyro_switchpoint();
-  Gyro_Async_deactivate(async);
+  async_deactivate(async);
   
   RB_GC_GUARD(ret);
   return ret;
@@ -143,6 +156,7 @@ void Init_Gyro_Async() {
   rb_define_alloc_func(cGyro_Async, Gyro_Async_allocate);
 
   rb_define_method(cGyro_Async, "initialize", Gyro_Async_initialize, 0);
-  rb_define_method(cGyro_Async, "signal", Gyro_Async_signal, -1);
   rb_define_method(cGyro_Async, "await", Gyro_Async_await, 0);
-}
+  rb_define_method(cGyro_Async, "deactivate_post_fork", Gyro_Async_deactivate_post_fork, 0);
+  rb_define_method(cGyro_Async, "signal", Gyro_Async_signal, -1);
+}

data/ext/gyro/child.c

@@ -24,11 +24,15 @@ static void Gyro_Child_mark(void *ptr) {
 
 static void Gyro_Child_free(void *ptr) {
   struct Gyro_Child *child = ptr;
-  if (child->active) {
-    ev_clear_pending(child->ev_loop, &child->ev_child);
-    ev_child_stop(child->ev_loop, &child->ev_child);
+  switch (child->active) {
+    case GYRO_WATCHER_POST_FORK:
+      return;
+    case 1:
+      ev_clear_pending(child->ev_loop, &child->ev_child);
+      ev_child_stop(child->ev_loop, &child->ev_child);
+    default:
+      xfree(child);
   }
-  xfree(child);
 }
 
 static size_t Gyro_Child_size(const void *ptr) {
@@ -46,7 +50,7 @@ static VALUE Gyro_Child_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Child_type, child);
 }
 
-inline void Gyro_Child_activate(struct Gyro_Child *child) {
+inline void child_activate(struct Gyro_Child *child) {
   if (child->active) return;
 
   child->active = 1;
@@ -57,7 +61,7 @@ inline void Gyro_Child_activate(struct Gyro_Child *child) {
   ev_child_start(child->ev_loop, &child->ev_child);
 }
 
-inline void Gyro_Child_deactivate(struct Gyro_Child *child) {
+inline void child_deactivate(struct Gyro_Child *child) {
   if (!child->active) return;
 
   ev_child_stop(child->ev_loop, &child->ev_child);
@@ -82,7 +86,7 @@ void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *ev_child, int
   VALUE resume_value = Gyro_Child_resume_value(ev_child);
   Fiber_make_runnable(child->fiber, resume_value);
 
-  Gyro_Child_deactivate(child);
+  child_deactivate(child);
 }
 
 #define GetGyro_Child(obj, child) \
@@ -93,12 +97,12 @@ static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
 
   GetGyro_Child(self, child);
 
-  child->self     = self;
-  child->fiber    = Qnil;
-  child->selector = Qnil;
-  child->pid      = NUM2INT(pid);
-  child->active   = 0;
-  child->ev_loop  = 0;
+  child->self       = self;
+  child->fiber      = Qnil;
+  child->selector   = Qnil;
+  child->pid        = NUM2INT(pid);
+  child->active     = 0;
+  child->ev_loop    = 0;
   
   ev_child_init(&child->ev_child, Gyro_Child_callback, child->pid, 0);
 
@@ -109,19 +113,29 @@ static VALUE Gyro_Child_await(VALUE self) {
   struct Gyro_Child *child;
   GetGyro_Child(self, child);
 
-  Gyro_Child_activate(child);
+  child_activate(child);
   VALUE ret = Gyro_switchpoint();
-  Gyro_Child_deactivate(child);
+  child_deactivate(child);
 
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
+VALUE Gyro_Child_deactivate_post_fork(VALUE self) {
+  struct Gyro_Child *child;
+  GetGyro_Child(self, child);
+
+  if (child->active)
+    child->active = GYRO_WATCHER_POST_FORK;
+  return self;
+}
+
 void Init_Gyro_Child() {
   cGyro_Child = rb_define_class_under(mGyro, "Child", rb_cData);
   rb_define_alloc_func(cGyro_Child, Gyro_Child_allocate);
 
   rb_define_method(cGyro_Child, "initialize", Gyro_Child_initialize, 1);
   rb_define_method(cGyro_Child, "await", Gyro_Child_await, 0);
+  rb_define_method(cGyro_Child, "deactivate_post_fork", Gyro_Child_deactivate_post_fork, 0);
 }

data/ext/gyro/fiber.c

@@ -71,7 +71,9 @@ void Fiber_make_runnable(VALUE fiber, VALUE value) {
     Thread_schedule_fiber(thread, fiber, value);
   }
   else {
-    rb_warn("No thread set for fiber");
+    rb_warn("No thread set for fiber (fiber, value, caller):");
+    VALUE caller = rb_funcall(rb_cObject, rb_intern("caller"), 0);
+    INSPECT(3, fiber, value, caller);
   }
 }
 

data/ext/gyro/gyro.c

@@ -44,11 +44,6 @@ VALUE Gyro_snooze(VALUE self) {
   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());
 }
@@ -73,7 +68,6 @@ VALUE Gyro_trace(VALUE self, VALUE enabled) {
 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);

data/ext/gyro/gyro.h

@@ -59,6 +59,12 @@ enum {
   FIBER_STATE_SCHEDULED     = 2
 };
 
+// watcher flags
+enum {
+  // a watcher's active field will be set to this after fork
+  GYRO_WATCHER_POST_FORK = 0xFF
+};
+
 VALUE Fiber_auto_async(VALUE self);
 VALUE Fiber_auto_io(VALUE self);
 void Fiber_make_runnable(VALUE fiber, VALUE value);

data/ext/gyro/io.c

@@ -34,11 +34,15 @@ static void Gyro_IO_mark(void *ptr) {
 
 static void Gyro_IO_free(void *ptr) {
   struct Gyro_IO *io = ptr;
-  if (io->active) {
-    ev_clear_pending(io->ev_loop, &io->ev_io);
-    ev_io_stop(io->ev_loop, &io->ev_io);
+  switch (io->active) {
+    case GYRO_WATCHER_POST_FORK:
+      return;
+    case 1:
+      ev_clear_pending(io->ev_loop, &io->ev_io);
+      ev_io_stop(io->ev_loop, &io->ev_io);
+    default:
+      xfree(io);
   }
-  xfree(io);
 }
 
 static size_t Gyro_IO_size(const void *ptr) {
@@ -57,7 +61,7 @@ static VALUE Gyro_IO_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_IO_type, io);
 }
 
-inline void Gyro_IO_activate(struct Gyro_IO *io) {
+inline void io_activate(struct Gyro_IO *io) {
   if (io->active) return;
 
   io->active = 1;
@@ -68,7 +72,7 @@ inline void Gyro_IO_activate(struct Gyro_IO *io) {
   ev_io_start(io->ev_loop, &io->ev_io);
 }
 
-inline void Gyro_IO_deactivate(struct Gyro_IO *io) {
+inline void io_deactivate(struct Gyro_IO *io) {
   if (!io->active) return;
 
   ev_io_stop(io->ev_loop, &io->ev_io);
@@ -83,7 +87,7 @@ 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;
 
   Fiber_make_runnable(io->fiber, Qnil);
-  Gyro_IO_deactivate(io);
+  io_deactivate(io);
 }
 
 static int Gyro_IO_symbol2event_mask(VALUE sym) {
@@ -143,15 +147,25 @@ VALUE Gyro_IO_await(VALUE self) {
   struct Gyro_IO *io;
   GetGyro_IO(self, io);
 
-  Gyro_IO_activate(io);
+  io_activate(io);
   VALUE ret = Gyro_switchpoint();
-  Gyro_IO_deactivate(io);
+  io_deactivate(io);
 
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
+VALUE Gyro_IO_deactivate_post_fork(VALUE self) {
+  struct Gyro_IO *io;
+  GetGyro_IO(self, io);
+
+  if (io->active)
+    io->active = GYRO_WATCHER_POST_FORK;
+
+  return self;
+}
+
 VALUE Gyro_IO_auto_io(int fd, int events) {
   VALUE watcher = Fiber_auto_io(rb_fiber_current());
   struct Gyro_IO *io;
@@ -453,6 +467,7 @@ void Init_Gyro_IO() {
 
   rb_define_method(cGyro_IO, "initialize", Gyro_IO_initialize, 2);
   rb_define_method(cGyro_IO, "await", Gyro_IO_await, 0);
+  rb_define_method(cGyro_IO, "deactivate_post_fork", Gyro_IO_deactivate_post_fork, 0);
 
   VALUE cIO = rb_const_get(rb_cObject, rb_intern("IO"));
   // rb_define_method(cIO, "gets", IO_gets, -1);