llvm/mlir/lib/Support/Timing.cpp

//===- Timing.cpp - Execution time measurement facilities -----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Facilities to measure and provide statistics on execution time.
//
//===----------------------------------------------------------------------===//

#include "mlir/Support/Timing.h"
#include "mlir/Support/ThreadLocalCache.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/RWMutex.h"
#include "llvm/Support/Threading.h"
#include "llvm/Support/raw_ostream.h"

#include <atomic>
#include <chrono>
#include <optional>

usingnamespacemlir;
usingnamespacedetail;
DisplayMode;
OutputFormat;

constexpr llvm::StringLiteral kTimingDescription = …;

//===----------------------------------------------------------------------===//
// TimingManager
//===----------------------------------------------------------------------===//

namespace mlir {
namespace detail {
/// Private implementation details of the `TimingManager`.
class TimingManagerImpl { … };
} // namespace detail
} // namespace mlir

TimingManager::TimingManager() : … { … }

TimingManager::~TimingManager() = default;

/// Get the root timer of this timing manager.
Timer TimingManager::getRootTimer() { … }

/// Get the root timer of this timing manager wrapped in a `TimingScope`.
TimingScope TimingManager::getRootScope() { … }

//===----------------------------------------------------------------------===//
// Identifier uniquing
//===----------------------------------------------------------------------===//

/// Return an identifier for the specified string.
TimingIdentifier TimingIdentifier::get(StringRef str, TimingManager &tm) { … }

//===----------------------------------------------------------------------===//
// Helpers for time record printing
//===----------------------------------------------------------------------===//

namespace {

class OutputTextStrategy : public OutputStrategy { … };

class OutputJsonStrategy : public OutputStrategy { … };

} // namespace

//===----------------------------------------------------------------------===//
// Timer Implementation for DefaultTimingManager
//===----------------------------------------------------------------------===//

namespace {

/// A timer used to sample execution time.
///
/// Separately tracks wall time and user time to account for parallel threads of
/// execution. Timers are intended to be started and stopped multiple times.
/// Each start and stop will add to the timer's wall and user time.
class TimerImpl { … };

} // namespace

//===----------------------------------------------------------------------===//
// DefaultTimingManager
//===----------------------------------------------------------------------===//

namespace mlir {
namespace detail {

/// Implementation details of the `DefaultTimingManager`.
class DefaultTimingManagerImpl { … };

} // namespace detail
} // namespace mlir

DefaultTimingManager::DefaultTimingManager()
    : … { … }

DefaultTimingManager::~DefaultTimingManager() { … }

/// Enable or disable execution time sampling.
void DefaultTimingManager::setEnabled(bool enabled) { … }

/// Return whether execution time sampling is enabled.
bool DefaultTimingManager::isEnabled() const { … }

/// Change the display mode.
void DefaultTimingManager::setDisplayMode(DisplayMode displayMode) { … }

/// Return the current display mode;
DefaultTimingManager::DisplayMode DefaultTimingManager::getDisplayMode() const { … }

/// Change the stream where the output will be printed to.
void DefaultTimingManager::setOutput(std::unique_ptr<OutputStrategy> output) { … }

/// Print and clear the timing results.
void DefaultTimingManager::print() { … }

/// Clear the timing results.
void DefaultTimingManager::clear() { … }

/// Debug print the timer data structures to an output stream.
void DefaultTimingManager::dumpTimers(raw_ostream &os) { … }

/// Debug print the timers as a list.
void DefaultTimingManager::dumpAsList(raw_ostream &os) { … }

/// Debug print the timers as a tree.
void DefaultTimingManager::dumpAsTree(raw_ostream &os) { … }

std::optional<void *> DefaultTimingManager::rootTimer() { … }

void DefaultTimingManager::startTimer(void *handle) { … }

void DefaultTimingManager::stopTimer(void *handle) { … }

void *DefaultTimingManager::nestTimer(void *handle, const void *id,
                                      function_ref<std::string()> nameBuilder) { … }

void DefaultTimingManager::hideTimer(void *handle) { … }

//===----------------------------------------------------------------------===//
// DefaultTimingManager Command Line Options
//===----------------------------------------------------------------------===//

namespace {
struct DefaultTimingManagerOptions { … };
} // namespace

static llvm::ManagedStatic<DefaultTimingManagerOptions> options;

void mlir::registerDefaultTimingManagerCLOptions() { … }

void mlir::applyDefaultTimingManagerCLOptions(DefaultTimingManager &tm) { … }