[llvm-exegesis][NFC] Use an enum instead of a string for benchmark mode.

[courbet]

Summary

YAML encoding is backwards-compatible.

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 std::string &Mode = Clustering.getPoints()[0].Key.Mode;
-  if (Mode == "latency") { // FIXME: use an enum.
+  const InstructionBenchmarkKey::ModeE Mode =
+      Clustering.getPoints()[0].Key.Mode;
+  if (Mode == InstructionBenchmarkKey::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 == "uops") {
+  } else if (Mode == InstructionBenchmarkKey::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;
       }
       const auto ProcResPressureIt =
           std::find_if(SC.IdealizedProcResPressure.begin(),
                        SC.IdealizedProcResPressure.end(),
                        [ProcResIdx](const std::pair<uint16_t, float> &WPR) {
                          return WPR.first == ProcResIdx;
                        });
       SchedClassPoint[I].Value =
           ProcResPressureIt == SC.IdealizedProcResPressure.end()
               ? 0.0
               : ProcResPressureIt->second;
       ClusterCenterPoint[I].Value = Representative[I].avg();
     }
   } else {
-    llvm::errs() << "unimplemented measurement matching for mode ''" << Mode
-                 << "''\n";
+    llvm::errs() << "unimplemented measurement matching for mode " << Mode
+                 << "\n";
     return false;
   }
   return Clustering.isNeighbour(ClusterCenterPoint, SchedClassPoint);
 }
 
 void Analysis::printSchedClassDescHtml(const SchedClass &SC,
                                        llvm::raw_ostream &OS) const {
   OS << "<table class=\"sched-class-desc\">";

tools/llvm-exegesis/lib/BenchmarkResult.h

 #include <string>
 #include <vector>
 
 namespace exegesis {
 
 struct InstructionBenchmarkKey {
   // The LLVM opcode name.
   std::string OpcodeName;
-  // The benchmark mode.
-  std::string Mode;
+  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;

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 ScalarEnumerationTraits<exegesis::InstructionBenchmarkKey::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);
+  }
+};
+
 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);
   }
 };
 

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 const char *getDisplayName() const = 0;
+  virtual InstructionBenchmarkKey::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;

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 = getDisplayName();
+  InstrBenchmark.Key.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;

tools/llvm-exegesis/lib/Latency.h

 namespace exegesis {
 
 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
   using BenchmarkRunner::BenchmarkRunner;
   ~LatencyBenchmarkRunner() override;
 
 private:
-  const char *getDisplayName() const override;
+  InstructionBenchmarkKey::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

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;
 
-const char *LatencyBenchmarkRunner::getDisplayName() const { return "latency"; }
+InstructionBenchmarkKey::ModeE LatencyBenchmarkRunner::getMode() const {
+  return InstructionBenchmarkKey::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);
   const Instruction ThisInstruction(MCInstrDesc, RATC);

tools/llvm-exegesis/lib/Uops.h

 namespace exegesis {
 
 class UopsBenchmarkRunner : public BenchmarkRunner {
 public:
   using BenchmarkRunner::BenchmarkRunner;
   ~UopsBenchmarkRunner() override;
 
 private:
-  const char *getDisplayName() const override;
+  InstructionBenchmarkKey::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

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;
 
-const char *UopsBenchmarkRunner::getDisplayName() const { return "uops"; }
+InstructionBenchmarkKey::ModeE UopsBenchmarkRunner::getMode() const {
+  return InstructionBenchmarkKey::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);
   const Instruction Instruction(MCInstrDesc, RATC);

unittests/tools/llvm-exegesis/BenchmarkResultTest.cpp

 }
 
 namespace {
 
 TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   InstructionBenchmark ToDisk;
 
   ToDisk.Key.OpcodeName = "name";
-  ToDisk.Key.Mode = "mode";
+  ToDisk.Key.Mode = InstructionBenchmarkKey::Latency;
   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";