Remove specializations of ProfileSummary (InstrProfSummary and SampleProfileSummary)

[eraman]

Summary

This removes the subclasses of ProfileSummary, moves the members of the derived classes to the base class.

[silvas]

LGTM

include/llvm/IR/ProfileSummary.h

77

As more passes start using these methods, you may want to add some documentation to them or rename them to be more clear.

[eraman]

include/llvm/IR/ProfileSummary.h

77

I'm struggling to come up with better names - your suggestions are welcome. In any case, the plan is to provide an immutable analysis pass that will consume the profile summary and provide APIs like "isHotCount" for the optimization passes to use.

include/llvm/IR/ProfileSummary.h

 
 class ProfileSummary {
 public:
   enum Kind { PSK_Instr, PSK_Sample };
 
 private:
   const Kind PSK;
   static const char *KindStr[2];
-
-protected:
   SummaryEntryVector DetailedSummary;
-  uint64_t TotalCount, MaxCount, MaxFunctionCount;
+  uint64_t TotalCount, MaxCount, MaxInternalCount, MaxFunctionCount;
   uint32_t NumCounts, NumFunctions;
-  ProfileSummary(Kind K, SummaryEntryVector DetailedSummary,
-                 uint64_t TotalCount, uint64_t MaxCount,
-                 uint64_t MaxFunctionCount, uint32_t NumCounts,
-                 uint32_t NumFunctions)
-      : PSK(K), DetailedSummary(DetailedSummary), TotalCount(TotalCount),
-        MaxCount(MaxCount), MaxFunctionCount(MaxFunctionCount),
-        NumCounts(NumCounts), NumFunctions(NumFunctions) {}
-  ~ProfileSummary() = default;
-  /// \brief Return metadata specific to the profile format.
-  /// Derived classes implement this method to return a vector of Metadata.
-  virtual std::vector<Metadata *> getFormatSpecificMD(LLVMContext &Context) = 0;
   /// \brief Return detailed summary as metadata.
   Metadata *getDetailedSummaryMD(LLVMContext &Context);
 
 public:
   static const int Scale = 1000000;
+  ProfileSummary(Kind K, SummaryEntryVector DetailedSummary,
+                 uint64_t TotalCount, uint64_t MaxCount,
+                 uint64_t MaxInternalCount, uint64_t MaxFunctionCount,
+                 uint32_t NumCounts, uint32_t NumFunctions)
+      : PSK(K), DetailedSummary(DetailedSummary), TotalCount(TotalCount),
+        MaxCount(MaxCount), MaxInternalCount(MaxInternalCount),
+        MaxFunctionCount(MaxFunctionCount), NumCounts(NumCounts),
+        NumFunctions(NumFunctions) {}
   Kind getKind() const { return PSK; }
-  const char *getKindStr() const { return KindStr[PSK]; }
   /// \brief Return summary information as metadata.
   Metadata *getMD(LLVMContext &Context);
   /// \brief Construct profile summary from metdata.
   static ProfileSummary *getFromMD(Metadata *MD);
   SummaryEntryVector &getDetailedSummary() { return DetailedSummary; }
   uint32_t getNumFunctions() { return NumFunctions; }
   uint64_t getMaxFunctionCount() { return MaxFunctionCount; }
-};
-
-class InstrProfSummary final : public ProfileSummary {
-  uint64_t MaxInternalBlockCount;
-
-protected:
-  std::vector<Metadata *> getFormatSpecificMD(LLVMContext &Context) override;
-
-public:
-  InstrProfSummary(uint64_t TotalCount, uint64_t MaxBlockCount,
-                   uint64_t MaxInternalBlockCount, uint64_t MaxFunctionCount,
-                   uint32_t NumBlocks, uint32_t NumFunctions,
-                   SummaryEntryVector Summary)
-      : ProfileSummary(PSK_Instr, Summary, TotalCount, MaxBlockCount,
-                       MaxFunctionCount, NumBlocks, NumFunctions),
-        MaxInternalBlockCount(MaxInternalBlockCount) {}
-  static bool classof(const ProfileSummary *PS) {
-    return PS->getKind() == PSK_Instr;
-  }
-  uint32_t getNumBlocks() { return NumCounts; }
+  uint32_t getNumCounts() { return NumCounts; }
   uint64_t getTotalCount() { return TotalCount; }
-  uint64_t getMaxBlockCount() { return MaxCount; }
-  uint64_t getMaxInternalBlockCount() { return MaxInternalBlockCount; }
-};
-
-class SampleProfileSummary final : public ProfileSummary {
-protected:
-  std::vector<Metadata *> getFormatSpecificMD(LLVMContext &Context) override;
-
-public:
-  uint32_t getNumLinesWithSamples() { return NumCounts; }
-  uint64_t getTotalSamples() { return TotalCount; }
-  uint64_t getMaxSamplesPerLine() { return MaxCount; }
-  SampleProfileSummary(uint64_t TotalSamples, uint64_t MaxSamplesPerLine,
-                       uint64_t MaxFunctionCount, int32_t NumLinesWithSamples,
-                       uint32_t NumFunctions,
-                       SummaryEntryVector DetailedSummary)
-      : ProfileSummary(PSK_Sample, DetailedSummary, TotalSamples,
-                       MaxSamplesPerLine, MaxFunctionCount, NumLinesWithSamples,
-                       NumFunctions) {}
-  static bool classof(const ProfileSummary *PS) {
-    return PS->getKind() == PSK_Sample;
-  }
+  uint64_t getMaxCount() { return MaxCount; }
+  uint64_t getMaxInternalCount() { return MaxInternalCount; }
 };
 
 } // end namespace llvm
 #endif

include/llvm/ProfileData/InstrProfReader.h

 /// Reader for the indexed binary instrprof format.
 class IndexedInstrProfReader : public InstrProfReader {
 private:
   /// The profile data file contents.
   std::unique_ptr<MemoryBuffer> DataBuffer;
   /// The index into the profile data.
   std::unique_ptr<InstrProfReaderIndexBase> Index;
   /// Profile summary data.
-  std::unique_ptr<InstrProfSummary> Summary;
+  std::unique_ptr<ProfileSummary> Summary;
 
   IndexedInstrProfReader(const IndexedInstrProfReader &) = delete;
   IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
 
   // Read the profile summary. Return a pointer pointing to one byte past the
   // end of the summary data if it exists or the input \c Cur.
   const unsigned char *readSummary(IndexedInstrProf::ProfVersion Version,
                                    const unsigned char *Cur);
public:
   void setValueProfDataEndianness(support::endianness Endianness) {
     Index->setValueProfDataEndianness(Endianness);
   }
 
   // See description in the base class. This interface is designed
   // to be used by llvm-profdata (for dumping). Avoid using this when
   // the client is the compiler.
   InstrProfSymtab &getSymtab() override;
-  InstrProfSummary &getSummary() { return *(Summary.get()); }
+  ProfileSummary &getSummary() { return *(Summary.get()); }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/ProfileData/ProfileCommon.h

class InstrProfSummaryBuilder final : public ProfileSummaryBuilder {
   uint64_t MaxInternalBlockCount;
   inline void addEntryCount(uint64_t Count);
   inline void addInternalCount(uint64_t Count);
 
 public:
   InstrProfSummaryBuilder(std::vector<uint32_t> Cutoffs)
       : ProfileSummaryBuilder(Cutoffs), MaxInternalBlockCount(0) {}
   void addRecord(const InstrProfRecord &);
-  InstrProfSummary *getSummary();
+  ProfileSummary *getSummary();
 };
 
 class SampleProfileSummaryBuilder final : public ProfileSummaryBuilder {
 
 public:
   void addRecord(const sampleprof::FunctionSamples &FS);
   SampleProfileSummaryBuilder(std::vector<uint32_t> Cutoffs)
       : ProfileSummaryBuilder(Cutoffs) {}
-  SampleProfileSummary *getSummary();
+  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

include/llvm/ProfileData/SampleProfReader.h

public:
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
   create(StringRef Filename, LLVMContext &C);
 
   /// \brief Create a sample profile reader from the supplied memory buffer.
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
   create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C);
 
   /// \brief Return the profile summary.
-  SampleProfileSummary &getSummary() { return *(Summary.get()); }
+  ProfileSummary &getSummary() { return *(Summary.get()); }
 
 protected:
   /// \brief Map every function to its associated profile.
   ///
   /// The profile of every function executed at runtime is collected
   /// in the structure FunctionSamples. This maps function objects
   /// to their corresponding profiles.
   StringMap<FunctionSamples> Profiles;
 
   /// \brief LLVM context used to emit diagnostics.
   LLVMContext &Ctx;
 
   /// \brief Memory buffer holding the profile file.
   std::unique_ptr<MemoryBuffer> Buffer;
 
   /// \brief Profile summary information.
-  std::unique_ptr<SampleProfileSummary> Summary;
+  std::unique_ptr<ProfileSummary> Summary;
 
   /// \brief Compute summary for this profile.
   void computeSummary();
 };
 
 class SampleProfileReaderText : public SampleProfileReader {
 public:
   SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)

include/llvm/ProfileData/SampleProfWriter.h

protected:
   /// \brief Write a file header for the profile file.
   virtual std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) = 0;
 
   /// \brief Output stream where to emit the profile to.
   std::unique_ptr<raw_ostream> OutputStream;
 
   /// \brief Profile summary.
-  std::unique_ptr<SampleProfileSummary> Summary;
+  std::unique_ptr<ProfileSummary> Summary;
 
   /// \brief Compute summary for this profile.
   void computeSummary(const StringMap<FunctionSamples> &ProfileMap);
 };
 
 /// \brief Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:

lib/IR/ProfileSummary.cpp

 
 // This returns an MDTuple representing this ProfileSummary object. The first
 // entry of this tuple is another MDTuple of two elements: a string
 // "ProfileFormat" and a string representing the format ("InstrProf" or
 // "SampleProfile"). The rest of the elements of the outer MDTuple are specific
 // to the kind of profile summary as returned by getFormatSpecificMD.
 Metadata *ProfileSummary::getMD(LLVMContext &Context) {
   std::vector<Metadata *> Components;
-  Components.push_back(getKeyValMD(Context, "ProfileFormat", getKindStr()));
-  std::vector<Metadata *> Res = getFormatSpecificMD(Context);
-  Components.insert(Components.end(), Res.begin(), Res.end());
-  return MDTuple::get(Context, Components);
-}
-
-// Returns a vector of MDTuples specific to InstrProfSummary. The first six
-// elements of this vector are (Key, Val) pairs of the six scalar fields of
-// InstrProfSummary (TotalCount, MaxBlockCount, MaxInternalBlockCount,
-// MaxFunctionCount, NumBlocks, NumFunctions). The last element of this vector
-// is an MDTuple returned by getDetailedSummaryMD.
-std::vector<Metadata *>
-InstrProfSummary::getFormatSpecificMD(LLVMContext &Context) {
-  std::vector<Metadata *> Components;
+  Components.push_back(getKeyValMD(Context, "ProfileFormat", KindStr[PSK]));
 
   Components.push_back(getKeyValMD(Context, "TotalCount", getTotalCount()));
+  Components.push_back(getKeyValMD(Context, "MaxCount", getMaxCount()));
   Components.push_back(
-      getKeyValMD(Context, "MaxBlockCount", getMaxBlockCount()));
-  Components.push_back(getKeyValMD(Context, "MaxInternalBlockCount",
-                                   getMaxInternalBlockCount()));
+      getKeyValMD(Context, "MaxInternalCount", getMaxInternalCount()));
   Components.push_back(
       getKeyValMD(Context, "MaxFunctionCount", getMaxFunctionCount()));
-  Components.push_back(getKeyValMD(Context, "NumBlocks", getNumBlocks()));
+  Components.push_back(getKeyValMD(Context, "NumCounts", getNumCounts()));
   Components.push_back(getKeyValMD(Context, "NumFunctions", getNumFunctions()));
-
-  Components.push_back(getDetailedSummaryMD(Context));
-  return Components;
-}
-
-std::vector<Metadata *>
-SampleProfileSummary::getFormatSpecificMD(LLVMContext &Context) {
-  std::vector<Metadata *> Components;
-
-  Components.push_back(getKeyValMD(Context, "TotalSamples", getTotalSamples()));
-  Components.push_back(
-      getKeyValMD(Context, "MaxSamplesPerLine", getMaxSamplesPerLine()));
-  Components.push_back(
-      getKeyValMD(Context, "MaxFunctionCount", getMaxFunctionCount()));
-  Components.push_back(
-      getKeyValMD(Context, "NumLinesWithSamples", getNumLinesWithSamples()));
-  Components.push_back(getKeyValMD(Context, "NumFunctions", NumFunctions));
-
   Components.push_back(getDetailedSummaryMD(Context));
-  return Components;
+  return MDTuple::get(Context, Components);
 }
 
 // Parse an MDTuple representing (Key, Val) pair.
 static bool getVal(MDTuple *MD, const char *Key, uint64_t &Val) {
   if (!MD)
     return false;
   if (MD->getNumOperands() != 2)
     return false;
if (!Op0 || !Op1 || !Op2)
       return false;
     Summary.emplace_back(cast<ConstantInt>(Op0->getValue())->getZExtValue(),
                          cast<ConstantInt>(Op1->getValue())->getZExtValue(),
                          cast<ConstantInt>(Op2->getValue())->getZExtValue());
   }
   return true;
 }
 
-// Parse an MDTuple representing an InstrProfSummary object.
-static ProfileSummary *getInstrProfSummaryFromMD(MDTuple *Tuple) {
-  uint64_t NumBlocks, TotalCount, NumFunctions, MaxFunctionCount, MaxBlockCount,
-      MaxInternalBlockCount;
-  SummaryEntryVector Summary;
-
+ProfileSummary *ProfileSummary::getFromMD(Metadata *MD) {
+  if (!isa<MDTuple>(MD))
+    return nullptr;
+  MDTuple *Tuple = cast<MDTuple>(MD);
   if (Tuple->getNumOperands() != 8)
     return nullptr;
 
-  // Skip operand 0 which has been already parsed in the caller
+  auto &FormatMD = Tuple->getOperand(0);
+  ProfileSummary::Kind SummaryKind;
+  if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat",
+                     "SampleProfile"))
+    SummaryKind = PSK_Sample;
+  else if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat",
+                          "InstrProf"))
+    SummaryKind = PSK_Instr;
+  else
+    return nullptr;
+
+  uint64_t NumCounts, TotalCount, NumFunctions, MaxFunctionCount, MaxCount,
+      MaxInternalCount;
   if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(1)), "TotalCount",
               TotalCount))
     return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(2)), "MaxBlockCount",
-              MaxBlockCount))
+  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(2)), "MaxCount", MaxCount))
     return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(3)), "MaxInternalBlockCount",
-              MaxInternalBlockCount))
+  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(3)), "MaxInternalCount",
+              MaxInternalCount))
     return nullptr;
   if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(4)), "MaxFunctionCount",
               MaxFunctionCount))
     return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(5)), "NumBlocks", NumBlocks))
+  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(5)), "NumCounts", NumCounts))
     return nullptr;
   if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(6)), "NumFunctions",
               NumFunctions))
     return nullptr;
-  if (!getSummaryFromMD(dyn_cast<MDTuple>(Tuple->getOperand(7)), Summary))
-    return nullptr;
-  return new InstrProfSummary(TotalCount, MaxBlockCount, MaxInternalBlockCount,
-                              MaxFunctionCount, NumBlocks, NumFunctions,
-                              Summary);
-}
 
-// Parse an MDTuple representing a SampleProfileSummary object.
-static ProfileSummary *getSampleProfileSummaryFromMD(MDTuple *Tuple) {
-  uint64_t TotalSamples, MaxSamplesPerLine, MaxFunctionCount,
-      NumLinesWithSamples, NumFunctions;
   SummaryEntryVector Summary;
-
-  if (Tuple->getNumOperands() != 7)
-    return nullptr;
-
-  // Skip operand 0 which has been already parsed in the caller
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(1)), "TotalSamples",
-              TotalSamples))
-    return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(2)), "MaxSamplesPerLine",
-              MaxSamplesPerLine))
-    return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(3)), "MaxFunctionCount",
-              MaxFunctionCount))
-    return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(4)), "NumLinesWithSamples",
-              NumLinesWithSamples))
-    return nullptr;
-  if (!getVal(dyn_cast<MDTuple>(Tuple->getOperand(5)), "NumFunctions",
-              NumFunctions))
-    return nullptr;
-  if (!getSummaryFromMD(dyn_cast<MDTuple>(Tuple->getOperand(6)), Summary))
-    return nullptr;
-  return new SampleProfileSummary(TotalSamples, MaxSamplesPerLine,
-                                  MaxFunctionCount, NumLinesWithSamples,
-                                  NumFunctions, Summary);
-}
-
-ProfileSummary *ProfileSummary::getFromMD(Metadata *MD) {
-  if (!isa<MDTuple>(MD))
-    return nullptr;
-  MDTuple *Tuple = cast<MDTuple>(MD);
-  auto &FormatMD = Tuple->getOperand(0);
-  if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat",
-                     "SampleProfile"))
-    return getSampleProfileSummaryFromMD(Tuple);
-  else if (isKeyValuePair(dyn_cast_or_null<MDTuple>(FormatMD), "ProfileFormat",
-                          "InstrProf"))
-    return getInstrProfSummaryFromMD(Tuple);
-  else
+  if (!getSummaryFromMD(dyn_cast<MDTuple>(Tuple->getOperand(7)), Summary))
     return nullptr;
+  return new ProfileSummary(SummaryKind, Summary, TotalCount, MaxCount,
+                            MaxInternalCount, MaxFunctionCount, NumCounts,
+                            NumFunctions);
 }

lib/ProfileData/InstrProfReader.cpp

if (Version >= IndexedInstrProf::Version4) {
 
     llvm::SummaryEntryVector DetailedSummary;
     for (unsigned I = 0; I < SummaryData->NumCutoffEntries; I++) {
       const IndexedInstrProf::Summary::Entry &Ent = SummaryData->getEntry(I);
       DetailedSummary.emplace_back((uint32_t)Ent.Cutoff, Ent.MinBlockCount,
                                    Ent.NumBlocks);
     }
     // initialize InstrProfSummary using the SummaryData from disk.
-    this->Summary = llvm::make_unique<InstrProfSummary>(
+    this->Summary = llvm::make_unique<ProfileSummary>(
+        ProfileSummary::PSK_Instr, DetailedSummary,
         SummaryData->get(Summary::TotalBlockCount),
         SummaryData->get(Summary::MaxBlockCount),
         SummaryData->get(Summary::MaxInternalBlockCount),
         SummaryData->get(Summary::MaxFunctionCount),
         SummaryData->get(Summary::TotalNumBlocks),
-        SummaryData->get(Summary::TotalNumFunctions), DetailedSummary);
+        SummaryData->get(Summary::TotalNumFunctions));
     return Cur + SummarySize;
   } else {
     // For older version of profile data, we need to compute on the fly:
     using namespace IndexedInstrProf;
     InstrProfSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
     // FIXME: This only computes an empty summary. Need to call addRecord for
     // all InstrProfRecords to get the correct summary.
     this->Summary.reset(Builder.getSummary());

lib/ProfileData/InstrProfWriter.cpp

for (const auto &Func : PD) {
     if (std::any_of(IPR.Counts.begin(), IPR.Counts.end(),
                     [](uint64_t Count) { return Count > 0; }))
       return true;
   }
   return false;
 }
 
 static void setSummary(IndexedInstrProf::Summary *TheSummary,
-                       InstrProfSummary &PS) {
+                       ProfileSummary &PS) {
   using namespace IndexedInstrProf;
   std::vector<ProfileSummaryEntry> &Res = PS.getDetailedSummary();
   TheSummary->NumSummaryFields = Summary::NumKinds;
   TheSummary->NumCutoffEntries = Res.size();
   TheSummary->set(Summary::MaxFunctionCount, PS.getMaxFunctionCount());
-  TheSummary->set(Summary::MaxBlockCount, PS.getMaxBlockCount());
-  TheSummary->set(Summary::MaxInternalBlockCount,
-                  PS.getMaxInternalBlockCount());
+  TheSummary->set(Summary::MaxBlockCount, PS.getMaxCount());
+  TheSummary->set(Summary::MaxInternalBlockCount, PS.getMaxInternalCount());
   TheSummary->set(Summary::TotalBlockCount, PS.getTotalCount());
-  TheSummary->set(Summary::TotalNumBlocks, PS.getNumBlocks());
+  TheSummary->set(Summary::TotalNumBlocks, PS.getNumCounts());
   TheSummary->set(Summary::TotalNumFunctions, PS.getNumFunctions());
   for (unsigned I = 0; I < Res.size(); I++)
     TheSummary->setEntry(I, Res[I]);
 }
 
 void InstrProfWriter::writeImpl(ProfOStream &OS) {
   OnDiskChainedHashTableGenerator<InstrProfRecordWriterTrait> Generator;
 
void InstrProfWriter::writeImpl(ProfOStream &OS) {
   // Write the hash table.
   uint64_t HashTableStart = Generator.Emit(OS.OS, *InfoObj);
 
   // Allocate space for data to be serialized out.
   std::unique_ptr<IndexedInstrProf::Summary> TheSummary =
       IndexedInstrProf::allocSummary(SummarySize);
   // Compute the Summary and copy the data to the data
   // structure to be serialized out (to disk or buffer).
-  InstrProfSummary *IPS = ISB.getSummary();
-  setSummary(TheSummary.get(), *IPS);
+  ProfileSummary *PS = ISB.getSummary();
+  setSummary(TheSummary.get(), *PS);
   InfoObj->SummaryBuilder = 0;
 
   // Now do the final patch:
   PatchItem PatchItems[] = {
       // Patch the Header.HashOffset field.
       {HashTableStartFieldOffset, &HashTableStart, 1},
       // Patch the summary data.
       {SummaryOffset, reinterpret_cast<uint64_t *>(TheSummary.get()),

lib/ProfileData/ProfileSummaryBuilder.cpp

while (CurrSum < DesiredCount && Iter != End) {
       Iter++;
     }
     assert(CurrSum >= DesiredCount);
     ProfileSummaryEntry PSE = {Cutoff, Count, CountsSeen};
     DetailedSummary.push_back(PSE);
   }
 }
 
-SampleProfileSummary *SampleProfileSummaryBuilder::getSummary() {
+ProfileSummary *SampleProfileSummaryBuilder::getSummary() {
   computeDetailedSummary();
-  return new SampleProfileSummary(TotalCount, MaxCount, MaxFunctionCount,
-                                  NumCounts, NumFunctions, DetailedSummary);
+  return new ProfileSummary(ProfileSummary::PSK_Sample, DetailedSummary,
+                            TotalCount, MaxCount, 0, MaxFunctionCount,
+                            NumCounts, NumFunctions);
 }
 
-InstrProfSummary *InstrProfSummaryBuilder::getSummary() {
+ProfileSummary *InstrProfSummaryBuilder::getSummary() {
   computeDetailedSummary();
-  return new InstrProfSummary(TotalCount, MaxCount, MaxInternalBlockCount,
-                              MaxFunctionCount, NumCounts, NumFunctions,
-                              DetailedSummary);
+  return new ProfileSummary(ProfileSummary::PSK_Instr, DetailedSummary,
+                            TotalCount, MaxCount, MaxInternalBlockCount,
+                            MaxFunctionCount, NumCounts, NumFunctions);
 }
 
 void InstrProfSummaryBuilder::addEntryCount(uint64_t Count) {
   addCount(Count);
   NumFunctions++;
   if (Count > MaxFunctionCount)
     MaxFunctionCount = Count;
 }
 
 void InstrProfSummaryBuilder::addInternalCount(uint64_t Count) {
   addCount(Count);
   if (Count > MaxInternalBlockCount)
     MaxInternalBlockCount = Count;
 }

lib/ProfileData/SampleProfReader.cpp

if (std::error_code EC = NumSummaryEntries.getError())
     return EC;
 
   std::vector<ProfileSummaryEntry> Entries;
   for (unsigned i = 0; i < *NumSummaryEntries; i++) {
     std::error_code EC = readSummaryEntry(Entries);
     if (EC != sampleprof_error::success)
       return EC;
   }
-  Summary = llvm::make_unique<SampleProfileSummary>(
-      *TotalCount, *MaxBlockCount, *MaxFunctionCount, *NumBlocks, *NumFunctions,
-      Entries);
+  Summary = llvm::make_unique<ProfileSummary>(
+      ProfileSummary::PSK_Sample, Entries, *TotalCount, *MaxBlockCount, 0,
+      *MaxFunctionCount, *NumBlocks, *NumFunctions);
 
   return sampleprof_error::success;
 }
 
 bool SampleProfileReaderBinary::hasFormat(const MemoryBuffer &Buffer) {
   const uint8_t *Data =
       reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
   uint64_t Magic = decodeULEB128(Data);

lib/ProfileData/SampleProfWriter.cpp

for (auto N : NameTable) {
     OS << N.first;
     encodeULEB128(0, OS);
   }
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterBinary::writeSummary() {
   auto &OS = *OutputStream;
-  encodeULEB128(Summary->getTotalSamples(), OS);
-  encodeULEB128(Summary->getMaxSamplesPerLine(), OS);
+  encodeULEB128(Summary->getTotalCount(), OS);
+  encodeULEB128(Summary->getMaxCount(), OS);
   encodeULEB128(Summary->getMaxFunctionCount(), OS);
-  encodeULEB128(Summary->getNumLinesWithSamples(), OS);
+  encodeULEB128(Summary->getNumCounts(), OS);
   encodeULEB128(Summary->getNumFunctions(), OS);
   std::vector<ProfileSummaryEntry> &Entries = Summary->getDetailedSummary();
   encodeULEB128(Entries.size(), OS);
   for (auto Entry : Entries) {
     encodeULEB128(Entry.Cutoff, OS);
     encodeULEB128(Entry.MinCount, OS);
     encodeULEB128(Entry.NumCounts, OS);
   }

tools/llvm-profdata/llvm-profdata.cpp

for (const auto &Func : *Reader) {
     }
   }
 
   if (Reader->hasError())
     exitWithErrorCode(Reader->getError(), Filename);
 
   if (ShowCounts && TextFormat)
     return 0;
-  std::unique_ptr<InstrProfSummary> PS(Builder.getSummary());
+  std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
   if (ShowAllFunctions || !ShowFunction.empty())
     OS << "Functions shown: " << ShownFunctions << "\n";
   OS << "Total functions: " << PS->getNumFunctions() << "\n";
   OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
-  OS << "Maximum internal block count: " << PS->getMaxInternalBlockCount()
-     << "\n";
+  OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
 
   if (ShowDetailedSummary) {
     OS << "Detailed summary:\n";
-    OS << "Total number of blocks: " << PS->getNumBlocks() << "\n";
+    OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
     OS << "Total count: " << PS->getTotalCount() << "\n";
     for (auto Entry : PS->getDetailedSummary()) {
       OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount
          << " account for "
          << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100)
          << " percentage of the total counts.\n";
     }
   }

unittests/ProfileData/InstrProfTest.cpp

TEST_F(InstrProfTest, get_profile_summary) {
   InstrProfRecord Record4("func4", 0x1234, {0});
   NoError(Writer.addRecord(std::move(Record1)));
   NoError(Writer.addRecord(std::move(Record2)));
   NoError(Writer.addRecord(std::move(Record3)));
   NoError(Writer.addRecord(std::move(Record4)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  auto VerifySummary = [](InstrProfSummary &IPS) mutable {
+  auto VerifySummary = [](ProfileSummary &IPS) mutable {
+    ASSERT_EQ(ProfileSummary::PSK_Instr, IPS.getKind());
     ASSERT_EQ(2305843009213693952U, IPS.getMaxFunctionCount());
-    ASSERT_EQ(2305843009213693952U, IPS.getMaxBlockCount());
-    ASSERT_EQ(10U, IPS.getNumBlocks());
+    ASSERT_EQ(2305843009213693952U, IPS.getMaxCount());
+    ASSERT_EQ(10U, IPS.getNumCounts());
     ASSERT_EQ(4539628424389557499U, IPS.getTotalCount());
     std::vector<ProfileSummaryEntry> &Details = IPS.getDetailedSummary();
     uint32_t Cutoff = 800000;
     auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
       return PE.Cutoff == Cutoff;
     };
     auto EightyPerc = std::find_if(Details.begin(), Details.end(), Predicate);
     Cutoff = 900000;
     auto NinetyPerc = std::find_if(Details.begin(), Details.end(), Predicate);
     Cutoff = 950000;
     auto NinetyFivePerc =
         std::find_if(Details.begin(), Details.end(), Predicate);
     Cutoff = 990000;
     auto NinetyNinePerc =
         std::find_if(Details.begin(), Details.end(), Predicate);
     ASSERT_EQ(576460752303423488U, EightyPerc->MinCount);
     ASSERT_EQ(288230376151711744U, NinetyPerc->MinCount);
     ASSERT_EQ(288230376151711744U, NinetyFivePerc->MinCount);
     ASSERT_EQ(72057594037927936U, NinetyNinePerc->MinCount);
   };
-  InstrProfSummary &PS = Reader->getSummary();
+  ProfileSummary &PS = Reader->getSummary();
   VerifySummary(PS);
 
   // Test that conversion of summary to and from Metadata works.
   LLVMContext Context;
   Metadata *MD = PS.getMD(Context);
   ASSERT_TRUE(MD);
   ProfileSummary *PSFromMD = ProfileSummary::getFromMD(MD);
   ASSERT_TRUE(PSFromMD);
-  ASSERT_TRUE(isa<InstrProfSummary>(PSFromMD));
-  InstrProfSummary *IPS = cast<InstrProfSummary>(PSFromMD);
-  VerifySummary(*IPS);
-  delete IPS;
+  VerifySummary(*PSFromMD);
+  delete PSFromMD;
 
   // Test that summary can be attached to and read back from module.
   Module M("my_module", Context);
   M.setProfileSummary(MD);
   MD = M.getProfileSummary();
   ASSERT_TRUE(MD);
   PSFromMD = ProfileSummary::getFromMD(MD);
   ASSERT_TRUE(PSFromMD);
-  ASSERT_TRUE(isa<InstrProfSummary>(PSFromMD));
-  IPS = cast<InstrProfSummary>(PSFromMD);
-  VerifySummary(*IPS);
-  delete IPS;
+  VerifySummary(*PSFromMD);
+  delete PSFromMD;
 }
 
 static const char callee1[] = "callee1";
 static const char callee2[] = "callee2";
 static const char callee3[] = "callee3";
 static const char callee4[] = "callee4";
 static const char callee5[] = "callee5";
 static const char callee6[] = "callee6";

unittests/ProfileData/SampleProfTest.cpp

void testRoundTrip(SampleProfileFormat Format) {
     FunctionSamples &ReadFooSamples = ReadProfiles[FooName];
     ASSERT_EQ(7711u, ReadFooSamples.getTotalSamples());
     ASSERT_EQ(610u, ReadFooSamples.getHeadSamples());
 
     FunctionSamples &ReadBarSamples = ReadProfiles[BarName];
     ASSERT_EQ(20301u, ReadBarSamples.getTotalSamples());
     ASSERT_EQ(1437u, ReadBarSamples.getHeadSamples());
 
-    auto VerifySummary = [](SampleProfileSummary &Summary) mutable {
-      ASSERT_EQ(123603u, Summary.getTotalSamples());
-      ASSERT_EQ(6u, Summary.getNumLinesWithSamples());
+    auto VerifySummary = [](ProfileSummary &Summary) mutable {
+      ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
+      ASSERT_EQ(123603u, Summary.getTotalCount());
+      ASSERT_EQ(6u, Summary.getNumCounts());
       ASSERT_EQ(2u, Summary.getNumFunctions());
       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
-      ASSERT_EQ(60351u, Summary.getMaxSamplesPerLine());
+      ASSERT_EQ(60351u, Summary.getMaxCount());
 
       uint32_t Cutoff = 800000;
       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
         return PE.Cutoff == Cutoff;
       };
       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
       auto EightyPerc = std::find_if(Details.begin(), Details.end(), Predicate);
       Cutoff = 900000;
       auto NinetyPerc = std::find_if(Details.begin(), Details.end(), Predicate);
       Cutoff = 950000;
       auto NinetyFivePerc =
           std::find_if(Details.begin(), Details.end(), Predicate);
       Cutoff = 990000;
       auto NinetyNinePerc =
           std::find_if(Details.begin(), Details.end(), Predicate);
       ASSERT_EQ(60000u, EightyPerc->MinCount);
       ASSERT_EQ(60000u, NinetyPerc->MinCount);
       ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
     };
 
-    SampleProfileSummary &Summary = Reader->getSummary();
+    ProfileSummary &Summary = Reader->getSummary();
     VerifySummary(Summary);
 
     // Test that conversion of summary to and from Metadata works.
     Metadata *MD = Summary.getMD(Context);
     ASSERT_TRUE(MD);
     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
     ASSERT_TRUE(PS);
-    ASSERT_TRUE(isa<SampleProfileSummary>(PS));
-    SampleProfileSummary *SPS = cast<SampleProfileSummary>(PS);
-    VerifySummary(*SPS);
-    delete SPS;
+    VerifySummary(*PS);
+    delete PS;
 
     // Test that summary can be attached to and read back from module.
     Module M("my_module", Context);
     M.setProfileSummary(MD);
     MD = M.getProfileSummary();
     ASSERT_TRUE(MD);
     PS = ProfileSummary::getFromMD(MD);
     ASSERT_TRUE(PS);
-    ASSERT_TRUE(isa<SampleProfileSummary>(PS));
-    SPS = cast<SampleProfileSummary>(PS);
-    VerifySummary(*SPS);
-    delete SPS;
+    VerifySummary(*PS);
+    delete PS;
   }
 };
 
 TEST_F(SampleProfTest, roundtrip_text_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Text);
 }
 
 TEST_F(SampleProfTest, roundtrip_binary_profile) {