EIC code displayed by LXR master/​include/​llvm/​ADT/​Statistic.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:09

 //===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines the 'Statistic' class, which is designed to be an easy way
 /// to expose various metrics from passes.  These statistics are printed at the
 /// end of a run (from llvm_shutdown), when the -stats command line option is
 /// passed on the command line.
 ///
 /// This is useful for reporting information like the number of instructions
 /// simplified, optimized or removed by various transformations, like this:
 ///
 /// static Statistic NumInstsKilled("gcse", "Number of instructions killed");
 ///
 /// Later, in the code: ++NumInstsKilled;
 ///
 /// NOTE: Statistics *must* be declared as global variables.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STATISTIC_H
 #define LLVM_ADT_STATISTIC_H
 
 #include "llvm/Config/llvm-config.h"
 #include <atomic>
 #include <memory>
 #include <vector>
 
 // Determine whether statistics should be enabled. We must do it here rather
 // than in CMake because multi-config generators cannot determine this at
 // configure time.
 #if !defined(NDEBUG) || LLVM_FORCE_ENABLE_STATS
 #define LLVM_ENABLE_STATS 1
 #else
 #define LLVM_ENABLE_STATS 0
 #endif
 
 namespace llvm {
 
 class raw_ostream;
 class raw_fd_ostream;
 class StringRef;
 
 class TrackingStatistic {
 public:
   const char *const DebugType;
   const char *const Name;
   const char *const Desc;
 
   std::atomic<uint64_t> Value;
   std::atomic<bool> Initialized;
 
   constexpr TrackingStatistic(const char *DebugType, const char *Name,
                               const char *Desc)
       : DebugType(DebugType), Name(Name), Desc(Desc), Value(0),
         Initialized(false) {}
 
   const char *getDebugType() const { return DebugType; }
   const char *getName() const { return Name; }
   const char *getDesc() const { return Desc; }
 
   uint64_t getValue() const { return Value.load(std::memory_order_relaxed); }
 
   // Allow use of this class as the value itself.
   operator uint64_t() const { return getValue(); }
 
   const TrackingStatistic &operator=(uint64_t Val) {
     Value.store(Val, std::memory_order_relaxed);
     return init();
   }
 
   const TrackingStatistic &operator++() {
     Value.fetch_add(1, std::memory_order_relaxed);
     return init();
   }
 
   uint64_t operator++(int) {
     init();
     return Value.fetch_add(1, std::memory_order_relaxed);
   }
 
   const TrackingStatistic &operator--() {
     Value.fetch_sub(1, std::memory_order_relaxed);
     return init();
   }
 
   uint64_t operator--(int) {
     init();
     return Value.fetch_sub(1, std::memory_order_relaxed);
   }
 
   const TrackingStatistic &operator+=(uint64_t V) {
     if (V == 0)
       return *this;
     Value.fetch_add(V, std::memory_order_relaxed);
     return init();
   }
 
   const TrackingStatistic &operator-=(uint64_t V) {
     if (V == 0)
       return *this;
     Value.fetch_sub(V, std::memory_order_relaxed);
     return init();
   }
 
   void updateMax(uint64_t V) {
     uint64_t PrevMax = Value.load(std::memory_order_relaxed);
     // Keep trying to update max until we succeed or another thread produces
     // a bigger max than us.
     while (V > PrevMax && !Value.compare_exchange_weak(
                               PrevMax, V, std::memory_order_relaxed)) {
     }
     init();
   }
 
 protected:
   TrackingStatistic &init() {
     if (!Initialized.load(std::memory_order_acquire))
       RegisterStatistic();
     return *this;
   }
 
   void RegisterStatistic();
 };
 
 class NoopStatistic {
 public:
   NoopStatistic(const char * /*DebugType*/, const char * /*Name*/,
                 const char * /*Desc*/) {}
 
   uint64_t getValue() const { return 0; }
 
   // Allow use of this class as the value itself.
   operator uint64_t() const { return 0; }
 
   const NoopStatistic &operator=(uint64_t Val) { return *this; }
 
   const NoopStatistic &operator++() { return *this; }
 
   uint64_t operator++(int) { return 0; }
 
   const NoopStatistic &operator--() { return *this; }
 
   uint64_t operator--(int) { return 0; }
 
   const NoopStatistic &operator+=(const uint64_t &V) { return *this; }
 
   const NoopStatistic &operator-=(const uint64_t &V) { return *this; }
 
   void updateMax(uint64_t V) {}
 };
 
 #if LLVM_ENABLE_STATS
 using Statistic = TrackingStatistic;
 #else
 using Statistic = NoopStatistic;
 #endif
 
 // STATISTIC - A macro to make definition of statistics really simple.  This
 // automatically passes the DEBUG_TYPE of the file into the statistic.
 #define STATISTIC(VARNAME, DESC)                                               \
   static llvm::Statistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 // ALWAYS_ENABLED_STATISTIC - A macro to define a statistic like STATISTIC but
 // it is enabled even if LLVM_ENABLE_STATS is off.
 #define ALWAYS_ENABLED_STATISTIC(VARNAME, DESC)                                \
   static llvm::TrackingStatistic VARNAME = {DEBUG_TYPE, #VARNAME, DESC}
 
 /// Enable the collection and printing of statistics.
 void EnableStatistics(bool DoPrintOnExit = true);
 
 /// Check if statistics are enabled.
 bool AreStatisticsEnabled();
 
 /// Return a stream to print our output on.
 std::unique_ptr<raw_ostream> CreateInfoOutputFile();
 
 /// Print statistics to the file returned by CreateInfoOutputFile().
 void PrintStatistics();
 
 /// Print statistics to the given output stream.
 void PrintStatistics(raw_ostream &OS);
 
 /// Print statistics in JSON format. This does include all global timers (\see
 /// Timer, TimerGroup). Note that the timers are cleared after printing and will
 /// not be printed in human readable form or in a second call of
 /// PrintStatisticsJSON().
 void PrintStatisticsJSON(raw_ostream &OS);
 
 /// Get the statistics. This can be used to look up the value of
 /// statistics without needing to parse JSON.
 ///
 /// This function does not prevent statistics being updated by other threads
 /// during it's execution. It will return the value at the point that it is
 /// read. However, it will prevent new statistics from registering until it
 /// completes.
 std::vector<std::pair<StringRef, uint64_t>> GetStatistics();
 
 /// Reset the statistics. This can be used to zero and de-register the
 /// statistics in order to measure a compilation.
 ///
 /// When this function begins to call destructors prior to returning, all
 /// statistics will be zero and unregistered. However, that might not remain the
 /// case by the time this function finishes returning. Whether update from other
 /// threads are lost or merely deferred until during the function return is
 /// timing sensitive.
 ///
 /// Callers who intend to use this to measure statistics for a single
 /// compilation should ensure that no compilations are in progress at the point
 /// this function is called and that only one compilation executes until calling
 /// GetStatistics().
 void ResetStatistics();
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_STATISTIC_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team