[llvm-exegesis] Refactor InstructionBenchmark to Benchmark

[aidengrossman]

Summary

When llvm-exegesis was first introduced, it only supported benchmarking
individual instructions, hence the name for the data structure storing
the data corresponding to a benchmark being called InstructionBenchmark
made sense. However, now that benchmarking arbitrary snippets is
supported, InstructionBenchmark doesn't correspond to a single
instruction. This patch refactors InstructionBenchmark to be called
Benchmark to clean up this little bit of technical debt.

llvm/tools/llvm-exegesis/lib/Analysis.h

 
 namespace llvm {
 namespace exegesis {
 
 // A helper class to analyze benchmark results for a target.
 class Analysis {
 public:
   Analysis(const LLVMState &State,
-           const InstructionBenchmarkClustering &Clustering,
+           const BenchmarkClustering &Clustering,
            double AnalysisInconsistencyEpsilon,
            bool AnalysisDisplayUnstableOpcodes);
 
   // Prints a csv of instructions for each cluster.
   struct PrintClusters {};
   // Find potential errors in the scheduling information given measurements.
   struct PrintSchedClassInconsistencies {};
 
   template <typename Pass> Error run(raw_ostream &OS) const;
 
 private:
-  using ClusterId = InstructionBenchmarkClustering::ClusterId;
+  using ClusterId = BenchmarkClustering::ClusterId;
 
   // Represents the intersection of a sched class and a cluster.
   class SchedClassCluster {
   public:
-    const InstructionBenchmarkClustering::ClusterId &id() const {
+    const BenchmarkClustering::ClusterId &id() const {
       return ClusterId;
     }
 
     const std::vector<size_t> &getPointIds() const { return PointIds; }
 
     void addPoint(size_t PointId,
-                  const InstructionBenchmarkClustering &Clustering);
+                  const BenchmarkClustering &Clustering);
 
     // Return the cluster centroid.
     const SchedClassClusterCentroid &getCentroid() const { return Centroid; }
 
     // Returns true if the cluster representative measurements match that of SC.
     bool
     measurementsMatch(const MCSubtargetInfo &STI, const ResolvedSchedClass &SC,
-                      const InstructionBenchmarkClustering &Clustering,
+                      const BenchmarkClustering &Clustering,
                       const double AnalysisInconsistencyEpsilonSquared_) const;
 
   private:
-    InstructionBenchmarkClustering::ClusterId ClusterId;
+    BenchmarkClustering::ClusterId ClusterId;
     std::vector<size_t> PointIds;
     // Measurement stats for the points in the SchedClassCluster.
     SchedClassClusterCentroid Centroid;
   };
 
   void printInstructionRowCsv(size_t PointId, raw_ostream &OS) const;
 
-  void printClusterRawHtml(const InstructionBenchmarkClustering::ClusterId &Id,
+  void printClusterRawHtml(const BenchmarkClustering::ClusterId &Id,
                            StringRef display_name, llvm::raw_ostream &OS) const;
 
-  void printPointHtml(const InstructionBenchmark &Point,
+  void printPointHtml(const Benchmark &Point,
                       llvm::raw_ostream &OS) const;
 
   void
   printSchedClassClustersHtml(const std::vector<SchedClassCluster> &Clusters,
                               const ResolvedSchedClass &SC,
                               raw_ostream &OS) const;
   void printSchedClassDescHtml(const ResolvedSchedClass &SC,
                                raw_ostream &OS) const;
private:
 
   // Builds a list of ResolvedSchedClassAndPoints.
   std::vector<ResolvedSchedClassAndPoints> makePointsPerSchedClass() const;
 
   template <typename EscapeTag, EscapeTag Tag>
   void writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
                     const char *Separator) const;
 
-  const InstructionBenchmarkClustering &Clustering_;
+  const BenchmarkClustering &Clustering_;
   const LLVMState &State_;
   std::unique_ptr<MCContext> Context_;
   std::unique_ptr<MCAsmInfo> AsmInfo_;
   std::unique_ptr<MCInstPrinter> InstPrinter_;
   std::unique_ptr<MCDisassembler> Disasm_;
   const double AnalysisInconsistencyEpsilonSquared_;
   const bool AnalysisDisplayUnstableOpcodes_;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

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

void writeEscaped<kEscapeHtmlString>(raw_ostream &OS, const StringRef S) {
   }
 }
 
 } // namespace
 
 template <EscapeTag Tag>
 static void
 writeClusterId(raw_ostream &OS,
-               const InstructionBenchmarkClustering::ClusterId &CID) {
+               const BenchmarkClustering::ClusterId &CID) {
   if (CID.isNoise())
     writeEscaped<Tag>(OS, "[noise]");
   else if (CID.isError())
     writeEscaped<Tag>(OS, "[error]");
   else
     OS << CID.getId();
 }
 
void Analysis::writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
   }
   writeEscaped<Tag>(OS, join(Lines, Separator));
 }
 
 // Prints a row representing an instruction, along with scheduling info and
 // point coordinates (measurements).
 void Analysis::printInstructionRowCsv(const size_t PointId,
                                       raw_ostream &OS) const {
-  const InstructionBenchmark &Point = Clustering_.getPoints()[PointId];
+  const Benchmark &Point = Clustering_.getPoints()[PointId];
   writeClusterId<kEscapeCsv>(OS, Clustering_.getClusterIdForPoint(PointId));
   OS << kCsvSep;
   writeSnippet<EscapeTag, kEscapeCsv>(OS, Point.AssembledSnippet, "; ");
   OS << kCsvSep;
   writeEscaped<kEscapeCsv>(OS, Point.Key.Config);
   OS << kCsvSep;
   assert(!Point.Key.Instructions.empty());
   const MCInst &MCI = Point.keyInstruction();
#endif
   for (const auto &Measurement : Point.Measurements) {
     OS << kCsvSep;
     writeMeasurementValue<kEscapeCsv>(OS, Measurement.PerInstructionValue);
   }
   OS << "\n";
 }
 
 Analysis::Analysis(const LLVMState &State,
-                   const InstructionBenchmarkClustering &Clustering,
+                   const BenchmarkClustering &Clustering,
                    double AnalysisInconsistencyEpsilon,
                    bool AnalysisDisplayUnstableOpcodes)
     : Clustering_(Clustering), State_(State),
       AnalysisInconsistencyEpsilonSquared_(AnalysisInconsistencyEpsilon *
                                            AnalysisInconsistencyEpsilon),
       AnalysisDisplayUnstableOpcodes_(AnalysisDisplayUnstableOpcodes) {
   if (Clustering.getPoints().empty())
     return;

 
 std::vector<Analysis::ResolvedSchedClassAndPoints>
 Analysis::makePointsPerSchedClass() const {
   std::vector<ResolvedSchedClassAndPoints> Entries;
   // Maps SchedClassIds to index in result.
   std::unordered_map<unsigned, size_t> SchedClassIdToIndex;
   const auto &Points = Clustering_.getPoints();
   for (size_t PointId = 0, E = Points.size(); PointId < E; ++PointId) {
-    const InstructionBenchmark &Point = Points[PointId];
+    const Benchmark &Point = Points[PointId];
     if (!Point.Error.empty())
       continue;
     assert(!Point.Key.Instructions.empty());
     // FIXME: we should be using the tuple of classes for instructions in the
     // snippet as key.
     const MCInst &MCI = Point.keyInstruction();
     unsigned SchedClassId;
     bool WasVariant;
for (const MCInst &Instr : Instructions) {
     if (First)
       First = false;
     else
       OS << " &rarr; ";
     writeEscaped<kEscapeHtml>(OS, InstrInfo.getName(Instr.getOpcode()));
   }
 }
 
-void Analysis::printPointHtml(const InstructionBenchmark &Point,
+void Analysis::printPointHtml(const Benchmark &Point,
                               llvm::raw_ostream &OS) const {
   OS << "<li><span class=\"mono\" title=\"";
   writeSnippet<EscapeTag, kEscapeHtmlString>(OS, Point.AssembledSnippet, "\n");
   OS << "\">";
   switch (Point.Mode) {
-  case InstructionBenchmark::Latency:
+  case Benchmark::Latency:
     writeLatencySnippetHtml(OS, Point.Key.Instructions, State_.getInstrInfo());
     break;
-  case InstructionBenchmark::Uops:
-  case InstructionBenchmark::InverseThroughput:
+  case Benchmark::Uops:
+  case Benchmark::InverseThroughput:
     writeParallelSnippetHtml(OS, Point.Key.Instructions, State_.getInstrInfo());
     break;
   default:
     llvm_unreachable("invalid mode");
   }
   OS << "</span> <span class=\"mono\">";
   writeEscaped<kEscapeHtml>(OS, Point.Key.Config);
   OS << "</span></li>";
for (const auto &Stats : Cluster.getCentroid().getStats()) {
       OS << "]</span></td>";
     }
     OS << "</tr>";
   }
   OS << "</table>";
 }
 
 void Analysis::SchedClassCluster::addPoint(
-    size_t PointId, const InstructionBenchmarkClustering &Clustering) {
+    size_t PointId, const BenchmarkClustering &Clustering) {
   PointIds.push_back(PointId);
   const auto &Point = Clustering.getPoints()[PointId];
   if (ClusterId.isUndef())
     ClusterId = Clustering.getClusterIdForPoint(PointId);
   assert(ClusterId == Clustering.getClusterIdForPoint(PointId));
 
   Centroid.addPoint(Point.Measurements);
 }
 
 bool Analysis::SchedClassCluster::measurementsMatch(
     const MCSubtargetInfo &STI, const ResolvedSchedClass &RSC,
-    const InstructionBenchmarkClustering &Clustering,
+    const BenchmarkClustering &Clustering,
     const double AnalysisInconsistencyEpsilonSquared_) const {
   assert(!Clustering.getPoints().empty());
-  const InstructionBenchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
+  const Benchmark::ModeE Mode = Clustering.getPoints()[0].Mode;
 
   if (!Centroid.validate(Mode))
     return false;
 
   const std::vector<BenchmarkMeasure> ClusterCenterPoint =
       Centroid.getAsPoint();
 
   const std::vector<BenchmarkMeasure> SchedClassPoint =
if (RSC.SCDesc->isValid()) {
     OS << "</tr>";
   } else {
     OS << "<tr><td>&#10005;</td><td></td><td></td></tr>";
   }
   OS << "</table>";
 }
 
 void Analysis::printClusterRawHtml(
-    const InstructionBenchmarkClustering::ClusterId &Id, StringRef display_name,
+    const BenchmarkClustering::ClusterId &Id, StringRef display_name,
     llvm::raw_ostream &OS) const {
   const auto &Points = Clustering_.getPoints();
   const auto &Cluster = Clustering_.getCluster(Id);
   if (Cluster.PointIndices.empty())
     return;
 
   OS << "<div class=\"inconsistency\"><p>" << display_name << " Cluster ("
      << Cluster.PointIndices.size() << " points)</p>";
#endif
     OS << "</span> contains instructions whose performance characteristics do"
           " not match that of LLVM:</p>";
     printSchedClassClustersHtml(SchedClassClusters, RSCAndPoints.RSC, OS);
     OS << "<p>llvm SchedModel data:</p>";
     printSchedClassDescHtml(RSCAndPoints.RSC, OS);
     OS << "</div>";
   }
 
-  printClusterRawHtml(InstructionBenchmarkClustering::ClusterId::noise(),
+  printClusterRawHtml(BenchmarkClustering::ClusterId::noise(),
                       "[noise]", OS);
 
   OS << "</body></html>";
   return Error::success();
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/BenchmarkCode.h

 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace exegesis {
 
 // A collection of instructions that are to be assembled, executed and measured.
 struct BenchmarkCode {
-  InstructionBenchmarkKey Key;
+  BenchmarkKey Key;
 
   // We also need to provide the registers that are live on entry for the
   // assembler to generate proper prologue/epilogue.
   std::vector<unsigned> LiveIns;
 
   // Informations about how this configuration was built.
   std::string Info;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKCODE_H

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

 
 enum class BenchmarkPhaseSelectorE {
   PrepareSnippet,
   PrepareAndAssembleSnippet,
   AssembleMeasuredCode,
   Measure,
 };
 
-enum class InstructionBenchmarkFilter { All, RegOnly, WithMem };
+enum class BenchmarkFilter { All, RegOnly, WithMem };
 
-struct InstructionBenchmarkKey {
+struct BenchmarkKey {
   // The LLVM opcode name.
   std::vector<MCInst> Instructions;
   // The initial values of the registers.
   std::vector<RegisterValue> RegisterInitialValues;
   // An opaque configuration, that can be used to separate several benchmarks of
   // the same instruction under different configurations.
   std::string Config;
 };
 
 struct BenchmarkMeasure {
   // A helper to create an unscaled BenchmarkMeasure.
   static BenchmarkMeasure Create(std::string Key, double Value) {
     return {Key, Value, Value};
   }
   std::string Key;
   // This is the per-instruction value, i.e. measured quantity scaled per
   // instruction.
   double PerInstructionValue;
   // This is the per-snippet value, i.e. measured quantity for one repetition of
   // the whole snippet.
   double PerSnippetValue;
 };
 
 // The result of an instruction benchmark.
-struct InstructionBenchmark {
-  InstructionBenchmarkKey Key;
+struct Benchmark {
+  BenchmarkKey Key;
   enum ModeE { Unknown, Latency, Uops, InverseThroughput };
   ModeE Mode;
   std::string CpuName;
   std::string LLVMTriple;
   // Which instruction is being benchmarked here?
   const MCInst &keyInstruction() const { return Key.Instructions[0]; }
   // The number of instructions inside the repeated snippet. For example, if a
   // snippet of 3 instructions is repeated 4 times, this is 12.
   unsigned NumRepetitions = 0;
   enum RepetitionModeE { Duplicate, Loop, AggregateMin };
   // Note that measurements are per instruction.
   std::vector<BenchmarkMeasure> Measurements;
   std::string Error;
   std::string Info;
   std::vector<uint8_t> AssembledSnippet;
   // How to aggregate measurements.
   enum ResultAggregationModeE { Min, Max, Mean, MinVariance };
 
-  InstructionBenchmark() = default;
-  InstructionBenchmark(InstructionBenchmark &&) = default;
+  Benchmark() = default;
+  Benchmark(Benchmark &&) = default;
 
-  InstructionBenchmark(const InstructionBenchmark &) = delete;
-  InstructionBenchmark &operator=(const InstructionBenchmark &) = delete;
-  InstructionBenchmark &operator=(InstructionBenchmark &&) = delete;
+  Benchmark(const Benchmark &) = delete;
+  Benchmark &operator=(const Benchmark &) = delete;
+  Benchmark &operator=(Benchmark &&) = delete;
 
   // Read functions.
-  static Expected<InstructionBenchmark> readYaml(const LLVMState &State,
+  static Expected<Benchmark> readYaml(const LLVMState &State,
                                                  MemoryBufferRef Buffer);
 
-  static Expected<std::vector<InstructionBenchmark>>
+  static Expected<std::vector<Benchmark>>
   readYamls(const LLVMState &State, MemoryBufferRef Buffer);
 
   // Given a set of serialized instruction benchmarks, returns the set of
   // triples and CPUs that appear in the list of benchmarks.
   struct TripleAndCpu {
     std::string LLVMTriple;
     std::string CpuName;
     bool operator<(const TripleAndCpu &O) const {

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

static void mapping(IO &Io, exegesis::BenchmarkMeasure &Obj) {
     }
     Io.mapRequired("value", Obj.PerInstructionValue);
     Io.mapOptional("per_snippet_value", Obj.PerSnippetValue);
   }
   static const bool flow = true;
 };
 
 template <>
-struct ScalarEnumerationTraits<exegesis::InstructionBenchmark::ModeE> {
+struct ScalarEnumerationTraits<exegesis::Benchmark::ModeE> {
   static void enumeration(IO &Io,
-                          exegesis::InstructionBenchmark::ModeE &Value) {
-    Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown);
-    Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency);
-    Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops);
+                          exegesis::Benchmark::ModeE &Value) {
+    Io.enumCase(Value, "", exegesis::Benchmark::Unknown);
+    Io.enumCase(Value, "latency", exegesis::Benchmark::Latency);
+    Io.enumCase(Value, "uops", exegesis::Benchmark::Uops);
     Io.enumCase(Value, "inverse_throughput",
-                exegesis::InstructionBenchmark::InverseThroughput);
+                exegesis::Benchmark::InverseThroughput);
   }
 };
 
 // std::vector<exegesis::RegisterValue> will be rendered as a list.
 template <> struct SequenceElementTraits<exegesis::RegisterValue> {
   static const bool flow = false;
 };
 
template <> struct ScalarTraits<exegesis::RegisterValue> {
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
 
   static const bool flow = true;
 };
 
 template <>
-struct MappingContextTraits<exegesis::InstructionBenchmarkKey, YamlContext> {
-  static void mapping(IO &Io, exegesis::InstructionBenchmarkKey &Obj,
+struct MappingContextTraits<exegesis::BenchmarkKey, YamlContext> {
+  static void mapping(IO &Io, exegesis::BenchmarkKey &Obj,
                       YamlContext &Context) {
     Io.setContext(&Context);
     Io.mapRequired("instructions", Obj.Instructions);
     Io.mapOptional("config", Obj.Config);
     Io.mapRequired("register_initial_values", Obj.RegisterInitialValues);
   }
 };
 
 template <>
-struct MappingContextTraits<exegesis::InstructionBenchmark, YamlContext> {
+struct MappingContextTraits<exegesis::Benchmark, YamlContext> {
   struct NormalizedBinary {
     NormalizedBinary(IO &io) {}
     NormalizedBinary(IO &, std::vector<uint8_t> &Data) : Binary(Data) {}
     std::vector<uint8_t> denormalize(IO &) {
       std::vector<uint8_t> Data;
       std::string Str;
       raw_string_ostream OSS(Str);
       Binary.writeAsBinary(OSS);
       OSS.flush();
       Data.assign(Str.begin(), Str.end());
       return Data;
     }
 
     BinaryRef Binary;
   };
 
-  static void mapping(IO &Io, exegesis::InstructionBenchmark &Obj,
+  static void mapping(IO &Io, exegesis::Benchmark &Obj,
                       YamlContext &Context) {
     Io.mapRequired("mode", Obj.Mode);
     Io.mapRequired("key", Obj.Key, Context);
     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);
     // AssembledSnippet
     MappingNormalization<NormalizedBinary, std::vector<uint8_t>> BinaryString(
         Io, Obj.AssembledSnippet);
     Io.mapOptional("assembled_snippet", BinaryString->Binary);
   }
 };
 
-template <> struct MappingTraits<exegesis::InstructionBenchmark::TripleAndCpu> {
+template <> struct MappingTraits<exegesis::Benchmark::TripleAndCpu> {
   static void mapping(IO &Io,
-                      exegesis::InstructionBenchmark::TripleAndCpu &Obj) {
+                      exegesis::Benchmark::TripleAndCpu &Obj) {
     assert(!Io.outputting() && "can only read TripleAndCpu");
     // Read triple.
     Io.mapRequired("llvm_triple", Obj.LLVMTriple);
     Io.mapRequired("cpu_name", Obj.CpuName);
     // Drop everything else.
   }
 };
 
 } // namespace yaml
 
 namespace exegesis {
 
-Expected<std::set<InstructionBenchmark::TripleAndCpu>>
-InstructionBenchmark::readTriplesAndCpusFromYamls(MemoryBufferRef Buffer) {
+Expected<std::set<Benchmark::TripleAndCpu>>
+Benchmark::readTriplesAndCpusFromYamls(MemoryBufferRef Buffer) {
   // We're only mapping a field, drop other fields and silence the corresponding
   // warnings.
   yaml::Input Yin(
       Buffer, nullptr, +[](const SMDiagnostic &, void *Context) {});
   Yin.setAllowUnknownKeys(true);
   std::set<TripleAndCpu> Result;
   yaml::EmptyContext Context;
   while (Yin.setCurrentDocument()) {
     TripleAndCpu TC;
     yamlize(Yin, TC, /*unused*/ true, Context);
     if (Yin.error())
       return errorCodeToError(Yin.error());
     Result.insert(TC);
     Yin.nextDocument();
   }
   return Result;
 }
 
-Expected<InstructionBenchmark>
-InstructionBenchmark::readYaml(const LLVMState &State, MemoryBufferRef Buffer) {
+Expected<Benchmark>
+Benchmark::readYaml(const LLVMState &State, MemoryBufferRef Buffer) {
   yaml::Input Yin(Buffer);
   YamlContext Context(State);
-  InstructionBenchmark Benchmark;
+  Benchmark Benchmark;
   if (Yin.setCurrentDocument())
     yaml::yamlize(Yin, Benchmark, /*unused*/ true, Context);
   if (!Context.getLastError().empty())
     return make_error<Failure>(Context.getLastError());
   return std::move(Benchmark);
 }
 
-Expected<std::vector<InstructionBenchmark>>
-InstructionBenchmark::readYamls(const LLVMState &State,
+Expected<std::vector<Benchmark>>
+Benchmark::readYamls(const LLVMState &State,
                                 MemoryBufferRef Buffer) {
   yaml::Input Yin(Buffer);
   YamlContext Context(State);
-  std::vector<InstructionBenchmark> Benchmarks;
+  std::vector<Benchmark> Benchmarks;
   while (Yin.setCurrentDocument()) {
     Benchmarks.emplace_back();
     yamlize(Yin, Benchmarks.back(), /*unused*/ true, Context);
     if (Yin.error())
       return errorCodeToError(Yin.error());
     if (!Context.getLastError().empty())
       return make_error<Failure>(Context.getLastError());
     Yin.nextDocument();
   }
   return std::move(Benchmarks);
 }
 
-Error InstructionBenchmark::writeYamlTo(const LLVMState &State,
+Error Benchmark::writeYamlTo(const LLVMState &State,
                                         raw_ostream &OS) {
   auto Cleanup = make_scope_exit([&] { OS.flush(); });
   yaml::Output Yout(OS, nullptr /*Ctx*/, 200 /*WrapColumn*/);
   YamlContext Context(State);
   Yout.beginDocuments();
   yaml::yamlize(Yout, *this, /*unused*/ true, Context);
   if (!Context.getLastError().empty())
     return make_error<Failure>(Context.getLastError());
   Yout.endDocuments();
   return Error::success();
 }
 
-Error InstructionBenchmark::readYamlFrom(const LLVMState &State,
+Error Benchmark::readYamlFrom(const LLVMState &State,
                                          StringRef InputContent) {
   yaml::Input Yin(InputContent);
   YamlContext Context(State);
   if (Yin.setCurrentDocument())
     yaml::yamlize(Yin, *this, /*unused*/ true, Context);
   if (!Context.getLastError().empty())
     return make_error<Failure>(Context.getLastError());
   return Error::success();

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

 
 namespace llvm {
 namespace exegesis {
 
 // Common code for all benchmark modes.
 class BenchmarkRunner {
 public:
   explicit BenchmarkRunner(const LLVMState &State,
-                           InstructionBenchmark::ModeE Mode,
+                           Benchmark::ModeE Mode,
                            BenchmarkPhaseSelectorE BenchmarkPhaseSelector);
 
   virtual ~BenchmarkRunner();
 
   class RunnableConfiguration {
     friend class BenchmarkRunner;
 
   public:
     ~RunnableConfiguration() = default;
     RunnableConfiguration(RunnableConfiguration &&) = default;
 
     RunnableConfiguration(const RunnableConfiguration &) = delete;
     RunnableConfiguration &operator=(RunnableConfiguration &&) = delete;
     RunnableConfiguration &operator=(const RunnableConfiguration &) = delete;
 
   private:
     RunnableConfiguration() = default;
 
-    InstructionBenchmark InstrBenchmark;
+    Benchmark InstrBenchmark;
     object::OwningBinary<object::ObjectFile> ObjectFile;
   };
 
   Expected<RunnableConfiguration>
   getRunnableConfiguration(const BenchmarkCode &Configuration,
                            unsigned NumRepetitions, unsigned LoopUnrollFactor,
                            const SnippetRepetitor &Repetitor) const;
 
-  Expected<InstructionBenchmark> runConfiguration(RunnableConfiguration &&RC,
+  Expected<Benchmark> runConfiguration(RunnableConfiguration &&RC,
                                                   bool DumpObjectToDisk) const;
 
   // Scratch space to run instructions that touch memory.
   struct ScratchSpace {
     static constexpr const size_t kAlignment = 1024;
     static constexpr const size_t kSize = 1 << 20; // 1MB.
     ScratchSpace()
         : UnalignedPtr(std::make_unique<char[]>(kSize + kAlignment)),
public:
     virtual Expected<int64_t> runAndMeasure(const char *Counters) const = 0;
 
     virtual Expected<llvm::SmallVector<int64_t, 4>>
     runAndSample(const char *Counters) const = 0;
   };
 
 protected:
   const LLVMState &State;
-  const InstructionBenchmark::ModeE Mode;
+  const Benchmark::ModeE Mode;
   const BenchmarkPhaseSelectorE BenchmarkPhaseSelector;
 
 private:
   virtual Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const = 0;
 
   Expected<SmallString<0>> assembleSnippet(const BenchmarkCode &BC,
                                            const SnippetRepetitor &Repetitor,

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

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 
 namespace llvm {
 namespace exegesis {
 
 BenchmarkRunner::BenchmarkRunner(const LLVMState &State,
-                                 InstructionBenchmark::ModeE Mode,
+                                 Benchmark::ModeE Mode,
                                  BenchmarkPhaseSelectorE BenchmarkPhaseSelector)
     : State(State), Mode(Mode), BenchmarkPhaseSelector(BenchmarkPhaseSelector),
       Scratch(std::make_unique<ScratchSpace>()) {}
 
 BenchmarkRunner::~BenchmarkRunner() = default;
 
 namespace {
 class FunctionExecutorImpl : public BenchmarkRunner::FunctionExecutor {

 }
 
 Expected<BenchmarkRunner::RunnableConfiguration>
 BenchmarkRunner::getRunnableConfiguration(
     const BenchmarkCode &BC, unsigned NumRepetitions, unsigned LoopBodySize,
     const SnippetRepetitor &Repetitor) const {
   RunnableConfiguration RC;
 
-  InstructionBenchmark &InstrBenchmark = RC.InstrBenchmark;
+  Benchmark &InstrBenchmark = RC.InstrBenchmark;
   InstrBenchmark.Mode = Mode;
   InstrBenchmark.CpuName = std::string(State.getTargetMachine().getTargetCPU());
   InstrBenchmark.LLVMTriple =
       State.getTargetMachine().getTargetTriple().normalize();
   InstrBenchmark.NumRepetitions = NumRepetitions;
   InstrBenchmark.Info = BC.Info;
 
   const std::vector<MCInst> &Instructions = BC.Key.Instructions;
if (BenchmarkPhaseSelector > BenchmarkPhaseSelectorE::PrepareAndAssembleSnippet) {
     if (Error E = Snippet.takeError())
       return std::move(E);
     RC.ObjectFile = getObjectFromBuffer(*Snippet);
   }
 
   return std::move(RC);
 }
 
-Expected<InstructionBenchmark>
+Expected<Benchmark>
 BenchmarkRunner::runConfiguration(RunnableConfiguration &&RC,
                                   bool DumpObjectToDisk) const {
-  InstructionBenchmark &InstrBenchmark = RC.InstrBenchmark;
+  Benchmark &InstrBenchmark = RC.InstrBenchmark;
   object::OwningBinary<object::ObjectFile> &ObjectFile = RC.ObjectFile;
 
   if (DumpObjectToDisk &&
       BenchmarkPhaseSelector > BenchmarkPhaseSelectorE::PrepareAndAssembleSnippet) {
     auto ObjectFilePath = writeObjectFile(ObjectFile.getBinary()->getData());
     if (Error E = ObjectFilePath.takeError()) {
       InstrBenchmark.Error = toString(std::move(E));
       return std::move(InstrBenchmark);

llvm/tools/llvm-exegesis/lib/Clustering.h

 #include "BenchmarkResult.h"
 #include "llvm/Support/Error.h"
 #include <limits>
 #include <vector>
 
 namespace llvm {
 namespace exegesis {
 
-class InstructionBenchmarkClustering {
+class BenchmarkClustering {
 public:
   enum ModeE { Dbscan, Naive };
 
   // Clusters `Points` using DBSCAN with the given parameters. See the cc file
   // for more explanations on the algorithm.
-  static Expected<InstructionBenchmarkClustering>
-  create(const std::vector<InstructionBenchmark> &Points, ModeE Mode,
+  static Expected<BenchmarkClustering>
+  create(const std::vector<Benchmark> &Points, ModeE Mode,
          size_t DbscanMinPts, double AnalysisClusteringEpsilon,
          const MCSubtargetInfo *SubtargetInfo = nullptr,
          const MCInstrInfo *InstrInfo = nullptr);
 
   class ClusterId {
   public:
     static ClusterId noise() { return ClusterId(kNoise); }
     static ClusterId error() { return ClusterId(kError); }
struct Cluster {
     // Indices of benchmarks within the cluster.
     std::vector<int> PointIndices;
   };
 
   ClusterId getClusterIdForPoint(size_t P) const {
     return ClusterIdForPoint_[P];
   }
 
-  const std::vector<InstructionBenchmark> &getPoints() const { return Points_; }
+  const std::vector<Benchmark> &getPoints() const { return Points_; }
 
   const Cluster &getCluster(ClusterId Id) const {
     assert(!Id.isUndef() && "unlabeled cluster");
     if (Id.isNoise()) {
       return NoiseCluster_;
     }
     if (Id.isError()) {
       return ErrorCluster_;
bool isNeighbour(const std::vector<BenchmarkMeasure> &P,
     for (size_t I = 0, E = P.size(); I < E; ++I) {
       const auto Diff = P[I].PerInstructionValue - Q[I].PerInstructionValue;
       DistanceSquared += Diff * Diff;
     }
     return DistanceSquared <= EpsilonSquared_;
   }
 
 private:
-  InstructionBenchmarkClustering(
-      const std::vector<InstructionBenchmark> &Points,
+  BenchmarkClustering(
+      const std::vector<Benchmark> &Points,
       double AnalysisClusteringEpsilonSquared);
 
   Error validateAndSetup();
 
   void clusterizeDbScan(size_t MinPts);
   void clusterizeNaive(const MCSubtargetInfo &SubtargetInfo,
                        const MCInstrInfo &InstrInfo);
 
   // Stabilization is only needed if dbscan was used to clusterize.
   void stabilize(unsigned NumOpcodes);
 
   void rangeQuery(size_t Q, std::vector<size_t> &Scratchpad) const;
 
   bool areAllNeighbours(ArrayRef<size_t> Pts) const;
 
-  const std::vector<InstructionBenchmark> &Points_;
+  const std::vector<Benchmark> &Points_;
   const double AnalysisClusteringEpsilonSquared_;
 
   int NumDimensions_ = 0;
   // ClusterForPoint_[P] is the cluster id for Points[P].
   std::vector<ClusterId> ClusterIdForPoint_;
   std::vector<Cluster> Clusters_;
   Cluster NoiseCluster_;
   Cluster ErrorCluster_;
 };
 
 class SchedClassClusterCentroid {
 public:
   const std::vector<PerInstructionStats> &getStats() const {
     return Representative;
   }
 
   std::vector<BenchmarkMeasure> getAsPoint() const;
 
   void addPoint(ArrayRef<BenchmarkMeasure> Point);
 
-  bool validate(InstructionBenchmark::ModeE Mode) const;
+  bool validate(Benchmark::ModeE Mode) const;
 
 private:
   // Measurement stats for the points in the SchedClassCluster.
   std::vector<PerInstructionStats> Representative;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

llvm/tools/llvm-exegesis/lib/Clustering.cpp

 // We've used DBSCAN here because it's simple to implement. This is a pretty
 // straightforward and inefficient implementation of the pseudocode in [2].
 //
 // [1] https://en.wikipedia.org/wiki/DBSCAN
 // [2] https://en.wikipedia.org/wiki/OPTICS_algorithm
 
 // Finds the points at distance less than sqrt(EpsilonSquared) of Q (not
 // including Q).
-void InstructionBenchmarkClustering::rangeQuery(
+void BenchmarkClustering::rangeQuery(
     const size_t Q, std::vector<size_t> &Neighbors) const {
   Neighbors.clear();
   Neighbors.reserve(Points_.size() - 1); // The Q itself isn't a neighbor.
   const auto &QMeasurements = Points_[Q].Measurements;
   for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     if (P == Q)
       continue;
     const auto &PMeasurements = Points_[P].Measurements;
     if (PMeasurements.empty()) // Error point.
       continue;
     if (isNeighbour(PMeasurements, QMeasurements,
                     AnalysisClusteringEpsilonSquared_)) {
       Neighbors.push_back(P);
     }
   }
 }
 
 // Given a set of points, checks that all the points are neighbours
 // up to AnalysisClusteringEpsilon. This is O(2*N).
-bool InstructionBenchmarkClustering::areAllNeighbours(
+bool BenchmarkClustering::areAllNeighbours(
     ArrayRef<size_t> Pts) const {
   // First, get the centroid of this group of points. This is O(N).
   SchedClassClusterCentroid G;
   for (size_t P : Pts) {
     assert(P < Points_.size());
     ArrayRef<BenchmarkMeasure> Measurements = Points_[P].Measurements;
     if (Measurements.empty()) // Error point.
       continue;
return all_of(
         const auto &PMeasurements = Points_[P].Measurements;
         if (PMeasurements.empty()) // Error point.
           return true;             // Pretend that error point is a neighbour.
         return isNeighbour(PMeasurements, Centroid,
                            AnalysisClusteringEpsilonHalvedSquared);
       });
 }
 
-InstructionBenchmarkClustering::InstructionBenchmarkClustering(
-    const std::vector<InstructionBenchmark> &Points,
+BenchmarkClustering::BenchmarkClustering(
+    const std::vector<Benchmark> &Points,
     const double AnalysisClusteringEpsilonSquared)
     : Points_(Points),
       AnalysisClusteringEpsilonSquared_(AnalysisClusteringEpsilonSquared),
       NoiseCluster_(ClusterId::noise()), ErrorCluster_(ClusterId::error()) {}
 
-Error InstructionBenchmarkClustering::validateAndSetup() {
+Error BenchmarkClustering::validateAndSetup() {
   ClusterIdForPoint_.resize(Points_.size());
   // Mark erroneous measurements out.
   // All points must have the same number of dimensions, in the same order.
   const std::vector<BenchmarkMeasure> *LastMeasurement = nullptr;
   for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     const auto &Point = Points_[P];
     if (!Point.Error.empty()) {
       ClusterIdForPoint_[P] = ClusterId::error();
for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     LastMeasurement = CurMeasurement;
   }
   if (LastMeasurement) {
     NumDimensions_ = LastMeasurement->size();
   }
   return Error::success();
 }
 
-void InstructionBenchmarkClustering::clusterizeDbScan(const size_t MinPts) {
+void BenchmarkClustering::clusterizeDbScan(const size_t MinPts) {
   std::vector<size_t> Neighbors; // Persistent buffer to avoid allocs.
   for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     if (!ClusterIdForPoint_[P].isUndef())
       continue; // Previously processed in inner loop.
     rangeQuery(P, Neighbors);
     if (Neighbors.size() + 1 < MinPts) { // Density check.
       // The region around P is not dense enough to create a new cluster, mark
       // as noise for now.
void BenchmarkClustering::clusterizeDbScan(const size_t MinPts) {
   // Add noisy points to noise cluster.
   for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
     if (ClusterIdForPoint_[P].isNoise()) {
       NoiseCluster_.PointIndices.push_back(P);
     }
   }
 }
 
-void InstructionBenchmarkClustering::clusterizeNaive(
+void BenchmarkClustering::clusterizeNaive(
     const MCSubtargetInfo &SubtargetInfo, const MCInstrInfo &InstrInfo) {
   // Given an instruction Opcode, which sched class id's are represented,
   // and which are the benchmarks for each sched class?
   std::vector<SmallMapVector<unsigned, SmallVector<size_t, 1>, 1>>
       OpcodeToSchedClassesToPoints;
   const unsigned NumOpcodes = InstrInfo.getNumOpcodes();
   OpcodeToSchedClassesToPoints.resize(NumOpcodes);
   size_t NumClusters = 0;
   for (size_t P = 0, NumPoints = Points_.size(); P < NumPoints; ++P) {
-    const InstructionBenchmark &Point = Points_[P];
+    const Benchmark &Point = Points_[P];
     const MCInst &MCI = Point.keyInstruction();
     unsigned SchedClassId;
     std::tie(SchedClassId, std::ignore) =
         ResolvedSchedClass::resolveSchedClassId(SubtargetInfo, InstrInfo, MCI);
     const unsigned Opcode = MCI.getOpcode();
     assert(Opcode < NumOpcodes && "NumOpcodes is incorrect (too small)");
     auto &Points = OpcodeToSchedClassesToPoints[Opcode][SchedClassId];
     if (Points.empty()) // If we previously have not seen any points of

 // Now, this is all not entirely deterministic. Some instructions have variable
 // characteristics, depending on their arguments. And thus, if we do several
 // benchmarks of the same instruction Opcode, we may end up with *different*
 // performance characteristics measurements. And when we then do clustering,
 // these several benchmarks of the same instruction Opcode may end up being
 // clustered into *different* clusters. This is not great for further analysis.
 // We shall find every opcode with benchmarks not in just one cluster, and move
 // *all* the benchmarks of said Opcode into one new unstable cluster per Opcode.
-void InstructionBenchmarkClustering::stabilize(unsigned NumOpcodes) {
+void BenchmarkClustering::stabilize(unsigned NumOpcodes) {
   // Given an instruction Opcode and Config, in which clusters do benchmarks of
   // this instruction lie? Normally, they all should be in the same cluster.
   struct OpcodeAndConfig {
-    explicit OpcodeAndConfig(const InstructionBenchmark &IB)
+    explicit OpcodeAndConfig(const Benchmark &IB)
         : Opcode(IB.keyInstruction().getOpcode()), Config(&IB.Key.Config) {}
     unsigned Opcode;
     const std::string *Config;
 
     auto Tie() const -> auto { return std::tie(Opcode, *Config); }
 
     bool operator<(const OpcodeAndConfig &O) const { return Tie() < O.Tie(); }
     bool operator!=(const OpcodeAndConfig &O) const { return Tie() != O.Tie(); }
for (const auto &OpcodeConfigToClusterID : OpcodeConfigToClusterIDs) {
     assert(UnstableCluster.PointIndices.size() > 1 &&
            "New unstable cluster should end up with more than one point.");
     assert(UnstableCluster.PointIndices.size() >= ClusterIDs.size() &&
            "New unstable cluster should end up with no less points than there "
            "was clusters");
   }
 }
 
-Expected<InstructionBenchmarkClustering> InstructionBenchmarkClustering::create(
-    const std::vector<InstructionBenchmark> &Points, const ModeE Mode,
+Expected<BenchmarkClustering> BenchmarkClustering::create(
+    const std::vector<Benchmark> &Points, const ModeE Mode,
     const size_t DbscanMinPts, const double AnalysisClusteringEpsilon,
     const MCSubtargetInfo *SubtargetInfo, const MCInstrInfo *InstrInfo) {
-  InstructionBenchmarkClustering Clustering(
+  BenchmarkClustering Clustering(
       Points, AnalysisClusteringEpsilon * AnalysisClusteringEpsilon);
   if (auto Error = Clustering.validateAndSetup()) {
     return std::move(Error);
   }
   if (Clustering.ErrorCluster_.PointIndices.size() == Points.size()) {
     return Clustering; // Nothing to cluster.
   }
 

 std::vector<BenchmarkMeasure> SchedClassClusterCentroid::getAsPoint() const {
   std::vector<BenchmarkMeasure> ClusterCenterPoint(Representative.size());
   for (auto I : zip(ClusterCenterPoint, Representative))
     std::get<0>(I).PerInstructionValue = std::get<1>(I).avg();
   return ClusterCenterPoint;
 }
 
 bool SchedClassClusterCentroid::validate(
-    InstructionBenchmark::ModeE Mode) const {
+    Benchmark::ModeE Mode) const {
   size_t NumMeasurements = Representative.size();
   switch (Mode) {
-  case InstructionBenchmark::Latency:
+  case Benchmark::Latency:
     if (NumMeasurements != 1) {
       errs()
           << "invalid number of measurements in latency mode: expected 1, got "
           << NumMeasurements << "\n";
       return false;
     }
     break;
-  case InstructionBenchmark::Uops:
+  case Benchmark::Uops:
     // Can have many measurements.
     break;
-  case InstructionBenchmark::InverseThroughput:
+  case Benchmark::InverseThroughput:
     if (NumMeasurements != 1) {
       errs() << "invalid number of measurements in inverse throughput "
                 "mode: expected 1, got "
              << NumMeasurements << "\n";
       return false;
     }
     break;
   default:

llvm/tools/llvm-exegesis/lib/CodeTemplate.h

struct CodeTemplate {
   CodeTemplate() = default;
 
   CodeTemplate(CodeTemplate &&);            // default
   CodeTemplate &operator=(CodeTemplate &&); // default
 
   CodeTemplate clone() const;
 
   ExecutionMode Execution = ExecutionMode::UNKNOWN;
-  // See InstructionBenchmarkKey.::Config.
+  // See BenchmarkKey.::Config.
   std::string Config;
   // Some information about how this template has been created.
   std::string Info;
   // The list of the instructions for this template.
   std::vector<InstructionTemplate> Instructions;
   // If the template uses the provided scratch memory, the register in which
   // the pointer to this memory is passed in to the function.
   unsigned ScratchSpacePointerInReg = 0;

llvm/tools/llvm-exegesis/lib/LatencyBenchmarkRunner.h

 #include "BenchmarkRunner.h"
 
 namespace llvm {
 namespace exegesis {
 
 class LatencyBenchmarkRunner : public BenchmarkRunner {
 public:
   LatencyBenchmarkRunner(
-      const LLVMState &State, InstructionBenchmark::ModeE Mode,
+      const LLVMState &State, Benchmark::ModeE Mode,
       BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-      InstructionBenchmark::ResultAggregationModeE ResultAggMode);
+      Benchmark::ResultAggregationModeE ResultAggMode);
   ~LatencyBenchmarkRunner() override;
 
 private:
   Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const override;
 
-  InstructionBenchmark::ResultAggregationModeE ResultAggMode;
+  Benchmark::ResultAggregationModeE ResultAggMode;
 };
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

llvm/tools/llvm-exegesis/lib/LatencyBenchmarkRunner.cpp

 #include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cmath>
 
 namespace llvm {
 namespace exegesis {
 
 LatencyBenchmarkRunner::LatencyBenchmarkRunner(
-    const LLVMState &State, InstructionBenchmark::ModeE Mode,
+    const LLVMState &State, Benchmark::ModeE Mode,
     BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-    InstructionBenchmark::ResultAggregationModeE ResultAgg)
+    Benchmark::ResultAggregationModeE ResultAgg)
     : BenchmarkRunner(State, Mode, BenchmarkPhaseSelector) {
-  assert((Mode == InstructionBenchmark::Latency ||
-          Mode == InstructionBenchmark::InverseThroughput) &&
+  assert((Mode == Benchmark::Latency ||
+          Mode == Benchmark::InverseThroughput) &&
          "invalid mode");
   ResultAggMode = ResultAgg;
 }
 
 LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
 
 static double computeVariance(const llvm::SmallVector<int64_t, 4> &Values) {
   if (Values.empty())
else {
         AccumulatedValues = std::move(ExpectedCounterValues.get());
         MinVariance = Variance;
       }
     }
   }
 
   std::string ModeName;
   switch (Mode) {
-  case InstructionBenchmark::Latency:
+  case Benchmark::Latency:
     ModeName = "latency";
     break;
-  case InstructionBenchmark::InverseThroughput:
+  case Benchmark::InverseThroughput:
     ModeName = "inverse_throughput";
     break;
   default:
     break;
   }
 
   switch (ResultAggMode) {
-  case InstructionBenchmark::MinVariance: {
+  case Benchmark::MinVariance: {
     if (ValuesCount == 1)
       llvm::errs() << "Each sample only has one value. result-aggregation-mode "
                       "of min-variance is probably non-sensical\n";
     std::vector<BenchmarkMeasure> Result;
     Result.reserve(AccumulatedValues.size());
     for (const int64_t Value : AccumulatedValues)
       Result.push_back(BenchmarkMeasure::Create(ModeName, Value));
     return std::move(Result);
   }
-  case InstructionBenchmark::Min: {
+  case Benchmark::Min: {
     std::vector<BenchmarkMeasure> Result;
     Result.push_back(
         BenchmarkMeasure::Create(ModeName, findMin(AccumulatedValues)));
     return std::move(Result);
   }
-  case InstructionBenchmark::Max: {
+  case Benchmark::Max: {
     std::vector<BenchmarkMeasure> Result;
     Result.push_back(
         BenchmarkMeasure::Create(ModeName, findMax(AccumulatedValues)));
     return std::move(Result);
   }
-  case InstructionBenchmark::Mean: {
+  case Benchmark::Mean: {
     std::vector<BenchmarkMeasure> Result;
     Result.push_back(
         BenchmarkMeasure::Create(ModeName, findMean(AccumulatedValues)));
     return std::move(Result);
   }
   }
   return llvm::make_error<Failure>(llvm::Twine("Unexpected benchmark mode(")
                                        .concat(std::to_string(Mode))
                                        .concat(" and unexpected ResultAggMode ")
                                        .concat(std::to_string(ResultAggMode)));
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/SchedClassResolution.h

struct ResolvedSchedClass {
   ResolvedSchedClass(const MCSubtargetInfo &STI, unsigned ResolvedSchedClassId,
                      bool WasVariant);
 
   static std::pair<unsigned /*SchedClassId*/, bool /*WasVariant*/>
   resolveSchedClassId(const MCSubtargetInfo &SubtargetInfo,
                       const MCInstrInfo &InstrInfo, const MCInst &MCI);
 
   std::vector<BenchmarkMeasure>
-  getAsPoint(InstructionBenchmark::ModeE Mode, const MCSubtargetInfo &STI,
+  getAsPoint(Benchmark::ModeE Mode, const MCSubtargetInfo &STI,
              ArrayRef<PerInstructionStats> Representative) const;
 
   const unsigned SchedClassId;
   const MCSchedClassDesc *const SCDesc;
   const bool WasVariant; // Whether the original class was variant.
   const SmallVector<MCWriteProcResEntry, 8> NonRedundantWriteProcRes;
   const std::vector<std::pair<uint16_t, float>> IdealizedProcResPressure;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_SCHEDCLASSRESOLUTION_H

llvm/tools/llvm-exegesis/lib/SchedClassResolution.cpp

static unsigned findProcResIdx(const MCSubtargetInfo &STI,
   for (int I = 0, E = SchedModel.getNumProcResourceKinds(); I < E; ++I) {
     if (NameOrId == SchedModel.getProcResource(I)->Name)
       return I;
   }
   return 0;
 }
 
 std::vector<BenchmarkMeasure> ResolvedSchedClass::getAsPoint(
-    InstructionBenchmark::ModeE Mode, const MCSubtargetInfo &STI,
+    Benchmark::ModeE Mode, const MCSubtargetInfo &STI,
     ArrayRef<PerInstructionStats> Representative) const {
   const size_t NumMeasurements = Representative.size();
 
   std::vector<BenchmarkMeasure> SchedClassPoint(NumMeasurements);
 
-  if (Mode == InstructionBenchmark::Latency) {
+  if (Mode == Benchmark::Latency) {
     assert(NumMeasurements == 1 && "Latency is a single measure.");
     BenchmarkMeasure &LatencyMeasure = SchedClassPoint[0];
 
     // Find the latency.
     LatencyMeasure.PerInstructionValue = 0.0;
 
     for (unsigned I = 0; I < SCDesc->NumWriteLatencyEntries; ++I) {
       const MCWriteLatencyEntry *const WLE =
           STI.getWriteLatencyEntry(SCDesc, I);
       LatencyMeasure.PerInstructionValue =
           std::max<double>(LatencyMeasure.PerInstructionValue, WLE->Cycles);
     }
-  } else if (Mode == InstructionBenchmark::Uops) {
+  } else if (Mode == Benchmark::Uops) {
     for (auto I : zip(SchedClassPoint, Representative)) {
       BenchmarkMeasure &Measure = std::get<0>(I);
       const PerInstructionStats &Stats = std::get<1>(I);
 
       StringRef Key = Stats.key();
       uint16_t ProcResIdx = findProcResIdx(STI, Key);
       if (ProcResIdx > 0) {
         // Find the pressure on ProcResIdx `Key`.
for (auto I : zip(SchedClassPoint, Representative)) {
         Measure.PerInstructionValue = SCDesc->NumMicroOps;
       } else {
         errs() << "expected `key` to be either a ProcResIdx or a ProcRes "
                   "name, got "
                << Key << "\n";
         return {};
       }
     }
-  } else if (Mode == InstructionBenchmark::InverseThroughput) {
+  } else if (Mode == Benchmark::InverseThroughput) {
     assert(NumMeasurements == 1 && "Inverse Throughput is a single measure.");
     BenchmarkMeasure &RThroughputMeasure = SchedClassPoint[0];
 
     RThroughputMeasure.PerInstructionValue =
         MCSchedModel::getReciprocalThroughput(STI, *SCDesc);
   } else {
     llvm_unreachable("unimplemented measurement matching mode");
   }
 
   return SchedClassPoint;
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/SnippetRepetitor.h

 #include "llvm/Object/Binary.h"
 
 namespace llvm {
 namespace exegesis {
 
 class SnippetRepetitor {
 public:
   static std::unique_ptr<const SnippetRepetitor>
-  Create(InstructionBenchmark::RepetitionModeE Mode, const LLVMState &State);
+  Create(Benchmark::RepetitionModeE Mode, const LLVMState &State);
 
   virtual ~SnippetRepetitor();
 
   // Returns the set of registers that are reserved by the repetitor.
   virtual BitVector getReservedRegs() const = 0;
 
   // Returns a functor that repeats `Instructions` so that the function executes
   // at least `MinInstructions` instructions.

llvm/tools/llvm-exegesis/lib/SnippetRepetitor.cpp

private:
   const unsigned LoopCounter;
 };
 
 } // namespace
 
 SnippetRepetitor::~SnippetRepetitor() {}
 
 std::unique_ptr<const SnippetRepetitor>
-SnippetRepetitor::Create(InstructionBenchmark::RepetitionModeE Mode,
+SnippetRepetitor::Create(Benchmark::RepetitionModeE Mode,
                          const LLVMState &State) {
   switch (Mode) {
-  case InstructionBenchmark::Duplicate:
+  case Benchmark::Duplicate:
     return std::make_unique<DuplicateSnippetRepetitor>(State);
-  case InstructionBenchmark::Loop:
+  case Benchmark::Loop:
     return std::make_unique<LoopSnippetRepetitor>(State);
-  case InstructionBenchmark::AggregateMin:
+  case Benchmark::AggregateMin:
     break;
   }
   llvm_unreachable("Unknown RepetitionModeE enum");
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/Target.h

public:
 
   // Checks hardware and software support for current benchmark mode.
   // Returns an error if the target host does not have support to run the
   // benchmark.
   virtual Error checkFeatureSupport() const { return Error::success(); }
 
   // Creates a snippet generator for the given mode.
   std::unique_ptr<SnippetGenerator>
-  createSnippetGenerator(InstructionBenchmark::ModeE Mode,
+  createSnippetGenerator(Benchmark::ModeE Mode,
                          const LLVMState &State,
                          const SnippetGenerator::Options &Opts) const;
   // Creates a benchmark runner for the given mode.
   Expected<std::unique_ptr<BenchmarkRunner>> createBenchmarkRunner(
-      InstructionBenchmark::ModeE Mode, const LLVMState &State,
+      Benchmark::ModeE Mode, const LLVMState &State,
       BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-      InstructionBenchmark::ResultAggregationModeE ResultAggMode =
-          InstructionBenchmark::Min) const;
+      Benchmark::ResultAggregationModeE ResultAggMode =
+          Benchmark::Min) const;
 
   // Returns the ExegesisTarget for the given triple or nullptr if the target
   // does not exist.
   static const ExegesisTarget *lookup(Triple TT);
   // Returns the default (unspecialized) ExegesisTarget.
   static const ExegesisTarget &getDefault();
   // Registers a target. Not thread safe.
   static void registerTarget(ExegesisTarget *T);
private:
 
   // Targets can implement their own snippet generators/benchmarks runners by
   // implementing these.
   std::unique_ptr<SnippetGenerator> virtual createSerialSnippetGenerator(
       const LLVMState &State, const SnippetGenerator::Options &Opts) const;
   std::unique_ptr<SnippetGenerator> virtual createParallelSnippetGenerator(
       const LLVMState &State, const SnippetGenerator::Options &Opts) const;
   std::unique_ptr<BenchmarkRunner> virtual createLatencyBenchmarkRunner(
-      const LLVMState &State, InstructionBenchmark::ModeE Mode,
+      const LLVMState &State, Benchmark::ModeE Mode,
       BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-      InstructionBenchmark::ResultAggregationModeE ResultAggMode) const;
+      Benchmark::ResultAggregationModeE ResultAggMode) const;
   std::unique_ptr<BenchmarkRunner> virtual createUopsBenchmarkRunner(
       const LLVMState &State, BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-      InstructionBenchmark::ResultAggregationModeE ResultAggMode) const;
+      Benchmark::ResultAggregationModeE ResultAggMode) const;
 
   const ExegesisTarget *Next = nullptr;
   const ArrayRef<CpuAndPfmCounters> CpuPfmCounters;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H

llvm/tools/llvm-exegesis/lib/Target.cpp

void ExegesisTarget::registerTarget(ExegesisTarget *Target) {
   }
   if (Target->Next != nullptr)
     return; // Already registered.
   Target->Next = FirstTarget;
   FirstTarget = Target;
 }
 
 std::unique_ptr<SnippetGenerator> ExegesisTarget::createSnippetGenerator(
-    InstructionBenchmark::ModeE Mode, const LLVMState &State,
+    Benchmark::ModeE Mode, const LLVMState &State,
     const SnippetGenerator::Options &Opts) const {
   switch (Mode) {
-  case InstructionBenchmark::Unknown:
+  case Benchmark::Unknown:
     return nullptr;
-  case InstructionBenchmark::Latency:
+  case Benchmark::Latency:
     return createSerialSnippetGenerator(State, Opts);
-  case InstructionBenchmark::Uops:
-  case InstructionBenchmark::InverseThroughput:
+  case Benchmark::Uops:
+  case Benchmark::InverseThroughput:
     return createParallelSnippetGenerator(State, Opts);
   }
   return nullptr;
 }
 
 Expected<std::unique_ptr<BenchmarkRunner>>
 ExegesisTarget::createBenchmarkRunner(
-    InstructionBenchmark::ModeE Mode, const LLVMState &State,
+    Benchmark::ModeE Mode, const LLVMState &State,
     BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-    InstructionBenchmark::ResultAggregationModeE ResultAggMode) const {
+    Benchmark::ResultAggregationModeE ResultAggMode) const {
   PfmCountersInfo PfmCounters = State.getPfmCounters();
   switch (Mode) {
-  case InstructionBenchmark::Unknown:
+  case Benchmark::Unknown:
     return nullptr;
-  case InstructionBenchmark::Latency:
-  case InstructionBenchmark::InverseThroughput:
+  case Benchmark::Latency:
+  case Benchmark::InverseThroughput:
     if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure &&
         !PfmCounters.CycleCounter) {
-      const char *ModeName = Mode == InstructionBenchmark::Latency
+      const char *ModeName = Mode == Benchmark::Latency
                                  ? "latency"
                                  : "inverse_throughput";
       return make_error<Failure>(
           Twine("can't run '")
               .concat(ModeName)
               .concat(
                   "' mode, sched model does not define a cycle counter. You "
                   "can pass --skip-measurements to skip the actual "
                   "benchmarking."));
     }
     return createLatencyBenchmarkRunner(State, Mode, BenchmarkPhaseSelector,
                                         ResultAggMode);
-  case InstructionBenchmark::Uops:
+  case Benchmark::Uops:
     if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure &&
         !PfmCounters.UopsCounter && !PfmCounters.IssueCounters)
       return make_error<Failure>(
           "can't run 'uops' mode, sched model does not define uops or issue "
           "counters. You can pass --skip-measurements to skip the actual "
           "benchmarking.");
     return createUopsBenchmarkRunner(State, BenchmarkPhaseSelector,
                                      ResultAggMode);
   }
   return nullptr;
 }
 
 std::unique_ptr<SnippetGenerator> ExegesisTarget::createSerialSnippetGenerator(
     const LLVMState &State, const SnippetGenerator::Options &Opts) const {
   return std::make_unique<SerialSnippetGenerator>(State, Opts);
 }
 
 std::unique_ptr<SnippetGenerator> ExegesisTarget::createParallelSnippetGenerator(
     const LLVMState &State, const SnippetGenerator::Options &Opts) const {
   return std::make_unique<ParallelSnippetGenerator>(State, Opts);
 }
 
 std::unique_ptr<BenchmarkRunner> ExegesisTarget::createLatencyBenchmarkRunner(
-    const LLVMState &State, InstructionBenchmark::ModeE Mode,
+    const LLVMState &State, Benchmark::ModeE Mode,
     BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-    InstructionBenchmark::ResultAggregationModeE ResultAggMode) const {
+    Benchmark::ResultAggregationModeE ResultAggMode) const {
   return std::make_unique<LatencyBenchmarkRunner>(
       State, Mode, BenchmarkPhaseSelector, ResultAggMode);
 }
 
 std::unique_ptr<BenchmarkRunner> ExegesisTarget::createUopsBenchmarkRunner(
     const LLVMState &State, BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
-    InstructionBenchmark::ResultAggregationModeE /*unused*/) const {
+    Benchmark::ResultAggregationModeE /*unused*/) const {
   return std::make_unique<UopsBenchmarkRunner>(State, BenchmarkPhaseSelector);
 }
 
 static_assert(std::is_trivial_v<PfmCountersInfo>,
               "We shouldn't have dynamic initialization here");
 const PfmCountersInfo PfmCountersInfo::Default = {nullptr, nullptr, nullptr,
                                                   0u};
 

llvm/tools/llvm-exegesis/lib/UopsBenchmarkRunner.h

 
 namespace llvm {
 namespace exegesis {
 
 class UopsBenchmarkRunner : public BenchmarkRunner {
 public:
   UopsBenchmarkRunner(const LLVMState &State,
                       BenchmarkPhaseSelectorE BenchmarkPhaseSelector)
-      : BenchmarkRunner(State, InstructionBenchmark::Uops,
+      : BenchmarkRunner(State, Benchmark::Uops,
                         BenchmarkPhaseSelector) {}
   ~UopsBenchmarkRunner() override;
 
   static constexpr const size_t kMinNumDifferentAddresses = 6;
 
 private:
   Expected<std::vector<BenchmarkMeasure>>
   runMeasurements(const FunctionExecutor &Executor) const override;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_UOPSBENCHMARKRUNNER_H

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

 
 static cl::opt<std::string>
     BenchmarkFile("benchmarks-file",
                   cl::desc("File to read (analysis mode) or write "
                            "(latency/uops/inverse_throughput modes) benchmark "
                            "results. “-” uses stdin/stdout."),
                   cl::cat(Options), cl::init(""));
 
-static cl::opt<exegesis::InstructionBenchmark::ModeE> BenchmarkMode(
+static cl::opt<exegesis::Benchmark::ModeE> BenchmarkMode(
     "mode", cl::desc("the mode to run"), cl::cat(Options),
-    cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency, "latency",
+    cl::values(clEnumValN(exegesis::Benchmark::Latency, "latency",
                           "Instruction Latency"),
-               clEnumValN(exegesis::InstructionBenchmark::InverseThroughput,
+               clEnumValN(exegesis::Benchmark::InverseThroughput,
                           "inverse_throughput",
                           "Instruction Inverse Throughput"),
-               clEnumValN(exegesis::InstructionBenchmark::Uops, "uops",
+               clEnumValN(exegesis::Benchmark::Uops, "uops",
                           "Uop Decomposition"),
                // When not asking for a specific benchmark mode,
                // we'll analyse the results.
-               clEnumValN(exegesis::InstructionBenchmark::Unknown, "analysis",
+               clEnumValN(exegesis::Benchmark::Unknown, "analysis",
                           "Analysis")));
 
-static cl::opt<exegesis::InstructionBenchmark::ResultAggregationModeE>
+static cl::opt<exegesis::Benchmark::ResultAggregationModeE>
     ResultAggMode(
         "result-aggregation-mode",
         cl::desc("How to aggregate multi-values result"),
         cl::cat(BenchmarkOptions),
-        cl::values(clEnumValN(exegesis::InstructionBenchmark::Min, "min",
+        cl::values(clEnumValN(exegesis::Benchmark::Min, "min",
                               "Keep min reading"),
-                   clEnumValN(exegesis::InstructionBenchmark::Max, "max",
+                   clEnumValN(exegesis::Benchmark::Max, "max",
                               "Keep max reading"),
-                   clEnumValN(exegesis::InstructionBenchmark::Mean, "mean",
+                   clEnumValN(exegesis::Benchmark::Mean, "mean",
                               "Compute mean of all readings"),
-                   clEnumValN(exegesis::InstructionBenchmark::MinVariance,
+                   clEnumValN(exegesis::Benchmark::MinVariance,
                               "min-variance",
                               "Keep readings set with min-variance")),
-        cl::init(exegesis::InstructionBenchmark::Min));
+        cl::init(exegesis::Benchmark::Min));
 
-static cl::opt<exegesis::InstructionBenchmark::RepetitionModeE> RepetitionMode(
+static cl::opt<exegesis::Benchmark::RepetitionModeE> RepetitionMode(
     "repetition-mode", cl::desc("how to repeat the instruction snippet"),
     cl::cat(BenchmarkOptions),
     cl::values(
-        clEnumValN(exegesis::InstructionBenchmark::Duplicate, "duplicate",
+        clEnumValN(exegesis::Benchmark::Duplicate, "duplicate",
                    "Duplicate the snippet"),
-        clEnumValN(exegesis::InstructionBenchmark::Loop, "loop",
+        clEnumValN(exegesis::Benchmark::Loop, "loop",
                    "Loop over the snippet"),
-        clEnumValN(exegesis::InstructionBenchmark::AggregateMin, "min",
+        clEnumValN(exegesis::Benchmark::AggregateMin, "min",
                    "All of the above and take the minimum of measurements")),
-    cl::init(exegesis::InstructionBenchmark::Duplicate));
+    cl::init(exegesis::Benchmark::Duplicate));
 
 static cl::opt<bool> BenchmarkMeasurementsPrintProgress(
     "measurements-print-progress",
     cl::desc("Produce progress indicator when performing measurements"),
     cl::cat(BenchmarkOptions), cl::init(false));
 
 static cl::opt<exegesis::BenchmarkPhaseSelectorE> BenchmarkPhaseSelector(
     "benchmark-phase",
cl::desc(
         "allow to snippet generator to generate at most that many configs"),
     cl::cat(BenchmarkOptions), cl::init(1));
 
 static cl::opt<bool> IgnoreInvalidSchedClass(
     "ignore-invalid-sched-class",
     cl::desc("ignore instructions that do not define a sched class"),
     cl::cat(BenchmarkOptions), cl::init(false));
 
-static cl::opt<exegesis::InstructionBenchmarkFilter> AnalysisSnippetFilter(
+static cl::opt<exegesis::BenchmarkFilter> AnalysisSnippetFilter(
     "analysis-filter", cl::desc("Filter the benchmarks before analysing them"),
     cl::cat(BenchmarkOptions),
     cl::values(
-        clEnumValN(exegesis::InstructionBenchmarkFilter::All, "all",
+        clEnumValN(exegesis::BenchmarkFilter::All, "all",
                    "Keep all benchmarks (default)"),
-        clEnumValN(exegesis::InstructionBenchmarkFilter::RegOnly, "reg-only",
+        clEnumValN(exegesis::BenchmarkFilter::RegOnly, "reg-only",
                    "Keep only those benchmarks that do *NOT* involve memory"),
-        clEnumValN(exegesis::InstructionBenchmarkFilter::WithMem, "mem-only",
+        clEnumValN(exegesis::BenchmarkFilter::WithMem, "mem-only",
                    "Keep only the benchmarks that *DO* involve memory")),
-    cl::init(exegesis::InstructionBenchmarkFilter::All));
+    cl::init(exegesis::BenchmarkFilter::All));
 
-static cl::opt<exegesis::InstructionBenchmarkClustering::ModeE>
+static cl::opt<exegesis::BenchmarkClustering::ModeE>
     AnalysisClusteringAlgorithm(
         "analysis-clustering", cl::desc("the clustering algorithm to use"),
         cl::cat(AnalysisOptions),
-        cl::values(clEnumValN(exegesis::InstructionBenchmarkClustering::Dbscan,
+        cl::values(clEnumValN(exegesis::BenchmarkClustering::Dbscan,
                               "dbscan", "use DBSCAN/OPTICS algorithm"),
-                   clEnumValN(exegesis::InstructionBenchmarkClustering::Naive,
+                   clEnumValN(exegesis::BenchmarkClustering::Naive,
                               "naive", "one cluster per opcode")),
-        cl::init(exegesis::InstructionBenchmarkClustering::Dbscan));
+        cl::init(exegesis::BenchmarkClustering::Dbscan));
 
 static cl::opt<unsigned> AnalysisDbscanNumPoints(
     "analysis-numpoints",
     cl::desc("minimum number of points in an analysis cluster (dbscan only)"),
     cl::cat(AnalysisOptions), cl::init(3));
 
 static cl::opt<float> AnalysisClusteringEpsilon(
     "analysis-clustering-epsilon",
static void runBenchmarkConfigurations(
   }
   raw_ostream &Ostr = FileOstr ? *FileOstr : outs();
 
   std::optional<ProgressMeter<>> Meter;
   if (BenchmarkMeasurementsPrintProgress)
     Meter.emplace(Configurations.size());
   for (const BenchmarkCode &Conf : Configurations) {
     ProgressMeter<>::ProgressMeterStep MeterStep(Meter ? &*Meter : nullptr);
-    SmallVector<InstructionBenchmark, 2> AllResults;
+    SmallVector<Benchmark, 2> AllResults;
 
     for (const std::unique_ptr<const SnippetRepetitor> &Repetitor :
          Repetitors) {
       auto RC = ExitOnErr(Runner.getRunnableConfiguration(
           Conf, NumRepetitions, LoopBodySize, *Repetitor));
       AllResults.emplace_back(
           ExitOnErr(Runner.runConfiguration(std::move(RC), DumpObjectToDisk)));
     }
-    InstructionBenchmark &Result = AllResults.front();
+    Benchmark &Result = AllResults.front();
 
     // If any of our measurements failed, pretend they all have failed.
     if (AllResults.size() > 1 &&
-        any_of(AllResults, [](const InstructionBenchmark &R) {
+        any_of(AllResults, [](const Benchmark &R) {
           return R.Measurements.empty();
         }))
       Result.Measurements.clear();
 
-    if (RepetitionMode == InstructionBenchmark::RepetitionModeE::AggregateMin) {
-      for (const InstructionBenchmark &OtherResult :
-           ArrayRef<InstructionBenchmark>(AllResults).drop_front()) {
+    if (RepetitionMode == Benchmark::RepetitionModeE::AggregateMin) {
+      for (const Benchmark &OtherResult :
+           ArrayRef<Benchmark>(AllResults).drop_front()) {
         llvm::append_range(Result.AssembledSnippet,
                            OtherResult.AssembledSnippet);
         // Aggregate measurements, but only iff all measurements succeeded.
         if (Result.Measurements.empty())
           continue;
         assert(OtherResult.Measurements.size() == Result.Measurements.size() &&
                "Expected to have identical number of measurements.");
         for (auto I : zip(Result.Measurements, OtherResult.Measurements)) {
const std::unique_ptr<BenchmarkRunner> Runner =
           BenchmarkMode, State, BenchmarkPhaseSelector, ResultAggMode));
   if (!Runner) {
     ExitWithError("cannot create benchmark runner");
   }
 
   const auto Opcodes = getOpcodesOrDie(State);
 
   SmallVector<std::unique_ptr<const SnippetRepetitor>, 2> Repetitors;
-  if (RepetitionMode != InstructionBenchmark::RepetitionModeE::AggregateMin)
+  if (RepetitionMode != Benchmark::RepetitionModeE::AggregateMin)
     Repetitors.emplace_back(SnippetRepetitor::Create(RepetitionMode, State));
   else {
-    for (InstructionBenchmark::RepetitionModeE RepMode :
-         {InstructionBenchmark::RepetitionModeE::Duplicate,
-          InstructionBenchmark::RepetitionModeE::Loop})
+    for (Benchmark::RepetitionModeE RepMode :
+         {Benchmark::RepetitionModeE::Duplicate,
+          Benchmark::RepetitionModeE::Loop})
       Repetitors.emplace_back(SnippetRepetitor::Create(RepMode, State));
   }
 
   BitVector AllReservedRegs;
   llvm::for_each(Repetitors,
                  [&AllReservedRegs](
                      const std::unique_ptr<const SnippetRepetitor> &Repetitor) {
                    AllReservedRegs |= Repetitor->getReservedRegs();
static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
   raw_fd_ostream ClustersOS(OutputFilename, ErrorCode,
                             sys::fs::FA_Read | sys::fs::FA_Write);
   if (ErrorCode)
     ExitOnFileError(OutputFilename, errorCodeToError(ErrorCode));
   if (auto Err = Analyzer.run<Pass>(ClustersOS))
     ExitOnFileError(OutputFilename, std::move(Err));
 }
 
-static void filterPoints(MutableArrayRef<InstructionBenchmark> Points,
+static void filterPoints(MutableArrayRef<Benchmark> Points,
                          const MCInstrInfo &MCII) {
-  if (AnalysisSnippetFilter == exegesis::InstructionBenchmarkFilter::All)
+  if (AnalysisSnippetFilter == exegesis::BenchmarkFilter::All)
     return;
 
   bool WantPointsWithMemOps =
-      AnalysisSnippetFilter == exegesis::InstructionBenchmarkFilter::WithMem;
-  for (InstructionBenchmark &Point : Points) {
+      AnalysisSnippetFilter == exegesis::BenchmarkFilter::WithMem;
+  for (Benchmark &Point : Points) {
     if (!Point.Error.empty())
       continue;
     if (WantPointsWithMemOps ==
         any_of(Point.Key.Instructions, [&MCII](const MCInst &Inst) {
           const MCInstrDesc &MCDesc = MCII.get(Inst.getOpcode());
           return MCDesc.mayLoad() || MCDesc.mayStore();
         }))
       continue;
static void analysisMain() {
   InitializeAllExegesisTargets();
 
   auto MemoryBuffer = ExitOnFileError(
       BenchmarkFile,
       errorOrToExpected(MemoryBuffer::getFile(BenchmarkFile, /*IsText=*/true)));
 
   const auto TriplesAndCpus = ExitOnFileError(
       BenchmarkFile,
-      InstructionBenchmark::readTriplesAndCpusFromYamls(*MemoryBuffer));
+      Benchmark::readTriplesAndCpusFromYamls(*MemoryBuffer));
   if (TriplesAndCpus.empty()) {
     errs() << "no benchmarks to analyze\n";
     return;
   }
   if (TriplesAndCpus.size() > 1) {
     ExitWithError("analysis file contains benchmarks from several CPUs. This "
                   "is unsupported.");
   }
   auto TripleAndCpu = *TriplesAndCpus.begin();
   if (AnalysisOverrideBenchmarksTripleAndCpu) {
     llvm::errs() << "overridding file CPU name (" << TripleAndCpu.CpuName
                  << ") with provided tripled (" << TripleName
                  << ") and CPU name (" << MCPU << ")\n";
     TripleAndCpu.LLVMTriple = TripleName;
     TripleAndCpu.CpuName = MCPU;
   }
   llvm::errs() << "using Triple '" << TripleAndCpu.LLVMTriple << "' and CPU '"
                << TripleAndCpu.CpuName << "'\n";
 
   // Read benchmarks.
   const LLVMState State = ExitOnErr(
       LLVMState::Create(TripleAndCpu.LLVMTriple, TripleAndCpu.CpuName));
-  std::vector<InstructionBenchmark> Points = ExitOnFileError(
-      BenchmarkFile, InstructionBenchmark::readYamls(State, *MemoryBuffer));
+  std::vector<Benchmark> Points = ExitOnFileError(
+      BenchmarkFile, Benchmark::readYamls(State, *MemoryBuffer));
 
   outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {
     errs() << "no benchmarks to analyze\n";
     return;
   }
   // FIXME: Merge points from several runs (latency and uops).
 
   filterPoints(Points, State.getInstrInfo());
 
-  const auto Clustering = ExitOnErr(InstructionBenchmarkClustering::create(
+  const auto Clustering = ExitOnErr(BenchmarkClustering::create(
       Points, AnalysisClusteringAlgorithm, AnalysisDbscanNumPoints,
       AnalysisClusteringEpsilon, &State.getSubtargetInfo(),
       &State.getInstrInfo()));
 
   const Analysis Analyzer(State, Clustering, AnalysisInconsistencyEpsilon,
                           AnalysisDisplayUnstableOpcodes);
 
   maybeRunAnalysis<Analysis::PrintClusters>(Analyzer, "analysis clusters",
cl::ParseCommandLineOptions(Argc, Argv,
                               "measurment and analysis.\n");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const Error &Err) {
     if (Err.isA<exegesis::ClusteringError>())
       return EXIT_SUCCESS;
     return EXIT_FAILURE;
   });
 
-  if (exegesis::BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
+  if (exegesis::BenchmarkMode == exegesis::Benchmark::Unknown) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }

llvm/unittests/tools/llvm-exegesis/ClusteringTest.cpp

 
 namespace {
 
 using testing::Field;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
 static const auto HasPoints = [](const std::vector<int> &Indices) {
-  return Field(&InstructionBenchmarkClustering::Cluster::PointIndices,
+  return Field(&BenchmarkClustering::Cluster::PointIndices,
                  UnorderedElementsAreArray(Indices));
 };
 
 TEST(ClusteringTest, Clusters3D) {
-  std::vector<InstructionBenchmark> Points(6);
+  std::vector<Benchmark> Points(6);
 
   // Cluster around (x=0, y=1, z=2): points {0, 3}.
   Points[0].Measurements = {
       {"x", 0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   Points[3].Measurements = {
       {"x", -0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   // Cluster around (x=1, y=1, z=2): points {1, 4}.
   Points[1].Measurements = {
       {"x", 1.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   Points[4].Measurements = {
       {"x", 0.99, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   // Cluster around (x=0, y=0, z=0): points {5}, marked as noise.
   Points[5].Measurements = {
       {"x", 0.0, 0.0}, {"y", 0.01, 0.0}, {"z", -0.02, 0.0}};
   // Error cluster: points {2}
   Points[2].Error = "oops";
 
-  auto Clustering = InstructionBenchmarkClustering::create(
-      Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25);
+  auto Clustering = BenchmarkClustering::create(
+      Points, BenchmarkClustering::ModeE::Dbscan, 2, 0.25);
   ASSERT_TRUE((bool)Clustering);
   EXPECT_THAT(Clustering.get().getValidClusters(),
               UnorderedElementsAre(HasPoints({0, 3}), HasPoints({1, 4})));
   EXPECT_THAT(Clustering.get().getCluster(
-                  InstructionBenchmarkClustering::ClusterId::noise()),
+                  BenchmarkClustering::ClusterId::noise()),
               HasPoints({5}));
   EXPECT_THAT(Clustering.get().getCluster(
-                  InstructionBenchmarkClustering::ClusterId::error()),
+                  BenchmarkClustering::ClusterId::error()),
               HasPoints({2}));
 
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(2),
-            InstructionBenchmarkClustering::ClusterId::error());
+            BenchmarkClustering::ClusterId::error());
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(5),
-            InstructionBenchmarkClustering::ClusterId::noise());
+            BenchmarkClustering::ClusterId::noise());
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(0),
             Clustering.get().getClusterIdForPoint(3));
   EXPECT_EQ(Clustering.get().getClusterIdForPoint(1),
             Clustering.get().getClusterIdForPoint(4));
 }
 
 TEST(ClusteringTest, Clusters3D_InvalidSize) {
-  std::vector<InstructionBenchmark> Points(6);
+  std::vector<Benchmark> Points(6);
   Points[0].Measurements = {
       {"x", 0.01, 0.0}, {"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   Points[1].Measurements = {{"y", 1.02, 0.0}, {"z", 1.98, 0.0}};
   auto Error =
-      InstructionBenchmarkClustering::create(
-          Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25)
+      BenchmarkClustering::create(
+          Points, BenchmarkClustering::ModeE::Dbscan, 2, 0.25)
           .takeError();
   ASSERT_TRUE((bool)Error);
   consumeError(std::move(Error));
 }
 
 TEST(ClusteringTest, Clusters3D_InvalidOrder) {
-  std::vector<InstructionBenchmark> Points(6);
+  std::vector<Benchmark> Points(6);
   Points[0].Measurements = {{"x", 0.01, 0.0}, {"y", 1.02, 0.0}};
   Points[1].Measurements = {{"y", 1.02, 0.0}, {"x", 1.98, 0.0}};
   auto Error =
-      InstructionBenchmarkClustering::create(
-          Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 0.25)
+      BenchmarkClustering::create(
+          Points, BenchmarkClustering::ModeE::Dbscan, 2, 0.25)
           .takeError();
   ASSERT_TRUE((bool)Error);
   consumeError(std::move(Error));
 }
 
 TEST(ClusteringTest, Ordering) {
-  ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(1),
-            InstructionBenchmarkClustering::ClusterId::makeValid(2));
+  ASSERT_LT(BenchmarkClustering::ClusterId::makeValid(1),
+            BenchmarkClustering::ClusterId::makeValid(2));
 
-  ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
-            InstructionBenchmarkClustering::ClusterId::noise());
+  ASSERT_LT(BenchmarkClustering::ClusterId::makeValid(2),
+            BenchmarkClustering::ClusterId::noise());
 
-  ASSERT_LT(InstructionBenchmarkClustering::ClusterId::makeValid(2),
-            InstructionBenchmarkClustering::ClusterId::error());
+  ASSERT_LT(BenchmarkClustering::ClusterId::makeValid(2),
+            BenchmarkClustering::ClusterId::error());
 
-  ASSERT_LT(InstructionBenchmarkClustering::ClusterId::noise(),
-            InstructionBenchmarkClustering::ClusterId::error());
+  ASSERT_LT(BenchmarkClustering::ClusterId::noise(),
+            BenchmarkClustering::ClusterId::error());
 }
 
 TEST(ClusteringTest, Ordering1) {
-  std::vector<InstructionBenchmark> Points(3);
+  std::vector<Benchmark> Points(3);
 
   Points[0].Measurements = {
       {"x", 0.0, 0.0}};
   Points[1].Measurements = {
       {"x", 1.0, 0.0}};
   Points[2].Measurements = {
       {"x", 2.0, 0.0}};
 
-  auto Clustering = InstructionBenchmarkClustering::create(
-      Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 1.1);
+  auto Clustering = BenchmarkClustering::create(
+      Points, BenchmarkClustering::ModeE::Dbscan, 2, 1.1);
   ASSERT_TRUE((bool)Clustering);
   EXPECT_THAT(Clustering.get().getValidClusters(),
               UnorderedElementsAre(HasPoints({0, 1, 2})));
 }
 
 TEST(ClusteringTest, Ordering2) {
-  std::vector<InstructionBenchmark> Points(3);
+  std::vector<Benchmark> Points(3);
 
   Points[0].Measurements = {
       {"x", 0.0, 0.0}};
   Points[1].Measurements = {
       {"x", 2.0, 0.0}};
   Points[2].Measurements = {
       {"x", 1.0, 0.0}};
 
-  auto Clustering = InstructionBenchmarkClustering::create(
-      Points, InstructionBenchmarkClustering::ModeE::Dbscan, 2, 1.1);
+  auto Clustering = BenchmarkClustering::create(
+      Points, BenchmarkClustering::ModeE::Dbscan, 2, 1.1);
   ASSERT_TRUE((bool)Clustering);
   EXPECT_THAT(Clustering.get().getValidClusters(),
               UnorderedElementsAre(HasPoints({0, 1, 2})));
 }
 
 } // namespace
 } // namespace exegesis
 } // namespace llvm

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

 
 namespace {
 
 class MipsBenchmarkResultTest : public MipsTestBase {};
 
 TEST_F(MipsBenchmarkResultTest, WriteToAndReadFromDisk) {
   ExitOnError ExitOnErr;
 
-  InstructionBenchmark ToDisk;
+  Benchmark ToDisk;
 
   ToDisk.Key.Instructions.push_back(MCInstBuilder(Mips::XOR)
                                         .addReg(Mips::T0)
                                         .addReg(Mips::T1)
                                         .addReg(Mips::T2));
   ToDisk.Key.Config = "config";
   ToDisk.Key.RegisterInitialValues = {
       RegisterValue{Mips::T1, APInt(8, "123", 10)},
       RegisterValue{Mips::T2, APInt(8, "456", 10)}};
-  ToDisk.Mode = InstructionBenchmark::Latency;
+  ToDisk.Mode = Benchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1});
   ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, 2});
   ToDisk.Error = "error";
   ToDisk.Info = "info";
 
errs() << Filename << "-------\n";
     ExitOnErr(ToDisk.writeYamlTo(State, FileOstr));
   }
   const std::unique_ptr<MemoryBuffer> Buffer =
       std::move(*MemoryBuffer::getFile(Filename));
 
   {
     // One-element version.
     const auto FromDisk =
-        ExitOnErr(InstructionBenchmark::readYaml(State, *Buffer));
+        ExitOnErr(Benchmark::readYaml(State, *Buffer));
 
     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(State, *Buffer));
+        ExitOnErr(Benchmark::readYamls(State, *Buffer));
     ASSERT_EQ(FromDiskVector.size(), size_t{1});
     const auto &FromDisk = FromDiskVector[0];
     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);

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

TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   InitializeX86ExegesisTarget();
 
   // Read benchmarks.
   const LLVMState State =
       cantFail(LLVMState::Create("x86_64-unknown-linux", "haswell"));
 
   ExitOnError ExitOnErr;
 
-  InstructionBenchmark ToDisk;
+  Benchmark ToDisk;
 
   ToDisk.Key.Instructions.push_back(MCInstBuilder(X86::XOR32rr)
                                         .addReg(X86::AL)
                                         .addReg(X86::AH)
                                         .addImm(123)
                                         .addDFPImm(bit_cast<uint64_t>(0.5)));
   ToDisk.Key.Config = "config";
   ToDisk.Key.RegisterInitialValues = {
       RegisterValue{X86::AL, APInt(8, "-1", 10)},
       RegisterValue{X86::AH, APInt(8, "123", 10)}};
-  ToDisk.Mode = InstructionBenchmark::Latency;
+  ToDisk.Mode = Benchmark::Latency;
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1});
   ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, 2});
   ToDisk.Error = "error";
   ToDisk.Info = "info";
 
TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
   }
 
   const std::unique_ptr<MemoryBuffer> Buffer =
       std::move(*MemoryBuffer::getFile(Filename));
 
   {
     // Read Triples/Cpu only.
     const auto TriplesAndCpus =
-        ExitOnErr(InstructionBenchmark::readTriplesAndCpusFromYamls(*Buffer));
+        ExitOnErr(Benchmark::readTriplesAndCpusFromYamls(*Buffer));
 
     ASSERT_THAT(TriplesAndCpus,
                 testing::ElementsAre(
-                    AllOf(Field(&InstructionBenchmark::TripleAndCpu::LLVMTriple,
+                    AllOf(Field(&Benchmark::TripleAndCpu::LLVMTriple,
                                 Eq("llvm_triple")),
-                          Field(&InstructionBenchmark::TripleAndCpu::CpuName,
+                          Field(&Benchmark::TripleAndCpu::CpuName,
                                 Eq("cpu_name")))));
   }
   {
     // One-element version.
     const auto FromDisk =
-        ExitOnErr(InstructionBenchmark::readYaml(State, *Buffer));
+        ExitOnErr(Benchmark::readYaml(State, *Buffer));
 
     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(State, *Buffer));
+        ExitOnErr(Benchmark::readYamls(State, *Buffer));
     ASSERT_EQ(FromDiskVector.size(), size_t{1});
     const auto &FromDisk = FromDiskVector[0];
     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);

llvm/unittests/tools/llvm-exegesis/X86/SnippetRepetitorTest.cpp

void SetUp() override {
     TM = State.createTargetMachine();
     Context = std::make_unique<LLVMContext>();
     Mod = std::make_unique<Module>("X86SnippetRepetitorTest", *Context);
     Mod->setDataLayout(TM->createDataLayout());
     MMI = std::make_unique<MachineModuleInfo>(TM.get());
     MF = &createVoidVoidPtrMachineFunction("TestFn", Mod.get(), MMI.get());
   }
 
-  void TestCommon(InstructionBenchmark::RepetitionModeE RepetitionMode) {
+  void TestCommon(Benchmark::RepetitionModeE RepetitionMode) {
     const auto Repetitor = SnippetRepetitor::Create(RepetitionMode, State);
     const std::vector<MCInst> Instructions = {MCInstBuilder(X86::NOOP)};
     FunctionFiller Sink(*MF, {X86::EAX});
     const auto Fill =
         Repetitor->Repeat(Instructions, kMinInstructions, kLoopBodySize);
     Fill(Sink);
   }
 
static auto HasOpcode = [](unsigned Opcode) {
   return Property(&MachineInstr::getOpcode, Eq(Opcode));
 };
 
 static auto LiveReg = [](unsigned Reg) {
   return Field(&MachineBasicBlock::RegisterMaskPair::PhysReg, Eq(Reg));
 };
 
 TEST_F(X86SnippetRepetitorTest, Duplicate) {
-  TestCommon(InstructionBenchmark::Duplicate);
+  TestCommon(Benchmark::Duplicate);
   // Duplicating creates a single basic block that repeats the instructions.
   ASSERT_EQ(MF->getNumBlockIDs(), 1u);
   EXPECT_THAT(MF->getBlockNumbered(0)->instrs(),
               ElementsAre(HasOpcode(X86::NOOP), HasOpcode(X86::NOOP),
                           HasOpcode(X86::NOOP), HasOpcode(X86::RET64)));
 }
 
 TEST_F(X86SnippetRepetitorTest, Loop) {
-  TestCommon(InstructionBenchmark::Loop);
+  TestCommon(Benchmark::Loop);
   // Duplicating creates an entry block, a loop body and a ret block.
   ASSERT_EQ(MF->getNumBlockIDs(), 3u);
   const auto &LoopBlock = *MF->getBlockNumbered(1);
   EXPECT_THAT(LoopBlock.instrs(),
               ElementsAre(HasOpcode(X86::NOOP), HasOpcode(X86::NOOP),
                           HasOpcode(X86::NOOP), HasOpcode(X86::NOOP),
                           HasOpcode(X86::NOOP), HasOpcode(X86::ADD64ri8),
                           HasOpcode(X86::JCC_1)));