Make dispatch chain walk non-recursive

Signed-off-by: Stefan Marr <[email protected]>

Author: smarr

src/trufflesom/interpreter/nodes/MessageSendNode.java

@@ -1,26 +1,33 @@
 package trufflesom.interpreter.nodes;
 
-import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.InvalidAssumptionException;
 import com.oracle.truffle.api.nodes.NodeCost;
 import com.oracle.truffle.api.source.SourceSection;
 
 import bd.primitives.Specializer;
 import bd.primitives.nodes.PreevaluatedExpression;
 import bd.tools.nodes.Invocation;
-import trufflesom.interpreter.TruffleCompiler;
+import trufflesom.interpreter.Types;
 import trufflesom.interpreter.nodes.dispatch.AbstractDispatchNode;
-import trufflesom.interpreter.nodes.dispatch.DispatchChain.Cost;
+import trufflesom.interpreter.nodes.dispatch.AbstractDispatchNode.CachedDispatchNode;
+import trufflesom.interpreter.nodes.dispatch.AbstractDispatchNode.CachedExprNode;
+import trufflesom.interpreter.nodes.dispatch.AbstractDispatchNode.GuardedDispatchNode;
+import trufflesom.interpreter.nodes.dispatch.CachedDnuNode;
+import trufflesom.interpreter.nodes.dispatch.DispatchGuard;
 import trufflesom.interpreter.nodes.dispatch.GenericDispatchNode;
-import trufflesom.interpreter.nodes.dispatch.UninitializedDispatchNode;
 import trufflesom.primitives.Primitives;
 import trufflesom.vm.NotYetImplementedException;
 import trufflesom.vm.Universe;
 import trufflesom.vmobjects.SClass;
 import trufflesom.vmobjects.SInvokable;
+import trufflesom.vmobjects.SObject;
 import trufflesom.vmobjects.SSymbol;
 
 
@@ -32,8 +39,7 @@ public static ExpressionNode create(final SSymbol selector,
     Specializer<Universe, ExpressionNode, SSymbol> specializer =
         prims.getParserSpecializer(selector, arguments);
     if (specializer == null) {
-      return new UninitializedMessageSendNode(
-          selector, arguments, universe).initialize(source);
+      return new GenericMessageSendNode(selector, arguments, universe).initialize(source);
     }
 
     ExpressionNode newNode = specializer.create(null, arguments, source, universe);
@@ -44,14 +50,14 @@ public static ExpressionNode create(final SSymbol selector,
 
   public static AbstractMessageSendNode createForPerformNodes(final SSymbol selector,
       final SourceSection source, final Universe universe) {
-    return new UninitializedMessageSendNode(selector, NO_ARGS, universe).initialize(source);
+    return new GenericMessageSendNode(selector, NO_ARGS, universe).initialize(source);
   }
 
   public static GenericMessageSendNode createGeneric(final SSymbol selector,
       final ExpressionNode[] argumentNodes, final SourceSection source,
       final Universe universe) {
-    return new GenericMessageSendNode(selector, argumentNodes,
-        new UninitializedDispatchNode(selector, universe)).initialize(source);
+    return new GenericMessageSendNode(
+        selector, argumentNodes, universe, true).initialize(source);
   }
 
   public static AbstractMessageSendNode createSuperSend(final SClass superClass,
@@ -102,109 +108,171 @@ private Object[] evaluateArguments(final VirtualFrame frame) {
     public abstract int getNumberOfArguments();
   }
 
-  public static final class UninitializedMessageSendNode extends AbstractMessageSendNode {
+  public static final class GenericMessageSendNode
+      extends AbstractMessageSendNode {
+
+    private final SSymbol  selector;
+    private final Universe universe;
+
+    private final int numberOfSignatureArguments;
+
+    @CompilationFinal private boolean triedEager;
 
-    protected final SSymbol  selector;
-    protected final Universe universe;
+    @Child private GuardedDispatchNode dispatchCache;
 
-    protected UninitializedMessageSendNode(final SSymbol selector,
-        final ExpressionNode[] arguments, final Universe universe) {
+    private GenericMessageSendNode(final SSymbol selector, final ExpressionNode[] arguments,
+        final Universe universe, final boolean triedEager) {
       super(arguments);
       this.selector = selector;
       this.universe = universe;
+      this.triedEager = triedEager;
+      this.numberOfSignatureArguments = selector.getNumberOfSignatureArguments();
     }
 
-    @Override
-    public String toString() {
-      return getClass().getSimpleName() + "(" + selector.getString() + ")";
+    private GenericMessageSendNode(final SSymbol selector, final ExpressionNode[] arguments,
+        final Universe universe) {
+      this(selector, arguments, universe, false);
     }
 
     @Override
-    public Object doPreEvaluated(final VirtualFrame frame, final Object[] arguments) {
-      return specialize(arguments).doPreEvaluated(frame, arguments);
-    }
-
-    private PreevaluatedExpression specialize(final Object[] arguments) {
-      TruffleCompiler.transferToInterpreterAndInvalidate("Specialize Message Node");
-
-      // We treat super sends separately for simplicity, might not be the
-      // optimal solution, especially in cases were the knowledge of the
-      // receiver class also allows us to do more specific things, but for the
-      // moment we will leave it at this.
-      // TODO: revisit, and also do more specific optimizations for super sends.
-
-      Primitives prims = universe.getPrimitives();
-
-      Specializer<Universe, ExpressionNode, SSymbol> specializer =
-          prims.getEagerSpecializer(selector, arguments, argumentNodes);
-
-      if (specializer != null) {
-        PreevaluatedExpression newNode =
-            (PreevaluatedExpression) specializer.create(arguments, argumentNodes,
-                sourceSection, universe);
+    @ExplodeLoop
+    public Object doPreEvaluated(final VirtualFrame frame,
+        final Object[] arguments) {
 
-        return (PreevaluatedExpression) replace((ExpressionNode) newNode);
+      GuardedDispatchNode cache = dispatchCache;
+
+      Object rcvr = arguments[0];
+
+      while (cache != null) {
+        try {
+          if (cache.entryMatches(rcvr)) {
+            return cache.doPreEvaluated(frame, arguments);
+          }
+        } catch (InvalidAssumptionException e) {
+          // Remove invalid node from dispatch chain
+          CompilerDirectives.transferToInterpreterAndInvalidate();
+          if (cache.getParent() == this) {
+            if (cache.next == null) {
+              dispatchCache = null;
+              cache = null;
+            } else {
+              dispatchCache = insert(cache.next);
+              cache = cache.next;
+            }
+          } else {
+            GuardedDispatchNode parent = (GuardedDispatchNode) cache.getParent();
+            if (cache.next == null) {
+              parent.next = null;
+              cache = null;
+            } else {
+              parent.next = insert(cache.next);
+              cache = cache.next;
+            }
+          }
+          continue;
+        }
+        // cache guard
+        // --> apply cache
+        cache = cache.next;
       }
 
-      return makeGenericSend();
-    }
+      CompilerDirectives.transferToInterpreterAndInvalidate();
 
-    private GenericMessageSendNode makeGenericSend() {
-      GenericMessageSendNode send = new GenericMessageSendNode(selector, argumentNodes,
-          new UninitializedDispatchNode(selector, universe)).initialize(sourceSection);
-      return replace(send);
+      return specialize(arguments).doPreEvaluated(frame, arguments);
     }
 
     @Override
-    public SSymbol getInvocationIdentifier() {
-      return selector;
+    public String toString() {
+      return "GMsgSend(" + selector.getString() + ")";
     }
 
     @Override
-    public int getNumberOfArguments() {
-      return selector.getNumberOfSignatureArguments();
+    public NodeCost getCost() {
+      return NodeCost.NONE;
     }
-  }
 
-  // TODO: currently, we do not only specialize the given stuff above, but also what has been
-  // classified as 'value' sends in the OMOP branch. Is that a problem?
+    private PreevaluatedExpression specialize(final Object[] arguments) {
+      if (!triedEager) {
+        triedEager = true;
+        PreevaluatedExpression eager = attemptEagerSpecialization(arguments);
+        if (eager != null) {
+          return eager;
+        }
+      }
 
-  public static final class GenericMessageSendNode
-      extends AbstractMessageSendNode {
+      final GuardedDispatchNode first = dispatchCache;
+      GuardedDispatchNode cache = first;
+      int cacheSize = 0;
+      while (cache != null) {
+        cache = cache.next;
+        cacheSize += 1;
+      }
 
-    private final SSymbol selector;
-    private final int     numberOfSignatureArguments;
+      Object rcvr = arguments[0];
+      assert rcvr != null;
 
-    @Child private AbstractDispatchNode dispatchNode;
+      if (rcvr instanceof SObject) {
+        SObject r = (SObject) rcvr;
+        if (r.updateLayoutToMatchClass() && first != null) {
+          // if the dispatchCache is null, we end up here, so continue directly below instead
+          // otherwise, let's retry the cache!
+          return this;
+        }
+      }
 
-    private GenericMessageSendNode(final SSymbol selector, final ExpressionNode[] arguments,
-        final AbstractDispatchNode dispatchNode) {
-      super(arguments);
-      this.selector = selector;
-      this.dispatchNode = dispatchNode;
-      this.numberOfSignatureArguments = selector.getNumberOfSignatureArguments();
-    }
+      if (cacheSize < AbstractDispatchNode.INLINE_CACHE_SIZE) {
+        SClass rcvrClass = Types.getClassOf(rcvr, universe);
+        SInvokable method = rcvrClass.lookupInvokable(selector);
+        CallTarget callTarget = null;
+        PreevaluatedExpression expr = null;
+        if (method != null) {
+          if (method.isTrivial()) {
+            expr = method.copyTrivialNode();
+            assert expr != null;
+          } else {
+            callTarget = method.getCallTarget();
+          }
+        }
+
+        DispatchGuard guard = DispatchGuard.create(rcvr);
+
+        GuardedDispatchNode node;
+        if (expr != null) {
+          node = new CachedExprNode(guard, expr);
+        } else if (method != null) {
+          node = new CachedDispatchNode(guard, callTarget);
+        } else {
+          node = new CachedDnuNode(rcvrClass, guard, selector);
+        }
+
+        if (first != null) {
+          node.next = node.insertHere(first);
+        }
+        dispatchCache = insert(node);
+        return node;
+      }
 
-    @Override
-    public Object doPreEvaluated(final VirtualFrame frame,
-        final Object[] arguments) {
-      return dispatchNode.executeDispatch(frame, arguments);
+      // the chain is longer than the maximum defined by INLINE_CACHE_SIZE and
+      // thus, this callsite is considered to be megaprophic, and we generalize it.
+      GenericDispatchNode generic = new GenericDispatchNode(selector, universe);
+      dispatchCache = insert(generic);
+      return generic;
     }
 
-    public void replaceDispatchListHead(
-        final GenericDispatchNode replacement) {
-      CompilerAsserts.neverPartOfCompilation();
-      dispatchNode.replace(replacement);
-    }
+    private PreevaluatedExpression attemptEagerSpecialization(final Object[] arguments) {
+      Primitives prims = universe.getPrimitives();
 
-    @Override
-    public String toString() {
-      return "GMsgSend(" + selector.getString() + ")";
-    }
+      Specializer<Universe, ExpressionNode, SSymbol> specializer =
+          prims.getEagerSpecializer(selector, arguments, argumentNodes);
 
-    @Override
-    public NodeCost getCost() {
-      return Cost.getCost(dispatchNode);
+      if (specializer != null) {
+        PreevaluatedExpression newNode =
+            (PreevaluatedExpression) specializer.create(arguments, argumentNodes,
+                sourceSection, universe);
+
+        return (PreevaluatedExpression) replace((ExpressionNode) newNode);
+      }
+      return null;
     }
 
     @Override

src/trufflesom/interpreter/nodes/dispatch/AbstractDispatchNode.java

@@ -4,32 +4,66 @@
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.DirectCallNode;
+import com.oracle.truffle.api.nodes.InvalidAssumptionException;
 import com.oracle.truffle.api.nodes.Node;
 
+import bd.primitives.nodes.PreevaluatedExpression;
 
-public abstract class AbstractDispatchNode extends Node implements DispatchChain {
+
+public abstract class AbstractDispatchNode extends Node implements PreevaluatedExpression {
   public static final int INLINE_CACHE_SIZE = 6;
 
-  public abstract Object executeDispatch(VirtualFrame frame, Object[] arguments);
+  @Override
+  public abstract Object doPreEvaluated(VirtualFrame frame, Object[] args);
+
+  public abstract boolean entryMatches(Object rcvr) throws InvalidAssumptionException;
+
+  public abstract static class GuardedDispatchNode extends AbstractDispatchNode {
+    private final DispatchGuard guard;
+
+    @Child public GuardedDispatchNode next;
+
+    protected GuardedDispatchNode(final DispatchGuard guard) {
+      this.guard = guard;
+    }
 
-  public abstract static class AbstractCachedDispatchNode
-      extends AbstractDispatchNode {
+    @Override
+    public boolean entryMatches(final Object rcvr) throws InvalidAssumptionException {
+      return guard.entryMatches(rcvr);
+    }
+
+    public final <T extends Node> T insertHere(final T newChild) {
+      return super.insert(newChild);
+    }
+  }
+
+  public static final class CachedDispatchNode extends GuardedDispatchNode {
+
+    @Child protected DirectCallNode cachedMethod;
+
+    public CachedDispatchNode(final DispatchGuard guard, final CallTarget callTarget) {
+      super(guard);
+      cachedMethod = insert(Truffle.getRuntime().createDirectCallNode(callTarget));
+    }
+
+    @Override
+    public Object doPreEvaluated(final VirtualFrame frame, final Object[] arguments) {
+      return cachedMethod.call(arguments);
+    }
+  }
 
-    @Child protected DirectCallNode       cachedMethod;
-    @Child protected AbstractDispatchNode nextInCache;
+  public static final class CachedExprNode extends GuardedDispatchNode {
 
-    public AbstractCachedDispatchNode(final CallTarget methodCallTarget,
-        final AbstractDispatchNode nextInCache) {
-      DirectCallNode cachedMethod =
-          Truffle.getRuntime().createDirectCallNode(methodCallTarget);
+    @Child protected PreevaluatedExpression expr;
 
-      this.cachedMethod = cachedMethod;
-      this.nextInCache = nextInCache;
+    public CachedExprNode(final DispatchGuard guard, final PreevaluatedExpression expr) {
+      super(guard);
+      this.expr = expr;
     }
 
     @Override
-    public final int lengthOfDispatchChain() {
-      return 1 + nextInCache.lengthOfDispatchChain();
+    public Object doPreEvaluated(final VirtualFrame frame, final Object[] arguments) {
+      return expr.doPreEvaluated(frame, arguments);
     }
   }
 }