[Stats] Add ALWAYS_ENABLED_STATISTIC enabled regardless of LLVM_ENABLE_STATS.

[vsapsai]

Summary

The intended usage is to measure relatively expensive operations. So the
cost of the statistic is negligible compared to the cost of a measured
operation and can be enabled all the time without impairing the
compilation time.

The change in clang is an example of where ALWAYS_ENABLED_STATISTIC can be
used. I'm also planning to add more stats for header search and modules.

rdar://problem/55715134

[vsapsai]

On release build with assertions disabled and LLVM_ENABLE_STATS being 0 the impact on the compile time is the following

Metric: compile_time

Program                                        output0jM4H6 output_KEgWj diff  
 test-suite...tTests/2003-05-07-VarArgs.test     0.03         0.02       -25.2%
 test-suite...sts/2003-05-31-CastToBool.test     0.02         0.02       22.1% 
 test-suite...ing-flt/Equivalencing-flt.test     0.61         0.73       20.7% 
 test-suite...s/2009-12-07-StructReturn.test     0.02         0.02       17.1% 
 test-suite...ts/2003-07-06-IntOverflow.test     0.02         0.02       17.0% 
 test-suite...ts/block-copied-in-cxxobj.test     0.03         0.03       16.2% 
 test-suite...e/UnitTests/ObjC/messages.test     0.03         0.04       15.9% 
 test-suite...r-algebra/kernels/2mm/2mm.test     0.08         0.06       -14.7%
 test-suite.../instance-method-metadata.test     0.37         0.42       14.0% 
 test-suite...ource/UnitTests/printargs.test     0.02         0.02       12.4% 
 test-suite...itTests/2003-05-26-Shorts.test     0.02         0.02       -12.2%
 test-suite...-06-20-StaticBitfieldInit.test     0.02         0.02       12.2% 
 test-suite...tTests/2002-05-03-NotTest.test     0.02         0.02       11.5% 
 test-suite...tTests/C++11/stdthreadbug.test     0.28         0.26       -10.3%
 test-suite...e/Benchmarks/Misc/flops-7.test     0.03         0.02       -10.2%
 Geomean difference                                                       nan% 
       output0jM4H6  output_KEgWj        diff
count  542.000000    542.000000    424.000000
mean   0.550511      0.547688     -0.001379  
std    2.215555      2.205268      0.045026  
min    0.000000      0.000000     -0.252280  
25%    0.015875      0.016725     -0.021092  
50%    0.040950      0.040000     -0.000875  
75%    0.350750      0.355700      0.017304  
max    30.343300     30.326700     0.220588

To me it looks that the change in compile time is within the noise.

[dsanders]

LGTM

llvm/include/llvm/ADT/Statistic.h

47

Do we actually need the common base class? I'm thinking that since NoopStatistic never registers (and can't because the interfaces to do so changed to TrackingStatistic*), then there's a good chance that nothing reads DebugType, Name, Desc, Value, Initialized and we might be able to save a little memory by eliminating them.

[vsapsai]

• Address review comments.

[vsapsai]

Thanks for the review.

llvm/include/llvm/ADT/Statistic.h

47

Good point. I've tried to remove the common base class but we are reading Name and Desc at least in [FusionCandidate::reportInvalidCandidate](https://github.com/llvm/llvm-project/blob/d6e9e99cec95c83293c68d3b30534e34f53a1923/llvm/lib/Transforms/Scalar/LoopFuse.cpp#L339-L342) and [reportLoopFusion](https://github.com/llvm/llvm-project/blob/d6e9e99cec95c83293c68d3b30534e34f53a1923/llvm/lib/Transforms/Scalar/LoopFuse.cpp#L1326-L1331). So I've made StatisticBase to store only DebugType, Name, Desc and moved Value and Initialized to TrackingStatistic. It saves a little bit of memory and makes NoopStatistic::getValue() cheaper as we don't touch atomic.

llvm/include/llvm/ADT/Statistic.h

 #endif
 
 namespace llvm {
 
 class raw_ostream;
 class raw_fd_ostream;
 class StringRef;
 
-class Statistic {
+class StatisticBase {
 public:
   const char *DebugType;
   const char *Name;
   const char *Desc;
-  std::atomic<unsigned> Value;
-  std::atomic<bool> Initialized;
 
-  unsigned getValue() const { return Value.load(std::memory_order_relaxed); }
+  StatisticBase(const char *DebugType, const char *Name, const char *Desc)
+      : DebugType(DebugType), Name(Name), Desc(Desc) {}
+
   const char *getDebugType() const { return DebugType; }
   const char *getName() const { return Name; }
   const char *getDesc() const { return Desc; }
+};
 
-  /// construct - This should only be called for non-global statistics.
-  void construct(const char *debugtype, const char *name, const char *desc) {
-    DebugType = debugtype;
-    Name = name;
-    Desc = desc;
-    Value = 0;
-    Initialized = false;
-  }
+class TrackingStatistic : public StatisticBase {
+public:
+  std::atomic<unsigned> Value;
+  std::atomic<bool> Initialized;
+
+  TrackingStatistic(const char *DebugType, const char *Name, const char *Desc)
+      : StatisticBase(DebugType, Name, Desc), Value(0), Initialized(false) {}
+
+  unsigned getValue() const { return Value.load(std::memory_order_relaxed); }
 
   // Allow use of this class as the value itself.
   operator unsigned() const { return getValue(); }
 
-#if LLVM_ENABLE_STATS
-   const Statistic &operator=(unsigned Val) {
+  const TrackingStatistic &operator=(unsigned Val) {
     Value.store(Val, std::memory_order_relaxed);
     return init();
   }
 
-  const Statistic &operator++() {
+  const TrackingStatistic &operator++() {
     Value.fetch_add(1, std::memory_order_relaxed);
     return init();
   }
 
   unsigned operator++(int) {
     init();
     return Value.fetch_add(1, std::memory_order_relaxed);
   }
 
-  const Statistic &operator--() {
+  const TrackingStatistic &operator--() {
     Value.fetch_sub(1, std::memory_order_relaxed);
     return init();
   }
 
   unsigned operator--(int) {
     init();
     return Value.fetch_sub(1, std::memory_order_relaxed);
   }
 
-  const Statistic &operator+=(unsigned V) {
+  const TrackingStatistic &operator+=(unsigned V) {
     if (V == 0)
       return *this;
     Value.fetch_add(V, std::memory_order_relaxed);
     return init();
   }
 
-  const Statistic &operator-=(unsigned V) {
+  const TrackingStatistic &operator-=(unsigned V) {
     if (V == 0)
       return *this;
     Value.fetch_sub(V, std::memory_order_relaxed);
     return init();
   }
 
   void updateMax(unsigned V) {
     unsigned 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();
   }
 
-#else  // Statistics are disabled in release builds.
-
-  const Statistic &operator=(unsigned Val) {
+protected:
+  TrackingStatistic &init() {
+    if (!Initialized.load(std::memory_order_acquire))
+      RegisterStatistic();
     return *this;
   }
 
-  const Statistic &operator++() {
-    return *this;
-  }
+  void RegisterStatistic();
+};
 
-  unsigned operator++(int) {
-    return 0;
-  }
+class NoopStatistic : public StatisticBase {
+public:
+  using StatisticBase::StatisticBase;
 
-  const Statistic &operator--() {
-    return *this;
-  }
+  unsigned getValue() const { return 0; }
 
-  unsigned operator--(int) {
-    return 0;
-  }
+  // Allow use of this class as the value itself.
+  operator unsigned() const { return 0; }
 
-  const Statistic &operator+=(const unsigned &V) {
-    return *this;
-  }
+  const NoopStatistic &operator=(unsigned Val) { return *this; }
 
-  const Statistic &operator-=(const unsigned &V) {
-    return *this;
-  }
+  const NoopStatistic &operator++() { return *this; }
 
-  void updateMax(unsigned V) {}
+  unsigned operator++(int) { return 0; }
 
-#endif  // LLVM_ENABLE_STATS
+  const NoopStatistic &operator--() { return *this; }
 
-protected:
-  Statistic &init() {
-    if (!Initialized.load(std::memory_order_acquire))
-      RegisterStatistic();
-    return *this;
-  }
+  unsigned operator--(int) { return 0; }
 
-  void RegisterStatistic();
+  const NoopStatistic &operator+=(const unsigned &V) { return *this; }
+
+  const NoopStatistic &operator-=(const unsigned &V) { return *this; }
+
+  void updateMax(unsigned 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, {0}, {false}}
+  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 PrintOnExit = true);
 
 /// Check if statistics are enabled.
 bool AreStatisticsEnabled();
 
 /// Return a file stream to print our output on.

llvm/lib/Support/Statistic.cpp

 
 namespace {
 /// This class is used in a ManagedStatic so that it is created on demand (when
 /// the first statistic is bumped) and destroyed only when llvm_shutdown is
 /// called. We print statistics from the destructor.
 /// This class is also used to look up statistic values from applications that
 /// use LLVM.
 class StatisticInfo {
-  std::vector<Statistic*> Stats;
+  std::vector<TrackingStatistic *> Stats;
 
   friend void llvm::PrintStatistics();
   friend void llvm::PrintStatistics(raw_ostream &OS);
   friend void llvm::PrintStatisticsJSON(raw_ostream &OS);
 
   /// Sort statistics by debugtype,name,description.
   void sort();
 public:
-  using const_iterator = std::vector<Statistic *>::const_iterator;
+  using const_iterator = std::vector<TrackingStatistic *>::const_iterator;
 
   StatisticInfo();
   ~StatisticInfo();
 
-  void addStatistic(Statistic *S) {
-    Stats.push_back(S);
-  }
+  void addStatistic(TrackingStatistic *S) { Stats.push_back(S); }
 
   const_iterator begin() const { return Stats.begin(); }
   const_iterator end() const { return Stats.end(); }
   iterator_range<const_iterator> statistics() const {
     return {begin(), end()};
   }
 
   void reset();
 };
 } // end anonymous namespace
 
 static ManagedStatic<StatisticInfo> StatInfo;
 static ManagedStatic<sys::SmartMutex<true> > StatLock;
 
 /// RegisterStatistic - The first time a statistic is bumped, this method is
 /// called.
-void Statistic::RegisterStatistic() {
+void TrackingStatistic::RegisterStatistic() {
   // If stats are enabled, inform StatInfo that this statistic should be
   // printed.
   // llvm_shutdown calls destructors while holding the ManagedStatic mutex.
   // These destructors end up calling PrintStatistics, which takes StatLock.
   // Since dereferencing StatInfo and StatLock can require taking the
   // ManagedStatic mutex, doing so with StatLock held would lead to a lock
   // order inversion. To avoid that, we dereference the ManagedStatics first,
   // and only take StatLock afterwards.
void llvm::EnableStatistics(bool PrintOnExit) {
   ::PrintOnExit = PrintOnExit;
 }
 
 bool llvm::AreStatisticsEnabled() {
   return Enabled || Stats;
 }
 
 void StatisticInfo::sort() {
-  llvm::stable_sort(Stats, [](const Statistic *LHS, const Statistic *RHS) {
+  llvm::stable_sort(
+      Stats, [](const TrackingStatistic *LHS, const TrackingStatistic *RHS) {
         if (int Cmp = std::strcmp(LHS->getDebugType(), RHS->getDebugType()))
           return Cmp < 0;
 
         if (int Cmp = std::strcmp(LHS->getName(), RHS->getName()))
           return Cmp < 0;
 
         return std::strcmp(LHS->getDesc(), RHS->getDesc()) < 0;
       });
 }
 
 void StatisticInfo::reset() {
   sys::SmartScopedLock<true> Writer(*StatLock);
 
   // Tell each statistic that it isn't registered so it has to register
   // again. We're holding the lock so it won't be able to do so until we're
   // finished. Once we've forced it to re-register (after we return), then zero
void llvm::PrintStatisticsJSON(raw_ostream &OS) {
   sys::SmartScopedLock<true> Reader(*StatLock);
   StatisticInfo &Stats = *StatInfo;
 
   Stats.sort();
 
   // Print all of the statistics.
   OS << "{\n";
   const char *delim = "";
-  for (const Statistic *Stat : Stats.Stats) {
+  for (const TrackingStatistic *Stat : Stats.Stats) {
     OS << delim;
     assert(yaml::needsQuotes(Stat->getDebugType()) == yaml::QuotingType::None &&
            "Statistic group/type name is simple.");
     assert(yaml::needsQuotes(Stat->getName()) == yaml::QuotingType::None &&
            "Statistic name is simple");
     OS << "\t\"" << Stat->getDebugType() << '.' << Stat->getName() << "\": "
        << Stat->getValue();
     delim = ",\n";

llvm/unittests/ADT/StatisticTest.cpp

 using namespace llvm;
 
 using OptionalStatistic = Optional<std::pair<StringRef, unsigned>>;
 
 namespace {
 #define DEBUG_TYPE "unittest"
 STATISTIC(Counter, "Counts things");
 STATISTIC(Counter2, "Counts other things");
+ALWAYS_ENABLED_STATISTIC(AlwaysCounter, "Counts things always");
 
 #if LLVM_ENABLE_STATS
 static void
 extractCounters(const std::vector<std::pair<StringRef, unsigned>> &Range,
                 OptionalStatistic &S1, OptionalStatistic &S2) {
   for (const auto &S : Range) {
     if (S.first == "Counter")
       S1 = S;
TEST(StatisticTest, Count) {
   EXPECT_EQ(Counter, 0u);
   Counter++;
   Counter++;
 #if LLVM_ENABLE_STATS
   EXPECT_EQ(Counter, 2u);
 #else
   EXPECT_EQ(Counter, 0u);
 #endif
+
+  AlwaysCounter = 0;
+  EXPECT_EQ(AlwaysCounter, 0u);
+  AlwaysCounter++;
+  ++AlwaysCounter;
+  EXPECT_EQ(AlwaysCounter, 2u);
 }
 
 TEST(StatisticTest, Assign) {
   EnableStatistics();
 
   Counter = 2;
 #if LLVM_ENABLE_STATS
   EXPECT_EQ(Counter, 2u);
 #else
   EXPECT_EQ(Counter, 0u);
 #endif
+
+  AlwaysCounter = 2;
+  EXPECT_EQ(AlwaysCounter, 2u);
 }
 
 TEST(StatisticTest, API) {
   EnableStatistics();
 
   Counter = 0;
   EXPECT_EQ(Counter, 0u);
   Counter++;