/*

 * Copyright (c) 2012, 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.

 *

 * 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 org.graalvm.compiler.debug;

import static java.util.FormattableFlags.LEFT_JUSTIFY;

import static java.util.FormattableFlags.UPPERCASE;

import static org.graalvm.compiler.debug.DebugOptions.Count;

import static org.graalvm.compiler.debug.DebugOptions.Counters;

import static org.graalvm.compiler.debug.DebugOptions.Dump;

import static org.graalvm.compiler.debug.DebugOptions.DumpOnError;

import static org.graalvm.compiler.debug.DebugOptions.DumpOnPhaseChange;

import static org.graalvm.compiler.debug.DebugOptions.ListMetrics;

import static org.graalvm.compiler.debug.DebugOptions.Log;

import static org.graalvm.compiler.debug.DebugOptions.MemUseTrackers;

import static org.graalvm.compiler.debug.DebugOptions.MethodFilter;

import static org.graalvm.compiler.debug.DebugOptions.Time;

import static org.graalvm.compiler.debug.DebugOptions.Timers;

import static org.graalvm.compiler.debug.DebugOptions.TrackMemUse;

import static org.graalvm.compiler.debug.DebugOptions.Verify;

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.Paths;

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.List;

import java.util.Map;

import java.util.SortedMap;

import java.util.TreeMap;

import org.graalvm.compiler.options.OptionKey;

import org.graalvm.compiler.options.OptionValues;

import org.graalvm.util.EconomicMap;

import org.graalvm.util.EconomicSet;

import org.graalvm.util.Pair;

import jdk.vm.ci.meta.JavaMethod;

/**

 * 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 {

    public static final Description NO_DESCRIPTION = null;

    public static final GlobalMetrics NO_GLOBAL_METRIC_VALUES = null;

    public static final Iterable<DebugHandlersFactory> NO_CONFIG_CUSTOMIZERS = Collections.emptyList();

    public static final PrintStream DEFAULT_LOG_STREAM = TTY.out;

    /**

     * 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;

    DebugConfig currentConfig;

    ScopeImpl currentScope;

    CloseableCounter currentTimer;

    CloseableCounter currentMemUseTracker;

    Scope lastClosedScope;

    Throwable lastExceptionThrown;

    /**

     * Stores the {@link MetricKey} values.

     */

    private long[] metricValues;

    /**

     * Determines if dynamic scopes are enabled.

     */

    public boolean areScopesEnabled() {

        return immutable.scopesEnabled;

    }

    /**

     * 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<String> unscopedCounters;

        /**

         * Names of unscoped timers. A timer is unscoped if this set is empty or contains the

         * timer's name.

         */

        final EconomicSet<String> 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<String> unscopedMemUseTrackers;

        private static EconomicSet<String> parseUnscopedMetricSpec(String spec, boolean unconditional, boolean accumulatedKey) {

            EconomicSet<String> 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<String> option, OptionValues options) {

            return option.getValue(options) != null && !option.getValue(options).isEmpty();

        }

        private Immutable(OptionValues options) {

            this.options = options;

            this.unscopedCounters = parseUnscopedMetricSpec(Counters.getValue(options), "".equals(Count.getValue(options)), false);

            this.unscopedTimers = parseUnscopedMetricSpec(Timers.getValue(options), "".equals(Time.getValue(options)), true);

            this.unscopedMemUseTrackers = parseUnscopedMetricSpec(MemUseTrackers.getValue(options), "".equals(TrackMemUse.getValue(options)), true);

            this.scopesEnabled = DumpOnError.getValue(options) ||

                            Dump.getValue(options) != null ||

                            Log.getValue(options) != null ||

                            isNotEmpty(DebugOptions.Count, options) ||

                            isNotEmpty(DebugOptions.Time, options) ||

                            isNotEmpty(DebugOptions.TrackMemUse, options) ||

                            DumpOnPhaseChange.getValue(options) != null;

            this.listMetrics = 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<DebugContext> {

    }

    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;

    }

    /**

     * Shared object used to represent a disabled debug context.

     */

    public static final DebugContext DISABLED = new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, new Immutable(), 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 class Description {

        /**

         * The primary input to the computation.

         */

        final Object compilable;

        /**

         * A runtime based identifier that is most likely to be unique.

         */

        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;

        }

    }

    private final Description description;

    /**

     * Gets a description of the computation associated with this debug context.

     *

     * @return {@code null} if no description is available

     */

    public Description getDescription() {

        return description;

    }

    /**

     * Gets the global metrics associated with this debug context.

     *

     * @return {@code null} if no global metrics are available

     */

    public GlobalMetrics getGlobalMetrics() {

        return globalMetrics;

    }

    /**

     * Creates a {@link DebugContext} based on a given set of option values and {@code factory}.

     */

    public static DebugContext create(OptionValues options, DebugHandlersFactory factory) {

        return new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, Immutable.create(options), Collections.singletonList(factory));

    }

    /**

     * Creates a {@link DebugContext} based on a given set of option values and {@code factories}.

     * The {@link DebugHandlersFactory#LOADER} can be used for the latter.

     */

    public static DebugContext create(OptionValues options, Iterable<DebugHandlersFactory> factories) {

        return new DebugContext(NO_DESCRIPTION, NO_GLOBAL_METRIC_VALUES, DEFAULT_LOG_STREAM, Immutable.create(options), factories);

    }

    /**

     * Creates a {@link DebugContext}.

     */

    public static DebugContext create(OptionValues options, Description description, GlobalMetrics globalMetrics, PrintStream logStream, Iterable<DebugHandlersFactory> factories) {

        return new DebugContext(description, globalMetrics, logStream, Immutable.create(options), factories);

    }

    private DebugContext(Description description, GlobalMetrics globalMetrics, PrintStream logStream, Immutable immutable, Iterable<DebugHandlersFactory> factories) {

        this.immutable = immutable;

        this.description = description;

        this.globalMetrics = globalMetrics;

        if (immutable.scopesEnabled) {

            OptionValues options = immutable.options;

            List<DebugDumpHandler> dumpHandlers = new ArrayList<>();

            List<DebugVerifyHandler> 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;

                        verifyHandlers.add((DebugVerifyHandler) handler);

                    }

                }

            }

            currentConfig = new DebugConfigImpl(

                            options,

                            Log.getValue(options),

                            Count.getValue(options),

                            TrackMemUse.getValue(options),

                            Time.getValue(options),

                            Dump.getValue(options),

                            Verify.getValue(options),

                            MethodFilter.getValue(options),

                            logStream, dumpHandlers, verifyHandlers);

            currentScope = new ScopeImpl(this, Thread.currentThread());

            currentScope.updateFlags(currentConfig);

            metricsEnabled = true;

        } else {

            metricsEnabled = immutable.hasUnscopedMetrics() || immutable.listMetrics;

        }

    }

    /**

     * 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 for any {@link JavaMethod} in the current scope.

     *

     * @see DebugContext#verify(Object, String)

     */

    public boolean isVerifyEnabledForMethod() {

        if (currentScope == null) {

            return false;

        }

        if (currentConfig == null) {

            return false;

        }

        return currentConfig.isVerifyEnabledForMethod(currentScope);

    }

    /**

     * 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 isTimeEnabled() {

        return currentScope != null && currentScope.isTimeEnabled();

    }

    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);

    }

    /**

     * 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.

     * <p>

     * It is recommended to use the try-with-resource statement for managing entering and leaving