[llvm-exegesis] Split AsmTemplate.Name into components.

[courbet]

Summary

AsmTemplate bemoces IntructionBenchmarkKey, which has three components.
This allows retreiving the opcode for analysis.

[gchatelet]

tools/llvm-exegesis/lib/BenchmarkResult.h

49 ↗

(On Diff #146796)

Can you add a std::string info while you're at it?

[courbet]

Add "Info" field to InstructionBenchmark.

llvm/trunk/tools/llvm-exegesis/lib/Analysis.cpp

 //===-- Analysis.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "BenchmarkResult.h"
 #include "Analysis.h"
+#include "BenchmarkResult.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <vector>
 
 namespace exegesis {
 
 static const char kCsvSep = ',';
 
-static void writeCsvEscaped(llvm::raw_ostream& OS, const std::string& S) {
+static void writeCsvEscaped(llvm::raw_ostream &OS, const std::string &S) {
   if (std::find(S.begin(), S.end(), kCsvSep) == S.end()) {
     OS << S;
   } else {
     // Needs escaping.
     OS << '"';
     for (const char C : S) {
       if (C == '"')
         OS << "\"\"";
       else
         OS << C;
     }
     OS << '"';
   }
 }
 
 // Prints a row representing an instruction, along with scheduling info and
 // point coordinates (measurements).
 static void printInstructionRow(const InstructionBenchmark &Point,
                                 const llvm::MCSubtargetInfo &STI,
                                 const size_t ClusterId, llvm::raw_ostream &OS) {
   OS << ClusterId << kCsvSep;
-  writeCsvEscaped(OS, Point.AsmTmpl.Name);
+  writeCsvEscaped(OS, Point.Key.OpcodeName);
+  OS << kCsvSep;
+  writeCsvEscaped(OS, Point.Key.Config);
   // FIXME: Print the sched class once InstructionBenchmark separates key into
   // (mnemonic, mode, opaque).
   for (const auto &Measurement : Point.Measurements) {
     OS << kCsvSep;
     writeCsvEscaped(OS, llvm::formatv("{0:F}", Measurement.Value));
   }
   OS << "\n";
 }
 
 static void printCluster(const std::vector<InstructionBenchmark> &Points,
-                  const llvm::MCSubtargetInfo &STI, const size_t ClusterId,
+                         const llvm::MCSubtargetInfo &STI,
+                         const size_t ClusterId,
                          const InstructionBenchmarkClustering::Cluster &Cluster,
                          llvm::raw_ostream &OS) {
   // Print all points.
   for (const auto &PointId : Cluster.PointIndices) {
     printInstructionRow(Points[PointId], STI, ClusterId, OS);
   }
 }
 
 llvm::Error
 printAnalysisClusters(const InstructionBenchmarkClustering &Clustering,
                       const llvm::MCSubtargetInfo &STI, llvm::raw_ostream &OS) {
   if (Clustering.getPoints().empty())
     return llvm::Error::success();
 
   // Write the header.
-  OS << "cluster_id;key,sched_class";
+  OS << "cluster_id" << kCsvSep << "opcode_name" << kCsvSep << "config"
+     << kCsvSep << "sched_class";
   for (const auto &Measurement : Clustering.getPoints().front().Measurements) {
     OS << kCsvSep;
     writeCsvEscaped(OS, Measurement.Key);
   }
   OS << "\n";
 
   // Write the points.
   for (size_t I = 0, E = Clustering.getValidClusters().size(); I < E; ++I) {
     printCluster(Clustering.getPoints(), STI, I,
                  Clustering.getValidClusters()[I], OS);
     OS << "\n\n";
   }
   return llvm::Error::success();
 }
 
 } // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkResult.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <string>
 #include <vector>
 
 namespace exegesis {
 
-struct AsmTemplate {
-  std::string Name;
+struct InstructionBenchmarkKey {
+  // The LLVM opcode name.
+  std::string OpcodeName;
+  // The benchmark mode.
+  std::string Mode;
+  // 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;
   double Value;
   std::string DebugString;
 };
 
 // The result of an instruction benchmark.
 struct InstructionBenchmark {
-  AsmTemplate AsmTmpl;
+  InstructionBenchmarkKey Key;
   std::string CpuName;
   std::string LLVMTriple;
   int NumRepetitions = 0;
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
+  std::string Info;
 
   static InstructionBenchmark readYamlOrDie(llvm::StringRef Filename);
   static std::vector<InstructionBenchmark> readYamlsOrDie(llvm::StringRef Filename);
 
   // Unfortunately this function is non const because of YAML traits.
   void writeYamlOrDie(const llvm::StringRef Filename);
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkResult.cpp

template <> struct MappingTraits<exegesis::BenchmarkMeasure> {
   static void mapping(IO &Io, exegesis::BenchmarkMeasure &Obj) {
     Io.mapRequired("key", Obj.Key);
     Io.mapRequired("value", Obj.Value);
     Io.mapOptional("debug_string", Obj.DebugString);
   }
   static const bool flow = true;
 };
 
-template <> struct MappingTraits<exegesis::AsmTemplate> {
-  static void mapping(IO &Io, exegesis::AsmTemplate &Obj) {
-    Io.mapRequired("name", Obj.Name);
+template <> struct MappingTraits<exegesis::InstructionBenchmarkKey> {
+  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj) {
+    Io.mapRequired("opcode_name", Obj.OpcodeName);
+    Io.mapRequired("mode", Obj.Mode);
+    Io.mapOptional("config", Obj.Config);
   }
 };
 
 template <> struct MappingTraits<exegesis::InstructionBenchmark> {
   static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj) {
-    Io.mapRequired("asm_template", Obj.AsmTmpl);
+    Io.mapRequired("key", Obj.Key);
     Io.mapRequired("cpu_name", Obj.CpuName);
     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
     Io.mapRequired("num_repetitions", Obj.NumRepetitions);
     Io.mapRequired("measurements", Obj.Measurements);
     Io.mapRequired("error", Obj.Error);
+    Io.mapOptional("info", Obj.Info);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(exegesis::InstructionBenchmark)
 

llvm/trunk/tools/llvm-exegesis/lib/BenchmarkRunner.cpp

 BenchmarkRunner::~BenchmarkRunner() = default;
 
 InstructionBenchmark
 BenchmarkRunner::run(const LLVMState &State, const unsigned Opcode,
                      unsigned NumRepetitions,
                      const InstructionFilter &Filter) const {
   InstructionBenchmark InstrBenchmark;
 
-  InstrBenchmark.AsmTmpl.Name =
-      llvm::Twine(getDisplayName())
-          .concat(" ")
-          .concat(State.getInstrInfo().getName(Opcode))
-          .str();
+  InstrBenchmark.Key.OpcodeName = State.getInstrInfo().getName(Opcode);
+  InstrBenchmark.Key.Mode = getDisplayName();
   InstrBenchmark.CpuName = State.getCpuName();
   InstrBenchmark.LLVMTriple = State.getTriple();
   InstrBenchmark.NumRepetitions = NumRepetitions;
 
   // Ignore instructions that we cannot run.
   if (State.getInstrInfo().get(Opcode).isPseudo()) {
     InstrBenchmark.Error = "Unsupported opcode: isPseudo";
     return InstrBenchmark;

llvm/trunk/unittests/tools/llvm-exegesis/BenchmarkResultTest.cpp

bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
   return std::tie(A.Key, A.Value) == std::tie(B.Key, B.Value);
 }
 
 namespace {
 
 TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   InstructionBenchmark ToDisk;
 
-  ToDisk.AsmTmpl.Name = "name";
+  ToDisk.Key.OpcodeName = "name";
+  ToDisk.Key.Mode = "mode";
+  ToDisk.Key.Config = "config";
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, "debug a"});
   ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, ""});
   ToDisk.Error = "error";
+  ToDisk.Info = "info";
 
   llvm::SmallString<64> Filename;
   std::error_code EC;
   EC = llvm::sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(Filename, "data.yaml");
 
   ToDisk.writeYamlOrDie(Filename);
 
   {
     // One-element version.
     const auto FromDisk = InstructionBenchmark::readYamlOrDie(Filename);
 
-    EXPECT_EQ(FromDisk.AsmTmpl.Name, ToDisk.AsmTmpl.Name);
+    EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
+    EXPECT_EQ(FromDisk.Key.Mode, ToDisk.Key.Mode);
+    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     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 = InstructionBenchmark::readYamlsOrDie(Filename);
     ASSERT_EQ(FromDiskVector.size(), size_t{1});
     const auto FromDisk = FromDiskVector[0];
-    EXPECT_EQ(FromDisk.AsmTmpl.Name, ToDisk.AsmTmpl.Name);
+    EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
+    EXPECT_EQ(FromDisk.Key.Mode, ToDisk.Key.Mode);
+    EXPECT_EQ(FromDisk.Key.Config, ToDisk.Key.Config);
     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);
   }
 }
 
 } // namespace
 } // namespace exegesis