[llvm-exegesis] move Mode from Key to BenchmarResult.

[gchatelet]

Summary

Moves the Mode field out of the Key. The existing yaml benchmark results can be fixed with the following script:

shell
#!/bin/bash
readonly FILE=$1
readonly MODE=latency # Change to uops to fix a uops benchmark.
cat $FILE | \
  sed "/^\ \+mode:\ \+$MODE$/d" | \
  sed "/^cpu_name.*$/i mode:            $MODE"

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

 bool Analysis::SchedClassCluster::measurementsMatch(
     const llvm::MCSubtargetInfo &STI, const SchedClass &SC,
     const InstructionBenchmarkClustering &Clustering) const {
   const size_t NumMeasurements = Representative.size();
   std::vector<BenchmarkMeasure> ClusterCenterPoint(NumMeasurements);
   std::vector<BenchmarkMeasure> SchedClassPoint(NumMeasurements);
   // Latency case.
   assert(!Clustering.getPoints().empty());
-  const InstructionBenchmarkKey::ModeE Mode =
-      Clustering.getPoints()[0].Key.Mode;
-  if (Mode == InstructionBenchmarkKey::Latency) {
+  const InstructionBenchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
+  if (Mode == InstructionBenchmark::Latency) {
     if (NumMeasurements != 1) {
       llvm::errs()
           << "invalid number of measurements in latency mode: expected 1, got "
           << NumMeasurements << "\n";
       return false;
     }
     // Find the latency.
     SchedClassPoint[0].Value = 0.0;
     for (unsigned I = 0; I < SC.SCDesc.NumWriteLatencyEntries; ++I) {
       const llvm::MCWriteLatencyEntry *const WLE =
           STI.getWriteLatencyEntry(&SC.SCDesc, I);
       SchedClassPoint[0].Value =
           std::max<double>(SchedClassPoint[0].Value, WLE->Cycles);
     }
     ClusterCenterPoint[0].Value = Representative[0].avg();
-  } else if (Mode == InstructionBenchmarkKey::Uops) {
+  } else if (Mode == InstructionBenchmark::Uops) {
     for (int I = 0, E = Representative.size(); I < E; ++I) {
       // Find the pressure on ProcResIdx `Key`.
       uint16_t ProcResIdx = 0;
       if (!llvm::to_integer(Representative[I].key(), ProcResIdx, 10)) {
         llvm::errs() << "expected ProcResIdx key, got "
                      << Representative[I].key() << "\n";
         return false;
       }

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

 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;
-  enum ModeE { Unknown, Latency, Uops };
-  ModeE 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 {
   InstructionBenchmarkKey Key;
+  enum ModeE { Unknown, Latency, Uops };
+  ModeE Mode;
   std::string CpuName;
   std::string LLVMTriple;
   int NumRepetitions = 0;
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
   std::string Info;
 
   // Read functions.

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

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 ScalarEnumerationTraits<exegesis::InstructionBenchmarkKey::ModeE> {
+struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
   static void enumeration(IO &Io,
-                          exegesis::InstructionBenchmarkKey::ModeE &Value) {
-    Io.enumCase(Value, "", exegesis::InstructionBenchmarkKey::Unknown);
-    Io.enumCase(Value, "latency", exegesis::InstructionBenchmarkKey::Latency);
-    Io.enumCase(Value, "uops", exegesis::InstructionBenchmarkKey::Uops);
+                          exegesis::InstructionBenchmark::ModeE &Value) {
+    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("mode", Obj.Mode);
     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);
     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);
   }

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

InstructionBenchmark run(unsigned Opcode, const InstructionFilter &Filter,
                            unsigned NumRepetitions);
 
 protected:
   const LLVMState &State;
   const llvm::MCInstrInfo &MCInstrInfo;
   const llvm::MCRegisterInfo &MCRegisterInfo;
 
 private:
-  virtual InstructionBenchmarkKey::ModeE getMode() const = 0;
+  virtual InstructionBenchmark::ModeE getMode() const = 0;
 
   virtual llvm::Expected<std::vector<llvm::MCInst>>
   createSnippet(RegisterAliasingTrackerCache &RATC, unsigned Opcode,
                 llvm::raw_ostream &Debug) const = 0;
 
   virtual std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const = 0;

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

 BenchmarkRunner::~BenchmarkRunner() = default;
 
 InstructionBenchmark BenchmarkRunner::run(unsigned Opcode,
                                           const InstructionFilter &Filter,
                                           unsigned NumRepetitions) {
   InstructionBenchmark InstrBenchmark;
 
   InstrBenchmark.Key.OpcodeName = State.getInstrInfo().getName(Opcode);
-  InstrBenchmark.Key.Mode = getMode();
+  InstrBenchmark.Mode = getMode();
   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/tools/llvm-exegesis/lib/Latency.h

 namespace exegesis {
 
 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
   using BenchmarkRunner::BenchmarkRunner;
   ~LatencyBenchmarkRunner() override;
 
 private:
-  InstructionBenchmarkKey::ModeE getMode() const override;
+  InstructionBenchmark::ModeE getMode() const override;
 
   llvm::Expected<std::vector<llvm::MCInst>>
   createSnippet(RegisterAliasingTrackerCache &RATC, unsigned OpcodeIndex,
                 llvm::raw_ostream &Info) const override;
 
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const override;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

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

 
 static llvm::Error makeError(llvm::Twine Msg) {
   return llvm::make_error<llvm::StringError>(Msg,
                                              llvm::inconvertibleErrorCode());
 }
 
 LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
 
-InstructionBenchmarkKey::ModeE LatencyBenchmarkRunner::getMode() const {
-  return InstructionBenchmarkKey::Latency;
+InstructionBenchmark::ModeE LatencyBenchmarkRunner::getMode() const {
+  return InstructionBenchmark::Latency;
 }
 
 llvm::Expected<std::vector<llvm::MCInst>>
 LatencyBenchmarkRunner::createSnippet(RegisterAliasingTrackerCache &RATC,
                                       unsigned Opcode,
                                       llvm::raw_ostream &Info) const {
   std::vector<llvm::MCInst> Snippet;
   const llvm::MCInstrDesc &MCInstrDesc = MCInstrInfo.get(Opcode);

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

 namespace exegesis {
 
 class UopsBenchmarkRunner : public BenchmarkRunner {
 public:
   using BenchmarkRunner::BenchmarkRunner;
   ~UopsBenchmarkRunner() override;
 
 private:
-  InstructionBenchmarkKey::ModeE getMode() const override;
+  InstructionBenchmark::ModeE getMode() const override;
 
   llvm::Expected<std::vector<llvm::MCInst>>
   createSnippet(RegisterAliasingTrackerCache &RATC, unsigned Opcode,
                 llvm::raw_ostream &Info) const override;
 
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const override;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_UOPS_H

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

 
 static llvm::Error makeError(llvm::Twine Msg) {
   return llvm::make_error<llvm::StringError>(Msg,
                                              llvm::inconvertibleErrorCode());
 }
 
 UopsBenchmarkRunner::~UopsBenchmarkRunner() = default;
 
-InstructionBenchmarkKey::ModeE UopsBenchmarkRunner::getMode() const {
-  return InstructionBenchmarkKey::Uops;
+InstructionBenchmark::ModeE UopsBenchmarkRunner::getMode() const {
+  return InstructionBenchmark::Uops;
 }
 
 llvm::Expected<std::vector<llvm::MCInst>>
 UopsBenchmarkRunner::createSnippet(RegisterAliasingTrackerCache &RATC,
                                    unsigned Opcode,
                                    llvm::raw_ostream &Info) const {
   std::vector<llvm::MCInst> Snippet;
   const llvm::MCInstrDesc &MCInstrDesc = MCInstrInfo.get(Opcode);

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

 TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   BenchmarkResultContext Ctx;
   Ctx.addInstrEntry(kInstrId, kInstrName);
 
   InstructionBenchmark ToDisk;
 
   ToDisk.Key.OpcodeName = "name";
   ToDisk.Key.Instructions.push_back(llvm::MCInstBuilder(kInstrId));
-  ToDisk.Key.Mode = InstructionBenchmarkKey::Latency;
   ToDisk.Key.Config = "config";
+  ToDisk.Mode = InstructionBenchmark::Latency;
   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(Ctx, Filename);
 
   {
     // One-element version.
     const auto FromDisk = InstructionBenchmark::readYamlOrDie(Ctx, Filename);
 
     EXPECT_EQ(FromDisk.Key.OpcodeName, ToDisk.Key.OpcodeName);
     EXPECT_THAT(FromDisk.Key.Instructions,
                 Pointwise(EqMCInst(), ToDisk.Key.Instructions));
-    EXPECT_EQ(FromDisk.Key.Mode, ToDisk.Key.Mode);
     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 =
         InstructionBenchmark::readYamlsOrDie(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.Mode, ToDisk.Key.Mode);
     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);
   }
 }