[GR-15990] Move the SafepointManager Assumption to RubyLanguage

* Only store the language in RubyRootNode, WhileRepeatingBaseNode

Author: eregon

src/main/java/org/truffleruby/RubyContext.java

@@ -100,7 +100,7 @@ public class RubyContext {
     @CompilationFinal private TruffleFile rubyHomeTruffleFile;
     @CompilationFinal private boolean hadHome;
 
-    private final SafepointManager safepointManager = new SafepointManager(this);
+    private final SafepointManager safepointManager;
     private final InteropManager interopManager = new InteropManager(this);
     private final CodeLoader codeLoader = new CodeLoader(this);
     private final FeatureLoader featureLoader;
@@ -165,6 +165,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
 
         options = createOptions(env, language.options);
 
+        safepointManager = new SafepointManager(this, language);
         frozenStringLiterals = new FrozenStringLiterals(this, language);
         coreExceptions = new CoreExceptions(this, language);
         encodingManager = new EncodingManager(this, language);

src/main/java/org/truffleruby/RubyLanguage.java

@@ -12,6 +12,7 @@
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.instrumentation.AllocationReporter;
@@ -115,7 +116,7 @@
         StandardTags.ReadVariableTag.class,
         StandardTags.WriteVariableTag.class,
 })
-public class RubyLanguage extends TruffleLanguage<RubyContext> {
+public final class RubyLanguage extends TruffleLanguage<RubyContext> {
 
     public static final String PLATFORM = String.format(
             "%s-%s%s",
@@ -138,6 +139,11 @@ public class RubyLanguage extends TruffleLanguage<RubyContext> {
             .createAssumption("single RubyContext per RubyLanguage instance");
     public final CyclicAssumption traceFuncUnusedAssumption = new CyclicAssumption("set_trace_func is not used");
 
+    private final ReentrantLock safepointLock = new ReentrantLock();
+    @CompilationFinal private Assumption safepointAssumption = Truffle
+            .getRuntime()
+            .createAssumption("SafepointManager");
+
     public final CoreMethodAssumptions coreMethodAssumptions;
     public final CoreStrings coreStrings;
     public final CoreSymbols coreSymbols;
@@ -222,6 +228,20 @@ public void invalidateTracingAssumption() {
         tracingAssumption = tracingCyclicAssumption.getAssumption();
     }
 
+    public Assumption getSafepointAssumption() {
+        return safepointAssumption;
+    }
+
+    public void invalidateSafepointAssumption(String reason) {
+        safepointLock.lock();
+        safepointAssumption.invalidate(reason);
+    }
+
+    public void resetSafepointAssumption() {
+        safepointAssumption = Truffle.getRuntime().createAssumption("SafepointManager");
+        safepointLock.unlock();
+    }
+
     @Override
     protected void initializeMultipleContexts() {
         // TODO Make Symbol.all_symbols per context, by having a SymbolTable per context and creating new symbols with

src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java

@@ -145,7 +145,7 @@ private void addCoreMethod(RubyModule module, MethodDetails methodDetails) {
 
         final Function<SharedMethodInfo, RootCallTarget> callTargetFactory = sharedMethodInfo -> {
             final RubyNode methodNode = createCoreMethodNode(nodeFactory, annotation, sharedMethodInfo);
-            return createCallTarget(context, sharedMethodInfo, methodNode, split);
+            return createCallTarget(language, sharedMethodInfo, methodNode, split);
         };
 
         addMethods(module, isModuleFunc, onSingleton, names, arity, visibility, callTargetFactory);
@@ -173,7 +173,7 @@ public void addLazyCoreMethod(
             final NodeFactory<? extends RubyNode> nodeFactory = loadNodeFactory(nodeFactoryName);
             final CoreMethod annotation = nodeFactory.getNodeClass().getAnnotation(CoreMethod.class);
             final RubyNode methodNode = createCoreMethodNode(nodeFactory, annotation, sharedMethodInfo);
-            return createCallTarget(context, sharedMethodInfo, methodNode, finalSplit);
+            return createCallTarget(language, sharedMethodInfo, methodNode, finalSplit);
         };
 
         addMethods(module, isModuleFunc, onSingleton, names, arity, visibility, callTargetFactory);
@@ -235,10 +235,10 @@ private static Arity createArity(int required, int optional, boolean rest, Strin
                 : new Arity(required, optional, rest, 0, new String[]{ keywordAsOptional }, true, false);
     }
 
-    private static RootCallTarget createCallTarget(RubyContext context, SharedMethodInfo sharedMethodInfo,
+    private static RootCallTarget createCallTarget(RubyLanguage language, SharedMethodInfo sharedMethodInfo,
             RubyNode methodNode, Split split) {
         final RubyRootNode rootNode = new RubyRootNode(
-                context,
+                language,
                 sharedMethodInfo.getSourceSection(),
                 null,
                 sharedMethodInfo,

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -71,6 +71,7 @@
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.RubyRootNode;
+import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.Backtrace;
@@ -1484,7 +1485,7 @@ public abstract static class CheckThreadInterrupt extends CoreMethodArrayArgumen
 
         @Specialization
         protected Object checkInts() {
-            getContext().getSafepointManager().poll(this);
+            SafepointManager.poll(getLanguage(), this);
             return nil;
         }
     }

src/main/java/org/truffleruby/core/GCNodes.java

@@ -22,6 +22,7 @@
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.collections.WeakValueCache;
+import org.truffleruby.language.SafepointManager;
 
 @CoreModule("GC")
 public abstract class GCNodes {
@@ -68,7 +69,7 @@ protected Object force() {
 
             do {
                 System.gc();
-                getContext().getSafepointManager().poll(this);
+                SafepointManager.poll(getLanguage(), this);
             } while (cache.get(key) != null);
 
             return nil;

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -1313,7 +1313,7 @@ private InternalMethod createMissingMethod(Object self, Object name, String norm
 
             final RubyNode newBody = new CallMethodMissingWithStaticName(name);
             final RubyRootNode newRootNode = new RubyRootNode(
-                    getContext(),
+                    getLanguage(),
                     info.getSourceSection(),
                     new FrameDescriptor(nil),
                     info,

src/main/java/org/truffleruby/core/method/MethodNodes.java

@@ -304,7 +304,7 @@ protected RootCallTarget methodCallTarget(InternalMethod method) {
 
             final SetReceiverNode setReceiverNode = new SetReceiverNode(method.getCallTarget());
             final RootNode newRootNode = new RubyRootNode(
-                    getContext(),
+                    getLanguage(),
                     sourceSection,
                     oldRootNode.getFrameDescriptor(),
                     method.getSharedMethodInfo(),

src/main/java/org/truffleruby/core/module/ModuleNodes.java

@@ -436,7 +436,7 @@ private void createAccessor(RubyModule module, String name, MaterializedFrame ca
             final RubyNode body = Translator
                     .createCheckArityNode(language, arity, accessInstanceVariable);
             final RubyRootNode rootNode = new RubyRootNode(
-                    getContext(),
+                    language,
                     sourceSection,
                     null,
                     sharedMethodInfo,
@@ -1214,7 +1214,7 @@ private RubySymbol defineMethod(RubyModule module, String name, RubyProc proc,
             final RubyNode body = NodeUtil.cloneNode(rootNode.getBody());
             final RubyNode newBody = new CallMethodWithProcBody(proc.declarationFrame, body);
             final RubyRootNode newRootNode = new RubyRootNode(
-                    getContext(),
+                    getLanguage(),
                     info.getSourceSection(),
                     rootNode.getFrameDescriptor(),
                     info,

src/main/java/org/truffleruby/core/mutex/ConditionVariableNodes.java

@@ -25,6 +25,7 @@
 import org.truffleruby.core.thread.ThreadManager;
 import org.truffleruby.core.thread.ThreadStatus;
 import org.truffleruby.language.Nil;
+import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.objects.AllocateHelperNode;
 
@@ -169,7 +170,7 @@ private void awaitSignal(RubyConditionVariable self, RubyThread thread, long dur
                      * the safepoint, and acquire it again before resuming waiting. */
                     condLock.unlock();
                     try {
-                        getContext().getSafepointManager().pollFromBlockingCall(this);
+                        SafepointManager.pollFromBlockingCall(getLanguage(), this);
                     } finally {
                         condLock.lock();
                     }

src/main/java/org/truffleruby/core/symbol/SymbolNodes.java

@@ -176,7 +176,7 @@ private static RubyProc createProc(RubyContext context, RubyLanguage language,
             declarationFrame.setObject(context.getCoreLibrary().emptyDeclarationSpecialVariableSlot, variables);
 
             final RubyRootNode rootNode = new RubyRootNode(
-                    context,
+                    language,
                     sourceSection,
                     new FrameDescriptor(nil),
                     sharedMethodInfo,