[llvm-profdata] Changed SampleProfWriter to take a range of of NameFunctionSamples

[huangjd]

Summary

Most functions in SampleProfWriter previously taking a
SampleProfileMap now take llvm::ArrayRef<NameFunctionSamples> instead.
The original write interface takes a SampleProfileMap and immediately
sorts it into a vector<NameFunctionSamples> before passing it down to
the actual write implementations.

The purpose of this change is to allow SampleProfWriter to take a slice
of the profile to write to file, instead of having to modify or
reconstruct a SampleProfileMap, which is very slow. In a following patch
I am going to enhance the functionality of reducing profile size limit,
which will make heavy use of the new SampleProfWriter interface.

[wenlei]

cc @hoy @wlei

[davidxl]

A meta comment -- when the parameter type is change, the name of the parameter should also be changed. In this case 'profileMap' is no longer meaningful.

llvm/include/llvm/ProfileData/SampleProf.h

1562

using template to share code with flattenProfile above?

llvm/include/llvm/ProfileData/ProfileCommon.h

 public:
   SampleProfileSummaryBuilder(std::vector<uint32_t> Cutoffs)
       : ProfileSummaryBuilder(std::move(Cutoffs)) {}
 
   void addRecord(const sampleprof::FunctionSamples &FS,
                  bool isCallsiteSample = false);
   std::unique_ptr<ProfileSummary>
   computeSummaryForProfiles(const sampleprof::SampleProfileMap &Profiles);
+  std::unique_ptr<ProfileSummary>
+  computeSummaryForProfiles(const ArrayRef<NameFunctionSamples> &Profiles);
   std::unique_ptr<ProfileSummary> getSummary();
 };
 
 /// This is called when a count is seen in the profile.
 void ProfileSummaryBuilder::addCount(uint64_t Count) {
   TotalCount += Count;
   if (Count > MaxCount)
     MaxCount = Count;
   NumCounts++;
   CountFrequencies[Count]++;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_PROFILECOMMON_H

llvm/include/llvm/ProfileData/SampleProf.h

if (ProfileIsCS) {
         FS.merge(I.second);
       }
     } else {
       for (const auto &I : InputProfiles)
         flattenNestedProfile(OutputProfiles, I.second);
     }
   }
 
+  static void flattenProfile(const ArrayRef<NameFunctionSamples> &InputProfiles,
+                             SampleProfileMap &OutputProfiles,
+                             bool ProfileIsCS = false) {
+    if (ProfileIsCS) {
+      for (const auto &I : InputProfiles) {
+        // Retain the profile name and clear the full context for each function
+        // profile.
+        FunctionSamples &FS = OutputProfiles.Create(I.second->getName());
+        FS.merge(*I.second);
+      }
+    } else {
+      for (const auto &I : InputProfiles)
+        flattenNestedProfile(OutputProfiles, *I.second);
+    }
+  }
+
 private:
   static void flattenNestedProfile(SampleProfileMap &OutputProfiles,
                                    const FunctionSamples &FS) {
     // To retain the context, checksum, attributes of the original profile, make
     // a copy of it if no profile is found.
     SampleContext &Context = FS.getContext();
     auto Ret = OutputProfiles.try_emplace(Context, FS);
     FunctionSamples &Profile = Ret.first->second;

llvm/include/llvm/ProfileData/SampleProfWriter.h

public:
   /// by total sample count.
   /// TODO: Find better heuristic.
   void Erase(size_t CurrentOutputSize) override;
 };
 
 /// Sample-based profile writer. Base class.
 class SampleProfileWriter {
 public:
+  using FunctionSamplesVector = const llvm::ArrayRef<NameFunctionSamples>;
+
   virtual ~SampleProfileWriter() = default;
 
   /// Write sample profiles in \p S.
   ///
   /// \returns status code of the file update operation.
   virtual std::error_code writeSample(const FunctionSamples &S) = 0;
 
   /// Write all the sample profiles in the given map of samples.
   ///
   /// \returns status code of the file update operation.
-  virtual std::error_code write(const SampleProfileMap &ProfileMap);
+  std::error_code write(const SampleProfileMap &ProfileMap) {
+    std::vector<NameFunctionSamples> SortedProfiles;
+    sortFuncProfiles(ProfileMap, SortedProfiles);
+    return write(SortedProfiles);
+  }
+
+  virtual std::error_code write(FunctionSamplesVector &ProfileMap);
 
   /// Write sample profiles up to given size limit, using the pruning strategy
   /// to drop some functions if necessary.
   ///
   /// \returns status code of the file update operation.
   template <typename FunctionPruningStrategy = DefaultFunctionPruningStrategy>
   std::error_code writeWithSizeLimit(SampleProfileMap &ProfileMap,
                                      size_t OutputSizeLimit) {
public:
   virtual void setPartialProfile() {}
   virtual void resetSecLayout(SectionLayout SL) {}
 
 protected:
   SampleProfileWriter(std::unique_ptr<raw_ostream> &OS)
       : OutputStream(std::move(OS)) {}
 
   /// Write a file header for the profile file.
-  virtual std::error_code writeHeader(const SampleProfileMap &ProfileMap) = 0;
+  virtual std::error_code writeHeader(FunctionSamplesVector &ProfileMap) = 0;
 
   // Write function profiles to the profile file.
-  virtual std::error_code writeFuncProfiles(const SampleProfileMap &ProfileMap);
+  virtual std::error_code writeFuncProfiles(FunctionSamplesVector &ProfileMap);
 
   std::error_code writeWithSizeLimitInternal(SampleProfileMap &ProfileMap,
                                              size_t OutputSizeLimit,
                                              FunctionPruningStrategy *Strategy);
 
   /// For writeWithSizeLimit in text mode, each newline takes 1 additional byte
   /// on Windows when actually written to the file, but not written to a memory
   /// buffer. This needs to be accounted for when rewriting the profile.
   size_t LineCount;
 
   /// Output stream where to emit the profile to.
   std::unique_ptr<raw_ostream> OutputStream;
 
   /// Profile summary.
   std::unique_ptr<ProfileSummary> Summary;
 
   /// Compute summary for this profile.
-  void computeSummary(const SampleProfileMap &ProfileMap);
+  void computeSummary(FunctionSamplesVector &ProfileMap);
 
   /// Profile format.
   SampleProfileFormat Format = SPF_None;
 };
 
 /// Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:
   std::error_code writeSample(const FunctionSamples &S) override;
 
 protected:
   SampleProfileWriterText(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS), Indent(0) {}
 
-  std::error_code writeHeader(const SampleProfileMap &ProfileMap) override {
+  std::error_code writeHeader(FunctionSamplesVector &ProfileMap) override {
     LineCount = 0;
     return sampleprof_error::success;
   }
 
 private:
   /// Indent level to use when writing.
   ///
   /// This is used when printing inlined callees.
SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS) {}
 
   std::error_code writeSample(const FunctionSamples &S) override;
 
 protected:
   virtual MapVector<StringRef, uint32_t> &getNameTable() { return NameTable; }
   virtual std::error_code writeMagicIdent(SampleProfileFormat Format);
   virtual std::error_code writeNameTable();
-  std::error_code writeHeader(const SampleProfileMap &ProfileMap) override;
+  std::error_code writeHeader(FunctionSamplesVector &ProfileMap) override;
   std::error_code writeSummary();
   virtual std::error_code writeContextIdx(const SampleContext &Context);
   std::error_code writeNameIdx(StringRef FName);
   std::error_code writeBody(const FunctionSamples &S);
   inline void stablizeNameTable(MapVector<StringRef, uint32_t> &NameTable,
                                 std::set<StringRef> &V);
 
   MapVector<StringRef, uint32_t> NameTable;
ExtBinaryHdrLayoutTable = {
                                           {SecLBRProfile, 0, 0, 0, 0},
                                           {SecProfileSymbolList, 0, 0, 0, 0},
                                           {SecFuncMetadata, 0, 0, 0, 0}}),
 };
 
 class SampleProfileWriterExtBinaryBase : public SampleProfileWriterBinary {
   using SampleProfileWriterBinary::SampleProfileWriterBinary;
 public:
-  std::error_code write(const SampleProfileMap &ProfileMap) override;
+  std::error_code write(FunctionSamplesVector &ProfileMap) override;
 
   void setToCompressAllSections() override;
   void setToCompressSection(SecType Type);
   std::error_code writeSample(const FunctionSamples &S) override;
 
   // Set to use MD5 to represent string in NameTable.
   void setUseMD5() override {
     UseMD5 = true;
protected:
   void addContext(const SampleContext &Context) override;
 
   // placeholder for subclasses to dispatch their own section writers.
   virtual std::error_code writeCustomSection(SecType Type) = 0;
   // Verify the SecLayout is supported by the format.
   virtual void verifySecLayout(SectionLayout SL) = 0;
 
   // specify the order to write sections.
-  virtual std::error_code writeSections(const SampleProfileMap &ProfileMap) = 0;
+  virtual std::error_code writeSections(FunctionSamplesVector &ProfileMap) = 0;
 
   // Dispatch section writer for each section. \p LayoutIdx is the sequence
   // number indicating where the section is located in SectionHdrLayout.
   virtual std::error_code writeOneSection(SecType Type, uint32_t LayoutIdx,
-                                          const SampleProfileMap &ProfileMap);
+                                          FunctionSamplesVector &ProfileMap);
 
   // Helper function to write name table.
   std::error_code writeNameTable() override;
   std::error_code writeContextIdx(const SampleContext &Context) override;
   std::error_code writeCSNameIdx(const SampleContext &Context);
   std::error_code writeCSNameTableSection();
 
-  std::error_code writeFuncMetadata(const SampleProfileMap &Profiles);
+  std::error_code writeFuncMetadata(FunctionSamplesVector &Profiles);
   std::error_code writeFuncMetadata(const FunctionSamples &Profile);
 
   // Functions to write various kinds of sections.
-  std::error_code writeNameTableSection(const SampleProfileMap &ProfileMap);
+  std::error_code writeNameTableSection(FunctionSamplesVector &ProfileMap);
   std::error_code writeFuncOffsetTable();
   std::error_code writeProfileSymbolListSection();
 
   SectionLayout SecLayout = DefaultLayout;
   // Specifiy the order of sections in section header table. Note
   // the order of sections in SecHdrTable may be different that the
   // order in SectionHdrLayout. sample Reader will follow the order
   // in SectionHdrLayout to read each section.
   SmallVector<SecHdrTableEntry, 8> SectionHdrLayout =
       ExtBinaryHdrLayoutTable[DefaultLayout];
 
   // Save the start of SecLBRProfile so we can compute the offset to the
   // start of SecLBRProfile for each Function's Profile and will keep it
   // in FuncOffsetTable.
   uint64_t SecLBRProfileStart = 0;
 
 private:
   void allocSecHdrTable();
   std::error_code writeSecHdrTable();
-  std::error_code writeHeader(const SampleProfileMap &ProfileMap) override;
+  std::error_code writeHeader(FunctionSamplesVector &ProfileMap) override;
   std::error_code compressAndOutput();
 
   // We will swap the raw_ostream held by LocalBufStream and that
   // held by OutputStream if we try to add a section which needs
   // compression. After the swap, all the data written to output
   // will be temporarily buffered into the underlying raw_string_ostream
   // originally held by LocalBufStream. After the data writing for the
   // section is completed, compress the data in the local buffer,

 };
 
 class SampleProfileWriterExtBinary : public SampleProfileWriterExtBinaryBase {
 public:
   SampleProfileWriterExtBinary(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriterExtBinaryBase(OS) {}
 
 private:
-  std::error_code writeDefaultLayout(const SampleProfileMap &ProfileMap);
-  std::error_code writeCtxSplitLayout(const SampleProfileMap &ProfileMap);
+  std::error_code writeDefaultLayout(FunctionSamplesVector &ProfileMap);
+  std::error_code writeCtxSplitLayout(FunctionSamplesVector &ProfileMap);
 
-  std::error_code writeSections(const SampleProfileMap &ProfileMap) override;
+  std::error_code writeSections(FunctionSamplesVector &ProfileMap) override;
 
   std::error_code writeCustomSection(SecType Type) override {
     return sampleprof_error::success;
   };
 
   void verifySecLayout(SectionLayout SL) override {
     assert((SL == DefaultLayout || SL == CtxSplitLayout) &&
            "Unsupported layout");
   }
 };
 
 } // end namespace sampleprof
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_SAMPLEPROFWRITER_H

llvm/lib/ProfileData/ProfileSummaryBuilder.cpp

SampleProfileSummaryBuilder::computeSummaryForProfiles(
   for (const auto &I : *ProfilesToUse) {
     const sampleprof::FunctionSamples &Profile = I.second;
     addRecord(Profile);
   }
 
   return getSummary();
 }
 
+/// Overload computeSummaryForProfiles to accept pointer to FunctionSamples.
+std::unique_ptr<ProfileSummary>
+SampleProfileSummaryBuilder::computeSummaryForProfiles(
+    const ArrayRef<NameFunctionSamples> &Profiles) {
+  assert(NumFunctions == 0 &&
+         "This can only be called on an empty summary builder");
+  sampleprof::SampleProfileMap ContextLessProfiles;
+  if (UseContextLessSummary || (sampleprof::FunctionSamples::ProfileIsCS &&
+                                !UseContextLessSummary.getNumOccurrences())) {
+    ProfileConverter::flattenProfile(Profiles, ContextLessProfiles, true);
+    for (const auto &I : ContextLessProfiles)
+      addRecord(I.second);
+  } else {
+    for (const auto &I : Profiles)
+      addRecord(*I.second);
+  }
+
+  return getSummary();
+}
+
 std::unique_ptr<ProfileSummary> InstrProfSummaryBuilder::getSummary() {
   computeDetailedSummary();
   return std::make_unique<ProfileSummary>(
       ProfileSummary::PSK_Instr, DetailedSummary, TotalCount, MaxCount,
       MaxInternalBlockCount, MaxFunctionCount, NumCounts, NumFunctions);
 }
 
 void InstrProfSummaryBuilder::addEntryCount(uint64_t Count) {

llvm/lib/ProfileData/SampleProfWriter.cpp

LLVM_DEBUG(dbgs() << "Profile originally has " << OriginalFunctionCount
                     << IterationCount << " iterations\n");
   // Silence warning on Release build.
   (void)OriginalFunctionCount;
   (void)IterationCount;
   return sampleprof_error::success;
 }
 
 std::error_code
-SampleProfileWriter::writeFuncProfiles(const SampleProfileMap &ProfileMap) {
-  std::vector<NameFunctionSamples> V;
-  sortFuncProfiles(ProfileMap, V);
-  for (const auto &I : V) {
+SampleProfileWriter::writeFuncProfiles(FunctionSamplesVector &ProfileMap) {
+  for (const auto &I : ProfileMap) {
     if (std::error_code EC = writeSample(*I.second))
       return EC;
   }
   return sampleprof_error::success;
 }
 
-std::error_code SampleProfileWriter::write(const SampleProfileMap &ProfileMap) {
+std::error_code SampleProfileWriter::write(FunctionSamplesVector &ProfileMap) {
   if (std::error_code EC = writeHeader(ProfileMap))
     return EC;
 
   if (std::error_code EC = writeFuncProfiles(ProfileMap))
     return EC;
 
   return sampleprof_error::success;
 }
if (std::error_code EC = compressAndOutput())
       return EC;
   }
   SecHdrTable.push_back({Type, Entry.Flags, SectionStart - FileStart,
                          OutputStream->tell() - SectionStart, LayoutIdx});
   return sampleprof_error::success;
 }
 
 std::error_code
-SampleProfileWriterExtBinaryBase::write(const SampleProfileMap &ProfileMap) {
+SampleProfileWriterExtBinaryBase::write(FunctionSamplesVector &ProfileMap) {
   // When calling write on a different profile map, existing states should be
   // cleared.
   NameTable.clear();
   CSNameTable.clear();
   SecHdrTable.clear();
 
   if (std::error_code EC = writeHeader(ProfileMap))
     return EC;
for (const auto &J : FunctionProfile.getCallsiteSamples()) {
       }
     }
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeFuncMetadata(
-    const SampleProfileMap &Profiles) {
+    FunctionSamplesVector &Profiles) {
   if (!FunctionSamples::ProfileIsProbeBased && !FunctionSamples::ProfileIsCS &&
       !FunctionSamples::ProfileIsPreInlined)
     return sampleprof_error::success;
   for (const auto &Entry : Profiles) {
-    if (std::error_code EC = writeFuncMetadata(Entry.second))
+    if (std::error_code EC = writeFuncMetadata(*Entry.second))
       return EC;
   }
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeNameTable() {
   if (!UseMD5)
     return SampleProfileWriterBinary::writeNameTable();
 
   auto &OS = *OutputStream;
   std::set<StringRef> V;
   stablizeNameTable(NameTable, V);
 
   // Write out the MD5 name table. We wrote unencoded MD5 so reader can
   // retrieve the name using the name index without having to read the
   // whole name table.
   encodeULEB128(NameTable.size(), OS);
   support::endian::Writer Writer(OS, support::little);
   for (auto N : V)
     Writer.write(hashFuncName(N));
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeNameTableSection(
-    const SampleProfileMap &ProfileMap) {
+    FunctionSamplesVector &ProfileMap) {
   for (const auto &I : ProfileMap) {
-    addContext(I.second.getContext());
-    addNames(I.second);
+    addContext(I.second->getContext());
+    addNames(*I.second);
   }
 
   // If NameTable contains ".__uniq." suffix, set SecFlagUniqSuffix flag
   // so compiler won't strip the suffix during profile matching after
   // seeing the flag in the profile.
   for (const auto &I : NameTable) {
     if (I.first.contains(FunctionSamples::UniqSuffix)) {
       addSectionFlag(SecNameTable, SecNameTableFlags::SecFlagUniqSuffix);
SampleProfileWriterExtBinaryBase::writeProfileSymbolListSection() {
   if (ProfSymList && ProfSymList->size() > 0)
     if (std::error_code EC = ProfSymList->write(*OutputStream))
       return EC;
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeOneSection(
-    SecType Type, uint32_t LayoutIdx, const SampleProfileMap &ProfileMap) {
+    SecType Type, uint32_t LayoutIdx, FunctionSamplesVector &ProfileMap) {
   // The setting of SecFlagCompress should happen before markSectionStart.
   if (Type == SecProfileSymbolList && ProfSymList && ProfSymList->toCompress())
     setToCompressSection(SecProfileSymbolList);
   if (Type == SecFuncMetadata && FunctionSamples::ProfileIsProbeBased)
     addSectionFlag(SecFuncMetadata, SecFuncMetadataFlags::SecFlagIsProbeBased);
   if (Type == SecFuncMetadata &&
       (FunctionSamples::ProfileIsCS || FunctionSamples::ProfileIsPreInlined))
     addSectionFlag(SecFuncMetadata, SecFuncMetadataFlags::SecFlagHasAttribute);
default:
     break;
   }
   if (std::error_code EC = addNewSection(Type, LayoutIdx, SectionStart))
     return EC;
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinary::writeDefaultLayout(
-    const SampleProfileMap &ProfileMap) {
+    FunctionSamplesVector &ProfileMap) {
   // The const indices passed to writeOneSection below are specifying the
   // positions of the sections in SectionHdrLayout. Look at
   // initSectionHdrLayout to find out where each section is located in
   // SectionHdrLayout.
   if (auto EC = writeOneSection(SecProfSummary, 0, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecNameTable, 1, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecCSNameTable, 2, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecLBRProfile, 4, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecProfileSymbolList, 5, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecFuncOffsetTable, 3, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecFuncMetadata, 6, ProfileMap))
     return EC;
   return sampleprof_error::success;
 }
 
-static void splitProfileMapToTwo(const SampleProfileMap &ProfileMap,
-                                 SampleProfileMap &ContextProfileMap,
-                                 SampleProfileMap &NoContextProfileMap) {
+static void
+splitProfileMapToTwo(SampleProfileWriter::FunctionSamplesVector &ProfileMap,
+                     std::vector<NameFunctionSamples> &ContextProfileMap,
+                     std::vector<NameFunctionSamples> &NoContextProfileMap) {
+  // ProfileMap is already sorted by total sample count, so splitting it into
+  // two still preserves the order.
   for (const auto &I : ProfileMap) {
-    if (I.second.getCallsiteSamples().size())
-      ContextProfileMap.insert({I.first, I.second});
+    if (I.second->getCallsiteSamples().size())
+      ContextProfileMap.emplace_back(I.first, I.second);
     else
-      NoContextProfileMap.insert({I.first, I.second});
+      NoContextProfileMap.emplace_back(I.first, I.second);
   }
 }
 
 std::error_code SampleProfileWriterExtBinary::writeCtxSplitLayout(
-    const SampleProfileMap &ProfileMap) {
-  SampleProfileMap ContextProfileMap, NoContextProfileMap;
+    FunctionSamplesVector &ProfileMap) {
+  std::vector<NameFunctionSamples> ContextProfileMap, NoContextProfileMap;
+  ContextProfileMap.reserve(ProfileMap.size());
+  NoContextProfileMap.reserve(ProfileMap.size());
   splitProfileMapToTwo(ProfileMap, ContextProfileMap, NoContextProfileMap);
 
   if (auto EC = writeOneSection(SecProfSummary, 0, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecNameTable, 1, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecLBRProfile, 3, ContextProfileMap))
     return EC;
if (auto EC = writeOneSection(SecProfileSymbolList, 6, ProfileMap))
     return EC;
   if (auto EC = writeOneSection(SecFuncMetadata, 7, ProfileMap))
     return EC;
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinary::writeSections(
-    const SampleProfileMap &ProfileMap) {
+    FunctionSamplesVector &ProfileMap) {
   std::error_code EC;
   if (SecLayout == DefaultLayout)
     EC = writeDefaultLayout(ProfileMap);
   else if (SecLayout == CtxSplitLayout)
     EC = writeCtxSplitLayout(ProfileMap);
   else
     llvm_unreachable("Unsupported layout");
   return EC;
SampleProfileWriterBinary::writeMagicIdent(SampleProfileFormat Format) {
   auto &OS = *OutputStream;
   // Write file magic identifier.
   encodeULEB128(SPMagic(Format), OS);
   encodeULEB128(SPVersion(), OS);
   return sampleprof_error::success;
 }
 
 std::error_code
-SampleProfileWriterBinary::writeHeader(const SampleProfileMap &ProfileMap) {
+SampleProfileWriterBinary::writeHeader(FunctionSamplesVector &ProfileMap) {
   // When calling write on a different profile map, existing names should be
   // cleared.
   NameTable.clear();
 
   writeMagicIdent(Format);
 
   computeSummary(ProfileMap);
   if (auto EC = writeSummary())
     return EC;
 
   // Generate the name table for all the functions referenced in the profile.
   for (const auto &I : ProfileMap) {
-    addContext(I.second.getContext());
-    addNames(I.second);
+    addContext(I.second->getContext());
+    addNames(*I.second);
   }
 
   writeNameTable();
   return sampleprof_error::success;
 }
 
 void SampleProfileWriterExtBinaryBase::setToCompressAllSections() {
   for (auto &Entry : SectionHdrLayout)
for (uint32_t LayoutIdx = 0; LayoutIdx < SectionHdrLayout.size();
     Writer.pwrite(static_cast<uint64_t>(Entry.Size),
                   SecHdrTableOffset + (4 * LayoutIdx + 3) * sizeof(uint64_t));
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterExtBinaryBase::writeHeader(
-    const SampleProfileMap &ProfileMap) {
+    FunctionSamplesVector &ProfileMap) {
   auto &OS = *OutputStream;
   FileStart = OS.tell();
   writeMagicIdent(Format);
 
   allocSecHdrTable();
   return sampleprof_error::success;
 }
 
SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
 
   if (EC)
     return EC;
 
   Writer->Format = Format;
   return std::move(Writer);
 }
 
-void SampleProfileWriter::computeSummary(const SampleProfileMap &ProfileMap) {
+void SampleProfileWriter::computeSummary(FunctionSamplesVector &ProfileMap) {
   SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
   Summary = Builder.computeSummaryForProfiles(ProfileMap);
 }