--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.microbenchmarks/src/org/graalvm/compiler/microbenchmarks/lir/GraalCompilerState.java Thu Feb 16 15:46:09 2017 -0800
@@ -0,0 +1,609 @@
+/*
+ * Copyright (c) 2016, 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.microbenchmarks.lir;
+
+import static org.graalvm.compiler.microbenchmarks.graal.util.GraalUtil.getGraph;
+import static org.graalvm.compiler.microbenchmarks.graal.util.GraalUtil.getMethodFromMethodSpec;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
+import org.graalvm.compiler.api.test.Graal;
+import org.graalvm.compiler.code.CompilationResult;
+import org.graalvm.compiler.core.GraalCompiler;
+import org.graalvm.compiler.core.GraalCompiler.Request;
+import org.graalvm.compiler.core.LIRGenerationPhase;
+import org.graalvm.compiler.core.LIRGenerationPhase.LIRGenerationContext;
+import org.graalvm.compiler.core.common.CompilationIdentifier;
+import org.graalvm.compiler.core.common.alloc.ComputeBlockOrder;
+import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
+import org.graalvm.compiler.core.target.Backend;
+import org.graalvm.compiler.debug.Debug;
+import org.graalvm.compiler.debug.DebugEnvironment;
+import org.graalvm.compiler.debug.internal.DebugScope;
+import org.graalvm.compiler.lir.LIR;
+import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
+import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
+import org.graalvm.compiler.lir.gen.LIRGenerationResult;
+import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
+import org.graalvm.compiler.lir.phases.AllocationPhase.AllocationContext;
+import org.graalvm.compiler.lir.phases.LIRPhase;
+import org.graalvm.compiler.lir.phases.LIRSuites;
+import org.graalvm.compiler.lir.phases.PostAllocationOptimizationPhase.PostAllocationOptimizationContext;
+import org.graalvm.compiler.lir.phases.PreAllocationOptimizationPhase.PreAllocationOptimizationContext;
+import org.graalvm.compiler.microbenchmarks.graal.util.GraalState;
+import org.graalvm.compiler.microbenchmarks.graal.util.GraalUtil;
+import org.graalvm.compiler.microbenchmarks.graal.util.MethodSpec;
+import org.graalvm.compiler.nodes.StructuredGraph;
+import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
+import org.graalvm.compiler.nodes.cfg.Block;
+import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
+import org.graalvm.compiler.nodes.spi.LoweringProvider;
+import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
+import org.graalvm.compiler.options.DerivedOptionValue;
+import org.graalvm.compiler.phases.OptimisticOptimizations;
+import org.graalvm.compiler.phases.PhaseSuite;
+import org.graalvm.compiler.phases.tiers.HighTierContext;
+import org.graalvm.compiler.phases.tiers.Suites;
+import org.graalvm.compiler.phases.tiers.TargetProvider;
+import org.graalvm.compiler.phases.util.Providers;
+import org.graalvm.compiler.runtime.RuntimeProvider;
+
+import jdk.vm.ci.code.CodeCacheProvider;
+import jdk.vm.ci.code.RegisterConfig;
+import jdk.vm.ci.code.TargetDescription;
+import jdk.vm.ci.meta.ConstantReflectionProvider;
+import jdk.vm.ci.meta.MetaAccessProvider;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+/**
+ * State providing a new copy of a graph for each invocation of a benchmark. Subclasses of this
+ * class are annotated with {@link MethodSpec} to specify the Java method that will be parsed to
+ * obtain the original graph.
+ */
+@State(Scope.Thread)
+public abstract class GraalCompilerState {
+
+ /**
+ * Original graph from which the per-benchmark invocation {@link #graph} is cloned.
+ */
+ private StructuredGraph originalGraph;
+
+ /**
+ * The graph processed by the benchmark.
+ */
+ private StructuredGraph graph;
+ private final Backend backend;
+ private final Providers providers;
+ private final DerivedOptionValue<Suites> suites;
+ private final DerivedOptionValue<LIRSuites> lirSuites;
+
+ /**
+ * We only allow inner classes to subclass this to ensure that the {@link Setup} methods are
+ * executed in the right order.
+ */
+ @SuppressWarnings("try")
+ protected GraalCompilerState() {
+ this.backend = Graal.getRequiredCapability(RuntimeProvider.class).getHostBackend();
+ this.providers = backend.getProviders();
+ this.suites = new DerivedOptionValue<>(this::createSuites);
+ this.lirSuites = new DerivedOptionValue<>(this::createLIRSuites);
+
+ // Ensure a debug configuration for this thread is initialized
+ if (Debug.isEnabled() && DebugScope.getConfig() == null) {
+ DebugEnvironment.initialize(System.out);
+ }
+
+ }
+
+ protected boolean useProfilingInfo() {
+ return false;
+ }
+
+ @SuppressWarnings("try")
+ protected void initializeMethod() {
+ GraalState graal = new GraalState();
+ ResolvedJavaMethod method = graal.metaAccess.lookupJavaMethod(getMethod());
+ StructuredGraph structuredGraph = null;
+ try (Debug.Scope s = Debug.scope("GraphState", method)) {
+ structuredGraph = preprocessOriginal(getGraph(graal, method, useProfilingInfo()));
+ } catch (Throwable t) {
+ Debug.handle(t);
+ }
+ this.originalGraph = structuredGraph;
+ }
+
+ protected Method getMethod() {
+ Class<?> c = getClass();
+ if (isMethodSpecAnnotationPresent(c)) {
+ return getMethodFromMethodSpec(c);
+ }
+ return findParamField(this);
+ }
+
+ protected boolean isMethodSpecAnnotationPresent(Class<?> startClass) {
+ Class<?> c = startClass;
+ while (c != null) {
+ if (c.isAnnotationPresent(MethodSpec.class)) {
+ return true;
+ }
+ c = c.getSuperclass();
+ }
+ return false;
+ }
+
+ /**
+ * Declares {@link GraalCompilerState#getMethodFromString(String) method description field}. The
+ * field must be a {@link String} and have a {@link Param} annotation.
+ */
+ @Inherited
+ @Target({ElementType.FIELD})
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface MethodDescString {
+ }
+
+ private static Method findParamField(Object obj) {
+ Class<?> c = obj.getClass();
+ Class<? extends Annotation> annotationClass = MethodDescString.class;
+ try {
+ for (Field f : c.getFields()) {
+ if (f.isAnnotationPresent(annotationClass)) {
+ // these checks could be done by an annotation processor
+ if (!f.getType().equals(String.class)) {
+ throw new RuntimeException("Found a field annotated with " + annotationClass.getSimpleName() + " in " + c + " which is not a " + String.class.getSimpleName());
+ }
+ if (!f.isAnnotationPresent(Param.class)) {
+ throw new RuntimeException("Found a field annotated with " + annotationClass.getSimpleName() + " in " + c + " which is not annotated with " + Param.class.getSimpleName());
+ }
+ String methodName;
+ methodName = (String) f.get(obj);
+ assert methodName != null;
+ return getMethodFromString(methodName);
+ }
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ throw new RuntimeException("Could not find class annotated with " + annotationClass.getSimpleName() + " in hierarchy of " + c);
+ }
+
+ /**
+ * Gets a {@link Method} from a method description string. The format is as follows:
+ *
+ * <pre>
+ * ClassName#MethodName
+ * ClassName#MethodName(ClassName, ClassName, ...)
+ * </pre>
+ *
+ * <code>CodeName</code> is passed to {@link Class#forName(String)}. <br>
+ * <b>Examples:</b>
+ *
+ * <pre>
+ * java.lang.String#equals
+ * java.lang.String#equals(java.lang.Object)
+ * </pre>
+ */
+ protected static Method getMethodFromString(String methodDesc) {
+ try {
+ String[] s0 = methodDesc.split("#", 2);
+ if (s0.length != 2) {
+ throw new RuntimeException("Missing method description? " + methodDesc);
+ }
+ String className = s0[0];
+ Class<?> clazz = Class.forName(className);
+ String[] s1 = s0[1].split("\\(", 2);
+ String name = s1[0];
+ Class<?>[] parameters = null;
+ if (s1.length > 1) {
+ String parametersPart = s1[1];
+ if (parametersPart.charAt(parametersPart.length() - 1) != ')') {
+ throw new RuntimeException("Missing closing ')'? " + methodDesc);
+ }
+ String[] s2 = parametersPart.substring(0, parametersPart.length() - 1).split(",");
+ parameters = new Class<?>[s2.length];
+ for (int i = 0; i < s2.length; i++) {
+ parameters[i] = Class.forName(s2[i]);
+ }
+ }
+ return GraalUtil.getMethod(clazz, name, parameters);
+ } catch (ClassNotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected StructuredGraph preprocessOriginal(StructuredGraph structuredGraph) {
+ return structuredGraph;
+ }
+
+ protected Suites createSuites() {
+ Suites ret = backend.getSuites().getDefaultSuites().copy();
+ return ret;
+ }
+
+ protected LIRSuites createLIRSuites() {
+ LIRSuites ret = backend.getSuites().getDefaultLIRSuites().copy();
+ return ret;
+ }
+
+ protected Backend getBackend() {
+ return backend;
+ }
+
+ protected Suites getSuites() {
+ return suites.getValue();
+ }
+
+ protected LIRSuites getOriginalLIRSuites() {
+ return lirSuites.getValue();
+ }
+
+ protected Providers getProviders() {
+ return providers;
+ }
+
+ protected SnippetReflectionProvider getSnippetReflection() {
+ return Graal.getRequiredCapability(SnippetReflectionProvider.class);
+ }
+
+ protected TargetDescription getTarget() {
+ return getTargetProvider().getTarget();
+ }
+
+ protected TargetProvider getTargetProvider() {
+ return getBackend();
+ }
+
+ protected CodeCacheProvider getCodeCache() {
+ return getProviders().getCodeCache();
+ }
+
+ protected ConstantReflectionProvider getConstantReflection() {
+ return getProviders().getConstantReflection();
+ }
+
+ protected MetaAccessProvider getMetaAccess() {
+ return getProviders().getMetaAccess();
+ }
+
+ protected LoweringProvider getLowerer() {
+ return getProviders().getLowerer();
+ }
+
+ protected PhaseSuite<HighTierContext> getDefaultGraphBuilderSuite() {
+ // defensive copying
+ return backend.getSuites().getDefaultGraphBuilderSuite().copy();
+ }
+
+ protected LIRSuites getLIRSuites() {
+ return request.lirSuites;
+ }
+
+ private Request<CompilationResult> request;
+ private LIRGenerationResult lirGenRes;
+ private LIRGeneratorTool lirGenTool;
+ private NodeLIRBuilderTool nodeLirGen;
+ private RegisterConfig registerConfig;
+ private ScheduleResult schedule;
+ private AbstractBlockBase<?>[] codeEmittingOrder;
+ private AbstractBlockBase<?>[] linearScanOrder;
+
+ /**
+ * Copies the {@link #originalGraph original graph} and prepares the {@link #request}.
+ *
+ * The {@link Suites} can be changed by overriding {@link #createSuites()}. {@link LIRSuites}
+ * can be changed by overriding {@link #createLIRSuites()}.
+ */
+ protected final void prepareRequest() {
+ assert originalGraph != null : "call initialzeMethod first";
+ CompilationIdentifier compilationId = backend.getCompilationIdentifier(originalGraph.method());
+ graph = originalGraph.copyWithIdentifier(compilationId);
+ assert !graph.isFrozen();
+ ResolvedJavaMethod installedCodeOwner = graph.method();
+ request = new Request<>(graph, installedCodeOwner, getProviders(), getBackend(), getDefaultGraphBuilderSuite(), OptimisticOptimizations.ALL,
+ graph.getProfilingInfo(), getSuites(), getOriginalLIRSuites(), new CompilationResult(), CompilationResultBuilderFactory.Default);
+ }
+
+ /**
+ * Executes the high-level (FrontEnd) part of the compiler.
+ */
+ protected final void emitFrontEnd() {
+ GraalCompiler.emitFrontEnd(request.providers, request.backend, request.graph, request.graphBuilderSuite, request.optimisticOpts, request.profilingInfo, request.suites);
+ request.graph.freeze();
+ }
+
+ /**
+ * Executes the low-level (BackEnd) part of the compiler.
+ */
+ protected final void emitBackEnd() {
+ emitLIR();
+ emitCode();
+ }
+
+ /**
+ * Generates {@link LIR} and executes the {@link LIR} pipeline.
+ */
+ protected final void emitLIR() {
+ generateLIR();
+ emitLowLevel();
+ }
+
+ /**
+ * Generates the initial {@link LIR}.
+ */
+ protected final void generateLIR() {
+ preLIRGeneration();
+ lirGeneration();
+ }
+
+ /**
+ * Sets up {@link LIR} generation.
+ */
+ protected final void preLIRGeneration() {
+ assert request.graph.isFrozen() : "Graph not frozen.";
+ Object stub = null;
+ schedule = request.graph.getLastSchedule();
+ ControlFlowGraph cfg = deepCopy(schedule.getCFG());
+ Block[] blocks = cfg.getBlocks();
+ Block startBlock = cfg.getStartBlock();
+ assert startBlock != null;
+ assert startBlock.getPredecessorCount() == 0;
+
+ codeEmittingOrder = ComputeBlockOrder.computeCodeEmittingOrder(blocks.length, startBlock);
+ linearScanOrder = ComputeBlockOrder.computeLinearScanOrder(blocks.length, startBlock);
+
+ LIR lir = new LIR(cfg, linearScanOrder, codeEmittingOrder);
+ FrameMapBuilder frameMapBuilder = request.backend.newFrameMapBuilder(registerConfig);
+ lirGenRes = request.backend.newLIRGenerationResult(graph.compilationId(), lir, frameMapBuilder, request.graph, stub);
+ lirGenTool = request.backend.newLIRGenerator(lirGenRes);
+ nodeLirGen = request.backend.newNodeLIRBuilder(request.graph, lirGenTool);
+ }
+
+ private static ControlFlowGraph deepCopy(ControlFlowGraph cfg) {
+ return ControlFlowGraph.compute(cfg.graph, true, true, true, true);
+ }
+
+ /**
+ * Executes the {@link LIRGenerationPhase}.
+ */
+ protected final void lirGeneration() {
+ LIRGenerationContext context = new LIRGenerationContext(lirGenTool, nodeLirGen, request.graph, schedule);
+ new LIRGenerationPhase().apply(request.backend.getTarget(), lirGenRes, context);
+ }
+
+ /**
+ * Executes the low-level compiler stages.
+ */
+ protected final void emitLowLevel() {
+ preAllocationStage();
+ allocationStage();
+ postAllocationStage();
+ }
+
+ /**
+ * Executes a {@link LIRPhase} within a given {@code context}.
+ */
+ protected <C> void applyLIRPhase(LIRPhase<C> phase, C context) {
+ phase.apply(request.backend.getTarget(), lirGenRes, context);
+ }
+
+ /**
+ * Executes the {@link PreAllocationStage}.
+ *
+ * {@link LIRPhase phases} can be changed by overriding {@link #createLIRSuites()}.
+ */
+ protected final void preAllocationStage() {
+ applyLIRPhase(getLIRSuites().getPreAllocationOptimizationStage(), createPreAllocationOptimizationContext());
+ }
+
+ protected PreAllocationOptimizationContext createPreAllocationOptimizationContext() {
+ return new PreAllocationOptimizationContext(lirGenTool);
+ }
+
+ /**
+ * Executes the {@link AllocationStage}.
+ *
+ * {@link LIRPhase phases} can be changed by overriding {@link #createLIRSuites()}.
+ */
+ protected final void allocationStage() {
+ applyLIRPhase(getLIRSuites().getAllocationStage(), createAllocationContext());
+ }
+
+ protected AllocationContext createAllocationContext() {
+ return new AllocationContext(lirGenTool.getSpillMoveFactory(), request.backend.newRegisterAllocationConfig(registerConfig));
+ }
+
+ /**
+ * Executes the {@link PostAllocationStage}.
+ *
+ * {@link LIRPhase phases} can be changed by overriding {@link #createLIRSuites()}.
+ */
+ protected final void postAllocationStage() {
+ applyLIRPhase(getLIRSuites().getPostAllocationOptimizationStage(), createPostAllocationOptimizationContext());
+ }
+
+ protected PostAllocationOptimizationContext createPostAllocationOptimizationContext() {
+ return new PostAllocationOptimizationContext(lirGenTool);
+ }
+
+ /**
+ * Emits the machine code.
+ */
+ protected final void emitCode() {
+ int bytecodeSize = request.graph.method() == null ? 0 : request.graph.getBytecodeSize();
+ request.compilationResult.setHasUnsafeAccess(request.graph.hasUnsafeAccess());
+ GraalCompiler.emitCode(request.backend, request.graph.getAssumptions(), request.graph.method(), request.graph.getMethods(), request.graph.getFields(), bytecodeSize, lirGenRes,
+ request.compilationResult, request.installedCodeOwner, request.factory);
+ }
+
+ protected StructuredGraph graph() {
+ return graph;
+ }
+
+ protected LIR getLIR() {
+ return lirGenRes.getLIR();
+ }
+
+ public abstract static class Compile extends GraalCompilerState {
+
+ @Setup(Level.Trial)
+ public void init() {
+ initializeMethod();
+ }
+
+ @Setup(Level.Invocation)
+ public void setup() {
+ prepareRequest();
+ }
+
+ public CompilationResult compile() {
+ emitFrontEnd();
+ emitBackEnd();
+ return super.request.compilationResult;
+ }
+
+ }
+
+ public abstract static class FrontEndOnly extends GraalCompilerState {
+
+ @Setup(Level.Trial)
+ public void init() {
+ initializeMethod();
+ }
+
+ @Setup(Level.Invocation)
+ public void setup() {
+ prepareRequest();
+ }
+
+ public StructuredGraph compile() {
+ emitFrontEnd();
+ return super.graph;
+ }
+
+ }
+
+ public abstract static class BackEndOnly extends GraalCompilerState {
+
+ @Setup(Level.Trial)
+ public void init() {
+ initializeMethod();
+ }
+
+ /**
+ * Cannot do this {@link Level#Trial only once} since {@link #emitCode()} closes the
+ * {@link CompilationResult}.
+ */
+ @Setup(Level.Invocation)
+ public void setupGraph() {
+ prepareRequest();
+ emitFrontEnd();
+ }
+
+ public CompilationResult compile() {
+ emitBackEnd();
+ return super.request.compilationResult;
+ }
+ }
+
+ public abstract static class PreAllocationStage extends GraalCompilerState {
+ /**
+ * No need to rebuild the graph for every invocation since it is not altered by the backend.
+ */
+ @Setup(Level.Trial)
+ public void setupGraph() {
+ initializeMethod();
+ prepareRequest();
+ emitFrontEnd();
+ }
+
+ @Setup(Level.Invocation)
+ public void setup() {
+ generateLIR();
+ }
+
+ public LIRGenerationResult compile() {
+ preAllocationStage();
+ return super.lirGenRes;
+ }
+ }
+
+ public abstract static class AllocationStage extends GraalCompilerState {
+ /**
+ * No need to rebuild the graph for every invocation since it is not altered by the backend.
+ */
+ @Setup(Level.Trial)
+ public void setupGraph() {
+ initializeMethod();
+ prepareRequest();
+ emitFrontEnd();
+ }
+
+ @Setup(Level.Invocation)
+ public void setup() {
+ generateLIR();
+ preAllocationStage();
+ }
+
+ public LIRGenerationResult compile() {
+ allocationStage();
+ return super.lirGenRes;
+ }
+ }
+
+ public abstract static class PostAllocationStage extends GraalCompilerState {
+ /**
+ * No need to rebuild the graph for every invocation since it is not altered by the backend.
+ */
+ @Setup(Level.Trial)
+ public void setupGraph() {
+ initializeMethod();
+ prepareRequest();
+ emitFrontEnd();
+ }
+
+ @Setup(Level.Invocation)
+ public void setup() {
+ generateLIR();
+ preAllocationStage();
+ allocationStage();
+ }
+
+ public LIRGenerationResult compile() {
+ postAllocationStage();
+ return super.lirGenRes;
+ }
+ }
+}