[llvm-mca][NFC] Refactor instruction printing

[wolfgangp]

Summary

There are several places where views generate an ASCII form of a machine instruction. Use a helper function.

This is another preparatory patch for JSON generation.

[lebedev.ri]

I believe this is going to regress normal codepath in terms of avoidable memory allocations.

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

23–24

I believe this change is going to cause many new allocations.

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

154–155

Same.

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

186–187

Same

295–297

Same

[lebedev.ri]

(marking as reviewed)

[wolfgangp]

Here is another proposal: We're using statics for the Instruction string and the stream to write it and return a reference to it.
The users all immediately write the string to a different stream. This should have even fewer allocations than the original code.

This is not MT-capable but I don't think this is a requirement for printing views.

[wolfgangp]

After some consultation with @andreadb this is some more extensive refactoring:
We create a new base class InstructionView that is meant for views that deal with individual instructions (e.g. print them). The 3 members MCIP (the instruction printer), STI (subtarget info) and Source (the array of machine instructions) live there and can be accessed via getters (they could be made protected as well). Printing the instructions is effected by using a string member in the new base class (which must be mutable along with its associated stream).

All this has the effect that only views that we don't use any globals for instruction printing while simplifying the code.

[andreadb]

Looks good to me module a few nits (see below).

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

38

Remove this comment.

47

Please add a virtual destructor.

virtual ~InstructionView() = defalt

51–57

Please move this definition to View.cpp.

[andreadb]

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

311

Remove const.

504

Remove const.

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

24

Remove const.

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

55

Remove const.

136

Remove const.

157

Remove const

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

283

Remove const.

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

36

Don't need const. It is not a mutable array.

45

Remove const.

61

Don't need const for this. ArrayRef is already a constant reference.

[lebedev.ri]

Looks better i guess, thanks.
Did't measure if there are any effects on memory consumption.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

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

 
 #include "Views/View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/FormattedStream.h"
 
 namespace llvm {
 namespace mca {
 
 class PressureTracker {
   const MCSchedModel &SM;
 
   // Resource pressure distribution. There is an element for every processor
public:
   void getCriticalSequence(SmallVectorImpl<const DependencyEdge *> &Seq) const;
 
 #ifndef NDEBUG
   void dump(raw_ostream &OS, MCInstPrinter &MCIP) const;
 #endif
 };
 
 /// A view that collects and prints a few performance numbers.
-class BottleneckAnalysis : public View {
-  const MCSubtargetInfo &STI;
-  MCInstPrinter &MCIP;
+class BottleneckAnalysis : public InstructionView {
   PressureTracker Tracker;
   DependencyGraph DG;
 
-  ArrayRef<MCInst> Source;
   unsigned Iterations;
   unsigned TotalCycles;
 
   bool PressureIncreasedBecauseOfResources;
   bool PressureIncreasedBecauseOfRegisterDependencies;
   bool PressureIncreasedBecauseOfMemoryDependencies;
   // True if throughput was affected by dispatch stalls.
   bool SeenStallCycles;
class BottleneckAnalysis : public InstructionView {
   };
   BackPressureInfo BPI;
 
   // Used to populate the dependency graph DG.
   void addRegisterDep(unsigned From, unsigned To, unsigned RegID, unsigned Cy);
   void addMemoryDep(unsigned From, unsigned To, unsigned Cy);
   void addResourceDep(unsigned From, unsigned To, uint64_t Mask, unsigned Cy);
 
+  void printInstruction(formatted_raw_ostream &FOS, const MCInst &MCI,
+                        bool UseDifferentColor = false) const;
+
   // Prints a bottleneck message to OS.
   void printBottleneckHints(raw_ostream &OS) const;
   void printCriticalSequence(raw_ostream &OS) const;
 
 public:
   BottleneckAnalysis(const MCSubtargetInfo &STI, MCInstPrinter &MCIP,
                      ArrayRef<MCInst> Sequence, unsigned Iterations);
 

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

 /// to report bottleneck info.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Views/BottleneckAnalysis.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MCA/Support.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/FormattedStream.h"
 
 namespace llvm {
 namespace mca {
 
 #define DEBUG_TYPE "llvm-mca"
 
 PressureTracker::PressureTracker(const MCSchedModel &Model)
     : SM(Model),
void DependencyGraph::getCriticalSequence(
   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;
     IID = N.CriticalPredecessor.FromIID;
   }
 }
 
-static void printInstruction(formatted_raw_ostream &FOS,
-                             const MCSubtargetInfo &STI, MCInstPrinter &MCIP,
+void BottleneckAnalysis::printInstruction(formatted_raw_ostream &FOS,
                                           const MCInst &MCI,
-                             bool UseDifferentColor = false) {
-  std::string Instruction;
-  raw_string_ostream InstrStream(Instruction);
-
+                                          bool UseDifferentColor) const {
   FOS.PadToColumn(14);
 
-  MCIP.printInst(&MCI, 0, "", STI, InstrStream);
-  InstrStream.flush();
-
   if (UseDifferentColor)
     FOS.changeColor(raw_ostream::CYAN, true, false);
-  FOS << StringRef(Instruction).ltrim();
+  FOS << printInstructionString(MCI);
   if (UseDifferentColor)
     FOS.resetColor();
 }
 
 void BottleneckAnalysis::printCriticalSequence(raw_ostream &OS) const {
   // Early exit if no bottlenecks were found during the simulation.
   if (!SeenStallCycles || !BPI.PressureIncreaseCycles)
     return;
 
   SmallVector<const DependencyEdge *, 16> Seq;
   DG.getCriticalSequence(Seq);
   if (Seq.empty())
     return;
 
   OS << "\nCritical sequence based on the simulation:\n\n";
 
   const DependencyEdge &FirstEdge = *Seq[0];
+  const ArrayRef<llvm::MCInst> Source = getSource();
   unsigned FromIID = FirstEdge.FromIID % Source.size();
   unsigned ToIID = FirstEdge.ToIID % Source.size();
   bool IsLoopCarried = FromIID >= ToIID;
 
   formatted_raw_ostream FOS(OS);
   FOS.PadToColumn(14);
   FOS << "Instruction";
   FOS.PadToColumn(58);
   FOS << "Dependency Information";
 
   bool HasColors = FOS.has_colors();
 
   unsigned CurrentIID = 0;
   if (IsLoopCarried) {
     FOS << "\n +----< " << FromIID << ".";
-    printInstruction(FOS, STI, MCIP, Source[FromIID], HasColors);
+    printInstruction(FOS, Source[FromIID], HasColors);
     FOS << "\n |\n |    < loop carried > \n |";
   } else {
     while (CurrentIID < FromIID) {
       FOS << "\n        " << CurrentIID << ".";
-      printInstruction(FOS, STI, MCIP, Source[CurrentIID]);
+      printInstruction(FOS, Source[CurrentIID]);
       CurrentIID++;
     }
 
     FOS << "\n +----< " << CurrentIID << ".";
-    printInstruction(FOS, STI, MCIP, Source[CurrentIID], HasColors);
+    printInstruction(FOS, Source[CurrentIID], HasColors);
     CurrentIID++;
   }
 
   for (const DependencyEdge *&DE : Seq) {
     ToIID = DE->ToIID % Source.size();
     unsigned LastIID = CurrentIID > ToIID ? Source.size() : ToIID;
 
     while (CurrentIID < LastIID) {
       FOS << "\n |      " << CurrentIID << ".";
-      printInstruction(FOS, STI, MCIP, Source[CurrentIID]);
+      printInstruction(FOS, Source[CurrentIID]);
       CurrentIID++;
     }
 
     if (CurrentIID == ToIID) {
       FOS << "\n +----> " << ToIID << ".";
-      printInstruction(FOS, STI, MCIP, Source[CurrentIID], HasColors);
+      printInstruction(FOS, Source[CurrentIID], HasColors);
     } else {
       FOS << "\n |\n |    < loop carried > \n |"
           << "\n +----> " << ToIID << ".";
-      printInstruction(FOS, STI, MCIP, Source[ToIID], HasColors);
+      printInstruction(FOS, Source[ToIID], HasColors);
     }
     FOS.PadToColumn(58);
 
     const DependencyEdge::Dependency &Dep = DE->Dep;
     if (HasColors)
       FOS.changeColor(raw_ostream::SAVEDCOLOR, true, false);
 
     if (Dep.Type == DependencyEdge::DT_REGISTER) {
       FOS << "## REGISTER dependency:  ";
       if (HasColors)
         FOS.changeColor(raw_ostream::MAGENTA, true, false);
-      MCIP.printRegName(FOS, Dep.ResourceOrRegID);
+      getInstPrinter().printRegName(FOS, Dep.ResourceOrRegID);
     } else if (Dep.Type == DependencyEdge::DT_MEMORY) {
       FOS << "## MEMORY dependency.";
     } else {
       assert(Dep.Type == DependencyEdge::DT_RESOURCE &&
              "Unsupported dependency type!");
       FOS << "## RESOURCE interference:  ";
       if (HasColors)
         FOS.changeColor(raw_ostream::MAGENTA, true, false);
       FOS << Tracker.resolveResourceName(Dep.ResourceOrRegID);
       if (HasColors) {
         FOS.resetColor();
         FOS.changeColor(raw_ostream::SAVEDCOLOR, true, false);
       }
       FOS << " [ probability: " << ((DE->Frequency * 100) / Iterations)
           << "% ]";
     }
     if (HasColors)
       FOS.resetColor();
     ++CurrentIID;
   }
 
   while (CurrentIID < Source.size()) {
     FOS << "\n        " << CurrentIID << ".";
-    printInstruction(FOS, STI, MCIP, Source[CurrentIID]);
+    printInstruction(FOS, Source[CurrentIID]);
     CurrentIID++;
   }
 
   FOS << '\n';
   FOS.flush();
 }
 
 #ifndef NDEBUG
void DependencyGraph::addDependency(unsigned From, unsigned To,
   DependencyEdge DE = {Dep, From, To, 1};
   Vec.emplace_back(DE);
   NodeTo.NumPredecessors++;
 }
 
 BottleneckAnalysis::BottleneckAnalysis(const MCSubtargetInfo &sti,
                                        MCInstPrinter &Printer,
                                        ArrayRef<MCInst> S, unsigned NumIter)
-    : STI(sti), MCIP(Printer), Tracker(STI.getSchedModel()), DG(S.size() * 3),
-      Source(S), Iterations(NumIter), TotalCycles(0),
+    : InstructionView(sti, Printer, S), Tracker(sti.getSchedModel()),
+      DG(S.size() * 3), Iterations(NumIter), TotalCycles(0),
       PressureIncreasedBecauseOfResources(false),
       PressureIncreasedBecauseOfRegisterDependencies(false),
       PressureIncreasedBecauseOfMemoryDependencies(false),
       SeenStallCycles(false), BPI() {}
 
 void BottleneckAnalysis::addRegisterDep(unsigned From, unsigned To,
                                         unsigned RegID, unsigned Cost) {
   bool IsLoopCarried = From >= To;
-  unsigned SourceSize = Source.size();
+  unsigned SourceSize = getSource().size();
   if (IsLoopCarried) {
     DG.addRegisterDep(From, To + SourceSize, RegID, Cost);
     DG.addRegisterDep(From + SourceSize, To + (SourceSize * 2), RegID, Cost);
     return;
   }
   DG.addRegisterDep(From + SourceSize, To + SourceSize, RegID, Cost);
 }
 
 void BottleneckAnalysis::addMemoryDep(unsigned From, unsigned To,
                                       unsigned Cost) {
   bool IsLoopCarried = From >= To;
-  unsigned SourceSize = Source.size();
+  unsigned SourceSize = getSource().size();
   if (IsLoopCarried) {
     DG.addMemoryDep(From, To + SourceSize, Cost);
     DG.addMemoryDep(From + SourceSize, To + (SourceSize * 2), Cost);
     return;
   }
   DG.addMemoryDep(From + SourceSize, To + SourceSize, Cost);
 }
 
 void BottleneckAnalysis::addResourceDep(unsigned From, unsigned To,
                                         uint64_t Mask, unsigned Cost) {
   bool IsLoopCarried = From >= To;
-  unsigned SourceSize = Source.size();
+  unsigned SourceSize = getSource().size();
   if (IsLoopCarried) {
     DG.addResourceDep(From, To + SourceSize, Mask, Cost);
     DG.addResourceDep(From + SourceSize, To + (SourceSize * 2), Mask, Cost);
     return;
   }
   DG.addResourceDep(From + SourceSize, To + SourceSize, Mask, Cost);
 }
 
 void BottleneckAnalysis::onEvent(const HWInstructionEvent &Event) {
   const unsigned IID = Event.IR.getSourceIndex();
   if (Event.Type == HWInstructionEvent::Dispatched) {
     Tracker.onInstructionDispatched(IID);
     return;
   }
   if (Event.Type == HWInstructionEvent::Executed) {
     Tracker.onInstructionExecuted(IID);
     return;
   }
 
   if (Event.Type != HWInstructionEvent::Issued)
     return;
 
+  const ArrayRef<llvm::MCInst> Source = getSource();
   const Instruction &IS = *Event.IR.getInstruction();
   unsigned To = IID % Source.size();
 
   unsigned Cycles = 2 * Tracker.getResourcePressureCycles(IID);
   uint64_t ResourceMask = IS.getCriticalResourceMask();
   SmallVector<std::pair<unsigned, unsigned>, 4> Users;
   while (ResourceMask) {
     uint64_t Current = ResourceMask & (-ResourceMask);
void BottleneckAnalysis::printBottleneckHints(raw_ostream &OS) const {
 
   OS << "\nThroughput Bottlenecks: "
      << "\n  Resource Pressure       [ "
      << format("%.2f", floor((ResourcePressurePerCycle * 100) + 0.5) / 100)
      << "% ]";
 
   if (BPI.PressureIncreaseCycles) {
     ArrayRef<unsigned> Distribution = Tracker.getResourcePressureDistribution();
-    const MCSchedModel &SM = STI.getSchedModel();
+    const MCSchedModel &SM = getSubTargetInfo().getSchedModel();
     for (unsigned I = 0, E = Distribution.size(); I < E; ++I) {
       unsigned ResourceCycles = Distribution[I];
       if (ResourceCycles) {
         double Frequency = (double)ResourceCycles * 100 / TotalCycles;
         const MCProcResourceDesc &PRDesc = *SM.getProcResource(I);
         OS << "\n  - " << PRDesc.Name << "  [ "
            << format("%.2f", floor((Frequency * 100) + 0.5) / 100) << "% ]";
       }

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

 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace llvm {
 namespace mca {
 
 /// A view that prints out generic instruction information.
-class InstructionInfoView : public View {
-  const llvm::MCSubtargetInfo &STI;
+class InstructionInfoView : public InstructionView {
   const llvm::MCInstrInfo &MCII;
   CodeEmitter &CE;
   bool PrintEncodings;
-  llvm::ArrayRef<llvm::MCInst> Source;
-  llvm::MCInstPrinter &MCIP;
 
   struct InstructionInfoViewData {
     unsigned NumMicroOpcodes = 0;
     unsigned Latency = 0;
     Optional<double> RThroughput = 0.0;
     bool mayLoad = false;
     bool mayStore = false;
     bool hasUnmodeledSideEffects = false;
   };
   using IIVDVec = SmallVector<InstructionInfoViewData, 16>;
 
   /// Place the data into the array of InstructionInfoViewData IIVD.
   void collectData(MutableArrayRef<InstructionInfoViewData> IIVD) const;
 
 public:
   InstructionInfoView(const llvm::MCSubtargetInfo &ST,
                       const llvm::MCInstrInfo &II, CodeEmitter &C,
                       bool ShouldPrintEncodings, llvm::ArrayRef<llvm::MCInst> S,
                       llvm::MCInstPrinter &IP)
-      : STI(ST), MCII(II), CE(C), PrintEncodings(ShouldPrintEncodings),
-        Source(S), MCIP(IP) {}
+      : InstructionView(ST, IP, S), MCII(II), CE(C),
+        PrintEncodings(ShouldPrintEncodings) {}
 
   void printView(llvm::raw_ostream &OS) const override;
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

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

 #include "llvm/Support/FormattedStream.h"
 
 namespace llvm {
 namespace mca {
 
 void InstructionInfoView::printView(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
-  std::string Instruction;
-  raw_string_ostream InstrStream(Instruction);
 
+  const ArrayRef<llvm::MCInst> &Source = getSource();
   if (!Source.size())
     return;
 
   IIVDVec IIVD(Source.size());
   collectData(IIVD);
 
   TempStream << "\n\nInstruction Info:\n";
   TempStream << "[1]: #uOps\n[2]: Latency\n[3]: RThroughput\n"
if (PrintEncodings) {
       formatted_raw_ostream FOS(TempStream);
       for (unsigned i = 0, e = Encoding.size(); i != e; ++i)
         FOS << format("%02x ", (uint8_t)Encoding[i]);
       FOS.PadToColumn(30);
       FOS.flush();
     }
 
     const MCInst &Inst = std::get<1>(I.value());
-    MCIP.printInst(&Inst, 0, "", STI, InstrStream);
-    InstrStream.flush();
-
-    // Consume any tabs or spaces at the beginning of the string.
-    StringRef Str(Instruction);
-    Str = Str.ltrim();
-    TempStream << Str << '\n';
-    Instruction = "";
+    TempStream << printInstructionString(Inst) << '\n';
   }
 
   TempStream.flush();
   OS << Buffer;
 }
 
 void InstructionInfoView::collectData(
     MutableArrayRef<InstructionInfoViewData> IIVD) const {
+  const llvm::MCSubtargetInfo &STI = getSubTargetInfo();
   const MCSchedModel &SM = STI.getSchedModel();
-  for (auto I : zip(Source, IIVD)) {
+  for (auto I : zip(getSource(), IIVD)) {
     const MCInst &Inst = std::get<0>(I);
     InstructionInfoViewData &IIVDEntry = std::get<1>(I);
     const MCInstrDesc &MCDesc = MCII.get(Inst.getOpcode());
 
     // Obtain the scheduling class information from the instruction.
     unsigned SchedClassID = MCDesc.getSchedClass();
     unsigned CPUID = SM.getProcessorID();
 

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

 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 namespace mca {
 
 /// This class collects resource pressure statistics and it is able to print
 /// out all the collected information as a table to an output stream.
-class ResourcePressureView : public View {
-  const llvm::MCSubtargetInfo &STI;
-  llvm::MCInstPrinter &MCIP;
-  llvm::ArrayRef<llvm::MCInst> Source;
+class ResourcePressureView : public InstructionView {
   unsigned LastInstructionIdx;
 
   // Map to quickly obtain the ResourceUsage column index from a processor
   // resource ID.
   llvm::DenseMap<unsigned, unsigned> Resource2VecIndex;
 
   // Table of resources used by instructions.
   std::vector<ResourceCycles> ResourceUsage;

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

 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 ResourcePressureView::ResourcePressureView(const llvm::MCSubtargetInfo &sti,
                                            MCInstPrinter &Printer,
                                            ArrayRef<MCInst> S)
-    : STI(sti), MCIP(Printer), Source(S), LastInstructionIdx(0) {
+    : InstructionView(sti, Printer, S), LastInstructionIdx(0) {
   // Populate the map of resource descriptors.
   unsigned R2VIndex = 0;
-  const MCSchedModel &SM = STI.getSchedModel();
+  const MCSchedModel &SM = getSubTargetInfo().getSchedModel();
   for (unsigned I = 0, E = SM.getNumProcResourceKinds(); I < E; ++I) {
     const MCProcResourceDesc &ProcResource = *SM.getProcResource(I);
     unsigned NumUnits = ProcResource.NumUnits;
     // Skip groups and invalid resources with zero units.
     if (ProcResource.SubUnitsIdxBegin || !NumUnits)
       continue;
 
     Resource2VecIndex.insert(std::pair<unsigned, unsigned>(I, R2VIndex));
     R2VIndex += ProcResource.NumUnits;
   }
 
   NumResourceUnits = R2VIndex;
-  ResourceUsage.resize(NumResourceUnits * (Source.size() + 1));
+  ResourceUsage.resize(NumResourceUnits * (getSource().size() + 1));
   std::fill(ResourceUsage.begin(), ResourceUsage.end(), 0.0);
 }
 
 void ResourcePressureView::onEvent(const HWInstructionEvent &Event) {
   if (Event.Type == HWInstructionEvent::Dispatched) {
     LastInstructionIdx = Event.IR.getSourceIndex();
     return;
   }
 
   // We're only interested in Issue events.
   if (Event.Type != HWInstructionEvent::Issued)
     return;
 
   const auto &IssueEvent = static_cast<const HWInstructionIssuedEvent &>(Event);
+  const ArrayRef<llvm::MCInst> &Source = getSource();
   const unsigned SourceIdx = Event.IR.getSourceIndex() % Source.size();
   for (const std::pair<ResourceRef, ResourceCycles> &Use :
        IssueEvent.UsedResources) {
     const ResourceRef &RR = Use.first;
     assert(Resource2VecIndex.find(RR.first) != Resource2VecIndex.end());
     unsigned R2VIndex = Resource2VecIndex[RR.first];
     R2VIndex += countTrailingZeros(RR.second);
     ResourceUsage[R2VIndex + NumResourceUnits * SourceIdx] += Use.second;

 }
 
 void ResourcePressureView::printResourcePressurePerIter(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   formatted_raw_ostream FOS(TempStream);
 
   FOS << "\n\nResources:\n";
-  const MCSchedModel &SM = STI.getSchedModel();
+  const MCSchedModel &SM = getSubTargetInfo().getSchedModel();
   for (unsigned I = 1, ResourceIndex = 0, E = SM.getNumProcResourceKinds();
        I < E; ++I) {
     const MCProcResourceDesc &ProcResource = *SM.getProcResource(I);
     unsigned NumUnits = ProcResource.NumUnits;
     // Skip groups and invalid resources with zero units.
     if (ProcResource.SubUnitsIdxBegin || !NumUnits)
       continue;
 
void ResourcePressureView::printResourcePressurePerIter(raw_ostream &OS) const {
   }
 
   FOS << "\n\nResource pressure per iteration:\n";
   FOS.flush();
   printColumnNames(FOS, SM);
   FOS << '\n';
   FOS.flush();
 
+  const ArrayRef<llvm::MCInst> Source = getSource();
   const unsigned Executions = LastInstructionIdx / Source.size() + 1;
   for (unsigned I = 0, E = NumResourceUnits; I < E; ++I) {
     double Usage = ResourceUsage[I + Source.size() * E];
     printResourcePressure(FOS, Usage / Executions, (I + 1) * 7);
   }
 
   FOS.flush();
   OS << Buffer;
 }
 
 void ResourcePressureView::printResourcePressurePerInst(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   formatted_raw_ostream FOS(TempStream);
 
   FOS << "\n\nResource pressure by instruction:\n";
-  printColumnNames(FOS, STI.getSchedModel());
+  printColumnNames(FOS, getSubTargetInfo().getSchedModel());
   FOS << "Instructions:\n";
 
-  std::string Instruction;
-  raw_string_ostream InstrStream(Instruction);
-
   unsigned InstrIndex = 0;
+  const ArrayRef<llvm::MCInst> Source = getSource();
   const unsigned Executions = LastInstructionIdx / Source.size() + 1;
   for (const MCInst &MCI : Source) {
     unsigned BaseEltIdx = InstrIndex * NumResourceUnits;
     for (unsigned J = 0; J < NumResourceUnits; ++J) {
       double Usage = ResourceUsage[J + BaseEltIdx];
       printResourcePressure(FOS, Usage / Executions, (J + 1) * 7);
     }
 
-    MCIP.printInst(&MCI, 0, "", STI, InstrStream);
-    InstrStream.flush();
-    StringRef Str(Instruction);
-
-    // Remove any tabs or spaces at the beginning of the instruction.
-    Str = Str.ltrim();
-
-    FOS << Str << '\n';
-    Instruction = "";
-
+    FOS << printInstructionString(MCI) << '\n';
     FOS.flush();
     OS << Buffer;
     Buffer = "";
 
     ++InstrIndex;
   }
 }
 } // namespace mca
 } // namespace llvm

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

 
 /// This class listens to instruction state transition events
 /// in order to construct a timeline information.
 ///
 /// For every instruction executed by the Pipeline, this class constructs
 /// a TimelineViewEntry object. TimelineViewEntry objects are then used
 /// to print the timeline information, as well as the "average wait times"
 /// for every instruction in the input assembly sequence.
-class TimelineView : public View {
-  const llvm::MCSubtargetInfo &STI;
-  llvm::MCInstPrinter &MCIP;
-  llvm::ArrayRef<llvm::MCInst> Source;
-
+class TimelineView : public InstructionView {
   unsigned CurrentCycle;
   unsigned MaxCycle;
   unsigned LastCycle;
 
   struct TimelineViewEntry {
     int CycleDispatched;  // A negative value is an "invalid cycle".
     unsigned CycleReady;
     unsigned CycleIssued;

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

 #include <numeric>
 
 namespace llvm {
 namespace mca {
 
 TimelineView::TimelineView(const MCSubtargetInfo &sti, MCInstPrinter &Printer,
                            llvm::ArrayRef<llvm::MCInst> S, unsigned Iterations,
                            unsigned Cycles)
-    : STI(sti), MCIP(Printer), Source(S), CurrentCycle(0),
+    : InstructionView(sti, Printer, S), CurrentCycle(0),
       MaxCycle(Cycles == 0 ? 80 : Cycles), LastCycle(0), WaitTime(S.size()),
       UsedBuffer(S.size()) {
-  unsigned NumInstructions = Source.size();
+  unsigned NumInstructions = getSource().size();
   assert(Iterations && "Invalid number of iterations specified!");
   NumInstructions *= Iterations;
   Timeline.resize(NumInstructions);
   TimelineViewEntry InvalidTVEntry = {-1, 0, 0, 0, 0};
   std::fill(Timeline.begin(), Timeline.end(), InvalidTVEntry);
 
   WaitTimeEntry NullWTEntry = {0, 0, 0};
   std::fill(WaitTime.begin(), WaitTime.end(), NullWTEntry);
 
   std::pair<unsigned, int> NullUsedBufferEntry = {/* Invalid resource ID*/ 0,
                                                   /* unknown buffer size */ -1};
   std::fill(UsedBuffer.begin(), UsedBuffer.end(), NullUsedBufferEntry);
 }
 
 void TimelineView::onReservedBuffers(const InstRef &IR,
                                      ArrayRef<unsigned> Buffers) {
-  if (IR.getSourceIndex() >= Source.size())
+  if (IR.getSourceIndex() >= getSource().size())
     return;
 
-  const MCSchedModel &SM = STI.getSchedModel();
+  const MCSchedModel &SM = getSubTargetInfo().getSchedModel();
   std::pair<unsigned, int> BufferInfo = {0, -1};
   for (const unsigned Buffer : Buffers) {
     const MCProcResourceDesc &MCDesc = *SM.getProcResource(Buffer);
     if (!BufferInfo.first || BufferInfo.second > MCDesc.BufferSize) {
       BufferInfo.first = Buffer;
       BufferInfo.second = MCDesc.BufferSize;
     }
   }
void TimelineView::onEvent(const HWInstructionEvent &Event) {
   case HWInstructionEvent::Retired: {
     TimelineViewEntry &TVEntry = Timeline[Index];
     if (CurrentCycle < MaxCycle)
       TVEntry.CycleRetired = CurrentCycle;
 
     // Update the WaitTime entry which corresponds to this Index.
     assert(TVEntry.CycleDispatched >= 0 && "Invalid TVEntry found!");
     unsigned CycleDispatched = static_cast<unsigned>(TVEntry.CycleDispatched);
-    WaitTimeEntry &WTEntry = WaitTime[Index % Source.size()];
+    WaitTimeEntry &WTEntry = WaitTime[Index % getSource().size()];
     WTEntry.CyclesSpentInSchedulerQueue +=
         TVEntry.CycleIssued - CycleDispatched;
     assert(CycleDispatched <= TVEntry.CycleReady &&
            "Instruction cannot be ready if it hasn't been dispatched yet!");
     WTEntry.CyclesSpentInSQWhileReady +=
         TVEntry.CycleIssued - TVEntry.CycleReady;
     WTEntry.CyclesSpentAfterWBAndBeforeRetire +=
         (CurrentCycle - 1) - TVEntry.CycleExecuted;
static void tryChangeColor(raw_ostream &OS, unsigned Cycles,
   }
   OS.changeColor(Color, /* bold */ true, /* BG */ false);
 }
 
 void TimelineView::printWaitTimeEntry(formatted_raw_ostream &OS,
                                       const WaitTimeEntry &Entry,
                                       unsigned SourceIndex,
                                       unsigned Executions) const {
-  bool PrintingTotals = SourceIndex == Source.size();
+  bool PrintingTotals = SourceIndex == getSource().size();
   unsigned CumulativeExecutions = PrintingTotals ? Timeline.size() : Executions;
 
   if (!PrintingTotals)
     OS << SourceIndex << '.';
 
   OS.PadToColumn(7);
 
   double AverageTime1, AverageTime2, AverageTime3;
void TimelineView::printWaitTimeEntry(formatted_raw_ostream &OS,
   OS.PadToColumn(20);
   if (!PrintingTotals)
     tryChangeColor(OS, Entry.CyclesSpentInSQWhileReady, CumulativeExecutions,
                    BufferSize);
   OS << format("%.1f", floor((AverageTime2 * 10) + 0.5) / 10);
   OS.PadToColumn(27);
   if (!PrintingTotals)
     tryChangeColor(OS, Entry.CyclesSpentAfterWBAndBeforeRetire,
-                   CumulativeExecutions, STI.getSchedModel().MicroOpBufferSize);
+                   CumulativeExecutions,
+                   getSubTargetInfo().getSchedModel().MicroOpBufferSize);
   OS << format("%.1f", floor((AverageTime3 * 10) + 0.5) / 10);
 
   if (OS.has_colors())
     OS.resetColor();
   OS.PadToColumn(34);
 }
 
 void TimelineView::printAverageWaitTimes(raw_ostream &OS) const {
   std::string Header =
       "\n\nAverage Wait times (based on the timeline view):\n"
       "[0]: Executions\n"
       "[1]: Average time spent waiting in a scheduler's queue\n"
       "[2]: Average time spent waiting in a scheduler's queue while ready\n"
       "[3]: Average time elapsed from WB until retire stage\n\n"
       "      [0]    [1]    [2]    [3]\n";
   OS << Header;
-
-  // Use a different string stream for printing instructions.
-  std::string Instruction;
-  raw_string_ostream InstrStream(Instruction);
-
   formatted_raw_ostream FOS(OS);
-  unsigned Executions = Timeline.size() / Source.size();
+  unsigned Executions = Timeline.size() / getSource().size();
   unsigned IID = 0;
-  for (const MCInst &Inst : Source) {
+  for (const MCInst &Inst : getSource()) {
     printWaitTimeEntry(FOS, WaitTime[IID], IID, Executions);
-    // Append the instruction info at the end of the line.
-    MCIP.printInst(&Inst, 0, "", STI, InstrStream);
-    InstrStream.flush();
-
-    // Consume any tabs or spaces at the beginning of the string.
-    StringRef Str(Instruction);
-    Str = Str.ltrim();
-    FOS << "   " << Str << '\n';
+    FOS << "   " << printInstructionString(Inst) << '\n';
     FOS.flush();
-    Instruction = "";
-
     ++IID;
   }
 
   // If the timeline contains more than one instruction,
   // let's also print global averages.
-  if (Source.size() != 1) {
+  if (getSource().size() != 1) {
     WaitTimeEntry TotalWaitTime = std::accumulate(
         WaitTime.begin(), WaitTime.end(), WaitTimeEntry{0, 0, 0},
         [](const WaitTimeEntry &A, const WaitTimeEntry &B) {
           return WaitTimeEntry{
               A.CyclesSpentInSchedulerQueue + B.CyclesSpentInSchedulerQueue,
               A.CyclesSpentInSQWhileReady + B.CyclesSpentInSQWhileReady,
               A.CyclesSpentAfterWBAndBeforeRetire +
                   B.CyclesSpentAfterWBAndBeforeRetire};
         });
     printWaitTimeEntry(FOS, TotalWaitTime, IID, Executions);
     FOS << "   "
         << "<total>" << '\n';
-    InstrStream.flush();
+    FOS.flush();
   }
 }
 
 void TimelineView::printTimelineViewEntry(formatted_raw_ostream &OS,
                                           const TimelineViewEntry &Entry,
                                           unsigned Iteration,
                                           unsigned SourceIndex) const {
   if (Iteration == 0 && SourceIndex == 0)
static void printTimelineHeader(formatted_raw_ostream &OS, unsigned Cycles) {
   OS << '\n';
 }
 
 void TimelineView::printTimeline(raw_ostream &OS) const {
   formatted_raw_ostream FOS(OS);
   printTimelineHeader(FOS, LastCycle);
   FOS.flush();
 
-  // Use a different string stream for the instruction.
-  std::string Instruction;
-  raw_string_ostream InstrStream(Instruction);
-
   unsigned IID = 0;
+  const ArrayRef<llvm::MCInst> &Source = getSource();
   const unsigned Iterations = Timeline.size() / Source.size();
   for (unsigned Iteration = 0; Iteration < Iterations; ++Iteration) {
     for (const MCInst &Inst : Source) {
       const TimelineViewEntry &Entry = Timeline[IID];
       if (Entry.CycleRetired == 0)
         return;
 
       unsigned SourceIndex = IID % Source.size();
       printTimelineViewEntry(FOS, Entry, Iteration, SourceIndex);
-      // Append the instruction info at the end of the line.
-      MCIP.printInst(&Inst, 0, "", STI, InstrStream);
-      InstrStream.flush();
-
-      // Consume any tabs or spaces at the beginning of the string.
-      StringRef Str(Instruction);
-      Str = Str.ltrim();
-      FOS << "   " << Str << '\n';
+      FOS << "   " << printInstructionString(Inst) << '\n';
       FOS.flush();
-      Instruction = "";
 
       ++IID;
     }
   }
 }
 } // namespace mca
 } // namespace llvm

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

 /// This file defines the main interface for Views. Each view contributes a
 /// portion of the final report generated by the tool.
 ///
 //===----------------------------------------------------------------------===//
 
 #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"
 
 namespace llvm {
 namespace mca {
 
 class View : public HWEventListener {
 public:
   virtual void printView(llvm::raw_ostream &OS) const = 0;
   virtual ~View() = default;
   void anchor() override;
 };
+
+// The base class for views that deal with individual machine instructions.
+class InstructionView : public View {
+  const llvm::MCSubtargetInfo &STI;
+  llvm::MCInstPrinter &MCIP;
+  const llvm::ArrayRef<llvm::MCInst> Source;
+
+  // Fields that 
+  mutable std::string InstructionString;
+  mutable raw_string_ostream InstrStream;
+
+protected:
+  InstructionView(const llvm::MCSubtargetInfo &STI,
+                  llvm::MCInstPrinter &Printer,
+                  const llvm::ArrayRef<llvm::MCInst> S)
+      : STI(STI), MCIP(Printer), Source(S), InstrStream(InstructionString) {}
+
+  // 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 {
+    InstructionString = "";
+    MCIP.printInst(&MCI, 0, "", STI, InstrStream);
+    InstrStream.flush();
+    // Remove any tabs or spaces at the beginning of the instruction.
+    return StringRef(InstructionString).ltrim();
+  }
+  
+  const llvm::MCSubtargetInfo &getSubTargetInfo() const { return STI; }
+  llvm::MCInstPrinter &getInstPrinter() const { return MCIP; }
+  const llvm::ArrayRef<llvm::MCInst> getSource() const { return Source; }
+};
 } // namespace mca
 } // namespace llvm
 
 #endif