[TimeProfiler] Fix some style issues. NFC

[russell.gallop]

LGTM, with assertion messages adjusted.

llvm/lib/Support/TimeProfiler.cpp

125–129

Assertion messages also need adjusting. Write -> write.

[MaskRay]

Address comment

llvm/lib/Support/TimeProfiler.cpp

 //===-- TimeProfiler.cpp - Hierarchical Time Profiler ---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements hierarchical time profiler.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeProfiler.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Threading.h"
 #include <algorithm>
 #include <cassert>
 #include <chrono>
 #include <mutex>
 #include <string>
 #include <vector>
 
 using namespace std::chrono;
 using namespace llvm;
 
-namespace {
-std::mutex Mu;
+static std::mutex Mu;
 // List of all instances
-std::vector<TimeTraceProfiler *>
-    ThreadTimeTraceProfilerInstances; // guarded by Mu
+static std::vector<TimeTraceProfiler *>
+    ThreadTimeTraceProfilerInstances; // GUARDED_BY(Mu)
 // Per Thread instance
-LLVM_THREAD_LOCAL TimeTraceProfiler *TimeTraceProfilerInstance = nullptr;
-} // namespace
+static LLVM_THREAD_LOCAL TimeTraceProfiler *TimeTraceProfilerInstance = nullptr;
 
-namespace llvm {
-
-TimeTraceProfiler *getTimeTraceProfilerInstance() {
+TimeTraceProfiler *llvm::getTimeTraceProfilerInstance() {
   return TimeTraceProfilerInstance;
 }
 
 typedef duration<steady_clock::rep, steady_clock::period> DurationType;
 typedef time_point<steady_clock> TimePointType;
 typedef std::pair<size_t, DurationType> CountAndDurationType;
 typedef std::pair<std::string, CountAndDurationType>
     NameAndCountAndDurationType;
 
+namespace {
 struct Entry {
   const TimePointType Start;
   TimePointType End;
   const std::string Name;
   const std::string Detail;
 
   Entry(TimePointType &&S, TimePointType &&E, std::string &&N, std::string &&Dt)
       : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
struct Entry {
   }
 
   steady_clock::rep getFlameGraphDurUs() const {
     return (time_point_cast<microseconds>(End) -
             time_point_cast<microseconds>(Start))
         .count();
   }
 };
+} // namespace
 
-struct TimeTraceProfiler {
+struct llvm::TimeTraceProfiler {
   TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "")
       : StartTime(steady_clock::now()), ProcName(ProcName),
         Tid(llvm::get_threadid()), TimeTraceGranularity(TimeTraceGranularity) {}
 
   void begin(std::string Name, llvm::function_ref<std::string()> Detail) {
     Stack.emplace_back(steady_clock::now(), TimePointType(), std::move(Name),
                        Detail());
   }
 
   void end() {
     assert(!Stack.empty() && "Must call begin() first");
-    auto &E = Stack.back();
+    Entry &E = Stack.back();
     E.End = steady_clock::now();
 
     // Check that end times monotonically increase.
     assert((Entries.empty() ||
             (E.getFlameGraphStartUs(StartTime) + E.getFlameGraphDurUs() >=
              Entries.back().getFlameGraphStartUs(StartTime) +
                  Entries.back().getFlameGraphDurUs())) &&
            "TimeProfiler scope ended earlier than previous scope");
if (std::find_if(++Stack.rbegin(), Stack.rend(), [&](const Entry &Val) {
       CountAndTotal.second += Duration;
     }
 
     Stack.pop_back();
   }
 
   // Write events from this TimeTraceProfilerInstance and
   // ThreadTimeTraceProfilerInstances.
-  void Write(raw_pwrite_stream &OS) {
+  void write(raw_pwrite_stream &OS) {
     // Acquire Mutex as reading ThreadTimeTraceProfilerInstances.
     std::lock_guard<std::mutex> Lock(Mu);
     assert(Stack.empty() &&
-           "All profiler sections should be ended when calling Write");
-    assert(std::all_of(ThreadTimeTraceProfilerInstances.begin(),
-                       ThreadTimeTraceProfilerInstances.end(),
+           "All profiler sections should be ended when calling write");
+    assert(llvm::all_of(ThreadTimeTraceProfilerInstances,
                         [](const auto &TTP) { return TTP->Stack.empty(); }) &&
-           "All profiler sections should be ended when calling Write");
+           "All profiler sections should be ended when calling write");
 
     json::OStream J(OS);
     J.objectBegin();
     J.attributeBegin("traceEvents");
     J.arrayBegin();
 
     // Emit all events for the main flame graph.
     auto writeEvent = [&](const auto &E, uint64_t Tid) {
       auto StartUs = E.getFlameGraphStartUs(StartTime);
       auto DurUs = E.getFlameGraphDurUs();
 
       J.object([&]{
         J.attribute("pid", 1);
         J.attribute("tid", int64_t(Tid));
         J.attribute("ph", "X");
         J.attribute("ts", StartUs);
         J.attribute("dur", DurUs);
         J.attribute("name", E.Name);
         if (!E.Detail.empty()) {
           J.attributeObject("args", [&] { J.attribute("detail", E.Detail); });
         }
       });
     };
-    for (const auto &E : Entries) {
+    for (const Entry &E : Entries)
       writeEvent(E, this->Tid);
-    }
-    for (const auto &TTP : ThreadTimeTraceProfilerInstances) {
-      for (const auto &E : TTP->Entries) {
+    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+      for (const Entry &E : TTP->Entries)
         writeEvent(E, TTP->Tid);
-      }
-    }
 
     // Emit totals by section name as additional "thread" events, sorted from
     // longest one.
     // Find highest used thread id.
     uint64_t MaxTid = this->Tid;
-    for (const auto &TTP : ThreadTimeTraceProfilerInstances) {
+    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
       MaxTid = std::max(MaxTid, TTP->Tid);
-    }
 
     // Combine all CountAndTotalPerName from threads into one.
     StringMap<CountAndDurationType> AllCountAndTotalPerName;
     auto combineStat = [&](const auto &Stat) {
       StringRef Key = Stat.getKey();
       auto Value = Stat.getValue();
       auto &CountAndTotal = AllCountAndTotalPerName[Key];
       CountAndTotal.first += Value.first;
       CountAndTotal.second += Value.second;
     };
-    for (const auto &Stat : CountAndTotalPerName) {
+    for (const auto &Stat : CountAndTotalPerName)
       combineStat(Stat);
-    }
-    for (const auto &TTP : ThreadTimeTraceProfilerInstances) {
-      for (const auto &Stat : TTP->CountAndTotalPerName) {
+    for (const TimeTraceProfiler *TTP : ThreadTimeTraceProfilerInstances)
+      for (const auto &Stat : TTP->CountAndTotalPerName)
         combineStat(Stat);
-      }
-    }
 
     std::vector<NameAndCountAndDurationType> SortedTotals;
     SortedTotals.reserve(AllCountAndTotalPerName.size());
     for (const auto &Total : AllCountAndTotalPerName)
       SortedTotals.emplace_back(std::string(Total.getKey()), Total.getValue());
 
-    llvm::sort(SortedTotals.begin(), SortedTotals.end(),
-               [](const NameAndCountAndDurationType &A,
+    llvm::sort(SortedTotals, [](const NameAndCountAndDurationType &A,
                                 const NameAndCountAndDurationType &B) {
-                 return A.second.second > B.second.second;
-               });
 
     // Report totals on separate threads of tracing file.
     uint64_t TotalTid = MaxTid + 1;
-    for (const auto &Total : SortedTotals) {
+    for (const NameAndCountAndDurationType &Total : SortedTotals) {
       auto DurUs = duration_cast<microseconds>(Total.second.second).count();
       auto Count = AllCountAndTotalPerName[Total.first].first;
 
       J.object([&]{
         J.attribute("pid", 1);
         J.attribute("tid", int64_t(TotalTid));
         J.attribute("ph", "X");
         J.attribute("ts", 0);
struct llvm::TimeTraceProfiler {
   const TimePointType StartTime;
   const std::string ProcName;
   const uint64_t Tid;
 
   // Minimum time granularity (in microseconds)
   const unsigned TimeTraceGranularity;
 };
 
-void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
+void llvm::timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                        StringRef ProcName) {
   assert(TimeTraceProfilerInstance == nullptr &&
          "Profiler should not be initialized");
   TimeTraceProfilerInstance = new TimeTraceProfiler(
       TimeTraceGranularity, llvm::sys::path::filename(ProcName));
 }
 
 // Removes all TimeTraceProfilerInstances.
 // Called from main thread.
-void timeTraceProfilerCleanup() {
+void llvm::timeTraceProfilerCleanup() {
   delete TimeTraceProfilerInstance;
   std::lock_guard<std::mutex> Lock(Mu);
   for (auto TTP : ThreadTimeTraceProfilerInstances)
     delete TTP;
   ThreadTimeTraceProfilerInstances.clear();
 }
 
 // Finish TimeTraceProfilerInstance on a worker thread.
 // This doesn't remove the instance, just moves the pointer to global vector.
-void timeTraceProfilerFinishThread() {
+void llvm::timeTraceProfilerFinishThread() {
   std::lock_guard<std::mutex> Lock(Mu);
   ThreadTimeTraceProfilerInstances.push_back(TimeTraceProfilerInstance);
   TimeTraceProfilerInstance = nullptr;
 }
 
-void timeTraceProfilerWrite(raw_pwrite_stream &OS) {
+void llvm::timeTraceProfilerWrite(raw_pwrite_stream &OS) {
   assert(TimeTraceProfilerInstance != nullptr &&
          "Profiler object can't be null");
-  TimeTraceProfilerInstance->Write(OS);
+  TimeTraceProfilerInstance->write(OS);
 }
 
-Error timeTraceProfilerWrite(StringRef PreferredFileName,
+Error llvm::timeTraceProfilerWrite(StringRef PreferredFileName,
                                    StringRef FallbackFileName) {
   assert(TimeTraceProfilerInstance != nullptr &&
          "Profiler object can't be null");
 
   std::string Path = PreferredFileName.str();
   if (Path.empty()) {
     Path = FallbackFileName == "-" ? "out" : FallbackFileName.str();
     Path += ".time-trace";
   }
 
   std::error_code EC;
   raw_fd_ostream OS(Path, EC, sys::fs::OF_Text);
   if (EC)
     return createStringError(EC, "Could not open " + Path);
 
   timeTraceProfilerWrite(OS);
   return Error::success();
 }
 
-void timeTraceProfilerBegin(StringRef Name, StringRef Detail) {
+void llvm::timeTraceProfilerBegin(StringRef Name, StringRef Detail) {
   if (TimeTraceProfilerInstance != nullptr)
     TimeTraceProfilerInstance->begin(std::string(Name),
                                      [&]() { return std::string(Detail); });
 }
 
-void timeTraceProfilerBegin(StringRef Name,
+void llvm::timeTraceProfilerBegin(StringRef Name,
                                   llvm::function_ref<std::string()> Detail) {
   if (TimeTraceProfilerInstance != nullptr)
     TimeTraceProfilerInstance->begin(std::string(Name), Detail);
 }
 
-void timeTraceProfilerEnd() {
+void llvm::timeTraceProfilerEnd() {
   if (TimeTraceProfilerInstance != nullptr)
     TimeTraceProfilerInstance->end();
 }
-
-} // namespace llvm