polyphony 0.21 → 0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38c4ab294136de3c31b69438b38aaae16f611b87ccd4730cbe4399a9b6e3a7c6
-  data.tar.gz: 35c69e1ff809d340dbe3a121536005338be13c051e8cf2d8c716fd2546c715bc
+  metadata.gz: 27942af70470ad8751268c35230cf822e5b671305450edc19dc4b998409ca1b2
+  data.tar.gz: 94393e31d741b484e188730496980fd5fc44fd4ff632abf8abe7e9ba3117b71f
 SHA512:
-  metadata.gz: 9d41e1f35a06a5906e21defa0dece49f27faac107764401eceb6e55e9fc6cf68c09ff0fdb109afd8b5b53fee0fdb8ab9ee744dce08490f1c433cc5ec3fe5b7a0
-  data.tar.gz: c69ee7c201fb812fc1c13120884df61f74ba7b4410ffa31a4a70190a8a95e04b2736f8208422c3018373ad02ca025acadadcdc4898b5eaed16071b14b17c00c7
+  metadata.gz: 2d97e95fd9b8d5c9bf8f3224652c88f29a8e5e930918819647a4e66f2d09be6c190c43c88cf202c3f3211b41faedf5afc0c1c67922fe6e31e2453750b0566777
+  data.tar.gz: 4f86964e496dcc418ed23f45cffe88db4d93489dc6ab7616157456f309f117e1fe3f4e12a2edc06347ee3b7ca3af76f2e2ec461499c5bf05caf30eea281bb6bd

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.6
   RubyInterpreters:
     - ruby
   Exclude:

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+0.22 2020-01-02
+---------------
+
+* Redesign Gyro scheduling subsystem, go scheduler-less
+* More docs
+* Rewrite HTTP client agent c1b63787
+* Increment Gyro refcount in ResourcePool#acquire
+* Rewrite ResourcePool
+* Fix socket extensions
+* Fix ALPN setup in Net.secure_socket
+
 0.21 2019-12-12
 ---------------
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.21)
+    polyphony (0.22)
       http-2 (= 0.10.0)
       http_parser.rb (= 0.6.0)
       modulation (~> 0.25)
@@ -11,7 +11,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     ansi (1.5.0)
-    builder (3.2.3)
+    builder (3.2.4)
     hiredis (0.6.3)
     http-2 (0.10.0)
     http_parser.rb (0.6.0)
@@ -19,7 +19,7 @@ GEM
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
     localhost (1.1.4)
-    mime-types (3.3)
+    mime-types (3.3.1)
       mime-types-data (~> 3.2015)
     mime-types-data (3.2019.1009)
     minitest (5.11.3)
@@ -31,7 +31,7 @@ GEM
     modulation (0.34)
     multi_xml (0.6.0)
     pg (1.1.3)
-    rack (2.0.7)
+    rack (2.0.8)
     rake (13.0.1)
     rake-compiler (1.0.5)
       rake
@@ -55,4 +55,4 @@ DEPENDENCIES
   websocket (= 1.2.8)
 
 BUNDLED WITH
-   2.1.0.pre.2
+   2.1.3

data/TODO.md

@@ -1,43 +1,106 @@
-# Roadmap:
+# Add ability to cancel multiple coprocesses
 
-## 0.20.1
+```ruby
+scope = CancelScope.new
+
+3.times { |i|
+  spin {
+    puts "sleep for #{i + 1}s"
+    scope.call { sleep i + 1 }
+    puts "woke up"
+  }
+}
+
+sleep 0.5
+scope.cancel!
+```
 
-- Cull, edit and annotate examples
-- Work better mechanism supervising multiple coprocesses (`when_done` feels a
-  bit hacky)
+# Add ability to wait for signal
 
-## 0.22 Full Rack adapter implementation
+```ruby
+sig = Gyro::Signal('SIGUP')
 
-- Homogenize HTTP 1 and HTTP 2 headers - upcase ? downcase ?
-- Rewrite agent code to use sequential API (like I did for server)
-- Streaming bodies for HTTP client
-
-  ```ruby
-  def download_doc
-    response = Polyphony::HTTP::Agent.get('https://acme.com/doc.pdf')
-    File.open('doc.pdf', 'wb+') do |f|
-      response.each { |chunk| f << chunk } # streaming body
+loop do
+  sig.await
+  restart
+end
+```
+
+# HTTP Client Agent
+
+The concurrency model and the fact that we want to serve the response object on
+receiving headers and let the user lazily read the response body, means we'll
+need to change the API to accept a block:
+
+```ruby
+# current API
+resp = Agent.get('http://acme.org')
+puts resp.body
+
+# proposed API
+Agent.get('http://acme.org') do |resp|
+  puts resp.body
+end
+```
+
+While the block is running, the connection adapter is acquired. Once the block
+is done running, the request (and response) can be discarded. The problem with
+that if we spin up a coprocess from that block we risk all kinds of race
+conditions and weird behaviours.
+
+A compromise might be to allow the two: doing a `get` without providing a block
+will return a response object that already has the body (i.e. the entire
+response has already been received). Doing a `get` with a block will invoke the
+block once headers are received, letting the user's code stream the body:
+
+```ruby
+def request(ctx, &block)
+  ...
+  connection_manager.acquire do |adapter|
+    response = adapter.request(ctx)
+    if block
+      block.(response)
+    else
+      # wait for body
+      response.body
     end
+    response
   end
-  ```
+end
+```
 
+# Roadmap:
+
+## 0.22 Redesign of Gyro scheduling system
+
+- Schedulerless design - no separate fiber for running ev loop
+- Blocking operations directly transfer to first scheduled fiber
+- Scheduled fibers managed using linked list, switching directly from one to the
+  other
+
+## 0.23 Full Rack adapter implementation
+
+- 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
 
-## 0.23 Working Sinatra application
+## 0.24 Working Sinatra application
 
 - app with database access (postgresql)
 - benchmarks!
 
-## 0.24 Support for multi-threading
+## 0.25 Support for multi-threading
 
 - Separate event loop for each thread
 
-## 0.25 Testing
+## 0.26 Testing
 
 - test thread / thread_pool modules
 - report test coverage
 
-## 0.26 Documentation
+## 0.27 Documentation
 
 # DNS
 

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

@@ -21,9 +21,9 @@ library. Polyphony's design is based on the following principles:
   puts 'going to sleep now'
   ```
 
-- Blocking operations should yield to the reactor without any decoration or
-  wrapper APIs. This means no `async/await` notation, and no built-in concept of
-  deferred computation.
+- Blocking operations should yield to other concurrent tasks without any
+  decoration or wrapper APIs. This means no `async/await` notation, and no
+  built-in concept of deferred computation.
 
   ```ruby
   # in Polyphony, I/O ops block the current fiber, but implicitly yield to other

data/docs/technical-overview/faq.md

@@ -72,3 +72,14 @@ Actually, async/await was contemplated while developing Polyphony, but at a cert
 
 Instead, we have decided to make blocking operations implicit and thus allow the use of common APIs such as `Kernel#sleep` or `IO.popen` in a transparent manner. After all, these APIs in their stock form block execution just as well.
 
+## Why use `Fiber#transfer` and not `Fiber#resume`?
+
+The API for `Fiber.yield`/`Fiber#resume` is stateful and is intended for the asymmetric execution of coroutines. This is useful when using generators, or other cases where one coroutine acts as a "server" and another as a "client". In Polyphony's case, all fibers are equal, and control can be transferred freely between them, which is much easier to achieve using `Fiber#transfer`. In addition, using `Fiber#transfer` allows us to perform blocking operations from the main fiber, which is not possible when using `Fiber#resume`.
+
+## Why is Polyphony not split into multiple gems?
+
+Polyphony is currently at an experimental stage, and its different APIs are still in flux. For that reason, all the different parts of Polyphony are currently kept in a single gem. Once things stabilize, and as Polyphony approaches version 1.0, it will be split into separate gems, each with its own functionality.
+
+## Who is behind this project?
+
+I'm Sharon Rosner, an independent software developer living in France. Here's my [github profile](https://github.com/ciconia). You can contact me by writing to [noteflakes@gmail.com](mailto:ciconia@gmail.com).

data/docs/technical-overview/fiber-scheduling.md

@@ -4,21 +4,43 @@ Ruby provides two mechanisms for transferring control between fibers: `Fiber#res
 
 The second mechanism, using `Fiber#transfer`, is completely symmetric and allows use of the root fiber as a general purpose resumable execution context. Polyphony uses `Fiber#transfer` exclusively for scheduling fibers.
 
-## The Reactor Fiber
+## Scheduler-less scheduling
 
-Polyphony relies on [libev](http://software.schmorp.de/pkg/libev.html) for handling events such as I/O readiness, timers and signals. The libev event loop runs in a separate fiber \(called the reactor fiber\) and handles each event by resuming the appropriate fiber using `Fiber#transfer`. The event loop will continue running and scheduling fibers as long as there's active event watchers. When all event watchers have been deactivated, the event loop terminates and control is transferred to the root fiber, which will either terminate the program, or go on with other work, and possibly another run of the event loop.
+Polyphony relies on [libev](http://software.schmorp.de/pkg/libev.html) for handling events such as I/O readiness, timers and signals. In most event reactor-based libraries and frameworks, such as `nio4r`, `EventMachine` or `node.js`, the reactor loop is run, and event callbacks are used to schedule user-supplied code *from inside the loop*. In Polyphony, however, we have chosen a programming model that does not use a loop to schedule fibers. In fact, in Polyphony there's no such thing as a reactor loop, and there's no *scheduler* running on a separate execution context.
 
-## Fiber scheduling
+Instead, Polyphony maintains a list of scheduled fibers, fibers that will be resumed once the current fiber yields control, which will occur on every blocking operation. If no fibers are scheduled, the libev event reactor will be ran until one or more events have occurred. Events are handled by adding the corresponding fibers onto the *scheduled fibers* list. Finally, control is transferred to the first scheduled fiber, which will run until it blocks or terminates, at which point control is transferred to the next scheduled fiber.
 
-When a new fiber is created, it is in a suspended state. To start it, it needs to be resumed using `Fiber#transfer`. Upon performing a blocking operation, such as `sleep` or `gets`, an event watcher will be created, and control will be transferred to the reactor fiber, which will resume running the event loop. A fiber waiting for an event will be resumed using `Fiber#transfer` once the event has been received, and will continue execution until encountering another blocking operation, at which point it will again create an event watcher and transfer control back to the reactor fiber.
+This approach has numerous benefits:
+
+- No separate reactor fiber that needs to be resumed on each blocking operation, leading to less context switches, and less bookkeeping.
+- Clear separation between the reactor code (the `libev` code) and the fiber scheduling code.
+- Much less time is spent in reactor loop callbacks, letting the reactor loop run more efficiently.
+- Fibers are resumed outside of the event reactor code, making it easier to avoid race conditions and unexpected behaviours.
+
+## Fiber states
+
+In Polyphony, each fiber has one of the following states at any given moment:
+
+- `:running`: this is the state of the currently running fiber.
+- `:dead`: the fiber has terminated.
+- `:paused`: the fiber is paused;
+- `:scheduled`: the fiber is scheduled to run soon.
+
+## Fiber scheduling and fiber switching
+
+The Polyphony scheduling model makes a clear separation between the scheduling of fibers and the switching of fibers. The scheduling of fibers is the act of marking the fiber to be run at the earliest opportunity, but not immediately. The switching of fibers is the act of transferring control to another fiber, in this case the first fiber in the list of *currently* scheduled fibers.
+
+The scheduling of fibers can occur at any time, either as a result of an event occuring, an exception being raised, or using `Fiber#schedule`. The switching of fibers will occur only when a blocking operation is started, or upon calling `Fiber#suspend` or `Fiber#snooze`. In order to switch to a scheduled fiber, Polyphony uses `Fiber#transfer`.
+
+When a fiber terminates, any other scheduled fibers will be run. If no fibers are waiting and the main fiber is done running, the Ruby process will terminate.
 
 ## Interrupting blocking operations
 
 Sometimes it is desirable to be able to interrupt a blocking operation, such as waiting for a socket to be readable, or sleeping for an extended period of time. This is especially useful when higher-level constructs are needed for controlling multiple concurrent operations.
 
-Polyphony provides the ability to interrupt a blocking operation by harnessing the ability to transfer values back and forth when using `Fiber#transfer`. Whenever a waiting fiber transfers control to the reactor fiber, the value received upon being resumed is checked. If the value is an exception, it will be raised in the context of the waiting fiber, effectively signalling that the blocking operation has been unsuccessful and allowing exception handling using the usual mechanisms offered by Ruby, namely `rescue` and `ensure` \(see also [exception handling](exception-handling.md)\).
+Polyphony provides the ability to interrupt a blocking operation by harnessing the ability to transfer values back and forth between fibers using `Fiber#transfer`. Whenever a waiting fiber yields control to the next scheduled fiber, the value received upon being resumed is checked. If the value is an exception, it will be raised in the context of the waiting fiber, effectively signalling that the blocking operation has been unsuccessful and allowing exception handling using the builtin mechanisms offered by Ruby, namely `rescue` and `ensure` (see also [exception handling](exception-handling.md)).
 
-Here's an siplified example of how this mechanism works when reading from an I/O object \(the actual code for I/O reading in Polyphony is written in C and a bit more involved\):
+Here's a naive implementation of a yielding I/O read operation in Polyphony (the actual code for I/O reading in Polyphony is written in C and is a bit more involved):
 
 ```ruby
 def read_from(io)
@@ -33,38 +55,29 @@ def read_from(io)
 end
 
 def wait_readable(io)
-  watcher = Gyro::IO.new(io, :read)
-  # transfer control to event loop
-  result = $__reactor_fiber__.transfer
-  # got control back, check if result is an exception
+  fiber = Fiber.current
+  watcher = Gyro::IO.new(io, :read) { fiber.transfer }
+
+  # run any scheduled fibers or run libev reactor waiting for events 
+  result = GV.run
+
+  # waiting fiber is resumed - check transferred value
   raise result if result.is_a?(Exception)
   result
 ensure
+  # ensure the I/O watcher is deactivated, even if exception is raised
   watcher.active = false
 end
 ```
 
-In the above example, the `wait_readable` method will normally wait indefinitely until the IO object has become readable. But we could interrupt it at any time by scheduling the corresponding fiber with an exception.
-
-## Deferred Operations
-
-In addition to waiting for blocking operations, Polyphony provides numerous APIs for suspending and scheduling fibers:
-
-* `Fiber#safe_transfer(value = nil)` - transfers control to another fiber with
-
-  exception handling.
-
-* `Fiber#schedule(value = nil)` - schedules a fiber to be resumed once the
-
-  event loop becomes idle.
-
-* `Kernel#snooze` - transfers control to the reactor fiber while scheduling the
-
-  current fiber to be resumed immediately once the event loop is idle.
-
-* `Kernel#suspend` - suspends the current fiber indefinitely by transferring
-
-  control to the reactor fiber.
-
-In addition, a lower level API allows running arbitrary code in the context of the reactor loop using `Kernel#defer`. Using this API will run the given block the next time the event loop is idle.
+In the above example, the `wait_readable` method will normally wait indefinitely until the IO object has become readable. But we could interrupt it at any time by scheduling the corresponding fiber with an exception:
 
+```ruby
+def timeout(duration)
+  fiber = Fiber.current
+  watcher = Gyro::Timer.new(duration) { fiber.transfer(TimerException.new) }
+  yield
+ensure
+  watcher.active = false
+end
+```

data/examples/core/sleep_spin.rb

@@ -5,14 +5,14 @@ require 'polyphony/auto_run'
 
 spin do
   10.times do |i|
-    sleep 0.1
+    sleep 0.05
     p i
   end
 end
 
 spin do
   puts 'going to sleep...'
-  sleep 0.8
+  sleep 0.4
   puts 'woke up'
 end.await
 

data/examples/http/http2_raw.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/auto_run'
+require 'http/2'
+
+# Response = import '../../lib/polyphony/http/client/response'
+
+url = 'https://realiteq.net/?q=time'
+uri = URI(url)
+uri_key = { scheme: uri.scheme, host: uri.host, port: uri.port }
+
+ctx = {
+  method: :GET,
+  uri:    uri,
+  opts:   {},
+  retry:  0
+}
+
+SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }.freeze
+socket = Polyphony::Net.tcp_connect(uri_key[:host], uri_key[:port], SECURE_OPTS)
+
+puts 'connected'
+
+$client = HTTP2::Client.new
+$client.on(:frame) { |bytes| socket << bytes }
+$client.on(:frame_received) do |frame|
+  puts "Received frame: #{frame.inspect}"
+end
+# $client.on(:frame_sent) do |frame|
+#   puts "Sent frame: #{frame.inspect}"
+# end
+
+reader = spin do
+  while (data = socket.readpartial(8192))
+    $client << data
+    snooze
+  end
+end
+
+stream = $client.new_stream
+
+$headers = nil
+$done = nil
+@buffered_chunks = []
+
+@waiting_headers_fiber = nil
+@waiting_chunk_fiber = nil
+@waiting_done_fiber = nil
+
+# send request
+headers = {
+  ':method'    => ctx[:method].to_s,
+  ':scheme'    => ctx[:uri].scheme,
+  ':authority' => [ctx[:uri].host, ctx[:uri].port].join(':'),
+  ':path'      => ctx[:uri].request_uri,
+  'User-Agent' => 'curl/7.54.0'
+}
+headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
+
+if ctx[:opts][:payload]
+  stream.headers(headers, end_stream: false)
+  stream.data(ctx[:opts][:payload], end_stream: true)
+else
+  stream.headers(headers, end_stream: true)
+end
+
+stream.on(:headers) { |headers|
+  puts "got headers"
+  # if @waiting_headers_fiber
+  #   @waiting_headers_fiber.transfer headers.to_h
+  # else
+    $headers = headers.to_h
+  # end
+}
+stream.on(:data) { |chunk|
+  puts "got data"
+  # if @waiting_chunk_fiber
+  #   @waiting_chunk_fiber&.transfer c
+  # else
+    @buffered_chunks << chunk
+  # end
+}
+
+def close
+  puts "got close"
+  $done = true
+end
+
+stream.on(:close) { close }
+  # @waiting_done_fiber&.transfer
+# }
+
+stream.on(:active) { puts "* active" }
+stream.on(:half_close) { puts "* half_close" }
+
+
+
+# wait for response
+# unless $headers
+#   @waiting_headers_fiber = Fiber.current
+#   $headers = suspend
+# end
+# p $headers
+# response = Response.new(self, $headers[':status'].to_i, $headers)
+# p response
+
+puts "waiting for response"
+while !$done
+  puts "waiting..."
+  sleep 1
+end
+puts "done"
+
+#   def body
+#     @waiting_chunk_fiber = Fiber.current
+#     body = +''
+#     while !$done
+#       chunk = suspend
+#       body << chunk
+#     end
+#     body
+#   rescue => e
+#     p e
+#     puts e.backtrace.join("\n")
+#   end
+# end
+
+# adapter = StreamAdapter.new
+# resp = adapter.request(ctx)
+# puts "*" * 40
+# p resp
+
+# body = resp.body
+# p body

data/examples/http/http_client.rb

@@ -3,15 +3,26 @@
 require 'bundler/setup'
 require 'polyphony/http'
 
+Exception.__disable_sanitized_backtrace__ = true
+
+TIME_URI = 'https://ui.realiteq.net/'
+
 def get_server_time
-  Polyphony::HTTP::Agent.get('https://ui.realiteq.net/', q: :time).json
+  json = Polyphony::HTTP::Agent.get(TIME_URI, query: { q: :time }).json
+  puts "*" * 40
+  p json
 end
 
-X = 10
+X = 1
 puts "Making #{X} requests..."
 t0 = Time.now
 supervise do |s|
-  X.times { s.spin { get_server_time } }
+  X.times {
+    s.spin {
+      get_server_time
+    }
+  }
 end
+# get_server_time
 elapsed = Time.now - t0
 puts "count: #{X} elapsed: #{elapsed} rate: #{X / elapsed} reqs/s"

data/examples/http/http_get.rb

@@ -2,6 +2,32 @@
 
 require 'bundler/setup'
 require 'polyphony/http'
+require 'polyphony/auto_run'
 
-resp = Polyphony::HTTP::Agent.get('https://google.com/')
-p resp.body
+Exception.__disable_sanitized_backtrace__ = true
+
+resp = Polyphony::HTTP::Agent.get('https://realiteq.net/?q=time')
+puts "*" * 40
+puts resp.body
+
+__END__
+
+X = 1
+Y = 1
+t0 = Time.now
+supervise { |s|
+  X.times {
+    s.spin {
+      Y.times {
+        resp = Polyphony::HTTP::Agent.get('http://about.gitlab.com/')
+        puts "*" * 40
+        p resp.headers
+        puts "*" * 40
+        puts resp.body
+        # puts "body size: #{resp.body.bytesize}"
+      }
+    }
+  }
+}
+elapsed = Time.now - t0
+puts "\nelapsed: #{elapsed} rate: #{(X * Y) / elapsed}"

data/examples/http/http_server.rb

@@ -12,12 +12,14 @@ opts = {
 spin do
   Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) do |req|
     req.respond("Hello world!\n")
+  rescue Exception => e
+    p e
   end
 end
 
 spin do
   throttled_loop(1) do
-    puts "Coprocess count: #{Polyphony::Coprocess.list.size}"
+    puts "#{Time.now} coprocess count: #{Polyphony::Coprocess.list.size}"
   end
 end
 

data/examples/http/http_server_forked.rb

@@ -3,6 +3,8 @@
 require 'bundler/setup'
 require 'polyphony/http'
 
+::Exception.__disable_sanitized_backtrace__ = true
+
 opts = {
   reuse_addr:  true,
   dont_linger: true
@@ -24,4 +26,4 @@ child_pids = []
   child_pids << pid
 end
 
-child_pids.each { |pid| EV::Child.new(pid).await }
+child_pids.each { |pid| Gyro::Child.new(pid).await }

data/examples/interfaces/pg_pool.rb

@@ -27,6 +27,7 @@ puts "concurrency: #{CONCURRENCY}"
 DBPOOL.preheat!
 t0 = Time.now
 count = 0
+
 coprocs = CONCURRENCY.times.map do
   spin do
     loop do

data/examples/io/echo_server.rb

@@ -4,6 +4,7 @@ require 'bundler/setup'
 require 'polyphony/auto_run'
 
 server = TCPServer.open('127.0.0.1', 1234)
+puts "Pid: #{Process.pid}"
 puts 'Echoing on port 1234...'
 while (client = server.accept)
   spin do

data/ext/gyro/async.c

@@ -77,18 +77,15 @@ static VALUE Gyro_Async_initialize(VALUE self) {
 }
 
 void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
-  VALUE fiber;
   struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
 
+  ev_async_stop(EV_DEFAULT, ev_async);
+  async->active = 0;
+
   if (async->fiber != Qnil) {
-    ev_async_stop(EV_DEFAULT, ev_async);
-    async->active = 0;
-    fiber = async->fiber;
+    VALUE fiber = async->fiber;
     async->fiber = Qnil;
-    SCHEDULE_FIBER(fiber, 0);
-  }
-  else {
-    ev_async_stop(EV_DEFAULT, ev_async);
+    Gyro_schedule_fiber(fiber, Qnil);
   }
 }
 
@@ -113,9 +110,10 @@ static VALUE Gyro_Async_await(VALUE self) {
     ev_async_start(EV_DEFAULT, &async->ev_async);
   }
 
-  ret = YIELD_TO_REACTOR();
+  ret = Gyro_yield();
 
   // fiber is resumed
+  async->fiber = Qnil;
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
     if (async->active) {
       async->active = 0;