Create the Fiber thread lazily on the first Fiber#{resume,transfer}

* This creates the thread later which is better for resources as there
  is no need for it earlier and there might be cases where a Fiber is
  created but never resumed.
* This avoids the problem of blocking in beforeEnter() which would
  prevent cancellation of a Fiber thread which never received a message.

Author: eregon

src/main/java/org/truffleruby/core/fiber/FiberManager.java

@@ -9,6 +9,7 @@
  */
 package org.truffleruby.core.fiber;
 
+import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
 
 import com.oracle.truffle.api.TruffleSafepoint.Interrupter;
@@ -61,16 +62,27 @@ public FiberManager(RubyLanguage language, RubyContext context) {
     public void initialize(RubyFiber fiber, boolean blocking, RubyProc block, Node currentNode) {
         final SourceSection sourceSection = block.getSharedMethodInfo().getSourceSection();
         fiber.sourceLocation = context.fileLine(sourceSection);
+        fiber.body = block;
+        fiber.initializeNode = currentNode;
         fiber.blocking = blocking;
+    }
+
+    private void createThreadToReceiveFirstMessage(RubyFiber fiber, Node currentNode) {
+        assert fiber.thread == null;
+        RubyProc block = Objects.requireNonNull(fiber.body);
+        fiber.body = null;
+        Node initializeNode = Objects.requireNonNull(fiber.initializeNode);
+        fiber.initializeNode = null;
 
+        var sourceSection = block.getSharedMethodInfo().getSourceSection();
         final TruffleContext truffleContext = context.getEnv().getContext();
 
         truffleContext.leaveAndEnter(currentNode, Interrupter.THREAD_INTERRUPT, (unused) -> {
-            ThreadManager threadManager = context.getThreadManager();
-            Thread thread = threadManager.createFiberJavaThread(fiber, sourceSection,
-                    () -> beforeEnter(fiber, currentNode),
-                    () -> fiberMain(context, fiber, block, currentNode),
+            Thread thread = context.getThreadManager().createFiberJavaThread(fiber, sourceSection,
+                    () -> beforeEnter(fiber, initializeNode),
+                    () -> fiberMain(context, fiber, block, initializeNode),
                     () -> afterLeave(fiber), currentNode);
+            fiber.thread = thread;
             thread.start();
             waitForInitializationUnentered(context, fiber, currentNode);
             return BlockingAction.SUCCESS;
@@ -121,22 +133,17 @@ private void beforeEnter(RubyFiber fiber, Node currentNode) {
 
         try {
             fiber.firstMessage = waitMessage(fiber, currentNode);
-        } catch (InterruptedException e) { // TODO ideally we would let this pop out of beforeEnter()
-            Thread.currentThread().interrupt();
-            return;
+        } catch (InterruptedException e) {
+            throw CompilerDirectives.shouldNotReachHere("unexpected interrupt in Fiber beforeEnter()");
         }
 
         // enter() polls so we need the current Fiber to be set before enter()
         fiber.rubyThread.setCurrentFiber(fiber);
     }
 
     private void fiberMain(RubyContext context, RubyFiber fiber, RubyProc block, Node currentNode) {
-        final FiberMessage message = fiber.firstMessage;
+        final FiberMessage message = Objects.requireNonNull(fiber.firstMessage);
         fiber.firstMessage = null;
-        if (message == null) {
-            TruffleSafepoint.poll(currentNode);
-            throw CompilerDirectives.shouldNotReachHere("null Fiber message and no cancellation");
-        }
 
         FiberMessage lastMessage = null;
         try {
@@ -308,6 +315,11 @@ public DescriptorAndArgs transferControlTo(RubyFiber fromFiber, RubyFiber toFibe
     @TruffleBoundary
     private FiberMessage resumeAndWait(RubyFiber fromFiber, RubyFiber toFiber, FiberOperation operation,
             ArgumentsDescriptor descriptor, Object[] args, Node currentNode) {
+
+        if (toFiber.body != null) {
+            context.fiberManager.createThreadToReceiveFirstMessage(toFiber, currentNode);
+        }
+
         final TruffleContext truffleContext = context.getEnv().getContext();
         final FiberMessage message = truffleContext.leaveAndEnter(currentNode, Interrupter.THREAD_INTERRUPT,
                 (unused) -> {
@@ -334,7 +346,12 @@ public void safepoint(RubyFiber fromFiber, RubyFiber fiber, SafepointAction acti
     }
 
     public void start(RubyFiber fiber, Thread javaThread) {
-        fiber.thread = javaThread;
+        if (fiber.isRootFiber()) {
+            fiber.thread = javaThread;
+            fiber.status = FiberStatus.RESUMED;
+        } else {
+            // fiber.thread set by createThreadToReceiveFirstMessage()
+        }
 
         final RubyThread rubyThread = fiber.rubyThread;
 

src/main/java/org/truffleruby/core/fiber/RubyFiber.java

@@ -15,6 +15,7 @@
 import java.util.concurrent.LinkedBlockingQueue;
 
 import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.nodes.Node;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.cext.ValueWrapperManager;
@@ -23,6 +24,7 @@
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.basicobject.RubyBasicObject;
 import org.truffleruby.core.klass.RubyClass;
+import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.thread.RubyThread;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyDynamicObject;
@@ -87,6 +89,8 @@ public enum FiberStatus {
     public Thread thread = null;
     public volatile Throwable uncaughtException = null;
     String sourceLocation;
+    RubyProc body;
+    Node initializeNode;
     public final MarkingService.ExtensionCallStack extensionCallStack;
     public final ValueWrapperManager.HandleBlockHolder handleData;
     boolean blocking = true;