[PGO] Add option to view CFG with profile after profile annotation

[davidxl]

Summary

Currently there is no way to view CFG with profile annotation right after the PGO annotation phase. This patch adds the support.

The profile displayed is based on BFI + entry profile count. This will be the profile which the downstream components see. A followup patch will be created to display CFG with raw profile counts produced by PGOUse phase. The later will be useful to detect bugs/limitations in BFI.

[vsk]

Transforms/Instrumentation/PGOInstrumentation.cpp

151

Could you change the name of the flag to reference the fact that this enables filtering by function name? E.g 'pgo-inspect-func' or 'pgo-view-function'.

1218

Does this have to be guarded by NDEBUG? It seems strange that the cl::opt will be visible + non-functional in release mode.

[davidxl]

Transforms/Instrumentation/PGOInstrumentation.cpp

151

ok

1218

this is currently true for BFI graph viewer. We may need to clean it up later (depending on the size impact to the release clang build).

[davidxl]

Address review feedback

[vsk]

LGTM.

Analysis/BlockFrequencyInfo.cpp

 cl::opt<unsigned>
     ViewHotFreqPercent("view-hot-freq-percent", cl::init(10), cl::Hidden,
                        cl::desc("An integer in percent used to specify "
                                 "the hot blocks/edges to be displayed "
                                 "in red: a block or edge whose frequency "
                                 "is no less than the max frequency of the "
                                 "function multiplied by this percent."));
 
+// Command line option to turn on CFG dot dump after profile annotation.
+cl::opt<bool> PGOViewCounts("pgo-view-counts", cl::init(false), cl::Hidden);
+
 namespace llvm {
 
+static GVDAGType getGVDT() {
+
+  if (PGOViewCounts)
+    return GVDT_Count;
+  return ViewBlockFreqPropagationDAG;
+}
+
 template <>
 struct GraphTraits<BlockFrequencyInfo *> {
   typedef const BasicBlock *NodeRef;
   typedef succ_const_iterator ChildIteratorType;
   typedef pointer_iterator<Function::const_iterator> nodes_iterator;
 
   static NodeRef getEntryNode(const BlockFrequencyInfo *G) {
     return &G->getFunction()->front();

 template <>
 struct DOTGraphTraits<BlockFrequencyInfo *> : public BFIDOTGTraitsBase {
   explicit DOTGraphTraits(bool isSimple = false)
       : BFIDOTGTraitsBase(isSimple) {}
 
   std::string getNodeLabel(const BasicBlock *Node,
                            const BlockFrequencyInfo *Graph) {
 
-    return BFIDOTGTraitsBase::getNodeLabel(Node, Graph,
-                                           ViewBlockFreqPropagationDAG);
+    return BFIDOTGTraitsBase::getNodeLabel(Node, Graph, getGVDT());
   }
 
   std::string getNodeAttributes(const BasicBlock *Node,
                                 const BlockFrequencyInfo *Graph) {
     return BFIDOTGTraitsBase::getNodeAttributes(Node, Graph,
                                                 ViewHotFreqPercent);
   }
 

Transforms/Instrumentation/PGOInstrumentation.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/IndirectCallSiteVisitor.h"
+#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"

 // the profile data for Comdat functions, which often turns out to be false
 // positive due to the pre-instrumentation inline.
 static cl::opt<bool> NoPGOWarnMismatchComdat("no-pgo-warn-mismatch-comdat",
                                              cl::init(true), cl::Hidden);
 
 // Command line option to enable/disable select instruction instrumentation.
 static cl::opt<bool> PGOInstrSelect("pgo-instr-select", cl::init(true),
                                     cl::Hidden);
+
+// Command line option to specify the name of the function for CFG dump
+static cl::opt<std::string>
+    PGOViewCountsName("pgo-view-counts-name", cl::Hidden,
+                      cl::desc("The option to specify "
+                               "the name of the function "
+                               "whose CFG will be displayed."));
+
+// Command line option to turn on CFG dot dump after profile annotation.
+extern cl::opt<bool> PGOViewCounts;
+
 namespace {
 
 /// The select instruction visitor plays three roles specified
 /// by the mode. In \c VM_counting mode, it simply counts the number of
 /// select instructions. In \c VM_instrument mode, it inserts code to count
 /// the number times TrueValue of select is taken. In \c VM_annotate mode,
 /// it reads the profile data and annotate the select instruction with metadata.
 enum VisitMode { VM_counting, VM_instrument, VM_annotate };
for (auto &F : M) {
     Func.populateCounters();
     Func.setBranchWeights();
     Func.annotateIndirectCallSites();
     PGOUseFunc::FuncFreqAttr FreqAttr = Func.getFuncFreqAttr();
     if (FreqAttr == PGOUseFunc::FFA_Cold)
       ColdFunctions.push_back(&F);
     else if (FreqAttr == PGOUseFunc::FFA_Hot)
       HotFunctions.push_back(&F);
+#ifndef NDEBUG
+    if (PGOViewCounts &&
+        (PGOViewCountsName.empty() || F.getName().equals(PGOViewCountsName))) {
+      LoopInfo LI{DominatorTree(F)};
+      std::unique_ptr<BranchProbabilityInfo> NewBPI =
+          llvm::make_unique<BranchProbabilityInfo>(F, LI);
+      std::unique_ptr<BlockFrequencyInfo> NewBFI =
+          llvm::make_unique<BlockFrequencyInfo>(F, *NewBPI, LI);
+
+      NewBFI->view();
+    }
+#endif
   }
   M.setProfileSummary(PGOReader->getSummary().getMD(M.getContext()));
   // Set function hotness attribute from the profile.
   // We have to apply these attributes at the end because their presence
   // can affect the BranchProbabilityInfo of any callers, resulting in an
   // inconsistent MST between prof-gen and prof-use.
   for (auto &F : HotFunctions) {
     F->addFnAttr(llvm::Attribute::InlineHint);