clazz) {
if (ENABLED) {
for (Object o : context()) {
if (clazz.isInstance(o)) {
return ((T) o);
}
}
}
return null;
}
/**
* Creates a {@linkplain DebugMemUseTracker memory use tracker} that is enabled iff debugging is
* {@linkplain #isEnabled() enabled}.
*
* A disabled tracker has virtually no overhead.
*/
public static DebugMemUseTracker memUseTracker(CharSequence name) {
if (!isUnconditionalMemUseTrackingEnabled && !ENABLED) {
return VOID_MEM_USE_TRACKER;
}
return createMemUseTracker("%s", name, null);
}
/**
* Creates a debug memory use tracker. Invoking this method is equivalent to:
*
*
* Debug.memUseTracker(format, arg, null)
*
*
* except that the string formatting only happens if mem tracking is enabled.
*
* @see #counter(String, Object, Object)
*/
public static DebugMemUseTracker memUseTracker(String format, Object arg) {
if (!isUnconditionalMemUseTrackingEnabled && !ENABLED) {
return VOID_MEM_USE_TRACKER;
}
return createMemUseTracker(format, arg, null);
}
/**
* Creates a debug memory use tracker. Invoking this method is equivalent to:
*
*
* Debug.memUseTracker(String.format(format, arg1, arg2))
*
*
* except that the string formatting only happens if memory use tracking is enabled. In
* addition, each argument is subject to the following type based conversion before being passed
* as an argument to {@link String#format(String, Object...)}:
*
*
* Type | Conversion
* ------------------+-----------------
* java.lang.Class | arg.getSimpleName()
* |
*
*
* @see #memUseTracker(CharSequence)
*/
public static DebugMemUseTracker memUseTracker(String format, Object arg1, Object arg2) {
if (!isUnconditionalMemUseTrackingEnabled && !ENABLED) {
return VOID_MEM_USE_TRACKER;
}
return createMemUseTracker(format, arg1, arg2);
}
private static DebugMemUseTracker createMemUseTracker(String format, Object arg1, Object arg2) {
String name = formatDebugName(format, arg1, arg2);
return DebugValueFactory.createMemUseTracker(name, !isUnconditionalMemUseTrackingEnabled);
}
/**
* Creates a {@linkplain DebugCounter counter} that is enabled iff debugging is
* {@linkplain #isEnabled() enabled} or the system property whose name is formed by adding
* {@value #ENABLE_COUNTER_PROPERTY_NAME_PREFIX} to {@code name} is
* {@linkplain Boolean#getBoolean(String) true}. If the latter condition is true, then the
* returned counter is {@linkplain DebugCounter#isConditional() unconditional} otherwise it is
* conditional.
*
* A disabled counter has virtually no overhead.
*/
public static DebugCounter counter(CharSequence name) {
if (!areUnconditionalCountersEnabled() && !ENABLED) {
return VOID_COUNTER;
}
return createCounter("%s", name, null);
}
/**
* Creates a {@link DebugMethodMetrics metric} that is enabled iff debugging is
* {@link #isEnabled() enabled}.
*/
public static DebugMethodMetrics methodMetrics(ResolvedJavaMethod method) {
if (isMethodMeterEnabled() && method != null) {
return MethodMetricsImpl.getMethodMetrics(method);
}
return VOID_MM;
}
public static String applyFormattingFlagsAndWidth(String s, int flags, int width) {
if (flags == 0 && width < 0) {
return s;
}
StringBuilder sb = new StringBuilder(s);
// apply width and justification
int len = sb.length();
if (len < width) {
for (int i = 0; i < width - len; i++) {
if ((flags & LEFT_JUSTIFY) == LEFT_JUSTIFY) {
sb.append(' ');
} else {
sb.insert(0, ' ');
}
}
}
String res = sb.toString();
if ((flags & UPPERCASE) == UPPERCASE) {
res = res.toUpperCase();
}
return res;
}
/**
* Creates a debug counter. Invoking this method is equivalent to:
*
*
* Debug.counter(format, arg, null)
*
*
* except that the string formatting only happens if count is enabled.
*
* @see #counter(String, Object, Object)
*/
public static DebugCounter counter(String format, Object arg) {
if (!areUnconditionalCountersEnabled() && !ENABLED) {
return VOID_COUNTER;
}
return createCounter(format, arg, null);
}
/**
* Creates a debug counter. Invoking this method is equivalent to:
*
*
* Debug.counter(String.format(format, arg1, arg2))
*
*
* except that the string formatting only happens if count is enabled. In addition, each
* argument is subject to the following type based conversion before being passed as an argument
* to {@link String#format(String, Object...)}:
*
*
* Type | Conversion
* ------------------+-----------------
* java.lang.Class | arg.getSimpleName()
* |
*
*
* @see #counter(CharSequence)
*/
public static DebugCounter counter(String format, Object arg1, Object arg2) {
if (!areUnconditionalCountersEnabled() && !ENABLED) {
return VOID_COUNTER;
}
return createCounter(format, arg1, arg2);
}
private static DebugCounter createCounter(String format, Object arg1, Object arg2) {
String name = formatDebugName(format, arg1, arg2);
boolean conditional = enabledCounters == null || !findMatch(enabledCounters, enabledCountersSubstrings, name);
if (!ENABLED && conditional) {
return VOID_COUNTER;
}
return DebugValueFactory.createCounter(name, conditional);
}
/**
* Changes the debug configuration for the current thread.
*
* @param config new configuration to use for the current thread
* @return an object that when {@linkplain DebugConfigScope#close() closed} will restore the
* debug configuration for the current thread to what it was before this method was
* called
*/
public static DebugConfigScope setConfig(DebugConfig config) {
if (ENABLED) {
return new DebugConfigScope(config);
} else {
return null;
}
}
/**
* Creates an object for counting value frequencies.
*/
public static DebugHistogram createHistogram(String name) {
return new DebugHistogramImpl(name);
}
public static DebugConfig silentConfig() {
return fixedConfig(0, 0, false, false, false, false, false, Collections. emptyList(), Collections. emptyList(), null);
}
public static DebugConfig fixedConfig(final int logLevel, final int dumpLevel, final boolean isCountEnabled, final boolean isMemUseTrackingEnabled, final boolean isTimerEnabled,
final boolean isVerifyEnabled, final boolean isMMEnabled, final Collection dumpHandlers, final Collection verifyHandlers,
final PrintStream output) {
return new DebugConfig() {
@Override
public int getLogLevel() {
return logLevel;
}
@Override
public boolean isLogEnabledForMethod() {
return logLevel > 0;
}
@Override
public boolean isCountEnabled() {
return isCountEnabled;
}
@Override
public boolean isMemUseTrackingEnabled() {
return isMemUseTrackingEnabled;
}
@Override
public int getDumpLevel() {
return dumpLevel;
}
@Override
public boolean isDumpEnabledForMethod() {
return dumpLevel > 0;
}
@Override
public boolean isVerifyEnabled() {
return isVerifyEnabled;
}
@Override
public boolean isVerifyEnabledForMethod() {
return isVerifyEnabled;
}
@Override
public boolean isMethodMeterEnabled() {
return isMMEnabled;
}
@Override
public boolean isTimeEnabled() {
return isTimerEnabled;
}
@Override
public RuntimeException interceptException(Throwable e) {
return null;
}
@Override
public Collection dumpHandlers() {
return dumpHandlers;
}
@Override
public Collection verifyHandlers() {
return verifyHandlers;
}
@Override
public PrintStream output() {
return output;
}
@Override
public void addToContext(Object o) {
}
@Override
public void removeFromContext(Object o) {
}
};
}
private static final DebugCounter VOID_COUNTER = new DebugCounter() {
@Override
public void increment() {
}
@Override
public void add(long value) {
}
@Override
public void setConditional(boolean flag) {
throw new InternalError("Cannot make void counter conditional");
}
@Override
public boolean isConditional() {
return false;
}
@Override
public long getCurrentValue() {
return 0L;
}
};
private static final DebugMethodMetrics VOID_MM = new DebugMethodMetrics() {
@Override
public void addToMetric(long value, String metricName) {
}
@Override
public void addToMetric(long value, String format, Object arg1) {
}
@Override
public void addToMetric(long value, String format, Object arg1, Object arg2) {
}
@Override
public void addToMetric(long value, String format, Object arg1, Object arg2, Object arg3) {
}
@Override
public void incrementMetric(String metricName) {
}
@Override
public void incrementMetric(String format, Object arg1) {
}
@Override
public void incrementMetric(String format, Object arg1, Object arg2) {
}
@Override
public void incrementMetric(String format, Object arg1, Object arg2, Object arg3) {
}
@Override
public long getCurrentMetricValue(String metricName) {
return 0;
}
@Override
public long getCurrentMetricValue(String format, Object arg1) {
return 0;
}
@Override
public long getCurrentMetricValue(String format, Object arg1, Object arg2) {
return 0;
}
@Override
public long getCurrentMetricValue(String format, Object arg1, Object arg2, Object arg3) {
return 0;
}
@Override
public ResolvedJavaMethod getMethod() {
return null;
}
};
private static final DebugMemUseTracker VOID_MEM_USE_TRACKER = new DebugMemUseTracker() {
@Override
public DebugCloseable start() {
return DebugCloseable.VOID_CLOSEABLE;
}
@Override
public long getCurrentValue() {
return 0;
}
};
/**
* @see #timer(CharSequence)
*/
public static final String ENABLE_TIMER_PROPERTY_NAME_PREFIX = "graaldebug.timer.";
/**
* @see #counter(CharSequence)
*/
public static final String ENABLE_COUNTER_PROPERTY_NAME_PREFIX = "graaldebug.counter.";
/**
* Set of unconditionally enabled counters. Possible values and their meanings:
*
* - {@code null}: no unconditionally enabled counters
* - {@code isEmpty()}: all counters are unconditionally enabled
* - {@code !isEmpty()}: use {@link #findMatch(Set, Set, String)} on this set and
* {@link #enabledCountersSubstrings} to determine which counters are unconditionally enabled
*
*
*/
private static final Set enabledCounters;
/**
* Set of unconditionally enabled timers. Same interpretation of values as for
* {@link #enabledCounters}.
*/
private static final Set enabledTimers;
private static final Set enabledCountersSubstrings = new HashSet<>();
private static final Set enabledTimersSubstrings = new HashSet<>();
/**
* Specifies if all mem use trackers are unconditionally enabled.
*/
private static final boolean isUnconditionalMemUseTrackingEnabled;
static {
Set counters = new HashSet<>();
Set timers = new HashSet<>();
parseCounterAndTimerSystemProperties(counters, timers, enabledCountersSubstrings, enabledTimersSubstrings);
counters = counters.isEmpty() && enabledCountersSubstrings.isEmpty() ? null : counters;
timers = timers.isEmpty() && enabledTimersSubstrings.isEmpty() ? null : timers;
if (counters == null && params.enableUnscopedCounters && !params.enableMethodFilter) {
counters = Collections.emptySet();
}
if (timers == null && params.enableUnscopedTimers && !params.enableMethodFilter) {
timers = Collections.emptySet();
}
enabledCounters = counters;
enabledTimers = timers;
isUnconditionalMemUseTrackingEnabled = params.enableUnscopedMemUseTrackers;
DebugValueFactory = initDebugValueFactory();
}
private static DebugValueFactory initDebugValueFactory() {
return new DebugValueFactory() {
@Override
public DebugTimer createTimer(String name, boolean conditional) {
return new TimerImpl(name, conditional, params.interceptTime);
}
@Override
public DebugCounter createCounter(String name, boolean conditional) {
return CounterImpl.create(name, conditional, params.interceptCount);
}
@Override
public DebugMethodMetrics createMethodMetrics(ResolvedJavaMethod method) {
return MethodMetricsImpl.getMethodMetrics(method);
}
@Override
public DebugMemUseTracker createMemUseTracker(String name, boolean conditional) {
return new MemUseTrackerImpl(name, conditional, params.interceptMem);
}
};
}
private static DebugValueFactory DebugValueFactory;
public static void setDebugValueFactory(DebugValueFactory factory) {
Objects.requireNonNull(factory);
DebugValueFactory = factory;
}
public static DebugValueFactory getDebugValueFactory() {
return DebugValueFactory;
}
private static boolean findMatch(Set haystack, Set haystackSubstrings, String needle) {
if (haystack.isEmpty() && haystackSubstrings.isEmpty()) {
// Empty haystack means match all
return true;
}
if (haystack.contains(needle)) {
return true;
}
if (!haystackSubstrings.isEmpty()) {
for (String h : haystackSubstrings) {
if (needle.startsWith(h)) {
return true;
}
}
}
return false;
}
public static boolean areUnconditionalTimersEnabled() {
return enabledTimers != null;
}
public static boolean areUnconditionalCountersEnabled() {
return enabledCounters != null;
}
public static boolean isMethodFilteringEnabled() {
return params.enableMethodFilter;
}
public static boolean areUnconditionalMethodMetricsEnabled() {
// we do not collect mm substrings
return params.enableUnscopedMethodMetrics;
}
protected static void parseCounterAndTimerSystemProperties(Set counters, Set timers, Set countersSubstrings, Set timersSubstrings) {
do {
try {
for (Map.Entry e : System.getProperties().entrySet()) {
String name = e.getKey().toString();
if (name.startsWith(ENABLE_COUNTER_PROPERTY_NAME_PREFIX) && Boolean.parseBoolean(e.getValue().toString())) {
if (name.endsWith("*")) {
countersSubstrings.add(name.substring(ENABLE_COUNTER_PROPERTY_NAME_PREFIX.length(), name.length() - 1));
} else {
counters.add(name.substring(ENABLE_COUNTER_PROPERTY_NAME_PREFIX.length()));
}
}
if (name.startsWith(ENABLE_TIMER_PROPERTY_NAME_PREFIX) && Boolean.parseBoolean(e.getValue().toString())) {
if (name.endsWith("*")) {
timersSubstrings.add(name.substring(ENABLE_TIMER_PROPERTY_NAME_PREFIX.length(), name.length() - 1));
} else {
timers.add(name.substring(ENABLE_TIMER_PROPERTY_NAME_PREFIX.length()));
}
}
}
return;
} catch (ConcurrentModificationException e) {
// Iterating over the system properties may race with another thread that is
// updating the system properties. Simply try again in this case.
}
} while (true);
}
/**
* Creates a {@linkplain DebugTimer timer} that is enabled iff debugging is
* {@linkplain #isEnabled() enabled} or the system property whose name is formed by adding
* {@value #ENABLE_TIMER_PROPERTY_NAME_PREFIX} to {@code name} is
* {@linkplain Boolean#getBoolean(String) true}. If the latter condition is true, then the
* returned timer is {@linkplain DebugCounter#isConditional() unconditional} otherwise it is
* conditional.
*
* A disabled timer has virtually no overhead.
*/
public static DebugTimer timer(CharSequence name) {
if (!areUnconditionalTimersEnabled() && !ENABLED) {
return VOID_TIMER;
}
return createTimer("%s", name, null);
}
/**
* Creates a debug timer. Invoking this method is equivalent to:
*
*
* Debug.timer(format, arg, null)
*
*
* except that the string formatting only happens if timing is enabled.
*
* @see #timer(String, Object, Object)
*/
public static DebugTimer timer(String format, Object arg) {
if (!areUnconditionalTimersEnabled() && !ENABLED) {
return VOID_TIMER;
}
return createTimer(format, arg, null);
}
/**
* Creates a debug timer. Invoking this method is equivalent to:
*
*
* Debug.timer(String.format(format, arg1, arg2))
*
*
* except that the string formatting only happens if timing is enabled. In addition, each
* argument is subject to the following type based conversion before being passed as an argument
* to {@link String#format(String, Object...)}:
*
*
* Type | Conversion
* ------------------+-----------------
* java.lang.Class | arg.getSimpleName()
* |
*
*
* @see #timer(CharSequence)
*/
public static DebugTimer timer(String format, Object arg1, Object arg2) {
if (!areUnconditionalTimersEnabled() && !ENABLED) {
return VOID_TIMER;
}
return createTimer(format, arg1, arg2);
}
/**
* There are paths where construction of formatted class names are common and the code below is
* surprisingly expensive, so compute it once and cache it.
*/
private static final ClassValue formattedClassName = new ClassValue() {
@Override
protected String computeValue(Class c) {
final String simpleName = c.getSimpleName();
Class enclosingClass = c.getEnclosingClass();
if (enclosingClass != null) {
String prefix = "";
while (enclosingClass != null) {
prefix = enclosingClass.getSimpleName() + "_" + prefix;
enclosingClass = enclosingClass.getEnclosingClass();
}
return prefix + simpleName;
} else {
return simpleName;
}
}
};
public static Object convertFormatArg(Object arg) {
if (arg instanceof Class) {
return formattedClassName.get((Class) arg);
}
return arg;
}
private static String formatDebugName(String format, Object arg1, Object arg2) {
return String.format(format, convertFormatArg(arg1), convertFormatArg(arg2));
}
private static DebugTimer createTimer(String format, Object arg1, Object arg2) {
String name = formatDebugName(format, arg1, arg2);
boolean conditional = enabledTimers == null || !findMatch(enabledTimers, enabledTimersSubstrings, name);
if (!ENABLED && conditional) {
return VOID_TIMER;
}
return DebugValueFactory.createTimer(name, conditional);
}
private static final DebugTimer VOID_TIMER = new DebugTimer() {
@Override
public DebugCloseable start() {
return DebugCloseable.VOID_CLOSEABLE;
}
@Override
public void setConditional(boolean flag) {
throw new InternalError("Cannot make void timer conditional");
}
@Override
public boolean isConditional() {
return false;
}
@Override
public long getCurrentValue() {
return 0L;
}
@Override
public TimeUnit getTimeUnit() {
return null;
}
};
}