Support resetting STATISTIC() values using llvm::ResetStatistics()

[dsanders]

Summary

Most of the time, compiler statistics can be obtained using a process that
performs a single compilation and terminates such as llc. However, this isn't
always the case. JITs for example, perform multiple compilations over their
lifetime and STATISTIC() will record cumulative values across all of them.

Provide tools like this with the facilities needed to measure individual
compilations by allowing them to reset the STATISTIC() values back to zero using
llvm::ResetStatistics(). It's still the tools responsibility to ensure that they
perform compilations in such a way that the results are meaningful to their
intended use.

[bogner]

unittests/ADT/StatisticTest.cpp

26

Isn't S.first a StringRef? Why do we need a std::string here for the comparison?

152–154

Why bother even calling it if we're not testing anything?

[dsanders]

unittests/ADT/StatisticTest.cpp

26

It was a const char * at one point. I'll fix this.

152–154

I was on the fence about calling it. I decided to leave it there since it at least confirms that it doesn't crash.

[dsanders]

Remove unnecessary std::string constructor

[bogner]

LGTM

include/llvm/ADT/Statistic.h

 /// 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.
 const std::vector<std::pair<StringRef, unsigned>> GetStatistics();
 
+/// \brief 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

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<const Statistic*> Stats;
+  std::vector<Statistic*> 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<const Statistic *>::const_iterator;
+  using const_iterator = std::vector<Statistic *>::const_iterator;
 
   StatisticInfo();
   ~StatisticInfo();
 
-  void addStatistic(const Statistic *S) {
+  void addStatistic(Statistic *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.
std::stable_sort(Stats.begin(), Stats.end(),
 
     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
+  // the value.
+  for (auto *Stat : Stats) {
+    // Value updates to a statistic that complete before this statement in the
+    // iteration for that statistic will be lost as intended.
+    Stat->Initialized = false;
+    Stat->Value = 0;
+  }
+
+  // Clear the registration list and release the lock once we're done. Any
+  // pending updates from other threads will safely take effect after we return.
+  // That might not be what the user wants if they're measuring a compilation
+  // but it's their responsibility to prevent concurrent compilations to make
+  // a single compilation measurable.
+  Stats.clear();
+}
+
 void llvm::PrintStatistics(raw_ostream &OS) {
   StatisticInfo &Stats = *StatInfo;
 
   // Figure out how long the biggest Value and Name fields are.
   unsigned MaxDebugTypeLen = 0, MaxValLen = 0;
   for (size_t i = 0, e = Stats.Stats.size(); i != e; ++i) {
     MaxValLen = std::max(MaxValLen,
                          (unsigned)utostr(Stats.Stats[i]->getValue()).size());

 const std::vector<std::pair<StringRef, unsigned>> llvm::GetStatistics() {
   sys::SmartScopedLock<true> Reader(*StatLock);
   std::vector<std::pair<StringRef, unsigned>> ReturnStats;
 
   for (const auto &Stat : StatInfo->statistics())
     ReturnStats.emplace_back(Stat->getName(), Stat->getValue());
   return ReturnStats;
 }
+
+void llvm::ResetStatistics() {
+  StatInfo->reset();
+}

unittests/ADT/StatisticTest.cpp

 //===- llvm/unittest/ADT/StatisticTest.cpp - Statistic unit tests ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
+using OptionalStatistic = Optional<std::pair<StringRef, unsigned>>;
+
 namespace {
 #define DEBUG_TYPE "unittest"
 STATISTIC(Counter, "Counts things");
 STATISTIC(Counter2, "Counts other things");
 
+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;
+    if (S.first == "Counter2")
+      S2 = S;
+  }
+}
+
 TEST(StatisticTest, Count) {
   EnableStatistics();
 
   Counter = 0;
   EXPECT_EQ(Counter, 0u);
   Counter++;
   Counter++;
 #if LLVM_ENABLE_STATS
TEST(StatisticTest, API) {
   Counter++;
 #if LLVM_ENABLE_STATS
   EXPECT_EQ(Counter, 2u);
 #else
   EXPECT_EQ(Counter, 0u);
 #endif
 
 #if LLVM_ENABLE_STATS
+  {
     const auto Range1 = GetStatistics();
     EXPECT_NE(Range1.begin(), Range1.end());
     EXPECT_EQ(Range1.begin() + 1, Range1.end());
 
-  Optional<std::pair<StringRef, unsigned>> S1;
-  Optional<std::pair<StringRef, unsigned>> S2;
-  for (const auto &S : Range1) {
-    if (std::string(S.first) == "Counter")
-      S1 = S;
-    if (std::string(S.first) == "Counter2")
-      S2 = S;
-  }
+    OptionalStatistic S1;
+    OptionalStatistic S2;
+    extractCounters(Range1, S1, S2);
 
-  EXPECT_NE(S1.hasValue(), false);
+    EXPECT_EQ(S1.hasValue(), true);
     EXPECT_EQ(S2.hasValue(), false);
+  }
 
   // Counter2 will be registered when it's first touched.
   Counter2++;
 
-  const auto Range2 = GetStatistics();
-  EXPECT_NE(Range2.begin(), Range2.end());
-  EXPECT_EQ(Range2.begin() + 2, Range2.end());
-
-  S1 = None;
-  S2 = None;
-  for (const auto &S : Range2) {
-    if (std::string(S.first) == "Counter")
-      S1 = S;
-    if (std::string(S.first) == "Counter2")
-      S2 = S;
-  }
+  {
+    const auto Range = GetStatistics();
+    EXPECT_NE(Range.begin(), Range.end());
+    EXPECT_EQ(Range.begin() + 2, Range.end());
+
+    OptionalStatistic S1;
+    OptionalStatistic S2;
+    extractCounters(Range, S1, S2);
 
-  EXPECT_NE(S1.hasValue(), false);
-  EXPECT_NE(S2.hasValue(), false);
+    EXPECT_EQ(S1.hasValue(), true);
+    EXPECT_EQ(S2.hasValue(), true);
 
     EXPECT_EQ(S1->first, "Counter");
     EXPECT_EQ(S1->second, 2u);
 
     EXPECT_EQ(S2->first, "Counter2");
     EXPECT_EQ(S2->second, 1u);
+  }
 #else
   Counter2++;
   auto &Range = GetStatistics();
   EXPECT_EQ(Range.begin(), Range.end());
 #endif
+
+#if LLVM_ENABLE_STATS
+  // Check that resetting the statistics works correctly.
+  // It should empty the list and zero the counters.
+  ResetStatistics();
+  {
+    auto &Range = GetStatistics();
+    EXPECT_EQ(Range.begin(), Range.end());
+    EXPECT_EQ(Counter, 0u);
+    EXPECT_EQ(Counter2, 0u);
+    OptionalStatistic S1;
+    OptionalStatistic S2;
+    extractCounters(Range, S1, S2);
+    EXPECT_EQ(S1.hasValue(), false);
+    EXPECT_EQ(S2.hasValue(), false);
+  }
+
+  // Now check that they successfully re-register and count.
+  Counter++;
+  Counter2++;
+
+  {
+    auto &Range = GetStatistics();
+    EXPECT_EQ(Range.begin() + 2, Range.end());
+    EXPECT_EQ(Counter, 1u);
+    EXPECT_EQ(Counter2, 1u);
+
+    OptionalStatistic S1;
+    OptionalStatistic S2;
+    extractCounters(Range, S1, S2);
+
+    EXPECT_EQ(S1.hasValue(), true);
+    EXPECT_EQ(S2.hasValue(), true);
+
+    EXPECT_EQ(S1->first, "Counter");
+    EXPECT_EQ(S1->second, 1u);
+
+    EXPECT_EQ(S2->first, "Counter2");
+    EXPECT_EQ(S2->second, 1u);
+  }
+#else
+  // No need to test the output ResetStatistics(), there's nothing to reset so
+  // we can't tell if it failed anyway.
+  ResetStatistics();
+#endif
 }
 
 } // end anonymous namespace