29
30 import java.lang.annotation.Annotation;
31 import java.lang.annotation.ElementType;
32 import java.lang.annotation.Inherited;
33 import java.lang.annotation.Retention;
34 import java.lang.annotation.RetentionPolicy;
35 import java.lang.annotation.Target;
36 import java.lang.reflect.Field;
37 import java.lang.reflect.Method;
38
39 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
40 import org.graalvm.compiler.api.test.Graal;
41 import org.graalvm.compiler.code.CompilationResult;
42 import org.graalvm.compiler.core.GraalCompiler;
43 import org.graalvm.compiler.core.GraalCompiler.Request;
44 import org.graalvm.compiler.core.LIRGenerationPhase;
45 import org.graalvm.compiler.core.LIRGenerationPhase.LIRGenerationContext;
46 import org.graalvm.compiler.core.common.CompilationIdentifier;
47 import org.graalvm.compiler.core.common.alloc.ComputeBlockOrder;
48 import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
49 import org.graalvm.compiler.core.target.Backend;
50 import org.graalvm.compiler.debug.DebugHandlersFactory;
51 import org.graalvm.compiler.debug.DebugContext;
52 import org.graalvm.compiler.lir.LIR;
53 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
54 import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
55 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
56 import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
57 import org.graalvm.compiler.lir.phases.AllocationPhase.AllocationContext;
58 import org.graalvm.compiler.lir.phases.LIRPhase;
59 import org.graalvm.compiler.lir.phases.LIRSuites;
60 import org.graalvm.compiler.lir.phases.PostAllocationOptimizationPhase.PostAllocationOptimizationContext;
61 import org.graalvm.compiler.lir.phases.PreAllocationOptimizationPhase.PreAllocationOptimizationContext;
62 import org.graalvm.compiler.microbenchmarks.graal.util.GraalState;
63 import org.graalvm.compiler.microbenchmarks.graal.util.GraalUtil;
64 import org.graalvm.compiler.microbenchmarks.graal.util.MethodSpec;
65 import org.graalvm.compiler.nodes.StructuredGraph;
66 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
67 import org.graalvm.compiler.nodes.cfg.Block;
68 import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
69 import org.graalvm.compiler.nodes.spi.LoweringProvider;
70 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
71 import org.graalvm.compiler.options.OptionValues;
72 import org.graalvm.compiler.phases.OptimisticOptimizations;
73 import org.graalvm.compiler.phases.PhaseSuite;
74 import org.graalvm.compiler.phases.tiers.HighTierContext;
75 import org.graalvm.compiler.phases.tiers.Suites;
76 import org.graalvm.compiler.phases.tiers.TargetProvider;
77 import org.graalvm.compiler.phases.util.Providers;
78 import org.graalvm.compiler.runtime.RuntimeProvider;
79 import org.openjdk.jmh.annotations.Level;
80 import org.openjdk.jmh.annotations.Param;
81 import org.openjdk.jmh.annotations.Scope;
82 import org.openjdk.jmh.annotations.Setup;
83 import org.openjdk.jmh.annotations.State;
84
85 import jdk.vm.ci.code.CodeCacheProvider;
86 import jdk.vm.ci.code.RegisterConfig;
87 import jdk.vm.ci.code.TargetDescription;
88 import jdk.vm.ci.meta.ConstantReflectionProvider;
89 import jdk.vm.ci.meta.MetaAccessProvider;
90 import jdk.vm.ci.meta.ResolvedJavaMethod;
91
92 /**
93 * State providing a new copy of a graph for each invocation of a benchmark. Subclasses of this
94 * class are annotated with {@link MethodSpec} to specify the Java method that will be parsed to
95 * obtain the original graph.
96 */
97 @State(Scope.Thread)
98 public abstract class GraalCompilerState {
99
100 /**
101 * Original graph from which the per-benchmark invocation {@link #graph} is cloned.
102 */
103 private StructuredGraph originalGraph;
104
105 /**
106 * The graph processed by the benchmark.
107 */
108 private final OptionValues options;
109 private final DebugContext debug;
110 private StructuredGraph graph;
357 lirGeneration();
358 }
359
360 /**
361 * Sets up {@link LIR} generation.
362 */
363 protected final void preLIRGeneration() {
364 assert request.graph.isFrozen() : "Graph not frozen.";
365 Object stub = null;
366 schedule = request.graph.getLastSchedule();
367 ControlFlowGraph cfg = deepCopy(schedule.getCFG());
368 Block[] blocks = cfg.getBlocks();
369 Block startBlock = cfg.getStartBlock();
370 assert startBlock != null;
371 assert startBlock.getPredecessorCount() == 0;
372
373 codeEmittingOrder = ComputeBlockOrder.computeCodeEmittingOrder(blocks.length, startBlock);
374 linearScanOrder = ComputeBlockOrder.computeLinearScanOrder(blocks.length, startBlock);
375
376 LIR lir = new LIR(cfg, linearScanOrder, codeEmittingOrder, getGraphOptions(), getGraphDebug());
377 FrameMapBuilder frameMapBuilder = request.backend.newFrameMapBuilder(registerConfig);
378 lirGenRes = request.backend.newLIRGenerationResult(graph.compilationId(), lir, frameMapBuilder, request.graph, stub);
379 lirGenTool = request.backend.newLIRGenerator(lirGenRes);
380 nodeLirGen = request.backend.newNodeLIRBuilder(request.graph, lirGenTool);
381 }
382
383 protected OptionValues getGraphOptions() {
384 return graph.getOptions();
385 }
386
387 protected DebugContext getGraphDebug() {
388 return graph.getDebug();
389 }
390
391 private static ControlFlowGraph deepCopy(ControlFlowGraph cfg) {
392 return ControlFlowGraph.compute(cfg.graph, true, true, true, true);
393 }
394
395 /**
396 * Executes the {@link LIRGenerationPhase}.
397 */
398 protected final void lirGeneration() {
399 LIRGenerationContext context = new LIRGenerationContext(lirGenTool, nodeLirGen, request.graph, schedule);
400 new LIRGenerationPhase().apply(request.backend.getTarget(), lirGenRes, context);
443 }
444
445 /**
446 * Executes the {@link PostAllocationStage}.
447 *
448 * {@link LIRPhase phases} can be changed by overriding {@link #createLIRSuites}.
449 */
450 protected final void postAllocationStage() {
451 applyLIRPhase(getLIRSuites().getPostAllocationOptimizationStage(), createPostAllocationOptimizationContext());
452 }
453
454 protected PostAllocationOptimizationContext createPostAllocationOptimizationContext() {
455 return new PostAllocationOptimizationContext(lirGenTool);
456 }
457
458 /**
459 * Emits the machine code.
460 */
461 protected final void emitCode() {
462 int bytecodeSize = request.graph.method() == null ? 0 : request.graph.getBytecodeSize();
463 request.compilationResult.setHasUnsafeAccess(request.graph.hasUnsafeAccess());
464 GraalCompiler.emitCode(request.backend, request.graph.getAssumptions(), request.graph.method(), request.graph.getMethods(), request.graph.getFields(), bytecodeSize, lirGenRes,
465 request.compilationResult, request.installedCodeOwner, request.factory);
466 }
467
468 protected StructuredGraph graph() {
469 return graph;
470 }
471
472 protected LIR getLIR() {
473 return lirGenRes.getLIR();
474 }
475
476 public abstract static class Compile extends GraalCompilerState {
477
478 @Setup(Level.Trial)
479 public void init() {
480 initializeMethod();
481 }
482
483 @Setup(Level.Invocation)
484 public void setup() {
|
29
30 import java.lang.annotation.Annotation;
31 import java.lang.annotation.ElementType;
32 import java.lang.annotation.Inherited;
33 import java.lang.annotation.Retention;
34 import java.lang.annotation.RetentionPolicy;
35 import java.lang.annotation.Target;
36 import java.lang.reflect.Field;
37 import java.lang.reflect.Method;
38
39 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
40 import org.graalvm.compiler.api.test.Graal;
41 import org.graalvm.compiler.code.CompilationResult;
42 import org.graalvm.compiler.core.GraalCompiler;
43 import org.graalvm.compiler.core.GraalCompiler.Request;
44 import org.graalvm.compiler.core.LIRGenerationPhase;
45 import org.graalvm.compiler.core.LIRGenerationPhase.LIRGenerationContext;
46 import org.graalvm.compiler.core.common.CompilationIdentifier;
47 import org.graalvm.compiler.core.common.alloc.ComputeBlockOrder;
48 import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
49 import org.graalvm.compiler.core.gen.LIRCompilerBackend;
50 import org.graalvm.compiler.core.gen.LIRGenerationProvider;
51 import org.graalvm.compiler.core.target.Backend;
52 import org.graalvm.compiler.debug.DebugContext;
53 import org.graalvm.compiler.debug.DebugHandlersFactory;
54 import org.graalvm.compiler.lir.LIR;
55 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
56 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
57 import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
58 import org.graalvm.compiler.lir.phases.AllocationPhase.AllocationContext;
59 import org.graalvm.compiler.lir.phases.LIRPhase;
60 import org.graalvm.compiler.lir.phases.LIRSuites;
61 import org.graalvm.compiler.lir.phases.PostAllocationOptimizationPhase.PostAllocationOptimizationContext;
62 import org.graalvm.compiler.lir.phases.PreAllocationOptimizationPhase.PreAllocationOptimizationContext;
63 import org.graalvm.compiler.microbenchmarks.graal.util.GraalState;
64 import org.graalvm.compiler.microbenchmarks.graal.util.GraalUtil;
65 import org.graalvm.compiler.microbenchmarks.graal.util.MethodSpec;
66 import org.graalvm.compiler.nodes.StructuredGraph;
67 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
68 import org.graalvm.compiler.nodes.cfg.Block;
69 import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
70 import org.graalvm.compiler.nodes.spi.LoweringProvider;
71 import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
72 import org.graalvm.compiler.options.OptionValues;
73 import org.graalvm.compiler.phases.OptimisticOptimizations;
74 import org.graalvm.compiler.phases.PhaseSuite;
75 import org.graalvm.compiler.phases.tiers.HighTierContext;
76 import org.graalvm.compiler.phases.tiers.Suites;
77 import org.graalvm.compiler.phases.tiers.TargetProvider;
78 import org.graalvm.compiler.phases.util.Providers;
79 import org.graalvm.compiler.runtime.RuntimeProvider;
80 import org.openjdk.jmh.annotations.Level;
81 import org.openjdk.jmh.annotations.Param;
82 import org.openjdk.jmh.annotations.Scope;
83 import org.openjdk.jmh.annotations.Setup;
84 import org.openjdk.jmh.annotations.State;
85
86 import jdk.vm.ci.code.CodeCacheProvider;
87 import jdk.vm.ci.code.RegisterConfig;
88 import jdk.vm.ci.code.TargetDescription;
89 import jdk.vm.ci.meta.ConstantReflectionProvider;
90 import jdk.vm.ci.meta.MetaAccessProvider;
91 import jdk.vm.ci.meta.ResolvedJavaMethod;
92 import jdk.vm.ci.meta.SpeculationLog;
93
94 /**
95 * State providing a new copy of a graph for each invocation of a benchmark. Subclasses of this
96 * class are annotated with {@link MethodSpec} to specify the Java method that will be parsed to
97 * obtain the original graph.
98 */
99 @State(Scope.Thread)
100 public abstract class GraalCompilerState {
101
102 /**
103 * Original graph from which the per-benchmark invocation {@link #graph} is cloned.
104 */
105 private StructuredGraph originalGraph;
106
107 /**
108 * The graph processed by the benchmark.
109 */
110 private final OptionValues options;
111 private final DebugContext debug;
112 private StructuredGraph graph;
359 lirGeneration();
360 }
361
362 /**
363 * Sets up {@link LIR} generation.
364 */
365 protected final void preLIRGeneration() {
366 assert request.graph.isFrozen() : "Graph not frozen.";
367 Object stub = null;
368 schedule = request.graph.getLastSchedule();
369 ControlFlowGraph cfg = deepCopy(schedule.getCFG());
370 Block[] blocks = cfg.getBlocks();
371 Block startBlock = cfg.getStartBlock();
372 assert startBlock != null;
373 assert startBlock.getPredecessorCount() == 0;
374
375 codeEmittingOrder = ComputeBlockOrder.computeCodeEmittingOrder(blocks.length, startBlock);
376 linearScanOrder = ComputeBlockOrder.computeLinearScanOrder(blocks.length, startBlock);
377
378 LIR lir = new LIR(cfg, linearScanOrder, codeEmittingOrder, getGraphOptions(), getGraphDebug());
379 LIRGenerationProvider lirBackend = (LIRGenerationProvider) request.backend;
380 lirGenRes = lirBackend.newLIRGenerationResult(graph.compilationId(), lir, registerConfig, request.graph, stub);
381 lirGenTool = lirBackend.newLIRGenerator(lirGenRes);
382 nodeLirGen = lirBackend.newNodeLIRBuilder(request.graph, lirGenTool);
383 }
384
385 protected OptionValues getGraphOptions() {
386 return graph.getOptions();
387 }
388
389 protected DebugContext getGraphDebug() {
390 return graph.getDebug();
391 }
392
393 private static ControlFlowGraph deepCopy(ControlFlowGraph cfg) {
394 return ControlFlowGraph.compute(cfg.graph, true, true, true, true);
395 }
396
397 /**
398 * Executes the {@link LIRGenerationPhase}.
399 */
400 protected final void lirGeneration() {
401 LIRGenerationContext context = new LIRGenerationContext(lirGenTool, nodeLirGen, request.graph, schedule);
402 new LIRGenerationPhase().apply(request.backend.getTarget(), lirGenRes, context);
445 }
446
447 /**
448 * Executes the {@link PostAllocationStage}.
449 *
450 * {@link LIRPhase phases} can be changed by overriding {@link #createLIRSuites}.
451 */
452 protected final void postAllocationStage() {
453 applyLIRPhase(getLIRSuites().getPostAllocationOptimizationStage(), createPostAllocationOptimizationContext());
454 }
455
456 protected PostAllocationOptimizationContext createPostAllocationOptimizationContext() {
457 return new PostAllocationOptimizationContext(lirGenTool);
458 }
459
460 /**
461 * Emits the machine code.
462 */
463 protected final void emitCode() {
464 int bytecodeSize = request.graph.method() == null ? 0 : request.graph.getBytecodeSize();
465 SpeculationLog speculationLog = null;
466 request.compilationResult.setHasUnsafeAccess(request.graph.hasUnsafeAccess());
467 LIRCompilerBackend.emitCode(request.backend, request.graph.getAssumptions(), request.graph.method(), request.graph.getMethods(), request.graph.getFields(),
468 speculationLog, bytecodeSize, lirGenRes,
469 request.compilationResult, request.installedCodeOwner, request.factory);
470 }
471
472 protected StructuredGraph graph() {
473 return graph;
474 }
475
476 protected LIR getLIR() {
477 return lirGenRes.getLIR();
478 }
479
480 public abstract static class Compile extends GraalCompilerState {
481
482 @Setup(Level.Trial)
483 public void init() {
484 initializeMethod();
485 }
486
487 @Setup(Level.Invocation)
488 public void setup() {
|