Improve hashing for time profiler

[anton-afanasyev]

Summary

Use optimized hashing while writing time trace by join two hashes to one.
Used for -ftime-trace option.

[anton-afanasyev]

Update: lint fix

[takuto.ikuta]

llvm/lib/Support/TimeProfiler.cpp

124 ↗

(On Diff #194124)

use emplace_back here?

[anton-afanasyev]

Updated, push_back() -> emplace_back()

llvm/lib/Support/TimeProfiler.cpp

124 ↗

(On Diff #194124)

Yes, thanks.

[takuto.ikuta]

llvm/lib/Support/TimeProfiler.cpp

150 ↗

(On Diff #194145)

better to include header for StringMap?

[anton-afanasyev]

Updated, added header for StringMap

llvm/lib/Support/TimeProfiler.cpp

150 ↗

(On Diff #194145)

Yes, thanks.

[takuto.ikuta]

LGTM with nit.
But I hope rnk take a look.

llvm/lib/Support/TimeProfiler.cpp

137 ↗

(On Diff #194242)

I prefer to reuse result of lookup for map here in L139.

[anton-afanasyev]

llvm/lib/Support/TimeProfiler.cpp

137 ↗

(On Diff #194242)

Ok.

[anton-afanasyev]

Updated, reuse result of map lookup

[anton-afanasyev]

In D60404#1459155, @takuto.ikuta wrote:

LGTM with nit.
But I hope rnk take a look.

Ok, thanks. Waiting for @rnk awhile.

[rnk]

Lgtm

I'm at eurollvm, feel free to find other reviewers in the meantime.

llvm/trunk/lib/Support/TimeProfiler.cpp

 //===-- TimeProfiler.cpp - Hierarchical Time Profiler ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file Hierarchical time profiler implementation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/FileSystem.h"
 #include <cassert>
 #include <chrono>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 using namespace std::chrono;
default:
         OS += C;
       }
     }
   }
   return OS;
 }
 
 typedef duration<steady_clock::rep, steady_clock::period> DurationType;
-typedef std::pair<std::string, DurationType> NameAndDuration;
+typedef std::pair<size_t, DurationType> CountAndDurationType;
+typedef std::pair<std::string, CountAndDurationType>
+    NameAndCountAndDurationType;
 
 struct Entry {
   time_point<steady_clock> Start;
   DurationType Duration;
   std::string Name;
   std::string Detail;
 };
 
void end() {
     // 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 (std::find_if(++Stack.rbegin(), Stack.rend(), [&](const Entry &Val) {
           return Val.Name == E.Name;
         }) == Stack.rend()) {
-      TotalPerName[E.Name] += E.Duration;
-      CountPerName[E.Name]++;
+      auto &CountAndTotal = CountAndTotalPerName[E.Name];
+      CountAndTotal.first++;
+      CountAndTotal.second += E.Duration;
     }
 
     Stack.pop_back();
   }
 
   void Write(std::unique_ptr<raw_pwrite_stream> &OS) {
     assert(Stack.empty() &&
            "All profiler sections should be ended when calling Write");
 
     *OS << "{ \"traceEvents\": [\n";
 
     // Emit all events for the main flame graph.
     for (const auto &E : Entries) {
       auto StartUs = duration_cast<microseconds>(E.Start - StartTime).count();
       auto DurUs = duration_cast<microseconds>(E.Duration).count();
       *OS << "{ \"pid\":1, \"tid\":0, \"ph\":\"X\", \"ts\":" << StartUs
           << ", \"dur\":" << DurUs << ", \"name\":\"" << escapeString(E.Name)
           << "\", \"args\":{ \"detail\":\"" << escapeString(E.Detail)
           << "\"} },\n";
     }
 
     // Emit totals by section name as additional "thread" events, sorted from
     // longest one.
     int Tid = 1;
-    std::vector<NameAndDuration> SortedTotals;
-    SortedTotals.reserve(TotalPerName.size());
-    for (const auto &E : TotalPerName) {
-      SortedTotals.push_back(E);
+    std::vector<NameAndCountAndDurationType> SortedTotals;
+    SortedTotals.reserve(CountAndTotalPerName.size());
+    for (const auto &E : CountAndTotalPerName) {
+      SortedTotals.emplace_back(E.getKey(), E.getValue());
     }
     std::sort(SortedTotals.begin(), SortedTotals.end(),
-              [](const NameAndDuration &A, const NameAndDuration &B) {
-                return A.second > B.second;
+              [](const NameAndCountAndDurationType &A,
+                 const NameAndCountAndDurationType &B) {
+                return A.second.second > B.second.second;
               });
     for (const auto &E : SortedTotals) {
-      auto DurUs = duration_cast<microseconds>(E.second).count();
+      auto DurUs = duration_cast<microseconds>(E.second.second).count();
+      auto Count = CountAndTotalPerName[E.first].first;
       *OS << "{ \"pid\":1, \"tid\":" << Tid << ", \"ph\":\"X\", \"ts\":" << 0
           << ", \"dur\":" << DurUs << ", \"name\":\"Total "
-          << escapeString(E.first)
-          << "\", \"args\":{ \"count\":" << CountPerName[E.first]
-          << ", \"avg ms\":" << (DurUs / CountPerName[E.first] / 1000)
-          << "} },\n";
+          << escapeString(E.first) << "\", \"args\":{ \"count\":" << Count
+          << ", \"avg ms\":" << (DurUs / Count / 1000) << "} },\n";
       ++Tid;
     }
 
     // Emit metadata event with process name.
     *OS << "{ \"cat\":\"\", \"pid\":1, \"tid\":0, \"ts\":0, \"ph\":\"M\", "
            "\"name\":\"process_name\", \"args\":{ \"name\":\"clang\" } }\n";
     *OS << "] }\n";
   }
 
   std::vector<Entry> Stack;
   std::vector<Entry> Entries;
-  std::unordered_map<std::string, DurationType> TotalPerName;
-  std::unordered_map<std::string, size_t> CountPerName;
+  StringMap<CountAndDurationType> CountAndTotalPerName;
   time_point<steady_clock> StartTime;
 };
 
 void timeTraceProfilerInitialize() {
   assert(TimeTraceProfilerInstance == nullptr &&
          "Profiler should not be initialized");
   TimeTraceProfilerInstance = new TimeTraceProfiler();
 }