Merge pull request #7 in G/truffle from ~JAROSLAV.TULACH_ORACLE.COM/truffle:FasterExecute to master

* commit '2433f9c6627870eea575477a51dd83c6a7b45774': (47 commits)
  Removing typo - additional l in the class name
  Using constant value fields rather than magical numbers
  Don't wrap the TruffleObject in case of single threaded execution. Assume people will manipulate them carefully on the right thread.
  Adding assumption checks per Christian's request
  Move Context support next to PolyglotEngine as package private classes
  Apply proper formatting
  Multiply by two
  Removing unneeded constructor
  Removing redundant modifiers and spaces
  Comparing speed of direct SLFunction execution with overhead of PolyglotEngine.Value.execute
  Simplify cached object access.
  Add missing transferToInterpreter.
  Hide debug events behind boundaries.
  Turn checkThread into assertion
  DirectValue allows us to skip executor == null check when execute method is being called
  Hide the communication with debugger behind an assumption. Let executionStarted be part of Truffle compilation - it is optimized now.
  argumentLength is no longer needed
  Use direct value for eval when there is no executor
  Use condition profile to track whether boxing is needed at all
  Use recursive version instead of loop of two
  ...

Author: Jaroslav Tulach

mx.truffle/suite.py

@@ -58,6 +58,7 @@
       "sourceDirs" : ["src"],
       "dependencies" : [
         "com.oracle.truffle.api.interop.java",
+        "com.oracle.truffle.api.profiles",
         "com.oracle.truffle.api.instrumentation",
       ],
       "checkstyle" : "com.oracle.truffle.api",
@@ -346,10 +347,12 @@
       "dependencies" : [
         "com.oracle.truffle.tck",
         "com.oracle.truffle.sl",
+        "mx:JMH",
       ],
       "checkstyle" : "com.oracle.truffle.sl",
       "javaCompliance" : "1.7",
       "workingSets" : "Truffle,SimpleLanguage,Test",
+      "annotationProcessors" : ["mx:JMH"],
       "license" : "UPL",
     },
    },
@@ -422,6 +425,10 @@
         "com.oracle.truffle.sl",
         "com.oracle.truffle.sl.test"
       ],
+      "exclude" : [
+        "mx:JUNIT",
+        "mx:JMH"
+      ],
       "distDependencies" : [
           "TRUFFLE_API",
           "TRUFFLE_TCK",

truffle/com.oracle.truffle.api.debug/src/com/oracle/truffle/api/debug/Debugger.java

@@ -24,14 +24,13 @@
  */
 package com.oracle.truffle.api.debug;
 
-import java.io.Closeable;
+import com.oracle.truffle.api.Assumption;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.Callable;
 
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -88,6 +87,7 @@ public final class Debugger {
 
     private static final SourceSectionFilter CALL_FILTER = SourceSectionFilter.newBuilder().tagIs(CallTag.class).build();
     private static final SourceSectionFilter HALT_FILTER = SourceSectionFilter.newBuilder().tagIs(StatementTag.class).build();
+    private static final Assumption NO_DEBUGGER = Truffle.getRuntime().createAssumption("No debugger assumption");
 
     /** Counter for externally requested step actions. */
     private static int nextActionID = 0;
@@ -126,7 +126,7 @@ public Debugger create(PolyglotEngine engine, Instrumenter instrumenter) {
         }
     };
 
-    private static Debugger find(PolyglotEngine engine, boolean create) {
+    static Debugger find(PolyglotEngine engine, boolean create) {
         PolyglotEngine.Instrument instrument = engine.getInstruments().get(DebuggerInstrument.ID);
         if (instrument == null) {
             throw new IllegalStateException();
@@ -151,6 +151,7 @@ private static Debugger find(PolyglotEngine engine, boolean create) {
         this.engine = engine;
         this.instrumenter = instrumenter;
         this.breakpoints = new BreakpointFactory(instrumenter, breakpointCallback, warningLog);
+        NO_DEBUGGER.invalidate();
     }
 
     interface BreakpointCallback {
@@ -872,7 +873,7 @@ public FrameInstance visitFrame(FrameInstance frameInstance) {
             try {
                 // Pass control to the debug client with current execution suspended
                 SuspendedEvent event = new SuspendedEvent(Debugger.this, haltedEventContext.getInstrumentedNode(), haltedFrame, contextStack, recentWarnings);
-                AccessorDebug.engineAccess().dispatchEvent(engine, event);
+                AccessorDebug.engineAccess().dispatchEvent(engine, event, Accessor.EngineSupport.SUSPENDED_EVENT);
                 if (event.isKillPrepared()) {
                     trace("KILL");
                     throw new KillException();
@@ -938,7 +939,7 @@ public Void visitFrame(FrameInstance frameInstance) {
         return count[0] == 0 ? 0 : count[0] + 1;
     }
 
-    private void executionStarted(int depth, Source source) {
+    void executionStarted(int depth, Source source) {
         Source execSource = source;
         if (execSource == null) {
             execSource = lastSource;
@@ -993,32 +994,32 @@ static Accessor.EngineSupport engineAccess() {
         }
 
         @Override
-        protected Closeable executionStart(Object vm, final int currentDepth, final boolean initializeDebugger, final Source s) {
-            final PolyglotEngine engine = (PolyglotEngine) vm;
-            final Debugger[] debugger = {find(engine, initializeDebugger)};
-            if (debugger[0] != null) {
-                debugger[0].executionStarted(currentDepth, s);
-                engineAccess().dispatchEvent(engine, new ExecutionEvent(debugger[0]));
-            } else {
-                engineAccess().dispatchEvent(engine, new ExecutionEvent(new Callable<Debugger>() {
-                    @Override
-                    public Debugger call() throws Exception {
-                        if (debugger[0] == null) {
-                            debugger[0] = find(engine, true);
-                            debugger[0].executionStarted(currentDepth, s);
-                        }
-                        return debugger[0];
-                    }
-                }));
+        protected DebugSupport debugSupport() {
+            return new DebugImpl();
+        }
+
+        private static final class DebugImpl extends DebugSupport {
+            @Override
+            public void executionStarted(Object vm, final int currentDepth, final Object[] debugger, final Source s) {
+                final PolyglotEngine engine = (PolyglotEngine) vm;
+                if (debugger[0] != null) {
+                    final Debugger dbg = (Debugger) debugger[0];
+                    dbg.executionStarted(currentDepth, s);
+                }
+                engineAccess().dispatchEvent(engine, new ExecutionEvent(engine, currentDepth, debugger, s), EngineSupport.EXECUTION_EVENT);
             }
-            return new Closeable() {
-                @Override
-                public void close() throws IOException {
-                    if (debugger[0] != null) {
-                        debugger[0].executionEnded();
-                    }
+
+            @Override
+            public void executionEnded(Object vm, Object[] debugger) {
+                if (debugger[0] != null) {
+                    ((Debugger) debugger[0]).executionEnded();
                 }
-            };
+            }
+
+            @Override
+            public Assumption assumeNoDebugger() {
+                return NO_DEBUGGER;
+            }
         }
 
         @SuppressWarnings("rawtypes")

truffle/com.oracle.truffle.api.debug/src/com/oracle/truffle/api/debug/ExecutionEvent.java

@@ -24,7 +24,8 @@
  */
 package com.oracle.truffle.api.debug;
 
-import java.util.concurrent.Callable;
+import com.oracle.truffle.api.source.Source;
+import com.oracle.truffle.api.vm.PolyglotEngine;
 
 /**
  * This event is delivered to all
@@ -43,14 +44,16 @@
  */
 @SuppressWarnings("javadoc")
 public final class ExecutionEvent {
-    private Object debugger;
+    private final Object[] debugger;
+    private final PolyglotEngine engine;
+    private final int currentDepth;
+    private final Source source;
 
-    ExecutionEvent(Debugger debugger) {
-        this.debugger = debugger;
-    }
-
-    ExecutionEvent(Callable<Debugger> debugger) {
+    ExecutionEvent(PolyglotEngine engine, int currentDepth, Object[] debugger, Source source) {
         this.debugger = debugger;
+        this.engine = engine;
+        this.currentDepth = currentDepth;
+        this.source = source;
     }
 
     /**
@@ -63,15 +66,17 @@ public final class ExecutionEvent {
      * @since 0.9
      */
     public Debugger getDebugger() {
-        if (debugger instanceof Debugger) {
-            return (Debugger) debugger;
+        if (debugger[0] instanceof Debugger) {
+            return (Debugger) debugger[0];
         }
         try {
-            debugger = ((Callable<?>) debugger).call();
+            final Debugger dbg = Debugger.find(engine, true);
+            dbg.executionStarted(currentDepth, source);
+            debugger[0] = dbg;
         } catch (Exception ex) {
             throw new IllegalStateException(ex);
         }
-        return (Debugger) debugger;
+        return (Debugger) debugger[0];
     }
 
     /**

truffle/com.oracle.truffle.api.instrumentation/src/com/oracle/truffle/api/instrumentation/InstrumentationHandler.java

@@ -502,6 +502,9 @@ private abstract class AbstractBindingsVisitor extends AbstractNodeVisitor {
 
         @Override
         boolean shouldVisit() {
+            if (root == null) {
+                return false;
+            }
             SourceSection sourceSection = root.getSourceSection();
             for (int i = 0; i < bindings.size(); i++) {
                 EventBinding<?> binding = bindings.get(i);

truffle/com.oracle.truffle.api.interop/src/com/oracle/truffle/api/interop/CachedObjectAccessNode.java

@@ -28,38 +28,30 @@
 import com.oracle.truffle.api.nodes.DirectCallNode;
 
 final class CachedObjectAccessNode extends ObjectAccessNode {
-    @Child private DirectCallNode callTarget;
+    @Child private DirectCallNode callNode;
     @Child private ObjectAccessNode next;
     private final ForeignAccess languageCheck;
 
     @Child private ForeignAccessArguments accessArguments = new ForeignAccessArguments();
 
-    protected CachedObjectAccessNode(DirectCallNode callTarget, ObjectAccessNode next, ForeignAccess languageCheck) {
-        this.callTarget = callTarget;
+    protected CachedObjectAccessNode(DirectCallNode callNode, ObjectAccessNode next, ForeignAccess languageCheck) {
+        this.callNode = callNode;
         this.next = next;
         this.languageCheck = languageCheck;
-        this.callTarget.forceInlining();
+        this.callNode.forceInlining();
     }
 
     protected CachedObjectAccessNode(CachedObjectAccessNode prev) {
-        this(prev.callTarget, prev.next, prev.languageCheck);
+        this(prev.callNode, prev.next, prev.languageCheck);
     }
 
     @Override
     public Object executeWith(VirtualFrame frame, TruffleObject receiver, Object[] arguments) {
-        return doAccess(frame, receiver, arguments);
-    }
-
-    private Object doAccess(VirtualFrame frame, TruffleObject receiver, Object[] arguments) {
         if (languageCheck.canHandle(receiver)) {
-            return callTarget.call(frame, accessArguments.executeCreate(receiver, arguments));
+            return callNode.call(frame, accessArguments.executeCreate(receiver, arguments));
         } else {
-            return doNext(frame, receiver, arguments);
+            return next.executeWith(frame, receiver, arguments);
         }
     }
 
-    private Object doNext(VirtualFrame frame, TruffleObject receiver, Object[] arguments) {
-        return next.executeWith(frame, receiver, arguments);
-    }
-
 }

truffle/com.oracle.truffle.api.interop/src/com/oracle/truffle/api/interop/ForeignAccess.java

@@ -28,6 +28,7 @@
 
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.impl.ReadOnlyArrayList;
@@ -38,7 +39,7 @@
  * foreign language implementations, you need to implement {@link TruffleObject} and its
  * {@link TruffleObject#getForeignAccess()} method. To create instance of <code>ForeignAccess</code>
  * , use one of the factory methods available in this class.
- * 
+ *
  * @since 0.8 or earlier
  */
 public final class ForeignAccess {
@@ -247,8 +248,10 @@ public static Object sendExecute(Node executeNode, VirtualFrame frame, TruffleOb
         try {
             return fn.executeForeignImpl(frame, receiver, arguments);
         } catch (UnsupportedTypeException | ArityException | UnsupportedMessageException e) {
+            CompilerDirectives.transferToInterpreter();
             throw e;
         } catch (InteropException e) {
+            CompilerDirectives.transferToInterpreter();
             throw new AssertionError("Unexpected exception catched.", e);
         }
     }
@@ -490,7 +493,7 @@ boolean canHandle(TruffleObject receiver) {
      * that provides an AST snippet for a given {@link Message}. Rather than using this generic
      * {@code Factory}, consider implementing {@link Factory10} interface that captures the set of
      * messages each language should implement as of Truffle version 1.0.
-     * 
+     *
      * @since 0.8 or earlier
      */
     public interface Factory {

truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/vm/ContextStoreProfileTest.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.api.vm;
+
+import java.util.concurrent.Executors;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class ContextStoreProfileTest {
+    @Test
+    public void switchFromConstantToMultipleThreads() throws Exception {
+        final ContextStoreProfile profile = new ContextStoreProfile(null);
+        ContextStore store1 = new ContextStore(null, 0);
+        final ContextStore store2 = new ContextStore(null, 0);
+        profile.enter(store1);
+        assertEquals("Store associated", store1, profile.get());
+        final ContextStore[] check = {null};
+        Executors.newSingleThreadExecutor().submit(new Runnable() {
+            @Override
+            public void run() {
+                profile.enter(store2);
+                check[0] = profile.get();
+            }
+        }).get();
+        assertEquals("Store on other thread associated", store2, check[0]);
+        assertEquals("1st thread store is still there", store1, profile.get());
+    }
+
+    @Test
+    public void switchFromDynamicToMultipleThreads() throws Exception {
+        final ContextStoreProfile profile = new ContextStoreProfile(null);
+        ContextStore store1 = new ContextStore(null, 0);
+        ContextStore store2 = new ContextStore(null, 0);
+        final ContextStore store3 = new ContextStore(null, 0);
+        profile.enter(store1);
+        assertEquals("Store associated", store1, profile.get());
+        profile.enter(store2);
+        assertEquals("Store associated", store2, profile.get());
+        final ContextStore[] check = {null};
+        Executors.newSingleThreadExecutor().submit(new Runnable() {
+            @Override
+            public void run() {
+                profile.enter(store3);
+                check[0] = profile.get();
+            }
+        }).get();
+        assertEquals("Store on other thread associated", store3, check[0]);
+        assertEquals("1st thread store is still there", store2, profile.get());
+    }
+}