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;
+ }
+ };
+}