[CSSPGO][llvm-profgen] Reimplement computeSummaryAndThreshold using context trie

[wlei]

Summary

Follow-up patch to https://reviews.llvm.org/D125246, support computeSummaryAndThreshold based on context trie.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

435

why delete this?

1048

Is false needed here? We are passing in contextless profiles so merging them again inside computeSummaryAndThreshold should be fine?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

435

It's not completely deleted, it's moved to the ctor(see: ProfileGenerator.h: 180), this is because we don't ever save the llvm-sample-profile into ProfileMap, I made the llvm-sample-profile a temporary variable, it's converted to trie right in the ctor and dropped. So I also moved this part of code there.

1048

Yeah, we can merge the contextless profiles twice, but is there any concern to save one?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

435

I see. Profiled functions are also used to on-demand decode pseudo probes and it's needed for non-CS profile generator too.

1048

I guess my questions should be why this the extra parameter needed. Is the original implementation that checks FunctionSamples::ProfileIsCS inside SampleProfileSummaryBuilder::computeSummaryForProfiles not working?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1048

OK, I see your point, to save the unnecessary merge. I'd say if this is not at a visible cost, let's avoid changing the interface. Otherwise maybe we can reset UseContextLessSummary here? A comment would be helpful.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

131–138

The move is for llvm-sample-profile path. Do we fall back from move to copy for that path now?

1047

Not critical, but in the past we have the ability to use context profile as well when profile-summary-contextless=0 is used. It seems like we now lost that ability?

1048

save/restore UseContextLessSummary sounds like a good idea.

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

131–138

There is no extra copy here, we don't update ProfileMap for CS profile. For llvm-sample-profile path, the input is a reference, the map is converted to a trie in the ctor, so the lifetime of the reference end in the ctor. The ProfileMap is always empty for CS profile until we call buildProfileMap.

435

I see, good catch! I added them back for non-CS path.

1047

I see, I wasn't aware that we can use profile-summary-contextless=0. Yes, now we don't have the ability. I guess we don't need this before pre-inliner?

To support this, we can create a full CS map here like we call buildProfileMap, but we need to make a copy instead of move in buildProfileMap, we don't have that for now. it seems it will increase the complexity of the code. or we can call to compute the summary again after pre-inliner.

1048

It seems we can not copy the cl::opt<bool> class, I just set UseContextLessSummary=true here, not sure if we need to recover the UseContextLessSummary value.

[wlei]

Updating D127026: [CSSPGO][llvm-profgen] Reimplement computeSummaryAndThreshold using context trie

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1048

Would be better to recover the value since that'll be used by the extbinary writer to compute and flush out the profile summary on the final ProfileMap.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

This piece of code is needed because Profiles is not saved as a field of ProfileGeneratorBase anymore. Can we still do that to avoid duplicate this code here?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

Before it copied to ProfileMap and now we need to make ProfileMap empty because the buildProfileMap will convert the optimized trie into ProfileMap. Non-empty ProfileMap will mess up the results.

Maybe we can add a new field to ProfileGeneratorBase like SampleProfileMap & LLVMSampleProfiles;?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

now we need to make ProfileMap empty because the buildProfileMap will convert the optimized trie into ProfileMap. Non-empty ProfileMap will mess up the results.

Just clean it inside buildProfileMap?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

If cleaning it before, all the FunctionSamples owned by the map are freed, the FunctionSamples pointer in the ContextTrieNode is dangling.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

I see. Maybe we should just compute a contextless profile from ContextTracker in collectProfiledFunctions ? This is less efficient, but should fit better in the pipeline for easier maintenance. The performance of the llvm profile path isn't critical at the end of the day.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

188

On the second thought, we don't really need a contextless profile, just looping on the context tri and collecting function names should be sufficient?

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1048

I see, value recovered.

llvm/tools/llvm-profgen/ProfileGenerator.h

188

Sounds good to use name directly from trie. Just one thing is context tri is only in CSProfileGenerator, so I still need to use different function for this.

[wlei]

Updating D127026: [CSSPGO][llvm-profgen] Reimplement computeSummaryAndThreshold using context trie

[wlei]

Updating D127026: [CSSPGO][llvm-profgen] Reimplement computeSummaryAndThreshold using context trie

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

445

Make a copy of this in ProfileGeneratorBase::collectProfiledFunctions to keep the function prototype consistent? Actually the function can be made a virtual function.

470

Also check FunctionProfile is not null? A null profile means the function is likely not executed.

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

423

Here is for all context including the non-sampling one.

470

I think we discussed before for the non-executed context and the conclusion is to keep it? because I saw in SampleCounters case, it keep the function there. See above code(line 413)

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

470

Oh right, functions only showing up in stack samples should be considered as profiled. Actually there was a bug on the ProfileMap path and now your change is fixing it. LGTM.

[wlei]

changed to use virtual function for collectProfiledFunctions.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

Sorry for not making it clear. Can we do something like below? Basically keep the original collectProfiledFunctions as is and add a new override for CSProfileGenerator.

void ProfileGeneratorBase::collectProfiledFunctions() {
  std::unordered_set<const BinaryFunction *> ProfiledFunctions;
  if (SampleCounters) {
     ....
  } else if (!ProfileMap.empty())
     ....
  }
  Binary->setProfiledFunctions(ProfiledFunctions);
}

void CSProfileGenerator::collectProfiledFunctions() {
  deal with ContextTrieNode;
  Binary->setProfiledFunctions(ProfiledFunctions);
}

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

if (SampleCounters) {
   ....
}

This part of code is also needed for CSProfileGenerator because collectProfiledFunctions is called before the generateProbeBasedProfile, at that time none of ContextTrieNode is created.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

I see, would this work?

void CSProfileGenerator::collectProfiledFunctions() {
  if (getRootContext) {
    ... 
    Binary->setProfiledFunctions(ProfiledFunctions);
   }
   else {
     ProfileGeneratorBase::collectProfiledFunctions();
   }
}

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

This one should work, but it might introduce more complexity. We only have two modes 1) from Sample counter 2) from llvm-sample-profile. Before we use one condition(SampleCounters == null) to differentiate this two mode. But this one adds another condition(getRootContext()) which intend to do the same thing.

Is there any concern for the current version?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

Not a really concern, the current version looks good. I'm trying to see if the code can be simplified furthermore. Now that the context tri and ProfileMap are mutual-exclusive, perhaps using virtual functions to implement them is the best way. Adding an extra check is not worth.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1049

Should this be set to false? We want to avoid merging ContextLessProfiles again in computeSummaryForProfiles?

[wlei]

Updating D127026: [CSSPGO][llvm-profgen] Reimplement computeSummaryAndThreshold using context trie

[wlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1049

Oops, it should be false. I also found that set UseContextLessSummary false is not enough, I have to set FunctionSamples::ProfileIsCS to false as well, because the UseContextLessSummary.getNumOccurrences() is 0 here.

  if (UseContextLessSummary || (sampleprof::FunctionSamples::ProfileIsCS &&
                                !UseContextLessSummary.getNumOccurrences())) {
...

[hoy]

LGTM, thanks for addressing the feedbacks!

llvm/tools/llvm-profgen/ProfileGenerator.cpp

1049

Good catch. A comment about why setting the two variables (e.g, "to avoid re-merging profiles") would be good.

[wlei]

added more commments.

[wlei]

rebase

[wlei]

rebase

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

475

Consider this to give it more structure and help readability?

ProfileGeneratorBase::collectProfiledFunctions() {
    if (collectFunctionsFromRawProfile(ProfiledFunctions)) 
        Binary->setProfiledFunctions(ProfiledFunctions);
    else if (collectFunctionsFromLLVMProfile(ProfiledFunctions)) 
        Binary->setProfiledFunctions(ProfiledFunctions);
    else 
        llvm_unreachable(...);
}

bool ProfileGeneratorBase::collectFunctionsFromRawProfile(...) {
    if (!SampleCounters)
       return false;
    // read raw profile sample counters
    return true;
}

bool ProfileGenerator::collectFunctionsFromLLVMProfile(..) {
    // read ProfileMap
    return true;
}

bool CSProfileGenerator::collectFunctionsFromLLVMProfile(..) {
    // read trie nodes
    return true;
}

1047

I think it's ok to not support profile-summary-contextless=0 given we haven't really use it much. Maybe add an assertion for UseContextLessSummary to be true?

[wlei]

Addressing Wenlei's feedback

[wenlei]

lgtm, thanks.

llvm/include/llvm/Transforms/IPO/SampleContextTracker.h

public:
   StringRef getFuncNameFor(ContextTrieNode *Node) const;
   // Mark a context profile as inlined when function is inlined.
   // This makes sure that inlined context profile will be excluded in
   // function's base profile.
   void markContextSamplesInlined(const FunctionSamples *InlinedSamples);
   ContextTrieNode &getRootContext();
   void promoteMergeContextSamplesTree(const Instruction &Inst,
                                       StringRef CalleeName);
+
+  // Create a merged conext-less profile map.
+  void createContextLessProfileMap(SampleProfileMap &ContextLessProfiles);
   // Dump the internal context profile trie.
   void dump();
 
 private:
   ContextTrieNode *getContextFor(const DILocation *DIL);
   ContextTrieNode *getCalleeContextFor(const DILocation *DIL,
                                        StringRef CalleeName);
   ContextTrieNode *getTopLevelContextNode(StringRef FName);
   ContextTrieNode &addTopLevelContextNode(StringRef FName);
   ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &NodeToPromo);
   void mergeContextNode(ContextTrieNode &FromNode, ContextTrieNode &ToNode,
                         uint32_t ContextFramesToRemove);
   ContextTrieNode &
   promoteMergeContextSamplesTree(ContextTrieNode &FromNode,
                                  ContextTrieNode &ToNodeParent,
                                  uint32_t ContextFramesToRemove);
-
   // Map from function name to context profiles (excluding base profile)
   StringMap<ContextSamplesTy> FuncToCtxtProfiles;
 
   // Map from function guid to real function names. Only used in md5 mode.
   const DenseMap<uint64_t, StringRef> *GUIDToFuncNameMap;
 
   // Root node for context trie tree
   ContextTrieNode RootContext;
 };
 
 } // end namespace llvm
 #endif // LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H

llvm/lib/Transforms/IPO/SampleContextTracker.cpp

ContextTrieNode &SampleContextTracker::promoteMergeContextSamplesTree(
   }
 
   // For root of subtree, remove itself from old parent too
   if (MoveToRoot)
     FromNodeParent.removeChildContext(OldCallSiteLoc, ToNode->getFuncName());
 
   return *ToNode;
 }
+
+void SampleContextTracker::createContextLessProfileMap(
+    SampleProfileMap &ContextLessProfiles) {
+  std::queue<ContextTrieNode *> NodeQueue;
+  NodeQueue.push(&RootContext);
+
+  while (!NodeQueue.empty()) {
+    ContextTrieNode *Node = NodeQueue.front();
+    FunctionSamples *FProfile = Node->getFunctionSamples();
+    NodeQueue.pop();
+
+    if (FProfile) {
+      // Profile's context can be empty, use ContextNode's func name.
+      ContextLessProfiles[Node->getFuncName()].merge(*FProfile);
+    }
+
+    for (auto &It : Node->getAllChildContext())
+      NodeQueue.push(&It.second);
+  }
+}
 } // namespace llvm

llvm/tools/llvm-profgen/ProfileGenerator.h

using ProbeCounterMap =
     std::unordered_map<const MCDecodedPseudoProbe *, uint64_t>;
 
 // This base class for profile generation of sample-based PGO. We reuse all
 // structures relating to function profiles and profile writers as seen in
 // /ProfileData/SampleProf.h.
 class ProfileGeneratorBase {
 
 public:
+  ProfileGeneratorBase(ProfiledBinary *Binary) : Binary(Binary){};
   ProfileGeneratorBase(ProfiledBinary *Binary,
                        const ContextSampleCounterMap *Counters)
       : Binary(Binary), SampleCounters(Counters){};
   ProfileGeneratorBase(ProfiledBinary *Binary,
                        const SampleProfileMap &&Profiles)
       : Binary(Binary), ProfileMap(std::move(Profiles)){};
 
   virtual ~ProfileGeneratorBase() = default;
   static std::unique_ptr<ProfileGeneratorBase>
   create(ProfiledBinary *Binary, const ContextSampleCounterMap *Counters,
          bool profileIsCS);
   static std::unique_ptr<ProfileGeneratorBase>
-  create(ProfiledBinary *Binary, const SampleProfileMap &&ProfileMap,
+  create(ProfiledBinary *Binary, SampleProfileMap &ProfileMap,
          bool profileIsCS);
   virtual void generateProfile() = 0;
   void write();
 
   static uint32_t
   getDuplicationFactor(unsigned Discriminator,
                        bool UseFSD = ProfileGeneratorBase::UseFSDiscriminator) {
     return UseFSD ? 1
protected:
   void updateFunctionSamples();
 
   void updateTotalSamples();
 
   void updateCallsiteSamples();
 
   StringRef getCalleeNameForOffset(uint64_t TargetOffset);
 
-  void computeSummaryAndThreshold();
+  void computeSummaryAndThreshold(SampleProfileMap &ProfileMap);
 
   void calculateAndShowDensity(const SampleProfileMap &Profiles);
 
   double calculateDensity(const SampleProfileMap &Profiles,
                           uint64_t HotCntThreshold);
 
   void showDensitySuggestion(double Density);
 
   void collectProfiledFunctions();
 
+  bool collectFunctionsFromRawProfile(
+      std::unordered_set<const BinaryFunction *> &ProfiledFunctions);
+
+  // Collect profiled Functions for llvm sample profile input.
+  virtual bool collectFunctionsFromLLVMProfile(
+      std::unordered_set<const BinaryFunction *> &ProfiledFunctions) = 0;
+
   // Thresholds from profile summary to answer isHotCount/isColdCount queries.
   uint64_t HotCountThreshold;
 
   uint64_t ColdCountThreshold;
 
   ProfiledBinary *Binary = nullptr;
 
   std::unique_ptr<ProfileSummary> Summary;
private:
   populateBoundarySamplesForAllFunctions(const BranchSample &BranchCounters);
   void
   populateBodySamplesWithProbesForAllFunctions(const RangeSample &RangeCounter);
   void populateBoundarySamplesWithProbesForAllFunctions(
       const BranchSample &BranchCounters);
   void postProcessProfiles();
   void trimColdProfiles(const SampleProfileMap &Profiles,
                         uint64_t ColdCntThreshold);
+  bool collectFunctionsFromLLVMProfile(
+      std::unordered_set<const BinaryFunction *> &ProfiledFunctions) override;
 };
 
 class CSProfileGenerator : public ProfileGeneratorBase {
 public:
   CSProfileGenerator(ProfiledBinary *Binary,
                      const ContextSampleCounterMap *Counters)
       : ProfileGeneratorBase(Binary, Counters){};
-  CSProfileGenerator(ProfiledBinary *Binary, const SampleProfileMap &&Profiles)
-      : ProfileGeneratorBase(Binary, std::move(Profiles)){};
+  CSProfileGenerator(ProfiledBinary *Binary, SampleProfileMap &Profiles)
+      : ProfileGeneratorBase(Binary), ContextTracker(Profiles, nullptr){};
   void generateProfile() override;
 
   // Trim the context stack at a given depth.
   template <typename T>
   static void trimContext(SmallVectorImpl<T> &S, int Depth = MaxContextDepth) {
     if (Depth < 0 || static_cast<size_t>(Depth) >= S.size())
       return;
     std::copy(S.begin() + S.size() - static_cast<size_t>(Depth), S.end(),
               S.begin());
private:
   getFunctionProfileForLeafProbe(SampleContextFrames ContextStack,
                                  const MCDecodedPseudoProbe *LeafProbe);
 
   void convertToProfileMap(ContextTrieNode &Node,
                            SampleContextFrameVector &Context);
 
   void convertToProfileMap();
 
+  void computeSummaryAndThreshold();
+
+  bool collectFunctionsFromLLVMProfile(
+      std::unordered_set<const BinaryFunction *> &ProfiledFunctions) override;
+
   ContextTrieNode &getRootContext() { return ContextTracker.getRootContext(); };
 
   // The container for holding the FunctionSamples used by context trie.
   std::list<FunctionSamples> FSamplesList;
 
   // Underlying context table serves for sample profile writer.
   std::unordered_set<SampleContextFrameVector, SampleContextFrameHash> Contexts;
 

llvm/tools/llvm-profgen/ProfileGenerator.cpp

 
 static cl::opt<bool> UpdateTotalSamples(
     "update-total-samples", llvm::cl::init(false),
     llvm::cl::desc(
         "Update total samples by accumulating all its body samples."),
     llvm::cl::Optional);
 
 extern cl::opt<int> ProfileSummaryCutoffHot;
+extern cl::opt<bool> UseContextLessSummary;
 
 static cl::opt<bool> GenCSNestedProfile(
     "gen-cs-nested-profile", cl::Hidden, cl::init(true),
     cl::desc("Generate nested function profiles for CSSPGO"));
 
 using namespace llvm;
 using namespace sampleprof;
 
ProfileGeneratorBase::create(ProfiledBinary *Binary,
   }
   ProfileGeneratorBase::UseFSDiscriminator = Binary->useFSDiscriminator();
   FunctionSamples::ProfileIsFS = Binary->useFSDiscriminator();
 
   return Generator;
 }
 
 std::unique_ptr<ProfileGeneratorBase>
-ProfileGeneratorBase::create(ProfiledBinary *Binary,
-                             const SampleProfileMap &&Profiles,
+ProfileGeneratorBase::create(ProfiledBinary *Binary, SampleProfileMap &Profiles,
                              bool ProfileIsCS) {
   std::unique_ptr<ProfileGeneratorBase> Generator;
   if (ProfileIsCS) {
     if (Binary->useFSDiscriminator())
       exitWithError("FS discriminator is not supported in CS profile.");
-    Generator.reset(new CSProfileGenerator(Binary, std::move(Profiles)));
+    Generator.reset(new CSProfileGenerator(Binary, Profiles));
   } else {
     Generator.reset(new ProfileGenerator(Binary, std::move(Profiles)));
   }
   ProfileGeneratorBase::UseFSDiscriminator = Binary->useFSDiscriminator();
   FunctionSamples::ProfileIsFS = Binary->useFSDiscriminator();
 
   return Generator;
 }
void ProfileGeneratorBase::updateFunctionSamples() {
   updateCallsiteSamples();
 
   if (UpdateTotalSamples)
     updateTotalSamples();
 }
 
 void ProfileGeneratorBase::collectProfiledFunctions() {
   std::unordered_set<const BinaryFunction *> ProfiledFunctions;
-  if (SampleCounters) {
-    // Go through all the stacks, ranges and branches in sample counters, use
-    // the start of the range to look up the function it belongs and record the
-    // function.
-    for (const auto &CI : *SampleCounters) {
-      if (const auto *CtxKey = dyn_cast<AddrBasedCtxKey>(CI.first.getPtr())) {
-        for (auto Addr : CtxKey->Context) {
-          if (FuncRange *FRange = Binary->findFuncRangeForOffset(
-                  Binary->virtualAddrToOffset(Addr)))
-            ProfiledFunctions.insert(FRange->Func);
-        }
-      }
+  if (collectFunctionsFromRawProfile(ProfiledFunctions))
+    Binary->setProfiledFunctions(ProfiledFunctions);
+  else if (collectFunctionsFromLLVMProfile(ProfiledFunctions))
+    Binary->setProfiledFunctions(ProfiledFunctions);
+  else
+    llvm_unreachable("Unsupported input profile");
+}
+
+bool ProfileGeneratorBase::collectFunctionsFromRawProfile(
+    std::unordered_set<const BinaryFunction *> &ProfiledFunctions) {
+  if (!SampleCounters)
+    return false;
 
-      for (auto Item : CI.second.RangeCounter) {
-        uint64_t StartOffset = Item.first.first;
-        if (FuncRange *FRange = Binary->findFuncRangeForOffset(StartOffset))
-          ProfiledFunctions.insert(FRange->Func);
-      }
 
-      for (auto Item : CI.second.BranchCounter) {
-        uint64_t SourceOffset = Item.first.first;
-        uint64_t TargetOffset = Item.first.first;
-        if (FuncRange *FRange = Binary->findFuncRangeForOffset(SourceOffset))
-          ProfiledFunctions.insert(FRange->Func);
-        if (FuncRange *FRange = Binary->findFuncRangeForOffset(TargetOffset))
-          ProfiledFunctions.insert(FRange->Func);
-      }
-    }
-  } else {
-    // This is for the case the input is a llvm sample profile.
-    for (const auto &FS : ProfileMap) {
-      if (auto *Func = Binary->getBinaryFunction(FS.first.getName()))
-        ProfiledFunctions.insert(Func);
-    }
-  }
+  return true;
+}
+
+bool ProfileGenerator::collectFunctionsFromLLVMProfile(
+    std::unordered_set<const BinaryFunction *> &ProfiledFunctions) {
+  return true;
 
-  Binary->setProfiledFunctions(ProfiledFunctions);
+bool CSProfileGenerator::collectFunctionsFromLLVMProfile(
+    std::unordered_set<const BinaryFunction *> &ProfiledFunctions) {
+  std::queue<ContextTrieNode *> NodeQueue;
+  NodeQueue.push(&getRootContext());
+  while (!NodeQueue.empty()) {
+    ContextTrieNode *Node = NodeQueue.front();
+    NodeQueue.pop();
+
+    if (!Node->getFuncName().empty())
+      if (auto *Func = Binary->getBinaryFunction(Node->getFuncName()))
+        ProfiledFunctions.insert(Func);
+
+    for (auto &It : Node->getAllChildContext())
+      NodeQueue.push(&It.second);
+  }
+  return true;
 }
 
 FunctionSamples &
 ProfileGenerator::getTopLevelFunctionProfile(StringRef FuncName) {
   SampleContext Context(FuncName);
   auto Ret = ProfileMap.emplace(Context, FunctionSamples());
   if (Ret.second) {
     FunctionSamples &FProfile = Ret.first->second;
     FProfile.setContext(Context);
   }
   return Ret.first->second;
if (Binary->usePseudoProbes()) {
       generateLineNumBasedProfile();
     }
   }
 
   postProcessProfiles();
 }
 
 void ProfileGenerator::postProcessProfiles() {
-  computeSummaryAndThreshold();
+  computeSummaryAndThreshold(ProfileMap);
   trimColdProfiles(ProfileMap, ColdCountThreshold);
   calculateAndShowDensity(ProfileMap);
 }
 
 void ProfileGenerator::trimColdProfiles(const SampleProfileMap &Profiles,
                                         uint64_t ColdCntThreshold) {
   if (!TrimColdProfile)
     return;
void CSProfileGenerator::convertToProfileMap() {
   SampleContextFrameVector Context;
   for (auto &It : getRootContext().getAllChildContext())
     convertToProfileMap(It.second, Context);
 
   IsProfileValidOnTrie = false;
 }
 
 void CSProfileGenerator::postProcessProfiles() {
-  if (SampleCounters)
-    convertToProfileMap();
-
   // Compute hot/cold threshold based on profile. This will be used for cold
   // context profile merging/trimming.
   computeSummaryAndThreshold();
 
+  convertToProfileMap();
+
   // Run global pre-inliner to adjust/merge context profile based on estimated
   // inline decisions.
   if (EnableCSPreInliner) {
     CSPreInliner(ProfileMap, *Binary, Summary.get()).run();
     // Turn off the profile merger by default unless it is explicitly enabled.
     if (!CSProfMergeColdContext.getNumOccurrences())
       CSProfMergeColdContext = false;
   }
void CSProfileGenerator::postProcessProfiles() {
   calculateAndShowDensity(ContextLessProfiles);
   if (GenCSNestedProfile) {
     CSProfileConverter CSConverter(ProfileMap);
     CSConverter.convertProfiles();
     FunctionSamples::ProfileIsCS = false;
   }
 }
 
-void ProfileGeneratorBase::computeSummaryAndThreshold() {
+void ProfileGeneratorBase::computeSummaryAndThreshold(
+    SampleProfileMap &Profiles) {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
-  Summary = Builder.computeSummaryForProfiles(ProfileMap);
+  Summary = Builder.computeSummaryForProfiles(Profiles);
   HotCountThreshold = ProfileSummaryBuilder::getHotCountThreshold(
       (Summary->getDetailedSummary()));
   ColdCountThreshold = ProfileSummaryBuilder::getColdCountThreshold(
       (Summary->getDetailedSummary()));
 }
 
+void CSProfileGenerator::computeSummaryAndThreshold() {
+  // Always merge and use context-less profile map to compute summary.
+  SampleProfileMap ContextLessProfiles;
+  ContextTracker.createContextLessProfileMap(ContextLessProfiles);
+
+  // Set the flag below to avoid merging the profile again in
+  // computeSummaryAndThreshold
+  FunctionSamples::ProfileIsCS = false;
+  assert(
+      (!UseContextLessSummary.getNumOccurrences() || UseContextLessSummary) &&
+      "Don't set --profile-summary-contextless to false for profile "
+      "generation");
+  ProfileGeneratorBase::computeSummaryAndThreshold(ContextLessProfiles);
+  // Recover the old value.
+  FunctionSamples::ProfileIsCS = true;
+}
+
 void ProfileGeneratorBase::extractProbesFromRange(
     const RangeSample &RangeCounter, ProbeCounterMap &ProbeCounter,
     bool FindDisjointRanges) {
   const RangeSample *PRanges = &RangeCounter;
   RangeSample Ranges;
   if (FindDisjointRanges) {
     findDisjointRanges(Ranges, RangeCounter);
     PRanges = &Ranges;

llvm/tools/llvm-profgen/llvm-profgen.cpp

int main(int argc, const char *argv[]) {
 
   if (SampleProfFilename.getNumOccurrences()) {
     LLVMContext Context;
     auto ReaderOrErr = SampleProfileReader::create(SampleProfFilename, Context);
     std::unique_ptr<sampleprof::SampleProfileReader> Reader =
         std::move(ReaderOrErr.get());
     Reader->read();
     std::unique_ptr<ProfileGeneratorBase> Generator =
-        ProfileGeneratorBase::create(Binary.get(),
-                                     std::move(Reader->getProfiles()),
+        ProfileGeneratorBase::create(Binary.get(), Reader->getProfiles(),
                                      Reader->profileIsCS());
     Generator->generateProfile();
     Generator->write();
   } else {
     Optional<uint32_t> PIDFilter;
     if (ProcessId.getNumOccurrences())
       PIDFilter = ProcessId;
     PerfInputFile PerfFile = getPerfInputFile();