Emit performance warnings regardless of compilation and add spec for Regexp inline caches

* Much easier to test and reproduce that way.
* Fix PerformanceWarningNode & NotOptimizedWarningNode to check $VERBOSE
  and to call Warning.warn.

Author: eregon

spec/tags/truffle/splitting_tags.txt

@@ -1 +1,2 @@
 slow:Critical methods whic must split are under 100 AST nodes
+slow:Critical methods which must split are under 100 AST nodes

spec/truffle/splitting_spec.rb

@@ -8,7 +8,7 @@
 
 require_relative '../ruby/spec_helper'
 
-describe 'Critical methods whic must split' do
+describe 'Critical methods which must split' do
   it 'are under 100 AST nodes' do
     code = <<-'EOF'
 require 'strscan'

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

@@ -202,6 +202,7 @@ public final class CoreLibrary {
     public final RubyModule truffleRegexpOperationsModule;
     public final RubyModule truffleRandomOperationsModule;
     public final RubyModule truffleThreadOperationsModule;
+    public final RubyModule truffleWarningOperationsModule;
     public final RubyClass encodingCompatibilityErrorClass;
     public final RubyClass encodingUndefinedConversionErrorClass;
     public final RubyClass methodClass;
@@ -508,6 +509,7 @@ public CoreLibrary(RubyContext context, RubyLanguage language) {
         defineModule(truffleModule, "ReadlineHistory");
         truffleRandomOperationsModule = defineModule(truffleModule, "RandomOperations");
         truffleThreadOperationsModule = defineModule(truffleModule, "ThreadOperations");
+        truffleWarningOperationsModule = defineModule(truffleModule, "WarningOperations");
         defineModule(truffleModule, "WeakRefOperations");
         handleClass = defineClass(truffleModule, objectClass, "Handle");
         warningModule = defineModule("Warning");

src/main/java/org/truffleruby/core/regexp/InterpolatedRegexpNode.java

@@ -15,7 +15,7 @@
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.regexp.InterpolatedRegexpNodeFactory.RegexpBuilderNodeGen;
 import org.truffleruby.core.string.TStringWithEncoding;
-import org.truffleruby.language.NotOptimizedWarningNode;
+import org.truffleruby.language.PerformanceWarningNode;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
@@ -103,8 +103,9 @@ Object fast(TStringWithEncoding[] parts,
 
         @Specialization(replaces = "fast")
         Object slow(TStringWithEncoding[] parts,
-                @Cached NotOptimizedWarningNode notOptimizedWarningNode) {
-            notOptimizedWarningNode.warn("unstable interpolated regexps are not optimized");
+                @Cached PerformanceWarningNode performanceWarningNode) {
+            performanceWarningNode.warn(
+                    "unstable interpolated regexps cause deoptimization loops which hurt performance significantly, avoid creating regexps dynamically where possible or cache them to fix this");
             return createRegexp(parts);
         }
 

src/main/java/org/truffleruby/core/regexp/RegexpNodes.java

@@ -13,6 +13,7 @@
 import java.util.Iterator;
 
 import com.oracle.truffle.api.dsl.Bind;
+import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import com.oracle.truffle.api.strings.TruffleString;
@@ -32,7 +33,7 @@
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.annotations.Visibility;
-import org.truffleruby.language.NotOptimizedWarningNode;
+import org.truffleruby.language.PerformanceWarningNode;
 import org.truffleruby.language.control.DeferredRaiseException;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.library.RubyStringLibrary;
@@ -60,6 +61,7 @@ public abstract static class QuoteNode extends CoreMethodArrayArgumentsNode {
 
         public abstract RubyString execute(Object raw);
 
+        @NeverDefault
         public static QuoteNode create() {
             return RegexpNodesFactory.QuoteNodeFactory.create(null);
         }
@@ -76,10 +78,11 @@ RubyString quoteSymbol(RubySymbol raw) {
         }
 
         @Fallback
-        RubyString quote(Object raw,
+        static RubyString quote(Object raw,
                 @Cached ToStrNode toStrNode,
-                @Cached QuoteNode recursive) {
-            return recursive.execute(toStrNode.execute(this, raw));
+                @Cached QuoteNode recursive,
+                @Bind("this") Node node) {
+            return recursive.execute(toStrNode.execute(node, raw));
         }
 
     }
@@ -192,9 +195,9 @@ RubyRegexp slowCompiling(Object pattern, int options,
                 @Cached InlinedBranchProfile errorProfile,
                 @Cached @Shared TruffleString.AsTruffleStringNode asTruffleStringNode,
                 @Cached @Shared RubyStringLibrary libPattern,
-                @Cached NotOptimizedWarningNode notOptimizedWarningNode) {
-            notOptimizedWarningNode.warn(
-                    "unbounded creation of regexps causes deoptimization loops which hurts performance significantly, avoid creating regexps dynamically where possible or cache them to fix this");
+                @Cached PerformanceWarningNode performanceWarningNode) {
+            performanceWarningNode.warn(
+                    "unbounded creation of regexps causes deoptimization loops which hurt performance significantly, avoid creating regexps dynamically where possible or cache them to fix this");
             return compile(pattern, options, this, libPattern, asTruffleStringNode, errorProfile);
         }
 

src/main/java/org/truffleruby/core/regexp/TruffleRegexpNodes.java

@@ -71,7 +71,7 @@
 import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.interop.TranslateInteropExceptionNode;
 import org.truffleruby.language.LazyWarnNode;
-import org.truffleruby.language.NotOptimizedWarningNode;
+import org.truffleruby.language.PerformanceWarningNode;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.WarnNode;
@@ -311,11 +311,10 @@ static Object fastUnion(VirtualFrame frame, RubyString str, Object sep, Object[]
 
         @Specialization(replaces = "fastUnion")
         Object slowUnion(RubyString str, Object sep, Object[] args,
-                @Cached NotOptimizedWarningNode notOptimizedWarningNode,
+                @Cached PerformanceWarningNode performanceWarningNode,
                 @Cached InlinedBranchProfile errorProfile) {
-            notOptimizedWarningNode.warn(
-                    "unbounded creation of regexps causes deoptimization loops which hurts performance significantly, " +
-                            "avoid creating regexps dynamically where possible or cache them to fix this");
+            performanceWarningNode.warn(
+                    "unbounded creation of regexps causes deoptimization loops which hurt performance significantly, avoid creating regexps dynamically where possible or cache them to fix this");
 
             return buildUnion(str, sep, args, errorProfile);
         }

src/main/java/org/truffleruby/extra/TruffleGraalNodes.java

@@ -144,6 +144,14 @@ RubyProc copyCapturedLocals(RubyProc proc) {
 
     }
 
+    @Primitive(name = "compiled?")
+    public abstract static class IsCompiledNode extends PrimitiveNode {
+        @Specialization
+        boolean isCompiled() {
+            return CompilerDirectives.inCompiledCode();
+        }
+    }
+
     @Primitive(name = "assert_compilation_constant")
     public abstract static class AssertCompilationConstantNode extends PrimitiveArrayArgumentsNode {
 
@@ -163,7 +171,7 @@ private void notConstantBoundary() {
     }
 
     @Primitive(name = "assert_not_compiled")
-    public abstract static class AssertNotCompilationConstantNode extends PrimitiveNode {
+    public abstract static class AssertNotCompiledNode extends PrimitiveNode {
 
         @Specialization
         Object assertNotCompiled() {

src/main/java/org/truffleruby/language/NotOptimizedWarningNode.java

@@ -11,36 +11,32 @@
 
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
 
-import com.oracle.truffle.api.dsl.NeverDefault;
-import org.truffleruby.RubyLanguage;
+import com.oracle.truffle.api.strings.TruffleString;
+import org.truffleruby.RubyContext;
 
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.ControlFlowException;
 import com.oracle.truffle.api.source.SourceSection;
+import org.truffleruby.core.encoding.Encodings;
+import org.truffleruby.language.globals.ReadSimpleGlobalVariableNode;
 
 /** Displays a warning when code is compiled that will compile successfully but is very low performance. We don't want
  * to bail out, as this isn't visible to users - we want them to see if they're using code like this in something like a
  * benchmark.
  *
  * Ideally you should not use this node, and instead you should optimise the code which would use it. */
-@GenerateUncached
 public abstract class NotOptimizedWarningNode extends RubyBaseNode {
 
-    @NeverDefault
-    public static NotOptimizedWarningNode create() {
-        return NotOptimizedWarningNodeGen.create();
-    }
-
     @SuppressWarnings("serial")
     protected static final class Warned extends ControlFlowException {
     }
 
+    @Child ReadSimpleGlobalVariableNode readVerboseNode = ReadSimpleGlobalVariableNode.create("$VERBOSE");
+
     public final void warn(String message) {
         executeWarn(message);
     }
@@ -50,13 +46,18 @@ public final void warn(String message) {
     @Specialization(rewriteOn = Warned.class)
     void warnOnce(String message) throws Warned {
         // The message should be a constant, because we don't want to do anything expensive to create it
-        CompilerAsserts.compilationConstant(message);
+        CompilerAsserts.partialEvaluationConstant(message);
 
         // If we're in the interpreter then don't warn
         if (CompilerDirectives.inInterpreter()) {
             return;
         }
 
+        // Do not warn if $VERBOSE is nil
+        if (readVerboseNode.execute() == nil) {
+            return;
+        }
+
         // Only warn if Warning[:performance] is true
         if (!getContext().getWarningCategoryPerformance().get()) {
             return;
@@ -78,12 +79,14 @@ private void log(String message) {
                 .getTopMostUserSourceSection(getEncapsulatingSourceSection());
 
         final String displayedWarning = String.format(
-                "%s: %s",
+                "%s: warning: %s\n",
                 getContext().fileLine(userSourceSection),
                 message);
 
         if (DISPLAYED_WARNINGS.add(displayedWarning)) {
-            RubyLanguage.LOGGER.log(Level.WARNING, displayedWarning);
+            var warningString = createString(TruffleString.FromJavaStringNode.getUncached(), displayedWarning,
+                    Encodings.US_ASCII);
+            RubyContext.send(this, coreLibrary().truffleWarningOperationsModule, "performance_warning", warningString);
         }
     }
 

src/main/java/org/truffleruby/language/PerformanceWarningNode.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2018, 2024 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;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.truffleruby.RubyContext;
+import org.truffleruby.core.encoding.Encodings;
+import org.truffleruby.language.globals.ReadSimpleGlobalVariableNode;
+
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.nodes.ControlFlowException;
+import com.oracle.truffle.api.source.SourceSection;
+import com.oracle.truffle.api.strings.TruffleString;
+
+public abstract class PerformanceWarningNode extends RubyBaseNode {
+
+    @SuppressWarnings("serial")
+    protected static final class Warned extends ControlFlowException {
+    }
+
+    @Child ReadSimpleGlobalVariableNode readVerboseNode = ReadSimpleGlobalVariableNode.create("$VERBOSE");
+
+    public final void warn(String message) {
+        executeWarn(message);
+    }
+
+    protected abstract void executeWarn(String message);
+
+    @Specialization(rewriteOn = Warned.class)
+    void warnOnce(String message) throws Warned {
+        // The message should be a constant, because we don't want to do anything expensive to create it
+        CompilerAsserts.partialEvaluationConstant(message);
+
+        // Do not warn if $VERBOSE is nil
+        if (readVerboseNode.execute() == nil) {
+            return;
+        }
+
+        // Only warn if Warning[:performance] is true
+        if (!getContext().getWarningCategoryPerformance().get()) {
+            return;
+        }
+
+        log(message);
+        throw new Warned();
+    }
+
+    @Specialization(replaces = "warnOnce")
+    void doNotWarn(String message) {
+        // do nothing
+    }
+
+    @TruffleBoundary
+    private void log(String message) {
+        // We want the topmost user source section, as otherwise lots of warnings will come from the same core methods
+        final SourceSection userSourceSection = getContext().getCallStack()
+                .getTopMostUserSourceSection(getEncapsulatingSourceSection());
+
+        final String displayedWarning = String.format(
+                "%s: warning: %s\n",
+                getContext().fileLine(userSourceSection),
+                message);
+
+        if (DISPLAYED_WARNINGS.add(displayedWarning)) {
+            var warningString = createString(TruffleString.FromJavaStringNode.getUncached(), displayedWarning,
+                    Encodings.US_ASCII);
+            RubyContext.send(this, coreLibrary().truffleWarningOperationsModule, "performance_warning", warningString);
+        }
+    }
+
+    // The remembered set of displayed warnings is global to the VM
+    private static final Set<String> DISPLAYED_WARNINGS = ConcurrentHashMap.newKeySet();
+}

src/main/java/org/truffleruby/language/WarnNode.java

@@ -39,8 +39,8 @@ public static WarnNode create() {
     }
 
     public boolean shouldWarn() {
-        final Object verbosity = readVerboseNode.execute();
-        return verbosity != nil;
+        final Object verbose = readVerboseNode.execute();
+        return verbose != nil;
     }
 
     public final boolean shouldWarnForDeprecation() {