Java SpeculationLog类代码示例

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
private StructuredGraph(String name,
                ResolvedJavaMethod method,
                int entryBCI,
                Assumptions assumptions,
                SpeculationLog speculationLog,
                boolean useProfilingInfo,
                CompilationIdentifier compilationId,
                OptionValues options,
                DebugContext debug,
                Cancellable cancellable) {
    super(name, options, debug);
    this.setStart(add(new StartNode()));
    this.rootMethod = method;
    this.graphId = uniqueGraphIds.incrementAndGet();
    this.compilationId = compilationId;
    this.entryBCI = entryBCI;
    this.assumptions = assumptions;
    this.speculationLog = speculationLog;
    this.useProfilingInfo = useProfilingInfo;
    this.cancellable = cancellable;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public StructuredGraph createGraph(ResolvedJavaMethod method, int entryBCI, boolean useProfilingInfo, CompilationIdentifier compilationId, OptionValues options, DebugContext debug) {
    HotSpotBackend backend = graalRuntime.getHostBackend();
    HotSpotProviders providers = backend.getProviders();
    final boolean isOSR = entryBCI != JVMCICompiler.INVOCATION_ENTRY_BCI;
    StructuredGraph graph = method.isNative() || isOSR ? null : getIntrinsicGraph(method, providers, compilationId, options, debug);

    if (graph == null) {
        SpeculationLog speculationLog = method.getSpeculationLog();
        if (speculationLog != null) {
            speculationLog.collectFailedSpeculations();
        }
        graph = new StructuredGraph.Builder(options, debug, AllowAssumptions.ifTrue(OptAssumptions.getValue(options))).method(method).entryBCI(entryBCI).speculationLog(
                        speculationLog).useProfilingInfo(useProfilingInfo).compilationId(compilationId).build();
    }
    return graph;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
private StructuredGraph(String name,
                ResolvedJavaMethod method,
                int entryBCI,
                Assumptions assumptions,
                SpeculationLog speculationLog,
                boolean useProfilingInfo,
                CompilationIdentifier compilationId,
                OptionValues options,
                Cancellable cancellable) {
    super(name, options);
    this.setStart(add(new StartNode()));
    this.rootMethod = method;
    this.graphId = uniqueGraphIds.incrementAndGet();
    this.compilationId = compilationId;
    this.entryBCI = entryBCI;
    this.assumptions = assumptions;
    this.speculationLog = speculationLog;
    this.useProfilingInfo = useProfilingInfo;
    this.cancellable = cancellable;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public SpeculationLog getSpeculationLog() {
    Map<Long, SpeculationLog> map = SpeculationLogs.get(holder.mirror());
    synchronized (map) {
        SpeculationLog log = map.get(this.metaspaceMethod);
        if (log == null) {
            log = new HotSpotSpeculationLog();
            map.put(metaspaceMethod, log);
        }
        return log;
    }
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public InstalledCode installCode(ResolvedJavaMethod method, CompiledCode compiledCode, InstalledCode installedCode, SpeculationLog log, boolean isDefault) {
    InstalledCode resultInstalledCode;
    if (installedCode == null) {
        if (method == null) {
            // Must be a stub
            resultInstalledCode = new HotSpotRuntimeStub(((HotSpotCompiledCode) compiledCode).getName());
        } else {
            resultInstalledCode = new HotSpotNmethod((HotSpotResolvedJavaMethod) method, ((HotSpotCompiledCode) compiledCode).getName(), isDefault);
        }
    } else {
        resultInstalledCode = installedCode;
    }

    HotSpotSpeculationLog speculationLog = (log != null && log.hasSpeculations()) ? (HotSpotSpeculationLog) log : null;

    int result = runtime.getCompilerToVM().installCode(target, (HotSpotCompiledCode) compiledCode, resultInstalledCode, speculationLog);
    if (result != config.codeInstallResultOk) {
        String resultDesc = config.getCodeInstallResultDescription(result);
        if (compiledCode instanceof HotSpotCompiledNmethod) {
            HotSpotCompiledNmethod compiledNmethod = (HotSpotCompiledNmethod) compiledCode;
            String msg = compiledNmethod.getInstallationFailureMessage();
            if (msg != null) {
                msg = String.format("Code installation failed: %s%n%s", resultDesc, msg);
            } else {
                msg = String.format("Code installation failed: %s", resultDesc);
            }
            if (result == config.codeInstallResultDependenciesInvalid) {
                throw new AssertionError(resultDesc + " " + msg);
            }
            throw new BailoutException(result != config.codeInstallResultDependenciesFailed, msg);
        } else {
            throw new BailoutException("Error installing %s: %s", ((HotSpotCompiledCode) compiledCode).getName(), resultDesc);
        }
    }
    return logOrDump(resultInstalledCode, compiledCode);
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public CompilationResult compile(ResolvedJavaMethod method, int entryBCI, boolean useProfilingInfo, CompilationIdentifier compilationId, OptionValues options) {
    HotSpotBackend backend = graalRuntime.getHostBackend();
    HotSpotProviders providers = backend.getProviders();
    final boolean isOSR = entryBCI != JVMCICompiler.INVOCATION_ENTRY_BCI;
    StructuredGraph graph = method.isNative() || isOSR ? null : getIntrinsicGraph(method, providers, compilationId, options);

    if (graph == null) {
        SpeculationLog speculationLog = method.getSpeculationLog();
        if (speculationLog != null) {
            speculationLog.collectFailedSpeculations();
        }
        graph = new StructuredGraph.Builder(options, AllowAssumptions.ifTrue(OptAssumptions.getValue(options))).method(method).entryBCI(entryBCI).speculationLog(
                        speculationLog).useProfilingInfo(useProfilingInfo).compilationId(compilationId).build();
    }

    Suites suites = getSuites(providers, options);
    LIRSuites lirSuites = getLIRSuites(providers, options);
    ProfilingInfo profilingInfo = useProfilingInfo ? method.getProfilingInfo(!isOSR, isOSR) : DefaultProfilingInfo.get(TriState.FALSE);
    OptimisticOptimizations optimisticOpts = getOptimisticOpts(profilingInfo, options);

    /*
     * Cut off never executed code profiles if there is code, e.g. after the osr loop, that is
     * never executed.
     */
    if (isOSR && !OnStackReplacementPhase.Options.DeoptAfterOSR.getValue(options)) {
        optimisticOpts.remove(Optimization.RemoveNeverExecutedCode);
    }
    CompilationResult result = new CompilationResult();
    result.setEntryBCI(entryBCI);
    boolean shouldDebugNonSafepoints = providers.getCodeCache().shouldDebugNonSafepoints();
    PhaseSuite<HighTierContext> graphBuilderSuite = configGraphBuilderSuite(providers.getSuites().getDefaultGraphBuilderSuite(), shouldDebugNonSafepoints, isOSR);
    GraalCompiler.compileGraph(graph, method, providers, backend, graphBuilderSuite, optimisticOpts, profilingInfo, suites, lirSuites, result, CompilationResultBuilderFactory.Default);

    if (!isOSR && useProfilingInfo) {
        ProfilingInfo profile = profilingInfo;
        profile.setCompilerIRSize(StructuredGraph.class, graph.getNodeCount());
    }

    return result;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
/**
 * @see #createInstalledCode(DebugContext, ResolvedJavaMethod, CompilationRequest,
 *      CompilationResult, SpeculationLog, InstalledCode, boolean, Object[])
 */
public InstalledCode createInstalledCode(DebugContext debug, ResolvedJavaMethod method, CompilationResult compilationResult,
                SpeculationLog speculationLog, InstalledCode predefinedInstalledCode, boolean isDefault) {
    return createInstalledCode(debug, method, null, compilationResult, speculationLog, predefinedInstalledCode, isDefault, null);
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public SpeculationLog getSpeculationLog() {
    return speculationLog;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public Builder speculationLog(SpeculationLog log) {
    this.speculationLog = log;
    return this;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
protected SpeculationLog getSpeculationLog() {
    return null;
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
@Override
protected Map<Long, SpeculationLog> computeValue(java.lang.Class<?> type) {
    return new HashMap<>(4);
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
public SpeculationLog createSpeculationLog() {
    return new HotSpotSpeculationLog();
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
/**
 * @see #createInstalledCode(ResolvedJavaMethod, CompilationRequest, CompilationResult,
 *      SpeculationLog, InstalledCode, boolean)
 */
public InstalledCode createInstalledCode(ResolvedJavaMethod method, CompilationResult compilationResult,
                SpeculationLog speculationLog, InstalledCode predefinedInstalledCode, boolean isDefault) {
    return createInstalledCode(method, null, compilationResult, speculationLog, predefinedInstalledCode, isDefault);
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
@Override
public SpeculationLog createSpeculationLog() {
    return new HotSpotSpeculationLog();
}
 

import jdk.vm.ci.meta.SpeculationLog; //导入依赖的package包/类
protected synchronized SpeculationLog getSpeculationLog() {
    if (speculationLog == null) {
        speculationLog = ((GraalTruffleRuntime) Truffle.getRuntime()).createSpeculationLog();
    }
    return speculationLog;
}