First support for inlining

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

Author: smarr

src/som/compiler/MethodGenerationContext.java

@@ -115,7 +115,8 @@ public Method assemble(final Universe universe, final ExpressionNode expressions
 
     som.interpreter.nodes.Method truffleMethod =
         new som.interpreter.nodes.Method(expressions,
-            selfSlot, argSlots, localSlots, nonLocalReturnMarker, universe);
+            selfSlot, argSlots, localSlots, nonLocalReturnMarker, universe,
+            frameDescriptor);
 
     assignSourceSectionToMethod(expressions, truffleMethod);
 

src/som/interpreter/nodes/MessageNode.java

@@ -21,22 +21,26 @@
  */
 package som.interpreter.nodes;
 
-import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.NodeInfo;
-import com.oracle.truffle.api.nodes.NodeInfo.Kind;
-
 import som.interpreter.nodes.VariableNode.SuperReadNode;
 import som.vm.Universe;
 import som.vmobjects.Class;
 import som.vmobjects.Invokable;
 import som.vmobjects.Object;
 import som.vmobjects.Symbol;
 
+import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.FrameFactory;
+import com.oracle.truffle.api.nodes.InlinableCallSite;
+import com.oracle.truffle.api.nodes.InlinedCallSite;
+import com.oracle.truffle.api.nodes.Node;
+
+// TODO: I need to add a check that the invokable has not changed
+
 // @NodeChildren({
 //  @NodeChild(value = "receiver",  type = ExpressionNode.class),
 //  @NodeChild(value = "arguments", type = ExpressionNode[].class)})
-@NodeInfo(kind = Kind.UNINITIALIZED)
 public class MessageNode extends ExpressionNode {
 
   @Child    protected final ExpressionNode   receiver;
@@ -116,8 +120,10 @@ public Object executeGeneric(VirtualFrame frame) {
       CompilerDirectives.transferToInterpreter();
 
       // First let's rewrite this node
-      MonomorpicMessageNode mono = new MonomorpicMessageNode(receiver, arguments, selector, universe, rcvrClass, invokable);
-      this.replace(mono, "Let's assume it is a monomorphic send site.");
+      MonomorpicMessageNode mono = new MonomorpicMessageNode(receiver,
+          arguments, selector, universe, rcvrClass, invokable);
+
+      replace(mono, "Let's assume it is a monomorphic send site.");
 
       // Then execute the invokable, because it can exit this method with
       // control flow exceptions (non-local returns), which would leave node
@@ -128,23 +134,29 @@ public Object executeGeneric(VirtualFrame frame) {
     }
   }
 
-  @NodeInfo(kind = Kind.SPECIALIZED)
-  public static class MonomorpicMessageNode extends MessageNode {
+  public static class MonomorpicMessageNode extends MessageNode
+    implements InlinableCallSite {
 
     private final Class      rcvrClass;
     private final Invokable  invokable;
 
+    private int callCount;
+
     public MonomorpicMessageNode(final ExpressionNode receiver,
         final ExpressionNode[] arguments, final Symbol selector,
         final Universe universe, final Class rcvrClass,
         final Invokable invokable) {
       super(receiver, arguments, selector, universe);
       this.rcvrClass = rcvrClass;
       this.invokable = invokable;
+
+      callCount = 0;
     }
 
     @Override
     public Object executeGeneric(VirtualFrame frame) {
+      callCount++;
+
       // evaluate all the expressions: first determine receiver
       Object rcvr = receiver.executeGeneric(frame);
 
@@ -160,13 +172,134 @@ public Object executeGeneric(VirtualFrame frame) {
         // So, it might just be a polymorphic send site.
         PolymorpicMessageNode poly = new PolymorpicMessageNode(receiver,
             arguments, selector, universe, rcvrClass, invokable, currentRcvrClass);
-        this.replace(poly, "It is not a monomorpic send.");
+
+        replace(poly, "It is not a monomorpic send.");
         return doFullSend(frame, rcvr, args, currentRcvrClass);
       }
     }
+
+    @Override
+    public int getCallCount() {
+      return callCount;
+    }
+
+    @Override
+    public void resetCallCount() {
+      callCount = 0;
+    }
+
+    @Override
+    public CallTarget getCallTarget() {
+      return invokable.getCallTarget();
+    }
+
+    @Override
+    public Node getInlineTree() {
+      if (invokable.isPrimitive()) {
+        return this;
+      } else {
+        return invokable.getTruffleInvokable();
+      }
+    }
+
+    private InlinedMonomorphicMessageNode newInlinedNode(
+        final FrameFactory frameFactory,
+        final Method method) {
+      return new InlinedMonomorphicMessageNode(receiver, arguments, selector,
+          universe, rcvrClass, invokable, method.methodCloneForInlining(),
+          frameFactory, method);
+    }
+
+    @Override
+    public boolean inline(FrameFactory factory) {
+      Method method = invokable.getTruffleInvokable();
+      if (method == null) {
+        return false;
+      }
+
+      InlinedMonomorphicMessageNode inlinedNode = newInlinedNode(factory,
+          method);
+
+      replace(inlinedNode, "Node got inlined");
+
+      return true;
+    }
+  }
+
+  public static class InlinedMonomorphicMessageNode extends MessageNode
+    implements InlinedCallSite {
+
+    private final Class      rcvrClass;
+    private final Invokable  invokable;
+
+    @Child private final ExpressionNode methodBody;
+
+    private final FrameFactory frameFactory;
+    private final Method inlinedMethod;
+
+    public InlinedMonomorphicMessageNode(final ExpressionNode receiver,
+        final ExpressionNode[] arguments, final Symbol selector,
+        final Universe universe, final Class rcvrClass,
+        final Invokable invokable, final ExpressionNode methodBody,
+        final FrameFactory frameFactory,
+        final Method inlinedMethod) {
+      super(receiver, arguments, selector, universe);
+      this.rcvrClass = rcvrClass;
+      this.invokable = invokable;
+
+      this.methodBody = adoptChild(methodBody);
+
+      this.frameFactory  = frameFactory;
+      this.inlinedMethod = inlinedMethod;
+    }
+
+    @Override
+    public Object executeGeneric(VirtualFrame frame) {
+      // evaluate all the expressions: first determine receiver
+      Object rcvr = receiver.executeGeneric(frame);
+
+      // then determine the arguments
+      Object[] args = determineArguments(frame);
+
+      Class currentRcvrClass = classOfReceiver(rcvr, receiver);
+
+      if (currentRcvrClass == rcvrClass) {
+        return executeInlined(frame, rcvr, args);
+      } else {
+        return generalizeNode(frame, rcvr, args, currentRcvrClass);
+      }
+    }
+
+    private Object executeInlined(final VirtualFrame caller, final Object rcvr,
+        final Object[] args) {
+      // CompilerDirectives.transferToInterpreter();
+      final VirtualFrame frame = frameFactory.create(
+          inlinedMethod.getFrameDescriptor(), caller.pack(),
+          new Arguments(rcvr, args));
+
+      final FrameOnStackMarker marker = Method.initializeFrame(inlinedMethod,
+          frame.materialize());
+
+      return Method.messageSendExecution(marker, frame, methodBody);
+    }
+
+    private Object generalizeNode(final VirtualFrame frame, final Object rcvr,
+        final Object[] args, final Class currentRcvrClass) {
+      CompilerDirectives.transferToInterpreter();
+      // So, it might just be a polymorphic send site.
+      PolymorpicMessageNode poly = new PolymorpicMessageNode(receiver,
+          arguments, selector, universe, rcvrClass, invokable, currentRcvrClass);
+
+      replace(poly, "It is not a monomorpic send.");
+      return doFullSend(frame, rcvr, args, currentRcvrClass);
+    }
+
+    @Override
+    public CallTarget getCallTarget() {
+      return invokable.getCallTarget();
+    }
   }
 
-  @NodeInfo(kind = Kind.SPECIALIZED)
   public static class PolymorpicMessageNode extends MessageNode {
     private static final int CACHE_SIZE = 8;
 
@@ -216,13 +349,13 @@ public Object executeGeneric(VirtualFrame frame) {
         CompilerDirectives.transferToInterpreter();
         // So, it might just be a megamorphic send site.
         MegamorphicMessageNode mega = new MegamorphicMessageNode(receiver, arguments, selector, universe);
-        this.replace(mega, "It is not a polymorpic send.");
+
+        replace(mega, "It is not a polymorpic send.");
         return doFullSend(frame, rcvr, args, currentRcvrClass);
       }
     }
   }
 
-  @NodeInfo(kind = Kind.GENERIC)
   public static class MegamorphicMessageNode extends MessageNode {
 
     public MegamorphicMessageNode(final ExpressionNode receiver,

src/som/interpreter/nodes/Method.java

@@ -25,6 +25,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.SourceSection;
+import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.frame.FrameSlotTypeException;
 import com.oracle.truffle.api.frame.MaterializedFrame;
@@ -43,22 +44,22 @@ public class Method extends RootNode {
   private final FrameSlot   nonLocalReturnMarker;
   private final Universe    universe;
 
-  //private final FrameDescriptor frameDescriptor;
+  private final FrameDescriptor frameDescriptor;
 
   public Method(final ExpressionNode expressions,
                 final FrameSlot selfSlot,
                 final FrameSlot[] argumentSlots,
                 final FrameSlot[] temporarySlots,
                 final FrameSlot nonLocalReturnMarker,
-                final Universe  universe) {
-                //, final FrameDescriptor frameDescriptor) {
+                final Universe  universe,
+                final FrameDescriptor frameDescriptor) {
     this.expressionOrSequence = adoptChild(expressions);
     this.selfSlot        = selfSlot;
     this.argumentSlots   = argumentSlots;
     this.temporarySlots  = temporarySlots;
     this.nonLocalReturnMarker = nonLocalReturnMarker;
     this.universe        = universe;
-    //this.frameDescriptor = frameDescriptor;
+    this.frameDescriptor = frameDescriptor;
   }
 
   @Override
@@ -67,10 +68,10 @@ public Object execute(VirtualFrame frame) {
     return messageSendExecution(marker, frame, expressionOrSequence);
   }
 
-  private static Object messageSendExecution(final FrameOnStackMarker marker,
+  public static som.vmobjects.Object messageSendExecution(final FrameOnStackMarker marker,
       final VirtualFrame frame,
       final ExpressionNode expr) {
-    Object  result;
+    som.vmobjects.Object  result;
     boolean restart;
 
     do {
@@ -95,7 +96,7 @@ private static Object messageSendExecution(final FrameOnStackMarker marker,
   }
 
   @ExplodeLoop
-  private static FrameOnStackMarker initializeFrame(final Method method,
+  public static FrameOnStackMarker initializeFrame(final Method method,
       final MaterializedFrame frame) {
     try {
       frame.setObject(method.selfSlot, frame.getArguments(Arguments.class).self);
@@ -125,4 +126,12 @@ public String toString() {
     final String location = getSourceSection().toString();
     return "Method " + name + ":" + location + "@" + Integer.toHexString(hashCode());
   }
+
+  public FrameDescriptor getFrameDescriptor() {
+    return frameDescriptor;
+  }
+
+  public ExpressionNode methodCloneForInlining() {
+    return expressionOrSequence.cloneForInlining();
+  }
 }