[GR-38034] Run MRI tests on native instead of JVM

PullRequest: truffleruby/3291

Author: eregon

CHANGELOG.md

@@ -37,6 +37,7 @@ Bug fixes:
 * Fix `String#insert` to not call a subclassed string method (@bjfish).
 * Fix `rb_obj_call_init` to pass any block argument to the `initialize` method (#2675, @aardvark179).
 * Fix issue with feature loading not detecting a previously loaded feature (#2677, @bjfish).
+* Fix `/#{...}/o` to evaluate only once per context when splitting happens (@eregon).
 
 Compatibility:
 

ci.jsonnet

@@ -535,10 +535,10 @@ local composition_environment = utils.add_inclusion_tracking(part_definitions, "
       "ruby-test-specs-darwin-aarch64-17": $.platform.darwin_aarch64 + $.jdk.v17 + $.env.jvm + gate_no_build + $.use.build + $.run.test_unit_tck + native_config + $.run.test_specs + { timelimit: "01:40:00" },
       "ruby-test-fast-linux-aarch64":   $.platform.linux_aarch64 + $.jdk.v11 + $.env.jvm + gate + $.run.test_fast + native_config + { timelimit: "45:00" },
       "ruby-test-fast-linux":           $.platform.linux  + $.jdk.v11 + $.env.jvm + gate + $.run.test_fast + { timelimit: "45:00" },  # To catch missing slow tags
-      "ruby-test-mri-linux":            $.platform.linux  + $.jdk.v11 + $.env.jvm + gate + $.run.test_mri + { timelimit: "01:10:00" },
-      "ruby-test-mri-linux-aarch64":    $.platform.linux_aarch64 + $.jdk.v11 + $.env.jvm + gate + $.run.test_mri + { timelimit: "01:10:00" },
-      "ruby-test-mri-darwin-amd64":     $.platform.darwin_amd64 + $.jdk.v11 + $.env.jvm + gate + $.run.test_mri + { timelimit: "01:30:00" },
-      "ruby-test-mri-darwin-aarch64":   $.platform.darwin_aarch64 + $.jdk.v11 + $.env.jvm + gate + $.run.test_mri + { timelimit: "01:30:00" },
+      "ruby-test-mri-linux":            $.platform.linux  + $.jdk.v11 + $.env.native + gate + $.run.test_mri + { timelimit: "01:10:00" },
+      "ruby-test-mri-linux-aarch64":    $.platform.linux_aarch64 + $.jdk.v11 + $.env.native + gate + $.run.test_mri + { timelimit: "01:10:00" },
+      "ruby-test-mri-darwin-amd64":     $.platform.darwin_amd64 + $.jdk.v11 + $.env.native + gate + $.run.test_mri + { timelimit: "01:30:00" },
+      "ruby-test-mri-darwin-aarch64":   $.platform.darwin_aarch64 + $.jdk.v11 + $.env.native + gate + $.run.test_mri + { timelimit: "01:30:00" },
       "ruby-test-integration-linux":    $.platform.linux  + $.jdk.v11 + $.env.jvm + gate + $.run.test_integration,
       "ruby-test-cexts-linux":          $.platform.linux  + $.jdk.v11 + $.env.jvm + gate + $.use.gem_test_pack + $.use.sqlite331 + $.run.test_cexts,
       "ruby-test-cexts-darwin-amd64":   $.platform.darwin_amd64 + $.jdk.v11 + $.env.jvm + gate + $.use.gem_test_pack + $.run.test_cexts + { timelimit: "01:20:00" },

src/main/java/org/truffleruby/core/binding/TruffleBindingNodes.java

@@ -33,15 +33,15 @@ protected Object ofCaller() {
             /* When you use this method you're asking for the binding of the caller at the call site. When we get into
              * this method, that is then the binding of the caller of the caller. */
 
-            final Memo<Integer> frameCount = new Memo<>(0);
+            final int[] frameCount = new int[]{ 0 };
             final Memo<SourceSection> sourceSection = new Memo<>(null);
 
             final MaterializedFrame frame = Truffle.getRuntime().iterateFrames(frameInstance -> {
-                if (frameCount.get() == 2) {
+                if (frameCount[0] == 2) {
                     sourceSection.set(frameInstance.getCallNode().getEncapsulatingSourceSection());
                     return frameInstance.getFrame(FrameAccess.MATERIALIZE).materialize();
                 } else {
-                    frameCount.set(frameCount.get() + 1);
+                    frameCount[0] += 1;
                     return null;
                 }
             });

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -873,16 +873,14 @@ protected Object freezeDynamicObject(Object self,
 
     }
 
-    @ReportPolymorphism
-    @CoreMethod(names = "frozen?")
-    public abstract static class KernelFrozenNode extends CoreMethodArrayArgumentsNode {
-
+    @GenerateUncached
+    @CoreMethod(names = "frozen?", alwaysInlined = true)
+    public abstract static class KernelFrozenNode extends AlwaysInlinedMethodNode {
         @Specialization(limit = "getRubyLibraryCacheLimit()")
-        protected boolean isFrozen(Object self,
+        protected boolean isFrozen(Frame callerFrame, Object self, Object[] rubyArgs, RootCallTarget target,
                 @CachedLibrary("self") RubyLibrary rubyLibrary) {
             return rubyLibrary.isFrozen(self);
         }
-
     }
 
     /** Keep consistent with {@link org.truffleruby.core.hash.HashingNodes.ToHashByHashCode} */

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

@@ -25,7 +25,6 @@
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.builtins.CoreMethodNode;
 import org.truffleruby.builtins.CoreModule;
-import org.truffleruby.collections.Memo;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.encoding.Encodings;
 import org.truffleruby.core.rope.CodeRange;
@@ -267,13 +266,13 @@ public abstract static class SourceOfCallerNode extends CoreMethodArrayArguments
         @TruffleBoundary
         @Specialization
         protected Object sourceOfCaller() {
-            final Memo<Integer> frameCount = new Memo<>(0);
+            final int[] frameCount = new int[]{ 0 };
 
             final Source source = Truffle.getRuntime().iterateFrames(frameInstance -> {
-                if (frameCount.get() == 2) {
+                if (frameCount[0] == 2) {
                     return frameInstance.getCallNode().getEncapsulatingSourceSection().getSource();
                 } else {
-                    frameCount.set(frameCount.get() + 1);
+                    frameCount[0] += 1;
                     return null;
                 }
             });

src/main/java/org/truffleruby/language/control/OnceNode.java

@@ -16,31 +16,37 @@
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
+import java.util.Objects;
+
 /** Executes a child node just once, and uses the same value each subsequent time the node is executed. */
 public class OnceNode extends RubyContextSourceNode {
 
+    static class Holder { // Not NodeCloneable, on purpose
+        @CompilationFinal private volatile Object cachedValue;
+    }
+
     @Child private RubyNode child;
 
-    @CompilationFinal private volatile Object cachedValue;
+    // An extra indirection so with splitting we compute the value only once, and the Holder is shared across splits.
+    private final Holder holder = new Holder();
 
     public OnceNode(RubyNode child) {
         this.child = child;
     }
 
     @Override
     public Object execute(VirtualFrame frame) {
-        Object value = cachedValue;
+        Object value = holder.cachedValue;
 
         if (value == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             synchronized (this) {
                 // Read `cachedValue` again to check if the value was updated by another thread while this thread
                 // was waiting on the lock. If it's still null, this thread is the first one to get the lock and
                 // must update the cache.
-                value = cachedValue;
+                value = holder.cachedValue;
                 if (value == null) {
-                    value = cachedValue = child.execute(frame);
-                    assert value != null;
+                    value = holder.cachedValue = Objects.requireNonNull(child.execute(frame));
                 }
             }
         }

src/main/ruby/truffleruby/core/truffle/feature_loader.rb

@@ -281,6 +281,7 @@ def self.with_synchronized_features
     # always called inside #with_synchronized_features
     def self.get_loaded_features_index
       unless @loaded_features_version == $LOADED_FEATURES.version
+        raise '$LOADED_FEATURES is frozen; cannot append feature' if $LOADED_FEATURES.frozen?
         @loaded_features_index.clear
         $LOADED_FEATURES.map! do |val|
           val = StringValue(val)

test/mri/excludes/TestGc.rb

@@ -12,3 +12,4 @@
 exclude :test_start_full_mark, "needs investigation"
 exclude :test_start_immediate_sweep, "needs investigation"
 exclude :test_verify_internal_consistency, "needs investigation"
+exclude :test_gc_disabled_start, "fails on native: GR-38054"

test/mri/tests/ruby/test_rational.rb

@@ -992,7 +992,7 @@ def test_gcd_no_memory_leak
     assert_no_memory_leak([], "#{<<-"begin;"}", "#{<<-"end;"}", limit: 1.2, rss: true)
     x = (1<<121) + 1
     y = (1<<99) + 1
-    1000.times{x.gcd(y)}
+    100.times {1000.times{x.gcd(y)}}
     begin;
       100.times {1000.times{x.gcd(y)}}
     end;