Add --hot-func-list to llvm-profdata show for sample profiles

[weihe]

Summary

Add the --hot-func-list feature to llvm-profdata show for sample profiles. This feature prints a list of hot functions whose max sample count are above the 99% threshold, with their numbers of total samples, total samples percentage, max samples, entry samples, and their function names.

[wmi]

Thanks for adding the feature.

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

1032–1048

Please make it a member function of FunctionSamples so it can be used elsewhere.

The max count can either be in inlinee or in itself. Your comment explicitly says that and it is good. Just the name getInlineeMaxCount is a little misleading. Perhaps use another name like getMaxCountInside?

1058

Uses a const variable instead of a raw number.

1092–1127

Can you wrap the output part in a function? I feel it can be useful as well for Instr profile. It is also better to be flexible about which metric is used to decide whether the function is hot (currently it is MaxCount). That could be different between PGO and SampleFDO.

[weihe]

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

1032–1048

Sounds good! I'll move and rename it. Thank you for your suggestions.

1058

Yeah, I'll change it. Thanks you!

1092–1127

Thank you for the suggestions! I would like to ask the following questions to make sure I understand them correctly:

For wrapping the output part into a function, is this function supposed to be reusable for other output format or only for the current format?

For making the metric flexible, is the purpose to make the showHotFunctionList() reusable for PGO? I'm asking this question because this function is currently coupled with FunctionSample objects and interfaces that may not work with other types of profiles.

Thanks!

[wmi]

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

1092–1127

It is to make the output part usable for PGO profile. I see that showHotFunctionList is coupled with FunctionSample, but after you decide which functions to output based on Function Sample, the output content and format are independent from profile kind and can be shared with PGO.

[weihe]

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

1092–1127

Thank you for the clarification! I'm working on it now.

[weihe]

Moved getInlineeMaxCount() to be FunctionSamples' member and wrapped printing code into a separate function.

The original static function getInlineeMaxCount() has been moved to be FunctionSamples::getMaxCountInside(). The output code in the original showHotFunctionList() has been wrapped into a separate function dumpHotFunctionList().

[weihe]

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

1092–1127

Hello, I moved the output code into a function dumpHotFunctionList() in the current revision. I tried to make it more flexible by allowing callers to determine column titles and column offsets. But the attributes to print out is still hard-coded in this function. There needs to be some changes if PGO would like to reuse this code. Please let me know if you have any suggestions.

[wmi]

LGTM. Thanks.

[wenlei]

@weihe thanks for working on this, I just committed this change on your behalf.

[riccibruno]

This is causing an Asan failure (see for example: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/17880).
I have reverted it for now. Thanks!

[wenlei]

In D81800#2105701, @riccibruno wrote:

This is causing an Asan failure (see for example: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/17880).
I have reverted it for now. Thanks!

Thanks for the heads up. We'll fix and resubmit later.

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

1054

ColNum isn't modified in the function, no need to pass by reference.

1141

ColumnOffset needs 4 slots too, otherwise dumpHotFunctionList will access out-of-bound. I think this is what's causing the asan failure.

[wenlei]

Resubmitted: https://reviews.llvm.org/rG53cf53023cbeb47d03fb9937ab3d06181eec8843

llvm/include/llvm/ProfileData/SampleProf.h

public:
   /// Return all the samples collected in the body of the function.
   const BodySampleMap &getBodySamples() const { return BodySamples; }
 
   /// Return all the callsite samples collected in the body of the function.
   const CallsiteSampleMap &getCallsiteSamples() const {
     return CallsiteSamples;
   }
 
+  /// Return the maximum of sample counts in a function body including functions
+  /// inlined in it.
+  uint64_t getMaxCountInside() const {
+    uint64_t MaxCount = 0;
+    for (const auto &L : getBodySamples()) {
+      MaxCount = std::max(MaxCount, L.second.getSamples());
+    }
+    for (const auto &C : getCallsiteSamples()) {
+      for (const auto &F : C.second) {
+        MaxCount = std::max(MaxCount, F.second.getMaxCountInside());
+      }
+    }
+    return MaxCount;
+  }
+
   /// Merge the samples in \p Other into this one.
   /// Optionally scale samples by \p Weight.
   sampleprof_error merge(const FunctionSamples &Other, uint64_t Weight = 1) {
     sampleprof_error Result = sampleprof_error::success;
     Name = Other.getName();
     MergeResult(Result, addTotalSamples(Other.getTotalSamples(), Weight));
     MergeResult(Result, addHeadSamples(Other.getHeadSamples(), Weight));
     for (const auto &I : Other.getBodySamples()) {

llvm/test/tools/llvm-profdata/Inputs/sample-hot-func-list.proftext

+_Z3bari:20301:1437
+ 1: 1437
+_Z3fooi:7711:610
+ 1: 610
+main:184019:0
+ 4: 534
+ 4.2: 534
+ 5: 1075
+ 5.1: 1075
+ 6: 2080
+ 7: 534
+ 9: 2300 _Z3bari:1471 _Z3fooi:631
+ 10: inline1:1000
+  1: 1000
+ 10: inline2:2000
+  1: 2000
+_Z3bazi:20305:1000
+ 1: 1000
+Func1:1523:169
+ 1: 169
+ 7: 563
+Func2:17043:1594
+ 1: 1594
+ 3: 1594
+ 6: 2009 Func1:150 Func3:1789
+ 13: 3105
+ 17: 3105
+ 19: 1594
+Func3:97401:3035
+ 1: 3035
+ 5: 7344
+ 9: 10640
+ 11: 10640
+ 15: 3035
+Func4:465:210
+ 1: 210
+Func5:6948:470
+ 1: 470
+ 3: 3507
+Func6:310:102
+ 1: 102

llvm/test/tools/llvm-profdata/sample-hot-func-list.test

+; RUN: llvm-profdata show --sample --hot-func-list %S/Inputs/sample-hot-func-list.proftext | FileCheck %s
+; CHECK: 8 out of 10 functions with profile (80.00%) are considered hot functions (max sample >= 470).
+; CHECK-NEXT: 355251 out of 356026 profile counts (99.78%) are from hot functions.
+; CHECK-NEXT: Total sample (%)        Max sample        Entry sample    Function name
+; CHECK-NEXT: 184019 (51.69%)         2300              534             main
+; CHECK-NEXT: 97401 (27.36%)          10640             3035            Func3
+; CHECK-NEXT: 20305 (5.70%)           1000              1000            _Z3bazi
+; CHECK-NEXT: 20301 (5.70%)           1437              1437            _Z3bari
+; CHECK-NEXT: 17043 (4.79%)           3105              1594            Func2
+; CHECK-NEXT: 7711 (2.17%)            610               610             _Z3fooi
+; CHECK-NEXT: 6948 (1.95%)            3507              470             Func5
+; CHECK-NEXT: 1523 (0.43%)            563               169             Func1

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

 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Threading.h"
 #include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
 
 enum ProfileFormat {
   PF_None = 0,
static void showSectionInfo(sampleprof::SampleProfileReader *Reader,
   if (!Reader->dumpSectionInfo(OS)) {
     WithColor::warning() << "-show-sec-info-only is only supported for "
                          << "sample profile in extbinary format and is "
                          << "ignored for other formats.\n";
     return;
   }
 }
 
+struct HotFuncInfo {
+  StringRef FuncName;
+  uint64_t TotalSample;
+  double TotalSamplePercent;
+  uint64_t MaxSample;
+  uint64_t EntrySample;
+
+  HotFuncInfo()
+      : FuncName(), TotalSample(0), TotalSamplePercent(0.0f), MaxSample(0),
+        EntrySample(0) {}
+
+  HotFuncInfo(StringRef FN, uint64_t TS, double TSP, uint64_t MS, uint64_t ES)
+      : FuncName(FN), TotalSample(TS), TotalSamplePercent(TSP), MaxSample(MS),
+        EntrySample(ES) {}
+};
+
+// Print out detailed information about hot functions in PrinfValues vector.
+// Users specify titles and offset of every columns through ColumnTitle and
+// ColumnOffset. Note that ColumnOffset starts from the offset of the second
+// column (because the first column always starts at offset 0). The size of
+// ColumnTitle and ColumnOffset need to be at least ColNum and ColNum-1. In
+// addition, users can optionally give a HotFuncMetric string to print out or
+// let it be an empty string.
+static void dumpHotFunctionList(
+    const uint64_t &ColNum, const std::vector<std::string> &ColumnTitle,
+    const std::vector<uint64_t> &ColumnOffset,
+    const std::vector<HotFuncInfo> &PrintValues, const uint64_t &HotFuncCount,
+    const uint64_t &TotalFuncCount, const uint64_t &HotProfCount,
+    const uint64_t &TotalProfCount, const std::string &HotFuncMetric,
+    raw_fd_ostream &OS) {
+  assert(ColumnOffset.size() >= ColNum - 1 && ColumnTitle.size() >= ColNum);
+
+  formatted_raw_ostream FOS(OS);
+  FOS << HotFuncCount << " out of " << TotalFuncCount
+      << " functions with profile ("
+      << format("%.2f%%", (((double)HotFuncCount) / TotalFuncCount * 100))
+      << ") are considered hot functions";
+  if (!HotFuncMetric.empty())
+    FOS << " (" << HotFuncMetric << ")";
+  FOS << ".\n";
+  FOS << HotProfCount << " out of " << TotalProfCount << " profile counts ("
+      << format("%.2f%%", (((double)HotProfCount) / TotalProfCount * 100))
+      << ") are from hot functions.\n";
+
+  if (ColNum == 0)
+    return;
+
+  for (size_t I = 0; I < ColNum; ++I) {
+    FOS << ColumnTitle[I];
+    FOS.PadToColumn(ColumnOffset[I]);
+  }
+  FOS << "\n";
+
+  for (const auto &R : PrintValues) {
+    FOS << R.TotalSample << " (" << format("%.2f%%", R.TotalSamplePercent)
+        << ")";
+    FOS.PadToColumn(ColumnOffset.size() > 0 ? ColumnOffset[0] : 0);
+    FOS << R.MaxSample;
+    FOS.PadToColumn(ColumnOffset.size() > 1 ? ColumnOffset[1] : 0);
+    FOS << R.EntrySample;
+    FOS.PadToColumn(ColumnOffset.size() > 2 ? ColumnOffset[2] : 0);
+    FOS << R.FuncName << "\n";
+  }
+  return;
+}
+
+static int
+showHotFunctionList(const StringMap<sampleprof::FunctionSamples> &Profiles,
+                    ProfileSummary &PS, raw_fd_ostream &OS) {
+  using namespace sampleprof;
+
+  const uint64_t HotFuncCutoff = 990000;
+  auto &SummaryVector = PS.getDetailedSummary();
+  uint64_t MinCountThreshold = 0;
+  for (const auto &SummaryEntry : SummaryVector) {
+    if (SummaryEntry.Cutoff == HotFuncCutoff) {
+      MinCountThreshold = SummaryEntry.MinCount;
+      break;
+    }
+  }
+  assert(MinCountThreshold != 0);
+
+  // Traverse all functions in the profile and keep only hot functions.
+  // The following loop also calculates the sum of total samples of all
+  // functions.
+  std::multimap<uint64_t, std::pair<const FunctionSamples *, const uint64_t>,
+                std::greater<uint64_t>>
+      HotFunc;
+  uint64_t ProfileTotalSample = 0;
+  uint64_t HotFuncSample = 0;
+  uint64_t HotFuncCount = 0;
+  uint64_t MaxCount = 0;
+  for (const auto &I : Profiles) {
+    const auto &FuncProf = I.second;
+    ProfileTotalSample += FuncProf.getTotalSamples();
+    MaxCount = FuncProf.getMaxCountInside();
+
+    // MinCountThreshold is a block/line threshold computed for a given cutoff.
+    // We intentionally compare the maximum sample count in a function with this
+    // threshold to get an approximate threshold for hot functions.
+    if (MaxCount >= MinCountThreshold) {
+      HotFunc.emplace(FuncProf.getTotalSamples(),
+                      std::make_pair(&(I.second), MaxCount));
+      HotFuncSample += FuncProf.getTotalSamples();
+      HotFuncCount++;
+    }
+  }
+
+  const uint64_t ColNum = 4;
+  std::vector<std::string> ColumnTitle{"Total sample (%)", "Max sample",
+                                       "Entry sample", "Function name"};
+  std::vector<uint64_t> ColumnOffset{24, 42, 58};
+  std::string Metric =
+      std::string("max sample >= ") + std::to_string(MinCountThreshold);
+  std::vector<HotFuncInfo> PrintValues;
+  for (const auto &FuncPair : HotFunc) {
+    const auto &FuncPtr = FuncPair.second.first;
+    PrintValues.emplace_back(
+        HotFuncInfo(FuncPtr->getFuncName(), FuncPtr->getTotalSamples(),
+                    (FuncPtr->getTotalSamples() * 100.0) / ProfileTotalSample,
+                    FuncPair.second.second, FuncPtr->getEntrySamples()));
+  }
+  dumpHotFunctionList(ColNum, ColumnTitle, ColumnOffset, PrintValues,
+                      HotFuncCount, Profiles.size(), HotFuncSample,
+                      ProfileTotalSample, Metric, OS);
+
+  return 0;
+}
+
 static int showSampleProfile(const std::string &Filename, bool ShowCounts,
                              bool ShowAllFunctions, bool ShowDetailedSummary,
                              const std::string &ShowFunction,
                              bool ShowProfileSymbolList,
-                             bool ShowSectionInfoOnly, raw_fd_ostream &OS) {
+                             bool ShowSectionInfoOnly, bool ShowHotFuncList,
+                             raw_fd_ostream &OS) {
   using namespace sampleprof;
   LLVMContext Context;
   auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
   if (std::error_code EC = ReaderOrErr.getError())
     exitWithErrorCode(EC, Filename);
 
   auto Reader = std::move(ReaderOrErr.get());
 
static int showSampleProfile(const std::string &Filename, bool ShowCounts,
   }
 
   if (ShowDetailedSummary) {
     auto &PS = Reader->getSummary();
     PS.printSummary(OS);
     PS.printDetailedSummary(OS);
   }
 
+  if (ShowHotFuncList)
+    showHotFunctionList(Reader->getProfiles(), Reader->getSummary(), OS);
+
   return 0;
 }
 
 static int show_main(int argc, const char *argv[]) {
   cl::opt<std::string> Filename(cl::Positional, cl::Required,
                                 cl::desc("<profdata-file>"));
 
   cl::opt<bool> ShowCounts("counts", cl::init(false),
cl::opt<bool> ShowMemOPSizes(
                "for shown functions"));
   cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
                                     cl::desc("Show detailed profile summary"));
   cl::list<uint32_t> DetailedSummaryCutoffs(
       cl::CommaSeparated, "detailed-summary-cutoffs",
       cl::desc(
           "Cutoff percentages (times 10000) for generating detailed summary"),
       cl::value_desc("800000,901000,999999"));
+  cl::opt<bool> ShowHotFuncList(
+      "hot-func-list", cl::init(false),
+      cl::desc("Show profile summary of a list of hot functions"));
   cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
                                  cl::desc("Details for every function"));
   cl::opt<bool> ShowCS("showcs", cl::init(false),
                        cl::desc("Show context sensitive counts"));
   cl::opt<std::string> ShowFunction("function",
                                     cl::desc("Details for matching functions"));
 
   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
if (ProfileKind == instr)
     return showInstrProfile(Filename, ShowCounts, TopNFunctions,
                             ShowIndirectCallTargets, ShowMemOPSizes,
                             ShowDetailedSummary, DetailedSummaryCutoffs,
                             ShowAllFunctions, ShowCS, ValueCutoff,
                             OnlyListBelow, ShowFunction, TextFormat, OS);
   else
     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
                              ShowDetailedSummary, ShowFunction,
-                             ShowProfileSymbolList, ShowSectionInfoOnly, OS);
+                             ShowProfileSymbolList, ShowSectionInfoOnly,
+                             ShowHotFuncList, OS);
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   StringRef ProgName(sys::path::filename(argv[0]));
   if (argc > 1) {
     int (*func)(int, const char *[]) = nullptr;