1 /*
2 * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24
25 package org.graalvm.compiler.hotspot;
26
27 import static org.graalvm.compiler.core.CompilationWrapper.ExceptionAction.Diagnose;
28 import static org.graalvm.compiler.core.CompilationWrapper.ExceptionAction.ExitVM;
29 import static org.graalvm.compiler.core.GraalCompilerOptions.CompilationBailoutAction;
30 import static org.graalvm.compiler.core.GraalCompilerOptions.CompilationFailureAction;
31 import static org.graalvm.compiler.core.phases.HighTier.Options.Inline;
32 import static org.graalvm.compiler.java.BytecodeParserOptions.InlineDuringParsing;
33
34 import java.io.PrintStream;
35 import java.util.List;
36
37 import jdk.internal.vm.compiler.collections.EconomicMap;
38 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
39 import org.graalvm.compiler.code.CompilationResult;
40 import org.graalvm.compiler.core.CompilationPrinter;
41 import org.graalvm.compiler.core.CompilationWrapper;
42 import org.graalvm.compiler.core.common.CompilationIdentifier;
43 import org.graalvm.compiler.debug.Assertions;
44 import org.graalvm.compiler.debug.CounterKey;
45 import org.graalvm.compiler.debug.DebugCloseable;
46 import org.graalvm.compiler.debug.DebugContext;
47 import org.graalvm.compiler.debug.DebugDumpScope;
48 import org.graalvm.compiler.debug.GraalError;
49 import org.graalvm.compiler.debug.TimerKey;
50 import org.graalvm.compiler.options.EnumOptionKey;
51 import org.graalvm.compiler.options.OptionKey;
52 import org.graalvm.compiler.options.OptionValues;
53 import org.graalvm.compiler.printer.GraalDebugHandlersFactory;
54
55 import jdk.vm.ci.code.BailoutException;
56 import jdk.vm.ci.code.CodeCacheProvider;
57 import jdk.vm.ci.hotspot.EventProvider;
58 import jdk.vm.ci.hotspot.HotSpotCompilationRequest;
59 import jdk.vm.ci.hotspot.HotSpotCompilationRequestResult;
60 import jdk.vm.ci.hotspot.HotSpotInstalledCode;
61 import jdk.vm.ci.hotspot.HotSpotJVMCICompilerFactory;
62 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
63 import jdk.vm.ci.hotspot.HotSpotNmethod;
64 import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
65 import jdk.vm.ci.runtime.JVMCICompiler;
66 import jdk.vm.ci.services.JVMCIServiceLocator;
67
68 public class CompilationTask {
69
70 private static final EventProvider eventProvider;
71
72 static {
73 List<EventProvider> providers = JVMCIServiceLocator.getProviders(EventProvider.class);
74 if (providers.size() > 1) {
75 throw new GraalError("Multiple %s providers found: %s", EventProvider.class.getName(), providers);
76 } else if (providers.isEmpty()) {
77 eventProvider = EventProvider.createEmptyEventProvider();
78 } else {
79 eventProvider = providers.get(0);
80 }
81 }
82
83 private final HotSpotJVMCIRuntime jvmciRuntime;
84
85 private final HotSpotGraalCompiler compiler;
86 private final HotSpotCompilationIdentifier compilationId;
87
88 private HotSpotInstalledCode installedCode;
89
90 /**
91 * Specifies whether the compilation result is installed as the
92 * {@linkplain HotSpotNmethod#isDefault() default} nmethod for the compiled method.
93 */
94 private final boolean installAsDefault;
95
96 private final boolean useProfilingInfo;
97 private final OptionValues options;
98
99 final class HotSpotCompilationWrapper extends CompilationWrapper<HotSpotCompilationRequestResult> {
100 private final EventProvider.CompilationEvent compilationEvent;
101 CompilationResult result;
102
103 HotSpotCompilationWrapper(EventProvider.CompilationEvent compilationEvent) {
104 super(compiler.getGraalRuntime().getOutputDirectory(), compiler.getGraalRuntime().getCompilationProblemsPerAction());
105 this.compilationEvent = compilationEvent;
106 }
107
108 @Override
109 protected DebugContext createRetryDebugContext(OptionValues retryOptions, PrintStream logStream) {
110 SnippetReflectionProvider snippetReflection = compiler.getGraalRuntime().getHostProviders().getSnippetReflection();
111 return DebugContext.create(retryOptions, logStream, new GraalDebugHandlersFactory(snippetReflection));
112 }
113
114 @Override
115 public String toString() {
116 return getMethod().format("%H.%n(%p)");
117 }
118
119 @Override
120 protected HotSpotCompilationRequestResult handleException(Throwable t) {
121 if (t instanceof BailoutException) {
122 BailoutException bailout = (BailoutException) t;
123 /*
124 * Handling of permanent bailouts: Permanent bailouts that can happen for example
125 * due to unsupported unstructured control flow in the bytecodes of a method must
126 * not be retried. Hotspot compile broker will ensure that no recompilation at the
127 * given tier will happen if retry is false.
128 */
129 return HotSpotCompilationRequestResult.failure(bailout.getMessage(), !bailout.isPermanent());
130 }
131 // Log a failure event.
132 EventProvider.CompilerFailureEvent event = eventProvider.newCompilerFailureEvent();
133 if (event.shouldWrite()) {
134 event.setCompileId(getId());
135 event.setMessage(t.getMessage());
136 event.commit();
137 }
138
139 /*
140 * Treat random exceptions from the compiler as indicating a problem compiling this
141 * method. Report the result of toString instead of getMessage to ensure that the
142 * exception type is included in the output in case there's no detail mesage.
143 */
144 return HotSpotCompilationRequestResult.failure(t.toString(), false);
145 }
146
147 @Override
148 protected ExceptionAction lookupAction(OptionValues values, EnumOptionKey<ExceptionAction> actionKey, Throwable cause) {
149 // Respect current action if it has been explicitly set.
150 if (!actionKey.hasBeenSet(values)) {
151 if (actionKey == CompilationFailureAction) {
152 // Automatically exit on non-bailout during bootstrap
153 // or when assertions are enabled.
154 if (Assertions.assertionsEnabled() || compiler.getGraalRuntime().isBootstrapping()) {
155 return ExitVM;
156 }
157 } else if (actionKey == CompilationBailoutAction && ((BailoutException) cause).isPermanent()) {
158 // Get more info for permanent bailouts during bootstrap
159 // or when assertions are enabled.
160 assert CompilationBailoutAction.getDefaultValue() == ExceptionAction.Silent;
161 if (Assertions.assertionsEnabled() || compiler.getGraalRuntime().isBootstrapping()) {
162 return Diagnose;
163 }
164 }
165 }
166 return super.lookupAction(values, actionKey, cause);
167 }
168
169 @SuppressWarnings("try")
170 @Override
171 protected HotSpotCompilationRequestResult performCompilation(DebugContext debug) {
172 HotSpotResolvedJavaMethod method = getMethod();
173 int entryBCI = getEntryBCI();
174 final boolean isOSR = entryBCI != JVMCICompiler.INVOCATION_ENTRY_BCI;
175 CompilationStatistics stats = CompilationStatistics.create(options, method, isOSR);
176
177 final CompilationPrinter printer = CompilationPrinter.begin(options, compilationId, method, entryBCI);
178
179 try (DebugContext.Scope s = debug.scope("Compiling", new DebugDumpScope(getIdString(), true))) {
180 // Begin the compilation event.
181 compilationEvent.begin();
182 result = compiler.compile(method, entryBCI, useProfilingInfo, compilationId, options, debug);
183 } catch (Throwable e) {
184 throw debug.handle(e);
185 } finally {
186 // End the compilation event.
187 compilationEvent.end();
188 }
189
190 if (result != null) {
191 try (DebugCloseable b = CodeInstallationTime.start(debug)) {
192 installMethod(debug, result);
193 }
194 // Installation is included in compilation time and memory usage reported by printer
195 printer.finish(result);
196 }
197 stats.finish(method, installedCode);
198 if (result != null) {
199 return HotSpotCompilationRequestResult.success(result.getBytecodeSize() - method.getCodeSize());
200 }
201 return null;
202 }
203
204 }
205
206 public CompilationTask(HotSpotJVMCIRuntime jvmciRuntime, HotSpotGraalCompiler compiler, HotSpotCompilationRequest request, boolean useProfilingInfo, boolean installAsDefault,
207 OptionValues options) {
208 this.jvmciRuntime = jvmciRuntime;
209 this.compiler = compiler;
210 this.compilationId = new HotSpotCompilationIdentifier(request);
211 this.useProfilingInfo = useProfilingInfo;
212 this.installAsDefault = installAsDefault;
213
214 /*
215 * Disable inlining if HotSpot has it disabled unless it's been explicitly set in Graal.
216 */
217 HotSpotGraalRuntimeProvider graalRuntime = compiler.getGraalRuntime();
218 GraalHotSpotVMConfig config = graalRuntime.getVMConfig();
219 OptionValues newOptions = options;
220 if (!config.inline) {
221 EconomicMap<OptionKey<?>, Object> m = OptionValues.newOptionMap();
222 if (Inline.getValue(options) && !Inline.hasBeenSet(options)) {
223 m.put(Inline, false);
224 }
225 if (InlineDuringParsing.getValue(options) && !InlineDuringParsing.hasBeenSet(options)) {
226 m.put(InlineDuringParsing, false);
227 }
228 if (!m.isEmpty()) {
229 newOptions = new OptionValues(options, m);
230 }
231 }
232 this.options = newOptions;
233 }
234
235 public HotSpotResolvedJavaMethod getMethod() {
236 return getRequest().getMethod();
237 }
238
239 CompilationIdentifier getCompilationIdentifier() {
240 return compilationId;
241 }
242
243 /**
244 * Returns the HotSpot id of this compilation.
245 *
246 * @return HotSpot compile id
247 */
248 public int getId() {
249 return getRequest().getId();
250 }
251
252 public int getEntryBCI() {
253 return getRequest().getEntryBCI();
254 }
255
256 /**
257 * @return the compilation id plus a trailing '%' if the compilation is an OSR to match
258 * PrintCompilation style output
259 */
260 public String getIdString() {
261 if (getEntryBCI() != JVMCICompiler.INVOCATION_ENTRY_BCI) {
262 return getId() + "%";
263 } else {
264 return Integer.toString(getId());
265 }
266 }
267
268 public HotSpotInstalledCode getInstalledCode() {
269 return installedCode;
270 }
271
272 /**
273 * Time spent in compilation.
274 */
275 private static final TimerKey CompilationTime = DebugContext.timer("CompilationTime").doc("Time spent in compilation and code installation.");
276
277 /**
278 * Counts the number of compiled {@linkplain CompilationResult#getBytecodeSize() bytecodes}.
279 */
280 private static final CounterKey CompiledBytecodes = DebugContext.counter("CompiledBytecodes");
281
282 /**
283 * Counts the number of compiled {@linkplain CompilationResult#getBytecodeSize() bytecodes} for
284 * which {@linkplain CompilationResult#getTargetCode()} code was installed.
285 */
286 private static final CounterKey CompiledAndInstalledBytecodes = DebugContext.counter("CompiledAndInstalledBytecodes");
287
288 /**
289 * Counts the number of installed {@linkplain CompilationResult#getTargetCodeSize()} bytes.
290 */
291 private static final CounterKey InstalledCodeSize = DebugContext.counter("InstalledCodeSize");
292
293 /**
294 * Time spent in code installation.
295 */
296 public static final TimerKey CodeInstallationTime = DebugContext.timer("CodeInstallation");
297
298 public HotSpotCompilationRequestResult runCompilation() {
299 SnippetReflectionProvider snippetReflection = compiler.getGraalRuntime().getHostProviders().getSnippetReflection();
300 try (DebugContext debug = DebugContext.create(options, new GraalDebugHandlersFactory(snippetReflection))) {
301 return runCompilation(debug);
302 }
303 }
304
305 @SuppressWarnings("try")
306 public HotSpotCompilationRequestResult runCompilation(DebugContext debug) {
307 HotSpotGraalRuntimeProvider graalRuntime = compiler.getGraalRuntime();
308 GraalHotSpotVMConfig config = graalRuntime.getVMConfig();
309 int entryBCI = getEntryBCI();
310 boolean isOSR = entryBCI != JVMCICompiler.INVOCATION_ENTRY_BCI;
311 HotSpotResolvedJavaMethod method = getMethod();
312
313 // Log a compilation event.
314 EventProvider.CompilationEvent compilationEvent = eventProvider.newCompilationEvent();
315
316 if (installAsDefault) {
317 // If there is already compiled code for this method on our level we simply return.
318 // JVMCI compiles are always at the highest compile level, even in non-tiered mode so we
319 // only need to check for that value.
320 if (method.hasCodeAtLevel(entryBCI, config.compilationLevelFullOptimization)) {
321 return HotSpotCompilationRequestResult.failure("Already compiled", false);
322 }
323 if (HotSpotGraalCompilerFactory.checkGraalCompileOnlyFilter(method.getDeclaringClass().toJavaName(), method.getName(), method.getSignature().toString(),
324 HotSpotJVMCICompilerFactory.CompilationLevel.FullOptimization) != HotSpotJVMCICompilerFactory.CompilationLevel.FullOptimization) {
325 return HotSpotCompilationRequestResult.failure("GraalCompileOnly excluded", false);
326 }
327 }
328
329 HotSpotCompilationWrapper compilation = new HotSpotCompilationWrapper(compilationEvent);
330 try (DebugCloseable a = CompilationTime.start(debug)) {
331 return compilation.run(debug);
332 } finally {
333 try {
334 int compiledBytecodes = 0;
335 int codeSize = 0;
336
337 if (compilation.result != null) {
338 compiledBytecodes = compilation.result.getBytecodeSize();
339 CompiledBytecodes.add(debug, compiledBytecodes);
340 if (installedCode != null) {
341 codeSize = installedCode.getSize();
342 CompiledAndInstalledBytecodes.add(debug, compiledBytecodes);
343 InstalledCodeSize.add(debug, codeSize);
344 }
345 }
346
347 // Log a compilation event.
348 if (compilationEvent.shouldWrite()) {
349 compilationEvent.setMethod(method.format("%H.%n(%p)"));
350 compilationEvent.setCompileId(getId());
351 compilationEvent.setCompileLevel(config.compilationLevelFullOptimization);
352 compilationEvent.setSucceeded(compilation.result != null && installedCode != null);
353 compilationEvent.setIsOsr(isOSR);
354 compilationEvent.setCodeSize(codeSize);
355 compilationEvent.setInlinedBytes(compiledBytecodes);
356 compilationEvent.commit();
357 }
358 } catch (Throwable t) {
359 return compilation.handleException(t);
360 }
361 }
362 }
363
364 @SuppressWarnings("try")
365 private void installMethod(DebugContext debug, final CompilationResult compResult) {
366 final CodeCacheProvider codeCache = jvmciRuntime.getHostJVMCIBackend().getCodeCache();
367 HotSpotBackend backend = compiler.getGraalRuntime().getHostBackend();
368 installedCode = null;
369 Object[] context = {new DebugDumpScope(getIdString(), true), codeCache, getMethod(), compResult};
370 try (DebugContext.Scope s = debug.scope("CodeInstall", context)) {
371 HotSpotCompilationRequest request = getRequest();
372 installedCode = (HotSpotInstalledCode) backend.createInstalledCode(debug,
373 request.getMethod(),
374 request,
375 compResult,
376 null,
377 installAsDefault,
378 context);
379 } catch (Throwable e) {
380 throw debug.handle(e);
381 }
382 }
383
384 @Override
385 public String toString() {
386 return "Compilation[id=" + getId() + ", " + getMethod().format("%H.%n(%p)") + (getEntryBCI() == JVMCICompiler.INVOCATION_ENTRY_BCI ? "" : "@" + getEntryBCI()) + "]";
387 }
388
389 private HotSpotCompilationRequest getRequest() {
390 return compilationId.getRequest();
391 }
392 }