[MCA] Rework InstructionInfoView printing to be able to add full view

Option instruction-tables is an enumeration now but
legacy behavior (boolean) is kept available.
New option: -instruction-tables=<none,normal,full>.
-instruction-tables is equivalent to -instruction-tables=normal.
-instruction-tables=none is the default.
-instruction-tables=full is equivalent to:
 -instruction-tables and -scheduling-info
-sheduling-info option removed.

Author: JulienVillette

llvm/docs/CommandGuide/llvm-mca.rst

@@ -170,20 +170,6 @@ option specifies "``-``", then the output will also be sent to standard output.
   Enable extra scheduler statistics. This view collects and analyzes instruction
   issue events. This view is disabled by default.
 
-.. option:: -scheduling-info
-
-  Enable scheduling info view. This view reports scheduling information defined
-  in LLVM target description in the form:
-  ``<uOps> <Latency> <Bypass Latency> <Throughput> <LLVM Opcode Name> <Resources
-  units> <instruction and comment (// or /* */) if defined>``
-  It allows to compare scheduling info with architecture documents and fix them
-  in target description by fixing InstrRW for the reported LLVM opcode.
-  Scheduling information can be defined in the same order in each instruction
-  comments to check easily reported and reference scheduling information.
-  Suggested information in comment:
-  ``// <architecture instruction form> \\ <scheduling documentation title> \\
-  <uOps>, <Latency>, <Bypass Latency>, <Throughput>, <Resources units>``
-
 .. option:: -retire-stats
 
   Enable extra retire control unit statistics. This view is disabled by default.
@@ -211,14 +197,25 @@ option specifies "``-``", then the output will also be sent to standard output.
 
   Enable all the view.
 
-.. option:: -instruction-tables
+.. option:: -instruction-tables=<level>
 
   Prints resource pressure information based on the static information
   available from the processor model. This differs from the resource pressure
   view because it doesn't require that the code is simulated. It instead prints
   the theoretical uniform distribution of resource pressure for every
   instruction in sequence.
 
+  The choice of `<level>` controls number of printed information.
+  `<level>` may be `none` (default), `normal`, `full`.
+  Note: If the option is used without `<label>`, default is `normal` (legacy).
+
+  When `<level>` is `full`, additional information are:
+  - `<Bypass Latency>`: Latency when a bypass is implemented between operands
+  in pipelines (see SchedReadAdvance).
+  - `<LLVM Opcode Name>`: mnemonic plus operands identifier.
+  - `<Resources units>`: Used resources associated with LLVM Opcode.
+  - `<instruction comment>`: reports comment if any from source assembly.
+
 .. option:: -bottleneck-analysis
 
   Print information about bottlenecks that affect the throughput. This analysis

llvm/test/tools/llvm-mca/AArch64/Neoverse/V1-sve-instructions.s

@@ -1,5 +1,5 @@
 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
-# RUN: llvm-mca -mtriple=aarch64 -mcpu=neoverse-v1 -instruction-tables -scheduling-info < %s | FileCheck %s
+# RUN: llvm-mca -mtriple=aarch64 -mcpu=neoverse-v1 -instruction-tables=full < %s | FileCheck %s
 
 abs	z0.b, p0/m, z0.b
 abs	z0.d, p0/m, z0.d

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

@@ -132,6 +132,7 @@ void InstructionInfoView::printSchedulingInfoView(raw_ostream &OS) const {
 void InstructionInfoView::printView(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
+  formatted_raw_ostream FOS(TempStream);
 
   ArrayRef<llvm::MCInst> Source = getSource();
   if (!Source.size())
@@ -140,7 +141,7 @@ void InstructionInfoView::printView(raw_ostream &OS) const {
   IIVDVec IIVD(Source.size());
   collectData(IIVD);
 
-  if (PrintSchedulingInfo) {
+  if (PrintFullInfo) {
     if (PrintEncodings)
       WithColor::warning()
           << "No encodings printed when -scheduling-info option enabled.\n";
@@ -152,82 +153,94 @@ void InstructionInfoView::printView(raw_ostream &OS) const {
     return;
   }
 
-  TempStream << "\n\nInstruction Info:\n";
-  TempStream << "[1]: #uOps\n[2]: Latency\n[3]: RThroughput\n"
-             << "[4]: MayLoad\n[5]: MayStore\n[6]: HasSideEffects (U)\n";
+  std::vector<unsigned> paddings = {0, 7, 14, 21, 28, 35};
+  std::vector<std::string>   fields   = {"#uOps", "Latency", "RThroughput",
+    "MayLoad", "MayStore", "HasSideEffects (U)"};
+  std::vector<std::string>   end_fields;
+  unsigned last_padding = 35;
   if (PrintBarriers) {
-    TempStream << "[7]: LoadBarrier\n[8]: StoreBarrier\n";
+    paddings.push_back(last_padding + 7);
+    paddings.push_back(last_padding + 14);
+    last_padding += 14;
+    fields.push_back("LoadBarrier"); fields.push_back("StoreBarrier");
   }
   if (PrintEncodings) {
-    if (PrintBarriers) {
-      TempStream << "[9]: Encoding Size\n";
-      TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    "
-                 << "[9]    Encodings:                    Instructions:\n";
-    } else {
-      TempStream << "[7]: Encoding Size\n";
-      TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    [7]    "
-                 << "Encodings:                    Instructions:\n";
+    paddings.push_back(last_padding + 7);
+    paddings.push_back(last_padding + 14);
+    paddings.push_back(last_padding + 44);
+    last_padding += 44;
+    fields.push_back("Encoding Size");
+    end_fields.push_back("Encodings:");
+    end_fields.push_back("Instructions:");
+  }
+  else {
+    paddings.push_back(last_padding + 7);
+    last_padding += 7;
+    end_fields.push_back("Instructions:");
+  }
+
+  FOS << "\n\nInstruction Info:\n";
+  for (unsigned i = 0; i < fields.size(); i++) {
+    FOS << "[" << i + 1 << "]: " << fields[i] << "\n";
+  }
+  FOS << "\n";
+
+  for (unsigned i = 0; i < paddings.size(); i++) {
+    if (paddings[i] != 0)
+      FOS.PadToColumn(paddings[i]);
+    if (i < fields.size()) {
+      FOS << "[" << i + 1 << "]";
     }
-  } else {
-    if (PrintBarriers) {
-      TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    "
-                 << "Instructions:\n";
-    } else {
-      TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    "
-                 << "Instructions:\n";
+    else {
+      FOS << end_fields[i - fields.size()];
     }
   }
+  FOS << "\n";
 
   for (const auto &[Index, IIVDEntry, Inst] : enumerate(IIVD, Source)) {
-    TempStream << ' ' << IIVDEntry.NumMicroOpcodes << "    ";
-    if (IIVDEntry.NumMicroOpcodes < 10)
-      TempStream << "  ";
-    else if (IIVDEntry.NumMicroOpcodes < 100)
-      TempStream << ' ';
-    TempStream << IIVDEntry.Latency << "   ";
-    if (IIVDEntry.Latency < 10)
-      TempStream << "  ";
-    else if (IIVDEntry.Latency < 100)
-      TempStream << ' ';
+    FOS.PadToColumn(paddings[0]+1);
+    FOS << IIVDEntry.NumMicroOpcodes;
+    FOS.PadToColumn(paddings[1]+1);
+    FOS << IIVDEntry.Latency;
 
+    FOS.PadToColumn(paddings[2]);
     if (IIVDEntry.RThroughput) {
       double RT = *IIVDEntry.RThroughput;
-      TempStream << format("%.2f", RT) << ' ';
-      if (RT < 10.0)
-        TempStream << "  ";
-      else if (RT < 100.0)
-        TempStream << ' ';
+      FOS << format("%.2f", RT);
     } else {
-      TempStream << " -     ";
+      FOS << " -";
     }
-    TempStream << (IIVDEntry.mayLoad ? " *     " : "       ");
-    TempStream << (IIVDEntry.mayStore ? " *     " : "       ");
-    TempStream << (IIVDEntry.hasUnmodeledSideEffects ? " U     " : "       ");
+    FOS.PadToColumn(paddings[3]+1);
+    FOS << (IIVDEntry.mayLoad ? "*" : " ");
+    FOS.PadToColumn(paddings[4]+1);
+    FOS << (IIVDEntry.mayStore ? "*" : " ");
+    FOS.PadToColumn(paddings[5]+1);
+    FOS << (IIVDEntry.hasUnmodeledSideEffects ? "U" : " ");
+    unsigned last_padding_idx = 5;
 
     if (PrintBarriers) {
-      TempStream << (LoweredInsts[Index]->isALoadBarrier() ? " *     "
-                                                           : "       ");
-      TempStream << (LoweredInsts[Index]->isAStoreBarrier() ? " *     "
-                                                            : "       ");
+      FOS.PadToColumn(paddings[last_padding_idx + 1]+1);
+      FOS << (LoweredInsts[Index]->isALoadBarrier() ? "*" : " ");
+      FOS.PadToColumn(paddings[last_padding_idx + 2]+1);
+      FOS << (LoweredInsts[Index]->isAStoreBarrier() ? "*" : " ");
+      last_padding_idx += 2;
     }
 
     if (PrintEncodings) {
       StringRef Encoding(CE.getEncoding(Index));
       unsigned EncodingSize = Encoding.size();
-      TempStream << " " << EncodingSize
-                 << (EncodingSize < 10 ? "     " : "    ");
-      TempStream.flush();
-      formatted_raw_ostream FOS(TempStream);
+      FOS.PadToColumn(paddings[last_padding_idx + 1]+1);
+      FOS << EncodingSize;
+      FOS.PadToColumn(paddings[last_padding_idx + 2]);
       for (unsigned i = 0, e = Encoding.size(); i != e; ++i)
         FOS << format("%02x ", (uint8_t)Encoding[i]);
-      FOS.PadToColumn(30);
-      FOS.flush();
+      last_padding_idx += 2;
     }
-
-    TempStream << printInstructionString(Inst) << '\n';
+    FOS.PadToColumn(paddings[last_padding_idx + 1]);
+    FOS << printInstructionString(Inst) << '\n';
   }
 
-  TempStream.flush();
+  FOS.flush();
   OS << Buffer;
 }
 
@@ -265,7 +278,7 @@ void InstructionInfoView::collectData(
     IIVDEntry.mayStore = MCDesc.mayStore();
     IIVDEntry.hasUnmodeledSideEffects = MCDesc.hasUnmodeledSideEffects();
 
-    if (PrintSchedulingInfo) {
+    if (PrintFullInfo) {
       // Get latency with bypass
       IIVDEntry.Bypass =
           IIVDEntry.Latency - MCSchedModel::getBypassDelayCycles(STI, SCDesc);
@@ -283,7 +296,6 @@ void InstructionInfoView::collectData(
           // Output ReleaseAtCycle between [] if not 1 (default)
           // This is to be able to evaluate throughput.
           // See getReciprocalThroughput in MCSchedule.cpp
-          // TODO: report AcquireAtCycle to check this scheduling info.
           TempStream << sep
                      << format("%s[%d]", MCProc->Name, Index->ReleaseAtCycle);
         } else {

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

@@ -56,7 +56,7 @@ class InstructionInfoView : public InstructionView {
   CodeEmitter &CE;
   bool PrintEncodings;
   bool PrintBarriers;
-  bool PrintSchedulingInfo;
+  bool PrintFullInfo;
   using UniqueInst = std::unique_ptr<Instruction>;
   ArrayRef<UniqueInst> LoweredInsts;
   const InstrumentManager &IM;
@@ -94,13 +94,13 @@ class InstructionInfoView : public InstructionView {
                       bool ShouldPrintEncodings, llvm::ArrayRef<llvm::MCInst> S,
                       llvm::MCInstPrinter &IP,
                       ArrayRef<UniqueInst> LoweredInsts,
-                      bool ShouldPrintBarriers, bool ShouldPrintSchedulingInfo,
+                      bool ShouldPrintBarriers, bool ShouldPrintFullInfo,
                       const InstrumentManager &IM,
                       const InstToInstrumentsT &InstToInstruments)
       : InstructionView(ST, IP, S), MCII(II), CE(C),
         PrintEncodings(ShouldPrintEncodings),
         PrintBarriers(ShouldPrintBarriers),
-        PrintSchedulingInfo(ShouldPrintSchedulingInfo),
+        PrintFullInfo(ShouldPrintFullInfo),
         LoweredInsts(LoweredInsts), IM(IM),
         InstToInstruments(InstToInstruments) {}
 

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

@@ -225,10 +225,51 @@ static cl::opt<unsigned> StoreQueueSize("squeue",
                                         cl::desc("Size of the store queue"),
                                         cl::cat(ToolOptions), cl::init(0));
 
-static cl::opt<bool>
-    PrintInstructionTables("instruction-tables",
-                           cl::desc("Print instruction tables"),
-                           cl::cat(ToolOptions), cl::init(false));
+enum class InstructionTablesType { NONE, NORMAL, FULL };
+
+class InstructionTablesOptionParser :
+  public cl::parser<enum InstructionTablesType> {
+public:
+  explicit InstructionTablesOptionParser(cl::Option &O)
+      : cl::parser<enum InstructionTablesType>(O) {}
+
+  bool parse(cl::Option &O, StringRef ArgName, StringRef Arg,
+	     enum InstructionTablesType &Value) {
+    if (Arg.empty()) {
+      Value = InstructionTablesType::NORMAL;
+      return false;
+    }
+    return cl::parser<enum InstructionTablesType>::parse(O, ArgName, Arg, Value);
+  }
+};
+
+static cl::opt<enum InstructionTablesType, false, InstructionTablesOptionParser>
+    InstructionTablesOption("instruction-tables",
+           cl::desc("Print instruction tables"),
+  	   cl::values(
+	      clEnumValN(InstructionTablesType::NONE, "none",
+			 "Do not print instruction tables"),
+	      clEnumValN(InstructionTablesType::NORMAL, "normal",
+			 "Print instruction tables"),
+	      clEnumValN(InstructionTablesType::FULL, "full",
+			 "Print instruction tables with additional"
+			 " information: bypass latency, LLVM opcode,"
+		         " used resources")),
+           cl::cat(ToolOptions), cl::init(InstructionTablesType::NONE));
+
+bool PrintInstructionTables() {
+  if (InstructionTablesOption == InstructionTablesType::NONE)
+    return false;
+
+  return true;
+}
+
+bool PrintInstructionTables(enum InstructionTablesType ITType) {
+  if (InstructionTablesOption == ITType)
+    return true;
+
+  return false;
+}
 
 static cl::opt<bool> PrintInstructionInfoView(
     "instruction-info",
@@ -259,12 +300,6 @@ static cl::opt<bool> ShowBarriers(
     cl::desc("Print memory barrier information in the instruction info view"),
     cl::cat(ViewOptions), cl::init(false));
 
-static cl::opt<bool>
-    ShowSchedulingInfo("scheduling-info",
-                       cl::desc("Print the instruction scheduling information "
-                                "in the instruction info view"),
-                       cl::cat(ViewOptions), cl::init(false));
-
 static cl::opt<bool> DisableCustomBehaviour(
     "disable-cb",
     cl::desc(
@@ -370,6 +405,8 @@ int main(int argc, char **argv) {
 
   cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions});
 
+  InstructionTablesOption.setValueExpectedFlag(cl::ValueOptional);
+
   // Parse flags and initialize target options.
   cl::ParseCommandLineOptions(argc, argv,
                               "llvm machine code performance analyzer.\n");
@@ -668,9 +705,9 @@ int main(int argc, char **argv) {
     NonEmptyRegions++;
 
     mca::CircularSourceMgr S(LoweredSequence,
-                             PrintInstructionTables ? 1 : Iterations);
+                             PrintInstructionTables() ? 1 : Iterations);
 
-    if (PrintInstructionTables) {
+    if (PrintInstructionTables()) {
       //  Create a pipeline, stages, and a printer.
       auto P = std::make_unique<mca::Pipeline>();
       P->appendStage(std::make_unique<mca::EntryStage>(S));
@@ -686,7 +723,8 @@ int main(int argc, char **argv) {
       if (PrintInstructionInfoView) {
         Printer.addView(std::make_unique<mca::InstructionInfoView>(
             *STI, *MCII, CE, ShowEncoding, Insts, *IP, LoweredSequence,
-            ShowBarriers, ShowSchedulingInfo, *IM, InstToInstruments));
+            ShowBarriers, PrintInstructionTables(InstructionTablesType::FULL),
+	    *IM, InstToInstruments));
       }
 
       Printer.addView(
@@ -764,7 +802,7 @@ int main(int argc, char **argv) {
     if (PrintInstructionInfoView)
       Printer.addView(std::make_unique<mca::InstructionInfoView>(
           *STI, *MCII, CE, ShowEncoding, Insts, *IP, LoweredSequence,
-          ShowBarriers, ShowSchedulingInfo, *IM, InstToInstruments));
+          ShowBarriers, false, *IM, InstToInstruments));
 
     // Fetch custom Views that are to be placed after the InstructionInfoView.
     // Refer to the comment paired with the CB->getStartViews(*IP, Insts); line