polyphony 0.24 → 0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a8da629de739b6091367c7220fd4a69dd83d7c78eb6d8c55c67385c8ca3edb2
-  data.tar.gz: 351f78d8b9635b6bc2c9838d652781a66009554287cfb5486c9fe0a0748ed6d6
+  metadata.gz: c47fca95a744d36163d87e80cd0e56a23ae9a613d1df4970475db7a7b8840ba3
+  data.tar.gz: eebe2e1f3dd6fd3efe80cd60444c881978d7d0ff34d8c381fdd4324e77ef14a6
 SHA512:
-  metadata.gz: 768ed2703dd01653e5c71c2d17799b0c42fd9eb03f382dd3e4d3e4a337f7055d7a68643f479160febd3aa9412a9b66ccf0adf79f1608882ef0d61b625c8f7ed2
-  data.tar.gz: eab163c7ce680640def7fe6971359969202e6cb53238e8006c479e158c9b488bf73a2e575008a94cee1320fcf6899276da85df33d2fb00f97fa8133ad8fc3f06
+  metadata.gz: a266b7d3ef74d98a3a43bf4f821e3894295bae084a4ca7f067c3e63b1600ea6c6191e9fe39caa72166c0dba759bca5dc0cb47312de76e45b7028ce3c231f5166
+  data.tar.gz: d3cb27c65c01fa8984d88ba047fbfb30d08660a5afcfe3636af6302e47d3b45b5ba3908419eb8a867ed7ed96aa83d3ec03eadf7dd03542de04095fe7cf64c5f5

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+0.25 2020-01-10
+---------------
+
+* Fold `Coprocess` functionality into `Fiber`
+* Add support for indefinite `#sleep`
+
 0.24 2020-01-08
 ---------------
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.24)
+    polyphony (0.25)
       modulation (~> 1.0)
 
 GEM

data/TODO.md

@@ -1,14 +1,18 @@
-## 0.25 Move Other interface code into separate gem
+## 0.25 Merge Coprocess functionality into Fiber
 
-- Pull out redis/postgres code, put into new `polyphony-contrib` gem
+- Merge `Coprocess` functionality into `Fiber`
+  - Get rid of the duality Coprocess - Fiber
+  - exception handling
+  - interrupting (`MoveOn`/`Cancel`)
+  - message passing (`receive`/`send`)
+  - Clear separation between scheduling code and event handling code
+  - Check performance difference using `http_server.rb`. We should expect a
+    modest increase in throughput, as well as significantly less memory usage.
+- Handle calls to `#sleep` without duration (should just `#suspend`)
 
-## 0.26 Full Rack adapter implementation
+## 0.26 Move Other interface code into separate gem
 
-- Work better mechanism supervising multiple coprocesses (`when_done` feels a
-  bit hacky)
-- Add supervisor test
-- Homogenize HTTP 1 and HTTP 2 headers - upcase ? downcase ?
-- find some demo Rack apps and test with Polyphony
+- Pull out redis/postgres code, put into new `polyphony-contrib` gem
 
 ## 0.27 Working Sinatra application
 

data/docs/README.md

@@ -4,7 +4,7 @@
 > 1. _Music_ the style of simultaneously combining a number of parts, each forming an individual melody and harmonizing with each other.
 > 2. _Programming_ a Ruby gem for concurrent programming focusing on performance and developer happiness.
 
-Polyphony is a library for building concurrent applications in Ruby. Polyphony harnesses the power of [Ruby fibers](https://ruby-doc.org/core-2.5.1/Fiber.html) to provide a cooperative, sequential coprocess-based concurrency model. Under the hood, Polyphony uses [libev](https://github.com/enki/libev) as a high-performance event reactor that provides timers, I/O watchers and other asynchronous event primitives.
+Polyphony is a library for building concurrent applications in Ruby. Polyphony harnesses the power of [Ruby fibers](https://ruby-doc.org/core-2.5.1/Fiber.html) to provide a cooperative, sequential coroutine-based concurrency model. Under the hood, Polyphony uses [libev](https://github.com/enki/libev) as a high-performance event reactor that provides timers, I/O watchers and other asynchronous event primitives.
 
 Polyphony makes it possible to use normal Ruby built-in classes like `IO`, and `Socket` in a concurrent fashion without having to resort to threads. Polyphony takes care of context-switching automatically whenever a blocking call like `Socket#accept` or `IO#read` is issued.
 
@@ -13,7 +13,7 @@ Polyphony makes it possible to use normal Ruby built-in classes like `IO`, and `
 * Co-operative scheduling of concurrent tasks using Ruby fibers.
 * High-performance event reactor for handling I/O events and timers.
 * Natural, sequential programming style that makes it easy to reason about concurrent code.
-* Abstractions and constructs for controlling the execution of concurrent code: coprocesses, supervisors, cancel scopes, throttling, resource pools etc.
+* Abstractions and constructs for controlling the execution of concurrent code: supervisors, cancel scopes, throttling, resource pools etc.
 * Code can use native networking classes and libraries, growing support for third-party gems such as `pg` and `redis`.
 * Use stdlib classes such as `TCPServer` and `TCPSocket` and `Net::HTTP`.
 * Competitive performance and scalability characteristics, in terms of both throughput and memory consumption.

data/docs/summary.md

@@ -23,7 +23,7 @@
 * [Use timers](howto/timers.md)
 * [Throttle recurrent operations](howto/throttle.md)
 * [Cancel ongoing operations](howto/cancel.md)
-* [Control coprocesses](howto/coprocesses.md)
+* [Control fibers](howto/fibers.md)
 * [Synchronize concurrent operations](howto/synchronize.md)
 * [Perform CPU-bound operations](howto/cpu-bound.md)
 * [Control backpressure](howto/backpressure.md)
@@ -43,8 +43,7 @@
 
 ## API Reference
 
-* [Polyphony::CancelScope](#)
-* [Polyphony::Coprocess](#)
+* [Fiber](#)
 * [Gyro](#)
 * [Gyro::Async](#)
 * [Gyro::Child](#)
@@ -52,6 +51,7 @@
 * [Gyro::Timer](#)
 * [Kernel](#)
 * [Polyphony](#)
+* [Polyphony::CancelScope](#)
 * [Polyphony::Mutex](#)
 * [Polyphony::Pulser](#)
 * [Polyphony::ResourcePool](#)

data/docs/technical-overview/concurrency.md

@@ -12,19 +12,17 @@ Polyphony takes Ruby's fibers and adds a way to schedule and switch between fibe
 
 Writing concurrent applications using Polyphony's fiber-based concurrency model offers a significant performance advantage. Computational tasks can be broken down into many fine-grained concurrent operations that cost very little in memory and context-switching time. More importantly, this concurrency model lets developers express their ideas in a sequential manner, leading to source code that is easy to read and reason about.
 
-## Coprocesses - Polyphony's basic unit of concurrency
+## Fibers - Polyphony's basic unit of concurrency
 
-While stock Ruby fibers can be used with Polyphony without any problem, the API they provide is very basic, and necessitates writing quite a bit of boilerplate code whenever they need to be synchronized, interrupted or otherwise controlled. For this reason, Polyphony provides entities that encapsulate fibers and provide a richer API, making it easier to compose concurrent applications employing fibers.
-
-A coprocess can be thought of as a fiber with enhanced powers. It makes sure any exception raised while it's running is [handled correctly](exception-handling.md). It can be interrupted or `await`ed \(just like `Thread#join`\). It provides methods for controlling its execution. Moreover, coprocesses can pass messages between themselves, turning them into autonomous actors in a fine-grained concurrent environment.
+Polyphony extends the core `Fiber` class with additional functionality that allows scheduling, synchronizing, interrupting and otherwise controlling running fibers. Polyphony makes sure any exception raised while a is running is [handled correctly](exception-handling.md). Moreover, fibers can communicate with each other using message passing, turning them into autonomous actors in a fine-grained concurrent environment.
 
 ## Higher-Order Concurrency Constructs
 
-Polyphony also provides several methods and constructs for controlling multiple coprocesses. Methods like `cancel_after` and `move_on_after` allow interrupting a coprocess that's blocking on any arbitrary operation.
+Polyphony also provides several methods and constructs for controlling multiple fibers. Methods like `cancel_after` and `move_on_after` allow interrupting a fiber that's blocking on any arbitrary operation.
 
 Cancel scopes \(borrowed from the brilliant Python library [Trio](https://trio.readthedocs.io/en/stable/)\) allows cancelling ongoing operations for any reason with more control over cancelling behaviour.
 
-Supervisors allow controlling multiple coprocesses. They offer enhanced exception handling and can be nested to create complex supervision trees ala [Erlang](https://adoptingerlang.org/docs/development/supervision_trees/).
+Supervisors allow controlling multiple fibers. They offer enhanced exception handling and can be nested to create complex supervision trees ala [Erlang](https://adoptingerlang.org/docs/development/supervision_trees/).
 
 Some other constructs offered by Polyphony:
 

data/docs/technical-overview/design-principles.md

@@ -11,14 +11,14 @@ library. Polyphony's design is based on the following principles:
   should be no calls to initialize the event reactor, or other ceremonial code:
 
   ```ruby
-  require 'polyphony/auto_run'
+  require 'polyphony'
 
-  10.times {
-    # start 10 coprocesses, each sleeping for 1 second
-    spin { sleep 1 }
-  }
+  # start 10 fibers, each sleeping for 1 second
+  10.times { spin { sleep 1 } }
 
   puts 'going to sleep now'
+  # wait for other fibers to terminate
+  sleep
   ```
 
 - Blocking operations should yield to other concurrent tasks without any
@@ -27,7 +27,7 @@ library. Polyphony's design is based on the following principles:
 
   ```ruby
   # in Polyphony, I/O ops block the current fiber, but implicitly yield to other
-  # concurrent coprocesses:
+  # concurrent fibers:
   clients.each { |client|
     spin { client.puts 'Elvis has left the chatroom' }
   }
@@ -40,7 +40,7 @@ library. Polyphony's design is based on the following principles:
   more compact and more legible:
 
   ```ruby
-  coprocess = spin {
+  fiber = spin {
     move_on_after(3) {
       do_something_slow
     }
@@ -66,7 +66,7 @@ library. Polyphony's design is based on the following principles:
   cancel scopes:
 
   ```ruby
-  # wait for multiple coprocesses
+  # wait for multiple fibers
   supervise { |s|
     clients.each { |client|
       s.spin { client.puts 'Elvis has left the chatroom' }

data/docs/technical-overview/exception-handling.md

@@ -83,5 +83,5 @@ spin do
 end.await
 ```
 
-In this example, there are four coprocesses, nested one within the other. An exception is raised in the inner most coprocess, and having no exception handler, will bubble up through the different enclosing coprocesses, until reaching the top-most level, that of the root fiber, at which point the exception will cause the program to halt and print an error message.
+In this example, there are four fibers, nested one within the other. An exception is raised in the inner most fiber, and having no exception handler, will bubble up through the different enclosing fibers, until reaching the top-most level, that of the root fiber, at which point the exception will cause the program to halt and print an error message.
 

data/examples/core/{01-spinning-up-coprocesses.rb → 01-spinning-up-fibers.rb}

@@ -10,7 +10,7 @@ def nap(tag, t)
   puts "#{Time.now} #{tag} done napping"
 end
 
-# We launch two concurrent coprocesses, each sleeping for the given duration.
+# We launch two concurrent fibers, each sleeping for the given duration.
 spin { nap(:a, 1) }
 spin { nap(:b, 2) }
 

data/examples/core/{02-awaiting-coprocesses.rb → 02-awaiting-fibers.rb}

@@ -9,10 +9,10 @@ sleeper = spin do
   puts 'woke up'
 end
 
-# One way to synchronize coprocesses is by using `Coprocess#await`, which blocks
-# until the coprocess has finished running or has been interrupted.
+# One way to synchronize fibers is by using `Fiber#await`, which blocks
+# until the fiber has finished running or has been interrupted.
 waiter = spin do
-  puts 'waiting for coprocess to terminate'
+  puts 'waiting for fiber to terminate'
   sleeper.await
   puts 'done waiting'
 end

data/examples/core/xx-erlang-style-genserver.rb

@@ -5,7 +5,7 @@ require 'polyphony'
 
 class GenServer
   def self.start(receiver, *args)
-    coprocess = spin do
+    fiber = spin do
       state = receiver.initial_state(*args)
       loop do
         msg = receive
@@ -13,20 +13,20 @@ class GenServer
         msg[:from] << reply unless reply == :noreply
       end
     end
-    build_api(coprocess, receiver)
+    build_api(fiber, receiver)
     snooze
-    coprocess
+    fiber
   end
 
-  def self.build_api(coprocess, receiver)
+  def self.build_api(fiber, receiver)
     receiver.methods(false).each do |m|
       if m =~ /!$/
-        coprocess.define_singleton_method(m) do |*args|
-          GenServer.cast(coprocess, m, *args)
+        fiber.define_singleton_method(m) do |*args|
+          GenServer.cast(fiber, m, *args)
         end
       else
-        coprocess.define_singleton_method(m) do |*args|
-          GenServer.call(coprocess, m, *args)
+        fiber.define_singleton_method(m) do |*args|
+          GenServer.call(fiber, m, *args)
         end
       end
     end
@@ -34,7 +34,7 @@ class GenServer
 
   def self.cast(process, method, *args)
     process << {
-      from:   Polyphony::Coprocess.current,
+      from:   Fiber.current,
       method: method,
       args:   args
     }
@@ -42,7 +42,7 @@ class GenServer
 
   def self.call(process, method, *args)
     process << {
-      from:   Polyphony::Coprocess.current,
+      from:   Fiber.current,
       method: method,
       args:   args
     }

data/examples/core/xx-extended_fibers.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'fiber'
+
+## An experiment to see if the Coprocess class could be implemented as an
+## extension for the stock Fiber (since it's already enhanced)
+
+class Fiber
+  def self.spin(&block)
+    new(&wrap_block(block)).set_block(block).tap { |f| f.schedule }
+  end
+
+  attr_accessor :__block__
+
+  def self.wrap_block(block)
+    calling_fiber = Fiber.current
+    proc { |v| Fiber.current.run(v, calling_fiber, &block) }
+  end
+
+  def run(v, calling_fiber)
+    raise v if v.is_a?(Exception)
+
+    @running = true
+    result = yield v
+    @running = nil
+    schedule_waiting_fibers(result)
+    Fiber.run_next_fiber
+  rescue Exception => e
+    @running = nil
+    parent_fiber = calling_fiber.running? ? calling_fiber : Fiber.main_fiber
+    parent_fiber.transfer(e)
+  end
+
+  def running?
+    @running
+  end
+
+  def set_block(block)
+    @__block__ = block
+    self
+  end
+
+  def inspect
+    if @__block__
+      "<Fiber:#{object_id} #{@__block__.source_location.join(':')} (#{__scheduled_value__.inspect})>"
+    else
+      "<Fiber:#{object_id} (main) (#{__scheduled_value__.inspect})>"
+    end
+  end
+  alias_method :to_s, :inspect
+
+  # scheduling
+  @@scheduled_head = nil
+  @@scheduled_tail = nil
+
+  attr_accessor :__scheduled_next__
+  attr_accessor :__scheduled_value__
+
+  def self.snooze
+    current.schedule
+    yield_to_next
+  end
+
+  def self.suspend
+    yield_to_next
+  end
+
+  @@main_fiber = Fiber.current
+
+  def self.main_fiber
+    @@main_fiber
+  end
+
+  def self.yield_to_next
+    v = Fiber.run_next_fiber
+    v.is_a?(Exception) ? (raise v) : v
+  end
+
+  def self.run_next_fiber
+    unless @@scheduled_head
+      return main_fiber.transfer
+    end
+
+    next_fiber = @@scheduled_head
+    next_next_fiber = @@scheduled_head.__scheduled_next__
+    next_fiber.__scheduled_next__ = nil
+    if next_next_fiber
+      @@scheduled_head = next_next_fiber
+    else
+      @@scheduled_head = @@scheduled_tail = nil
+    end
+    next_fiber.transfer(next_fiber.__scheduled_value__)
+  end
+
+  def schedule(value = nil)
+    @__scheduled_value__ = value
+    if @@scheduled_head
+      @@scheduled_tail.__scheduled_next__ = self
+      @@scheduled_tail = self
+    else
+      @@scheduled_head = @@scheduled_tail = self
+    end
+  end
+
+  def await
+    current_fiber = Fiber.current
+    if @waiting_fiber
+      if @waiting_fiber.is_a?(Array)
+        @waiting_fiber << current_fiber
+      else
+        @waiting_fiber = [@waiting_fiber, current_fiber]
+      end
+    else
+      @waiting_fiber = current_fiber
+    end
+    Fiber.suspend
+  end
+
+  def schedule_waiting_fibers(v)
+    case @waiting_fiber
+    when Array then @waiting_fiber.each { |f| f.schedule(v) }
+    when Fiber then @waiting_fiber.schedule(v)
+    end
+  end
+end
+
+f1 = Fiber.spin {
+  p Fiber.current
+  Fiber.snooze
+  3.times {
+    STDOUT << '*'
+    Fiber.snooze
+  }
+  :foo
+}
+
+f2 = Fiber.spin {
+  p Fiber.current
+  Fiber.snooze
+  10.times {
+    STDOUT << '.'
+    Fiber.snooze
+  }
+}
+
+# v = f1.await
+# puts "done waiting #{v.inspect}"
+
+Fiber.suspend

data/examples/core/xx-sleeping.rb

@@ -3,6 +3,15 @@
 require 'bundler/setup'
 require 'polyphony'
 
+Exception.__disable_sanitized_backtrace__ = true
+
+spin {
+  10.times {
+    STDOUT << '.'
+    sleep 0.1
+  }
+}
+
 puts 'going to sleep...'
 sleep 1
 puts 'woke up'

data/examples/core/xx-supervisors.rb

@@ -15,7 +15,7 @@ supervise do |s|
   s.spin { my_sleep(2) }
   s.spin { my_sleep(3) }
   s.spin do
-    puts "fiber count: #{Polyphony::Coprocess.list.size}"
+    puts "fiber count: #{Fiber.count}"
   end
 end
 puts "#{Time.now} done waiting"

data/examples/interfaces/pg_pool.rb

@@ -11,7 +11,7 @@ PGOPTS = {
   sslmode:  'require'
 }.freeze
 
-DBPOOL = Polyphony::ResourcePool.new(limit: 8) { PG.connect(PGOPTS) }
+DBPOOL = Polyphony::ResourcePool.new(limit: 16) { PG.connect(PGOPTS) }
 
 def get_records(db)
   db.query('select pg_sleep(0.001) as test')
@@ -28,7 +28,7 @@ DBPOOL.preheat!
 t0 = Time.now
 count = 0
 
-coprocs = CONCURRENCY.times.map do
+fibers = CONCURRENCY.times.map do
   spin do
     loop do
       DBPOOL.acquire do |db|
@@ -40,4 +40,4 @@ coprocs = CONCURRENCY.times.map do
 end
 sleep 5
 puts "count: #{count} query rate: #{count / (Time.now - t0)} queries/s"
-coprocs.each(&:interrupt)
+fibers.each(&:interrupt)

data/examples/performance/mem-usage.rb

@@ -1,7 +1,7 @@
 require 'fiber'
 
 def mem_usage
-  `ps -o rss #{$$}`.strip.split.last.to_i
+  `ps -o rss #{$$}`.split.last.to_i
 end
 
 def calculate_fiber_memory_cost(count)
@@ -17,10 +17,25 @@ end
 
 calculate_fiber_memory_cost(10000)
 
+def calculate_thread_memory_cost(count)
+  GC.disable
+  rss0 = mem_usage
+  count.times { Thread.new { sleep 1 } }
+  sleep 0.5
+  rss1 = mem_usage
+  sleep 0.5
+  GC.start
+  cost = (rss1 - rss0).to_f / count
+
+  puts "thread memory cost: #{cost}KB"
+end
+
+calculate_thread_memory_cost(500)
+
 require 'bundler/setup'
 require 'polyphony'
 
-def calculate_coprocess_memory_cost(count)
+def calculate_extended_fiber_memory_cost(count)
   GC.disable
   rss0 = mem_usage
   count.times { spin { :foo } }
@@ -29,7 +44,7 @@ def calculate_coprocess_memory_cost(count)
   GC.start
   cost = (rss1 - rss0).to_f / count
 
-  puts "coprocess memory cost: #{cost}KB"
+  puts "extended fiber memory cost: #{cost}KB"
 end
 
-calculate_coprocess_memory_cost(10000)
+calculate_extended_fiber_memory_cost(10000)

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -54,11 +54,7 @@ spin do
     client = server.accept
     spin { handle_client(client) }
   end
-rescue Exception => e
-  puts "uncaught exception: #{e.inspect}"
-  puts e.backtrace.join("\n")
-  exit!
-  server.close
 end
 
+puts "pid #{Process.pid}"
 suspend

data/ext/gyro/gyro.c

@@ -14,7 +14,6 @@ static VALUE Gyro_suspend(VALUE self);
 static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self);
 static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self);
 static VALUE Fiber_state(VALUE self);
-static VALUE Fiber_mark_as_done(VALUE self);
 
 static void Gyro_clear_scheduled_fibers();
 
@@ -29,11 +28,11 @@ static VALUE scheduled_tail;
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
-ID ID_done;
 ID ID_each;
 ID ID_inspect;
 ID ID_raise;
 ID ID_read_watcher;
+ID ID_running;
 ID ID_scheduled;
 ID ID_scheduled_next;
 ID ID_scheduled_value;
@@ -45,8 +44,8 @@ ID ID_RW;
 
 VALUE SYM_DEAD;
 VALUE SYM_RUNNING;
-VALUE SYM_PAUSED;
 VALUE SYM_SCHEDULED;
+VALUE SYM_SUSPENDED;
 
 void Init_Gyro() {
   mGyro = rb_define_module("Gyro");
@@ -69,16 +68,15 @@ void Init_Gyro() {
   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);
-  rb_define_method(cFiber, "mark_as_done!", Fiber_mark_as_done, 0);
 
   ID_call             = rb_intern("call");
   ID_caller           = rb_intern("caller");
   ID_clear            = rb_intern("clear");
-  ID_done             = rb_intern("done");
   ID_each             = rb_intern("each");
   ID_inspect          = rb_intern("inspect");
   ID_raise            = rb_intern("raise");
   ID_read_watcher     = rb_intern("read_watcher");
+  ID_running          = rb_intern("@running");
   ID_scheduled        = rb_intern("scheduled");
   ID_scheduled_next   = rb_intern("scheduled_next");
   ID_scheduled_value  = rb_intern("scheduled_value");
@@ -90,12 +88,12 @@ void Init_Gyro() {
 
   SYM_DEAD = ID2SYM(rb_intern("dead"));
   SYM_RUNNING = ID2SYM(rb_intern("running"));
-  SYM_PAUSED = ID2SYM(rb_intern("paused"));
   SYM_SCHEDULED = ID2SYM(rb_intern("scheduled"));
+  SYM_SUSPENDED = ID2SYM(rb_intern("suspended"));
   rb_global_variable(&SYM_DEAD);
   rb_global_variable(&SYM_RUNNING);
-  rb_global_variable(&SYM_PAUSED);
   rb_global_variable(&SYM_SCHEDULED);
+  rb_global_variable(&SYM_SUSPENDED);
 
   scheduled_head = Qnil;
   scheduled_tail = Qnil;
@@ -161,8 +159,9 @@ static VALUE Gyro_suspend(VALUE self) {
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
-  else
+  else {
     return ret;
+  }
 }
 
 static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
@@ -181,17 +180,12 @@ static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE Fiber_state(VALUE self) {
-  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_done) != Qnil))
+  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_running) == Qfalse))
     return SYM_DEAD;
   if (rb_fiber_current() == self) return SYM_RUNNING;
   if (rb_ivar_get(self, ID_scheduled) != Qnil) return SYM_SCHEDULED;
   
-  return SYM_PAUSED;
-}
-
-static VALUE Fiber_mark_as_done(VALUE self) {
-  rb_ivar_set(self, ID_done, Qtrue);
-  return self;
+  return SYM_SUSPENDED;
 }
 
 VALUE Gyro_await() {

data/lib/polyphony/core/cancel_scope.rb

@@ -22,7 +22,6 @@ class CancelScope
   def cancel!
     @cancelled = true
     @fibers.each do |f|
-      f.cancelled = true
       f.schedule error_class.new(self, @opts[:value])
     end
     @on_cancel&.()
@@ -57,7 +56,6 @@ class CancelScope
   def call
     fiber = Fiber.current
     @fibers << fiber
-    fiber.cancelled = nil
     yield self
   rescue Exceptions::MoveOn => e
     e.scope == self ? e.value : raise(e)

data/lib/polyphony/core/exceptions.rb

@@ -2,8 +2,8 @@
 
 export :Interrupt, :MoveOn, :Cancel
 
-# Common exception class for interrupting coprocesses. These exceptions allow
-# control of coprocesses. Interrupt exceptions can encapsulate a value and thus
+# Common exception class for interrupting fibers. These exceptions allow
+# control of fibers. Interrupt exceptions can encapsulate a value and thus
 # provide a way to interrupt long-running blocking operations while still
 # passing a value back to the call site. Interrupt exceptions can also
 # references a cancel scope in order to allow correct bubbling of exceptions