[GR-17457] More laziness in Nodes.

PullRequest: truffleruby/2809

Author: wirthi

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

@@ -400,9 +400,6 @@ protected Object ldexp(Object a, Object b) {
     @CoreMethod(names = "lgamma", isModuleFunction = true, required = 1)
     public abstract static class LGammaNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private IsANode isANode = IsANode.create();
-        @Child private ToFNode toFNode = ToFNode.create();
-
         private final BranchProfile exceptionProfile = BranchProfile.create();
 
         @Specialization
@@ -433,7 +430,9 @@ protected RubyArray lgamma(double a) {
         }
 
         @Fallback
-        protected RubyArray lgamma(Object a) {
+        protected RubyArray lgamma(Object a,
+                @Cached IsANode isANode,
+                @Cached ToFNode toFNode) {
             if (!isANode.executeIsA(a, coreLibrary().numericClass)) {
                 exceptionProfile.enter();
                 throw new RaiseException(getContext(), coreExceptions().typeErrorCantConvertInto(a, "Float", this));
@@ -469,6 +468,7 @@ protected double function(double a, NotProvided b) {
 
         @Specialization(guards = { "!isRubyBignum(a)", "!isImplicitLongOrDouble(a)" })
         protected double function(Object a, NotProvided b,
+                @Cached IsANode isANode,
                 @Cached ToFNode toFNode) {
             if (!isANode.executeIsA(a, coreLibrary().numericClass)) {
                 exceptionProfile.enter();
@@ -599,9 +599,6 @@ protected double doFunction(double a) {
 
     protected abstract static class SimpleMonadicMathNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private IsANode isANode = IsANode.create();
-        @Child private ToFNode toFNode = ToFNode.create();
-
         protected final BranchProfile exceptionProfile = BranchProfile.create();
 
         // Must be implemented because we can't prevent Truffle from generating the useless SimpleMonadicClassGen.
@@ -630,7 +627,9 @@ protected double function(double a) {
         }
 
         @Fallback
-        protected double function(Object a) {
+        protected double function(Object a,
+                @Cached IsANode isANode,
+                @Cached ToFNode toFNode) {
             if (!isANode.executeIsA(a, coreLibrary().numericClass)) {
                 exceptionProfile.enter();
                 throw new RaiseException(getContext(), coreExceptions().typeErrorCantConvertInto(a, "Float", this));
@@ -643,10 +642,6 @@ protected double function(Object a) {
 
     protected abstract static class SimpleDyadicMathNode extends CoreMethodArrayArgumentsNode {
 
-        @Child protected IsANode isANode = IsANode.create();
-        @Child protected ToFNode floatANode = ToFNode.create();
-        @Child protected ToFNode floatBNode = ToFNode.create();
-
         protected final BranchProfile exceptionProfile = BranchProfile.create();
 
         // Must be implemented because we can't prevent Truffle from generating the useless SimpleDyadicClassGen.
@@ -735,7 +730,10 @@ protected double function(double a, double b) {
         }
 
         @Fallback
-        protected double function(Object a, Object b) {
+        protected double function(Object a, Object b,
+                @Cached IsANode isANode,
+                @Cached ToFNode floatANode,
+                @Cached ToFNode floatBNode) {
             if (!(isANode.executeIsA(a, coreLibrary().numericClass) &&
                     isANode.executeIsA(b, coreLibrary().numericClass))) {
                 exceptionProfile.enter();

src/main/java/org/truffleruby/core/format/convert/ToDoubleNode.java

@@ -20,6 +20,10 @@ public abstract class ToDoubleNode extends FormatNode {
 
     public abstract double executeToDouble(VirtualFrame frame, Object object);
 
+    public static ToDoubleNode create() {
+        return ToDoubleNodeGen.create(null);
+    }
+
     @Specialization
     protected double toDouble(int value) {
         return value;

src/main/java/org/truffleruby/core/format/convert/ToIntegerNode.java

@@ -13,16 +13,14 @@
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.language.dispatch.DispatchNode;
 
-import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
 @NodeChild("value")
 public abstract class ToIntegerNode extends FormatNode {
 
-    @Child private DispatchNode integerNode;
-
     public abstract Object executeToInteger(VirtualFrame frame, Object object);
 
     @Specialization
@@ -46,12 +44,8 @@ protected long toInteger(double value) {
     }
 
     @Specialization(guards = "!isRubyNumber(value)")
-    protected Object toInteger(VirtualFrame frame, Object value) {
-        if (integerNode == null) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            integerNode = insert(DispatchNode.create());
-        }
-
+    protected Object toInteger(VirtualFrame frame, Object value,
+            @Cached DispatchNode integerNode) {
         return integerNode.call(getContext().getCoreLibrary().kernelModule, "Integer", value);
     }
 

src/main/java/org/truffleruby/core/format/read/array/ReadDoubleNode.java

@@ -13,10 +13,9 @@
 import org.truffleruby.core.array.library.ArrayStoreLibrary;
 import org.truffleruby.core.format.FormatNode;
 import org.truffleruby.core.format.convert.ToDoubleNode;
-import org.truffleruby.core.format.convert.ToDoubleNodeGen;
 import org.truffleruby.core.format.read.SourceNode;
 
-import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -27,16 +26,10 @@
 @ImportStatic(ArrayGuards.class)
 public abstract class ReadDoubleNode extends FormatNode {
 
-    @Child private ToDoubleNode toDoubleNode;
-
     @Specialization(limit = "storageStrategyLimit()")
     protected Object read(VirtualFrame frame, Object source,
-            @CachedLibrary("source") ArrayStoreLibrary sources) {
-        if (toDoubleNode == null) {
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            toDoubleNode = insert(ToDoubleNodeGen.create(null));
-        }
-
+            @CachedLibrary("source") ArrayStoreLibrary sources,
+            @Cached ToDoubleNode toDoubleNode) {
         return toDoubleNode.executeToDouble(frame, sources.read(source, advanceSourcePosition(frame)));
     }
 

src/main/java/org/truffleruby/core/hash/HashNodes.java

@@ -68,7 +68,7 @@ protected RubyHash allocate(RubyClass rubyClass) {
     @ImportStatic(HashGuards.class)
     public abstract static class ConstructNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private DispatchNode fallbackNode = DispatchNode.create();
+        @Child private DispatchNode fallbackNode;
 
         @ExplodeLoop(kind = LoopExplosionKind.FULL_UNROLL)
         @Specialization(guards = "isSmallArrayOfPairs(args, getLanguage())")
@@ -87,14 +87,14 @@ protected Object construct(RubyClass hashClass, Object[] args,
                     final Object pair = store[n];
 
                     if (!RubyGuards.isRubyArray(pair)) {
-                        return fallbackNode.call(hashClass, "_constructor_fallback", args);
+                        return fallback(hashClass, args);
                     }
 
                     final RubyArray pairArray = (RubyArray) pair;
                     final Object pairStore = pairArray.store;
 
                     if (pairStore.getClass() != Object[].class || pairArray.size != 2) {
-                        return fallbackNode.call(hashClass, "_constructor_fallback", args);
+                        return fallback(hashClass, args);
                     }
 
                     final Object[] pairObjectStore = (Object[]) pairStore;
@@ -114,6 +114,14 @@ protected Object construct(RubyClass hashClass, Object[] args,
 
         @Specialization(guards = "!isSmallArrayOfPairs(args, getLanguage())")
         protected Object constructFallback(RubyClass hashClass, Object[] args) {
+            return fallback(hashClass, args);
+        }
+
+        private Object fallback(RubyClass hashClass, Object[] args) {
+            if (fallbackNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                fallbackNode = insert(DispatchNode.create());
+            }
             return fallbackNode.call(hashClass, "_constructor_fallback", args);
         }