[GR-6155] [GR-6358] Faster polyglot calls; fix host language multithreading; reenable threads closed assertion for languages.

PullRequest: graal/596

Author: chumer

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/GraalTVMCI.java

@@ -59,6 +59,28 @@ protected boolean isGuestCallStackFrame(StackTraceElement e) {
         return e.getMethodName().equals(OptimizedCallTarget.CALL_BOUNDARY_METHOD_NAME) && e.getClassName().equals(OptimizedCallTarget.class.getName());
     }
 
+    /**
+     * Initializes the argument profile with a custom profile without calling it. A call target must
+     * never be called prior initialization of argument types. Also the argument types must be final
+     * if used in combination with {@link #callProfiled(CallTarget, Object...)}.
+     */
+    @Override
+    protected void initializeProfile(CallTarget target, Class<?>[] argumentTypes) {
+        ((OptimizedCallTarget) target).getCompilationProfile().initializeArgumentTypes(argumentTypes);
+    }
+
+    /**
+     * Call without verifying the argument profile. Needs to be initialized by
+     * {@link #initializeProfile(CallTarget, Class[])}. Potentially crashes the VM if the argument
+     * profile is incompatible with the actual arguments. Use with caution.
+     */
+    @Override
+    protected Object callProfiled(CallTarget target, Object... args) {
+        OptimizedCallTarget castTarget = (OptimizedCallTarget) target;
+        assert castTarget.compilationProfile != null && castTarget.compilationProfile.isValidArgumentProfile(args) : "Invalid argument profile. UnsafeCalls need to explicity initialize the profile.";
+        return castTarget.doInvoke(args);
+    }
+
     @Override
     protected OptionDescriptors getCompilerOptionDescriptors() {
         return PolyglotCompilerOptions.getDescriptors();

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/OptimizedCompilationProfile.java

@@ -82,6 +82,17 @@ public String toString() {
                         compilationCallAndLoopThreshold);
     }
 
+    void initializeArgumentTypes(Class<?>[] argumentTypes) {
+        CompilerAsserts.neverPartOfCompilation();
+        if (profiledArgumentTypesAssumption != null) {
+            this.profiledArgumentTypesAssumption.invalidate();
+            throw new AssertionError("Argument types already initialized. initializeArgumentTypes must be called before any profile is initialized.");
+        } else {
+            this.profiledArgumentTypesAssumption = createAssumption("Custom profiled argument types");
+            this.profiledArgumentTypes = argumentTypes;
+        }
+    }
+
     Class<?>[] getProfiledArgumentTypes() {
         if (profiledArgumentTypesAssumption == null) {
             /*
@@ -315,6 +326,18 @@ private void updateProfiledArgumentTypes(Object[] args, Class<?>[] types) {
         profiledArgumentTypesAssumption = createAssumption("Profiled Argument Types");
     }
 
+    private static boolean checkProfiledArgumentTypes(Object[] args, Class<?>[] types) {
+        assert types != null;
+        if (args.length != types.length) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        for (int j = 0; j < types.length; j++) {
+            // throws ClassCast on error
+            types[j].cast(args[j]);
+        }
+        return true;
+    }
+
     private static Class<?> classOf(Object arg) {
         return arg != null ? arg.getClass() : null;
     }
@@ -385,4 +408,8 @@ public static OptimizedCompilationProfile create(OptionValues options) {
     private static OptimizedAssumption createAssumption(String name) {
         return (OptimizedAssumption) Truffle.getRuntime().createAssumption(name);
     }
+
+    public boolean isValidArgumentProfile(Object[] args) {
+        return profiledArgumentTypesAssumption != null && profiledArgumentTypesAssumption.isValid() && checkProfiledArgumentTypes(args, profiledArgumentTypes);
+    }
 }

sdk/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Graal SDK Changelog
+
+This changelog summarizes major changes between Graal SDK versions. The main focus is on APIs exported by Graal SDK.
+
+## Version 0.29
+
+* Introduced Context.enter() and Context.leave() that allows explicitly entering and leaving the context to improve performance of performing many simple operations.
+* Introduced Value.executeVoid to allow execution of functions more efficiently if not return value is expected.
+
+
+## Version 0.26
+
+* Initial revision of the polyglot API introduced.
+* Initial revision of the native image API introduced.
+* Initial revision of the options API introduced.

sdk/src/org.graalvm.polyglot/src/org/graalvm/polyglot/Context.java

@@ -255,6 +255,37 @@ public boolean initialize(String languageId) {
         return impl.initializeLanguage(languageId);
     }
 
+    /**
+     * Explicitly enters this context on the current thread. A context needs to be entered for any
+     * operation to be performed. The context implicitly enters and leaves the context for every
+     * operation. For example, before and after invoking the {@link Value#execute(Object...)
+     * execute} method. This can be inefficient if a very high number of simple operations needs to
+     * be performed. By {@link #enter() entering} and {@link #leave() leaving} once explicitly, the
+     * overhead for entering/leaving contexts for each operation can be eliminated. Contexts can be
+     * entered multiple times on the same thread.
+     *
+     * @throws IllegalStateException if the context is already {@link #close() closed}.
+     * @throws PolyglotException if a language has denied execution on the current thread.
+     * @see #leave() to leave a context.
+     * @since 1.0
+     */
+    public void enter() {
+        impl.explicitEnter();
+    }
+
+    /**
+     * Explicitly leaves this context on the current thread. The context must be {@link #enter()
+     * entered} before calling this method.
+     *
+     * @throws IllegalStateException if the context is already closed or if the context was not
+     *             {@link #enter() entered} on the current thread.
+     * @see #enter() to enter a context.
+     * @since 1.0
+     */
+    public void leave() {
+        impl.explicitLeave();
+    }
+
     /**
      * Closes this context and frees up potentially allocated native resources. A context cannot
      * free all native resources allocated automatically. For this reason it is necessary to close

sdk/src/org.graalvm.polyglot/src/org/graalvm/polyglot/Value.java

@@ -29,8 +29,10 @@
 import org.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractValueImpl;
 
 /**
- * Represents a polyglot value. Polyglot values can either result from a {@link #isHostObject()
- * host} or guest language. Polyglot values are bound to a {@link Context context}.
+ * Represents a polyglot value that can be accessed using a set of language agnostic operations.
+ * Polyglot values can either result from a {@link #isHostObject() host} or guest language. Polyglot
+ * values are bound to a {@link Context context}. If the context is closed then the value operation
+ * throw an {@link IllegalStateException}.
  *
  * @since 1.0
  */
@@ -144,22 +146,35 @@ public void putMember(String key, Object member) {
     // executable
 
     /**
-     * Returns <code>true</code> if the value can be executed. This indicates that the
-     * {@link #execute(Object...)} can be used with this value.
+     * Returns <code>true</code> if the value can be {@link #execute(Object...) executed}.
      *
+     * @throws IllegalStateException if the underlying context was closed
+     * @see #execute(Object...)
      * @since 1.0
      */
     public boolean canExecute() {
         return impl.canExecute(receiver);
     }
 
     /**
+     * Executes this value if it {@link #canExecute() can} be executed and returns its result. If no
+     * result value is expected or needed use {@link #executeVoid(Object...)} for better
+     * performance.
      *
+     * @throws IllegalStateException if the underlying context was closed
+     * @throws UnsupportedOperationException if this object cannot be executed.
+     * @throws PolyglotException if a guest language error occurred during execution.
+     * @see #executeVoid(Object...)
      *
      * @since 1.0
      */
     public Value execute(Object... arguments) {
-        return impl.execute(receiver, arguments);
+        if (arguments.length == 0) {
+            // specialized entry point for zero argument execute calls
+            return impl.execute(receiver);
+        } else {
+            return impl.execute(receiver, arguments);
+        }
     }
 
     /**
@@ -181,6 +196,26 @@ public Value newInstance(Object... arguments) {
         return impl.newInstance(receiver, arguments);
     }
 
+    /**
+     * Executes this value if it {@link #canExecute() can} be executed. If the result value is
+     * needed use {@link #execute(Object...)} instead.
+     *
+     * @throws IllegalStateException if the underlying context was closed
+     * @throws UnsupportedOperationException if this object cannot be executed.
+     * @throws PolyglotException if a guest language error occurred during execution.
+     * @see #execute(Object...)
+     *
+     * @since 1.0
+     */
+    public void executeVoid(Object... arguments) {
+        if (arguments.length == 0) {
+            // specialized entry point for zero argument execute calls
+            impl.executeVoid(receiver);
+        } else {
+            impl.executeVoid(receiver, arguments);
+        }
+    }
+
     /**
      *
      *

sdk/src/org.graalvm.polyglot/src/org/graalvm/polyglot/impl/AbstractPolyglotImpl.java

@@ -226,6 +226,10 @@ protected AbstractContextImpl(AbstractPolyglotImpl impl) {
 
         public abstract void close(boolean interuptExecution);
 
+        public abstract void explicitEnter();
+
+        public abstract void explicitLeave();
+
     }
 
     public abstract static class AbstractEngineImpl {
@@ -427,6 +431,10 @@ public Value execute(Object receiver, Object[] arguments) {
             return executeUnsupported(receiver);
         }
 
+        public Value execute(Object receiver) {
+            return executeUnsupported(receiver);
+        }
+
         public final Value executeUnsupported(Object receiver) {
             throw unsupported(receiver, "execute(Object...)", "canExecute()");
         }
@@ -443,6 +451,18 @@ public final Value newInstanceUnsupported(Object receiver) {
             throw unsupported(receiver, "newInstance(Object...)", "canInstantiate()");
         }
 
+        public void executeVoid(Object receiver, Object[] arguments) {
+            executeVoidUnsupported(receiver);
+        }
+
+        public void executeVoid(Object receiver) {
+            executeVoidUnsupported(receiver);
+        }
+
+        public final void executeVoidUnsupported(Object receiver) {
+            throw unsupported(receiver, "executeVoid(Object...)", "canExecute()");
+        }
+
         public boolean isString(Object receiver) {
             return false;
         }

truffle/src/com.oracle.truffle.api.benchmark/src/com/oracle/truffle/api/benchmark/EngineBenchmark.java

@@ -32,14 +32,15 @@
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Measurement;
 import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
 import org.openjdk.jmh.annotations.Warmup;
 
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.Scope;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.TruffleLanguage.Env;
-import com.oracle.truffle.api.Scope;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.ForeignAccess;
@@ -74,7 +75,26 @@ public static class ContextState {
         final Context context = Context.create(TEST_LANGUAGE);
         final Value value = context.eval(source);
         final Integer intValue = 42;
-        final Value hostValue = context.lookup(TEST_LANGUAGE, "context");
+        final Value hostValue = context.importSymbol("context");
+
+        @TearDown
+        public void tearDown() {
+            context.close();
+        }
+    }
+
+    @State(org.openjdk.jmh.annotations.Scope.Thread)
+    public static class ContextStateEnterLeave extends ContextState {
+
+        public ContextStateEnterLeave() {
+            context.enter();
+        }
+
+        @Override
+        public void tearDown() {
+            context.leave();
+            super.tearDown();
+        }
     }
 
     @Benchmark
@@ -87,6 +107,21 @@ public void executePolyglot1(ContextState state) {
         state.value.execute();
     }
 
+    @Benchmark
+    public void executePolyglot1Void(ContextState state) {
+        state.value.executeVoid();
+    }
+
+    @Benchmark
+    public void executePolyglot1VoidEntered(ContextStateEnterLeave state) {
+        state.value.executeVoid();
+    }
+
+    @Benchmark
+    public Object executePolyglot1CallTarget(CallTargetCallState state) {
+        return state.callTarget.call(state.internalContext.object);
+    }
+
     @Benchmark
     public int executePolyglot2(ContextState state) {
         int result = 0;
@@ -115,11 +150,11 @@ public Object execute(VirtualFrame frame) {
                 return constant;
             }
         });
-    }
 
-    @Benchmark
-    public Object executeCallTarget1(CallTargetCallState state) {
-        return state.callTarget.call(state.internalContext.object);
+        @TearDown
+        public void tearDown() {
+            context.close();
+        }
     }
 
     @Benchmark
@@ -191,17 +226,23 @@ public Object asHostObject(ContextState state) {
     /*
      * Test language that ensures that only engine overhead is tested.
      */
-    @TruffleLanguage.Registration(id = TEST_LANGUAGE, name = "", version = "", mimeType = "")
+    @TruffleLanguage.Registration(id = TEST_LANGUAGE, name = "", version = "", mimeType = TEST_LANGUAGE)
     public static class BenchmarkTestLanguage extends TruffleLanguage<BenchmarkContext> {
 
         @Override
         protected BenchmarkContext createContext(Env env) {
-            return new BenchmarkContext(env, new Function<TruffleObject, Scope>() {
+            BenchmarkContext context = new BenchmarkContext(env, new Function<TruffleObject, Scope>() {
                 @Override
                 public Scope apply(TruffleObject obj) {
                     return Scope.newBuilder("Benchmark top scope", obj).build();
                 }
             });
+            return context;
+        }
+
+        @Override
+        protected void initializeContext(BenchmarkContext context) throws Exception {
+            context.env.exportSymbol("context", JavaInterop.asTruffleValue(context));
         }
 
         @Override
@@ -245,7 +286,6 @@ static class BenchmarkContext {
             this.env = env;
             topScopes = Collections.singleton(scopeProvider.apply(new TopScopeObject(this)));
         }
-
     }
 
     public static class BenchmarkObject implements TruffleObject {

truffle/src/com.oracle.truffle.api.benchmark/src/com/oracle/truffle/api/benchmark/debug/DebugSpeedBench.java

@@ -24,6 +24,8 @@
 
 import java.io.IOException;
 
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Source;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Fork;
 import org.openjdk.jmh.annotations.Measurement;
@@ -33,9 +35,6 @@
 import org.openjdk.jmh.annotations.TearDown;
 import org.openjdk.jmh.annotations.Warmup;
 
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Source;
-
 import com.oracle.truffle.api.debug.Debugger;
 import com.oracle.truffle.api.debug.DebuggerSession;
 import com.oracle.truffle.api.debug.SuspendedCallback;