Adds diagnostics for missing opportunities of indirect call promotion.

[netforce]

Summary

Some indirect branches that are important for performance might not
be promoted because there are too many targets and/or they don't have enough
counts to be promoted. Let's make them easier to understand by adding
diagnostics for such opportunities.

[xur]

Also, adding a test would be helpful.

llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

373

How about move this ilne to line 412 to ICallPromotionAnalysis? I think that's a better place for this.

380

How about NotMeetPercentThreshold. It's better to use a same terms for the whole message.

[netforce]

Added a test and fixed some minor issues that I found while adding the test.

ICallPromotionAnalysis::getPromotionCandidatesForInstruction used to return only MaxNumPromotions targets even when there are more number of targets. So, added MaxNumTargets to set that number separately.

The desired coverage should be (100 - ICPMissingPercentThreshold) and not ICPMissingPercentThreshold.

[netforce]

Added a test. PTAL.

llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

373

Could you clarify this comment in a little more detail? Do you suggest changing the interface of ICallAnalysis.getPromotionCandidatesForInstruction() so that it could also exposed RemainingCount next to TotalCount? I don't see how it could be moved to line 412.

380

Done.

llvm/lib/Analysis/IndirectCallPromotionAnalysis.cpp

 static cl::opt<unsigned>
     ICPTotalPercentThreshold("icp-total-percent-threshold", cl::init(5),
                              cl::Hidden, cl::ZeroOrMore,
                              cl::desc("The percentage threshold against total "
                                       "count for the promotion"));
 
 // Set the maximum number of targets to promote for a single indirect-call
 // callsite.
-static cl::opt<unsigned>
+cl::opt<unsigned>
     MaxNumPromotions("icp-max-prom", cl::init(3), cl::Hidden, cl::ZeroOrMore,
                      cl::desc("Max number of promotions for a single indirect "
                               "call callsite"));
 
+// Set the maximum number of targets to fetch profile counts for a single
+// indirect-call callsite.
+static cl::opt<unsigned>
+    MaxNumTargets("icp-max-target", cl::init(6), cl::Hidden, cl::ZeroOrMore,
+                  cl::desc("Max number of targets to fetch profile counts for "
+                           "a single indirect call callsite"));
+
 ICallPromotionAnalysis::ICallPromotionAnalysis() {
-  ValueDataArray = std::make_unique<InstrProfValueData[]>(MaxNumPromotions);
+  ValueDataArray = std::make_unique<InstrProfValueData[]>(MaxNumTargets);
 }
 
 bool ICallPromotionAnalysis::isPromotionProfitable(uint64_t Count,
                                                    uint64_t TotalCount,
                                                    uint64_t RemainingCount) {
   return Count * 100 >= ICPRemainingPercentThreshold * RemainingCount &&
          Count * 100 >= ICPTotalPercentThreshold * TotalCount;
 }
uint32_t ICallPromotionAnalysis::getProfitablePromotionCandidates(
   return I;
 }
 
 ArrayRef<InstrProfValueData>
 ICallPromotionAnalysis::getPromotionCandidatesForInstruction(
     const Instruction *I, uint32_t &NumVals, uint64_t &TotalCount,
     uint32_t &NumCandidates) {
   bool Res =
-      getValueProfDataFromInst(*I, IPVK_IndirectCallTarget, MaxNumPromotions,
+      getValueProfDataFromInst(*I, IPVK_IndirectCallTarget, MaxNumTargets,
                                ValueDataArray.get(), NumVals, TotalCount);
   if (!Res) {
     NumCandidates = 0;
     return ArrayRef<InstrProfValueData>();
   }
   NumCandidates = getProfitablePromotionCandidates(I, NumVals, TotalCount);
   return ArrayRef<InstrProfValueData>(ValueDataArray.get(), NumVals);
 }

llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

 // Set the cutoff value for the promotion. If the value is other than 0, we
 // stop the transformation once the total number of promotions equals the cutoff
 // value.
 // For debug use only.
 static cl::opt<unsigned>
     ICPCutOff("icp-cutoff", cl::init(0), cl::Hidden, cl::ZeroOrMore,
               cl::desc("Max number of promotions for this compilation"));
 
+extern cl::opt<unsigned> MaxNumPromotions;
+
+static cl::opt<unsigned> ICPMissingPercentThreshold(
+    "icp-missing-percent-threshold", cl::init(50), cl::Hidden, cl::ZeroOrMore,
+    cl::desc("The percentage threshold of unpromoted indirect call counts to "
+             "print missed remark"));
+
 // If ICPCSSkip is non zero, the first ICPCSSkip callsites will be skipped.
 // For debug use only.
 static cl::opt<unsigned>
     ICPCSSkip("icp-csskip", cl::init(0), cl::Hidden, cl::ZeroOrMore,
               cl::desc("Skip Callsite up to this number for this compilation"));
 
 // Set if the pass is called in LTO optimization. The difference for LTO mode
 // is the pass won't prefix the source module name to the internal linkage

 bool ICallPromotionFunc::processFunction(ProfileSummaryInfo *PSI) {
   bool Changed = false;
   ICallPromotionAnalysis ICallAnalysis;
   for (auto *CB : findIndirectCalls(F)) {
     uint32_t NumVals, NumCandidates;
     uint64_t TotalCount;
     auto ICallProfDataRef = ICallAnalysis.getPromotionCandidatesForInstruction(
         CB, NumVals, TotalCount, NumCandidates);
-    if (!NumCandidates ||
-        (PSI && PSI->hasProfileSummary() && !PSI->isHotCount(TotalCount)))
+    if (PSI && PSI->hasProfileSummary() && !PSI->isHotCount(TotalCount)) {
+      if (!ICallProfDataRef.empty()) {
+        ORE.emit([&]() {
+          return OptimizationRemarkMissed(DEBUG_TYPE, "ColdCall", CB)
+                 << " Not promoted: cold call";
+        });
+      }
+      continue;
+    }
+    uint64_t RemainingCount = TotalCount;
+    for (uint32_t I = 0; I < NumCandidates; I++) {
+      RemainingCount -= ICallProfDataRef[I].Count;
+    }
+    if (ICallProfDataRef.size() > NumCandidates &&
+        RemainingCount * 100 > TotalCount * ICPMissingPercentThreshold) {
+      ORE.emit([&]() {
+        OptimizationRemarkMissed R(DEBUG_TYPE, "NotMeetPercentThreshold", CB);
+        if (NumCandidates == MaxNumPromotions) {
+          R << "icp-max-prom (="
+            << ore::NV("MaxNumPromotions", MaxNumPromotions)
+            << ") candidates were chosen, ";
+        } else {
+          R << ore::NV("NumCandidates", NumCandidates)
+            << " candidates were chosen and remaining are not profitable, ";
+        }
+        R << "but hasn't reached desired coverage "
+          << ore::NV("ICPMissingPercentThreshold",
+                     100 - ICPMissingPercentThreshold)
+          << "\% for a hot indirect call, and "
+          << ore::NV("Candidates", ICallProfDataRef.size() - NumCandidates)
+          << " candidates left with remaining count "
+          << ore::NV("RemainingCount", RemainingCount) << " out of total count "
+          << ore::NV("TotalCount", TotalCount) << " (";
+        for (uint32_t I = NumCandidates; I < ICallProfDataRef.size(); I++) {
+          if (I != NumCandidates) {
+            R << ", ";
+          }
+          uint64_t Target = ICallProfDataRef[I].Value;
+          StringRef Name = Symtab->getFuncName(Target);
+          if (Name.empty()) {
+            R << ore::NV("Target md4sum", Target);
+          } else {
+            R << ore::NV("TargetName", Name);
+          }
+          R << ": " << ore::NV("Target count", ICallProfDataRef[I].Count);
+        }
+        R << ")";
+        return R;
+      });
+    }
+    if (!NumCandidates)
       continue;
     auto PromotionCandidates = getPromotionCandidatesForCallSite(
         *CB, ICallProfDataRef, TotalCount, NumCandidates);
     uint32_t NumPromoted = tryToPromote(*CB, PromotionCandidates, TotalCount);
     if (NumPromoted == 0)
       continue;
 
     Changed = true;

llvm/test/Transforms/PGOProfile/icp_missed_msg.ll

+; RUN: opt < %s -pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S -icp-missing-percent-threshold=1 -profile-summary-hot-count=10 2>& 1 | FileCheck %s
+; RUN: opt < %s -passes=pgo-icall-prom -pass-remarks-missed=pgo-icall-prom -S -icp-missing-percent-threshold=1 -profile-summary-hot-count=10 2>& 1 | FileCheck %s
+
+; CHECK: remark: <unknown>:0:0: Not promoted: cold call
+; CHECK: remark: <unknown>:0:0: 1 candidates were chosen and remaining are not profitable, but hasn't reached desired coverage 99% for a hot indirect call, and 1 candidates left with remaining count 100 out of total count 1000 (func2: 10)
+; CHECK: remark: <unknown>:0:0: icp-max-prom (=3) candidates were chosen, but hasn't reached desired coverage 99% for a hot indirect call, and 1 candidates left with remaining count 100 out of total count 1000 (func1: 10)
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@foo = common global i32 ()* null, align 8
+@foo2 = common global i32 ()* null, align 8
+@foo3 = common global i32 ()* null, align 8
+
+define i32 @func1() {
+entry:
+  ret i32 0
+}
+
+define i32 @func2() {
+entry:
+  ret i32 1
+}
+
+define i32 @func3() {
+entry:
+  ret i32 2
+}
+
+define i32 @func4() {
+entry:
+  ret i32 3
+}
+
+define i32 @bar() {
+entry:
+  %tmp = load i32 ()*, i32 ()** @foo, align 8
+  %call = call i32 %tmp(), !prof !33
+  %tmp2 = load i32 ()*, i32 ()** @foo2, align 8
+  %call1 = call i32 %tmp2(), !prof !34
+  %add = add nsw i32 %call1, %call
+  %tmp3 = load i32 ()*, i32 ()** @foo3, align 8
+  %call2 = call i32 %tmp3(), !prof !35
+  %add2 = add nsw i32 %add, %call2
+  ret i32 %add2
+}
+
+!llvm.module.flags = !{!3}
+
+!3 = !{i32 1, !"ProfileSummary", !4}
+!4 = !{!5, !6, !7, !8, !9, !10, !11, !12}
+!5 = !{!"ProfileFormat", !"SampleProfile"}
+!6 = !{!"TotalCount", i64 0}
+!7 = !{!"MaxCount", i64 0}
+!8 = !{!"MaxInternalCount", i64 0}
+!9 = !{!"MaxFunctionCount", i64 0}
+!10 = !{!"NumCounts", i64 1}
+!11 = !{!"NumFunctions", i64 1}
+!12 = !{!"DetailedSummary", !13}
+!13 = !{!14, !15, !16, !17, !18, !19, !19, !20, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29}
+!14 = !{i32 10000, i64 0, i32 0}
+!15 = !{i32 100000, i64 0, i32 0}
+!16 = !{i32 200000, i64 0, i32 0}
+!17 = !{i32 300000, i64 0, i32 0}
+!18 = !{i32 400000, i64 0, i32 0}
+!19 = !{i32 500000, i64 0, i32 0}
+!20 = !{i32 600000, i64 0, i32 0}
+!21 = !{i32 700000, i64 0, i32 0}
+!22 = !{i32 800000, i64 0, i32 0}
+!23 = !{i32 900000, i64 0, i32 0}
+!24 = !{i32 950000, i64 0, i32 0}
+!25 = !{i32 990000, i64 0, i32 0}
+!26 = !{i32 999000, i64 0, i32 0}
+!27 = !{i32 999900, i64 0, i32 0}
+!28 = !{i32 999990, i64 0, i32 0}
+!29 = !{i32 999999, i64 0, i32 0}
+
+!33 = !{!"VP", i32 0, i64 5, i64 -2545542355363006406, i64 5}
+!34 = !{!"VP", i32 0, i64 1000, i64 -2545542355363006406, i64 900, i64 -4377547752858689819, i64 10}
+!35 = !{!"VP", i32 0, i64 1000, i64 7651369219802541373, i64 500, i64 -4377547752858689819, i64 300, i64 -6929281286627296573, i64 100, i64 -2545542355363006406, i64 10}