[llvm-profdata] add value-cutoff functionality to show command

[xur]

Summary

This patch improves llvm-profdata show command:
(1) add -value-cutoff=<N> option: only show function whose max count value is greater or equal to this cutoff value.
(2) add -list-below-cutoff option: output the functions whose max count value are below the cutoff value.
(3) format value-profile count values and print out the percentage.

[davidxl]

why is list-below-cutoff option useful?

Please also update the documentation for llvm-profdata with the new options.

[xur]

In D56342#1348462, @davidxl wrote:

why is list-below-cutoff option useful?

it can be used to list all the 0-count functions, like "-list-below-cutoff -value-cutoff=1 "

Please also update the documentation for llvm-profdata with the new options.

[xur]

Update llvm-prodata.rst per David's suggestion.

[davidxl]

docs/CommandGuide/llvm-profdata.rst

226

'Only output names of functions whose .... '

tools/llvm-profdata/llvm-profdata.cpp

674

ListBelow --> OnlyListBelow

702

!TextFormat && ListBelow

Text dump option is not compatible with ListBelow, and it should take precedence

811

Number of functions with maximum count (< " << ValueCutoff << "): " << ..

812

Functions -> functions

921

ListBelow --> OnlyListBelow

923

The semantics seems to be 'only list functions with ...'

[xur]

Integrated review comments from David.

[davidxl]

docs/CommandGuide/llvm-profdata.rst

221

value --> values

226

value -->values

tools/llvm-profdata/llvm-profdata.cpp

650

just use %.2f%% to remove the extra space

[xur]

Updated based on David's review comments

[davidxl]

lgtm

test/tools/llvm-profdata/value-prof.proftext

50

Remove space here.

docs/CommandGuide/llvm-profdata.rst

 .. option:: -text
 
  Instruct the profile dumper to show profile counts in the text format of the
  instrumentation-based profile data representation. By default, the profile
  information is dumped in a more human readable form (also in text) with
  annotations.
 
 .. option:: -topn=n
-       
  Instruct the profile dumper to show the top ``n`` functions with the
  hottest basic blocks in the summary section. By default, the topn functions
  are not dumped.
 
 .. option:: -sample
 
  Specify that the input profile is a sample-based profile.
 
 .. option:: -memop-sizes
 
  Show the profiled sizes of the memory intrinsic calls for shown functions.
 
+.. option:: -value-cutoff=n
+
+ Show only those functions whose max count values are greater or equal to ``n``.
+ By default, the value-cutoff is set to 0.
+
+.. option:: -list-below-cutoff
+
+ Only output names of functions whose max count value are below the cutoff
+ value.
+
 EXIT STATUS
 -----------
 
 :program:`llvm-profdata` returns 1 if the command is omitted or is invalid,
 if it cannot read input files, or if there is a mismatch between their data.

test/tools/llvm-profdata/Inputs/cutoff.proftext

+# IR level Instrumentation Flag
+:ir
+bar
+10
+2
+0
+0
+
+main
+16650
+4
+1
+1000
+1000000
+499500
+
+foo
+10
+2
+999
+1

test/tools/llvm-profdata/cutoff.test

+Basic tests for cutoff options in show command.
+
+RUN: llvm-profdata show -value-cutoff=1 %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=CUTOFF1 -check-prefix=CHECK
+RUN: llvm-profdata show -value-cutoff=1000 %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=CUTOFF1000 -check-prefix=CHECK
+RUN: llvm-profdata show -all-functions -value-cutoff=1 %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=CUTOFF1FUNC -check-prefix=CUTOFF1 -check-prefix=CHECK
+RUN: llvm-profdata show -all-functions -value-cutoff=1000 %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=CUTOFF1000FUNC -check-prefix=CUTOFF1000 -check-prefix=CHECK
+RUN: llvm-profdata show -value-cutoff=1 -list-below-cutoff %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=BELOW1 -check-prefix=CUTOFF1 -check-prefix=CHECK
+RUN: llvm-profdata show -value-cutoff=1000 -list-below-cutoff %p/Inputs/cutoff.proftext | FileCheck %s -check-prefix=BELOW1000 -check-prefix=CUTOFF1000 -check-prefix=CHECK
+CUTOFF1FUNC-NOT: bar
+CUTOFF1FUNC: Functions shown: 2
+CUTOFF1000FUNC-NOT: bar
+CUTOFF1000FUNC-NOT: foo
+CUTOFF1000FUNC: Functions shown: 1
+BELOW1: The list of functions with the maximum counter less than 1:
+BELOW1:  bar: (Max = 0 Sum = 0)
+BELOW1000:The list of functions with the maximum counter less than 1000:
+BELOW1000:  bar: (Max = 0 Sum = 0)
+BELOW1000:  foo: (Max = 999 Sum = 1000)
+CHECK: Total functions: 3
+CUTOFF1: Number of functions with maximum count (< 1): 1
+CUTOFF1: Number of functions with maximum count (>= 1): 2
+CUTOFF1000: Number of functions with maximum count (< 1000): 2
+CUTOFF1000: Number of functions with maximum count (>= 1000): 1

test/tools/llvm-profdata/value-prof.proftext

 2
 foo:100
 foo2:1000
 1
 foo2:20000
 
 #ICTXT: Indirect Call Site Count: 3
 #ICTXT-NEXT:    Indirect Target Results:
-#ICTXT-NEXT:  [ 1, foo, 100 ]
-#ICTXT-NEXT:  [ 1, foo2, 1000 ]
-#ICTXT-NEXT:  [ 2, foo2, 20000 ]
+#ICTXT-NEXT:  [ 1, foo, 100 ] ( 9.09%)
+#ICTXT-NEXT:  [ 1, foo2, 1000 ] ( 90.91%)
+#ICTXT-NEXT:  [ 2, foo2, 20000 ] (100.00%)
 
 #IC: Indirect Call Site Count: 3
 #IC-NEXT:    Indirect Target Results:
 #IC-NEXT: [ 1, foo2, 1000 ]
 #IC-NEXT: [ 1, foo, 100 ]
 #IC-NEXT: [ 2, foo2, 20000 ]
 
 #ICTEXT: foo:100

tools/llvm-profdata/llvm-profdata.cpp

for (size_t I = 0; I < NS; ++I) {
     std::unique_ptr<InstrProfValueData[]> VD = Func.getValueForSite(VK, I);
     Stats.TotalNumValues += NV;
     if (NV) {
       Stats.TotalNumValueSitesWithValueProfile++;
       if (NV > Stats.ValueSitesHistogram.size())
         Stats.ValueSitesHistogram.resize(NV, 0);
       Stats.ValueSitesHistogram[NV - 1]++;
     }
+
+    uint64_t SiteSum = 0;
+    for (uint32_t V = 0; V < NV; V++)
+      SiteSum += VD[V].Count;
+    if (SiteSum == 0)
+      SiteSum = 1;
+
     for (uint32_t V = 0; V < NV; V++) {
-      OS << "\t[ " << I << ", ";
+      OS << "\t[ " << format("%2u", I) << ", ";
       if (Symtab == nullptr)
-        OS << VD[V].Value;
+        OS << format("%4u", VD[V].Value);
       else
         OS << Symtab->getFuncName(VD[V].Value);
-      OS << ", " << VD[V].Count << " ]\n";
+      OS << ", " << format("%10" PRId64, VD[V].Count) << " ] ("
+         << format("%.2f%%", (VD[V].Count * 100.0 / SiteSum)) << ")\n";
     }
   }
 }
 
 static void showValueSitesStats(raw_fd_ostream &OS, uint32_t VK,
                                 ValueSitesStats &Stats) {
   OS << "  Total number of sites: " << Stats.TotalNumValueSites << "\n";
   OS << "  Total number of sites with values: "
      << Stats.TotalNumValueSitesWithValueProfile << "\n";
   OS << "  Total number of profiled values: " << Stats.TotalNumValues << "\n";
 
   OS << "  Value sites histogram:\n\tNumTargets, SiteCount\n";
   for (unsigned I = 0; I < Stats.ValueSitesHistogram.size(); I++) {
     if (Stats.ValueSitesHistogram[I] > 0)
       OS << "\t" << I + 1 << ", " << Stats.ValueSitesHistogram[I] << "\n";
   }
 }
 
 static int showInstrProfile(const std::string &Filename, bool ShowCounts,
                             uint32_t TopN, bool ShowIndirectCallTargets,
                             bool ShowMemOPSizes, bool ShowDetailedSummary,
                             std::vector<uint32_t> DetailedSummaryCutoffs,
-                            bool ShowAllFunctions,
-                            const std::string &ShowFunction, bool TextFormat,
-                            raw_fd_ostream &OS) {
+                            bool ShowAllFunctions, uint64_t ValueCutoff,
+                            bool OnlyListBelow, const std::string &ShowFunction,
+                            bool TextFormat, raw_fd_ostream &OS) {
   auto ReaderOrErr = InstrProfReader::create(Filename);
   std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
   if (ShowDetailedSummary && Cutoffs.empty()) {
     Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
   }
   InstrProfSummaryBuilder Builder(std::move(Cutoffs));
   if (Error E = ReaderOrErr.takeError())
     exitWithError(std::move(E), Filename);
 
   auto Reader = std::move(ReaderOrErr.get());
   bool IsIRInstr = Reader->isIRLevelProfile();
   size_t ShownFunctions = 0;
+  size_t BelowCutoffFunctions = 0;
   int NumVPKind = IPVK_Last - IPVK_First + 1;
   std::vector<ValueSitesStats> VPStats(NumVPKind);
 
   auto MinCmp = [](const std::pair<std::string, uint64_t> &v1,
                    const std::pair<std::string, uint64_t> &v2) {
     return v1.second > v2.second;
   };
 
   std::priority_queue<std::pair<std::string, uint64_t>,
                       std::vector<std::pair<std::string, uint64_t>>,
                       decltype(MinCmp)>
       HottestFuncs(MinCmp);
 
+  if (!TextFormat && OnlyListBelow) {
+    OS << "The list of functions with the maximum counter less than "
+       << ValueCutoff << ":\n";
+  }
+
   // Add marker so that IR-level instrumentation round-trips properly.
   if (TextFormat && IsIRInstr)
     OS << ":ir\n";
 
   for (const auto &Func : *Reader) {
     bool Show =
         ShowAllFunctions || (!ShowFunction.empty() &&
                              Func.Name.find(ShowFunction) != Func.Name.npos);
 
     bool doTextFormatDump = (Show && TextFormat);
 
     if (doTextFormatDump) {
       InstrProfSymtab &Symtab = Reader->getSymtab();
       InstrProfWriter::writeRecordInText(Func.Name, Func.Hash, Func, Symtab,
                                          OS);
       continue;
     }
 
     assert(Func.Counts.size() > 0 && "function missing entry counter");
     Builder.addRecord(Func);
 
-    if (TopN) {
-      uint64_t FuncMax = 0;
-      for (size_t I = 0, E = Func.Counts.size(); I < E; ++I)
-        FuncMax = std::max(FuncMax, Func.Counts[I]);
+    uint64_t FuncSum = 0;
+    for (size_t I = 0, E = Func.Counts.size(); I < E; ++I) {
+      FuncSum += Func.Counts[I];
+    }
 
+    if (FuncMax < ValueCutoff) {
+      ++BelowCutoffFunctions;
+      if (OnlyListBelow) {
+        OS << "  " << Func.Name << ": (Max = " << FuncMax
+           << " Sum = " << FuncSum << ")\n";
+      }
+      continue;
+    } else if (OnlyListBelow)
+      continue;
+
+    if (TopN) {
       if (HottestFuncs.size() == TopN) {
         if (HottestFuncs.top().second < FuncMax) {
           HottestFuncs.pop();
           HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
         }
       } else
         HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
     }
 
     if (Show) {
-
       if (!ShownFunctions)
         OS << "Counters:\n";
 
       ++ShownFunctions;
 
       OS << "  " << Func.Name << ":\n"
          << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
          << "    Counters: " << Func.Counts.size() << "\n";
static int showInstrProfile(const std::string &Filename, bool ShowCounts,
   if (TextFormat)
     return 0;
   std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
   OS << "Instrumentation level: "
      << (Reader->isIRLevelProfile() ? "IR" : "Front-end") << "\n";
   if (ShowAllFunctions || !ShowFunction.empty())
     OS << "Functions shown: " << ShownFunctions << "\n";
   OS << "Total functions: " << PS->getNumFunctions() << "\n";
+  if (ValueCutoff > 0) {
+    OS << "Number of functions with maximum count (< " << ValueCutoff
+       << "): " << BelowCutoffFunctions << "\n";
+    OS << "Number of functions with maximum count (>= " << ValueCutoff
+       << "): " << PS->getNumFunctions() - BelowCutoffFunctions << "\n";
+  }
   OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
   OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
 
   if (TopN) {
     std::vector<std::pair<std::string, uint64_t>> SortedHottestFuncs;
     while (!HottestFuncs.empty()) {
       SortedHottestFuncs.emplace_back(HottestFuncs.top());
       HottestFuncs.pop();
cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                             cl::aliasopt(OutputFilename));
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
                  clEnumVal(sample, "Sample profile")));
   cl::opt<uint32_t> TopNFunctions(
       "topn", cl::init(0),
       cl::desc("Show the list of functions with the largest internal counts"));
-
+  cl::opt<uint32_t> ValueCutoff(
+      "value-cutoff", cl::init(0),
+      cl::desc("Set the count value cutoff. Functions with the maximum count "
+               "less than this value will not be printed out. (Default is 0)"));
+  cl::opt<bool> OnlyListBelow(
+      "list-below-cutoff", cl::init(false),
+      cl::desc("Only output names of functions whose max count values are "
+               "below the cutoff value"));
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
 
   if (OutputFilename.empty())
     OutputFilename = "-";
 
   std::error_code EC;
   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   if (ShowAllFunctions && !ShowFunction.empty())
     WithColor::warning() << "-function argument ignored: showing all functions\n";
 
   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs.begin(),
                                 DetailedSummaryCutoffs.end());
   if (ProfileKind == instr)
     return showInstrProfile(Filename, ShowCounts, TopNFunctions,
                             ShowIndirectCallTargets, ShowMemOPSizes,
                             ShowDetailedSummary, DetailedSummaryCutoffs,
-                            ShowAllFunctions, ShowFunction, TextFormat, OS);
+                            ShowAllFunctions, ValueCutoff, OnlyListBelow,
+                            ShowFunction, TextFormat, OS);
   else
     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
                              ShowFunction, OS);
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);