Deoptimization cycle patterns documentation; documentation for source cache tracing and statistics.

Author: jchalou

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/DeoptLoopDetectionTest.java

@@ -28,11 +28,15 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
+import java.io.IOException;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
 import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Engine;
+import org.graalvm.polyglot.Source;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assume;
@@ -44,18 +48,26 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.IndirectCallNode;
 import com.oracle.truffle.api.nodes.RootNode;
+import com.oracle.truffle.api.test.common.NullObject;
 import com.oracle.truffle.compiler.TruffleCompilerListener;
 import com.oracle.truffle.runtime.AbstractCompilationTask;
 import com.oracle.truffle.runtime.OptimizedCallTarget;
 import com.oracle.truffle.runtime.OptimizedTruffleRuntime;
 import com.oracle.truffle.runtime.OptimizedTruffleRuntimeListener;
 
 import jdk.graal.compiler.truffle.TruffleCompilerOptions;
+import jdk.graal.compiler.util.CollectionsUtil;
 
 public class DeoptLoopDetectionTest {
 
+    private static final Map<String, String> ENGINE_OPTIONS = CollectionsUtil.mapOf(
+                    "engine.CompilationFailureAction", "Silent", //
+                    "engine.BackgroundCompilation", "false", //
+                    "engine.CompileImmediately", "true");
     private final AtomicReference<CallTarget> callTargetFilter = new AtomicReference<>();
     private final AtomicReference<Boolean> compilationResult = new AtomicReference<>();
     private final AtomicReference<String> compilationFailedReason = new AtomicReference<>();
@@ -80,10 +92,7 @@ public void onCompilationFailed(OptimizedCallTarget target, String reason, boole
 
     @Before
     public void setup() {
-        context = Context.newBuilder().//
-                        option("engine.CompilationFailureAction", "Silent").//
-                        option("engine.BackgroundCompilation", "false").//
-                        option("engine.CompileImmediately", "true").build();
+        context = Context.newBuilder().options(ENGINE_OPTIONS).build();
         context.enter();
         Assume.assumeTrue(Truffle.getRuntime() instanceof OptimizedTruffleRuntime);
         ((OptimizedTruffleRuntime) Truffle.getRuntime()).addListener(listener);
@@ -104,7 +113,7 @@ public Object execute(VirtualFrame frame) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 return null;
             }
-        }, "alwaysDeopt", CallTarget::call, 1);
+        }, "alwaysDeopt", CallTarget::call, 0, 1);
     }
 
     @Test
@@ -145,19 +154,19 @@ public void accept(CallTarget callTarget) {
                     ((OptimizedCallTarget) callTarget).invalidate("Force one more recompile");
                 }
             }
-        }, 1));
+        }, 0, 1));
         Assert.assertEquals("No deopt loop detected after " + MAX_EXECUTIONS + " executions", expectedError.getMessage());
     }
 
     @Test
     public void testLocalDeopt() {
         assertDeoptLoop(new BaseRootNode() {
 
-            @CompilationFinal boolean cachedValue;
+            @CompilationFinal int cachedValue;
 
             @Override
             public Object execute(VirtualFrame frame) {
-                boolean arg = (boolean) frame.getArguments()[0];
+                int arg = (int) frame.getArguments()[0];
                 if (this.cachedValue != arg) {
                     CompilerDirectives.transferToInterpreterAndInvalidate();
                     this.cachedValue = arg;
@@ -166,9 +175,9 @@ public Object execute(VirtualFrame frame) {
             }
 
         }, "localDeopt", (target) -> {
-            target.call(true);
-            target.call(false);
-        }, 2);
+            target.call(0);
+            target.call(1);
+        }, 0, 2);
     }
 
     @Test
@@ -190,7 +199,7 @@ public Object execute(VirtualFrame frame) {
 
         }, "globalDeopt", (target) -> {
             target.call(true);
-        }, 1);
+        }, 0, 1);
     }
 
     static class StaticAssumptionRootNode extends BaseRootNode {
@@ -215,7 +224,7 @@ public void testStaticAssumptionNoDeopt() {
                 StaticAssumptionRootNode.assumption = Assumption.create();
                 firstExecution[0] = false;
             }
-        }, 1));
+        }, 0, 1));
         Assert.assertEquals("No deopt loop detected after " + MAX_EXECUTIONS + " executions", expectedError.getMessage());
     }
 
@@ -243,7 +252,7 @@ public Object execute(VirtualFrame frame) {
 
         }, "localLoopDeoptwithChangedCode", (target) -> {
             target.call(1);
-        }, 1);
+        }, 0, 1);
     }
 
     @Test
@@ -289,12 +298,166 @@ public Object execute(VirtualFrame frame) {
             public void accept(CallTarget target) {
                 target.call(input++);
             }
-        }, 1);
+        }, 0, 1);
+    }
+
+    @TruffleLanguage.Registration(id = NonConstantLanguageContextTestLanguage.ID, contextPolicy = TruffleLanguage.ContextPolicy.SHARED)
+    static class NonConstantLanguageContextTestLanguage extends TruffleLanguage<NonConstantLanguageContextTestLanguage.LanguageContext> {
+        static final String ID = "NonConstantLanguageContextTestLanguage";
+        static final String ROOT_NODE_NAME = "languageContextFallacy";
+
+        static class LanguageContext {
+            private final Env env;
+
+            @CompilationFinal boolean initialized;
+
+            LanguageContext(Env env) {
+                this.env = env;
+            }
+
+            void ensureInitialized() {
+                if (!initialized) {
+                    CompilerDirectives.transferToInterpreterAndInvalidate();
+                    initialize();
+                }
+            }
+
+            private void initialize() {
+                // perform initialization
+                initialized = true;
+            }
+
+            static final ContextReference<LanguageContext> REF = ContextReference.create(NonConstantLanguageContextTestLanguage.class);
+        }
+
+        @Override
+        protected LanguageContext createContext(Env env) {
+            return new LanguageContext(env);
+        }
+
+        @Override
+        protected CallTarget parse(ParsingRequest request) throws Exception {
+            BaseRootNode rootNode = new BaseRootNode() {
+                @Override
+                public Object execute(VirtualFrame frame) {
+                    LanguageContext languageContext = LanguageContext.REF.get(this);
+                    languageContext.ensureInitialized();
+                    // ...
+                    return NullObject.SINGLETON;
+                }
+            };
+            rootNode.name = ROOT_NODE_NAME;
+            return rootNode.getCallTarget();
+        }
+    }
+
+    @Test
+    public void testNonConstantLanguageContext() throws IOException {
+        try (Engine engine = Engine.newBuilder().options(ENGINE_OPTIONS).build()) {
+            Source source = Source.newBuilder(NonConstantLanguageContextTestLanguage.ID, "", "TestSource").build();
+            AtomicReference<OptimizedCallTarget> captureTargetReference = new AtomicReference<>();
+            final OptimizedTruffleRuntimeListener listener2 = new OptimizedTruffleRuntimeListener() {
+                @Override
+                public void onCompilationSuccess(OptimizedCallTarget target, AbstractCompilationTask task, TruffleCompilerListener.GraphInfo graph,
+                                TruffleCompilerListener.CompilationResultInfo result) {
+                    OptimizedTruffleRuntimeListener.super.onCompilationSuccess(target, task, graph, result);
+                    captureTargetReference.set(target);
+                }
+            };
+            ((OptimizedTruffleRuntime) Truffle.getRuntime()).addListener(listener2);
+            try {
+                try (Context context1 = Context.newBuilder().engine(engine).build()) {
+                    context1.eval(source);
+                }
+            } finally {
+                ((OptimizedTruffleRuntime) Truffle.getRuntime()).removeListener(listener2);
+            }
+            assertDeoptLoop((BaseRootNode) captureTargetReference.get().getRootNode(), NonConstantLanguageContextTestLanguage.ROOT_NODE_NAME, new Consumer<>() {
+
+                int calleeIndex = 0;
+
+                @Override
+                public void accept(CallTarget target) {
+                    try (Context context2 = Context.newBuilder().engine(engine).build()) {
+                        context2.eval(source);
+                    }
+                }
+            }, 1, 1);
+        }
+    }
+
+    static class MyFunction {
+        private final RootNode root;
+
+        MyFunction(int id) {
+            this.root = new RootNode(null) {
+                @Override
+                public Object execute(VirtualFrame frame) {
+                    return NullObject.SINGLETON;
+                }
+
+                @Override
+                public String getName() {
+                    return "callee" + id;
+                }
+
+                @Override
+                public String toString() {
+                    return getName();
+                }
+            };
+        }
+    }
+
+    @Test
+    public void testLookupAndDispatch() {
+        assertDeoptLoop(new BaseRootNode() {
+
+            @Child IndirectCallNode callNode = IndirectCallNode.create();
+
+            @Override
+            public Object execute(VirtualFrame frame) {
+                MyFunction function = (MyFunction) frame.getArguments()[0];
+                CallTarget target = function.root.getCallTarget();
+                return callNode.call(target);
+            }
+
+        }, "tooBroadDispatch", new Consumer<>() {
+
+            int calleeIndex = 0;
+
+            @Override
+            public void accept(CallTarget target) {
+                target.call(new MyFunction(calleeIndex++));
+            }
+        }, 0, 1);
+    }
+
+    @Test
+    public void testSkippedException() {
+        assertDeoptLoop(new BaseRootNode() {
+
+            @Override
+            public Object execute(VirtualFrame frame) {
+                try {
+                    throw new IndexOutOfBoundsException();
+                } catch (RuntimeException e) {
+                    //
+                }
+                return null;
+            }
+
+        }, "skippedException", new Consumer<>() {
+            @Override
+            public void accept(CallTarget target) {
+                target.call();
+            }
+        }, 0, 1);
     }
 
     private static final int MAX_EXECUTIONS = 1024;
 
-    private void assertDeoptLoop(BaseRootNode root, String name, Consumer<CallTarget> callStrategy, int compilationsPerIteration) {
+    private void assertDeoptLoop(BaseRootNode root, String name, Consumer<CallTarget> callStrategy, int previousCompilations, int compilationsPerIteration) {
         root.name = name;
         CallTarget callTarget = root.getCallTarget();
         callTargetFilter.set(callTarget);
@@ -313,7 +476,7 @@ private void assertDeoptLoop(BaseRootNode root, String name, Consumer<CallTarget
             iterationCounter++;
         }
 
-        assertTrue(iterationCounter * compilationsPerIteration > TruffleCompilerOptions.DeoptCycleDetectionThreshold.getDefaultValue());
+        assertTrue(previousCompilations + iterationCounter * compilationsPerIteration > TruffleCompilerOptions.DeoptCycleDetectionThreshold.getDefaultValue());
         assertEquals(Boolean.FALSE, compilationResult.get());
         String failedReason = compilationFailedReason.get();
         assertNotNull(failedReason);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/KnownTruffleTypes.java

@@ -231,6 +231,7 @@ private static ResolvedJavaField getThrowableJFRTracingField(MetaAccessProvider
     }
 
     private ResolvedJavaType[] createSkippedExceptionTypes() {
+        // keep in sync with truffle/docs/DeoptCyclePatterns.md
         List<ResolvedJavaType> types = new ArrayList<>(16);
         types.add(UnexpectedResultException);
         types.add(SlowPathException);