[llvm-exegesis] Use BenchmarkResult::Instructions instead of OpcodeName

[courbet]

Summary

Get rid of OpcodeName.

To remove the opcode name from an old file:

cat old_file | sed '/opcode_name.*/d'

[courbet]

fix comment

[gchatelet]

tools/llvm-exegesis/lib/Analysis.cpp

194

Unneeded braces.

[courbet]

address review comments

[courbet]

Thanks.

tools/llvm-exegesis/lib/Analysis.cpp

 #include <vector>
 
 namespace exegesis {
 
 static const char kCsvSep = ',';
 
 namespace {
 
-enum EscapeTag { kEscapeCsv, kEscapeHtml };
+enum EscapeTag { kEscapeCsv, kEscapeHtml, kEscapeHtmlString };
 
 template <EscapeTag Tag>
 void writeEscaped(llvm::raw_ostream &OS, const llvm::StringRef S);
 
 template <>
 void writeEscaped<kEscapeCsv>(llvm::raw_ostream &OS, const llvm::StringRef S) {
   if (std::find(S.begin(), S.end(), kCsvSep) == S.end()) {
     OS << S;
else if (C == '>')
       OS << "&gt;";
     else if (C == '&')
       OS << "&amp;";
     else
       OS << C;
   }
 }
 
+template <>
+void writeEscaped<kEscapeHtmlString>(llvm::raw_ostream &OS, const llvm::StringRef S) {
+  for (const char C : S) {
+    if (C == '"')
+      OS << "\\\"";
+    else
+      OS << C;
+  }
+}
+
 } // namespace
 
 template <EscapeTag Tag>
 static void
 writeClusterId(llvm::raw_ostream &OS,
                const InstructionBenchmarkClustering::ClusterId &CID) {
   if (CID.isNoise())
     writeEscaped<Tag>(OS, "[noise]");
   else if (CID.isError())
     writeEscaped<Tag>(OS, "[error]");
   else
     OS << CID.getId();
 }
 
 template <EscapeTag Tag>
 static void writeMeasurementValue(llvm::raw_ostream &OS, const double Value) {
   writeEscaped<Tag>(OS, llvm::formatv("{0:F}", Value).str());
 }
 
+template <EscapeTag Tag>
+static void writeSnippet(llvm::raw_ostream &OS,
+                         const std::vector<llvm::MCInst> &Instructions,
+                         const llvm::MCInstrInfo &InstrInfo,
+                         const char* Separator) {
+  // FIXME: Print operands.
+  llvm::SmallVector<llvm::StringRef, 3> Opcodes;
+  for (const llvm::MCInst &Instr : Instructions) {
+    Opcodes.push_back(InstrInfo.getName(Instr.getOpcode()));
+  }
+  writeEscaped<Tag>(OS, llvm::join(Opcodes, Separator));
+}
+
 // Prints a row representing an instruction, along with scheduling info and
 // point coordinates (measurements).
 void Analysis::printInstructionRowCsv(const size_t PointId,
                                       llvm::raw_ostream &OS) const {
   const InstructionBenchmark &Point = Clustering_.getPoints()[PointId];
   writeClusterId<kEscapeCsv>(OS, Clustering_.getClusterIdForPoint(PointId));
   OS << kCsvSep;
-  writeEscaped<kEscapeCsv>(OS, Point.Key.OpcodeName);
+  writeSnippet<kEscapeCsv>(OS, Point.Key.Instructions, *InstrInfo_, "; ");
   OS << kCsvSep;
   writeEscaped<kEscapeCsv>(OS, Point.Key.Config);
   OS << kCsvSep;
-  const auto OpcodeIt = MnemonicToOpcode_.find(Point.Key.OpcodeName);
-  if (OpcodeIt != MnemonicToOpcode_.end()) {
-    const unsigned SchedClassId =
-        InstrInfo_->get(OpcodeIt->second).getSchedClass();
+  assert(!Point.Key.Instructions.empty());
+  // FIXME: Resolve variant classes.
+      InstrInfo_->get(Point.Key.Instructions[0].getOpcode()).getSchedClass();
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-    const auto &SchedModel = SubtargetInfo_->getSchedModel();
-    const llvm::MCSchedClassDesc *const SCDesc =
-        SchedModel.getSchedClassDesc(SchedClassId);
-    writeEscaped<kEscapeCsv>(OS, SCDesc->Name);
 #else
-    OS << SchedClassId;
 #endif
-  }
-  // FIXME: Print the sched class once InstructionBenchmark separates key into
-  // (mnemonic, mode, opaque).
   for (const auto &Measurement : Point.Measurements) {
     OS << kCsvSep;
     writeMeasurementValue<kEscapeCsv>(OS, Measurement.Value);
   }
   OS << "\n";
 }
 
 Analysis::Analysis(const llvm::Target &Target,
                    const InstructionBenchmarkClustering &Clustering)
     : Clustering_(Clustering) {
   if (Clustering.getPoints().empty())
     return;
 
   InstrInfo_.reset(Target.createMCInstrInfo());
   const InstructionBenchmark &FirstPoint = Clustering.getPoints().front();
   SubtargetInfo_.reset(Target.createMCSubtargetInfo(FirstPoint.LLVMTriple,
                                                     FirstPoint.CpuName, ""));
-
-  // Build an index of mnemonic->opcode.
-  for (int I = 0, E = InstrInfo_->getNumOpcodes(); I < E; ++I)
-    MnemonicToOpcode_.emplace(InstrInfo_->getName(I), I);
 }
 
 template <>
 llvm::Error
 Analysis::run<Analysis::PrintClusters>(llvm::raw_ostream &OS) const {
   if (Clustering_.getPoints().empty())
     return llvm::Error::success();
 

 std::unordered_map<unsigned, std::vector<size_t>>
 Analysis::makePointsPerSchedClass() const {
   std::unordered_map<unsigned, std::vector<size_t>> PointsPerSchedClass;
   const auto &Points = Clustering_.getPoints();
   for (size_t PointId = 0, E = Points.size(); PointId < E; ++PointId) {
     const InstructionBenchmark &Point = Points[PointId];
     if (!Point.Error.empty())
       continue;
-    const auto OpcodeIt = MnemonicToOpcode_.find(Point.Key.OpcodeName);
-    if (OpcodeIt == MnemonicToOpcode_.end())
-      continue;
-    const unsigned SchedClassId =
-        InstrInfo_->get(OpcodeIt->second).getSchedClass();
-    PointsPerSchedClass[SchedClassId].push_back(PointId);
+    assert(!Point.Key.Instructions.empty());
+    const auto Opcode = Point.Key.Instructions[0].getOpcode();
+    // FIXME: Resolve variant classes.
+    PointsPerSchedClass[InstrInfo_->get(Opcode).getSchedClass()].push_back(
+        PointId);
   }
   return PointsPerSchedClass;
 }
 
+// Uops repeat the same opcode over again. Just show this opcode and show the
+// whole snippet only on hover.
+static void writeUopsSnippetHtml(llvm::raw_ostream &OS,
+                                 const std::vector<llvm::MCInst> &Instructions,
+                                 const llvm::MCInstrInfo &InstrInfo) {
+  if (Instructions.empty())
+    return;
+  writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instructions[0].getOpcode()));
+  if (Instructions.size() > 1)
+    OS << " (x" << Instructions.size() << ")";
+}
+
+// Latency tries to find a serial path. Just show the opcode path and show the
+// whole snippet only on hover.
+static void writeLatencySnippetHtml(llvm::raw_ostream &OS,
+                                 const std::vector<llvm::MCInst> &Instructions,
+                                 const llvm::MCInstrInfo &InstrInfo) {
+  bool First = true;
+  for (const llvm::MCInst &Instr : Instructions) {
+    if (First)
+      First = false;
+    else
+      OS << " &rarr; ";
+    writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instr.getOpcode()));
+  }
+}
+
 void Analysis::printSchedClassClustersHtml(
     const std::vector<SchedClassCluster> &Clusters, const SchedClass &SC,
     llvm::raw_ostream &OS) const {
   const auto &Points = Clustering_.getPoints();
   OS << "<table class=\"sched-class-clusters\">";
   OS << "<tr><th>ClusterId</th><th>Opcode/Config</th>";
   assert(!Clusters.empty());
   for (const auto &Measurement :
OS << "<tr class=\""
        << (Cluster.measurementsMatch(*SubtargetInfo_, SC, Clustering_)
                ? "good-cluster"
                : "bad-cluster")
        << "\"><td>";
     writeClusterId<kEscapeHtml>(OS, Cluster.id());
     OS << "</td><td><ul>";
     for (const size_t PointId : Cluster.getPointIds()) {
       const auto &Point = Points[PointId];
-      OS << "<li><span class=\"mono\">";
-      writeEscaped<kEscapeHtml>(OS, Point.Key.OpcodeName);
+      OS << "<li><span class=\"mono\" title=\"";
+      writeSnippet<kEscapeHtmlString>(OS, Point.Key.Instructions, *InstrInfo_, "\n");
+      OS << "\">";
+      switch (Point.Mode) {
+        case InstructionBenchmark::Latency:
+          writeLatencySnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
+          break;
+        case InstructionBenchmark::Uops:
+          writeUopsSnippetHtml(OS, Point.Key.Instructions, *InstrInfo_);
+          break;
+        default:
+          llvm_unreachable("invalid mode");
+      }
       OS << "</span> <span class=\"mono\">";
       writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
       OS << "</span></li>";
     }
     OS << "</ul></td>";
     for (const auto &Stats : Cluster.getRepresentative()) {
       OS << "<td class=\"measurement\">";
       writeMeasurementValue<kEscapeHtml>(OS, Stats.avg());

tools/llvm-exegesis/lib/BenchmarkResult.h

 #include <vector>
 
 namespace exegesis {
 
 struct BenchmarkResultContext; // Forward declaration.
 
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
-  std::string OpcodeName; // FIXME: Deprecated, use Instructions below.
   std::vector<llvm::MCInst> Instructions;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
   std::string Key;

tools/llvm-exegesis/lib/BenchmarkResult.cpp

static void enumeration(IO &Io,
     Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
     Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
     Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
   }
 };
 
 template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
   static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
-    Io.mapRequired("opcode_name", Obj.OpcodeName);
-    Io.mapOptional("instructions", Obj.Instructions);
+    Io.mapRequired("instructions", Obj.Instructions);
     Io.mapOptional("config", Obj.Config);
   }
 };
 
 template <> struct MappingTraits<exegesis::InstructionBenchmark> {
   static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
     Io.mapRequired("mode", Obj.Mode);
     Io.mapRequired("key", Obj.Key);

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

for (const BenchmarkConfiguration &Conf : ConfigurationOrError.get())
     InstrBenchmarks.push_back(runOne(Conf, Opcode, NumRepetitions));
   return InstrBenchmarks;
 }
 
 InstructionBenchmark
 BenchmarkRunner::runOne(const BenchmarkConfiguration &Configuration,
                         unsigned Opcode, unsigned NumRepetitions) const {
   InstructionBenchmark InstrBenchmark;
-  InstrBenchmark.Key.OpcodeName = State.getInstrInfo().getName(Opcode);
   InstrBenchmark.Mode = getMode();
   InstrBenchmark.CpuName = State.getCpuName();
   InstrBenchmark.LLVMTriple = State.getTriple();
   InstrBenchmark.NumRepetitions = NumRepetitions;
   InstrBenchmark.Info = Configuration.Info;
 
   const std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
   if (Snippet.empty()) {

unittests/tools/llvm-exegesis/BenchmarkResultTest.cpp

TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   llvm::ExitOnError ExitOnErr;
   BenchmarkResultContext Ctx;
   Ctx.addInstrEntry(kInstrId, kInstrName);
   Ctx.addRegEntry(kReg1Id, kReg1Name);
   Ctx.addRegEntry(kReg2Id, kReg2Name);
 
   InstructionBenchmark ToDisk;
 
-  ToDisk.Key.OpcodeName = "name";
   ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(kInstrId)
                                         .addReg(kReg1Id)
                                         .addReg(kReg2Id)
                                         .addImm(123)
                                         .addFPImm(0.5));
   ToDisk.Key.Config = "config";
   ToDisk.Mode = InstructionBenchmark::Latency;
   ToDisk.CpuName = "cpu_name";
TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   llvm::sys::path::append(Filename, "data.yaml");
   ExitOnErr(ToDisk.writeYaml(Ctx, Filename));
 
   {
     // One-element version.
     const auto FromDisk =
         ExitOnErr(InstructionBenchmark::readYaml(Ctx, Filename));
 
-    EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
     EXPECT_THAT(FromDisk.Key.Instructions,
                 Pointwise(EqMCInst(), ToDisk.Key.Instructions));
     EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
     EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
     EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
     EXPECT_THAT(FromDisk.Error, ToDisk.Error);
     EXPECT_EQ(FromDisk.Info, ToDisk.Info);
   }
   {
     // Vector version.
     const auto FromDiskVector =
         ExitOnErr(InstructionBenchmark::readYamls(Ctx, Filename));
     ASSERT_EQ(FromDiskVector.size(), size_t{1});
     const auto FromDisk = FromDiskVector[0];
-    EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
     EXPECT_THAT(FromDisk.Key.Instructions,
                 Pointwise(EqMCInst(), ToDisk.Key.Instructions));
     EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     EXPECT_EQ(FromDisk.Mode, ToDisk.Mode);
     EXPECT_EQ(FromDisk.CpuName, ToDisk.CpuName);
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
     EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);