[llvm-exegesis] Delegate the decision of cycle counter name to the target

[john.brawn]

Summary

Currently the cycle counter is taken from the subtarget schedule model, which isn't any use if the subtarget doesn't have one. Delegate the decision to the target benchmark runner, as it may know better what to do in that case, with the default being the current behaviour.

[courbet]

Just two minor comments.

tools/llvm-exegesis/lib/Latency.cpp

98 ↗

(On Diff #153534)

I think you can remove this fixme now.

117 ↗

(On Diff #153534)

You need to keep the test for nullity, just in case the implementation returns nullptr.

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

private:
   llvm::Error isInfeasible(const llvm::MCInstrDesc &MCInstrDesc) const;
 
   llvm::Expected<SnippetPrototype> generateTwoInstructionPrototype(
       const Instruction &Instr) const;
 
   std::vector<BenchmarkMeasure>
   runMeasurements(const ExecutableFunction &EF,
                   const unsigned NumRepetitions) const override;
+
+  virtual const char *getCounterName() const;
 };
 
 } // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LATENCY_H

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

LatencyBenchmarkRunner::generatePrototype(unsigned Opcode) const {
   if (auto SelfAliasingPrototype = generateSelfAliasingPrototype(Instr))
     return SelfAliasingPrototype;
   else
     llvm::consumeError(SelfAliasingPrototype.takeError());
   // No self aliasing, trying to create a dependency through another opcode.
   return generateTwoInstructionPrototype(Instr);
 }
 
+const char *LatencyBenchmarkRunner::getCounterName() const {
+  if (!State.getSubtargetInfo().getSchedModel().hasExtraProcessorInfo())
+    llvm::report_fatal_error("sched model is missing extra processor info!");
+  const char *CounterName = State.getSubtargetInfo()
+                                .getSchedModel()
+                                .getExtraProcessorInfo()
+                                .PfmCounters.CycleCounter;
+  if (!CounterName)
+    llvm::report_fatal_error("sched model does not define a cycle counter");
+  return CounterName;
+}
+
 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;
   int64_t MinLatency = std::numeric_limits<int64_t>::max();
-  const char *CounterName = State.getSubtargetInfo()
-                                .getSchedModel()
-                                .getExtraProcessorInfo()
-                                .PfmCounters.CycleCounter;
+  const char *CounterName = getCounterName();
   if (!CounterName)
-    llvm::report_fatal_error("sched model does not define a cycle counter");
+    llvm::report_fatal_error("could not determine cycle counter name");
   const pfm::PerfEvent CyclesPerfEvent(CounterName);
   if (!CyclesPerfEvent.valid())
     llvm::report_fatal_error("invalid perf event");
   for (size_t I = 0; I < NumMeasurements; ++I) {
     pfm::Counter Counter(CyclesPerfEvent);
     Counter.start();
     Function();
     Counter.stop();
     const int64_t Value = Counter.read();
     if (Value < MinLatency)
       MinLatency = Value;
   }
   return {{"latency", static_cast<double>(MinLatency) / NumRepetitions, ""}};
 }
 
 } // namespace exegesis

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

#endif
   // Ignore instructions without a sched class if -ignore-invalid-sched-class is
   // passed.
   if (IgnoreInvalidSchedClass &&
       State.getInstrInfo().get(Opcode).getSchedClass() == 0) {
     llvm::errs() << "ignoring instruction without sched class\n";
     return;
   }
 
-  // FIXME: Do not require SchedModel for latency.
-  if (!State.getSubtargetInfo().getSchedModel().hasExtraProcessorInfo())
-    llvm::report_fatal_error("sched model is missing extra processor info!");
-
   const std::unique_ptr<BenchmarkRunner> Runner =
       State.getExegesisTarget().createBenchmarkRunner(BenchmarkMode, State);
   if (!Runner) {
     llvm::report_fatal_error("cannot create benchmark runner");
   }
 
   if (NumRepetitions == 0)
     llvm::report_fatal_error("--num-repetitions must be greater than zero");