Add profile summary support for sample profile

[eraman]

Summary

This adds profile summary to the sample profile file. This is similar to the changes to the instrumentation based profile. For sample profile, I treat a program line as the unit of summary computation.

[davidxl]

Can you upload the patch with more context lines?

[eraman]

Added summary support to GCC format and the diff now has more context.

[dnovillo]

I just started looking at this. Some early feedback so we can discuss whether my idea makes sense. Mostly, I'm thinking we want to support summary data in text profiles for testing and debugging. Does that make sense to you?

include/llvm/ProfileData/SampleProfReader.h

139 ↗

(On Diff #48087)

Well, this is always exactly one for sampling profiles. There's always one count per line.

lib/ProfileData/SampleProfReader.cpp

792 ↗

(On Diff #48087)

s/aftter/after/

I would prefer to see a text version of the summary profile. This is invaluable for generating test cases and general debugging.

lib/ProfileData/SampleProfWriter.cpp

126 ↗

(On Diff #48087)

One blank line above, please.

[eraman]

include/llvm/ProfileData/SampleProfReader.h

139 ↗

(On Diff #48087)

I use count to mean samples. The fields of ProfileSummary are named *Counts and in the context of sample profiles, I use those fields to represent samples. Thus, MaxBlockCount contains the max among samples on any given line.

lib/ProfileData/SampleProfReader.cpp

792 ↗

(On Diff #48087)

The reason why I decided to compute the summary after reading is that it made generating test cases easy. If it is part of the header, either we need to make it optional (and compute it while reading) or write the summary to the profile file.

One thing I want to point out is that I'll add support to llvm-profdata to generate summaries for sample profile after this change. At present, it does generate summaries for instrumented profile, but that also needs to be cleaned up since it uses a different set of cutoffs.

[dnovillo]

include/llvm/ProfileData/SampleProfReader.h

139 ↗

(On Diff #48087)

Ah, yes, that makes sense. Thanks.

lib/ProfileData/ProfileSummary.cpp

20 ↗

(On Diff #48087)

Could you add a comment describing these cutoffs and a general idea of what the numbers are and mean?

lib/ProfileData/SampleProfReader.cpp

403 ↗

(On Diff #48087)

I'm wondering if we don't want to do something similar to what we do for instrumented profiles here. We could make up a fake summary for older versions of the profile.

Right now, you should be seeing test failures for older binary profiles. Are you not?

792 ↗

(On Diff #48087)

OK, thanks. That sounds fine.

Still need to s/aftter/after/ in the comment.

[eraman]

I had refactored the ProfileSummary class and made InstrProfSummary as a derived patch. I have merged in that change and added a SampleProfSummary as a new class and avoided the need to use InstrProf specific terms here.

lib/ProfileData/ProfileSummary.cpp

20 ↗

(On Diff #48087)

I've added a comment here. Let me know if you want anything more specific.

lib/ProfileData/SampleProfReader.cpp

403 ↗

(On Diff #48087)

In the case of instrumented profile, summary is available only for indexed format. If we read an older version of the profile, the summary is computed after reading the profile.

There was only one test case that had a binary format directly checked in and I have fixed that test case.

[eraman]

Address Diego's comments and rebase.

[dnovillo]

Thanks for the new feature! LGTM with one minor nit.

include/llvm/ProfileData/SampleProfReader.h

299 ↗

(On Diff #48258)

As a matter of consistency, let's keep the naming to SampleProfile instead of SampleProf. I know it's not really "consistent" because instruction profiles use InstrProf, but at least we make it consistent within the sample profiler :)

llvm/trunk/include/llvm/ProfileData/InstrProf.h

 struct Header {
   uint64_t Magic;
   uint64_t Version;
   uint64_t Unused; // Becomes unused since version 4
   uint64_t HashType;
   uint64_t HashOffset;
 };
 
-static const uint32_t SummaryCutoffs[] = {
-    10000,  /*  1% */
-    100000, /* 10% */
-    200000, 300000, 400000, 500000, 600000, 500000, 600000, 700000,
-    800000, 900000, 950000, 990000, 999000, 999900, 999990, 999999};
-static const uint32_t NumSummaryCutoffs =
-    sizeof(SummaryCutoffs) / sizeof(*SummaryCutoffs);
-
 // Profile summary data recorded in the profile data file in indexed
 // format. It is introduced in version 4. The summary data follows
 // right after the profile file header.
 struct Summary {
 
   struct Entry {
     uint64_t Cutoff; ///< The required percentile of total execution count.
     uint64_t

llvm/trunk/include/llvm/ProfileData/ProfileCommon.h

 
 #ifndef LLVM_PROFILEDATA_PROFILE_COMMON_H
 #define LLVM_PROFILEDATA_PROFILE_COMMON_H
 
 namespace llvm {
 namespace IndexedInstrProf {
 struct Summary;
 }
+namespace sampleprof {
+class FunctionSamples;
+}
 struct InstrProfRecord;
 // The profile summary is one or more (Cutoff, MinCount, NumCounts) triplets.
 // The semantics of counts depend on the type of profile. For instrumentation
 // profile, counts are block counts and for sample profile, counts are
 // per-line samples. Given a target counts percentile, we compute the minimum
 // number of counts needed to reach this target and the minimum among these
 // counts.
 struct ProfileSummaryEntry {
protected:
   std::vector<ProfileSummaryEntry> DetailedSummary;
   std::vector<uint32_t> DetailedSummaryCutoffs;
   uint64_t TotalCount, MaxCount;
   uint32_t NumCounts;
   ProfileSummary(std::vector<uint32_t> Cutoffs)
       : DetailedSummaryCutoffs(Cutoffs), TotalCount(0), MaxCount(0),
         NumCounts(0) {}
   ProfileSummary() : TotalCount(0), MaxCount(0), NumCounts(0) {}
+  ProfileSummary(std::vector<ProfileSummaryEntry> DetailedSummary,
+                 uint64_t TotalCount, uint64_t MaxCount, uint32_t NumCounts)
+      : DetailedSummary(DetailedSummary), TotalCount(TotalCount),
+        MaxCount(MaxCount), NumCounts(NumCounts) {}
   inline void addCount(uint64_t Count);
 
 public:
   static const int Scale = 1000000;
   inline std::vector<ProfileSummaryEntry> &getDetailedSummary();
   void computeDetailedSummary();
+  /// \brief A vector of useful cutoff values for detailed summary.
+  static const std::vector<uint32_t> DefaultCutoffs;
 };
 
 class InstrProfSummary : public ProfileSummary {
   uint64_t MaxInternalBlockCount, MaxFunctionCount;
   uint32_t NumFunctions;
   inline void addEntryCount(uint64_t Count);
   inline void addInternalCount(uint64_t Count);
 
 public:
   InstrProfSummary(std::vector<uint32_t> Cutoffs)
       : ProfileSummary(Cutoffs), MaxInternalBlockCount(0), MaxFunctionCount(0),
         NumFunctions(0) {}
   InstrProfSummary(const IndexedInstrProf::Summary &S);
   void addRecord(const InstrProfRecord &);
   uint32_t getNumBlocks() { return NumCounts; }
   uint64_t getTotalCount() { return TotalCount; }
   uint32_t getNumFunctions() { return NumFunctions; }
   uint64_t getMaxFunctionCount() { return MaxFunctionCount; }
   uint64_t getMaxBlockCount() { return MaxCount; }
   uint64_t getMaxInternalBlockCount() { return MaxInternalBlockCount; }
 };
 
+class SampleProfileSummary : public ProfileSummary {
+  uint64_t MaxHeadSamples;
+  uint32_t NumFunctions;
+
+public:
+  uint32_t getNumLinesWithSamples() { return NumCounts; }
+  uint64_t getTotalSamples() { return TotalCount; }
+  uint32_t getNumFunctions() { return NumFunctions; }
+  uint64_t getMaxHeadSamples() { return MaxHeadSamples; }
+  uint64_t getMaxSamplesPerLine() { return MaxCount; }
+  void addRecord(const sampleprof::FunctionSamples &FS);
+  SampleProfileSummary(std::vector<uint32_t> Cutoffs)
+      : ProfileSummary(Cutoffs), MaxHeadSamples(0), NumFunctions(0) {}
+  SampleProfileSummary(uint64_t TotalSamples, uint64_t MaxSamplesPerLine,
+                       uint64_t MaxHeadSamples, int32_t NumLinesWithSamples,
+                       uint32_t NumFunctions,
+                       std::vector<ProfileSummaryEntry> DetailedSummary)
+      : ProfileSummary(DetailedSummary, TotalSamples, MaxSamplesPerLine,
+                       NumLinesWithSamples),
+        MaxHeadSamples(MaxHeadSamples), NumFunctions(NumFunctions) {}
+};
+
 // This is called when a count is seen in the profile.
 void ProfileSummary::addCount(uint64_t Count) {
   TotalCount += Count;
   if (Count > MaxCount)
     MaxCount = Count;
   NumCounts++;
   CountFrequencies[Count]++;
 }

llvm/trunk/include/llvm/ProfileData/SampleProf.h

 
 static inline uint64_t SPMagic() {
   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(0xff);
 }
 
-static inline uint64_t SPVersion() { return 102; }
+static inline uint64_t SPVersion() { return 103; }
 
 /// Represents the relative location of an instruction.
 ///
 /// Instruction locations are specified by the line offset from the
 /// beginning of the function (marked by the line where the function
 /// header is) and the discriminator value within that line.
 ///
 /// The discriminator value is useful to distinguish instructions

llvm/trunk/include/llvm/ProfileData/SampleProfReader.h

 // the following sections:
 //
 // MAGIC (uint64_t)
 //    File identifier computed by function SPMagic() (0x5350524f463432ff)
 //
 // VERSION (uint32_t)
 //    File format version number computed by SPVersion()
 //
+// SUMMARY
+//    TOTAL_COUNT (uint64_t)
+//        Total number of samples in the profile.
+//    MAX_COUNT (uint64_t)
+//        Maximum value of samples on a line.
+//    MAX_HEAD_SAMPLES (uint64_t)
+//        Maximum number of head samples.
+//    NUM_COUNTS (uint64_t)
+//        Number of lines with samples.
+//    NUM_FUNCTIONS (uint64_t)
+//        Number of functions with samples.
+//    NUM_DETAILED_SUMMARY_ENTRIES (size_t)
+//        Number of entries in detailed summary
+//    DETAILED_SUMMARY
+//        A list of detailed summary entry. Each entry consists of
+//        CUTOFF (uint32_t)
+//            Required percentile of total sample count expressed as a fraction
+//            multiplied by 1000000.
+//        MIN_COUNT (uint64_t)
+//            The minimum number of samples required to reach the target
+//            CUTOFF.
+//        NUM_COUNTS (uint64_t)
+//            Number of samples to get to the desrired percentile.
+//
 // NAME TABLE
 //    SIZE (uint32_t)
 //        Number of entries in the name table.
 //    NAMES
 //        A NUL-separated list of SIZE strings.
 //
 // FUNCTION BODY (one for each uninlined function body present in the profile)
 //    HEAD_SAMPLES (uint64_t) [only for top-level functions]

 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/GCOV.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
public:
   /// \brief Create a sample profile reader appropriate to the file format.
   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()); }
+
 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;
+
+  /// \brief Compute summary for this profile.
+  void computeSummary();
 };
 
 class SampleProfileReaderText : public SampleProfileReader {
 public:
   SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
       : SampleProfileReader(std::move(B), C) {}
 
   /// \brief Read and validate the file header.
protected:
   /// \brief Points to the current location in the buffer.
   const uint8_t *Data;
 
   /// \brief Points to the end of the buffer.
   const uint8_t *End;
 
   /// Function name table.
   std::vector<StringRef> NameTable;
+
+private:
+  std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
+
+  /// \brief Read profile summary.
+  std::error_code readSummary();
 };
 
 typedef SmallVector<FunctionSamples *, 10> InlineCallStack;
 
 // Supported histogram types in GCC.  Currently, we only need support for
 // call target histograms.
 enum HistType {
   HIST_TYPE_INTERVAL,

llvm/trunk/include/llvm/ProfileData/SampleProfWriter.h

 // This file contains definitions needed for writing sample profiles.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
 #define LLVM_PROFILEDATA_SAMPLEPROFWRITER_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 namespace sampleprof {
public:
   virtual std::error_code write(StringRef FName, const FunctionSamples &S) = 0;
 
   /// Write all the sample profiles in the given map of samples.
   ///
   /// \returns status code of the file update operation.
   std::error_code write(const StringMap<FunctionSamples> &ProfileMap) {
     if (std::error_code EC = writeHeader(ProfileMap))
       return EC;
-
     for (const auto &I : ProfileMap) {
       StringRef FName = I.first();
       const FunctionSamples &Profile = I.second;
       if (std::error_code EC = write(FName, Profile))
         return EC;
     }
     return sampleprof_error::success;
   }
SampleProfileWriter(std::unique_ptr<raw_ostream> &OS)
       : OutputStream(std::move(OS)) {}
 
   /// \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;
+
+  /// \brief Compute summary for this profile.
+  void computeSummary(const StringMap<FunctionSamples> &ProfileMap);
 };
 
 /// \brief Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:
   std::error_code write(StringRef FName, const FunctionSamples &S) override;
 
 protected:
public:
   std::error_code write(StringRef F, const FunctionSamples &S) override;
 
 protected:
   SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS), NameTable() {}
 
   std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
+  std::error_code writeSummary();
   std::error_code writeNameIdx(StringRef FName);
   std::error_code writeBody(StringRef FName, const FunctionSamples &S);
 
 private:
   void addName(StringRef FName);
   void addNames(const FunctionSamples &S);
 
   MapVector<StringRef, uint32_t> NameTable;

llvm/trunk/lib/ProfileData/InstrProfReader.cpp

for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
       Dst[I] = endian::byte_swap<uint64_t, little>(Src[I]);
 
     // initialize InstrProfSummary using the SummaryData from disk.
     this->Summary = llvm::make_unique<InstrProfSummary>(*(SummaryData.get()));
     return Cur + SummarySize;
   } else {
     // For older version of profile data, we need to compute on the fly:
     using namespace IndexedInstrProf;
-    std::vector<uint32_t> Cutoffs(&SummaryCutoffs[0],
-                                  &SummaryCutoffs[NumSummaryCutoffs]);
-    this->Summary = llvm::make_unique<InstrProfSummary>(Cutoffs);
+    this->Summary =
+        llvm::make_unique<InstrProfSummary>(ProfileSummary::DefaultCutoffs);
     this->Summary->computeDetailedSummary();
     return Cur;
   }
 }
 
 std::error_code IndexedInstrProfReader::readHeader() {
   const unsigned char *Start =
       (const unsigned char *)DataBuffer->getBufferStart();

llvm/trunk/lib/ProfileData/InstrProfWriter.cpp

static void setSummary(IndexedInstrProf::Summary *TheSummary,
   for (unsigned I = 0; I < Res.size(); I++)
     TheSummary->setEntry(I, Res[I]);
 }
 
 void InstrProfWriter::writeImpl(ProfOStream &OS) {
   OnDiskChainedHashTableGenerator<InstrProfRecordWriterTrait> Generator;
 
   using namespace IndexedInstrProf;
-  std::vector<uint32_t> Cutoffs(&SummaryCutoffs[0],
-                                &SummaryCutoffs[NumSummaryCutoffs]);
-  InstrProfSummary PS(Cutoffs);
+  InstrProfSummary PS(ProfileSummary::DefaultCutoffs);
   InfoObj->TheProfileSummary = &PS;
 
   // Populate the hash table generator.
   for (const auto &I : FunctionData)
     if (shouldEncodeData(I.getValue()))
       Generator.insert(I.getKey(), &I.getValue());
   // Write the header.
   IndexedInstrProf::Header Header;
for (int I = 0; I < N - 1; I++)
     OS.write(reinterpret_cast<uint64_t *>(&Header)[I]);
 
   // Save the location of Header.HashOffset field in \c OS.
   uint64_t HashTableStartFieldOffset = OS.tell();
   // Reserve the space for HashOffset field.
   OS.write(0);
 
   // Reserve space to write profile summary data.
-  uint32_t NumEntries = Cutoffs.size();
+  uint32_t NumEntries = ProfileSummary::DefaultCutoffs.size();
   uint32_t SummarySize = Summary::getSize(Summary::NumKinds, NumEntries);
   // Remember the summary offset.
   uint64_t SummaryOffset = OS.tell();
   for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
     OS.write(0);
 
   // Write the hash table.
   uint64_t HashTableStart = Generator.Emit(OS.OS, *InfoObj);

llvm/trunk/lib/ProfileData/ProfileSummary.cpp

 //=-- Profilesummary.cpp - Profile summary computation ----------------------=//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for computing profile summary data.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/ProfileCommon.h"
+#include "llvm/ProfileData/SampleProf.h"
 
 using namespace llvm;
 
+// A set of cutoff values. Each value, when divided by ProfileSummary::Scale
+// (which is 1000000) is a desired percentile of total counts.
+const std::vector<uint32_t> ProfileSummary::DefaultCutoffs(
+    {10000,  /*  1% */
+     100000, /* 10% */
+     200000, 300000, 400000, 500000, 600000, 500000, 600000, 700000, 800000,
+     900000, 950000, 990000, 999000, 999900, 999990, 999999});
+
 void InstrProfSummary::addRecord(const InstrProfRecord &R) {
   addEntryCount(R.Counts[0]);
   for (size_t I = 1, E = R.Counts.size(); I < E; ++I)
     addInternalCount(R.Counts[I]);
 }
 
+// To compute the detailed summary, we consider each line containing samples as
+// equivalent to a block with a count in the instrumented profile.
+void SampleProfileSummary::addRecord(const sampleprof::FunctionSamples &FS) {
+  NumFunctions++;
+  if (FS.getHeadSamples() > MaxHeadSamples)
+    MaxHeadSamples = FS.getHeadSamples();
+  for (const auto &I : FS.getBodySamples())
+    addCount(I.second.getSamples());
+}
+
 // The argument to this method is a vector of cutoff percentages and the return
 // value is a vector of (Cutoff, MinCount, NumCounts) triplets.
 void ProfileSummary::computeDetailedSummary() {
   if (DetailedSummaryCutoffs.empty())
     return;
   auto Iter = CountFrequencies.begin();
   auto End = CountFrequencies.end();
   std::sort(DetailedSummaryCutoffs.begin(), DetailedSummaryCutoffs.end());

llvm/trunk/lib/ProfileData/SampleProfReader.cpp

 // tool (https://github.com/google/autofdo)
 //
 // All three encodings can be used interchangeably as an input sample profile.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm::sampleprof;
if ((*LineIt)[0] != ' ') {
                                   LineOffset, Discriminator, name_count.first,
                                   name_count.second));
         }
         MergeResult(Result, FProfile.addBodySamples(LineOffset, Discriminator,
                                                     NumSamples));
       }
     }
   }
+  if (Result == sampleprof_error::success)
+    computeSummary();
 
   return Result;
 }
 
 bool SampleProfileReaderText::hasFormat(const MemoryBuffer &Buffer) {
   bool result = false;
 
   // Check that the first non-comment line is a valid function header.
std::error_code SampleProfileReaderBinary::readHeader() {
 
   // Read the version number.
   auto Version = readNumber<uint64_t>();
   if (std::error_code EC = Version.getError())
     return EC;
   else if (*Version != SPVersion())
     return sampleprof_error::unsupported_version;
 
+  if (std::error_code EC = readSummary())
+    return EC;
+
   // Read the name table.
   auto Size = readNumber<uint32_t>();
   if (std::error_code EC = Size.getError())
     return EC;
   NameTable.reserve(*Size);
   for (uint32_t I = 0; I < *Size; ++I) {
     auto Name(readString());
     if (std::error_code EC = Name.getError())
       return EC;
     NameTable.push_back(*Name);
   }
 
   return sampleprof_error::success;
 }
 
+std::error_code SampleProfileReaderBinary::readSummaryEntry(
+    std::vector<ProfileSummaryEntry> &Entries) {
+  auto Cutoff = readNumber<uint64_t>();
+  if (std::error_code EC = Cutoff.getError())
+    return EC;
+
+  auto MinBlockCount = readNumber<uint64_t>();
+  if (std::error_code EC = MinBlockCount.getError())
+    return EC;
+
+  auto NumBlocks = readNumber<uint64_t>();
+  if (std::error_code EC = NumBlocks.getError())
+    return EC;
+
+  Entries.emplace_back(*Cutoff, *MinBlockCount, *NumBlocks);
+  return sampleprof_error::success;
+}
+
+std::error_code SampleProfileReaderBinary::readSummary() {
+  auto TotalCount = readNumber<uint64_t>();
+  if (std::error_code EC = TotalCount.getError())
+    return EC;
+
+  auto MaxBlockCount = readNumber<uint64_t>();
+  if (std::error_code EC = MaxBlockCount.getError())
+    return EC;
+
+  auto MaxFunctionCount = readNumber<uint64_t>();
+  if (std::error_code EC = MaxFunctionCount.getError())
+    return EC;
+
+  auto NumBlocks = readNumber<uint64_t>();
+  if (std::error_code EC = NumBlocks.getError())
+    return EC;
+
+  auto NumFunctions = readNumber<uint64_t>();
+  if (std::error_code EC = NumFunctions.getError())
+    return EC;
+
+  auto NumSummaryEntries = readNumber<uint64_t>();
+  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);
+
+  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);
   return Magic == SPMagic();
 }
 
 std::error_code SampleProfileReaderGCC::skipNextWord() {
std::error_code SampleProfileReaderGCC::readFunctionProfiles() {
   if (!GcovBuffer.readInt(NumFunctions))
     return sampleprof_error::truncated;
 
   InlineCallStack Stack;
   for (uint32_t I = 0; I < NumFunctions; ++I)
     if (std::error_code EC = readOneFunctionProfile(Stack, true, 0))
       return EC;
 
+  computeSummary();
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
     const InlineCallStack &InlineStack, bool Update, uint32_t Offset) {
   uint64_t HeadCount = 0;
   if (InlineStack.size() == 0)
     if (!GcovBuffer.readInt64(HeadCount))
SampleProfileReader::create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C) {
   else
     return sampleprof_error::unrecognized_format;
 
   if (std::error_code EC = Reader->readHeader())
     return EC;
 
   return std::move(Reader);
 }
+
+// For text and GCC file formats, we compute the summary after reading the
+// profile. Binary format has the profile summary in its header.
+void SampleProfileReader::computeSummary() {
+  Summary.reset(new SampleProfileSummary(ProfileSummary::DefaultCutoffs));
+  for (const auto &I : Profiles) {
+    const FunctionSamples &Profile = I.second;
+    Summary->addRecord(Profile);
+  }
+  Summary->computeDetailedSummary();
+}

llvm/trunk/lib/ProfileData/SampleProfWriter.cpp

 std::error_code SampleProfileWriterBinary::writeHeader(
     const StringMap<FunctionSamples> &ProfileMap) {
   auto &OS = *OutputStream;
 
   // Write file magic identifier.
   encodeULEB128(SPMagic(), OS);
   encodeULEB128(SPVersion(), OS);
 
+  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) {
     addName(I.first());
     addNames(I.second);
   }
 
   // Write out the name table.
   encodeULEB128(NameTable.size(), OS);
   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->getMaxHeadSamples(), OS);
+  encodeULEB128(Summary->getNumLinesWithSamples(), 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);
+  }
+  return sampleprof_error::success;
+}
 std::error_code SampleProfileWriterBinary::writeBody(StringRef FName,
                                                      const FunctionSamples &S) {
   auto &OS = *OutputStream;
 
   if (std::error_code EC = writeNameIdx(FName))
     return EC;
 
   encodeULEB128(S.getTotalSamples(), OS);
SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
   else
     EC = sampleprof_error::unrecognized_format;
 
   if (EC)
     return EC;
 
   return std::move(Writer);
 }
+
+void SampleProfileWriter::computeSummary(
+    const StringMap<FunctionSamples> &ProfileMap) {
+  Summary.reset(new SampleProfileSummary(ProfileSummary::DefaultCutoffs));
+  for (const auto &I : ProfileMap) {
+    const FunctionSamples &Profile = I.second;
+    Summary->addRecord(Profile);
+  }
+  Summary->computeDetailedSummary();
+}

llvm/trunk/unittests/ProfileData/SampleProfTest.cpp

struct SampleProfTest : ::testing::Test {
   void testRoundTrip(SampleProfileFormat Format) {
     createWriter(Format);
 
     StringRef FooName("_Z3fooi");
     FunctionSamples FooSamples;
     FooSamples.addTotalSamples(7711);
     FooSamples.addHeadSamples(610);
     FooSamples.addBodySamples(1, 0, 610);
+    FooSamples.addBodySamples(2, 0, 600);
+    FooSamples.addBodySamples(4, 0, 60000);
+    FooSamples.addBodySamples(8, 0, 60351);
+    FooSamples.addBodySamples(10, 0, 605);
 
     StringRef BarName("_Z3bari");
     FunctionSamples BarSamples;
     BarSamples.addTotalSamples(20301);
     BarSamples.addHeadSamples(1437);
     BarSamples.addBodySamples(1, 0, 1437);
 
     StringMap<FunctionSamples> Profiles;
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());
+
+    SampleProfileSummary &Summary = Reader->getSummary();
+    ASSERT_EQ(123603u, Summary.getTotalSamples());
+    ASSERT_EQ(6u, Summary.getNumLinesWithSamples());
+    ASSERT_EQ(2u, Summary.getNumFunctions());
+    ASSERT_EQ(1437u, Summary.getMaxHeadSamples());
+    ASSERT_EQ(60351u, Summary.getMaxSamplesPerLine());
+
+    std::vector<ProfileSummaryEntry> &Details = Summary.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(60000u, EightyPerc->MinCount);
+    ASSERT_EQ(60000u, NinetyPerc->MinCount);
+    ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
+    ASSERT_EQ(610u, NinetyNinePerc->MinCount);
   }
 };
 
 TEST_F(SampleProfTest, roundtrip_text_profile) {
   testRoundTrip(SampleProfileFormat::SPF_Text);
 }
 
 TEST_F(SampleProfTest, roundtrip_binary_profile) {