[llvm-profdata] Convert nested profile to CS flat profile.

[hoy]

Summary

Support of convert a regular nested profile to CS flat profile. This is useful for comparing the calling contexts in two different types of profiles.

[wenlei]

Some linter seems legit.

llvm/lib/ProfileData/SampleProf.cpp

501–502

I'm a bit confused by the name convertToCSFlatProfiles, looking at the implementation isn't this converting to nested profile?

553–617

Here the caller name is convertToCSNestedProfiles, but the callee on line 552 is convertToCSFlatProfiles.

llvm/test/tools/llvm-profdata/cs-sample-flat-profile.test

2

Add round trip test for conversion?

llvm/tools/llvm-profdata/llvm-profdata.cpp

750–751

Are the two flags (GenCSNestedProfile/GenCSFlatProfile and the corresponding switches) supposed to be mutually exclusive? If yes, perhaps we should make it explicit?

one way to make then mutual exclusive is to use a single switch: gen-cs-nested-profile==true means nested, false means flat. Or we can have -gen-cs-profile={nest|flat}.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

[hoy]

llvm/lib/ProfileData/SampleProf.cpp

553–617

Sorry, bad auto renaming.

llvm/test/tools/llvm-profdata/cs-sample-flat-profile.test

2

Done.

llvm/tools/llvm-profdata/llvm-profdata.cpp

750–751

Introduced a --sample-profile-layout=cs|nest switch.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

[wenlei]

llvm/include/llvm/ProfileData/SampleProf.h

101

I think flat vs nest is better here (than cs vs nest).

382–383

addCalledTarget does not add to NumSamples, but removeCalledTarget subtracts NumSamples. What's the reason for the inconsistency?

llvm/lib/ProfileData/SampleProf.cpp

515

nit: 0->ContextNone

527–528

It looks like the discrepancy comes from the fact that flat profile has target counts included in total samples, but nest profile doesn't? Is this something that should be unified? I don't remember why we choose to include target counts (rather than SampleRecord::NumSamples) in total counts for flat profile. Was it intentional?

[hoy]

llvm/include/llvm/ProfileData/SampleProf.h

101

Sounds good.

382–383

I think. It's due to the implementation of the profile generator. Callsite block samples are computed by analyzing LBR ranges, and NumSamples is updated there, while call target samples are computed based on branch samples. D122609 provides an option to make them consistent.

removeCalledTarget handles both in one place.

llvm/lib/ProfileData/SampleProf.cpp

515

Done.

527–528

The profile generator, for both flat and nest profiles, only includes callsite counts in the total count but not target counts. Ideally they would be the same. Here we are excluding target counts from callsite counts, which in turn excluded from total counts.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

[hoy]

Rebasing

[hoy]

Rebasing.

[wenlei]

llvm/tools/llvm-profdata/llvm-profdata.cpp

831

The boolean conversion seem to point to hasValue? I think the convention is mostly *ProfileIsCS.

constexpr explicit operator bool() const { return hasValue(); }

1026

nit: name this convert-sample-profile-layout. otherwise having SPL_None as default can be confusing as there's no None layout. But it makes sense for conversion to be None.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

llvm/tools/llvm-profdata/llvm-profdata.cpp

831

Here ProfileLayout is a function parameter of type SampleProfileLayout .

1026

Sounds good.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

[wenlei]

llvm/tools/llvm-profdata/llvm-profdata.cpp

831

I was talking about Optional<bool> ProfileIsCS.

[hoy]

llvm/tools/llvm-profdata/llvm-profdata.cpp

831

Oh I see. Yes, *ProfileIsCS should be used instead.

Also fixed another place like this.

[hoy]

Updating D121651: [llvm-profdata] Convert nested profile to CS flat profile.

llvm/include/llvm/ProfileData/SampleProf.h

enum SampleProfileFormat {
   SPF_None = 0,
   SPF_Text = 0x1,
   SPF_Compact_Binary = 0x2,
   SPF_GCC = 0x3,
   SPF_Ext_Binary = 0x4,
   SPF_Binary = 0xff
 };
 
+enum SampleProfileLayout {
+  SPL_None = 0,
+  SPL_Nest = 0x1,
+  SPL_Flat = 0x2,
+};
+
 static inline uint64_t SPMagic(SampleProfileFormat Format = SPF_Binary) {
   return uint64_t('S') << (64 - 8) | uint64_t('P') << (64 - 16) |
          uint64_t('R') << (64 - 24) | uint64_t('O') << (64 - 32) |
          uint64_t('F') << (64 - 40) | uint64_t('4') << (64 - 48) |
          uint64_t('2') << (64 - 56) | uint64_t(Format);
 }
 
 /// Get the proper representation of a string according to whether the
public:
 
   /// Remove called function from the call target map. Return the target sample
   /// count of the called function.
   uint64_t removeCalledTarget(StringRef F) {
     uint64_t Count = 0;
     auto I = CallTargets.find(F);
     if (I != CallTargets.end()) {
       Count = I->second;
       CallTargets.erase(I);
     }
     return Count;
   }
 
   /// Return true if this sample record contains function calls.
   bool hasCalls() const { return !CallTargets.empty(); }
 
   uint64_t getSamples() const { return NumSamples; }
   const CallTargetMap &getCallTargets() const { return CallTargets; }
public:
 
   /// Return all the samples collected in the body of the function.
   const BodySampleMap &getBodySamples() const { return BodySamples; }
 
   /// Return all the callsite samples collected in the body of the function.
   const CallsiteSampleMap &getCallsiteSamples() const {
     return CallsiteSamples;
   }
+  CallsiteSampleMap &getCallsiteSamples() { return CallsiteSamples; }
 
   /// Return the maximum of sample counts in a function body including functions
   /// inlined in it.
   uint64_t getMaxCountInside() const {
     uint64_t MaxCount = 0;
     for (const auto &L : getBodySamples())
       MaxCount = std::max(MaxCount, L.second.getSamples());
     for (const auto &C : getCallsiteSamples())
public:
   // Canonicalize context profile name and attributes.
   void canonicalizeContextProfiles();
 
 private:
   SampleProfileMap &ProfileMap;
 };
 
 // CSProfileConverter converts a full context-sensitive flat sample profile into
-// a nested context-sensitive sample profile.
+// a nested sample profile, or the other way around from a nested profile to a
+// CS flat profile.
 class CSProfileConverter {
 public:
-  CSProfileConverter(SampleProfileMap &Profiles);
-  void convertProfiles();
+  CSProfileConverter(SampleProfileMap &Profiles,
+                     std::list<SampleContextFrameVector> *Contexts = nullptr);
+  void convertToCSNestedProfiles();
+  void convertToCSFlatProfiles();
   struct FrameNode {
     FrameNode(StringRef FName = StringRef(),
               FunctionSamples *FSamples = nullptr,
               LineLocation CallLoc = {0, 0})
         : FuncName(FName), FuncSamples(FSamples), CallSiteLoc(CallLoc){};
 
     // Map line+discriminator location to child frame
     std::map<uint64_t, FrameNode> AllChildFrames;
     // Function name for current frame
     StringRef FuncName;
     // Function Samples for current frame
     FunctionSamples *FuncSamples;
     // Callsite location in parent context
     LineLocation CallSiteLoc;
 
     FrameNode *getOrCreateChildFrame(const LineLocation &CallSite,
                                      StringRef CalleeName);
   };
 
 private:
   // Nest all children profiles into the profile of Node.
-  void convertProfiles(FrameNode &Node);
+  void convertToCSNestedProfiles(FrameNode &Node);
+  // Flatten all children profiles of `FProfile` out to `NewProfileMap`
+  void convertToCSFlatProfiles(FunctionSamples &FProfile,
+                               SampleProfileMap &NewProfileMap,
+                               SampleContextFrameVector &Context);
   FrameNode *getOrCreateContextPath(const SampleContext &Context);
 
   SampleProfileMap &ProfileMap;
+
+  // Underlying context table serves for sample profile writer when
+  // converting a nested profile to a flat profile.
+  std::list<SampleContextFrameVector> *Contexts;
   FrameNode RootFrame;
 };
 
 /// ProfileSymbolList records the list of function symbols shown up
 /// in the binary used to generate the profile. It is useful to
 /// to discriminate a function being so cold as not to shown up
 /// in the profile and a function newly added.
 class ProfileSymbolList {

llvm/lib/ProfileData/SampleProf.cpp

cl::desc("Cutoff value about how many symbols in profile symbol list "
              "will be used. This is very useful for performance debugging"));
 
 cl::opt<bool> GenerateMergedBaseProfiles(
     "generate-merged-base-profiles",
     cl::desc("When generating nested context-sensitive profiles, always "
              "generate extra base profile for function with all its context "
              "profiles merged into it."));
 
+cl::opt<bool> PreserveContextAttributes(
+    "preserve-context-attributes", cl::init(true), cl::ZeroOrMore,
+    cl::desc("When generating nested context-sensitive profiles, always "
+             "preserve the attributes of each context."));
+
 namespace llvm {
 namespace sampleprof {
 bool FunctionSamples::ProfileIsProbeBased = false;
 bool FunctionSamples::ProfileIsCS = false;
 bool FunctionSamples::ProfileIsPreInlined = false;
 bool FunctionSamples::UseMD5 = false;
 bool FunctionSamples::HasUniqSuffix = true;
 bool FunctionSamples::ProfileIsFS = false;
assert(It->second.FuncName == CalleeName &&
            "Hash collision for child context node");
     return &It->second;
   }
 
   AllChildFrames[Hash] = FrameNode(CalleeName, nullptr, CallSite);
   return &AllChildFrames[Hash];
 }
 
-CSProfileConverter::CSProfileConverter(SampleProfileMap &Profiles)
-    : ProfileMap(Profiles) {
-  for (auto &FuncSample : Profiles) {
-    FunctionSamples *FSamples = &FuncSample.second;
-    auto *NewNode = getOrCreateContextPath(FSamples->getContext());
-    assert(!NewNode->FuncSamples && "New node cannot have sample profile");
-    NewNode->FuncSamples = FSamples;
-  }
-}
+CSProfileConverter::CSProfileConverter(
+    SampleProfileMap &Profiles, std::list<SampleContextFrameVector> *Contexts)
+    : ProfileMap(Profiles), Contexts(Contexts) {}
 
 CSProfileConverter::FrameNode *
 CSProfileConverter::getOrCreateContextPath(const SampleContext &Context) {
   auto Node = &RootFrame;
   LineLocation CallSiteLoc(0, 0);
   for (auto &Callsite : Context.getContextFrames()) {
     Node = Node->getOrCreateChildFrame(CallSiteLoc, Callsite.FuncName);
     CallSiteLoc = Callsite.Location;
   }
   return Node;
 }
 
-void CSProfileConverter::convertProfiles(CSProfileConverter::FrameNode &Node) {
+void CSProfileConverter::convertToCSNestedProfiles(
+    CSProfileConverter::FrameNode &Node) {
   // Process each child profile. Add each child profile to callsite profile map
   // of the current node `Node` if `Node` comes with a profile. Otherwise
   // promote the child profile to a standalone profile.
   auto *NodeProfile = Node.FuncSamples;
   for (auto &It : Node.AllChildFrames) {
     auto &ChildNode = It.second;
-    convertProfiles(ChildNode);
+    convertToCSNestedProfiles(ChildNode);
     auto *ChildProfile = ChildNode.FuncSamples;
     if (!ChildProfile)
       continue;
+
+    if (!PreserveContextAttributes)
+      ChildProfile->getContext().setAllAttributes(ContextNone);
+
     SampleContext OrigChildContext = ChildProfile->getContext();
     // Reset the child context to be contextless.
     ChildProfile->getContext().setName(OrigChildContext.getName());
     if (NodeProfile) {
       // Add child profile to the callsite profile map.
       auto &SamplesMap = NodeProfile->functionSamplesAt(ChildNode.CallSiteLoc);
       SamplesMap.emplace(OrigChildContext.getName().str(), *ChildProfile);
       NodeProfile->addTotalSamples(ChildProfile->getTotalSamples());
       // Remove the corresponding body sample for the callsite and update the
       // total weight.
       auto Count = NodeProfile->removeCalledTargetAndBodySample(
           ChildNode.CallSiteLoc.LineOffset, ChildNode.CallSiteLoc.Discriminator,
           OrigChildContext.getName());
       NodeProfile->removeTotalSamples(Count);
     }
 
     // Separate child profile to be a standalone profile, if the current parent
     // profile doesn't exist. This is a duplicating operation when the child
     // profile is already incorporated into the parent which is still useful and
     // thus done optionally. It is seen that duplicating context profiles into
     // base profiles improves the code quality for thinlto build by allowing a
     // profile in the prelink phase for to-be-fully-inlined functions.
     if (!NodeProfile) {
       ProfileMap[ChildProfile->getContext()].merge(*ChildProfile);
     } else if (GenerateMergedBaseProfiles) {
       ProfileMap[ChildProfile->getContext()].merge(*ChildProfile);
       auto &SamplesMap = NodeProfile->functionSamplesAt(ChildNode.CallSiteLoc);
       SamplesMap[ChildProfile->getName().str()].getContext().setAttribute(
           ContextDuplicatedIntoBase);
     }
 
     // Remove the original child profile.
     ProfileMap.erase(OrigChildContext);
   }
 }
 
-void CSProfileConverter::convertProfiles() { convertProfiles(RootFrame); }
+void CSProfileConverter::convertToCSNestedProfiles() {
+  for (auto &FuncSample : ProfileMap) {
+    FunctionSamples *FSamples = &FuncSample.second;
+    auto *NewNode = getOrCreateContextPath(FSamples->getContext());
+    assert(!NewNode->FuncSamples && "New node cannot have sample profile");
+    NewNode->FuncSamples = FSamples;
+  }
+  convertToCSNestedProfiles(RootFrame);
+}
+
+void CSProfileConverter::convertToCSFlatProfiles(
+    FunctionSamples &FProfile, SampleProfileMap &NewProfileMap,
+    SampleContextFrameVector &ParentContext) {
+  // Push current frame.
+  ParentContext.emplace_back(FProfile.getName(), LineLocation(0, 0));
+
+  // Recursively promote callee profiles to a standalone top-level profiles with
+  // a flattened context.
+  while (!FProfile.getCallsiteSamples().empty()) {
+    auto I = FProfile.getCallsiteSamples().begin();
+    ParentContext.back().Location = I->first;
+    for (auto &Callee : I->second) {
+      auto &CalleeProfile = Callee.second;
+      // Add body sample.
+      FProfile.addBodySamples(I->first.LineOffset, I->first.Discriminator,
+                              CalleeProfile.getEntrySamples());
+      // Add callsite sample.
+      FProfile.addCalledTargetSamples(
+          I->first.LineOffset, I->first.Discriminator, CalleeProfile.getName(),
+          CalleeProfile.getEntrySamples());
+      // Update total samples.
+      FProfile.addTotalSamples(CalleeProfile.getEntrySamples());
+      // Withdraw callee samples from total samples.
+      FProfile.setTotalSamples(FProfile.getTotalSamples() -
+                               CalleeProfile.getTotalSamples());
+      // Recursively convert callee profile.
+      convertToCSFlatProfiles(CalleeProfile, NewProfileMap, ParentContext);
+    }
+
+    // Remove callee profile
+    FProfile.getCallsiteSamples().erase(I);
+    ParentContext.back().Location = LineLocation(0, 0);
+  }
+
+  // Update head samples for callee profiles.
+  if (ParentContext.size() > 1)
+    FProfile.addHeadSamples(FProfile.getEntrySamples());
+
+  // Update current context.
+  Contexts->push_back(ParentContext);
+  SampleContext NewContext(Contexts->back());
+  FProfile.setContext(NewContext);
+  NewProfileMap.emplace(NewContext, FProfile);
+
+  // Pop current frame.
+  ParentContext.pop_back();
+}
+
+void CSProfileConverter::convertToCSFlatProfiles() {
+  SampleProfileMap NewProfileMap;
+  SampleContextFrameVector Context;
+  for (auto &FuncSample : ProfileMap)
+    convertToCSFlatProfiles(FuncSample.second, NewProfileMap, Context);
+  ProfileMap = std::move(NewProfileMap);
+}

llvm/test/Transforms/SampleProfile/csspgo-inline.ll

 ; Test for CSSPGO's new early inliner using priority queue
 
 ; Note that we need new pass manager to enable top-down processing for sample profile loader
 ; Test we inlined the following in top-down order with old inliner
 ;   main:3 @ _Z5funcAi
 ;   main:3 @ _Z5funcAi:1 @ _Z8funcLeafi
 ;   _Z5funcBi:1 @ _Z8funcLeafi
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/profile-context-tracker.prof -sample-profile-inline-size -sample-profile-prioritized-inline=0 -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-BASE
 
 ; RUN: llvm-profdata merge --sample --extbinary --use-md5 %S/Inputs/profile-context-tracker.prof -o %t.md5
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%t.md5 -sample-profile-inline-size -sample-profile-prioritized-inline=0 -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-BASE
 
-; RUN: llvm-profdata merge --sample --text --gen-cs-nested-profile %S/Inputs/profile-context-tracker.prof -o %t.prof
+; RUN: llvm-profdata merge --sample --text --convert-sample-profile-layout=nest %S/Inputs/profile-context-tracker.prof -o %t.prof
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%t.prof -sample-profile-inline-size -sample-profile-prioritized-inline=0 -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-BASE
 
 ; With new FDO early inliner, callee entry count is used to drive inlining instead of callee total samples, so we get less inlining for given profile
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/profile-context-tracker.prof -sample-profile-inline-size -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-NEW
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%t.prof -sample-profile-prioritized-inline -sample-profile-inline-size -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-NEW
 ;
 ; With new FDO early inliner, callee entry count is used to drive inlining instead of callee total samples, tuning hot cutoff can get us the same inlining
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/profile-context-tracker.prof -sample-profile-inline-size -profile-summary-cutoff-hot=999990 -profile-sample-accurate -S -pass-remarks=inline -o /dev/null 2>&1 | FileCheck %s --check-prefix=INLINE-BASE

llvm/test/Transforms/SampleProfile/csspgo-use-preinliner.ll

 ; Test for CSSPGO's sample loader inlining to make sure it can use llvm-profgen preinliner's decision
 
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/csspgo-use-preinliner.prof -pass-remarks=inline -sample-profile-prioritized-inline -profile-sample-accurate -sample-profile-use-preinliner=0 -S 2>&1 | FileCheck %s --check-prefix=DEFAULT
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%S/Inputs/csspgo-use-preinliner.prof -pass-remarks=inline -sample-profile-prioritized-inline -profile-sample-accurate -sample-profile-use-preinliner=1 -S 2>&1 | FileCheck %s --check-prefix=PREINLINE
 
-; RUN: llvm-profdata merge --sample --text --gen-cs-nested-profile -generate-merged-base-profiles=0 %S/Inputs/csspgo-use-preinliner.prof -o %t.prof
+; RUN: llvm-profdata merge --sample --text --convert-sample-profile-layout=nest -generate-merged-base-profiles=0 %S/Inputs/csspgo-use-preinliner.prof -o %t.prof
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%t.prof -pass-remarks=inline -sample-profile-prioritized-inline -profile-sample-accurate -sample-profile-use-preinliner=0 -S 2>&1 | FileCheck %s --check-prefix=DEFAULT
 ; RUN: opt < %s -passes=sample-profile -sample-profile-file=%t.prof -pass-remarks=inline -sample-profile-prioritized-inline -profile-sample-accurate -sample-profile-use-preinliner=1 -S 2>&1 | FileCheck %s --check-prefix=PREINLINE
 
 ; DEFAULT: '_Z5funcAi' inlined into 'main'
 ; DEFAULT-NOT: inlined into
 
 ; PREINLINE-NOT: inlined into
 ; `[main:3 @ _Z5funcAi]` does not have preinline decision, so it's up for loader inliner to decided.

llvm/test/tools/llvm-profdata/cs-sample-flat-profile.test

+RUN: llvm-profdata merge --sample --text -output=%t.proftext %S/Inputs/sample-profile.proftext --convert-sample-profile-layout=cs
+RUN: FileCheck %s < %t.proftext
+RUN: llvm-profdata merge --sample --text -output=%t2.proftext %t.proftext --convert-sample-profile-layout=nest --preserve-context-attributes=0 -generate-merged-base-profiles=0
+RUN: diff %t2.proftext %S/Inputs/sample-profile.proftext
+
+
+; CHECK:      [main]:184019:0
+; CHECK-NEXT:  4: 534
+; CHECK-NEXT:  4.2: 534
+; CHECK-NEXT:  5: 1075
+; CHECK-NEXT:  5.1: 1075
+; CHECK-NEXT:  6: 2080
+; CHECK-NEXT:  7: 534
+; CHECK-NEXT:  9: 2064 _Z3bari:1471 _Z3fooi:631
+; CHECK-NEXT:  10: 3000 inline2:2000 inline1:1000
+; CHECK-NEXT: [_Z3bari]:20301:1437
+; CHECK-NEXT:  1: 1437
+; CHECK-NEXT: [_Z3fooi]:7711:610
+; CHECK-NEXT:  1: 610
+; CHECK-NEXT: [main:10 @ inline2]:2000:2000
+; CHECK-NEXT:  1: 2000
+; CHECK-NEXT: [main:10 @ inline1]:1000:1000
+; CHECK-NEXT:  1: 1000

llvm/test/tools/llvm-profdata/cs-sample-nested-profile.test

-RUN: llvm-profdata merge --sample --text -output=%t.proftext %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
+RUN: llvm-profdata merge --sample --text -output=%t.proftext %S/Inputs/cs-sample-preinline.proftext --convert-sample-profile-layout=nest -generate-merged-base-profiles=0
 RUN: FileCheck %s < %t.proftext --match-full-lines --strict-whitespace
-RUN: llvm-profdata merge --sample --text -output=%t.probe.proftext %S/Inputs/cs-sample-preinline-probe.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
+RUN: llvm-profdata merge --sample --text -output=%t.probe.proftext %S/Inputs/cs-sample-preinline-probe.proftext --convert-sample-profile-layout=nest -generate-merged-base-profiles=0
 RUN: FileCheck %s < %t.probe.proftext --match-full-lines --strict-whitespace -check-prefix=PROBE
-RUN: llvm-profdata merge --sample --extbinary -output=%t.profbin %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=0
+RUN: llvm-profdata merge --sample --extbinary -output=%t.profbin %S/Inputs/cs-sample-preinline.proftext --convert-sample-profile-layout=nest -generate-merged-base-profiles=0
 RUN: llvm-profdata merge --sample --text -output=%t2.proftext %t.profbin
 RUN: FileCheck %s < %t2.proftext --match-full-lines --strict-whitespace
 RUN: llvm-profdata show --sample -show-sec-info-only %t.profbin | FileCheck %s -check-prefix=PREINLINE
-RUN: llvm-profdata merge --sample --text -output=%t3.proftext %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=1
+RUN: llvm-profdata merge --sample --text -output=%t3.proftext %S/Inputs/cs-sample-preinline.proftext --convert-sample-profile-layout=nest -generate-merged-base-profiles=1
 RUN: FileCheck %s < %t3.proftext --match-full-lines --strict-whitespace -check-prefix=RECOUNT
-RUN: llvm-profdata merge --sample --extbinary -output=%t2.profbin %S/Inputs/cs-sample-preinline.proftext --gen-cs-nested-profile=1 -generate-merged-base-profiles=1
+RUN: llvm-profdata merge --sample --extbinary -output=%t2.profbin %S/Inputs/cs-sample-preinline.proftext --convert-sample-profile-layout=nest -generate-merged-base-profiles=1
 RUN: llvm-profdata show -sample -detailed-summary %S/Inputs/cs-sample-preinline.proftext | FileCheck %s -check-prefix=SUMMARY
 RUN: llvm-profdata show -sample -detailed-summary %t2.profbin | FileCheck %s -check-prefix=SUMMARY-NEST
 RUN: llvm-profdata show -sample -detailed-summary %t3.proftext | FileCheck %s -check-prefix=SUMMARY-NEST
 
 
 ; CHECK:main:1968621:12
 ; CHECK-NEXT: 2: 24
 ; CHECK-NEXT: 3: 17 _Z5funcAi:7

llvm/tools/llvm-profdata/llvm-profdata.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/ProfileData/InstrProfCorrelator.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/ProfileData/MemProf.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/RawMemProfReader.h"
+#include "llvm/ProfileData/SampleProf.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Discriminator.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
else
       Writer.setPartialProfile();
   }
 }
 
 static void
 mergeSampleProfile(const WeightedFileVector &Inputs, SymbolRemapper *Remapper,
                    StringRef OutputFilename, ProfileFormat OutputFormat,
                    StringRef ProfileSymbolListFile, bool CompressAllSections,
-                   bool UseMD5, bool GenPartialProfile, bool GenCSNestedProfile,
+                   bool UseMD5, bool GenPartialProfile,
+                   SampleProfileLayout ProfileLayout,
                    bool SampleMergeColdContext, bool SampleTrimColdContext,
                    bool SampleColdContextFrameDepth, FailureMode FailMode) {
   using namespace sampleprof;
   SampleProfileMap ProfileMap;
   SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
   LLVMContext Context;
   sampleprof::ProfileSymbolList WriterList;
   Optional<bool> ProfileIsProbeBased;
for (const auto &Input : Inputs) {
     }
 
     std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
         Reader->getProfileSymbolList();
     if (ReaderList)
       WriterList.merge(*ReaderList);
   }
 
-  if (ProfileIsCS && (SampleMergeColdContext || SampleTrimColdContext)) {
+  if (*ProfileIsCS && (SampleMergeColdContext || SampleTrimColdContext)) {
     // Use threshold calculated from profile summary unless specified.
     SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
     auto Summary = Builder.computeSummaryForProfiles(ProfileMap);
     uint64_t SampleProfColdThreshold =
         ProfileSummaryBuilder::getColdCountThreshold(
             (Summary->getDetailedSummary()));
 
     // Trim and merge cold context profile using cold threshold above;
     SampleContextTrimmer(ProfileMap)
         .trimAndMergeColdContextProfiles(
             SampleProfColdThreshold, SampleTrimColdContext,
             SampleMergeColdContext, SampleColdContextFrameDepth, false);
   }
 
-  if (ProfileIsCS && GenCSNestedProfile) {
+  // Underlying context table serves for sample profile writer when
+  // converting a nested profile to a CS profile.
+  std::list<SampleContextFrameVector> Contexts;
+
+  if (*ProfileIsCS && ProfileLayout == llvm::sampleprof::SPL_Nest) {
     CSProfileConverter CSConverter(ProfileMap);
-    CSConverter.convertProfiles();
+    CSConverter.convertToCSNestedProfiles();
     ProfileIsCS = FunctionSamples::ProfileIsCS = false;
+  } else if (!*ProfileIsCS && ProfileLayout == llvm::sampleprof::SPL_Flat) {
+    CSProfileConverter CSConverter(ProfileMap, &Contexts);
+    CSConverter.convertToCSFlatProfiles();
+    ProfileIsCS = FunctionSamples::ProfileIsCS = true;
   }
 
   auto WriterOrErr =
       SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithErrorCode(EC, OutputFilename);
 
   auto Writer = std::move(WriterOrErr.get());
cl::opt<unsigned> SupplMinSizeThreshold(
       "suppl-min-size-threshold", cl::init(10), cl::Hidden,
       cl::desc("If the size of a function is smaller than the threshold, "
                "assume it can be inlined by PGO early inliner and it won't "
                "be adjusted based on sample profile."));
   cl::opt<unsigned> InstrProfColdThreshold(
       "instr-prof-cold-threshold", cl::init(0), cl::Hidden,
       cl::desc("User specified cold threshold for instr profile which will "
                "override the cold threshold got from profile summary. "));
-  cl::opt<bool> GenCSNestedProfile(
-      "gen-cs-nested-profile", cl::Hidden, cl::init(false),
-      cl::desc("Generate nested function profiles for CSSPGO"));
   cl::opt<std::string> DebugInfoFilename(
       "debug-info", cl::init(""),
       cl::desc("Use the provided debug info to correlate the raw profile."));
   cl::opt<std::string> ProfiledBinary(
       "profiled-binary", cl::init(""),
       cl::desc("Path to binary from which the profile was collected."));
+  cl::opt<SampleProfileLayout> ProfileLayout(
+      "convert-sample-profile-layout",
+      cl::desc("Convert the generated profile to"), cl::init(SPL_None),
+      cl::values(clEnumValN(SPL_Nest, "nest", "Nested profile"),
+                 clEnumValN(SPL_Flat, "cs", "Context-sensitive flat profile")));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
 
   WeightedFileVector WeightedInputs;
   for (StringRef Filename : InputFilenames)
     addWeightedInput(WeightedInputs, {std::string(Filename), 1});
   for (StringRef WeightedFilename : WeightedInputFilenames)
     addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename));
static int merge_main(int argc, const char *argv[]) {
 
   if (ProfileKind == instr)
     mergeInstrProfile(WeightedInputs, DebugInfoFilename, Remapper.get(),
                       OutputFilename, OutputFormat, OutputSparse, NumThreads,
                       FailureMode, ProfiledBinary);
   else
     mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
                        OutputFormat, ProfileSymbolListFile, CompressAllSections,
-                       UseMD5, GenPartialProfile, GenCSNestedProfile,
+                       UseMD5, GenPartialProfile, ProfileLayout,
                        SampleMergeColdContext, SampleTrimColdContext,
                        SampleColdContextFrameDepth, FailureMode);
   return 0;
 }
 
 /// Computer the overlap b/w profile BaseFilename and profile TestFilename.
 static void overlapInstrProfile(const std::string &BaseFilename,
                                 const std::string &TestFilename,

llvm/tools/llvm-profgen/ProfileGenerator.cpp

void CSProfileGenerator::postProcessProfiles() {
   sampleprof::SampleProfileMap ContextLessProfiles;
   for (const auto &I : ProfileMap) {
     ContextLessProfiles[I.second.getName()].merge(I.second);
   }
 
   calculateAndShowDensity(ContextLessProfiles);
   if (GenCSNestedProfile) {
     CSProfileConverter CSConverter(ProfileMap);
-    CSConverter.convertProfiles();
+    CSConverter.convertToCSNestedProfiles();
     FunctionSamples::ProfileIsCS = false;
   }
 }
 
 void ProfileGeneratorBase::computeSummaryAndThreshold() {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
   Summary = Builder.computeSummaryForProfiles(ProfileMap);
   HotCountThreshold = ProfileSummaryBuilder::getHotCountThreshold(