| /* |
| * Copyright (c) 2012, 2016, 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 org.graalvm.compiler.core.test.inlining; |
| |
| import static org.graalvm.compiler.test.SubprocessUtil.getVMCommandLine; |
| import static org.graalvm.compiler.test.SubprocessUtil.java; |
| import static org.graalvm.compiler.test.SubprocessUtil.withoutDebuggerArguments; |
| |
| import jdk.vm.ci.meta.ResolvedJavaMethod; |
| import org.graalvm.compiler.core.test.GraalCompilerTest; |
| import org.graalvm.compiler.debug.DebugContext; |
| import org.graalvm.compiler.debug.DebugDumpScope; |
| import org.graalvm.compiler.graph.Node; |
| import org.graalvm.compiler.nodes.DeoptimizeNode; |
| import org.graalvm.compiler.nodes.InvokeNode; |
| import org.graalvm.compiler.nodes.StructuredGraph; |
| import org.graalvm.compiler.nodes.StructuredGraph.AllowAssumptions; |
| import org.graalvm.compiler.nodes.StructuredGraph.Builder; |
| import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration; |
| import org.graalvm.compiler.nodes.java.TypeSwitchNode; |
| import org.graalvm.compiler.phases.OptimisticOptimizations; |
| import org.graalvm.compiler.phases.PhaseSuite; |
| import org.graalvm.compiler.phases.common.CanonicalizerPhase; |
| import org.graalvm.compiler.phases.common.DeadCodeEliminationPhase; |
| import org.graalvm.compiler.phases.common.inlining.InliningPhase; |
| import org.graalvm.compiler.phases.tiers.HighTierContext; |
| import org.graalvm.compiler.test.SubprocessUtil; |
| import org.junit.Assert; |
| import org.junit.Test; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| public class PolymorphicInliningTest extends GraalCompilerTest { |
| |
| @Test |
| public void testInSubprocess() throws InterruptedException, IOException { |
| String recursionPropName = getClass().getName() + ".recursion"; |
| if (Boolean.getBoolean(recursionPropName)) { |
| testPolymorphicInlining(); |
| testPolymorphicNotInlining(); |
| testMegamorphicInlining(); |
| testMegamorphicNotInlining(); |
| } else { |
| List<String> vmArgs = withoutDebuggerArguments(getVMCommandLine()); |
| NotInlinableSubClass.class.getCanonicalName(); |
| vmArgs.add("-XX:CompileCommand=dontinline,org/graalvm/compiler/core/test/inlining/PolymorphicInliningTest$NotInlinableSubClass.publicOverriddenMethod"); |
| vmArgs.add("-D" + recursionPropName + "=true"); |
| SubprocessUtil.Subprocess proc = java(vmArgs, "com.oracle.mxtool.junit.MxJUnitWrapper", getClass().getName()); |
| if (proc.exitCode != 0) { |
| Assert.fail(String.format("non-zero exit code %d for command:%n%s", proc.exitCode, proc)); |
| } |
| } |
| } |
| |
| public int polymorphicCallsite(SuperClass receiver) { |
| return receiver.publicOverriddenMethod(); |
| } |
| |
| public void testPolymorphicInlining() { |
| for (int i = 0; i < 10000; i++) { |
| if (i % 2 == 0) { |
| polymorphicCallsite(Receivers.subClassA); |
| } else { |
| polymorphicCallsite(Receivers.subClassB); |
| } |
| } |
| StructuredGraph graph = getGraph("polymorphicCallsite", false); |
| // This callsite should be inlined with a TypeCheckedInliningViolated deoptimization. |
| assertTrue(getNodeCount(graph, InvokeNode.class) == 0); |
| assertTrue(getNodeCount(graph, TypeSwitchNode.class) == 1); |
| assertTrue(getNodeCount(graph, DeoptimizeNode.class) >= 1); |
| } |
| |
| /** |
| * This snippet is identical to {@link #polymorphicCallsite(SuperClass)}, and is for avoiding |
| * interference of the receiver type profile from different unit tests. |
| */ |
| public int polymorphicCallsite1(SuperClass receiver) { |
| return receiver.publicOverriddenMethod(); |
| } |
| |
| public void testPolymorphicNotInlining() { |
| for (int i = 0; i < 10000; i++) { |
| if (i % 2 == 0) { |
| polymorphicCallsite1(Receivers.subClassA); |
| } else { |
| polymorphicCallsite1(Receivers.notInlinableSubClass); |
| } |
| } |
| StructuredGraph graph = getGraph("polymorphicCallsite1", false); |
| // This callsite should not be inlined due to one of the potential callee method is not |
| // inlinable. |
| assertTrue(getNodeCount(graph, InvokeNode.class) == 1); |
| assertTrue(getNodeCount(graph, TypeSwitchNode.class) == 0); |
| } |
| |
| /** |
| * This snippet is identical to {@link #polymorphicCallsite(SuperClass)}, and is for avoiding |
| * interference of the receiver type profile from different unit tests. |
| */ |
| public int polymorphicCallsite2(SuperClass receiver) { |
| return receiver.publicOverriddenMethod(); |
| } |
| |
| public void testMegamorphicInlining() { |
| // Construct a receiver type profile that exceeds the max type width (by default 8 in JVMCI, |
| // specified by -XX:TypeProfileWidth). |
| for (int i = 0; i < 2000; i++) { |
| // Ensure the following receiver type is within the type profile. |
| polymorphicCallsite2(Receivers.subClassA); |
| } |
| for (int i = 0; i < 10000; i++) { |
| switch (i % 20) { |
| case 0: |
| case 1: |
| case 2: |
| case 3: |
| case 4: |
| case 5: |
| case 6: |
| case 7: |
| // Probability: 40% |
| // Ensure the probability is greater than |
| // GraalOptions.MegamorphicInliningMinMethodProbability (by default 0.33D); |
| polymorphicCallsite2(Receivers.subClassA); |
| break; |
| case 8: |
| polymorphicCallsite2(Receivers.subClassB); |
| break; |
| case 9: |
| polymorphicCallsite2(Receivers.subClassC); |
| break; |
| case 10: |
| polymorphicCallsite2(Receivers.subClassD); |
| break; |
| case 11: |
| polymorphicCallsite2(Receivers.subClassE); |
| break; |
| case 12: |
| polymorphicCallsite2(Receivers.subClassF); |
| break; |
| case 13: |
| polymorphicCallsite2(Receivers.subClassG); |
| break; |
| case 14: |
| polymorphicCallsite2(Receivers.subClassH); |
| break; |
| default: |
| // Probability: 25% |
| polymorphicCallsite2(Receivers.notInlinableSubClass); |
| break; |
| } |
| } |
| StructuredGraph graph = getGraph("polymorphicCallsite2", false); |
| // This callsite should be inlined with a fallback invocation. |
| assertTrue(getNodeCount(graph, InvokeNode.class) == 1); |
| assertTrue(getNodeCount(graph, TypeSwitchNode.class) == 1); |
| } |
| |
| /** |
| * This snippet is identical to {@link #polymorphicCallsite(SuperClass)}, and is for avoiding |
| * interference of the receiver type profile from different unit tests. |
| */ |
| public int polymorphicCallsite3(SuperClass receiver) { |
| return receiver.publicOverriddenMethod(); |
| } |
| |
| public void testMegamorphicNotInlining() { |
| for (int i = 0; i < 10000; i++) { |
| switch (i % 10) { |
| case 0: |
| case 1: |
| polymorphicCallsite3(Receivers.subClassA); |
| break; |
| case 2: |
| polymorphicCallsite3(Receivers.subClassB); |
| break; |
| case 3: |
| polymorphicCallsite3(Receivers.subClassC); |
| break; |
| case 4: |
| polymorphicCallsite3(Receivers.subClassD); |
| break; |
| case 5: |
| polymorphicCallsite3(Receivers.subClassE); |
| break; |
| case 6: |
| polymorphicCallsite3(Receivers.subClassF); |
| break; |
| case 7: |
| polymorphicCallsite3(Receivers.subClassG); |
| break; |
| case 8: |
| polymorphicCallsite3(Receivers.subClassH); |
| break; |
| default: |
| polymorphicCallsite3(Receivers.notInlinableSubClass); |
| break; |
| } |
| } |
| StructuredGraph graph = getGraph("polymorphicCallsite3", false); |
| // This callsite should not be inlined due to non of the potential callee method exceeds the |
| // probability specified by GraalOptions.MegamorphicInliningMinMethodProbability. |
| assertTrue(getNodeCount(graph, InvokeNode.class) == 1); |
| assertTrue(getNodeCount(graph, TypeSwitchNode.class) == 0); |
| } |
| |
| @SuppressWarnings("try") |
| private StructuredGraph getGraph(final String snippet, final boolean eagerInfopointMode) { |
| DebugContext debug = getDebugContext(); |
| try (DebugContext.Scope s = debug.scope("InliningTest", new DebugDumpScope(snippet, true))) { |
| ResolvedJavaMethod method = getResolvedJavaMethod(snippet); |
| Builder builder = builder(method, AllowAssumptions.YES, debug); |
| StructuredGraph graph = eagerInfopointMode ? parse(builder, getDebugGraphBuilderSuite()) : parse(builder, getEagerGraphBuilderSuite()); |
| try (DebugContext.Scope s2 = debug.scope("Inlining", graph)) { |
| PhaseSuite<HighTierContext> graphBuilderSuite = eagerInfopointMode |
| ? getCustomGraphBuilderSuite(GraphBuilderConfiguration.getDefault(getDefaultGraphBuilderPlugins()).withFullInfopoints(true)) |
| : getDefaultGraphBuilderSuite(); |
| HighTierContext context = new HighTierContext(getProviders(), graphBuilderSuite, OptimisticOptimizations.ALL); |
| debug.dump(DebugContext.BASIC_LEVEL, graph, "Graph"); |
| new CanonicalizerPhase().apply(graph, context); |
| new InliningPhase(new CanonicalizerPhase()).apply(graph, context); |
| debug.dump(DebugContext.BASIC_LEVEL, graph, "Graph"); |
| new CanonicalizerPhase().apply(graph, context); |
| new DeadCodeEliminationPhase().apply(graph); |
| return graph; |
| } |
| } catch (Throwable e) { |
| throw debug.handle(e); |
| } |
| } |
| |
| private static int getNodeCount(StructuredGraph graph, Class<? extends Node> nodeClass) { |
| return graph.getNodes().filter(nodeClass).count(); |
| } |
| |
| private static final class Receivers { |
| static final SubClassA subClassA = new SubClassA(); |
| static final SubClassB subClassB = new SubClassB(); |
| static final SubClassC subClassC = new SubClassC(); |
| static final SubClassD subClassD = new SubClassD(); |
| static final SubClassE subClassE = new SubClassE(); |
| static final SubClassF subClassF = new SubClassF(); |
| static final SubClassG subClassG = new SubClassG(); |
| static final SubClassH subClassH = new SubClassH(); |
| |
| static final NotInlinableSubClass notInlinableSubClass = new NotInlinableSubClass(); |
| } |
| |
| private abstract static class SuperClass { |
| |
| public abstract int publicOverriddenMethod(); |
| |
| } |
| |
| private static class SubClassA extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'A'; |
| } |
| |
| } |
| |
| private static class SubClassB extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'B'; |
| } |
| |
| } |
| |
| private static class SubClassC extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'C'; |
| } |
| |
| } |
| |
| private static class SubClassD extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'D'; |
| } |
| |
| } |
| |
| private static class SubClassE extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'E'; |
| } |
| |
| } |
| |
| private static class SubClassF extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'F'; |
| } |
| |
| } |
| |
| private static class SubClassG extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'G'; |
| } |
| |
| } |
| |
| private static class SubClassH extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'H'; |
| } |
| |
| } |
| |
| private static final class NotInlinableSubClass extends SuperClass { |
| |
| @Override |
| public int publicOverriddenMethod() { |
| return 'X'; |
| } |
| |
| } |
| |
| } |
