From: merch-redmine@...
Date: 2019-10-22T17:55:22+00:00
Subject: [ruby-core:95471] [Ruby master Bug#6117] Transfers allowed into Fibers that have resumed into other fibers

Issue #6117 has been updated by jeremyevans0 (Jeremy Evans).

Assignee changed from ko1 (Koichi Sasada) to ioquatix (Samuel Williams)

I do not think this code is actually a problem.  The restriction on transferred fibers is:

```
You cannot resume a fiber that transferred control to another one.
This will cause a double resume error. You need to transfer control
back to this fiber before it can yield and resume.
```

That is not happening in this case.  `main_fiber` transfers to `a`, which resumes `x`, which transfers back to `main_fiber`, which transfers again to `a`.  At no point is a fiber that has transferred control to another fiber resumed before control is transferred back to the fiber.

In the example given `x` is not transferred back to after it transfers to `main_fiber`, which is why `6` does not appear in the output.  You can fix this by having `a` transfer to `x` after it is transferred back to (the second time) from `main_fiber`:

```ruby
  require 'fiber'

  def foo
    order = []
    main_fiber = Fiber.current
    a = Fiber.new do
      order << 2
      x = Fiber.new do
        order << 4
        main_fiber.transfer
        order << 6
      end
      order << 3
      x.resume
      x.transfer
      order << 7
    end

    order << 1
    a.transfer
    order << 5
    a.transfer
    order << 8
  end
```

Assinging to @ioquatix to determine if this is actually a bug.

----------------------------------------
Bug #6117: Transfers allowed into Fibers that have resumed into other fibers
https://bugs.ruby-lang.org/issues/6117#change-82241

* Author: loganb (Logan Bowers)
* Status: Feedback
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version: 
* ruby -v: ruby 2.0.0dev (2012-03-06) [x86_64-darwin11.3.0]
* Backport: 
----------------------------------------
Consider the following code: 

```ruby
  require 'fiber'

  def foo
    order = []
    main_fiber = Fiber.current
    a = Fiber.new do 
      order << 2
      x = Fiber.new do
        order << 4
        main_fiber.transfer
        order << 6
      end
      order << 3
      x.resume
      order << 7
    end

    order << 1
    a.transfer
    order << 5
    a.transfer
    order << 8
  end
```

It produces output:

```
  [1, 2, 3, 4, 5, 7, 8]
```

Note: the missing 6. I'd expect either the array to be 1-8 OR for an exception to be raised after 5 when the main fiber attempts to transfer into a again.

Either it shouldn't be possible to transfer into a Fiber that is blocked resuming another Fiber, OR it should automatically resume the sub-Fiber.




-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>