1 //===-- Statistic.cpp - Easy way to expose stats information --------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the 'Statistic' class, which is designed to be an easy 10 // way to expose various success metrics from passes. These statistics are 11 // printed at the end of a run, when the -stats command line option is enabled 12 // on the command line. 13 // 14 // This is useful for reporting information like the number of instructions 15 // simplified, optimized or removed by various transformations, like this: 16 // 17 // static Statistic NumInstEliminated("GCSE", "Number of instructions killed"); 18 // 19 // Later, in the code: ++NumInstEliminated; 20 // 21 //===----------------------------------------------------------------------===// 22 23 #include "llvm/ADT/Statistic.h" 24 25 #include "DebugOptions.h" 26 27 #include "llvm/ADT/StringExtras.h" 28 #include "llvm/Support/CommandLine.h" 29 #include "llvm/Support/Compiler.h" 30 #include "llvm/Support/Debug.h" 31 #include "llvm/Support/Format.h" 32 #include "llvm/Support/ManagedStatic.h" 33 #include "llvm/Support/Mutex.h" 34 #include "llvm/Support/Timer.h" 35 #include "llvm/Support/YAMLTraits.h" 36 #include "llvm/Support/raw_ostream.h" 37 #include <algorithm> 38 #include <cstring> 39 using namespace llvm; 40 41 /// -stats - Command line option to cause transformations to emit stats about 42 /// what they did. 43 /// 44 static bool EnableStats; 45 static bool StatsAsJSON; 46 static bool Enabled; 47 static bool PrintOnExit; 48 49 void llvm::initStatisticOptions() { 50 static cl::opt<bool, true> registerEnableStats{ 51 "stats", 52 cl::desc( 53 "Enable statistics output from program (available with Asserts)"), 54 cl::location(EnableStats), cl::Hidden}; 55 static cl::opt<bool, true> registerStatsAsJson{ 56 "stats-json", cl::desc("Display statistics as json data"), 57 cl::location(StatsAsJSON), cl::Hidden}; 58 } 59 60 namespace { 61 /// This class is used in a ManagedStatic so that it is created on demand (when 62 /// the first statistic is bumped) and destroyed only when llvm_shutdown is 63 /// called. We print statistics from the destructor. 64 /// This class is also used to look up statistic values from applications that 65 /// use LLVM. 66 class StatisticInfo { 67 std::vector<TrackingStatistic *> Stats; 68 69 friend void llvm::PrintStatistics(); 70 friend void llvm::PrintStatistics(raw_ostream &OS); 71 friend void llvm::PrintStatisticsJSON(raw_ostream &OS); 72 73 /// Sort statistics by debugtype,name,description. 74 void sort(); 75 public: 76 using const_iterator = std::vector<TrackingStatistic *>::const_iterator; 77 78 StatisticInfo(); 79 ~StatisticInfo(); 80 81 void addStatistic(TrackingStatistic *S) { Stats.push_back(S); } 82 83 const_iterator begin() const { return Stats.begin(); } 84 const_iterator end() const { return Stats.end(); } 85 iterator_range<const_iterator> statistics() const { 86 return {begin(), end()}; 87 } 88 89 void reset(); 90 }; 91 } // end anonymous namespace 92 93 static ManagedStatic<StatisticInfo> StatInfo; 94 static ManagedStatic<sys::SmartMutex<true> > StatLock; 95 96 /// RegisterStatistic - The first time a statistic is bumped, this method is 97 /// called. 98 void TrackingStatistic::RegisterStatistic() { 99 // If stats are enabled, inform StatInfo that this statistic should be 100 // printed. 101 // llvm_shutdown calls destructors while holding the ManagedStatic mutex. 102 // These destructors end up calling PrintStatistics, which takes StatLock. 103 // Since dereferencing StatInfo and StatLock can require taking the 104 // ManagedStatic mutex, doing so with StatLock held would lead to a lock 105 // order inversion. To avoid that, we dereference the ManagedStatics first, 106 // and only take StatLock afterwards. 107 if (!Initialized.load(std::memory_order_relaxed)) { 108 sys::SmartMutex<true> &Lock = *StatLock; 109 StatisticInfo &SI = *StatInfo; 110 sys::SmartScopedLock<true> Writer(Lock); 111 // Check Initialized again after acquiring the lock. 112 if (Initialized.load(std::memory_order_relaxed)) 113 return; 114 if (EnableStats || Enabled) 115 SI.addStatistic(this); 116 117 // Remember we have been registered. 118 Initialized.store(true, std::memory_order_release); 119 } 120 } 121 122 StatisticInfo::StatisticInfo() { 123 // Ensure that necessary timer global objects are created first so they are 124 // destructed after us. 125 TimerGroup::constructForStatistics(); 126 } 127 128 // Print information when destroyed, iff command line option is specified. 129 StatisticInfo::~StatisticInfo() { 130 if (EnableStats || PrintOnExit) 131 llvm::PrintStatistics(); 132 } 133 134 void llvm::EnableStatistics(bool DoPrintOnExit) { 135 Enabled = true; 136 PrintOnExit = DoPrintOnExit; 137 } 138 139 bool llvm::AreStatisticsEnabled() { return Enabled || EnableStats; } 140 141 void StatisticInfo::sort() { 142 llvm::stable_sort( 143 Stats, [](const TrackingStatistic *LHS, const TrackingStatistic *RHS) { 144 if (int Cmp = std::strcmp(LHS->getDebugType(), RHS->getDebugType())) 145 return Cmp < 0; 146 147 if (int Cmp = std::strcmp(LHS->getName(), RHS->getName())) 148 return Cmp < 0; 149 150 return std::strcmp(LHS->getDesc(), RHS->getDesc()) < 0; 151 }); 152 } 153 154 void StatisticInfo::reset() { 155 sys::SmartScopedLock<true> Writer(*StatLock); 156 157 // Tell each statistic that it isn't registered so it has to register 158 // again. We're holding the lock so it won't be able to do so until we're 159 // finished. Once we've forced it to re-register (after we return), then zero 160 // the value. 161 for (auto *Stat : Stats) { 162 // Value updates to a statistic that complete before this statement in the 163 // iteration for that statistic will be lost as intended. 164 Stat->Initialized = false; 165 Stat->Value = 0; 166 } 167 168 // Clear the registration list and release the lock once we're done. Any 169 // pending updates from other threads will safely take effect after we return. 170 // That might not be what the user wants if they're measuring a compilation 171 // but it's their responsibility to prevent concurrent compilations to make 172 // a single compilation measurable. 173 Stats.clear(); 174 } 175 176 void llvm::PrintStatistics(raw_ostream &OS) { 177 StatisticInfo &Stats = *StatInfo; 178 179 // Figure out how long the biggest Value and Name fields are. 180 unsigned MaxDebugTypeLen = 0, MaxValLen = 0; 181 for (TrackingStatistic *Stat : Stats.Stats) { 182 MaxValLen = std::max(MaxValLen, (unsigned)utostr(Stat->getValue()).size()); 183 MaxDebugTypeLen = 184 std::max(MaxDebugTypeLen, (unsigned)std::strlen(Stat->getDebugType())); 185 } 186 187 Stats.sort(); 188 189 // Print out the statistics header... 190 OS << "===" << std::string(73, '-') << "===\n" 191 << " ... Statistics Collected ...\n" 192 << "===" << std::string(73, '-') << "===\n\n"; 193 194 // Print all of the statistics. 195 for (TrackingStatistic *Stat : Stats.Stats) 196 OS << format("%*" PRIu64 " %-*s - %s\n", MaxValLen, Stat->getValue(), 197 MaxDebugTypeLen, Stat->getDebugType(), Stat->getDesc()); 198 199 OS << '\n'; // Flush the output stream. 200 OS.flush(); 201 } 202 203 void llvm::PrintStatisticsJSON(raw_ostream &OS) { 204 sys::SmartScopedLock<true> Reader(*StatLock); 205 StatisticInfo &Stats = *StatInfo; 206 207 Stats.sort(); 208 209 // Print all of the statistics. 210 OS << "{\n"; 211 const char *delim = ""; 212 for (const TrackingStatistic *Stat : Stats.Stats) { 213 OS << delim; 214 assert(yaml::needsQuotes(Stat->getDebugType()) == yaml::QuotingType::None && 215 "Statistic group/type name is simple."); 216 assert(yaml::needsQuotes(Stat->getName()) == yaml::QuotingType::None && 217 "Statistic name is simple"); 218 OS << "\t\"" << Stat->getDebugType() << '.' << Stat->getName() << "\": " 219 << Stat->getValue(); 220 delim = ",\n"; 221 } 222 // Print timers. 223 TimerGroup::printAllJSONValues(OS, delim); 224 225 OS << "\n}\n"; 226 OS.flush(); 227 } 228 229 void llvm::PrintStatistics() { 230 #if LLVM_ENABLE_STATS 231 sys::SmartScopedLock<true> Reader(*StatLock); 232 StatisticInfo &Stats = *StatInfo; 233 234 // Statistics not enabled? 235 if (Stats.Stats.empty()) return; 236 237 // Get the stream to write to. 238 std::unique_ptr<raw_ostream> OutStream = CreateInfoOutputFile(); 239 if (StatsAsJSON) 240 PrintStatisticsJSON(*OutStream); 241 else 242 PrintStatistics(*OutStream); 243 244 #else 245 // Check if the -stats option is set instead of checking 246 // !Stats.Stats.empty(). In release builds, Statistics operators 247 // do nothing, so stats are never Registered. 248 if (EnableStats) { 249 // Get the stream to write to. 250 std::unique_ptr<raw_ostream> OutStream = CreateInfoOutputFile(); 251 (*OutStream) << "Statistics are disabled. " 252 << "Build with asserts or with -DLLVM_FORCE_ENABLE_STATS\n"; 253 } 254 #endif 255 } 256 257 std::vector<std::pair<StringRef, uint64_t>> llvm::GetStatistics() { 258 sys::SmartScopedLock<true> Reader(*StatLock); 259 std::vector<std::pair<StringRef, uint64_t>> ReturnStats; 260 261 for (const auto &Stat : StatInfo->statistics()) 262 ReturnStats.emplace_back(Stat->getName(), Stat->getValue()); 263 return ReturnStats; 264 } 265 266 void llvm::ResetStatistics() { 267 StatInfo->reset(); 268 } 269