[NFC] Expose Time Profile utilities for easier reuse

[nrj5k]

Summary

In the OpenMP GPU runtime we want to track kernel times and splice them into the time profile of the runtime. To this end we need access to some internals of the Time Profile interface. No functional change intended.

[jdoerfert]

Let's address these issues first and then we look again.

llvm/include/llvm/Support/TimeProfiler.h

98

llvm::Entry is not a great way to export this.
Rename it, put it into a namespace, or make it part of the TimeTraceProfiler. The last option is probably the nicest.
You also managed to delete the few comments, e.g. for the Entry class, and down below introduces a typo (or reverted a fix for it).

211

This doesn't need to be exposed. That's what the getter is for.

llvm/include/llvm/Support/TimeProfiler.h

 //    stringification costs interfering with tracing.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TIMEPROFILER_H
 #define LLVM_SUPPORT_TIMEPROFILER_H
 
 #include "llvm/ADT/STLFunctionalExtras.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/Process.h"
+#include <chrono>
+#include <mutex>
+
+typedef std::chrono::duration<std::chrono::steady_clock::rep,
+                              std::chrono::steady_clock::period>
+    DurationType;
+typedef std::chrono::time_point<std::chrono::steady_clock> TimePointType;
+typedef std::pair<size_t, DurationType> CountAndDurationType;
+typedef std::pair<std::string, CountAndDurationType>
+    NameAndCountAndDurationType;
 
 namespace llvm {
 
 class raw_pwrite_stream;
 
-struct TimeTraceProfiler;
+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);
+
+  // Calculate timings for FlameGraph.
+  std::chrono::steady_clock::rep
+  getFlameGraphStartUs(TimePointType StartTime) const;
+  std::chrono::steady_clock::rep getFlameGraphDurUs() const;
+};
+struct TimeTraceProfiler {
+  TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "");
+  void begin(std::string Name, llvm::function_ref<std::string()> Detail);
+  void end();
+
+  // Write events from this TimeTraceProfilerInstance and
+  // ThreadTimeTraceProfilerInstances.
+  void write(raw_pwrite_stream &OS);
+
+  SmallVector<Entry, 16> Stack;
+  SmallVector<Entry, 128> Entries;
+  StringMap<CountAndDurationType> CountAndTotalPerName;
+  const std::chrono::time_point<std::chrono::system_clock> BeginningOfTime;
+  const TimePointType StartTime;
+  const std::string ProcName;
+  const sys::Process::Pid Pid;
+  SmallString<0> ThreadName;
+  const uint64_t Tid;
+
+  // Minimum time granularity (in microseconds)
+  const unsigned TimeTraceGranularity;
+};
 TimeTraceProfiler *getTimeTraceProfilerInstance();
 
 /// Initialize the time trace profiler.
 /// This sets up the global \p TimeTraceProfilerInstance
 /// variable to be the profiler instance.
 void timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                  StringRef ProcName);
 
if (getTimeTraceProfilerInstance() != nullptr)
       timeTraceProfilerBegin(Name, Detail);
   }
   ~TimeTraceScope() {
     if (getTimeTraceProfilerInstance() != nullptr)
       timeTraceProfilerEnd();
   }
 };
 
+struct TimeTraceProfilerInstances {
+  std::mutex Lock;
+  std::vector<TimeTraceProfiler *> List;
+};
+static TimeTraceProfilerInstances Instances;
+TimeTraceProfilerInstances &getTimeTraceProfilerInstances();
+
 } // end namespace llvm
 
 #endif

llvm/lib/Support/TimeProfiler.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
 #include "llvm/Support/Threading.h"
 #include <algorithm>
 #include <cassert>
-#include <chrono>
 #include <mutex>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
-namespace {
-
-using std::chrono::duration;
-using std::chrono::duration_cast;
-using std::chrono::microseconds;
-using std::chrono::steady_clock;
-using std::chrono::system_clock;
-using std::chrono::time_point;
-using std::chrono::time_point_cast;
-
-struct TimeTraceProfilerInstances {
-  std::mutex Lock;
-  std::vector<TimeTraceProfiler *> List;
-};
-
-TimeTraceProfilerInstances &getTimeTraceProfilerInstances() {
-  static TimeTraceProfilerInstances Instances;
-  return Instances;
-}
-
-} // anonymous namespace
-
 // Per Thread instance
 static LLVM_THREAD_LOCAL TimeTraceProfiler *TimeTraceProfilerInstance = nullptr;
 
 TimeTraceProfiler *llvm::getTimeTraceProfilerInstance() {
   return TimeTraceProfilerInstance;
 }
 
-namespace {
+namespace llvm {
 
-using ClockType = steady_clock;
-using TimePointType = time_point<ClockType>;
-using DurationType = duration<ClockType::rep, ClockType::period>;
-using CountAndDurationType = std::pair<size_t, DurationType>;
-using NameAndCountAndDurationType =
-    std::pair<std::string, CountAndDurationType>;
-
-/// Represents an open or completed time section entry to be captured.
-struct TimeTraceProfilerEntry {
-  const TimePointType Start;
-  TimePointType End;
-  const std::string Name;
-  const std::string Detail;
+using std::chrono::duration_cast;
+using std::chrono::microseconds;
+using std::chrono::steady_clock;
+using std::chrono::system_clock;
+using std::chrono::time_point_cast;
 
-  TimeTraceProfilerEntry(TimePointType &&S, TimePointType &&E, std::string &&N,
-                         std::string &&Dt)
-      : Start(std::move(S)), End(std::move(E)), Name(std::move(N)),
-        Detail(std::move(Dt)) {}
+Entry::Entry(TimePointType &&S, TimePointType &&E, std::string &&N,
 
-  // Calculate timings for FlameGraph. Cast time points to microsecond precision
-  // rather than casting duration. This avoids truncation issues causing inner
-  // scopes overruning outer scopes.
-  ClockType::rep getFlameGraphStartUs(TimePointType StartTime) const {
-    return (time_point_cast<microseconds>(Start) -
-            time_point_cast<microseconds>(StartTime))
-        .count();
-  }
+// rather than casting duration. This avoid truncation issues causing inner
+std::chrono::steady_clock::rep Entry::getFlameGraphStartUs(TimePointType StartTime) const {
 
-  ClockType::rep getFlameGraphDurUs() const {
-    return (time_point_cast<microseconds>(End) -
-            time_point_cast<microseconds>(Start))
-        .count();
-  }
-};
-
-} // anonymous namespace
+std::chrono::steady_clock::rep Entry::getFlameGraphDurUs() const {
 
-struct llvm::TimeTraceProfiler {
-  TimeTraceProfiler(unsigned TimeTraceGranularity = 0, StringRef ProcName = "")
-      : BeginningOfTime(system_clock::now()), StartTime(ClockType::now()),
-        ProcName(ProcName), Pid(sys::Process::getProcessId()),
-        Tid(llvm::get_threadid()), TimeTraceGranularity(TimeTraceGranularity) {
-    llvm::get_thread_name(ThreadName);
-  }
+TimeTraceProfiler::TimeTraceProfiler(unsigned TimeTraceGranularity,
+                                     StringRef ProcName)
+    : BeginningOfTime(system_clock::now()), StartTime(steady_clock::now()),
 
-  void begin(std::string Name, llvm::function_ref<std::string()> Detail) {
-    Stack.emplace_back(ClockType::now(), TimePointType(), std::move(Name),
-                       Detail());
-  }
+void TimeTraceProfiler::begin(std::string Name,
+                              llvm::function_ref<std::string()> Detail) {
+  Stack.emplace_back(steady_clock::now(), TimePointType(), std::move(Name),
 
-  void end() {
-    assert(!Stack.empty() && "Must call begin() first");
-    TimeTraceProfilerEntry &E = Stack.back();
-    E.End = ClockType::now();
+void TimeTraceProfiler::end() {
+  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");
 
-    // Calculate duration at full precision for overall counts.
-    DurationType Duration = E.End - E.Start;
 
-    // Only include sections longer or equal to TimeTraceGranularity msec.
-    if (duration_cast<microseconds>(Duration).count() >= TimeTraceGranularity)
-      Entries.emplace_back(E);
 
-    // Track total time taken by each "name", but only the topmost levels of
-    // them; e.g. if there's a template instantiation that instantiates other
-    // templates from within, we only want to add the topmost one. "topmost"
-    // happens to be the ones that don't have any currently open entries above
-    // itself.
-    if (llvm::none_of(llvm::drop_begin(llvm::reverse(Stack)),
-                      [&](const TimeTraceProfilerEntry &Val) {
-                        return Val.Name == E.Name;
-                      })) {
-      auto &CountAndTotal = CountAndTotalPerName[E.Name];
-      CountAndTotal.first++;
-      CountAndTotal.second += Duration;
-    }
+                    [&](const Entry &Val) { return Val.Name == E.Name; })) {
 
-    Stack.pop_back();
-  }
 
-  // Write events from this TimeTraceProfilerInstance and
-  // ThreadTimeTraceProfilerInstances.
-  void write(raw_pwrite_stream &OS) {
-    // Acquire Mutex as reading ThreadTimeTraceProfilerInstances.
-    auto &Instances = getTimeTraceProfilerInstances();
-    std::lock_guard<std::mutex> Lock(Instances.Lock);
-    assert(Stack.empty() &&
-           "All profiler sections should be ended when calling write");
-    assert(llvm::all_of(Instances.List,
-                        [](const auto &TTP) { return TTP->Stack.empty(); }) &&
-           "All profiler sections should be ended when calling write");
+void TimeTraceProfiler::write(raw_pwrite_stream &OS) {
 
-    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", Pid);
-        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 TimeTraceProfilerEntry &E : Entries)
-      writeEvent(E, this->Tid);
-    for (const TimeTraceProfiler *TTP : Instances.List)
-      for (const TimeTraceProfilerEntry &E : TTP->Entries)
-        writeEvent(E, TTP->Tid);
+  for (const Entry &E : Entries)
+    for (const Entry &E : TTP->Entries)
 
-    // 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 TimeTraceProfiler *TTP : Instances.List)
-      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)
-      combineStat(Stat);
-    for (const TimeTraceProfiler *TTP : Instances.List)
-      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, [](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 NameAndCountAndDurationType &Total : SortedTotals) {
-      auto DurUs = duration_cast<microseconds>(Total.second.second).count();
-      auto Count = AllCountAndTotalPerName[Total.first].first;
 
-      J.object([&] {
-        J.attribute("pid", Pid);
-        J.attribute("tid", int64_t(TotalTid));
-        J.attribute("ph", "X");
-        J.attribute("ts", 0);
-        J.attribute("dur", DurUs);
-        J.attribute("name", "Total " + Total.first);
-        J.attributeObject("args", [&] {
-          J.attribute("count", int64_t(Count));
-          J.attribute("avg ms", int64_t(DurUs / Count / 1000));
-        });
-      });
 
-      ++TotalTid;
-    }
 
-    auto writeMetadataEvent = [&](const char *Name, uint64_t Tid,
-                                  StringRef arg) {
-      J.object([&] {
-        J.attribute("cat", "");
-        J.attribute("pid", Pid);
-        J.attribute("tid", int64_t(Tid));
-        J.attribute("ts", 0);
-        J.attribute("ph", "M");
-        J.attribute("name", Name);
-        J.attributeObject("args", [&] { J.attribute("name", arg); });
-      });
-    };
+  auto writeMetadataEvent = [&](const char *Name, uint64_t Tid, StringRef arg) {
 
-    writeMetadataEvent("process_name", Tid, ProcName);
-    writeMetadataEvent("thread_name", Tid, ThreadName);
-    for (const TimeTraceProfiler *TTP : Instances.List)
-      writeMetadataEvent("thread_name", TTP->Tid, TTP->ThreadName);
 
-    J.arrayEnd();
-    J.attributeEnd();
 
-    // Emit the absolute time when this TimeProfiler started.
-    // This can be used to combine the profiling data from
-    // multiple processes and preserve actual time intervals.
-    J.attribute("beginningOfTime",
-                time_point_cast<microseconds>(BeginningOfTime)
+  J.attribute("beginningOfTime", time_point_cast<microseconds>(BeginningOfTime)
                                      .time_since_epoch()
                                      .count());
 
-    J.objectEnd();
-  }
 
-  SmallVector<TimeTraceProfilerEntry, 16> Stack;
-  SmallVector<TimeTraceProfilerEntry, 128> Entries;
-  StringMap<CountAndDurationType> CountAndTotalPerName;
-  // System clock time when the session was begun.
-  const time_point<system_clock> BeginningOfTime;
-  // Profiling clock time when the session was begun.
-  const TimePointType StartTime;
-  const std::string ProcName;
-  const sys::Process::Pid Pid;
-  SmallString<0> ThreadName;
-  const uint64_t Tid;
-
-  // Minimum time granularity (in microseconds)
-  const unsigned TimeTraceGranularity;
-};
+TimeTraceProfilerInstances &getTimeTraceProfilerInstances() {
+  return Instances;
+}
+} // namespace llvm
 
 void llvm::timeTraceProfilerInitialize(unsigned TimeTraceGranularity,
                                        StringRef ProcName) {
   assert(TimeTraceProfilerInstance == nullptr &&
          "Profiler should not be initialized");
   TimeTraceProfilerInstance = new TimeTraceProfiler(
       TimeTraceGranularity, llvm::sys::path::filename(ProcName));
 }