Address truffle-interpreted-performance warnings

Author: eregon

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

@@ -80,14 +80,14 @@
 import org.truffleruby.interop.ToJavaStringNode;
 import org.truffleruby.interop.TranslateInteropExceptionNode;
 import org.truffleruby.core.string.ImmutableRubyString;
-import org.truffleruby.language.LazyWarnNode;
+import org.truffleruby.language.LazyWarningNode;
 import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.RubyRootNode;
-import org.truffleruby.language.WarnNode;
+import org.truffleruby.language.WarningNode;
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
 import org.truffleruby.language.arguments.EmptyArgumentsDescriptor;
 import org.truffleruby.language.arguments.KeywordArgumentsDescriptor;
@@ -1046,55 +1046,47 @@ Object rbConstSet(RubyModule module, Object name, Object value,
     @Primitive(name = "rb_gv_get")
     @ReportPolymorphism
     public abstract static class RbGvGetNode extends PrimitiveArrayArgumentsNode {
-
-        @Specialization(guards = "name == cachedName", limit = "getCacheLimit()")
-        static Object rbGvGetCached(VirtualFrame frame, String name,
-                @Cached("name") String cachedName,
-                @Cached("create(cachedName)") ReadGlobalVariableNode readGlobalVariableNode,
+        @Specialization
+        Object rbGvGet(VirtualFrame frame, String name,
                 @Cached InlinedBranchProfile notExistsProfile,
-                @Cached @Shared LazyWarnNode lazyWarnNode,
-                @Bind("this") Node node) {
-            boolean exists = getContext(node).getCoreLibrary().globalVariables.contains(cachedName);
+                @Cached LazyWarningNode lazyWarningNode,
+                @Cached RbGvGetInnerNode rbGvGetInnerNode) {
+            boolean exists = getContext().getCoreLibrary().globalVariables.contains(name);
 
+            // Check if it exists and return if not, before creating the GlobalVariableStorage
             if (!exists) {
-                notExistsProfile.enter(node);
-                warn(node, lazyWarnNode.get(node),
-                        StringUtils.format("global variable `%s' not initialized", cachedName));
-
+                notExistsProfile.enter(this);
+                WarningNode warningNode = lazyWarningNode.get(this);
+                if (warningNode.shouldWarn()) {
+                    warningNode.warningMessage(getContext(this).getCallStack().getTopMostUserSourceSection(),
+                            StringUtils.format("global variable `%s' not initialized", name));
+                }
                 return nil;
             }
 
-            return readGlobalVariableNode.execute(frame);
+            return rbGvGetInnerNode.execute(frame, this, name);
         }
+    }
 
-        @TruffleBoundary
-        @Specialization
-        Object rbGvGetUncached(String name,
-                @Cached DispatchNode dispatchNode,
-                @Cached @Shared LazyWarnNode lazyWarnNode) {
-            boolean exists = getContext().getCoreLibrary().globalVariables.contains(name);
-
-            if (!exists) {
-                warn(this, lazyWarnNode.get(this), StringUtils.format("global variable `%s' not initialized", name));
 
-                return nil;
-            }
+    @GenerateInline
+    @GenerateCached(false)
+    public abstract static class RbGvGetInnerNode extends RubyBaseNode {
 
-            return dispatchNode.call(coreLibrary().topLevelBinding, "eval", name);
-        }
+        public abstract Object execute(VirtualFrame frame, Node node, String name);
 
-        private static void warn(Node node, WarnNode warnNode, String message) {
-            if (warnNode.shouldWarn()) {
-                warnNode.warningMessage(
-                        getContext(node).getCallStack().getTopMostUserSourceSection(),
-                        message);
-            }
+        @Specialization(guards = "name == cachedName", limit = "getDefaultCacheLimit()")
+        static Object rbGvGetCached(VirtualFrame frame, Node node, String name,
+                @Cached("name") String cachedName,
+                @Cached(value = "create(cachedName)", inline = false) ReadGlobalVariableNode readGlobalVariableNode) {
+            return readGlobalVariableNode.execute(frame);
         }
 
-        protected int getCacheLimit() {
-            return getLanguage().options.DEFAULT_CACHE;
+        @Specialization
+        static Object rbGvGetUncached(Node node, String name,
+                @Cached(inline = false) DispatchNode dispatchNode) {
+            return dispatchNode.call(coreLibrary(node).topLevelBinding, "eval", name);
         }
-
     }
 
     @CoreMethod(names = "cext_module_function", onSingleton = true, required = 2)
@@ -1988,60 +1980,28 @@ protected RubyArray compileArgTypes(AbstractTruffleString format, RubyEncoding e
     @ReportPolymorphism
     public abstract static class RBSprintfNode extends CoreMethodArrayArgumentsNode {
 
-        @Specialization(
-                guards = {
-                        "libFormat.isRubyString(format)",
-                        "equalNode.execute(node, libFormat, format, cachedFormat, cachedEncoding)" },
-                limit = "2")
-        static RubyString formatCached(Object format, Object stringReader, RubyArray argArray,
-                @Cached @Shared ArrayToObjectArrayNode arrayToObjectArrayNode,
-                @Cached @Shared RubyStringLibrary libFormat,
-                @Cached @Shared InlinedBranchProfile exceptionProfile,
-                @Cached @Shared InlinedConditionProfile resizeProfile,
-                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode,
-                @Cached("asTruffleStringUncached(format)") TruffleString cachedFormat,
-                @Cached("libFormat.getEncoding(format)") RubyEncoding cachedEncoding,
-                @Cached("cachedFormat.byteLength(cachedEncoding.tencoding)") int cachedFormatLength,
-                @Cached("create(compileFormat(cachedFormat, cachedEncoding, stringReader))") DirectCallNode formatNode,
-                @Cached StringHelperNodes.EqualSameEncodingNode equalNode,
+        @Specialization(guards = "libFormat.isRubyString(format)", limit = "1")
+        static RubyString format(Object format, Object stringReader, RubyArray argArray,
+                @Cached ArrayToObjectArrayNode arrayToObjectArrayNode,
+                @Cached RubyStringLibrary libFormat,
+                @Cached TruffleString.FromByteArrayNode fromByteArrayNode,
+                @Cached RBSprintfInnerNode rbSprintfInnerNode,
+                @Cached InlinedBranchProfile exceptionProfile,
+                @Cached InlinedConditionProfile resizeProfile,
                 @Bind("this") Node node) {
-            final BytesResult result;
-            final Object[] arguments = arrayToObjectArrayNode.executeToObjectArray(argArray);
-            try {
-                result = (BytesResult) formatNode.call(new Object[]{ arguments, arguments.length, null });
-            } catch (FormatException e) {
-                exceptionProfile.enter(node);
-                throw FormatExceptionTranslator.translate(getContext(node), node, e);
-            }
-
-            return finishFormat(node, cachedFormatLength, result, resizeProfile, fromByteArrayNode);
-        }
-
-        @Specialization(guards = "libFormat.isRubyString(format)", replaces = "formatCached")
-        RubyString formatUncached(Object format, Object stringReader, RubyArray argArray,
-                @Cached IndirectCallNode formatNode,
-                @Cached @Shared InlinedBranchProfile exceptionProfile,
-                @Cached @Shared InlinedConditionProfile resizeProfile,
-                @Cached @Shared TruffleString.FromByteArrayNode fromByteArrayNode,
-                @Cached @Shared ArrayToObjectArrayNode arrayToObjectArrayNode,
-                @Cached @Shared RubyStringLibrary libFormat) {
             var tstring = libFormat.getTString(format);
             var encoding = libFormat.getEncoding(format);
             final Object[] arguments = arrayToObjectArrayNode.executeToObjectArray(argArray);
+
             final BytesResult result;
             try {
-                result = (BytesResult) formatNode.call(compileFormat(tstring, encoding, stringReader),
-                        new Object[]{ arguments, arguments.length, null });
+                result = rbSprintfInnerNode.execute(node, tstring, encoding, stringReader, arguments);
             } catch (FormatException e) {
-                exceptionProfile.enter(this);
-                throw FormatExceptionTranslator.translate(getContext(), this, e);
+                exceptionProfile.enter(node);
+                throw FormatExceptionTranslator.translate(getContext(node), node, e);
             }
 
-            return finishFormat(this, tstring.byteLength(encoding.tencoding), result, resizeProfile, fromByteArrayNode);
-        }
-
-        private static RubyString finishFormat(Node node, int formatLength, BytesResult result,
-                InlinedConditionProfile resizeProfile, TruffleString.FromByteArrayNode fromByteArrayNode) {
+            int formatLength = tstring.byteLength(encoding.tencoding);
             byte[] bytes = result.getOutput();
 
             if (resizeProfile.profile(node, bytes.length != result.getOutputLength())) {
@@ -2052,14 +2012,43 @@ private static RubyString finishFormat(Node node, int formatLength, BytesResult
                     result.getEncoding().getEncodingForLength(formatLength));
         }
 
+    }
+
+    @GenerateInline
+    @GenerateCached(false)
+    public abstract static class RBSprintfInnerNode extends RubyBaseNode {
+
+        public abstract BytesResult execute(Node node, AbstractTruffleString format, RubyEncoding encoding,
+                Object stringReader, Object[] arguments);
+
+        @Specialization(
+                guards = "equalNode.execute(node, format, encoding, cachedFormat, cachedEncoding)",
+                limit = "2")
+        static BytesResult formatCached(
+                Node node, AbstractTruffleString format, RubyEncoding encoding, Object stringReader, Object[] arguments,
+                @Cached("format.asTruffleStringUncached(encoding.tencoding)") TruffleString cachedFormat,
+                @Cached("encoding") RubyEncoding cachedEncoding,
+                @Cached(value = "create(compileFormat(cachedFormat, cachedEncoding, stringReader, node))",
+                        inline = false) DirectCallNode formatNode,
+                @Cached StringHelperNodes.EqualSameEncodingNode equalNode) {
+            return (BytesResult) formatNode.call(new Object[]{ arguments, arguments.length, null });
+        }
+
+        @Specialization(replaces = "formatCached")
+        static BytesResult formatUncached(
+                Node node, AbstractTruffleString format, RubyEncoding encoding, Object stringReader, Object[] arguments,
+                @Cached(inline = false) IndirectCallNode formatNode) {
+            return (BytesResult) formatNode.call(compileFormat(format, encoding, stringReader, node),
+                    new Object[]{ arguments, arguments.length, null });
+        }
+
         @TruffleBoundary
-        protected RootCallTarget compileFormat(AbstractTruffleString format, RubyEncoding encoding,
-                Object stringReader) {
+        protected static RootCallTarget compileFormat(AbstractTruffleString format, RubyEncoding encoding,
+                Object stringReader, Node node) {
             try {
-                return new RBSprintfCompiler(getLanguage(), this)
-                        .compile(format, encoding, stringReader);
+                return new RBSprintfCompiler(getLanguage(node), node).compile(format, encoding, stringReader);
             } catch (InvalidFormatException e) {
-                throw new RaiseException(getContext(), coreExceptions().argumentError(e.getMessage(), this));
+                throw new RaiseException(getContext(node), coreExceptions(node).argumentError(e.getMessage(), node));
             }
         }
     }

src/main/java/org/truffleruby/core/array/ArrayNodes.java

@@ -474,10 +474,9 @@ public abstract static class ClearNode extends ArrayCoreMethodNode {
 
         @Specialization
         RubyArray clear(RubyArray array,
-                @Cached IsSharedNode isSharedNode,
-                @Cached ConditionProfile sharedProfile) {
+                @Cached IsSharedNode isSharedNode) {
             setStoreAndSize(array,
-                    ArrayStoreLibrary.initialStorage(sharedProfile.profile(isSharedNode.executeIsShared(this, array))),
+                    ArrayStoreLibrary.initialStorage(isSharedNode.execute(this, array)),
                     0);
             return array;
         }
@@ -1031,13 +1030,15 @@ public abstract static class HashNode extends PrimitiveArrayArgumentsNode {
 
         private static final int CLASS_SALT = 42753062; // random number, stops hashes for similar values but different classes being the same, static because we want deterministic hashes
 
+        // Inlined profiles/nodes are @Exclusive to fix truffle-interpreted-performance warning
+
         @Specialization(limit = "storageStrategyLimit()")
-        static long hash(VirtualFrame frame, RubyArray array,
+        static long hash(RubyArray array,
                 @Bind("array.getStore()") Object store,
                 @CachedLibrary("store") ArrayStoreLibrary stores,
                 @Cached HashingNodes.ToHashByHashCode toHashByHashCode,
-                @Cached @Shared InlinedIntValueProfile arraySizeProfile,
-                @Cached @Shared InlinedLoopConditionProfile loopProfile,
+                @Cached @Exclusive InlinedIntValueProfile arraySizeProfile,
+                @Cached @Exclusive InlinedLoopConditionProfile loopProfile,
                 @Bind("this") Node node) {
             final int size = arraySizeProfile.profile(node, array.size);
             long h = getContext(node).getHashing(node).start(size);
@@ -1107,28 +1108,28 @@ public abstract static class InitializeNode extends CoreMethodArrayArgumentsNode
         protected abstract RubyArray executeInitialize(RubyArray array, Object size, Object fillingValue,
                 Object block);
 
+        // Inlined profiles/nodes are @Exclusive to fix truffle-interpreted-performance warning
+
         @Specialization
         RubyArray initializeNoArgs(RubyArray array, NotProvided size, NotProvided fillingValue, Nil block,
-                @Cached @Shared IsSharedNode isSharedNode,
-                @Cached @Shared ConditionProfile sharedProfile) {
+                @Cached @Shared IsSharedNode isSharedNode) {
             setStoreAndSize(array,
-                    ArrayStoreLibrary.initialStorage(sharedProfile.profile(isSharedNode.executeIsShared(this, array))),
+                    ArrayStoreLibrary.initialStorage(isSharedNode.execute(this, array)),
                     0);
             return array;
         }
 
         @Specialization
         RubyArray initializeOnlyBlock(RubyArray array, NotProvided size, NotProvided fillingValue, RubyProc block,
                 @Cached @Shared IsSharedNode isSharedNode,
-                @Cached @Shared ConditionProfile sharedProfile,
                 @Cached("new()") WarningNode warningNode) {
             if (warningNode.shouldWarn()) {
                 final SourceSection sourceSection = getContext().getCallStack().getTopMostUserSourceSection();
                 warningNode.warningMessage(sourceSection, "given block not used");
             }
 
             setStoreAndSize(array,
-                    ArrayStoreLibrary.initialStorage(sharedProfile.profile(isSharedNode.executeIsShared(this, array))),
+                    ArrayStoreLibrary.initialStorage(isSharedNode.execute(this, array)),
                     0);
             return array;
         }
@@ -1157,10 +1158,9 @@ RubyArray initializeSizeTooBig(RubyArray array, long size, NotProvided fillingVa
         @Specialization(guards = "size >= 0")
         RubyArray initializeWithSizeNoValue(RubyArray array, int size, NotProvided fillingValue, Nil block,
                 @Cached @Shared IsSharedNode isSharedNode,
-                @Cached @Shared ConditionProfile sharedProfile,
                 @CachedLibrary(limit = "2") @Exclusive ArrayStoreLibrary stores) {
             final Object store;
-            if (sharedProfile.profile(isSharedNode.executeIsShared(this, array))) {
+            if (isSharedNode.execute(this, array)) {
                 store = new SharedArrayStorage(new Object[size]);
             } else {
                 store = new Object[size];
@@ -1209,8 +1209,8 @@ RubyArray initializeSizeOther(RubyArray array, Object size, Object fillingValue,
         static Object initializeBlock(RubyArray array, int size, Object unusedFillingValue, RubyProc block,
                 @Cached ArrayBuilderNode arrayBuilder,
                 @CachedLibrary(limit = "2") @Exclusive ArrayStoreLibrary stores,
-                @Cached @Shared IsSharedNode isSharedNode,
-                @Cached @Shared ConditionProfile sharedProfile,
+                // @Exclusive to fix truffle-interpreted-performance warning
+                @Cached @Exclusive IsSharedNode isSharedNode,
                 @Cached @Exclusive LoopConditionProfile loopProfile,
                 @Cached CallBlockNode yieldNode,
                 @Bind("this") Node node) {
@@ -1225,7 +1225,7 @@ static Object initializeBlock(RubyArray array, int size, Object unusedFillingVal
             } finally {
                 profileAndReportLoopCount(node, loopProfile, n);
                 Object store = arrayBuilder.finish(state, n);
-                if (sharedProfile.profile(isSharedNode.executeIsShared(node, array))) {
+                if (isSharedNode.execute(node, array)) {
                     store = stores.makeShared(store, n);
                 }
                 setStoreAndSize(array, store, n);
@@ -1796,12 +1796,11 @@ RubyArray replace(RubyArray array, Object otherObject,
                 @Cached ToAryNode toAryNode,
                 @Cached ArrayCopyOnWriteNode cowNode,
                 @Cached IsSharedNode isSharedNode,
-                @Cached ConditionProfile sharedProfile,
                 @CachedLibrary(limit = "2") ArrayStoreLibrary stores) {
             final var other = toAryNode.execute(this, otherObject);
             final int size = other.size;
             Object store = cowNode.execute(other, 0, size);
-            if (sharedProfile.profile(isSharedNode.executeIsShared(this, array))) {
+            if (isSharedNode.execute(this, array)) {
                 store = stores.makeShared(store, size);
             }
             setStoreAndSize(array, store, size);