[GR-53439] Change splitting strategy for some core methods

PullRequest: truffleruby/4262

Author: andrykonchin

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

@@ -21,6 +21,7 @@
 
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -46,7 +47,7 @@ public static ArrayAppendOneNode create() {
     // Append of the correct type
 
     @Specialization(
-            guards = { "stores.acceptsValue(store, value)" },
+            guards = "stores.acceptsValue(store, value)",
             limit = "storageStrategyLimit()")
     RubyArray appendOneSameType(RubyArray array, Object value,
             @Bind("array.getStore()") Object store,
@@ -68,15 +69,34 @@ RubyArray appendOneSameType(RubyArray array, Object value,
         return array;
     }
 
+    // Append to an empty array
+
+    @ReportPolymorphism.Exclude
+    @Specialization(
+            guards = "isZeroLengthArrayStore(array.getStore())",
+            limit = "storageStrategyLimit()")
+    RubyArray appendOneToEmptyArray(RubyArray array, Object value,
+            @Bind("array.getStore()") Object currentStore,
+            @CachedLibrary("currentStore") ArrayStoreLibrary currentStores,
+            @CachedLibrary(limit = "storageStrategyLimit()") @Exclusive ArrayStoreLibrary newStores) {
+        final int newCapacity = ArrayUtils.capacityForOneMore(getLanguage(), 0);
+        final Object newStore = currentStores.allocateForNewValue(currentStore, value, newCapacity);
+        newStores.write(newStore, 0, value);
+        setStoreAndSize(array, newStore, 1);
+        return array;
+    }
+
     // Append forcing a generalization
 
     @Specialization(
-            guards = "!currentStores.acceptsValue(array.getStore(), value)",
+            guards = {
+                    "!isZeroLengthArrayStore(array.getStore())",
+                    "!currentStores.acceptsValue(array.getStore(), value)" },
             limit = "storageStrategyLimit()")
     RubyArray appendOneGeneralizeNonMutable(RubyArray array, Object value,
             @Bind("array.getStore()") Object currentStore,
             @CachedLibrary("currentStore") ArrayStoreLibrary currentStores,
-            @CachedLibrary(limit = "storageStrategyLimit()") ArrayStoreLibrary newStores) {
+            @CachedLibrary(limit = "storageStrategyLimit()") @Exclusive ArrayStoreLibrary newStores) {
         final int oldSize = array.size;
         final int newSize = oldSize + 1;
         final int oldCapacity = currentStores.capacity(currentStore);

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

@@ -10,6 +10,7 @@
 package org.truffleruby.core.array;
 
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.core.array.library.ArrayStoreLibrary;
 import org.truffleruby.core.array.library.ZeroLengthArrayStore;
 
 public final class ArrayGuards {
@@ -41,4 +42,8 @@ public static boolean basicStore(Object store) {
     public static boolean zeroLengthStore(Object store) {
         return store == ZeroLengthArrayStore.ZERO_LENGTH_STORE;
     }
+
+    public static boolean isZeroLengthArrayStore(Object store) {
+        return store == ZeroLengthArrayStore.ZERO_LENGTH_STORE || store == ArrayStoreLibrary.SHARED_INITIAL_STORE;
+    }
 }

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

@@ -1712,7 +1712,7 @@ Object popNToInt(RubyArray array, Object n,
 
     }
 
-    @CoreMethod(names = "<<", raiseIfFrozenSelf = true, required = 1)
+    @CoreMethod(names = "<<", raiseIfFrozenSelf = true, required = 1, split = Split.ALWAYS)
     public abstract static class AppendNode extends ArrayCoreMethodNode {
 
         @Child private ArrayAppendOneNode appendOneNode = ArrayAppendOneNode.create();

src/main/java/org/truffleruby/core/array/library/ArrayStoreLibrary.java

@@ -34,7 +34,7 @@ public abstract class ArrayStoreLibrary extends Library {
     private static final Object INITIAL_STORE = ZeroLengthArrayStore.ZERO_LENGTH_STORE;
     private static final ArrayAllocator INITIAL_ALLOCATOR = ZeroLengthArrayStore.ZERO_LENGTH_ALLOCATOR;
 
-    private static final Object SHARED_INITIAL_STORE = new SharedArrayStorage(ZeroLengthArrayStore.ZERO_LENGTH_STORE);
+    public static final Object SHARED_INITIAL_STORE = new SharedArrayStorage(ZeroLengthArrayStore.ZERO_LENGTH_STORE);
     private static final ArrayAllocator SHARED_INITIAL_ALLOCATOR = SharedArrayStorage.SHARED_ZERO_LENGTH_ARRAY_ALLOCATOR;
 
     private static final LibraryFactory<ArrayStoreLibrary> FACTORY = LibraryFactory.resolve(ArrayStoreLibrary.class);

src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java

@@ -106,15 +106,17 @@ boolean not(Object value,
 
     }
 
-    @CoreMethod(names = "!=", required = 1)
-    public abstract static class NotEqualNode extends CoreMethodArrayArgumentsNode {
-
-        @Child private DispatchNode equalNode = DispatchNode.create();
+    // Needed to split since it calls `==`. But seems a bit expensive to split, so it should be AlwaysInlinedMethodNode.
+    @GenerateUncached
+    @CoreMethod(names = "!=", required = 1, alwaysInlined = true)
+    public abstract static class NotEqualNode extends AlwaysInlinedMethodNode {
 
         @Specialization
-        boolean equal(VirtualFrame frame, Object a, Object b,
-                @Cached BooleanCastNode booleanCastNode) {
-            return !booleanCastNode.execute(this, equalNode.call(a, "==", b));
+        boolean equal(Frame frame, Object self, Object[] rubyArgs, RootCallTarget target,
+                @Cached BooleanCastNode booleanCastNode,
+                @Cached DispatchNode equalNode) {
+            final Object object = RubyArguments.getArgument(rubyArgs, 0);
+            return !booleanCastNode.execute(this, equalNode.call(self, "==", object));
         }
 
     }
@@ -126,7 +128,6 @@ boolean equal(VirtualFrame frame, Object a, Object b,
     @CoreMethod(names = { "equal?", "==" }, required = 1)
     public abstract static class BasicObjectEqualNode extends CoreMethodArrayArgumentsNode {
 
-
         @Specialization
         boolean equal(Object a, Object b,
                 @Cached ReferenceEqualNode referenceEqualNode) {

src/main/java/org/truffleruby/core/proc/ProcNodes.java

@@ -17,6 +17,7 @@
 import com.oracle.truffle.api.strings.TruffleString;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.annotations.CoreMethod;
+import org.truffleruby.annotations.Split;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
 import org.truffleruby.annotations.CoreModule;
 import org.truffleruby.annotations.Primitive;
@@ -60,7 +61,7 @@ RubyProc allocate(RubyClass rubyClass) {
         }
     }
 
-    @CoreMethod(names = "new", constructor = true, needsBlock = true, rest = true)
+    @CoreMethod(names = "new", constructor = true, needsBlock = true, rest = true, split = Split.HEURISTIC)
     public abstract static class ProcNewNode extends CoreMethodArrayArgumentsNode {
 
         @NeverDefault

src/main/ruby/truffleruby/core/kernel.rb

@@ -319,7 +319,7 @@ def exit!(code = 1)
   def extend(*modules)
     raise ArgumentError, 'wrong number of arguments (0 for 1+)' if modules.empty?
 
-    modules.reverse_each do |mod|
+    block = proc do |mod|
       if !Primitive.is_a?(mod, Module) or Primitive.is_a?(mod, Class)
         raise TypeError, "wrong argument type #{Primitive.class(mod)} (expected Module)"
       elsif Primitive.is_a?(mod, Refinement)
@@ -329,8 +329,16 @@ def extend(*modules)
       mod.__send__ :extend_object, self
       mod.__send__ :extended, self
     end
+
+    # __send__ calls above report polymorphism because they see different singleton classes for each module instance.
+    # But these methods are called only once per object and module pair, so it is not worth to split for them.
+    Truffle::Graal.never_split block
+
+    modules.reverse_each(&block)
+
     self
   end
+  Truffle::Graal.never_split instance_method(:extend)
 
   def getc
     $stdin.getc

src/main/ruby/truffleruby/core/module.rb

@@ -78,10 +78,12 @@ def include?(mod)
 
   def include(*modules)
     raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)' if modules.empty?
+
     if Primitive.is_a?(self, Refinement)
       raise TypeError, 'Refinement#include has been removed'
     end
-    modules.reverse_each do |mod|
+
+    block = proc do |mod|
       if !Primitive.is_a?(mod, Module) or Primitive.is_a?(mod, Class)
         raise TypeError, "wrong argument type #{Primitive.class(mod)} (expected Module)"
       end
@@ -93,15 +95,25 @@ def include(*modules)
       mod.__send__ :append_features, self
       mod.__send__ :included, self
     end
+
+    # __send__ calls above report polymorphism because they see different singleton classes for each module instance.
+    # But these methods are called only once per object and module pair, so it is not worth to split for them.
+    Truffle::Graal.never_split block
+
+    modules.reverse_each(&block)
+
     self
   end
+  Truffle::Graal.never_split instance_method(:include)
 
   def prepend(*modules)
     raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)' if modules.empty?
+
     if Primitive.is_a?(self, Refinement)
       raise TypeError, 'Refinement#prepend has been removed'
     end
-    modules.reverse_each do |mod|
+
+    block = proc do |mod|
       if !Primitive.is_a?(mod, Module) or Primitive.is_a?(mod, Class)
         raise TypeError, "wrong argument type #{Primitive.class(mod)} (expected Module)"
       end
@@ -113,8 +125,16 @@ def prepend(*modules)
       mod.__send__ :prepend_features, self
       mod.__send__ :prepended, self
     end
+
+    # __send__ calls above report polymorphism because they see different singleton classes for each module instance.
+    # But these methods are called only once per object and module pair, so it is not worth to split for them.
+    Truffle::Graal.never_split block
+
+    modules.reverse_each(&block)
+
     self
   end
+  Truffle::Graal.never_split instance_method(:prepend)
 
   def const_defined?(name, inherit = true)
     Primitive.module_const_defined?(self, name, inherit, true)

src/main/ruby/truffleruby/core/pre.rb

@@ -82,6 +82,7 @@ module Kernel
   def define_singleton_method(*args, &block)
     singleton_class.define_method(*args, &block)
   end
+  Truffle::Graal.never_split instance_method(:define_singleton_method)
 
   def extend(mod)
     mod.__send__ :extend_object, self