[llvm-profgen] Refactor the code of getHashCode

[wlei]

Summary

Refactor to generate hash code lazily. Tested on clang self build, no observable generating time regression.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

350

This will compute hash code every time when we access it, can we do it only once? i.e. keep HashCode. same for the probe version.

if (!HashCode)
  HashCode = hash_value(SampleContextFrames(Context));
  
return HashCode;

[wlei]

addressing Wenlei's feedback

[hoy]

lgtm, thanks.

llvm/tools/llvm-profgen/PerfReader.h

struct UnwindState {
 
   ProfiledFrame *getDummyRootPtr() { return &DummyTrieRoot; }
 };
 
 // Base class for sample counter key with context
 struct ContextKey {
   uint64_t HashCode = 0;
   virtual ~ContextKey() = default;
-  uint64_t getHashCode() const { return HashCode; }
+  uint64_t getHashCode() {
+    if (HashCode == 0)
+      genHashCode();
+    return HashCode;
+  }
+  virtual void genHashCode() = 0;
   virtual bool isEqual(const ContextKey *K) const {
     return HashCode == K->HashCode;
   };
 
   // Utilities for LLVM-style RTTI
   enum ContextKind { CK_StringBased, CK_ProbeBased };
   const ContextKind Kind;
   ContextKind getKind() const { return Kind; }
static bool classof(const ContextKey *K) {
     return K->getKind() == CK_StringBased;
   }
 
   bool isEqual(const ContextKey *K) const override {
     const StringBasedCtxKey *Other = dyn_cast<StringBasedCtxKey>(K);
     return Context == Other->Context;
   }
 
-  void genHashCode() { HashCode = hash_value(SampleContextFrames(Context)); }
+  void genHashCode() override {
+    HashCode = hash_value(SampleContextFrames(Context));
+  }
 };
 
 // Probe based context key as the intermediate key of context
 // String based context key will introduce redundant string handling
 // since the callee context is inferred from the context string which
 // need to be splitted by '@' to get the last location frame, so we
 // can just use probe instead and generate the string in the end.
 struct ProbeBasedCtxKey : public ContextKey {
   SmallVector<const MCDecodedPseudoProbe *, 16> Probes;
 
   ProbeBasedCtxKey() : ContextKey(CK_ProbeBased) {}
   static bool classof(const ContextKey *K) {
     return K->getKind() == CK_ProbeBased;
   }
 
   bool isEqual(const ContextKey *K) const override {
     const ProbeBasedCtxKey *O = dyn_cast<ProbeBasedCtxKey>(K);
     assert(O != nullptr && "Probe based key shouldn't be null in isEqual");
     return std::equal(Probes.begin(), Probes.end(), O->Probes.begin(),
                       O->Probes.end());
   }
 
-  void genHashCode() {
+  void genHashCode() override {
     for (const auto *P : Probes) {
       HashCode = hash_combine(HashCode, P);
     }
     if (HashCode == 0) {
       // Avoid zero value of HashCode when it's an empty list
       HashCode = 1;
     }
   }

llvm/tools/llvm-profgen/PerfReader.cpp

 }
 
 std::shared_ptr<StringBasedCtxKey> FrameStack::getContextKey() {
   std::shared_ptr<StringBasedCtxKey> KeyStr =
       std::make_shared<StringBasedCtxKey>();
   KeyStr->Context = Binary->getExpandedContext(Stack, KeyStr->WasLeafInlined);
   if (KeyStr->Context.empty())
     return nullptr;
-  KeyStr->genHashCode();
   return KeyStr;
 }
 
 std::shared_ptr<ProbeBasedCtxKey> ProbeStack::getContextKey() {
   std::shared_ptr<ProbeBasedCtxKey> ProbeBasedKey =
       std::make_shared<ProbeBasedCtxKey>();
   for (auto CallProbe : Stack) {
     ProbeBasedKey->Probes.emplace_back(CallProbe);
   }
   CSProfileGenerator::compressRecursionContext<const MCDecodedPseudoProbe *>(
       ProbeBasedKey->Probes);
   CSProfileGenerator::trimContext<const MCDecodedPseudoProbe *>(
       ProbeBasedKey->Probes);
-
-  ProbeBasedKey->genHashCode();
   return ProbeBasedKey;
 }
 
 template <typename T>
 void VirtualUnwinder::collectSamplesFromFrame(UnwindState::ProfiledFrame *Cur,
                                               T &Stack) {
   if (Cur->RangeSamples.empty() && Cur->BranchSamples.empty())
     return;
while (!TraceIt.isAtEoF()) {
     StringRef Line = TraceIt.getCurrentLine();
     // Read context stack for CS profile.
     if (Line.startswith("[")) {
       ProfileIsCS = true;
       auto I = ContextStrSet.insert(Line.str());
       SampleContext::createCtxVectorFromStr(*I.first, Key->Context);
       TraceIt.advance();
     }
-    Key->genHashCode();
     auto Ret =
         SampleCounters.emplace(Hashable<ContextKey>(Key), SampleCounter());
     readSampleCounters(TraceIt, Ret.first->second);
   }
 }
 
 void UnsymbolizedProfileReader::parsePerfTraces() {
   readUnsymbolizedProfile(PerfTraceFile);

 
 void PerfScriptReader::generateUnsymbolizedProfile() {
   // There is no context for LBR only sample, so initialize one entry with
   // fake "empty" context key.
   assert(SampleCounters.empty() &&
          "Sample counter map should be empty before raw profile generation");
   std::shared_ptr<StringBasedCtxKey> Key =
       std::make_shared<StringBasedCtxKey>();
-  Key->genHashCode();
   SampleCounters.emplace(Hashable<ContextKey>(Key), SampleCounter());
   for (const auto &Item : AggregatedSamples) {
     const PerfSample *Sample = Item.first.getPtr();
     computeCounterFromLBR(Sample, Item.second);
   }
 }
 
 uint64_t PerfScriptReader::parseAggregatedCount(TraceStream &TraceIt) {