[llvm-mca] [NFC] Formatting code

[markoshorro]

Summary

Applied clang-format to all files. Discarded BottleneckAnalysis.h 80-column width violation since it contains an example of report. Caught some typos and minor style details.

[andreadb]

LGTM

llvm/tools/llvm-mca/PipelinePrinter.cpp

for (unsigned I = 1, E = SM.getNumProcResourceKinds(); I < E; ++I) {
     const MCProcResourceDesc &ProcResource = *SM.getProcResource(I);
     unsigned NumUnits = ProcResource.NumUnits;
     if (ProcResource.SubUnitsIdxBegin || !NumUnits)
       continue;
 
     for (unsigned J = 0; J < NumUnits; ++J) {
       std::string ResourceName = ProcResource.Name;
       if (NumUnits > 1) {
-        ResourceName +=  ".";
+        ResourceName += ".";
         ResourceName += J;
       }
 
       Resources.push_back(ResourceName);
     }
   }
 
   return json::Object({{"CPUName", MCPU}, {"Resources", std::move(Resources)}});

llvm/tools/llvm-mca/Views/BottleneckAnalysis.h

 /// This file implements the bottleneck analysis view.
 ///
 /// This view internally observes backend pressure increase events in order to
 /// identify problematic data dependencies and processor resource interferences.
 ///
 /// Example of bottleneck analysis report for a dot-product on X86 btver2:
 ///
 /// Cycles with backend pressure increase [ 40.76% ]
 /// Throughput Bottlenecks: 
 ///   Resource Pressure       [ 39.34% ]
 ///   - JFPA  [ 39.34% ]
 ///   - JFPU0  [ 39.34% ]
 ///   Data Dependencies:      [ 1.42% ]
 ///   - Register Dependencies [ 1.42% ]
 ///   - Memory Dependencies   [ 0.00% ]
 ///
 /// According to the example, backend pressure increased during the 40.76% of
 /// the simulated cycles.  In particular, the major cause of backend pressure
 /// increases was the contention on floating point adder JFPA accessible from
 /// pipeline resource JFPU0.
 ///
 /// At the end of each cycle, if pressure on the simulated out-of-order buffers
 /// has increased, a backend pressure event is reported.
 /// In particular, this occurs when there is a delta between the number of uOps
 /// dispatched and the number of uOps issued to the underlying pipelines.
 ///
-/// The bottleneck analysis view is also responsible for identifying and printing
-/// the most "critical" sequence of dependent instructions according to the
-/// simulated run.
+/// The bottleneck analysis view is also responsible for identifying and
+/// printing the most "critical" sequence of dependent instructions according to
+/// the simulated run.
 ///
 /// Below is the critical sequence computed for the dot-product example on
 /// btver2:
 ///
 ///              Instruction                     Dependency Information
 /// +----< 2.    vhaddps %xmm3, %xmm3, %xmm4
 /// |
 /// |    < loop carried > 
 /// |
 /// |      0.    vmulps  %xmm0, %xmm0, %xmm2
 /// +----> 1.    vhaddps %xmm2, %xmm2, %xmm3     ## RESOURCE interference:  JFPA [ probability: 73% ]
 /// +----> 2.    vhaddps %xmm3, %xmm3, %xmm4     ## REGISTER dependency:  %xmm3
 /// |
 /// |    < loop carried > 
 /// |
 /// +----> 1.    vhaddps %xmm2, %xmm2, %xmm3     ## RESOURCE interference:  JFPA [ probability: 73% ]
 ///
 ///
 /// The algorithm that computes the critical sequence is very similar to a
 /// critical path analysis.
 /// 
 /// A dependency graph is used internally to track dependencies between nodes.
 /// Nodes of the graph represent instructions from the input assembly sequence,
 /// and edges of the graph represent data dependencies or processor resource
 /// interferences.
 ///
-/// Edges are dynamically 'discovered' by observing instruction state transitions
-/// and backend pressure increase events. Edges are internally ranked based on
-/// their "criticality". A dependency is considered to be critical if it takes a
-/// long time to execute, and if it contributes to backend pressure increases.
-/// Criticality is internally measured in terms of cycles; it is computed for
-/// every edge in the graph as a function of the edge latency and the number of
-/// backend pressure increase cycles contributed by that edge.
+/// Edges are dynamically 'discovered' by observing instruction state
+/// transitions and backend pressure increase events. Edges are internally
+/// ranked based on their "criticality". A dependency is considered to be
+/// critical if it takes a long time to execute, and if it contributes to
+/// backend pressure increases. Criticality is internally measured in terms of
+/// cycles; it is computed for every edge in the graph as a function of the edge
+/// latency and the number of backend pressure increase cycles contributed by
+/// that edge.
 ///
 /// At the end of simulation, costs are propagated to nodes through the edges of
 /// the graph, and the most expensive path connecting the root-set (a
 /// set of nodes with no predecessors) to a leaf node is reported as critical
 /// sequence.
 //
 //===----------------------------------------------------------------------===//
 

 //
 // The cost of a dependency is a function of both the latency and the number of
 // cycles where the dependency has been seen as critical (i.e. contributing to
 // back-pressure increases).
 //
 // Loop carried dependencies are carefully expanded by the bottleneck analysis
 // to guarantee that the graph stays acyclic. To this end, extra nodes are
 // pre-allocated at construction time to describe instructions from "past and
-// future" iterations. The graph is kept acyclic mainly because it simplifies the
-// complexity of the algorithm that computes the critical sequence.
+// future" iterations. The graph is kept acyclic mainly because it simplifies
+// the complexity of the algorithm that computes the critical sequence.
 class DependencyGraph {
   struct DGNode {
     unsigned NumPredecessors;
     unsigned NumVisitedPredecessors;
     uint64_t Cost;
     unsigned Depth;
 
     DependencyEdge CriticalPredecessor;
     SmallVector<DependencyEdge, 8> OutgoingEdges;
   };
   SmallVector<DGNode, 16> Nodes;
 
   DependencyGraph(const DependencyGraph &) = delete;
   DependencyGraph &operator=(const DependencyGraph &) = delete;
 
   void addDependency(unsigned From, unsigned To,
                      DependencyEdge::Dependency &&DE);
 
   void pruneEdges(unsigned Iterations);
   void initializeRootSet(SmallVectorImpl<unsigned> &RootSet) const;
-  void propagateThroughEdges(SmallVectorImpl<unsigned> &RootSet, unsigned Iterations);
+  void propagateThroughEdges(SmallVectorImpl<unsigned> &RootSet,
+                             unsigned Iterations);
 
 #ifndef NDEBUG
   void dumpDependencyEdge(raw_ostream &OS, const DependencyEdge &DE,
                           MCInstPrinter &MCIP) const;
 #endif
 
 public:
   DependencyGraph(unsigned Size) : Nodes(Size) {}

llvm/tools/llvm-mca/Views/BottleneckAnalysis.cpp

void DependencyGraph::initializeRootSet(
     SmallVectorImpl<unsigned> &RootSet) const {
   for (unsigned I = 0, E = Nodes.size(); I < E; ++I) {
     const DGNode &N = Nodes[I];
     if (N.NumPredecessors == 0 && !N.OutgoingEdges.empty())
       RootSet.emplace_back(I);
   }
 }
 
-void DependencyGraph::propagateThroughEdges(
-    SmallVectorImpl<unsigned> &RootSet, unsigned Iterations) {
+void DependencyGraph::propagateThroughEdges(SmallVectorImpl<unsigned> &RootSet,
+                                            unsigned Iterations) {
   SmallVector<unsigned, 8> ToVisit;
 
   // A critical sequence is computed as the longest path from a node of the
   // RootSet to a leaf node (i.e. a node with no successors).  The RootSet is
   // composed of nodes with at least one successor, and no predecessors.
   //
   // Each node of the graph starts with an initial default cost of zero.  The
   // cost of a node is a measure of criticality: the higher the cost, the bigger
   // is the performance impact.
   // For register and memory dependencies, the cost is a function of the write
   // latency as well as the actual delay (in cycles) caused to users.
   // For processor resource dependencies, the cost is a function of the resource
   // pressure. Resource interferences with low frequency values are ignored.
   //
   // This algorithm is very similar to a (reverse) Dijkstra.  Every iteration of
   // the inner loop selects (i.e. visits) a node N from a set of `unvisited
   // nodes`, and then propagates the cost of N to all its neighbors.
   //
   // The `unvisited nodes` set initially contains all the nodes from the
   // RootSet.  A node N is added to the `unvisited nodes` if all its
   // predecessors have been visited already.
-  // 
+  //
   // For simplicity, every node tracks the number of unvisited incoming edges in
   // field `NumVisitedPredecessors`.  When the value of that field drops to
   // zero, then the corresponding node is added to a `ToVisit` set.
   //
   // At the end of every iteration of the outer loop, set `ToVisit` becomes our
   // new `unvisited nodes` set.
-  // 
+  //
   // The algorithm terminates when the set of unvisited nodes (i.e. our RootSet)
   // is empty. This algorithm works under the assumption that the graph is
   // acyclic.
   do {
     for (unsigned IID : RootSet) {
       const DGNode &N = Nodes[IID];
       for (const DependencyEdge &DepEdge : N.OutgoingEdges) {
         unsigned ToIID = DepEdge.ToIID;
void DependencyGraph::getCriticalSequence(
     SmallVectorImpl<const DependencyEdge *> &Seq) const {
   // At this stage, nodes of the graph have been already visited, and costs have
   // been propagated through the edges (see method `propagateThroughEdges()`).
 
   // Identify the node N with the highest cost in the graph. By construction,
   // that node is the last instruction of our critical sequence.
   // Field N.Depth would tell us the total length of the sequence.
   //
-  // To obtain the sequence of critical edges, we simply follow the chain of critical
-  // predecessors starting from node N (field DGNode::CriticalPredecessor).
+  // To obtain the sequence of critical edges, we simply follow the chain of
+  // critical predecessors starting from node N (field
+  // DGNode::CriticalPredecessor).
   const auto It = std::max_element(
       Nodes.begin(), Nodes.end(),
       [](const DGNode &Lhs, const DGNode &Rhs) { return Lhs.Cost < Rhs.Cost; });
   unsigned IID = std::distance(Nodes.begin(), It);
   Seq.resize(Nodes[IID].Depth);
   for (unsigned I = Seq.size(), E = 0; I > E; --I) {
     const DGNode &N = Nodes[IID];
     Seq[I - 1] = &N.CriticalPredecessor;

llvm/tools/llvm-mca/Views/DispatchStatistics.cpp

-//===--------------------- DispatchStatistics.cpp ---------------------*- C++
-//-*-===//
+//===--------------------- DispatchStatistics.cpp ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///

llvm/tools/llvm-mca/Views/InstructionView.h

-//===----------------------- InstrucionView.h -----------------------------*- C++ -*-===//
+//===----------------------- InstructionView.h ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the main interface for Views that examine and reference
 /// a sequence of machine instructions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 
 #include "Views/View.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 // The base class for views that deal with individual machine instructions.
 class InstructionView : public View {
   const llvm::MCSubtargetInfo &STI;
   llvm::MCInstPrinter &MCIP;
   llvm::ArrayRef<llvm::MCInst> Source;
 
   mutable std::string InstructionString;
   mutable raw_string_ostream InstrStream;
 
 public:
   void printView(llvm::raw_ostream &) const override {}
   InstructionView(const llvm::MCSubtargetInfo &STI,
-                  llvm::MCInstPrinter &Printer,
-                  llvm::ArrayRef<llvm::MCInst> S)
+                  llvm::MCInstPrinter &Printer, llvm::ArrayRef<llvm::MCInst> S)
       : STI(STI), MCIP(Printer), Source(S), InstrStream(InstructionString) {}
 
   virtual ~InstructionView();
 
-  StringRef getNameAsString() const override {
-    return "Instructions";
-  }
+  StringRef getNameAsString() const override { return "Instructions"; }
 
   // Return a reference to a string representing a given machine instruction.
   // The result should be used or copied before the next call to
   // printInstructionString() as it will overwrite the previous result.
   StringRef printInstructionString(const llvm::MCInst &MCI) const;
   const llvm::MCSubtargetInfo &getSubTargetInfo() const { return STI; }
 
   llvm::MCInstPrinter &getInstPrinter() const { return MCIP; }

llvm/tools/llvm-mca/Views/InstructionView.cpp

-//===----------------------- View.cpp ---------------------------*- C++ -*-===//
+//===----------------------- InstructionView.cpp ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the member functions of the class InstructionView.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Views/InstructionView.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 namespace mca {
 
 InstructionView::~InstructionView() = default;
 
-StringRef InstructionView::printInstructionString(const llvm::MCInst &MCI) const {
+StringRef
+InstructionView::printInstructionString(const llvm::MCInst &MCI) const {
   InstructionString = "";
   MCIP.printInst(&MCI, 0, "", STI, InstrStream);
   InstrStream.flush();
   // Remove any tabs or spaces at the beginning of the instruction.
   return StringRef(InstructionString).ltrim();
 }
 
 json::Value InstructionView::toJSON() const {

llvm/tools/llvm-mca/Views/RegisterFileStatistics.cpp

void RegisterFileStatistics::updateMoveElimInfo(const Instruction &Inst) {
   if (!Inst.isOptimizableMove())
     return;
 
   if (Inst.getDefs().size() != Inst.getUses().size())
     return;
 
   for (size_t I = 0, E = Inst.getDefs().size(); I < E; ++I) {
     const WriteState &WS = Inst.getDefs()[I];
-    const ReadState &RS = Inst.getUses()[E - (I+1)];
+    const ReadState &RS = Inst.getUses()[E - (I + 1)];
 
     MoveEliminationInfo &Info =
         MoveElimInfo[Inst.getDefs()[0].getRegisterFileID()];
     Info.TotalMoveEliminationCandidates++;
     if (WS.isEliminated())
       Info.CurrentMovesEliminated++;
     if (WS.isWriteZero() && RS.isReadZero())
       Info.TotalMovesThatPropagateZero++;

llvm/tools/llvm-mca/Views/RetireControlUnitStatistics.cpp

for (const std::pair<const unsigned, unsigned> &Entry : RetiredPerCycle) {
     else
       TempStream << ",          ";
     TempStream << Entry.second << "  ("
                << format("%.1f", ((double)Entry.second / NumCycles) * 100.0)
                << "%)\n";
   }
 
   unsigned AvgUsage = (double)SumOfUsedEntries / NumCycles;
-  double MaxUsagePercentage = ((double)MaxUsedEntries / TotalROBEntries) * 100.0;
+  double MaxUsagePercentage =
+      ((double)MaxUsedEntries / TotalROBEntries) * 100.0;
   double NormalizedMaxPercentage = floor((MaxUsagePercentage * 10) + 0.5) / 10;
   double AvgUsagePercentage = ((double)AvgUsage / TotalROBEntries) * 100.0;
   double NormalizedAvgPercentage = floor((AvgUsagePercentage * 10) + 0.5) / 10;
 
   TempStream << "\nTotal ROB Entries:                " << TotalROBEntries
              << "\nMax Used ROB Entries:             " << MaxUsedEntries
              << format("  ( %.1f%% )", NormalizedMaxPercentage)
              << "\nAverage Used ROB Entries per cy:  " << AvgUsage
              << format("  ( %.1f%% )\n", NormalizedAvgPercentage);
 
   TempStream.flush();
   OS << Buffer;
 }
 
 } // namespace mca
 } // namespace llvm

llvm/tools/llvm-mca/Views/SummaryView.h

-//===--------------------- SummaryView.h ---------------------*- C++ -*-===//
+//===--------------------- SummaryView.h ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///

llvm/tools/llvm-mca/Views/SummaryView.cpp

-//===--------------------- SummaryView.cpp -------------------*- C++ -*-===//
+//===--------------------- SummaryView.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///

 
 namespace llvm {
 namespace mca {
 
 #define DEBUG_TYPE "llvm-mca"
 
 SummaryView::SummaryView(const MCSchedModel &Model, ArrayRef<MCInst> S,
                          unsigned Width)
-    : SM(Model), Source(S), DispatchWidth(Width?Width: Model.IssueWidth),
-      LastInstructionIdx(0),
-      TotalCycles(0), NumMicroOps(0),
+    : SM(Model), Source(S), DispatchWidth(Width ? Width : Model.IssueWidth),
+      LastInstructionIdx(0), TotalCycles(0), NumMicroOps(0),
       ProcResourceUsage(Model.getNumProcResourceKinds(), 0),
       ProcResourceMasks(Model.getNumProcResourceKinds()),
       ResIdx2ProcResID(Model.getNumProcResourceKinds(), 0) {
   computeProcResourceMasks(SM, ProcResourceMasks);
   for (unsigned I = 1, E = SM.getNumProcResourceKinds(); I < E; ++I) {
     unsigned Index = getResourceStateIndex(ProcResourceMasks[I]);
     ResIdx2ProcResID[Index] = I;
   }

llvm/tools/llvm-mca/Views/TimelineView.h

 /// to print the timeline information, as well as the "average wait times"
 /// for every instruction in the input assembly sequence.
 class TimelineView : public InstructionView {
   unsigned CurrentCycle;
   unsigned MaxCycle;
   unsigned LastCycle;
 
   struct TimelineViewEntry {
-    int CycleDispatched;  // A negative value is an "invalid cycle".
+    int CycleDispatched; // A negative value is an "invalid cycle".
     unsigned CycleReady;
     unsigned CycleIssued;
     unsigned CycleExecuted;
     unsigned CycleRetired;
   };
   std::vector<TimelineViewEntry> Timeline;
 
   struct WaitTimeEntry {

llvm/tools/llvm-mca/Views/View.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_VIEW_H
 #define LLVM_TOOLS_LLVM_MCA_VIEW_H
 
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MCA/HWEventListener.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 class View : public HWEventListener {
 public:
   virtual ~View() = default;
 

llvm/tools/llvm-mca/llvm-mca.cpp

TripleName("mtriple",
                cl::desc("Target triple. See -version for available targets"),
                cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
          cl::value_desc("cpu-name"), cl::cat(ToolOptions), cl::init("native"));
 
-static cl::opt<std::string>
-    MATTR("mattr",
+static cl::opt<std::string> MATTR("mattr",
                                   cl::desc("Additional target features."),
                                   cl::cat(ToolOptions));
 
-static cl::opt<bool>
-    PrintJson("json",
+static cl::opt<bool> PrintJson("json",
                                cl::desc("Print the output in json format"),
                                cl::cat(ToolOptions), cl::init(false));
 
 static cl::opt<int>
     OutputAsmVariant("output-asm-variant",
                      cl::desc("Syntax variant to use for output printing"),
                      cl::cat(ToolOptions), cl::init(-1));
 
 static cl::opt<bool>
     PrintImmHex("print-imm-hex", cl::cat(ToolOptions), cl::init(false),
for (const std::unique_ptr<mca::CodeRegion> &Region : Regions) {
     if (PrintInstructionTables) {
       //  Create a pipeline, stages, and a printer.
       auto P = std::make_unique<mca::Pipeline>();
       P->appendStage(std::make_unique<mca::EntryStage>(S));
       P->appendStage(std::make_unique<mca::InstructionTables>(SM));
 
       mca::PipelinePrinter Printer(*P, *Region, RegionIdx, *STI);
       if (PrintJson) {
-        auto IV = std::make_unique<mca::InstructionView>(*STI, *IP, Insts);
-        Printer.addView(std::move(IV));
+        Printer.addView(
+            std::make_unique<mca::InstructionView>(*STI, *IP, Insts));
       }
 
       // Create the views for this pipeline, execute, and emit a report.
       if (PrintInstructionInfoView) {
         Printer.addView(std::make_unique<mca::InstructionInfoView>(
             *STI, *MCII, CE, ShowEncoding, Insts, *IP));
       }
       Printer.addView(