[GR-19220] If a call target supplier is fulfilled, just use it (#2686)

eregon · eregon · commit 3dfcaa039a9e · 2022-07-14T19:03:10.000Z
PullRequest: truffleruby/3411
diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java
@@ -16,7 +16,7 @@
 import com.oracle.truffle.api.TruffleSafepoint;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.collections.CachedSupplier;
+import org.truffleruby.language.methods.CachedLazyCallTargetSupplier;
 import org.truffleruby.core.CoreLibrary;
 import org.truffleruby.core.DummyNode;
 import org.truffleruby.core.array.ArrayUtils;
@@ -253,7 +253,7 @@ private static void addMethod(
                     arity);
 
             final RootCallTarget callTarget;
-            final CachedSupplier<RootCallTarget> callTargetSupplier;
+            final CachedLazyCallTargetSupplier callTargetSupplier;
             final NodeFactory<? extends RubyBaseNode> alwaysInlinedNodeFactory;
             if (alwaysInlined) {
                 callTarget = callTargetFactory.apply(sharedMethodInfo);
@@ -262,7 +262,8 @@ private static void addMethod(
             } else {
                 if (context.getLanguageSlow().options.LAZY_CALLTARGETS) {
                     callTarget = null;
-                    callTargetSupplier = new CachedSupplier<>(() -> callTargetFactory.apply(sharedMethodInfo));
+                    callTargetSupplier = new CachedLazyCallTargetSupplier(
+                            () -> callTargetFactory.apply(sharedMethodInfo));
                 } else {
                     callTarget = callTargetFactory.apply(sharedMethodInfo);
                     callTargetSupplier = null;
diff --git a/src/main/java/org/truffleruby/collections/CachedSupplier.java b/src/main/java/org/truffleruby/collections/CachedSupplier.java
diff --git a/src/main/java/org/truffleruby/language/methods/CachedLazyCallTargetSupplier.java b/src/main/java/org/truffleruby/language/methods/CachedLazyCallTargetSupplier.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020, 2022 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.language.methods;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.RootCallTarget;
+
+import java.util.function.Supplier;
+
+public class CachedLazyCallTargetSupplier {
+
+    // Volatile, so that writes from another thread will finish publishing the RootCallTarget first
+    private volatile RootCallTarget callTarget = null;
+    private Supplier<RootCallTarget> supplier;
+
+    public CachedLazyCallTargetSupplier(Supplier<RootCallTarget> supplier) {
+        this.supplier = supplier;
+    }
+
+    public RootCallTarget get() {
+        CompilerAsserts.neverPartOfCompilation("Only behind a transfer, must not PE the Supplier");
+
+        RootCallTarget alreadySet = this.callTarget;
+        if (alreadySet != null) {
+            return alreadySet;
+        }
+
+        synchronized (this) {
+            if (callTarget == null) {
+                callTarget = supplier.get();
+                supplier = null;
+            }
+            return callTarget;
+        }
+    }
+
+    public RootCallTarget getWhenAvailable() {
+        return callTarget;
+    }
+
+}
diff --git a/src/main/java/org/truffleruby/language/methods/InternalMethod.java b/src/main/java/org/truffleruby/language/methods/InternalMethod.java
@@ -15,7 +15,6 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import org.truffleruby.RubyContext;
-import org.truffleruby.collections.CachedSupplier;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.core.proc.RubyProc;
@@ -53,7 +52,7 @@ public class InternalMethod implements ObjectGraphNode {
     public final NodeFactory<? extends RubyBaseNode> alwaysInlinedNodeFactory;
     private final RubyProc proc; // only if method is created from a Proc
 
-    private final CachedSupplier<RootCallTarget> callTargetSupplier;
+    private final CachedLazyCallTargetSupplier callTargetSupplier;
     @CompilationFinal private RootCallTarget callTarget;
 
     public static InternalMethod fromProc(
@@ -117,7 +116,7 @@ public InternalMethod(
             NodeFactory<? extends RubyBaseNode> alwaysInlined,
             RubyProc proc,
             RootCallTarget callTarget,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         this(
                 sharedMethodInfo,
                 lexicalScope,
@@ -151,7 +150,7 @@ private InternalMethod(
             DeclarationContext activeRefinements,
             RubyProc proc,
             RootCallTarget callTarget,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         assert declaringModule != null;
         assert lexicalScope != null;
         assert !sharedMethodInfo.isBlock() : sharedMethodInfo;
@@ -171,6 +170,12 @@ private InternalMethod(
         this.proc = proc;
         this.callTarget = callTarget;
         this.callTargetSupplier = callTargetSupplier;
+
+        /* If the call target supplier has already been run, then don't wait until the first time the InternalMethod is
+         * asked for the call target, because this would be a deoptimization in getCallTarget(). */
+        if (callTarget == null && callTargetSupplier != null) {
+            this.callTarget = callTargetSupplier.getWhenAvailable();
+        }
     }
 
     public SharedMethodInfo getSharedMethodInfo() {
diff --git a/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java b/src/main/java/org/truffleruby/language/methods/LiteralMethodDefinitionNode.java
@@ -13,14 +13,12 @@
 import com.oracle.truffle.api.instrumentation.InstrumentableNode;
 import com.oracle.truffle.api.instrumentation.StandardTags;
 import com.oracle.truffle.api.instrumentation.Tag;
-import org.truffleruby.collections.CachedSupplier;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.RubyArguments;
 
-import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
 import java.util.Set;
@@ -32,7 +30,7 @@ public class LiteralMethodDefinitionNode extends RubyContextSourceNode {
     private final String name;
     private final SharedMethodInfo sharedMethodInfo;
     private final boolean isDefSingleton;
-    private final CachedSupplier<RootCallTarget> callTargetSupplier;
+    private final CachedLazyCallTargetSupplier callTargetSupplier;
 
     @Child private RubyNode moduleNode;
 
@@ -41,7 +39,7 @@ public LiteralMethodDefinitionNode(
             String name,
             SharedMethodInfo sharedMethodInfo,
             boolean isDefSingleton,
-            CachedSupplier<RootCallTarget> callTargetSupplier) {
+            CachedLazyCallTargetSupplier callTargetSupplier) {
         this.name = name;
         this.sharedMethodInfo = sharedMethodInfo;
         this.isDefSingleton = isDefSingleton;
diff --git a/src/main/java/org/truffleruby/parser/MethodTranslator.java b/src/main/java/org/truffleruby/parser/MethodTranslator.java
@@ -13,7 +13,7 @@
 import java.util.function.Supplier;
 
 import org.truffleruby.RubyLanguage;
-import org.truffleruby.collections.CachedSupplier;
+import org.truffleruby.language.methods.CachedLazyCallTargetSupplier;
 import org.truffleruby.core.IsNilNode;
 import org.truffleruby.core.cast.SplatCastNode;
 import org.truffleruby.core.cast.SplatCastNode.NilBehavior;
@@ -418,16 +418,15 @@ private RubyMethodRootNode translateMethodNode(SourceIndexLength sourceSection,
                 argsNode.getArity());
     }
 
-    public CachedSupplier<RootCallTarget> buildMethodNodeCompiler(SourceIndexLength sourceSection,
+    public CachedLazyCallTargetSupplier buildMethodNodeCompiler(SourceIndexLength sourceSection,
             MethodDefParseNode defNode, ParseNode bodyNode) {
 
         if (shouldLazyTranslate) {
-            return new CachedSupplier<>(() -> {
-                return translateMethodNode(sourceSection, defNode, bodyNode).getCallTarget();
-            });
+            return new CachedLazyCallTargetSupplier(
+                    () -> translateMethodNode(sourceSection, defNode, bodyNode).getCallTarget());
         } else {
             final RubyMethodRootNode root = translateMethodNode(sourceSection, defNode, bodyNode);
-            return new CachedSupplier<>(() -> root.getCallTarget());
+            return new CachedLazyCallTargetSupplier(() -> root.getCallTarget());
         }
     }
 
