[GR-25305] Implement RubyRootNode#cloneUninitialized

PullRequest: truffleruby/3472
oracle · Oct 10, 2022 · 72aa843 · 72aa843
2 parents a02c9a3 + 9924cd7
commit 72aa843
Show file tree

Hide file tree

Showing 260 changed files with 2,991 additions and 608 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,6 +12,7 @@ Compatibility:
 Performance:
 
 * Marking of native structures wrapped in objects is now done on C call exit to reduce memory overhead (@aardvark179).
+* Splitting (copying) of call targets has been optimized by implementing `cloneUninitialized()` (@andrykonchin, @eregon).
 
 Changes:
 

diff --git a/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java b/src/main/java/org/truffleruby/builtins/BuiltinsClasses.java
@@ -12,6 +12,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.cext.CExtNodesBuiltins;
 import org.truffleruby.cext.CExtNodesFactory;
 import org.truffleruby.core.GCNodesBuiltins;
@@ -155,6 +156,7 @@
 import org.truffleruby.interop.SourceLocationNodesBuiltins;
 import org.truffleruby.interop.SourceLocationNodesFactory;
 import org.truffleruby.language.RubyBaseNode;
+import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.TruffleBootNodesBuiltins;
 import org.truffleruby.language.TruffleBootNodesFactory;
 import org.truffleruby.stdlib.CoverageNodesBuiltins;
@@ -418,4 +420,21 @@ public static List<List<? extends NodeFactory<? extends RubyBaseNode>>> getCoreN
                 WeakRefNodesFactory.getFactories());
     }
 
+    // TODO: maybe we can make this more efficient or prepopulate it (but that might eager-load node classes on JVM, not so good)
+    public static final ClassValue<NodeFactory<RubyNode>> FACTORIES = new ClassValue<>() {
+        @SuppressWarnings("unchecked")
+        @Override
+        protected NodeFactory<RubyNode> computeValue(Class<?> type) {
+            for (var factories : getCoreNodeFactories()) {
+                for (var factory : factories) {
+                    if (factory.getNodeClass() == type) {
+                        return (NodeFactory<RubyNode>) factory;
+                    }
+                }
+            }
+
+            throw CompilerDirectives.shouldNotReachHere("Could not find NodeFactory for " + type);
+        }
+    };
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodArrayArgumentsNode.java
@@ -13,7 +13,7 @@
 
 import com.oracle.truffle.api.dsl.NodeChild;
 
-@NodeChild(value = "arguments", type = RubyNode[].class)
+@NodeChild(value = "argumentNodes", type = RubyNode[].class)
 public abstract class CoreMethodArrayArgumentsNode extends CoreMethodNode {
 
 }
diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNode.java b/src/main/java/org/truffleruby/builtins/CoreMethodNode.java
@@ -9,11 +9,19 @@
  */
 package org.truffleruby.builtins;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.language.RubyContextSourceNode;
 
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
+import org.truffleruby.language.RubyNode;
 
 @GenerateNodeFactory
 public abstract class CoreMethodNode extends RubyContextSourceNode {
 
+    @Override
+    public final RubyNode cloneUninitialized() {
+        throw CompilerDirectives.shouldNotReachHere(
+                getClass() + " should be handled by RubyCoreMethodRootNode#cloneUninitializedRootNode()");
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java b/src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java
@@ -147,7 +147,7 @@ private void addCoreMethod(RubyModule module, MethodDetails methodDetails) {
         final Split split = effectiveSplit(annotation.split(), annotation.needsBlock());
 
         final Function<SharedMethodInfo, RootCallTarget> callTargetFactory = sharedMethodInfo -> {
-            return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, split, annotation);
+            return createCoreMethodCallTarget(nodeFactory, language, sharedMethodInfo, split, annotation);
         };
 
         addMethods(
@@ -189,7 +189,7 @@ public void addLazyCoreMethod(
         final Function<SharedMethodInfo, RootCallTarget> callTargetFactory = sharedMethodInfo -> {
             final NodeFactory<? extends RubyBaseNode> nodeFactory = loadNodeFactory(nodeFactoryName);
             final CoreMethod annotation = nodeFactory.getNodeClass().getAnnotation(CoreMethod.class);
-            return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, finalSplit, annotation);
+            return createCoreMethodCallTarget(nodeFactory, language, sharedMethodInfo, finalSplit, annotation);
         };
 
         addMethods(
@@ -319,9 +319,8 @@ private static SharedMethodInfo makeSharedMethodInfo(String moduleName, boolean
                 null);
     }
 
-    public RootCallTarget createCoreMethodRootNode(NodeFactory<? extends RubyBaseNode> nodeFactory,
+    public static RootCallTarget createCoreMethodCallTarget(NodeFactory<? extends RubyBaseNode> nodeFactory,
             RubyLanguage language, SharedMethodInfo sharedMethodInfo, Split split, CoreMethod method) {
-
         // It's fine to load the node class here, this is only called when resolving the lazy CallTarget
         var nodeClass = nodeFactory.getNodeClass();
 
@@ -350,11 +349,18 @@ public RootCallTarget createCoreMethodRootNode(NodeFactory<? extends RubyBaseNod
                     null,
                     sharedMethodInfo,
                     new ReRaiseInlinedExceptionNode(nodeFactory),
-                    split,
+                    Split.NEVER,
                     ReturnID.INVALID);
             return reRaiseRootNode.getCallTarget();
         }
 
+        return createCoreMethodRootNode(nodeFactory, language, sharedMethodInfo, split, method).getCallTarget();
+    }
+
+    public static RubyCoreMethodRootNode createCoreMethodRootNode(NodeFactory<? extends RubyBaseNode> nodeFactory,
+            RubyLanguage language, SharedMethodInfo sharedMethodInfo, Split split, CoreMethod method) {
+        assert !method.alwaysInlined();
+
         final RubyNode[] argumentsNodes = new RubyNode[nodeFactory.getExecutionSignature().size()];
         int i = 0;
 
@@ -384,18 +390,19 @@ public RootCallTarget createCoreMethodRootNode(NodeFactory<? extends RubyBaseNod
         }
 
         RubyNode node = (RubyNode) createNodeFromFactory(nodeFactory, argumentsNodes);
-        RubyNode methodNode = transformResult(method, node);
+        RubyNode methodNode = transformResult(language, method, node);
 
-        final RubyCoreMethodRootNode rootNode = new RubyCoreMethodRootNode(
+        return new RubyCoreMethodRootNode(
                 language,
                 sharedMethodInfo.getSourceSection(),
                 null,
                 sharedMethodInfo,
                 methodNode,
                 split,
                 ReturnID.INVALID,
-                sharedMethodInfo.getArity());
-        return rootNode.getCallTarget();
+                sharedMethodInfo.getArity(),
+                nodeFactory,
+                method);
     }
 
     public static RubyBaseNode createNodeFromFactory(NodeFactory<? extends RubyBaseNode> nodeFactory,
@@ -438,7 +445,7 @@ private static RubyNode transformArgument(CoreMethod method, RubyNode argument,
         return argument;
     }
 
-    private RubyNode transformResult(CoreMethod method, RubyNode node) {
+    private static RubyNode transformResult(RubyLanguage language, CoreMethod method, RubyNode node) {
         if (!method.enumeratorSize().isEmpty()) {
             assert !method.returnsEnumeratorIfNoBlock()
                     : "Only one of enumeratorSize or returnsEnumeratorIfNoBlock can be specified";

diff --git a/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java b/src/main/java/org/truffleruby/builtins/EnumeratorSizeNode.java
@@ -29,10 +29,10 @@ public class EnumeratorSizeNode extends RubyContextSourceNode {
     private final RubySymbol methodName;
     private final RubySymbol sizeMethodName;
 
-    public EnumeratorSizeNode(RubySymbol enumeratorSize, RubySymbol methodName, RubyNode method) {
+    public EnumeratorSizeNode(RubySymbol sizeMethodName, RubySymbol methodName, RubyNode method) {
         this.method = method;
         this.methodName = methodName;
-        this.sizeMethodName = enumeratorSize;
+        this.sizeMethodName = sizeMethodName;
     }
 
     @Override
@@ -57,4 +57,13 @@ public Object execute(VirtualFrame frame) {
         }
     }
 
+    @Override
+    public RubyNode cloneUninitialized() {
+        var copy = new EnumeratorSizeNode(
+                sizeMethodName,
+                methodName,
+                method.cloneUninitialized());
+        return copy.copyFlags(this);
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveArrayArgumentsNode.java
@@ -9,11 +9,22 @@
  */
 package org.truffleruby.builtins;
 
+import com.oracle.truffle.api.dsl.NodeFactory;
 import org.truffleruby.language.RubyNode;
 
 import com.oracle.truffle.api.dsl.NodeChild;
 
-@NodeChild(value = "arguments", type = RubyNode[].class)
+@NodeChild(value = "argumentNodes", type = RubyNode[].class)
 public abstract class PrimitiveArrayArgumentsNode extends PrimitiveNode {
 
+    public abstract RubyNode[] getArgumentNodes();
+
+    @Override
+    public RubyNode cloneUninitialized() {
+        NodeFactory<RubyNode> factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass());
+        RubyNode[] copiedArguments = cloneUninitialized(getArgumentNodes());
+        var copy = (PrimitiveArrayArgumentsNode) CoreMethodNodeManager.createNodeFromFactory(factory, copiedArguments);
+        return copy.copyFlags(this);
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/PrimitiveNode.java b/src/main/java/org/truffleruby/builtins/PrimitiveNode.java
@@ -10,18 +10,24 @@
 
 package org.truffleruby.builtins;
 
+import com.oracle.truffle.api.dsl.NodeFactory;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.NotProvided;
 
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
+import org.truffleruby.language.RubyNode;
 
 @GenerateNodeFactory
 public abstract class PrimitiveNode extends RubyContextSourceNode {
 
     // The same as "undefined" in Ruby code
     protected static final Object FAILURE = NotProvided.INSTANCE;
 
-    public PrimitiveNode() {
+    @Override
+    public RubyNode cloneUninitialized() {
+        NodeFactory<RubyNode> factory = BuiltinsClasses.FACTORIES.get(getClass().getSuperclass());
+        var copy = (PrimitiveNode) CoreMethodNodeManager.createNodeFromFactory(factory, RubyNode.EMPTY_ARRAY);
+        return copy.copyFlags(this);
     }
 
 }
diff --git a/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java b/src/main/java/org/truffleruby/builtins/ReRaiseInlinedExceptionNode.java
@@ -14,6 +14,7 @@
 import org.truffleruby.core.exception.RubyException;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextSourceNode;
+import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.control.RaiseException;
 
 import com.oracle.truffle.api.CompilerDirectives;
@@ -48,4 +49,9 @@ public Object execute(VirtualFrame frame) {
         throw new RaiseException(getContext(), rubyException);
     }
 
+    @Override
+    public RubyNode cloneUninitialized() {
+        throw CompilerDirectives.shouldNotReachHere(getClass() + " should never be split");
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java b/src/main/java/org/truffleruby/builtins/ReturnEnumeratorIfNoBlockNode.java
@@ -58,4 +58,12 @@ public Object execute(VirtualFrame frame) {
         }
     }
 
+    @Override
+    public RubyNode cloneUninitialized() {
+        var copy = new ReturnEnumeratorIfNoBlockNode(
+                methodName,
+                method.cloneUninitialized());
+        return copy.copyFlags(this);
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java b/src/main/java/org/truffleruby/builtins/UnaryCoreMethodNode.java
diff --git a/src/main/java/org/truffleruby/cext/CExtNodes.java b/src/main/java/org/truffleruby/cext/CExtNodes.java
@@ -620,7 +620,7 @@ protected int bitLength(RubyBignum num) {
     }
 
     @Primitive(name = "rb_int_singlebit_p")
-    public abstract static class IntSinglebitPPrimitiveNode extends CoreMethodArrayArgumentsNode {
+    public abstract static class IntSinglebitPPrimitiveNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization
         protected int intSinglebitP(int num) {

diff --git a/src/main/java/org/truffleruby/core/IsNilNode.java b/src/main/java/org/truffleruby/core/IsNilNode.java
@@ -27,4 +27,10 @@ public Object execute(VirtualFrame frame) {
         return child.execute(frame) == nil;
     }
 
+    @Override
+    public RubyNode cloneUninitialized() {
+        var copy = new IsNilNode(child.cloneUninitialized());
+        return copy.copyFlags(this);
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/core/MathNodes.java b/src/main/java/org/truffleruby/core/MathNodes.java
@@ -387,9 +387,9 @@ protected double doFunction(double a) {
     }
 
     @Primitive(name = "math_hypot")
-    public abstract static class HypotNode extends SimpleDyadicMathNode {
+    public abstract static class HypotNode extends PrimitiveArrayArgumentsNode {
 
-        @Override
+        @Specialization
         protected double doFunction(double a, double b) {
             return Math.hypot(a, b);
         }

diff --git a/src/main/java/org/truffleruby/core/TruffleSystemNodes.java b/src/main/java/org/truffleruby/core/TruffleSystemNodes.java
@@ -98,7 +98,7 @@ protected RubyArray envVars() {
     }
 
     @Primitive(name = "java_get_env")
-    public abstract static class JavaGetEnv extends CoreMethodArrayArgumentsNode {
+    public abstract static class JavaGetEnv extends PrimitiveArrayArgumentsNode {
 
         @Specialization(guards = "strings.isRubyString(name)", limit = "1")
         protected Object javaGetEnv(Object name,

diff --git a/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java b/src/main/java/org/truffleruby/core/array/ArrayAppendOneNode.java
@@ -24,7 +24,7 @@
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
-@NodeChild(value = "array", type = RubyNode.class)
+@NodeChild(value = "arrayNode", type = RubyNode.class)
 @NodeChild(value = "valueNode", type = RubyNode.class)
 @ImportStatic(ArrayGuards.class)
 public abstract class ArrayAppendOneNode extends RubyContextSourceNode {
@@ -35,6 +35,8 @@ public static ArrayAppendOneNode create() {
 
     public abstract RubyArray executeAppendOne(RubyArray array, Object value);
 
+    public abstract RubyNode getArrayNode();
+
     public abstract RubyNode getValueNode();
 
     // Append of the correct type
@@ -83,4 +85,13 @@ protected RubyArray appendOneGeneralizeNonMutable(RubyArray array, Object value,
         setStoreAndSize(array, newStore, newSize);
         return array;
     }
+
+    @Override
+    public RubyNode cloneUninitialized() {
+        var copy = ArrayAppendOneNodeGen.create(
+                getArrayNode().cloneUninitialized(),
+                getValueNode().cloneUninitialized());
+        return copy.copyFlags(this);
+    }
+
 }
diff --git a/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java b/src/main/java/org/truffleruby/core/array/ArrayConcatNode.java
@@ -91,4 +91,9 @@ public void doExecuteVoid(VirtualFrame frame) {
         }
     }
 
+    public RubyNode cloneUninitialized() {
+        var copy = new ArrayConcatNode(cloneUninitialized(children));
+        return copy.copyFlags(this);
+    }
+
 }