Complete refactoring of execution strategy to utilize Truffle DSL

This is a major rewrite of the Truffle-based execution system. Instead of relying on a general MessageNode, we need to introduce Unary, Binary, and Ternary nodes to use the Truffle DSL specialization features properly. For variable arguments, we still keep the KeywordMessage nodes around. However, the specific node types are needed to have a specialization down to the argument level of execution methods of a node. For instance, an addition needs to get the receiver and the argument evaluated properly. That's not supported by the DSL otherwise.

The NodeFactory should now be used for all 'higher-level'/'higher-complexity' node creations. (Refactoring needs to be completed still)

#if* and #while* related nodes have be split into classes for each selector.

Primitives are rewritten so that each primitive node class represents one operation (i.e., selector) and implementers all variants for all types.
Not yet clear is whether this is going to work well for primitives. Especially since we still want to enable classes to override primitives in subclasses, and since we need to handle polymorphism in a way that works. Also need to avoid primitives becoming polymorphic sends when it is not necessary!

TODO:
 * Cloning for inlining needs to be implemented
 * Move all 'complex' node creation stuff into NodeFactory
 * Primitives can be further optimized by using primitive types, avoid boxing, using ExactMath, etc.
 * verify polymorphism works properly with new Primitive design

[TODO-REPORT: give an overview of the final node type hierarchy, and the transitions between optimization states]

Signed-off-by: Stefan Marr <git@stefan-marr.de>

Author: smarr

src/som/compiler/Parser.java

@@ -63,15 +63,20 @@
 import java.util.List;
 
 import som.compiler.SourcecodeCompiler.Source;
+import som.interpreter.nodes.AbstractMessageNode;
 import som.interpreter.nodes.ArgumentEvaluationNode;
+import som.interpreter.nodes.BinaryMessageNode;
+import som.interpreter.nodes.BinaryMessageNodeFactory;
 import som.interpreter.nodes.ExpressionNode;
 import som.interpreter.nodes.FieldNode.FieldReadNode;
 import som.interpreter.nodes.FieldNode.FieldWriteNode;
 import som.interpreter.nodes.GlobalNode.GlobalReadNode;
-import som.interpreter.nodes.MessageNode;
-import som.interpreter.nodes.MessageNodeFactory;
+import som.interpreter.nodes.KeywordMessageNodeFactory;
 import som.interpreter.nodes.ReturnNonLocalNode;
 import som.interpreter.nodes.SequenceNode;
+import som.interpreter.nodes.TernaryMessageNodeFactory;
+import som.interpreter.nodes.UnaryMessageNode;
+import som.interpreter.nodes.UnaryMessageNodeFactory;
 import som.interpreter.nodes.VariableNode.SelfReadNode;
 import som.interpreter.nodes.VariableNode.SuperReadNode;
 import som.interpreter.nodes.VariableNode.VariableReadNode;
@@ -527,9 +532,9 @@ private String variable() {
     return identifier();
   }
 
-  private MessageNode messages(final MethodGenerationContext mgenc,
+  private AbstractMessageNode messages(final MethodGenerationContext mgenc,
       final ExpressionNode receiver) {
-    MessageNode msg;
+    AbstractMessageNode msg;
     if (sym == Identifier) {
       msg = unaryMessage(receiver);
 
@@ -560,24 +565,21 @@ private MessageNode messages(final MethodGenerationContext mgenc,
     return msg;
   }
 
-  private MessageNode unaryMessage(final ExpressionNode receiver) {
+  private UnaryMessageNode unaryMessage(final ExpressionNode receiver) {
     SourceCoordinate coord = getCoordinate();
     SSymbol selector = unarySelector();
-    MessageNode msg = MessageNodeFactory.create(selector, universe, receiver, new ArgumentEvaluationNode());
+    UnaryMessageNode msg = UnaryMessageNodeFactory.create(selector, universe, receiver);
     assignSource(msg, coord);
     return msg;
   }
 
-  private MessageNode binaryMessage(final MethodGenerationContext mgenc,
+  private BinaryMessageNode binaryMessage(final MethodGenerationContext mgenc,
       final ExpressionNode receiver) {
     SourceCoordinate coord = getCoordinate();
     SSymbol msg = binarySelector();
-    ExpressionNode operand   = binaryOperand(mgenc);
-
-    ArgumentEvaluationNode args =
-        new ArgumentEvaluationNode(new ExpressionNode[] {operand});
+    ExpressionNode operand = binaryOperand(mgenc);
 
-    MessageNode msgNode = MessageNodeFactory.create(msg, universe, receiver, args);
+    BinaryMessageNode msgNode = BinaryMessageNodeFactory.create(msg, universe, receiver, operand);
     assignSource(msgNode, coord);
     return msgNode;
   }
@@ -594,7 +596,7 @@ private ExpressionNode binaryOperand(final MethodGenerationContext mgenc) {
     return operand;
   }
 
-  private MessageNode keywordMessage(final MethodGenerationContext mgenc,
+  private AbstractMessageNode keywordMessage(final MethodGenerationContext mgenc,
       final ExpressionNode receiver) {
     SourceCoordinate coord = getCoordinate();
     List<ExpressionNode> arguments = new ArrayList<ExpressionNode>();
@@ -608,10 +610,18 @@ private MessageNode keywordMessage(final MethodGenerationContext mgenc,
 
     SSymbol msg = universe.symbolFor(kw.toString());
 
-    ArgumentEvaluationNode args =
-        new ArgumentEvaluationNode(arguments.toArray(new ExpressionNode[0]));
+    AbstractMessageNode msgNode;
+    int numArgs = msg.getNumberOfSignatureArguments();
+    if (numArgs == 2) {
+      msgNode = BinaryMessageNodeFactory.create(msg, universe, receiver, arguments.get(0));
+    } else if (numArgs == 3) {
+      msgNode = TernaryMessageNodeFactory.create(msg, universe, receiver, arguments.get(0), arguments.get(1));
+    } else {
+      ArgumentEvaluationNode args =
+          new ArgumentEvaluationNode(arguments.toArray(new ExpressionNode[0]));
+      msgNode = KeywordMessageNodeFactory.create(msg, universe, receiver, args);
+    }
 
-    MessageNode msgNode = MessageNodeFactory.create(msg, universe, receiver, args);
     assignSource(msgNode, coord);
     return msgNode;
   }

src/som/interpreter/Method.java

@@ -69,7 +69,7 @@ protected static SAbstractObject messageSendExecution(final FrameOnStackMarker m
     do {
       restart = false;
       try {
-        result = expr.executeGeneric(frame);
+        result = (SAbstractObject) expr.executeGeneric(frame); // TODO: work out whether there is another way than this cast!
       } catch (ReturnException e) {
         if (!e.reachedTarget(marker)) {
           marker.frameNoLongerOnStack();

src/som/interpreter/Primitive.java

@@ -1,7 +1,6 @@
 package som.interpreter;
 
 import som.interpreter.nodes.ExpressionNode;
-import som.interpreter.nodes.PrimitiveNode;
 import som.vmobjects.SAbstractObject;
 
 import com.oracle.truffle.api.frame.FrameDescriptor;
@@ -12,7 +11,7 @@
 
 public class Primitive extends Invokable {
 
-  public Primitive(final PrimitiveNode primitive,
+  public Primitive(final ExpressionNode primitive,
       final FrameSlot selfSlot, final FrameSlot[] arugmentSlots,
       final FrameDescriptor frameDescriptor) {
     super(primitive, selfSlot, arugmentSlots, frameDescriptor);
@@ -43,7 +42,7 @@ protected void initializeFrame(final VirtualFrame frame) {
   public SAbstractObject executeInlined(final VirtualFrame frame,
       final ExpressionNode exp) {
     initializeFrame(frame);
-    return exp.executeGeneric(frame);
+    return (SAbstractObject) exp.executeGeneric(frame); // TODO: Work out whether there is another way than this cast!
   }
 
   @Override

src/som/interpreter/nodes/AbstractMessageNode.java

@@ -7,15 +7,8 @@
 import som.vmobjects.SMethod;
 import som.vmobjects.SSymbol;
 
-import com.oracle.truffle.api.dsl.NodeChild;
-import com.oracle.truffle.api.dsl.NodeChildren;
 import com.oracle.truffle.api.frame.VirtualFrame;
 
-
-@NodeChildren({
-  @NodeChild(value = "receiver",  type = ExpressionNode.class),
-  @NodeChild(value = "arguments", type = ArgumentEvaluationNode.class)
-})
 public abstract class AbstractMessageNode extends ExpressionNode {
 
   protected final SSymbol  selector;
@@ -26,14 +19,10 @@ public AbstractMessageNode(final SSymbol selector, final Universe universe) {
     this.universe = universe;
   }
 
-  public AbstractMessageNode(final MessageNode node) {
+  public AbstractMessageNode(final AbstractMessageNode node) {
     this(node.selector, node.universe);
   }
 
-  // TODO: document this getter idiom
-  public abstract ExpressionNode getReceiver();
-  public abstract ArgumentEvaluationNode getArguments();
-
   protected SClass classOfReceiver(final SAbstractObject rcvr, final ExpressionNode receiver) {
     SClass rcvrClass = rcvr.getSOMClass(universe);
 
@@ -44,17 +33,18 @@ protected SClass classOfReceiver(final SAbstractObject rcvr, final ExpressionNod
     return rcvrClass;
   }
 
-  protected boolean hasOneArgument(final Object receiver, final Object arguments) {
-    return (arguments != null && ((SAbstractObject[]) arguments).length == 1);
-  }
-
-  protected boolean hasTwoArguments(final Object receiver, final Object arguments) {
-    return (arguments != null && ((SAbstractObject[]) arguments).length == 2);
+  protected boolean isBooleanReceiver(final SAbstractObject receiver) {
+    return receiver == universe.trueObject || receiver == universe.falseObject;
   }
 
-  protected boolean isBooleanReceiver(final SAbstractObject receiver) {
-    SClass rcvrClass = classOfReceiver(receiver, getReceiver());
-    return rcvrClass == universe.trueClass || rcvrClass == universe.falseClass;
+  /**
+   * Guard for system primitives.
+   * TODO: make sure system primitives do not trigger on any other kind of object
+   * @param receiver
+   * @return
+   */
+  protected boolean receiverIsSystemObject(final SAbstractObject receiver) {
+    return receiver == universe.systemObject;
   }
 
   protected SAbstractObject doFullSend(final VirtualFrame frame, final SAbstractObject rcvr,
@@ -68,4 +58,8 @@ protected SAbstractObject doFullSend(final VirtualFrame frame, final SAbstractOb
       return rcvr.sendDoesNotUnderstand(selector, args, universe, frame.pack());
     }
   }
+
+  protected static final SAbstractObject[] noArgs = new SAbstractObject[0];
+
+  public static final int PriorityMonomorphicCase = 9999;
 }

src/som/interpreter/nodes/ArgumentEvaluationNode.java

@@ -31,7 +31,7 @@ public SAbstractObject[] doArray(final VirtualFrame frame) {
     SAbstractObject[] result = new SAbstractObject[arguments.length];
 
     for (int i = 0; i < arguments.length; i++) {
-      result[i] = arguments[i].executeGeneric(frame);
+      result[i] = (SAbstractObject) arguments[i].executeGeneric(frame); // TODO: Work out whether there is another way than this cast!
     }
 
     return result;

src/som/interpreter/nodes/BinaryMessageNode.java

@@ -0,0 +1,64 @@
+package som.interpreter.nodes;
+
+import som.interpreter.nodes.messages.BinaryMonomorphicNode;
+import som.vm.Universe;
+import som.vmobjects.SAbstractObject;
+import som.vmobjects.SClass;
+import som.vmobjects.SMethod;
+import som.vmobjects.SSymbol;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.NodeChildren;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+
+
+@NodeChildren({
+  @NodeChild(value = "receiver", type = ExpressionNode.class),
+  @NodeChild(value = "argument", type = ExpressionNode.class)
+})
+public abstract class BinaryMessageNode extends AbstractMessageNode {
+
+  public BinaryMessageNode(final SSymbol selector, final Universe universe) {
+    super(selector, universe);
+  }
+
+  public BinaryMessageNode(final BinaryMessageNode node) {
+    this(node.selector, node.universe);
+  }
+
+  // TODO: document this getter idiom
+  public abstract ExpressionNode getReceiver();
+  public abstract ExpressionNode getArgument();
+  public abstract Object executeEvaluated(final VirtualFrame frame, final Object receiver, Object argument);
+
+  // TODO: want to use @Generic here!
+  @Specialization
+  public Object doGeneric(final VirtualFrame frame,
+      final Object rcvr,
+      final Object arg) {
+    CompilerDirectives.transferToInterpreter();
+
+    SAbstractObject receiver = (SAbstractObject) rcvr;
+    SAbstractObject argument = (SAbstractObject) arg;
+
+    SClass rcvrClass = classOfReceiver(receiver, getReceiver());
+    SMethod invokable = rcvrClass.lookupInvokable(selector);
+
+    if (invokable != null) {
+      BinaryMonomorphicNode node = NodeFactory.createBinaryMonomorphicNode(selector, universe, rcvrClass, invokable, getReceiver(), getReceiver());
+      // BinaryMonomorphicNodeFactory.create(selector, universe, rcvrClass, invokable, getReceiver(), getArgument());
+      return replace(node, "Be optimisitic and do a monomorphic lookup cache, or a primitive inline.").executeEvaluated(frame, receiver, argument);
+    } else {
+      SAbstractObject[] args = new SAbstractObject[] {argument};
+      return doFullSend(frame, receiver, args, rcvrClass);
+    }
+  }
+
+  @Override
+  public ExpressionNode cloneForInlining() {
+    // TODO: test whether this is problematic
+    return (ExpressionNode) this.copy();
+  }
+}

src/som/interpreter/nodes/FieldNode.java

@@ -80,8 +80,8 @@ public FieldWriteNode(final int fieldIndex,
     @Override
     public SAbstractObject executeGeneric(final VirtualFrame frame) {
       MaterializedFrame ctx = determineContext(frame.materialize());
-      SAbstractObject value = exp.executeGeneric(frame);
-      SObject self  = getSelfFromMaterialized(ctx);
+      SAbstractObject value = (SAbstractObject) exp.executeGeneric(frame);  // TODO: Work out whether there is another way than this cast!
+      SObject self = getSelfFromMaterialized(ctx);
 
       self.setField(fieldIndex, value);
       return value;

src/som/interpreter/nodes/KeywordMessageNode.java

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2013 Stefan Marr, stefan.marr@vub.ac.be
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package som.interpreter.nodes;
+
+import som.interpreter.nodes.messages.KeywordMonomorphicNode;
+import som.vm.Universe;
+import som.vmobjects.SAbstractObject;
+import som.vmobjects.SClass;
+import som.vmobjects.SMethod;
+import som.vmobjects.SSymbol;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.NodeChildren;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+
+@NodeChildren({
+  @NodeChild(value = "receiver",  type = ExpressionNode.class),
+  @NodeChild(value = "arguments", type = ArgumentEvaluationNode.class)
+})
+public abstract class KeywordMessageNode extends AbstractMessageNode {
+
+  public KeywordMessageNode(final SSymbol selector, final Universe universe) {
+    super(selector, universe);
+  }
+
+  public KeywordMessageNode(final KeywordMessageNode node) {
+    this(node.selector, node.universe);
+  }
+
+  public abstract ExpressionNode getReceiver();
+  public abstract ArgumentEvaluationNode getArguments();
+  public abstract Object executeEvaluated(final VirtualFrame frame, final Object receiver, Object arguments);
+
+  // TODO: want to use @Generic here!
+  @Specialization
+  public Object doGeneric(final VirtualFrame frame, final Object rcvr,
+      final Object arguments) {
+    CompilerDirectives.transferToInterpreter();
+
+    SAbstractObject receiver = (SAbstractObject) rcvr;
+
+    SClass rcvrClass = classOfReceiver(receiver, getReceiver());
+    SMethod invokable = rcvrClass.lookupInvokable(selector);
+
+    if (invokable != null) {
+      KeywordMonomorphicNode node = NodeFactory.createKeywordMonomorphicNode(selector, universe, rcvrClass, invokable, getReceiver(), getArguments());
+      return replace(node, "Be optimisitic and do a monomorphic lookup cache, or a primitive inline.").
+          executeEvaluated(frame, receiver, arguments);
+    } else {
+      SAbstractObject[] args = (SAbstractObject[]) arguments;
+      return doFullSend(frame, receiver, args, rcvrClass);
+    }
+  }
+
+  @Override
+  public ExpressionNode cloneForInlining() {
+    // TODO: test whether this is problematic
+    return (ExpressionNode) this.copy();
+    //return NodeFactory.createKeywordMessageNode(selector, universe, getReceiver(), getArguments());
+  }
+}