Issue #13821 has been updated by ioquatix (Samuel Williams).
One issue was the use of the copy-coroutine. As we've removed this and replaced it
with a pthread fallback, we can now potentially allow fibers to be resumed across threads.
I'll put together a PR so we can experiment.
----------------------------------------
Feature #13821: Allow fibers to be resumed across threads
https://bugs.ruby-lang.org/issues/13821#change-105913
* Author: cremes (Chuck Remes)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
----------------------------------------
Given a Fiber created in ThreadA, Ruby 2.4.1 (and earlier releases) raise a FiberError if
the fiber is resumed in ThreadB or any other thread other than the one that created the
original Fiber.
Sample code attached to demonstrate problem.
If Fibers are truly encapsulating all of the data for the continuation, we should be
allowed to move them between Threads and resume their operation.
Why?
One use-case is to support the async-await asynchronous programming model. In that model,
a method marked async runs *synchronously* until the #await method is encountered. At that
point the method is suspended and control is returned to the caller. When the #await
method completes (asynchronously) then it may resume the suspended method and continue.
The only way to capture this program state, suspend and resume, is via a Fiber.
example:
```
class Wait
include AsyncAwait
def dofirst
async do
puts 'Synchronously print dofirst.'
result = await { dosecond }
puts 'dosecond is complete'
result
end
end
def dosecond
async do
puts 'Synchronously print dosecond from async task.'
slept = await { sleep 3 }
puts 'Sleep complete'
slept
end
end
def run
task = dofirst
puts 'Received task'
p AsyncAwait::Task.await(task)
end
end
Wait.new.run
```
```
# Expected output:
# Synchronous print dofirst.
# Received task
# Synchronously print dosecond from async task.
# Sleep complete
# dosecond is complete
# 3
```
Right now the best way to accomplish suspension of the #dofirst and #dosecond commands and
allow them to run asynchronously is by passing those blocks to *another thread* (other
than the callers thread) so they can be encapsulated in a new Fiber and then yielded. When
it's time to resume after #await completes, that other thread must lookup the fiber
and resume it. This is lots of extra code and logic to make sure that fibers are only
resumed on the threads that created them. Allowing Fibers to migrate between threads would
eliminate this problem.
---Files--------------------------------
fiber_across_threads.rb (377 Bytes)
wait.rb (728 Bytes)
--
https://bugs.ruby-lang.org/