jdk.graal.compiler.debug.DebugContext Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of compiler Show documentation
Show all versions of compiler Show documentation
The GraalVM compiler and the Graal-truffle optimizer.
/*
* Copyright (c) 2012, 2023, 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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 jdk.graal.compiler.debug;
import static java.util.FormattableFlags.LEFT_JUSTIFY;
import static java.util.FormattableFlags.UPPERCASE;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Formatter;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.function.Supplier;
import org.graalvm.collections.EconomicMap;
import org.graalvm.collections.EconomicSet;
import org.graalvm.collections.Pair;
import jdk.graal.compiler.graphio.GraphOutput;
import jdk.graal.compiler.options.OptionKey;
import jdk.graal.compiler.options.OptionValues;
import jdk.graal.compiler.serviceprovider.GraalServices;
import jdk.vm.ci.common.NativeImageReinitialize;
import jdk.vm.ci.meta.JavaMethod;
import jdk.vm.ci.meta.ResolvedJavaMethod;
/**
* A facility for logging and dumping as well as a container for values associated with
* {@link MetricKey}s.
*
* A {@code DebugContext} object must only be used on the thread that created it. This means it
* needs to be passed around as a parameter. For convenience, it can be encapsulated in a widely
* used object that is in scope wherever a {@code DebugContext} is needed. However, care must be
* taken when such objects can be exposed to multiple threads (e.g., they are in a non-thread-local
* cache).
*/
public final class DebugContext implements AutoCloseable {
/**
* The format of the message printed on the console by {@link #getDumpPath} when
* {@link DebugOptions#ShowDumpFiles} is true. The {@code %s} placeholder is replaced with the
* absolute path of the dump file (i.e. the value returned by the method).
*/
public static final String DUMP_FILE_MESSAGE_FORMAT = "Dumping debug output to '%s'";
/**
* The regular expression for matching the message derived from
* {@link #DUMP_FILE_MESSAGE_FORMAT}.
*
* Keep in sync with the {@code catch_files} array in {@code ci/common.jsonnet}.
*/
public static final String DUMP_FILE_MESSAGE_REGEXP = "Dumping debug output to '(?[^']+)'";
public static final Description NO_DESCRIPTION = new Description(null, "NO_DESCRIPTION");
public static final GlobalMetrics NO_GLOBAL_METRIC_VALUES = null;
public static final Iterable NO_CONFIG_CUSTOMIZERS = Collections.emptyList();
/**
* Contains the immutable parts of a debug context. This separation allows the immutable parts
* to be shared and reduces the overhead of initialization since most immutable fields are
* configured by parsing options.
*/
final Immutable immutable;
/**
* Determines whether metrics are enabled.
*/
boolean metricsEnabled;
/**
* Determines whether debug context was closed.
*/
boolean closed;
/**
* Set to true during a retry compilation in case of a compilation error.
*/
boolean inRetryCompilation;
DebugConfigImpl currentConfig;
ScopeImpl currentScope;
CloseableCounter currentTimer;
CloseableCounter currentMemUseTracker;
Scope lastClosedScope;
Throwable lastExceptionThrown;
/**
* Lazily initialized IGV channel used for {@linkplain #buildOutput dumping a graph} associated
* with this context.
*/
private IgvDumpChannel igvChannel;
/**
* An existing object for graph dumping whose IGV channel and other internals can be shared with
* newly {@linkplain #buildOutput created} graph dumping objects.
*/
private GraphOutput prototypeOutput;
/**
* Stores the {@link MetricKey} values.
*/
private long[] metricValues;
public static PrintStream getDefaultLogStream() {
// The PrintStream in the TTY#out field cannot be used because it does not respect current
// thread TTY.Filter. We have to use TTY#out(), which returns a LogStream that respects
// current thread TTY.filter. Truffle uses TTY.Filter to redirect Graal logging into engine
// logger.
return TTY.out().out();
}
/**
* Determines if dynamic scopes are enabled.
*/
public boolean areScopesEnabled() {
return immutable.scopesEnabled;
}
/**
* Gets an object for describing a graph and sending it to IGV.
*/
public GraphOutput buildOutput(GraphOutput.Builder builder) throws IOException {
if (prototypeOutput != null) {
return builder.build(prototypeOutput);
} else {
if (igvChannel == null) {
igvChannel = new IgvDumpChannel(() -> getDumpPath(".bgv", false), immutable.options);
}
builder.attr(GraphOutput.ATTR_VM_ID, GraalServices.getExecutionID());
final GraphOutput output = builder.build(igvChannel);
prototypeOutput = output;
return output;
}
}
/**
* Adds version properties to the provided map. The version properties are read at a start of
* the JVM from a JVM specific location. Each property identifiers a commit of a certain
* component in the system. The properties added to the {@code properties} map are prefixed with
* {@code "version."} prefix.
*
* @param properties map to add the version properties to or {@code null}
* @return {@code properties} with version properties added or an unmodifiable map containing
* the version properties if {@code properties == null}
*/
public static Map addVersionProperties(Map properties) {
return Versions.VERSIONS.withVersions(properties);
}
/**
* The immutable configuration that can be shared between {@link DebugContext} objects.
*/
static final class Immutable {
private static final Immutable[] CACHE = new Immutable[5];
/**
* The options from which this object was configured.
*/
final OptionValues options;
/**
* Specifies if dynamic scopes are enabled.
*/
final boolean scopesEnabled;
final boolean listMetrics;
/**
* Names of unscoped counters. A counter is unscoped if this set is empty or contains the
* counter's name.
*/
final EconomicSet unscopedCounters;
/**
* Names of unscoped timers. A timer is unscoped if this set is empty or contains the
* timer's name.
*/
final EconomicSet unscopedTimers;
/**
* Names of unscoped memory usage trackers. A memory usage tracker is unscoped if this set
* is empty or contains the memory usage tracker's name.
*/
final EconomicSet unscopedMemUseTrackers;
private static EconomicSet parseUnscopedMetricSpec(String spec, boolean unconditional, boolean accumulatedKey) {
EconomicSet res;
if (spec == null) {
if (!unconditional) {
res = null;
} else {
res = EconomicSet.create();
}
} else {
res = EconomicSet.create();
if (!spec.isEmpty()) {
if (!accumulatedKey) {
res.addAll(Arrays.asList(spec.split(",")));
} else {
for (String n : spec.split(",")) {
res.add(n + AccumulatedKey.ACCUMULATED_KEY_SUFFIX);
res.add(n + AccumulatedKey.FLAT_KEY_SUFFIX);
}
}
}
}
return res;
}
static Immutable create(OptionValues options) {
int i = 0;
while (i < CACHE.length) {
Immutable immutable = CACHE[i];
if (immutable == null) {
break;
}
if (immutable.options == options) {
return immutable;
}
i++;
}
Immutable immutable = new Immutable(options);
if (i < CACHE.length) {
CACHE[i] = immutable;
}
return immutable;
}
private static boolean isNotEmpty(OptionKey option, OptionValues options) {
return option.getValue(options) != null && !option.getValue(options).isEmpty();
}
private Immutable(OptionValues options) {
this.options = options;
String timeValue = DebugOptions.Time.getValue(options);
String trackMemUseValue = DebugOptions.TrackMemUse.getValue(options);
this.unscopedCounters = parseUnscopedMetricSpec(DebugOptions.Counters.getValue(options), "".equals(DebugOptions.Count.getValue(options)), false);
this.unscopedTimers = parseUnscopedMetricSpec(DebugOptions.Timers.getValue(options), "".equals(timeValue), true);
this.unscopedMemUseTrackers = parseUnscopedMetricSpec(DebugOptions.MemUseTrackers.getValue(options), "".equals(trackMemUseValue), true);
if (unscopedMemUseTrackers != null || trackMemUseValue != null) {
if (!GraalServices.isThreadAllocatedMemorySupported()) {
TTY.println("WARNING: Missing VM support for MemUseTrackers and TrackMemUse options so all reported memory usage will be 0");
}
}
this.scopesEnabled = DebugOptions.DumpOnError.getValue(options) ||
DebugOptions.Dump.getValue(options) != null ||
DebugOptions.Log.getValue(options) != null ||
isNotEmpty(DebugOptions.Count, options) ||
isNotEmpty(DebugOptions.Time, options) ||
isNotEmpty(DebugOptions.TrackMemUse, options) ||
DebugOptions.DumpOnPhaseChange.getValue(options) != null;
this.listMetrics = DebugOptions.ListMetrics.getValue(options);
}
private Immutable() {
this.options = new OptionValues(EconomicMap.create());
this.unscopedCounters = null;
this.unscopedTimers = null;
this.unscopedMemUseTrackers = null;
this.scopesEnabled = false;
this.listMetrics = false;
}
public boolean hasUnscopedMetrics() {
return unscopedCounters != null || unscopedTimers != null || unscopedMemUseTrackers != null;
}
}
/**
* Gets the options this debug context was constructed with.
*/
public OptionValues getOptions() {
return immutable.options;
}
static class Activated extends ThreadLocal {
}
private static final Activated activated = new Activated();
/**
* An object used to undo the changes made by DebugContext#activate().
*/
public static class Activation implements AutoCloseable {
private final DebugContext parent;
Activation(DebugContext parent) {
this.parent = parent;
}
@Override
public void close() {
activated.set(parent);
}
}
/**
* Activates this object as the debug context {@linkplain DebugContext#forCurrentThread for the
* current thread}. This method should be used in a try-with-resources statement.
*
* @return an object that will deactivate the debug context for the current thread when
* {@link Activation#close()} is called on it
*/
public Activation activate() {
Activation res = new Activation(activated.get());
activated.set(this);
return res;
}
/**
* Singleton used to represent a disabled debug context.
*/
private static final DebugContext DISABLED = new DebugContext(NO_DESCRIPTION, null, NO_GLOBAL_METRIC_VALUES, getDefaultLogStream(), new Immutable(), NO_CONFIG_CUSTOMIZERS);
/**
* Create a DebugContext with debugging disabled.
*/
public static DebugContext disabled(OptionValues options) {
if (options == null || options.getMap().isEmpty()) {
return DISABLED;
}
return new DebugContext(NO_DESCRIPTION, null, NO_GLOBAL_METRIC_VALUES, getDefaultLogStream(), Immutable.create(options), NO_CONFIG_CUSTOMIZERS);
}
/**
* Gets the debug context for the current thread. This should only be used when there is no
* other reasonable means to get a hold of a debug context.
*/
public static DebugContext forCurrentThread() {
DebugContext current = activated.get();
if (current == null) {
return DISABLED;
}
return current;
}
private final GlobalMetrics globalMetrics;
/**
* Describes the computation associated with a {@link DebugContext}.
*/
public static final class Description {
/**
* The primary input to the computation.
*/
final Object compilable;
/**
* A runtime based identifier that is most likely to be unique.
*/
public final String identifier;
public Description(Object compilable, String identifier) {
this.compilable = compilable;
this.identifier = identifier;
}
@Override
public String toString() {
String compilableName = compilable instanceof JavaMethod ? ((JavaMethod) compilable).format("%H.%n(%p)%R") : String.valueOf(compilable);
return identifier + ":" + compilableName;
}
String getLabel() {
if (compilable instanceof JavaMethod method) {
return method.format("%h.%n(%p)%r");
}
return String.valueOf(compilable);
}
}
private final Description description;
private final CompilationListener compilationListener;
/**
* Gets a description of the computation associated with this debug context.
*
* @return {@code null} if no description is available
*/
public Description getDescription() {
return description;
}
/**
* Determines if {@link #enterCompilerPhase} and {@link #notifyInlining} do anything.
*
* @return {@code true} if there is a listener for compiler phase and inlining events attached
* to this object, {@code false} otherwise
*/
public boolean hasCompilationListener() {
return compilationListener != null;
}
private int compilerPhaseNesting = 0;
/**
* Scope for a compiler phase event.
*/
public interface CompilerPhaseScope extends AutoCloseable {
/**
* Notifies the listener that the phase has ended.
*/
@Override
void close();
}
/**
* Notifies this object that the compiler is entering a phase.
*
* It is recommended to use this method in a try-with-resource statement.
*
* @param phaseName name of the phase being entered
* @return {@code null} if {@link #hasCompilationListener()} returns {@code false} otherwise an
* object whose {@link CompilerPhaseScope#close()} method must be called when the phase
* ends
*/
public CompilerPhaseScope enterCompilerPhase(CharSequence phaseName) {
if (compilationListener != null) {
return enterCompilerPhase(() -> phaseName);
}
return null;
}
/**
* Notifies this object that the compiler is entering a phase.
*
* It is recommended to use this method in a try-with-resource statement.
*
* @param phaseName name of the phase being entered
* @return {@code null} if {@link #hasCompilationListener()} returns {@code false} otherwise an
* object whose {@link CompilerPhaseScope#close()} method must be called when the phase
* ends
*/
public CompilerPhaseScope enterCompilerPhase(Supplier phaseName) {
CompilationListener l = compilationListener;
if (l != null) {
CompilerPhaseScope scope = l.enterPhase(phaseName.get(), compilerPhaseNesting++);
return new CompilerPhaseScope() {
@Override
public void close() {
--compilerPhaseNesting;
scope.close();
}
};
}
return null;
}
/**
* Notifies this object when the compiler considers inlining {@code callee} into {@code caller}.
* A call to this method should be guarded with {@link #hasCompilationListener()} if
* {@code message} is not a string literal or pre-computed value
*
* @param caller caller method
* @param callee callee method considered for inlining into {@code caller}
* @param succeeded true if {@code callee} was inlined into {@code caller}
* @param message extra information about inlining decision
* @param bci byte code index of call site
*/
public void notifyInlining(ResolvedJavaMethod caller, ResolvedJavaMethod callee, boolean succeeded, CharSequence message, int bci) {
if (compilationListener != null) {
compilationListener.notifyInlining(caller, callee, succeeded, message, bci);
}
}
/**
* Gets the global metrics associated with this debug context.
*
* @return {@code null} if no global metrics are available
*/
public GlobalMetrics getGlobalMetrics() {
return globalMetrics;
}
/**
* Object used to create a {@link DebugContext}.
*/
public static class Builder {
private final OptionValues options;
private Description description = NO_DESCRIPTION;
private CompilationListener compilationListener;
private GlobalMetrics globalMetrics = NO_GLOBAL_METRIC_VALUES;
private PrintStream logStream = getDefaultLogStream();
private final Iterable factories;
private boolean disabled = false;
/**
* Builder for a {@link DebugContext} based on {@code options} and
* {@link DebugHandlersFactory#LOADER}.
*/
public Builder(OptionValues options) {
this.options = options;
this.factories = DebugHandlersFactory.LOADER;
}
/**
* Builder for a {@link DebugContext} based on {@code options} and {@code factories}. The
* {@link DebugHandlersFactory#LOADER} value can be used for the latter.
*/
public Builder(OptionValues options, Iterable factories) {
this.options = options;
this.factories = factories;
}
/**
* Builder for a {@link DebugContext} based {@code options} and {@code factory}. The latter
* can be null in which case {@link DebugContext#NO_CONFIG_CUSTOMIZERS} is used.
*/
public Builder(OptionValues options, DebugHandlersFactory factory) {
this.options = options;
this.factories = factory == null ? NO_CONFIG_CUSTOMIZERS : Collections.singletonList(factory);
}
/**
* Sets the description for the debug context. The default is for a context to have no
* description.
*/
public Builder description(Description desc) {
this.description = desc;
return this;
}
/**
* Sets the compilation listener for the debug context. The default is for a context to have
* no compilation listener.
*/
public Builder compilationListener(CompilationListener listener) {
this.compilationListener = listener;
return this;
}
public Builder globalMetrics(GlobalMetrics metrics) {
this.globalMetrics = metrics;
return this;
}
public Builder logStream(PrintStream stream) {
this.logStream = stream;
return this;
}
public Builder disabled(boolean disable) {
this.disabled = disable;
return this;
}
public DebugContext build() {
return new DebugContext(description,
compilationListener,
globalMetrics,
logStream,
Immutable.create(options),
factories,
disabled);
}
}
private DebugContext(Description description,
CompilationListener compilationListener,
GlobalMetrics globalMetrics,
PrintStream logStream,
Immutable immutable,
Iterable factories) {
this(description, compilationListener, globalMetrics, logStream, immutable, factories, false);
}
private DebugContext(Description description,
CompilationListener compilationListener,
GlobalMetrics globalMetrics,
PrintStream logStream,
Immutable immutable,
Iterable factories, boolean disableConfig) {
this.immutable = immutable;
this.description = description;
this.globalMetrics = globalMetrics;
this.compilationListener = compilationListener;
if (immutable.scopesEnabled) {
OptionValues options = immutable.options;
List dumpHandlers = new ArrayList<>();
List verifyHandlers = new ArrayList<>();
for (DebugHandlersFactory factory : factories) {
for (DebugHandler handler : factory.createHandlers(options)) {
if (handler instanceof DebugDumpHandler) {
dumpHandlers.add((DebugDumpHandler) handler);
} else {
assert handler instanceof DebugVerifyHandler : handler;
verifyHandlers.add((DebugVerifyHandler) handler);
}
}
}
if (disableConfig) {
currentConfig = new DebugConfigImpl(options, null, null, null, null, null, null, null, logStream, dumpHandlers, verifyHandlers);
} else {
currentConfig = new DebugConfigImpl(options, logStream, dumpHandlers, verifyHandlers);
}
currentScope = new ScopeImpl(this, Thread.currentThread(), DebugOptions.DisableIntercept.getValue(options));
currentScope.updateFlags(currentConfig);
metricsEnabled = true;
} else {
metricsEnabled = immutable.hasUnscopedMetrics() || immutable.listMetrics;
}
}
public String getDumpPath(String extension, boolean createMissingDirectory) {
return getDumpPath(extension, createMissingDirectory, DebugOptions.ShowDumpFiles.getValue(immutable.options));
}
public String getDumpPath(String extension, boolean createMissingDirectory, boolean showDumpFiles) {
try {
String id = description == null ? null : description.identifier;
String label = description == null ? null : description.getLabel();
String prefix;
if (id == null) {
prefix = DebugOptions.DumpPath.getValue(immutable.options);
int slash = prefix.lastIndexOf(File.separatorChar);
prefix = prefix.substring(slash + 1);
} else {
prefix = id;
}
String result = PathUtilities.createUnique(DebugOptions.getDumpDirectory(immutable.options), prefix, label, extension, createMissingDirectory);
if (showDumpFiles) {
TTY.println(DUMP_FILE_MESSAGE_FORMAT, result);
}
return result;
} catch (IOException ex) {
throw rethrowSilently(RuntimeException.class, ex);
}
}
/**
* A special dump level that indicates the dumping machinery is enabled but no dumps will be
* produced except through other options.
*/
public static final int ENABLED_LEVEL = 0;
/**
* Basic debug level.
*
* For HIR dumping, only ~5 graphs per method: after parsing, after inlining, after high tier,
* after mid tier, after low tier.
*
* LIR dumping: After LIR generation, after each pre-allocation, allocation and post allocation
* stage, and after code installation.
*/
public static final int BASIC_LEVEL = 1;
/**
* Informational debug level.
*
* HIR dumping: One graph after each applied top-level phase.
*
* LIR dumping: After each applied phase.
*/
public static final int INFO_LEVEL = 2;
/**
* Verbose debug level.
*
* HIR dumping: One graph after each phase (including sub phases).
*
* LIR dumping: After each phase including sub phases.
*/
public static final int VERBOSE_LEVEL = 3;
/**
* Detailed debug level.
*
* HIR dumping: Graphs within phases where interesting for a phase, max ~5 per phase.
*
* LIR dumping: Dump CFG within phases where interesting.
*/
public static final int DETAILED_LEVEL = 4;
/**
* Very detailed debug level.
*
* HIR dumping: Graphs per node granularity graph change (before/after change).
*
* LIR dumping: Intermediate CFGs of phases where interesting.
*/
public static final int VERY_DETAILED_LEVEL = 5;
public boolean isDumpEnabled(int dumpLevel) {
return currentScope != null && currentScope.isDumpEnabled(dumpLevel);
}
/**
* Determines if verification is enabled in the current scope.
*
* @see DebugContext#verify(Object, String)
*/
public boolean isVerifyEnabled() {
return currentScope != null && currentScope.isVerifyEnabled();
}
public boolean isCountEnabled() {
return currentScope != null && currentScope.isCountEnabled();
}
public boolean isMemUseTrackingEnabled() {
return currentScope != null && currentScope.isMemUseTrackingEnabled();
}
public boolean isDumpEnabledForMethod() {
if (currentConfig == null) {
return false;
}
return currentConfig.isDumpEnabledForMethod(currentScope);
}
public boolean isLogEnabledForMethod() {
if (currentScope == null) {
return false;
}
if (currentConfig == null) {
return false;
}
return currentConfig.isLogEnabledForMethod(currentScope);
}
public boolean isLogEnabled() {
return currentScope != null && isLogEnabled(BASIC_LEVEL);
}
public boolean isLogEnabled(int logLevel) {
return currentScope != null && currentScope.isLogEnabled(logLevel);
}
/**
* Check if the current method matches the {@link DebugOptions#MethodFilter method filter} debug
* option.
*/
public boolean methodFilterMatchesCurrentMethod() {
return currentConfig != null && currentConfig.methodFilterMatchesCurrentMethod(currentScope);
}
/**
* Checks if this context is in the scope of a retry compilation.
*/
public boolean inRetryCompilation() {
return inRetryCompilation;
}
/**
* Gets a string composed of the names in the current nesting of debug
* {@linkplain #scope(Object) scopes} separated by {@code '.'}.
*/
public String getCurrentScopeName() {
if (currentScope != null) {
return currentScope.getQualifiedName();
} else {
return "";
}
}
/**
* Creates and enters a new debug scope which will be a child of the current debug scope.
*
* It is recommended to use the try-with-resource statement for managing entering and leaving
* debug scopes. For example:
*
*
* try (Scope s = Debug.scope("InliningGraph", inlineeGraph)) {
* ...
* } catch (Throwable e) {
* throw Debug.handle(e);
* }
*
*
* The {@code name} argument is subject to the following type based conversion before having
* {@link Object#toString()} called on it:
*
*
* Type | Conversion
* ------------------+-----------------
* java.lang.Class | arg.getSimpleName()
* |
*
*
* @param name the name of the new scope
* @param contextObjects an array of object to be appended to the {@linkplain #context()
* current} debug context
* @throws Throwable used to enforce a catch block.
* @return the scope entered by this method which will be exited when its {@link Scope#close()}
* method is called
*/
public DebugContext.Scope scope(Object name, Object[] contextObjects) throws Throwable {
if (currentScope != null) {
return enterScope(convertFormatArg(name).toString(), null, contextObjects);
} else {
return null;
}
}
/**
* Similar to {@link #scope(Object, Object[])} but without context objects. Therefore the catch
* block can be omitted.
*
* @see #scope(Object, Object[])
*/
public DebugContext.Scope scope(Object name) {
if (currentScope != null) {
return enterScope(convertFormatArg(name).toString(), null);
} else {
return null;
}
}
/**
* Arbitrary threads cannot be in the image so null out {@code DebugContext.invariants} which
* holds onto a thread and is only used for assertions.
*/
@NativeImageReinitialize private final Invariants invariants = Assertions.assertionsEnabled() ? new Invariants() : null;
static StackTraceElement[] getStackTrace(Thread thread) {
return thread.getStackTrace();
}
/**
* Utility for enforcing {@link DebugContext} invariants via assertions.
*/
static class Invariants {
private final Thread thread;
private final StackTraceElement[] origin;
Invariants() {
thread = Thread.currentThread();
origin = getStackTrace(thread);
}
boolean checkNoConcurrentAccess() {
Thread currentThread = Thread.currentThread();
if (currentThread != thread) {
Formatter buf = new Formatter();
buf.format("Thread local %s object was created on thread %s but is being accessed by thread %s. The most likely cause is " +
"that the object is being retrieved from a non-thread-local cache.",
DebugContext.class.getName(), thread, currentThread);
int debugContextConstructors = 0;
boolean addedHeader = false;
for (StackTraceElement e : origin) {
if (e.getMethodName().equals("") && e.getClassName().equals(DebugContext.class.getName())) {
debugContextConstructors++;
} else if (debugContextConstructors != 0) {
if (!addedHeader) {
addedHeader = true;
buf.format(" The object was instantiated here:");
}
// Distinguish from assertion stack trace by using double indent and
// "in" instead of "at" prefix.
buf.format("%n\t\tin %s", e);
}
}
if (addedHeader) {
buf.format("%n");
}
throw new AssertionError(buf.toString());
}
return true;
}
}
boolean checkNoConcurrentAccess() {
assert invariants == null || invariants.checkNoConcurrentAccess();
return true;
}
private DebugContext.Scope enterScope(CharSequence name, DebugConfig sandboxConfig, Object... newContextObjects) {
assert checkNoConcurrentAccess();
currentScope = currentScope.scope(name, sandboxConfig, newContextObjects);
return currentScope;
}
/**
* @see #scope(Object, Object[])
* @param context an object to be appended to the {@linkplain #context() current} debug context
*/
public DebugContext.Scope scope(Object name, Object context) throws Throwable {
if (currentScope != null) {
return enterScope(convertFormatArg(name).toString(), null, context);
} else {
return null;
}
}
/**
* @see #scope(Object, Object[])
* @param context1 first object to be appended to the {@linkplain #context() current} debug
* context
* @param context2 second object to be appended to the {@linkplain #context() current} debug
* context
*/
public DebugContext.Scope scope(Object name, Object context1, Object context2) throws Throwable {
if (currentScope != null) {
return enterScope(convertFormatArg(name).toString(), null, context1, context2);
} else {
return null;
}
}
/**
* @see #scope(Object, Object[])
* @param context1 first object to be appended to the {@linkplain #context() current} debug
* context
* @param context2 second object to be appended to the {@linkplain #context() current} debug
* context
* @param context3 third object to be appended to the {@linkplain #context() current} debug
* context
*/
public DebugContext.Scope scope(Object name, Object context1, Object context2, Object context3) throws Throwable {
if (currentScope != null) {
return enterScope(convertFormatArg(name).toString(), null, context1, context2, context3);
} else {
return null;
}
}
/**
* Create an unnamed scope that appends some context to the current scope.
*
* @param context an object to be appended to the {@linkplain #context() current} debug context
*/
public DebugContext.Scope withContext(Object context) {
if (currentScope != null) {
return enterScope("", null, context);
} else {
return null;
}
}
/**
* Creates and enters a new debug scope which will be disjoint from the current debug scope.
*
* It is recommended to use the try-with-resource statement for managing entering and leaving
* debug scopes. For example:
*
*
* try (Scope s = Debug.sandbox("CompilingStub", null, stubGraph)) {
* ...
* } catch (Throwable e) {
* throw Debug.handle(e);
* }
*
*
* @param name the name of the new scope
* @param config the debug configuration to use for the new scope or {@code null} to disable the
* scoping mechanism within the sandbox scope
* @param context objects to be appended to the {@linkplain #context() current} debug context
* @return the scope entered by this method which will be exited when its {@link Scope#close()}
* method is called
*/
public DebugContext.Scope sandbox(CharSequence name, DebugConfig config, Object... context) throws Throwable {
if (config == null) {
return disable();
}
if (currentScope != null) {
return enterScope(name, config, context);
} else {
return null;
}
}
/**
* Determines if scopes are enabled and this context is in a non-top-level scope.
*/
public boolean inNestedScope() {
if (immutable.scopesEnabled) {
if (currentScope == null) {
// In an active DisabledScope
return !closed;
}
return !currentScope.isTopLevel();
} else {
return false;
}
}
class DisabledScope implements DebugContext.Scope {
final boolean savedMetricsEnabled;
final ScopeImpl savedScope;
final DebugConfigImpl savedConfig;
DisabledScope() {
this.savedMetricsEnabled = metricsEnabled;
this.savedScope = currentScope;
this.savedConfig = currentConfig;
metricsEnabled = false;
currentScope = null;
currentConfig = null;
}
@Override
public String getQualifiedName() {
return "";
}
@Override
public Iterable © 2015 - 2025 Weber Informatics LLC | Privacy Policy