Remove the --fiber-leave-context option

* It is too hard to maintain and handle both possibilities.
* Performance-wise it seems very similar, and the default of leaving the
  context is much better to avoid triggering Truffle multithreading.
* This means SafepointPredicate.ALL_THREADS_AND_FIBERS will need special
  handling so it can work even when Fibers leave the context.

Author: eregon

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

@@ -89,9 +89,7 @@ public static void waitForInitialization(RubyContext context, RubyFiber fiber, N
 
     private void fiberMain(RubyContext context, RubyFiber fiber, RubyProc block, Node currentNode) {
         assert !fiber.isRootFiber() : "Root Fibers execute threadMain() and not fiberMain()";
-
-        final boolean entered = !context.getOptions().FIBER_LEAVE_CONTEXT;
-        assert entered == context.getEnv().getContext().isEntered();
+        assertNotEntered("Fibers should start unentered to avoid triggering multithreading");
 
         final Thread thread = Thread.currentThread();
         final SourceSection sourceSection = block.sharedMethodInfo.getSourceSection();
@@ -104,14 +102,9 @@ private void fiberMain(RubyContext context, RubyFiber fiber, RubyProc block, Nod
         fiber.initializedLatch.countDown();
 
         final FiberMessage message = waitMessage(fiber, currentNode);
-        final TruffleContext truffleContext = entered ? null : context.getEnv().getContext();
+        final TruffleContext truffleContext = context.getEnv().getContext();
 
-        final Object prev;
-        if (!entered) {
-            prev = truffleContext.enter(currentNode);
-        } else {
-            prev = null;
-        }
+        final Object prev = truffleContext.enter(currentNode);
         language.setupCurrentThread(thread, fiber.rubyThread);
 
         FiberMessage lastMessage = null;
@@ -146,9 +139,7 @@ private void fiberMain(RubyContext context, RubyFiber fiber, RubyProc block, Nod
             fiber.alive = false;
             // Leave context before addToMessageQueue() -> parent Fiber starts executing
             language.setupCurrentThread(thread, null);
-            if (!entered) {
-                truffleContext.leave(currentNode, prev);
-            }
+            truffleContext.leave(currentNode, prev);
             cleanup(fiber, thread);
             thread.setName(oldName);
 
@@ -205,7 +196,7 @@ class State {
     }
 
     private void assertNotEntered(String reason) {
-        assert !context.getOptions().FIBER_LEAVE_CONTEXT || !context.getEnv().getContext().isEntered() : reason;
+        assert !context.getEnv().getContext().isEntered() : reason;
     }
 
     @TruffleBoundary

src/main/java/org/truffleruby/core/thread/ThreadManager.java

@@ -78,11 +78,11 @@ public class ThreadManager {
     private final Set<RubyThread> runningRubyThreads = ConcurrentHashMap.newKeySet();
 
     /** The set of Java threads TruffleRuby created, and is responsible to exit in {@link #killAndWaitOtherThreads()}.
-     * Needs to be weak because {@link RubyLanguage#disposeThread} is called late for Fibers with --fiber-leave-context
-     * as that uses a "host thread" (disposeThread is only called on Context#close for those), and there might be
-     * multiple Fibers per such thread with the pool. If a Thread is unreachable we do not need to wait for it in
-     * {@link #killAndWaitOtherThreads()}, but otherwise we need to and we can never remove from this Set as otherwise
-     * we cannot guarantee we wait until the Thread truly finishes execution. */
+     * Needs to be weak because {@link RubyLanguage#disposeThread} is called late as Fibers use a "host thread"
+     * (disposeThread is only called on Context#close for those), and there might be multiple Fibers per such thread
+     * with the pool. If a Thread is unreachable we do not need to wait for it in {@link #killAndWaitOtherThreads()},
+     * but otherwise we need to and we can never remove from this Set as otherwise we cannot guarantee we wait until the
+     * Thread truly finishes execution. */
     private final Set<Thread> rubyManagedThreads = Collections
             .newSetFromMap(Collections.synchronizedMap(new WeakHashMap<>()));
 
@@ -155,12 +155,7 @@ private Thread createFiberJavaThread(Runnable runnable) {
             throw new UnsupportedOperationException("fibers should not be created while pre-initializing the context");
         }
 
-        final Thread thread;
-        if (context.getOptions().FIBER_LEAVE_CONTEXT) {
-            thread = new Thread(runnable); // context.getEnv().createUnenteredThread(runnable);
-        } else {
-            thread = context.getEnv().createThread(runnable);
-        }
+        final Thread thread = new Thread(runnable); // context.getEnv().createUnenteredThread(runnable);
         rubyManagedThreads.add(thread); // need to be set before initializeThread()
         thread.setUncaughtExceptionHandler((javaThread, throwable) -> {
             System.err.println("Throwable escaped Fiber pool thread:");
@@ -472,25 +467,14 @@ public interface BlockingAction<T> {
         T block() throws InterruptedException;
     }
 
-    /** Only leaves the context if FIBER_LEAVE_CONTEXT is true */
     public <T> T leaveAndEnter(TruffleContext truffleContext, Node currentNode, Supplier<T> runWhileOutsideContext) {
         assert truffleContext.isEntered();
-
-        if (context.getOptions().FIBER_LEAVE_CONTEXT) {
-            return truffleContext.leaveAndEnter(currentNode, runWhileOutsideContext);
-        } else {
-            return runWhileOutsideContext.get();
-        }
+        return truffleContext.leaveAndEnter(currentNode, runWhileOutsideContext);
     }
 
     /** Only use when the context is not entered. */
     @TruffleBoundary
     public <T> void retryWhileInterrupted(Node currentNode, TruffleSafepoint.Interruptible<T> interruptible, T object) {
-        if (!context.getOptions().FIBER_LEAVE_CONTEXT) {
-            runUntilResultKeepStatus(currentNode, interruptible, object);
-            return;
-        }
-
         assert !context.getEnv().getContext().isEntered() : "Use runUntilResult*() when entered";
         boolean interrupted = false;
         try {

src/main/java/org/truffleruby/options/Options.java

@@ -69,8 +69,6 @@ public class Options {
     public final boolean PATCHING;
     /** --hashing-deterministic=false */
     public final boolean HASHING_DETERMINISTIC;
-    /** --fiber-leave-context=true */
-    public final boolean FIBER_LEAVE_CONTEXT;
     /** --fiber-pool=true */
     public final boolean FIBER_POOL;
     /** --log-subprocess=false */
@@ -228,7 +226,6 @@ public Options(Env env, OptionValues options, LanguageOptions languageOptions) {
         PATTERN_MATCHING = options.get(OptionsCatalog.PATTERN_MATCHING_KEY);
         PATCHING = options.get(OptionsCatalog.PATCHING_KEY);
         HASHING_DETERMINISTIC = options.get(OptionsCatalog.HASHING_DETERMINISTIC_KEY);
-        FIBER_LEAVE_CONTEXT = options.get(OptionsCatalog.FIBER_LEAVE_CONTEXT_KEY);
         FIBER_POOL = options.get(OptionsCatalog.FIBER_POOL_KEY);
         LOG_SUBPROCESS = options.get(OptionsCatalog.LOG_SUBPROCESS_KEY);
         WARN_LOCALE = options.get(OptionsCatalog.WARN_LOCALE_KEY);
@@ -345,8 +342,6 @@ public Object fromDescriptor(OptionDescriptor descriptor) {
                 return PATCHING;
             case "ruby.hashing-deterministic":
                 return HASHING_DETERMINISTIC;
-            case "ruby.fiber-leave-context":
-                return FIBER_LEAVE_CONTEXT;
             case "ruby.fiber-pool":
                 return FIBER_POOL;
             case "ruby.log-subprocess":

src/main/ruby/truffleruby/core/main.rb

@@ -56,11 +56,7 @@ def to_s
 end
 
 show_backtraces = -> {
-  if Truffle::Boot.get_option('fiber-leave-context')
-    $stderr.puts 'All Thread backtraces (use --fiber-leave-context=false to see all Fiber backtraces):'
-  else
-    $stderr.puts 'All Fiber backtraces:'
-  end
+  $stderr.puts 'All Thread backtraces:'
   Primitive.all_fibers_backtraces.each do |fiber, backtrace|
     $stderr.puts "#{fiber} of #{Primitive.fiber_thread(fiber)}", backtrace, nil
   end

src/options.yml

@@ -102,7 +102,6 @@ EXPERT:
     LAZY_TRANSLATION_USER: [lazy-translation-user, boolean, LAZY_CALLTARGETS, 'Lazily translation of stdlib, gem and user source files']
     PATCHING: [patching, boolean, true, Use patching]
     HASHING_DETERMINISTIC: [hashing-deterministic, boolean, false, Produce deterministic hash values]
-    FIBER_LEAVE_CONTEXT: [fiber-leave-context, boolean, true, 'Leave the TruffleContext when suspending a Fiber (avoids triggering multithreading)']
     FIBER_POOL: [fiber-pool, boolean, true, 'Use a thread pool to speed up creating Fibers']
     LOG_SUBPROCESS: [log-subprocess, boolean, false, 'Log whenever a subprocess is created']
     WARN_LOCALE: [warn-locale, boolean, true, 'Warn when the system locale is not set properly']

src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java

@@ -52,7 +52,6 @@ public class OptionsCatalog {
     public static final OptionKey<Boolean> LAZY_TRANSLATION_USER_KEY = new OptionKey<>(LAZY_CALLTARGETS_KEY.getDefaultValue());
     public static final OptionKey<Boolean> PATCHING_KEY = new OptionKey<>(true);
     public static final OptionKey<Boolean> HASHING_DETERMINISTIC_KEY = new OptionKey<>(false);
-    public static final OptionKey<Boolean> FIBER_LEAVE_CONTEXT_KEY = new OptionKey<>(true);
     public static final OptionKey<Boolean> FIBER_POOL_KEY = new OptionKey<>(true);
     public static final OptionKey<Boolean> LOG_SUBPROCESS_KEY = new OptionKey<>(false);
     public static final OptionKey<Boolean> WARN_LOCALE_KEY = new OptionKey<>(true);
@@ -387,13 +386,6 @@ public class OptionsCatalog {
             .stability(OptionStability.EXPERIMENTAL)
             .build();
 
-    public static final OptionDescriptor FIBER_LEAVE_CONTEXT = OptionDescriptor
-            .newBuilder(FIBER_LEAVE_CONTEXT_KEY, "ruby.fiber-leave-context")
-            .help("Leave the TruffleContext when suspending a Fiber (avoids triggering multithreading)")
-            .category(OptionCategory.EXPERT)
-            .stability(OptionStability.EXPERIMENTAL)
-            .build();
-
     public static final OptionDescriptor FIBER_POOL = OptionDescriptor
             .newBuilder(FIBER_POOL_KEY, "ruby.fiber-pool")
             .help("Use a thread pool to speed up creating Fibers")
@@ -1223,8 +1215,6 @@ public static OptionDescriptor fromName(String name) {
                 return PATCHING;
             case "ruby.hashing-deterministic":
                 return HASHING_DETERMINISTIC;
-            case "ruby.fiber-leave-context":
-                return FIBER_LEAVE_CONTEXT;
             case "ruby.fiber-pool":
                 return FIBER_POOL;
             case "ruby.log-subprocess":
@@ -1482,7 +1472,6 @@ public static OptionDescriptor[] allDescriptors() {
             LAZY_TRANSLATION_USER,
             PATCHING,
             HASHING_DETERMINISTIC,
-            FIBER_LEAVE_CONTEXT,
             FIBER_POOL,
             LOG_SUBPROCESS,
             WARN_LOCALE,