[llvm-exegesis] Make BenchmarkRunner handle multiple configurations.

[gchatelet]

Summary

BenchmarkRunner subclasses can now create many configurations - although this patch still generates one.

[courbet]

tools/llvm-exegesis/lib/BenchmarkRunner.cpp

26 ↗

(On Diff #150301)

let's refactor this.

[gchatelet]

Inlining most of the makeError functions.

[gchatelet]

Fix wrongly split string literal.

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

 struct BenchmarkConfiguration {
   // This code is run before the Snippet is iterated. Since it is part of the
   // measurement it should be as short as possible. It is usually used to setup
   // the content of the Registers.
   std::vector<llvm::MCInst> SnippetSetup;
 
   // The sequence of instructions that are to be repeated.
   std::vector<llvm::MCInst> Snippet;
+
+  // Informations about how this configuration was built.
+  std::string Info;
 };
 
 // Common code for all benchmark modes.
 class BenchmarkRunner {
 public:
   explicit BenchmarkRunner(const LLVMState &State);
 
   // Subtargets can disable running benchmarks for some instructions by
   // returning an error here.
   class InstructionFilter {
   public:
     virtual ~InstructionFilter();
 
     virtual llvm::Error shouldRun(const LLVMState &State,
                                   unsigned Opcode) const {
       return llvm::ErrorSuccess();
     }
   };
 
   virtual ~BenchmarkRunner();
 
-  InstructionBenchmark run(unsigned Opcode, const InstructionFilter &Filter,
-                           unsigned NumRepetitions);
+  llvm::Expected<std::vector<InstructionBenchmark>>
+  run(unsigned Opcode, const InstructionFilter &Filter,
 
 protected:
   const LLVMState &State;
   const llvm::MCInstrInfo &MCInstrInfo;
   const llvm::MCRegisterInfo &MCRegisterInfo;
 
 private:
+  InstructionBenchmark runOne(const BenchmarkConfiguration &Configuration,
+                              unsigned Opcode, unsigned NumRepetitions) const;
+
   virtual InstructionBenchmark::ModeE getMode() const = 0;
 
-  virtual llvm::Expected<BenchmarkConfiguration>
-  createConfiguration(RegisterAliasingTrackerCache &RATC, unsigned Opcode,
-                      llvm::raw_ostream &Debug) const = 0;
+  virtual llvm::Expected<std::vector<BenchmarkConfiguration>>
+  createConfigurations(RegisterAliasingTrackerCache &RATC,
+                       unsigned Opcode) const = 0;
 
   virtual std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const = 0;
 
   llvm::Expected<std::string>
   writeObjectFile(llvm::ArrayRef<llvm::MCInst> Code) const;
 
   RegisterAliasingTrackerCache RATC;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRUNNER_H

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

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 
 namespace exegesis {
 
 BenchmarkRunner::InstructionFilter::~InstructionFilter() = default;
+
 BenchmarkRunner::BenchmarkRunner(const LLVMState &State)
     : State(State), MCInstrInfo(State.getInstrInfo()),
       MCRegisterInfo(State.getRegInfo()),
       RATC(MCRegisterInfo,
            getFunctionReservedRegs(*State.createTargetMachine())) {}
+
 BenchmarkRunner::~BenchmarkRunner() = default;
 
-InstructionBenchmark BenchmarkRunner::run(unsigned Opcode,
-                                          const InstructionFilter &Filter,
-                                          unsigned NumRepetitions) {
-  InstructionBenchmark InstrBenchmark;
+llvm::Expected<std::vector<InstructionBenchmark>>
+BenchmarkRunner::run(unsigned Opcode, const InstructionFilter &Filter,
+  // Ignore instructions that we cannot run.
+  if (State.getInstrInfo().get(Opcode).isPseudo())
+    return llvm::make_error<llvm::StringError>("Unsupported opcode: isPseudo",
+                                               llvm::inconvertibleErrorCode());
+
+  if (llvm::Error E = Filter.shouldRun(State, Opcode))
+    return std::move(E);
 
+  llvm::Expected<std::vector<BenchmarkConfiguration>> ConfigurationOrError =
+      createConfigurations(RATC, Opcode);
+
+  if (llvm::Error E = ConfigurationOrError.takeError())
+    return std::move(E);
+
+  std::vector<InstructionBenchmark> InstrBenchmarks;
+  for (const BenchmarkConfiguration &Conf : ConfigurationOrError.get())
+    InstrBenchmarks.push_back(runOne(Conf, Opcode, NumRepetitions));
+  return InstrBenchmarks;
+}
+
+InstructionBenchmark
+BenchmarkRunner::runOne(const BenchmarkConfiguration &Configuration,
+                        unsigned Opcode, unsigned NumRepetitions) const {
+  InstructionBenchmark InstrBenchmark;
   InstrBenchmark.Key.OpcodeName = State.getInstrInfo().getName(Opcode);
   InstrBenchmark.Mode = getMode();
   InstrBenchmark.CpuName = State.getCpuName();
   InstrBenchmark.LLVMTriple = State.getTriple();
   InstrBenchmark.NumRepetitions = NumRepetitions;
+  InstrBenchmark.Info = Configuration.Info;
 
-  // Ignore instructions that we cannot run.
-  if (State.getInstrInfo().get(Opcode).isPseudo()) {
-    InstrBenchmark.Error = "Unsupported opcode: isPseudo";
-    return InstrBenchmark;
-  }
-  if (llvm::Error E = Filter.shouldRun(State, Opcode)) {
-    InstrBenchmark.Error = llvm::toString(std::move(E));
-    return InstrBenchmark;
-  }
-  llvm::raw_string_ostream InfoStream(InstrBenchmark.Info);
-  llvm::Expected<BenchmarkConfiguration> ConfigurationOrError =
-      createConfiguration(RATC, Opcode, InfoStream);
-  if (llvm::Error E = ConfigurationOrError.takeError()) {
-    InstrBenchmark.Error = llvm::toString(std::move(E));
-    return InstrBenchmark;
-  }
-  BenchmarkConfiguration &Configuration = ConfigurationOrError.get();
   const std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
   if (Snippet.empty()) {
     InstrBenchmark.Error = "Empty snippet";
     return InstrBenchmark;
   }
-  for (const auto &MCInst : Snippet) {
+
+  for (const auto &MCInst : Snippet)
     InstrBenchmark.Key.Instructions.push_back(MCInst);
-  }
-  InfoStream << "Snippet:\n";
-  for (const auto &MCInst : Snippet) {
-    DumpMCInst(MCRegisterInfo, MCInstrInfo, MCInst, InfoStream);
-    InfoStream << "\n";
-  }
 
   std::vector<llvm::MCInst> Code;
   for (int I = 0; I < InstrBenchmark.NumRepetitions; ++I)
     Code.push_back(Snippet[I % Snippet.size()]);
 
   auto ExpectedObjectPath = writeObjectFile(Code);
   if (llvm::Error E = ExpectedObjectPath.takeError()) {
     InstrBenchmark.Error = llvm::toString(std::move(E));

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

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

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

static bool IsInfeasible(const Instruction &Instruction, std::string &Error) {
   }
   if (llvm::any_of(MCInstrDesc.operands(), HasMemoryOperand)) {
     Error = "has memory operands";
     return true;
   }
   return false;
 }
 
-static llvm::Error makeError(llvm::Twine Msg) {
-  return llvm::make_error<llvm::StringError>(Msg,
-                                             llvm::inconvertibleErrorCode());
-}
-
 LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
 
 InstructionBenchmark::ModeE LatencyBenchmarkRunner::getMode() const {
   return InstructionBenchmark::Latency;
 }
 
-llvm::Expected<BenchmarkConfiguration>
-LatencyBenchmarkRunner::createConfiguration(RegisterAliasingTrackerCache &RATC,
-                                            unsigned Opcode,
-                                            llvm::raw_ostream &Info) const {
-  BenchmarkConfiguration Configuration;
-  std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
+llvm::Expected<std::vector<BenchmarkConfiguration>>
+LatencyBenchmarkRunner::createConfigurations(RegisterAliasingTrackerCache &RATC,
+                                             unsigned Opcode) const {
   const llvm::MCInstrDesc &MCInstrDesc = MCInstrInfo.get(Opcode);
   const Instruction ThisInstruction(MCInstrDesc, RATC);
 
   std::string Error;
   if (IsInfeasible(ThisInstruction, Error))
-    return makeError(llvm::Twine("Infeasible : ").concat(Error));
+    return llvm::make_error<llvm::StringError>(
+        llvm::Twine("Infeasible : ").concat(Error),
+        llvm::inconvertibleErrorCode());
 
+  BenchmarkConfiguration Conf;
   const AliasingConfigurations SelfAliasing(ThisInstruction, ThisInstruction);
   if (!SelfAliasing.empty()) {
     if (!SelfAliasing.hasImplicitAliasing()) {
-      Info << "explicit self cycles, selecting one aliasing configuration.\n";
+      Conf.Info = "explicit self cycles, selecting one aliasing Conf.";
       setRandomAliasing(SelfAliasing);
     } else {
-      Info << "implicit Self cycles, picking random values.\n";
+      Conf.Info = "implicit Self cycles, picking random values.";
     }
-    Snippet.push_back(randomizeUnsetVariablesAndBuild(ThisInstruction));
-    return Configuration;
+    Conf.Snippet = {randomizeUnsetVariablesAndBuild(ThisInstruction)};
+    return std::vector<BenchmarkConfiguration>{Conf};
   }
 
   // Let's try to create a dependency through another opcode.
   std::vector<unsigned> Opcodes;
   Opcodes.resize(MCInstrInfo.getNumOpcodes());
   std::iota(Opcodes.begin(), Opcodes.end(), 0U);
   std::shuffle(Opcodes.begin(), Opcodes.end(), randomGenerator());
   for (const unsigned OtherOpcode : Opcodes) {
     clearVariableAssignments(ThisInstruction);
     if (OtherOpcode == Opcode)
       continue;
     const Instruction OtherInstruction(MCInstrInfo.get(OtherOpcode), RATC);
     if (IsInfeasible(OtherInstruction, Error))
       continue;
     const AliasingConfigurations Forward(ThisInstruction, OtherInstruction);
     const AliasingConfigurations Back(OtherInstruction, ThisInstruction);
     if (Forward.empty() || Back.empty())
       continue;
     setRandomAliasing(Forward);
     setRandomAliasing(Back);
-    Info << "creating cycle through " << MCInstrInfo.getName(OtherOpcode)
-         << ".\n";
-    Snippet.push_back(randomizeUnsetVariablesAndBuild(ThisInstruction));
-    Snippet.push_back(randomizeUnsetVariablesAndBuild(OtherInstruction));
-    return Configuration;
+    Conf.Info = llvm::Twine("creating cycle through ")
+                    .concat(MCInstrInfo.getName(OtherOpcode))
+                    .concat(".")
+                    .str();
+    Conf.Snippet.push_back(randomizeUnsetVariablesAndBuild(ThisInstruction));
+    Conf.Snippet.push_back(randomizeUnsetVariablesAndBuild(OtherInstruction));
+    return std::vector<BenchmarkConfiguration>{Conf};
   }
 
-  return makeError(
-      "Infeasible : Didn't find any scheme to make the instruction serial\n");
+  return llvm::make_error<llvm::StringError>(
+      "Infeasible : Didn't find any scheme to make the instruction serial",
+      llvm::inconvertibleErrorCode());
 }
 
 std::vector<BenchmarkMeasure>
 LatencyBenchmarkRunner::runMeasurements(const ExecutableFunction &Function,
                                         const unsigned NumRepetitions) const {
   // Cycle measurements include some overhead from the kernel. Repeat the
   // measure several times and take the minimum value.
   constexpr const int NumMeasurements = 30;

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

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

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

 }
 
 static void remove(llvm::BitVector &a, const llvm::BitVector &b) {
   assert(a.size() == b.size());
   for (auto I : b.set_bits())
     a.reset(I);
 }
 
-static llvm::Error makeError(llvm::Twine Msg) {
-  return llvm::make_error<llvm::StringError>(Msg,
-                                             llvm::inconvertibleErrorCode());
-}
-
 UopsBenchmarkRunner::~UopsBenchmarkRunner() = default;
 
 InstructionBenchmark::ModeE UopsBenchmarkRunner::getMode() const {
   return InstructionBenchmark::Uops;
 }
 
-llvm::Expected<BenchmarkConfiguration>
-UopsBenchmarkRunner::createConfiguration(RegisterAliasingTrackerCache &RATC,
-                                         unsigned Opcode,
-                                         llvm::raw_ostream &Info) const {
-  BenchmarkConfiguration Configuration;
-  std::vector<llvm::MCInst> &Snippet = Configuration.Snippet;
+llvm::Expected<std::vector<BenchmarkConfiguration>>
+UopsBenchmarkRunner::createConfigurations(RegisterAliasingTrackerCache &RATC,
+                                          unsigned Opcode) const {
   const llvm::MCInstrDesc &MCInstrDesc = MCInstrInfo.get(Opcode);
   const Instruction Instruction(MCInstrDesc, RATC);
 
   std::string Error;
-  if (isInfeasible(Instruction, Error)) {
-    llvm::report_fatal_error(llvm::Twine("Infeasible : ").concat(Error));
-  }
+  if (isInfeasible(Instruction, Error))
+    return llvm::make_error<llvm::StringError>(
+        llvm::Twine("Infeasible : ").concat(Error),
+        llvm::inconvertibleErrorCode());
 
+  BenchmarkConfiguration Conf;
   const AliasingConfigurations SelfAliasing(Instruction, Instruction);
   if (SelfAliasing.empty()) {
-    Info << "instruction is parallel, repeating a random one.\n";
-    Snippet.push_back(randomizeUnsetVariablesAndBuild(Instruction));
-    return Configuration;
+    Conf.Info = "instruction is parallel, repeating a random one.";
+    Conf.Snippet = {randomizeUnsetVariablesAndBuild(Instruction)};
+    return std::vector<BenchmarkConfiguration>{Conf};
   }
   if (SelfAliasing.hasImplicitAliasing()) {
-    Info << "instruction is serial, repeating a random one.\n";
-    Snippet.push_back(randomizeUnsetVariablesAndBuild(Instruction));
-    return Configuration;
+    Conf.Info = "instruction is serial, repeating a random one.";
+    Conf.Snippet = {randomizeUnsetVariablesAndBuild(Instruction)};
+    return std::vector<BenchmarkConfiguration>{Conf};
   }
   const auto TiedVariables = getTiedVariables(Instruction);
   if (!TiedVariables.empty()) {
-    if (TiedVariables.size() > 1) {
-      Info << "Not yet implemented, don't know how to handle several tied "
-              "variables\n";
-      return makeError("Infeasible : don't know how to handle several tied "
-                       "variables");
-    }
-    Info << "instruction has tied variables using static renaming.\n";
+    if (TiedVariables.size() > 1)
+      return llvm::make_error<llvm::StringError>(
+          "Infeasible : don't know how to handle several tied variables",
+          llvm::inconvertibleErrorCode());
+    Conf.Info = "instruction has tied variables using static renaming.";
     Variable *Var = TiedVariables.front();
     assert(Var);
     assert(!Var->TiedOperands.empty());
     const Operand &Operand = *Var->TiedOperands.front();
     assert(Operand.Tracker);
     for (const llvm::MCPhysReg Reg : Operand.Tracker->sourceBits().set_bits()) {
       clearVariableAssignments(Instruction);
       Var->AssignedValue = llvm::MCOperand::createReg(Reg);
-      Snippet.push_back(randomizeUnsetVariablesAndBuild(Instruction));
+      Conf.Snippet.push_back(randomizeUnsetVariablesAndBuild(Instruction));
     }
-    return Configuration;
+    return std::vector<BenchmarkConfiguration>{Conf};
   }
   // No tied variables, we pick random values for defs.
   llvm::BitVector Defs(MCRegisterInfo.getNumRegs());
   for (const auto &Op : Instruction.Operands) {
     if (Op.Tracker && Op.IsExplicit && Op.IsDef) {
       assert(Op.Var);
       auto PossibleRegisters = Op.Tracker->sourceBits();
       remove(PossibleRegisters, RATC.reservedRegisters());
if (Op.Tracker && Op.IsExplicit && !Op.IsDef) {
       auto PossibleRegisters = Op.Tracker->sourceBits();
       remove(PossibleRegisters, RATC.reservedRegisters());
       remove(PossibleRegisters, DefAliases);
       assert(PossibleRegisters.any() && "No register left to choose from");
       const auto RandomReg = randomBit(PossibleRegisters);
       Op.Var->AssignedValue = llvm::MCOperand::createReg(RandomReg);
     }
   }
-  Info
-      << "instruction has no tied variables picking Uses different from defs\n";
-  Snippet.push_back(randomizeUnsetVariablesAndBuild(Instruction));
-  return Configuration;
+  Conf.Info =
+      "instruction has no tied variables picking Uses different from defs";
+  Conf.Snippet = {randomizeUnsetVariablesAndBuild(Instruction)};
+  return std::vector<BenchmarkConfiguration>{Conf};
 }
 
 std::vector<BenchmarkMeasure>
 UopsBenchmarkRunner::runMeasurements(const ExecutableFunction &Function,
                                      const unsigned NumRepetitions) const {
   const auto &SchedModel = State.getSubtargetInfo().getSchedModel();
 
   std::vector<BenchmarkMeasure> Result;

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

void benchmarkMain() {
 
   if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");
 
   // Write to standard output if file is not set.
   if (BenchmarkFile.empty())
     BenchmarkFile = "-";
 
-  ExitOnErr(
-      Runner->run(GetOpcodeOrDie(State.getInstrInfo()), Filter, NumRepetitions)
-          .writeYaml(getBenchmarkResultContext(State), BenchmarkFile));
+  const BenchmarkResultContext Context = getBenchmarkResultContext(State);
+  std::vector<InstructionBenchmark> Results = ExitOnErr(Runner->run(
+      GetOpcodeOrDie(State.getInstrInfo()), Filter, NumRepetitions));
+  for (InstructionBenchmark &Result : Results)
+    Result.writeYaml(Context, BenchmarkFile);
+
   exegesis::pfm::pfmTerminate();
 }
 
 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
 // if OutputFilename is non-empty.
 template <typename Pass>
 static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
                              const std::string &OutputFilename) {