[llvm-profgen] Read sample profiles for post-processing.

[hoy]

Summary

Sometimes we would like to run post-processing repeatedly on the original sample profile for tuning. In order to avoid regenerating the original profile from scratch every time, this change adds the support of reading in the original profile (called symbolized profile) and running the post-processor on it.

[wenlei]

original non-modified profile

nit: rephrase to be clearer what it means, or just simplify "llvm pgo profile".

llvm/test/tools/llvm-profgen/cold-profile-trimming-symbolized.test

3

Maybe we should probably support no-diff llvm profile to llvm profile conversion? You mentioned the call site samples as a difference and I'm wondering whether this is an easy to fix difference.

llvm/tools/llvm-profgen/PerfReader.h

68 ↗

(On Diff #415288)

I'd prefer not to introduce a new term, given we already have a proper name for it - LLVM PGO profile. Also this is not really PerfFormat anyways.

I think it's fine and probably clearer to create a side channel to deal with llvm profile as input, rather than trying to fit in the existing perf format/reader structure. Taking llvm profile as input is indeed a special mode and use of llvm-profgen anyways.

730 ↗

(On Diff #415288)

This doesn't look right. This is no longer a perf profile, but rather a proper LLVM profile, so inheriting from PerfReaderBase isn't good. As you can see, there's really no notion of trace, so parsePerfTraces really just calls LLVM's profile reader.

Maybe instead of passing a reader to profile generator, we can just either pass the counters like we do today, or a ProfileMap which is what profile reader gives us. This may need two separate ctor for profile generator. But I think that's better than the (awkward) inheritance we have here.

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

53

This is just PGO profile right? If so, I don't think we need yet another name for it. We can say something like llvm-pgo-profile to be clear.

Do you intend to make this work for all kinds of pgo profiles as input? like CSSPGO/AutoFDO, flat vs nest etc.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

730 ↗

(On Diff #415288)

I was thinking about that. Not only for the profile generator, the reader would also need a different constructor or a different type hierarchy and the work flow of llvm-profgen may not look as clean as now. As shown below (from llvm-profgen::main), the current approach tries to reuse the PerfReaderBase and ProfileGeneratorBase. I guess it's a tradeoff between adding a new base class for Reader or diverging the workflow structure a little bit.

PerfInputFile PerfFile = getPerfInputFile();
 std::unique_ptr<PerfReaderBase> Reader =
     PerfReaderBase::create(Binary.get(), PerfFile);
 // Parse perf events and samples
 Reader->parsePerfTraces();

 if (SkipSymbolization)
   return EXIT_SUCCESS;

 std::unique_ptr<ProfileGeneratorBase> Generator =
     ProfileGeneratorBase::create(Binary.get(), Reader->getSampleCounters(),
                                  Reader->profileIsCSFlat());
 Generator->generateProfile();
 Generator->write();

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

53

llvm-pgo-profile sounds better. Yes, I'd like all kinds for sample profiles to be read and postpreocessed by the tool.

[wenlei]

llvm/tools/llvm-profgen/PerfReader.h

730 ↗

(On Diff #415288)

the reader would also need a different constructor or a different type hierarchy and the work flow of llvm-profgen may not look as clean as now

It'd be a very thin wrapper over the actually llvm profile reader. Maybe a standalone function is all we need, instead of a new reader class. we take file as input, produced ProfileMap and pass it to generator. The use case and workflow is indeed special, it's like a side channel not tied to the main use of the tool (raw profile to llvm profile). Forcing that special workflow to use the same structure of the rest creates the problems. Yes, it's tradeoff, but shove llvm profile reader under the hierarchy of perf reader doesn't look like a good one to me.

[hoy]

llvm/tools/llvm-profgen/PerfReader.h

730 ↗

(On Diff #415288)

Changed to using a separate channel for sample profile input.

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

53

I ended up ing llvm-sample-profile.

[hoy]

Using a separate channel for sample profile input.

[hoy]

llvm/test/tools/llvm-profgen/cold-profile-trimming-symbolized.test

3

The check here is to make sure the profile post-processing is effective. There's no cross-type profile conversion here. The non-diff profile conversion I mentioned was about converting CS flat profile to CS nest which should be independent of this diff. I can make a separate fix for that though.

[hoy]

Moving pseudo probe decoding out of probe profile generation so that it'll run for sample profile input case.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

431–435

So for pgo profile as input, we still need probe decoding because preinliner needs context size based on profile, right?

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

Both Reader->getSampleCounters() and Reader->getProfiles() return by reference so there should be no copy, why do we need move ctor here?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.cpp

431–435

Exactly.

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

This is because previously the SampleCounters field is a reference and it must be initialized in constructors. I'm now changing it to a value field and using the move constructor to initialize it when needed.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

Ok, move still has some cost as a new object is constructed. In this case can we just use pointer type instead?

IIUC, the change is to allow them to be "optional" depending on whether input is perf profile or llvm profile, for that it seems pointer which is nullable fits well..

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

Yes, pointer type should work for SampleCounters since it's always read-only. For ProfileMap, which is not optional and is mutable during the postprocessing, a pointer type may result in ProfileGenerator changing the Reader's buffer. This doesn't sound right conceptually, though technically this has no difference with std::move stealing the reader buffer. Another issue with using pointer type for ProfileMap is that it has to be explicitly initialized (maybe via unique_ptr) in one of the constructors.

[hoy]

Using pointer type for SampleCounters.

[hoy]

Updating D121655: [llvm-profgen] Read sample profiles for post-processing.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

I am not sure if the reasoning to use move ctor makes sense, but I also don't have a strong opinion.

For ProfileMap, which is not optional and is mutable during the postprocessing, a pointer type may result in ProfileGenerator changing the Reader's buffer. This doesn't sound right conceptually, though technically this has no difference with std::move stealing the reader buffer.

Changing reader's buffer is not the problem of the API, and using move ctor API also does not solve the problem. In fact using move may make it worse, because the Reader's buffer become invalid instead of changed.

Another issue with using pointer type for ProfileMap is that it has to be explicitly initialized (maybe via unique_ptr) in one of the constructors.

Why is explicit initialization an *issue*?

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

An explicit initialization may need an explicit destruction, unless some wrapping DS is used like unique_ptr. However, using unique_ptr in one case and raw ptr in the other makes it inconsistent, ie., how do you define the ProfileMap field. Using raw ptrs for both will require an explicit delete for one case and we need a way to tell it apart.

Ideally what comes out of the reader should be readonly, however, it looks like not easy to achieve without duplicating the whole data. Sounds like using move constructor is easy to implement. WDYT?

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

An explicit initialization may need an explicit destruction, unless some wrapping DS is used like unique_ptr. However, using unique_ptr in one case and raw ptr in the other makes it inconsistent, ie., how do you define the ProfileMap field. Using raw ptrs for both will require an explicit delete for one case and we need a way to tell it apart.

You can let reader own the data (so destruction belongs to reader as well), then ProfileGenerator only takes an escaped raw pointer. explicit initialization is justing assign a value to raw pointer.

Ideally what comes out of the reader should be readonly, however, it looks like not easy to achieve without duplicating the whole data. Sounds like using move constructor is easy to implement. WDYT?

I don't have strong opinion, but I don't see how move achieves what you want, it's not readonly anyways.

[hoy]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

You can let reader own the data (so destruction belongs to reader as well), then ProfileGenerator only takes an escaped raw pointer. explicit initialization is justing assign a value to raw pointer.

That'd require a change to the reader and the generator's constructor, just to be consistent with the other path.

Right, neither solves the readonly issue. The std::move one seems a bit clearer. I'm inlined to go with it if you're fine with both.

[wenlei]

llvm/tools/llvm-profgen/ProfileGenerator.h

136–139

sounds good.

[goncharov]

Hi, I have found that cs-preinline-sample-profile.test is flaky around 10% of the runs. Could you please check what might be the issue?

[hoy]

In D121655#3419998, @goncharov wrote:

Hi, I have found that cs-preinline-sample-profile.test is flaky around 10% of the runs. Could you please check what might be the issue?

Thanks for reporting this issue. Let me double check and try to repro.

[hoy]

In D121655#3420056, @hoy wrote:

In D121655#3419998, @goncharov wrote:

Hi, I have found that cs-preinline-sample-profile.test is flaky around 10% of the runs. Could you please check what might be the issue?

Thanks for reporting this issue. Let me double check and try to repro.

An update on this. It appears this new test exposed an existing issue. This should be fixed by D122844.

llvm/test/tools/llvm-profgen/cold-profile-trimming-symbolized.test

+; RUN: llvm-profgen --format=text --unsymbolized-profile=%S/Inputs/cold-profile-trimming.raw.prof --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t1 --use-offset=0
+; RUN: llvm-profgen --format=text --llvm-sample-profile=%t1 --binary=%S/Inputs/inline-noprobe2.perfbin --output=%t2 --trim-cold-profile=1 --profile-summary-cold-count=1000
+; RUN: FileCheck %s --input-file %t2 --check-prefix=CHECK-TRIM
+
+
+;CHECK-TRIM: partition_pivot_last:5187:7
+;CHECK-TRIM: partition_pivot_first:3010:5
+;CHECK-TRIM-NOT: quick_sort:903:25
+;CHECK-TRIM-NOT: main:820:0
+
+; original code:
+; clang -O3 -g -fno-optimize-sibling-calls -fdebug-info-for-profiling qsort.c -o a.out
+#include <stdio.h>
+#include <stdlib.h>
+
+void swap(int *a, int *b) {
+  int t = *a;
+  *a = *b;
+  *b = t;
+}
+
+int partition_pivot_last(int* array, int low, int high) {
+  int pivot = array[high];
+  int i = low - 1;
+  for (int j = low; j < high; j++)
+    if (array[j] < pivot)
+      swap(&array[++i], &array[j]);
+  swap(&array[i + 1], &array[high]);
+  return (i + 1);
+}
+
+int partition_pivot_first(int* array, int low, int high) {
+  int pivot = array[low];
+  int i = low + 1;
+  for (int j = low + 1; j <= high; j++)
+    if (array[j] < pivot) { if (j != i) swap(&array[i], &array[j]); i++;}
+  swap(&array[i - 1], &array[low]);
+  return i - 1;
+}
+
+void quick_sort(int* array, int low, int high, int (*partition_func)(int *, int, int)) {
+  if (low < high) {
+    int pi = (*partition_func)(array, low, high);
+    quick_sort(array, low, pi - 1, partition_func);
+    quick_sort(array, pi + 1, high, partition_func);
+  }
+}
+
+int main() {
+  const int size = 200;
+  int sum = 0;
+  int *array = malloc(size * sizeof(int));
+  for(int i = 0; i < 100 * 1000; i++) {
+    for(int j = 0; j < size; j++)
+      array[j] = j % 10 ? rand() % size: j;
+    int (*fptr)(int *, int, int) = i % 3 ? partition_pivot_last : partition_pivot_first;
+    quick_sort(array, 0, size - 1, fptr);
+    sum += array[i % size];
+  }
+  printf("sum=%d\n", sum);
+
+  return 0;
+}

llvm/test/tools/llvm-profgen/cs-preinline-sample-profile.test

+; Test default llvm-profgen with preinline off
+; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-noprobe.perfscript --binary=%S/Inputs/inline-cs-noprobe.perfbin --csspgo-preinliner=0 --gen-cs-nested-profile=0 --output=%t1
+
+; Test llvm-profgen with preinliner on will merge not inlinable profile into base profile.
+; RUN: llvm-profgen --format=text --llvm-sample-profile=%t1 --binary=%S/Inputs/inline-cs-noprobe.perfbin --csspgo-preinliner=1 --gen-cs-nested-profile=0 --sample-profile-hot-inline-threshold=3000 --sample-profile-cold-inline-threshold=45 --output=%t2
+; RUN: FileCheck %s --input-file %t2 --check-prefix=CHECK-PREINL
+
+; Test default llvm-profgen with preinline off
+; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --csspgo-preinliner=0 --gen-cs-nested-profile=0 --output=%t3
+
+; Test llvm-profgen with preinliner on will merge not inlinable profile into base profile.
+; RUN: llvm-profgen --format=text --llvm-sample-profile=%t3 --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --csspgo-preinliner=1 --gen-cs-nested-profile=0 --sample-profile-hot-inline-threshold=3000 --sample-profile-cold-inline-threshold=45 --output=%t4
+; RUN: FileCheck %s --input-file %t4 --check-prefix=CHECK-PREINL-PROBE
+
+; CHECK-PREINL:     [foo]:309:0
+; CHECK-PREINL-NEXT: 2.1: 14
+; CHECK-PREINL-NEXT: 3: 15
+; CHECK-PREINL-NEXT: 3.1: 14 bar:14
+; CHECK-PREINL-NEXT: 3.2: 1
+; CHECK-PREINL-NEXT: 65526: 14
+; CHECK-PREINL-NEXT: !Attributes: 1
+; CHECK-PREINL-NEXT:[foo:3.1 @ bar]:84:0
+; CHECK-PREINL-NEXT: 1: 14
+; CHECK-PREINL-NEXT: !Attributes: 3
+
+
+; CHECK-PREINL-PROBE:     [foo]:74:0
+; CHECK-PREINL-PROBE-NEXT: 1: 0
+; CHECK-PREINL-PROBE-NEXT: 2: 15
+; CHECK-PREINL-PROBE-NEXT: 3: 15
+; CHECK-PREINL-PROBE-NEXT: 4: 14
+; CHECK-PREINL-PROBE-NEXT: 5: 1
+; CHECK-PREINL-PROBE-NEXT: 6: 15
+; CHECK-PREINL-PROBE-NEXT: 7: 0
+; CHECK-PREINL-PROBE-NEXT: 8: 14 bar:14
+; CHECK-PREINL-PROBE-NEXT: 9: 0
+; CHECK-PREINL-PROBE-NEXT: !CFGChecksum: 563088904013236
+; CHECK-PREINL-PROBE-NEXT: !Attributes: 1
+; CHECK-PREINL-PROBE-NEXT:[foo:8 @ bar]:28:14
+; CHECK-PREINL-PROBE-NEXT: 1: 14
+; CHECK-PREINL-PROBE-NEXT: 4: 14
+; CHECK-PREINL-PROBE-NEXT: !CFGChecksum: 72617220756
+; CHECK-PREINL-PROBE-NEXT: !Attributes: 3

llvm/tools/llvm-profgen/ProfileGenerator.h

 
 // 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,
-                       const ContextSampleCounterMap &Counters)
+                       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 &SampleCounters,
+  create(ProfiledBinary *Binary, const ContextSampleCounterMap *Counters,
+         bool ProfileIsCSFlat);
+  static std::unique_ptr<ProfileGeneratorBase>
+  create(ProfiledBinary *Binary, const SampleProfileMap &&ProfileMap,
          bool ProfileIsCSFlat);
   virtual void generateProfile() = 0;
   void write();
 
   static uint32_t
   getDuplicationFactor(unsigned Discriminator,
                        bool UseFSD = ProfileGeneratorBase::UseFSDiscriminator) {
     return UseFSD ? 1
protected:
 
   void collectProfiledFunctions();
 
   // Thresholds from profile summary to answer isHotCount/isColdCount queries.
   uint64_t HotCountThreshold;
 
   uint64_t ColdCountThreshold;
 
+  ProfiledBinary *Binary = nullptr;
+
   // Used by SampleProfileWriter
   SampleProfileMap ProfileMap;
 
-  ProfiledBinary *Binary = nullptr;
-
-  const ContextSampleCounterMap &SampleCounters;
+  const ContextSampleCounterMap *SampleCounters = nullptr;
 };
 
 class ProfileGenerator : public ProfileGeneratorBase {
 
 public:
   ProfileGenerator(ProfiledBinary *Binary,
-                   const ContextSampleCounterMap &Counters)
+                   const ContextSampleCounterMap *Counters)
       : ProfileGeneratorBase(Binary, Counters){};
+  ProfileGenerator(ProfiledBinary *Binary, const SampleProfileMap &&Profiles)
+      : ProfileGeneratorBase(Binary, std::move(Profiles)){};
   void generateProfile() override;
 
 private:
   void generateLineNumBasedProfile();
   void generateProbeBasedProfile();
   RangeSample preprocessRangeCounter(const RangeSample &RangeCounter);
   FunctionSamples &getTopLevelFunctionProfile(StringRef FuncName);
   // Helper function to get the leaf frame's FunctionProfile by traversing the
   // inline stack and meanwhile it adds the total samples for each frame's
   // function profile.
   FunctionSamples &
   getLeafProfileAndAddTotalSamples(const SampleContextFrameVector &FrameVec,
                                    uint64_t Count);
   void populateBodySamplesForAllFunctions(const RangeSample &RangeCounter);
   void
   populateBoundarySamplesForAllFunctions(const BranchSample &BranchCounters);
-  void populateBodySamplesWithProbesForAllFunctions(const RangeSample &RangeCounter);
   void
-  populateBoundarySamplesWithProbesForAllFunctions(const BranchSample &BranchCounters);
+  populateBodySamplesWithProbesForAllFunctions(const RangeSample &RangeCounter);
+  void populateBoundarySamplesWithProbesForAllFunctions(
+      const BranchSample &BranchCounters);
   void postProcessProfiles();
   void trimColdProfiles(const SampleProfileMap &Profiles,
                         uint64_t ColdCntThreshold);
 };
 
 class CSProfileGenerator : public ProfileGeneratorBase {
 public:
   CSProfileGenerator(ProfiledBinary *Binary,
-                     const ContextSampleCounterMap &Counters)
+                     const ContextSampleCounterMap *Counters)
       : ProfileGeneratorBase(Binary, Counters){};
-
+  CSProfileGenerator(ProfiledBinary *Binary, const SampleProfileMap &&Profiles)
+      : ProfileGeneratorBase(Binary, std::move(Profiles)){};
   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(),

llvm/tools/llvm-profgen/ProfileGenerator.cpp

 //===-- ProfileGenerator.cpp - Profile Generator  ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "ProfileGenerator.h"
 #include "ErrorHandling.h"
+#include "PerfReader.h"
 #include "ProfiledBinary.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include <algorithm>
 #include <float.h>
 #include <unordered_set>
+#include <utility>
 
 cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                     cl::Required,
                                     cl::desc("Output profile file"));
 static cl::alias OutputA("o", cl::desc("Alias for --output"),
                          cl::aliasopt(OutputFilename));
 
 static cl::opt<SampleProfileFormat> OutputFormat(

 int32_t CSProfileGenerator::MaxCompressionSize = -1;
 
 int CSProfileGenerator::MaxContextDepth = -1;
 
 bool ProfileGeneratorBase::UseFSDiscriminator = false;
 
 std::unique_ptr<ProfileGeneratorBase>
 ProfileGeneratorBase::create(ProfiledBinary *Binary,
-                             const ContextSampleCounterMap &SampleCounters,
+                             const ContextSampleCounterMap *SampleCounters,
                              bool ProfileIsCSFlat) {
   std::unique_ptr<ProfileGeneratorBase> Generator;
   if (ProfileIsCSFlat) {
     if (Binary->useFSDiscriminator())
       exitWithError("FS discriminator is not supported in CS profile.");
     Generator.reset(new CSProfileGenerator(Binary, SampleCounters));
   } else {
     Generator.reset(new ProfileGenerator(Binary, SampleCounters));
   }
   ProfileGeneratorBase::UseFSDiscriminator = Binary->useFSDiscriminator();
   FunctionSamples::ProfileIsFS = Binary->useFSDiscriminator();
 
   return Generator;
 }
 
+std::unique_ptr<ProfileGeneratorBase>
+ProfileGeneratorBase::create(ProfiledBinary *Binary,
+                             const SampleProfileMap &&Profiles,
+                             bool ProfileIsCSFlat) {
+  std::unique_ptr<ProfileGeneratorBase> Generator;
+  if (ProfileIsCSFlat) {
+    if (Binary->useFSDiscriminator())
+      exitWithError("FS discriminator is not supported in CS profile.");
+    Generator.reset(new CSProfileGenerator(Binary, std::move(Profiles)));
+  } else {
+    Generator.reset(new ProfileGenerator(Binary, std::move(Profiles)));
+  }
+  ProfileGeneratorBase::UseFSDiscriminator = Binary->useFSDiscriminator();
+  FunctionSamples::ProfileIsFS = Binary->useFSDiscriminator();
+
+  return Generator;
+}
+
 void ProfileGeneratorBase::write(std::unique_ptr<SampleProfileWriter> Writer,
                                  SampleProfileMap &ProfileMap) {
   // Populate profile symbol list if extended binary format is used.
   ProfileSymbolList SymbolList;
 
   if (PopulateProfileSymbolList && OutputFormat == SPF_Ext_Binary) {
     Binary->populateSymbolListFromDWARF(SymbolList);
     Writer->setProfileSymbolList(&SymbolList);
void ProfileGeneratorBase::updateTotalSamples() {
   for (auto &Item : ProfileMap) {
     FunctionSamples &FunctionProfile = Item.second;
     FunctionProfile.updateTotalSamples();
   }
 }
 
 void ProfileGeneratorBase::collectProfiledFunctions() {
   std::unordered_set<const BinaryFunction *> ProfiledFunctions;
-  // 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
+  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) {
+    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);
         }
       }
 
       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);
+    }
+  }
 
   Binary->setProfiledFunctions(ProfiledFunctions);
 }
 
 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;
 }
 
 void ProfileGenerator::generateProfile() {
   collectProfiledFunctions();
+
+  if (Binary->usePseudoProbes())
+    Binary->decodePseudoProbe();
+
+  if (SampleCounters) {
     if (Binary->usePseudoProbes()) {
       generateProbeBasedProfile();
     } else {
       generateLineNumBasedProfile();
     }
+  }
+
   postProcessProfiles();
 }
 
 void ProfileGenerator::postProcessProfiles() {
   computeSummaryAndThreshold();
   trimColdProfiles(ProfileMap, ColdCountThreshold);
   calculateAndShowDensity(ProfileMap);
 }
void ProfileGenerator::trimColdProfiles(const SampleProfileMap &Profiles,
   }
 
   // Remove the cold profile from ProfileMap.
   for (const auto &I : ColdProfiles)
     ProfileMap.erase(I);
 }
 
 void ProfileGenerator::generateLineNumBasedProfile() {
-  assert(SampleCounters.size() == 1 &&
+  assert(SampleCounters->size() == 1 &&
          "Must have one entry for profile generation.");
-  const SampleCounter &SC = SampleCounters.begin()->second;
+  const SampleCounter &SC = SampleCounters->begin()->second;
   // Fill in function body samples
   populateBodySamplesForAllFunctions(SC.RangeCounter);
   // Fill in boundary sample counts as well as call site samples for calls
   populateBoundarySamplesForAllFunctions(SC.BranchCounter);
 
   updateTotalSamples();
 }
 
 void ProfileGenerator::generateProbeBasedProfile() {
-  assert(SampleCounters.size() == 1 &&
+  assert(SampleCounters->size() == 1 &&
          "Must have one entry for profile generation.");
-  Binary->decodePseudoProbe();
   // Enable pseudo probe functionalities in SampleProf
   FunctionSamples::ProfileIsProbeBased = true;
-  const SampleCounter &SC = SampleCounters.begin()->second;
+  const SampleCounter &SC = SampleCounters->begin()->second;
   // Fill in function body samples
   populateBodySamplesWithProbesForAllFunctions(SC.RangeCounter);
   // Fill in boundary sample counts as well as call site samples for calls
   populateBoundarySamplesWithProbesForAllFunctions(SC.BranchCounter);
 
   updateTotalSamples();
 }
 
FunctionSamples &CSProfileGenerator::getFunctionProfileForContext(
   return I->second;
 }
 
 void CSProfileGenerator::generateProfile() {
   FunctionSamples::ProfileIsCSFlat = true;
 
   collectProfiledFunctions();
 
+  if (Binary->usePseudoProbes())
+    Binary->decodePseudoProbe();
+
+  if (SampleCounters) {
     if (Binary->usePseudoProbes()) {
       generateProbeBasedProfile();
     } else {
       generateLineNumBasedProfile();
     }
+  }
 
   if (Binary->getTrackFuncContextSize())
     computeSizeForProfiledFunctions();
 
   postProcessProfiles();
 }
 
 void CSProfileGenerator::computeSizeForProfiledFunctions() {
   std::unordered_set<const BinaryFunction *> ProfiledFunctions;
   for (auto *Func : Binary->getProfiledFunctions())
     Binary->computeInlinedContextSizeForFunc(Func);
 
   // Flush the symbolizer to save memory.
   Binary->flushSymbolizer();
 }
 
 void CSProfileGenerator::generateLineNumBasedProfile() {
-  for (const auto &CI : SampleCounters) {
+  for (const auto &CI : *SampleCounters) {
     const auto *CtxKey = cast<StringBasedCtxKey>(CI.first.getPtr());
 
     // Get or create function profile for the range
     FunctionSamples &FunctionProfile =
         getFunctionProfileForContext(CtxKey->Context, CtxKey->WasLeafInlined);
 
     // Fill in function body samples
     populateBodySamplesForFunction(FunctionProfile, CI.second.RangeCounter);
extractPrefixContextStack(SampleContextFrameVector &ContextStack,
   // Extract context stack for reusing, leaf context stack will be added
   // compressed while looking up function profile.
   for (const auto *P : Probes) {
     Binary->getInlineContextForProbe(P, ContextStack, true);
   }
 }
 
 void CSProfileGenerator::generateProbeBasedProfile() {
-  Binary->decodePseudoProbe();
   // Enable pseudo probe functionalities in SampleProf
   FunctionSamples::ProfileIsProbeBased = true;
-  for (const auto &CI : SampleCounters) {
+  for (const auto &CI : *SampleCounters) {
     const AddrBasedCtxKey *CtxKey =
         dyn_cast<AddrBasedCtxKey>(CI.first.getPtr());
     SampleContextFrameVector ContextStack;
     extractPrefixContextStack(ContextStack, CtxKey->Context, Binary);
     // Fill in function body samples from probes, also infer caller's samples
     // from callee's probe
     populateBodySamplesWithProbes(CI.second.RangeCounter, ContextStack);
     // Fill in boundary samples for a call probe

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

static cl::opt<std::string> UnsymbolizedProfFilename(
     cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated,
     cl::desc("Path of the unsymbolized profile created by "
              "`llvm-profgen` with `--skip-symbolization`"),
     cl::cat(ProfGenCategory));
 static cl::alias UPA("up", cl::desc("Alias for --unsymbolized-profile"),
                      cl::aliasopt(UnsymbolizedProfFilename));
 
 static cl::opt<std::string>
+    SampleProfFilename("llvm-sample-profile",
+                       cl::value_desc("llvm sample profile"), cl::ZeroOrMore,
+                       cl::desc("Path of the LLVM sample profile"),
+                       cl::cat(ProfGenCategory));
+
+static cl::opt<std::string>
     BinaryPath("binary", cl::value_desc("binary"), cl::Required,
                cl::desc("Path of profiled executable binary."),
                cl::cat(ProfGenCategory));
 
 static cl::opt<std::string> DebugBinPath(
     "debug-binary", cl::value_desc("debug-binary"), cl::ZeroOrMore,
     cl::desc("Path of debug info binary, llvm-profgen will load the DWARF info "
              "from it instead of the executable binary."),

 static void validateCommandLine() {
   // Allow the missing perfscript if we only use to show binary disassembly.
   if (!ShowDisassemblyOnly) {
     // Validate input profile is provided only once
     uint16_t HasPerfData = PerfDataFilename.getNumOccurrences();
     uint16_t HasPerfScript = PerfScriptFilename.getNumOccurrences();
     uint16_t HasUnsymbolizedProfile =
         UnsymbolizedProfFilename.getNumOccurrences();
-    uint16_t S = HasPerfData + HasPerfScript + HasUnsymbolizedProfile;
+    uint16_t HasSampleProfile = SampleProfFilename.getNumOccurrences();
+    uint16_t S =
+        HasPerfData + HasPerfScript + HasUnsymbolizedProfile + HasSampleProfile;
     if (S != 1) {
       std::string Msg =
           S > 1
               ? "`--perfscript`, `--perfdata` and `--unsymbolized-profile` "
                 "cannot be used together."
               : "Perf input file is missing, please use one of `--perfscript`, "
                 "`--perfdata` and `--unsymbolized-profile` for the input.";
       exitWithError(Msg);
     }
 
     auto CheckFileExists = [](bool H, StringRef File) {
       if (H && !llvm::sys::fs::exists(File)) {
         std::string Msg = "Input perf file(" + File.str() + ") doesn't exist.";
         exitWithError(Msg);
       }
     };
 
     CheckFileExists(HasPerfData, PerfDataFilename);
     CheckFileExists(HasPerfScript, PerfScriptFilename);
     CheckFileExists(HasUnsymbolizedProfile, UnsymbolizedProfFilename);
+    CheckFileExists(HasSampleProfile, SampleProfFilename);
   }
 
   if (!llvm::sys::fs::exists(BinaryPath)) {
     std::string Msg = "Input binary(" + BinaryPath + ") doesn't exist.";
     exitWithError(Msg);
   }
 
   if (CSProfileGenerator::MaxCompressionSize < -1) {
int main(int argc, const char *argv[]) {
   validateCommandLine();
 
   // Load symbols and disassemble the code of a given binary.
   std::unique_ptr<ProfiledBinary> Binary =
       std::make_unique<ProfiledBinary>(BinaryPath, DebugBinPath);
   if (ShowDisassemblyOnly)
     return EXIT_SUCCESS;
 
+  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()),
+                                     Reader->profileIsCSFlat());
+    Generator->generateProfile();
+    Generator->write();
+  } else {
     PerfInputFile PerfFile = getPerfInputFile();
     std::unique_ptr<PerfReaderBase> Reader =
         PerfReaderBase::create(Binary.get(), PerfFile);
     // Parse perf events and samples
     Reader->parsePerfTraces();
 
     if (SkipSymbolization)
       return EXIT_SUCCESS;
 
     std::unique_ptr<ProfileGeneratorBase> Generator =
-      ProfileGeneratorBase::create(Binary.get(), Reader->getSampleCounters(),
+        ProfileGeneratorBase::create(Binary.get(), &Reader->getSampleCounters(),
                                      Reader->profileIsCSFlat());
     Generator->generateProfile();
     Generator->write();
+  }
 
   return EXIT_SUCCESS;
 }