ShareObjectNode supports DSL inlining

Author: horakivo

src/main/java/org/truffleruby/language/objects/shared/ShareObjectNode.java

@@ -13,6 +13,9 @@
 import java.util.List;
 import java.util.Objects;
 
+import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.dsl.GenerateInline;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.PropertyGetter;
 import org.truffleruby.core.kernel.KernelNodes;
 import org.truffleruby.language.RubyBaseNode;
@@ -32,24 +35,28 @@
 
 /** Share the object and all that is reachable from it (see {@link ObjectGraph#getAdjacentObjects}) */
 @ImportStatic(ShapeCachingGuards.class)
+@GenerateInline(inlineByDefault = true)
 public abstract class ShareObjectNode extends RubyBaseNode {
 
     protected static final int CACHE_LIMIT = 8;
 
-    protected final int depth;
+    public final void execute(Node node, RubyDynamicObject object, int depth) {
+        CompilerAsserts.partialEvaluationConstant(depth);
+        executeInternal(node, object, depth);
+    }
 
-    public ShareObjectNode(int depth) {
-        this.depth = depth;
+    public final void executeCached(RubyDynamicObject object, int depth) {
+        execute(this, object, depth);
     }
 
-    public abstract void executeShare(RubyDynamicObject object);
+    protected abstract void executeInternal(Node node, RubyDynamicObject object, int depth);
 
     @ExplodeLoop
     @Specialization(
             guards = { "object.getShape() == cachedShape", "propertyGetters.length <= MAX_EXPLODE_SIZE" },
             assumptions = { "cachedShape.getValidAssumption()", "sharedShape.getValidAssumption()" },
             limit = "CACHE_LIMIT")
-    protected void shareCached(RubyDynamicObject object,
+    protected static void shareCached(Node node, RubyDynamicObject object, int depth,
             @Cached("object.getShape()") Shape cachedShape,
             @Cached("createSharedShape(cachedShape)") Shape sharedShape,
             @CachedLibrary(limit = "1") DynamicObjectLibrary objectLibrary,
@@ -66,12 +73,12 @@ protected void shareCached(RubyDynamicObject object,
         // Note that the metaclass might refer to `object` via `attached`, so it is important to share the object first.
         if (!object.getMetaClass().getShape().isShared()) {
             shareMetaClassProfile.enter();
-            SharedObjects.writeBarrier(getLanguage(), object.getMetaClass());
+            SharedObjects.writeBarrier(getLanguage(node), object.getMetaClass());
         }
         assert SharedObjects
                 .isShared(object.getLogicalClass()) : "the logical class should have been shared by the metaclass";
 
-        shareInternalFieldsNode.execute(this, object, depth);
+        shareInternalFieldsNode.execute(node, object, depth);
 
         for (int i = 0; i < propertyGetters.length; i++) {
             final PropertyGetter propertyGetter = propertyGetters[i];
@@ -82,7 +89,7 @@ protected void shareCached(RubyDynamicObject object,
         assert allFieldsAreShared(object);
     }
 
-    private boolean allFieldsAreShared(RubyDynamicObject object) {
+    private static boolean allFieldsAreShared(RubyDynamicObject object) {
         for (Object value : ObjectGraph.getAdjacentObjects(object)) {
             assert SharedObjects.isShared(value) : "unshared field in shared object: " + value;
         }
@@ -91,13 +98,14 @@ private boolean allFieldsAreShared(RubyDynamicObject object) {
     }
 
     @Specialization(guards = "updateShape(object)")
-    protected void updateShapeAndShare(RubyDynamicObject object) {
-        executeShare(object);
+    protected static void updateShapeAndShare(RubyDynamicObject object, int depth,
+            @Cached(inline = false) ShareObjectNode shareObjectNode) {
+        shareObjectNode.executeCached(object, depth);
     }
 
     @Specialization(replaces = { "shareCached", "updateShapeAndShare" })
-    protected void shareUncached(RubyDynamicObject object) {
-        SharedObjects.writeBarrier(getLanguage(), object);
+    protected static void shareUncached(Node node, RubyDynamicObject object, int depth) {
+        SharedObjects.writeBarrier(getLanguage(node), object);
     }
 
     protected static PropertyGetter[] getObjectProperties(Shape shape) {
@@ -110,7 +118,7 @@ protected static PropertyGetter[] getObjectProperties(Shape shape) {
         return objectProperties.toArray(KernelNodes.CopyInstanceVariablesNode.EMPTY_PROPERTY_GETTER_ARRAY);
     }
 
-    protected WriteBarrierNode[] createWriteBarrierNodes(PropertyGetter[] propertyGetters) {
+    protected static WriteBarrierNode[] createWriteBarrierNodes(PropertyGetter[] propertyGetters) {
         WriteBarrierNode[] nodes = propertyGetters.length == 0
                 ? WriteBarrierNode.EMPTY_ARRAY
                 : new WriteBarrierNode[propertyGetters.length];
@@ -120,7 +128,7 @@ protected WriteBarrierNode[] createWriteBarrierNodes(PropertyGetter[] propertyGe
         return nodes;
     }
 
-    protected Shape createSharedShape(Shape cachedShape) {
+    protected static Shape createSharedShape(Shape cachedShape) {
         if (cachedShape.isShared()) {
             throw new UnsupportedOperationException(
                     "Thread-safety bug: the object is already shared. This means another thread marked the object as shared concurrently.");

src/main/java/org/truffleruby/language/objects/shared/WriteBarrierNode.java

@@ -71,14 +71,17 @@ protected static void alreadySharedUncached(RubyDynamicObject value, int depth)
             assumptions = "cachedShape.getValidAssumption()",
             // limit of 1 to avoid creating many nodes if the value's Shape is polymorphic.
             limit = "1")
-    protected static void writeBarrierCached(RubyDynamicObject value, int depth,
+    protected static void writeBarrierCached(Node node, RubyDynamicObject value, int depth,
             @Cached("value.getShape()") Shape cachedShape,
-            @Cached("createShareObjectNode(depth)") ShareObjectNode shareObjectNode) {
-        shareObjectNode.executeShare(value);
+            // Recursive inlining is not supported. ShareObjectNode contains cached parameter ShareInternalFieldsNode
+            // which contains again WriteBarrierNode
+            @Cached(inline = false) ShareObjectNode shareObjectNode) {
+        shareObjectNode.executeCached(value, depth + 1);
     }
 
     @Specialization(guards = "updateShape(value)")
     protected static void updateShapeAndWriteBarrier(RubyDynamicObject value, int depth,
+            // Recursive inlining is not supported.
             @Cached(inline = false) WriteBarrierNode writeBarrierNode) {
         writeBarrierNode.executeCached(value, depth);
     }
@@ -110,8 +113,4 @@ protected static boolean isFinalizer(Object object) {
         return object instanceof FinalizerReference || object instanceof DataObjectFinalizerReference;
     }
 
-    protected static ShareObjectNode createShareObjectNode(int depth) {
-        return ShareObjectNodeGen.create(depth + 1);
-    }
-
 }