Reland rG4fcd1a8e6528:[llvm-exegesis] Add option to check the hardware support for a given feature before benchmarking.

This is mostly for the benefit of the LBR latency mode.
Right now, it performs no checking. If this is run on non-supported hardware, it will produce all zeroes for latency.

      Differential Revision: https://reviews.llvm.org/D85254

New change: Updated lit.local.cfg to use pass the right argument to llvm-exegesis to actually request the LBR mode.

Differential Revision: https://reviews.llvm.org/D88670

llvm/test/tools/llvm-exegesis/X86/lbr/lit.local.cfg

@@ -10,7 +10,7 @@ elif not ('x86_64' in config.root.host_triple):
     config.unsupported = True
     
 else:    
-    # We need libpfm to be installed and the host to be at least skylake.
+    # We need libpfm to be installed and the host to be support LBR format with cycles.
     llvm_exegesis_exe = lit.util.which('llvm-exegesis', config.llvm_tools_dir)
     if not llvm_exegesis_exe:
         print('llvm-exegesis not found')
@@ -18,14 +18,10 @@ else:
     else:
       try:
           with open(os.devnull, 'w') as quiet:
-              check_llvm_exegesis_uops_result = subprocess.call(
-                [llvm_exegesis_exe, '-allowed-host-cpu', 'skylake', '-allowed-host-cpu', 'skylake-avx512', '-mode', 'uops', '-snippets-file', '/dev/null'], stdout=quiet, stderr=quiet)
               check_llvm_exegesis_latency_result = subprocess.call(
-                [llvm_exegesis_exe, '-allowed-host-cpu', 'skylake', '-allowed-host-cpu', 'skylake-avx512', '-mode', 'latency', '-snippets-file', '/dev/null'], stdout=quiet, stderr=quiet)
+                [llvm_exegesis_exe, '-mode', 'latency', '-x86-lbr-sample-period', '123', '-repetition-mode', 'loop', '-snippets-file', '/dev/null'], stdout=quiet, stderr=quiet)
       except OSError:
           print('could not exec llvm-exegesis')
           config.unsupported = True
-      if not check_llvm_exegesis_uops_result == 0:
-        config.unsupported = True
       if not check_llvm_exegesis_latency_result == 0:
         config.unsupported = True

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

@@ -142,6 +142,11 @@ public:
     return {&Instr};
   }
 
+  // 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,

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

@@ -674,6 +674,23 @@ private:
     return Arch == Triple::x86_64 || Arch == Triple::x86;
   }
 
+  Error checkFeatureSupport() const override {
+    // LBR is the only feature we conditionally support now.
+    // So if LBR is not requested, then we should be able to run the benchmarks.
+    if (LbrSamplingPeriod == 0)
+      return Error::success();
+
+#if defined(__linux__) && defined(HAVE_LIBPFM) &&                              \
+    defined(LIBPFM_HAS_FIELD_CYCLES)
+    // If the kernel supports it, the hardware still may not have it.
+    return X86LbrCounter::checkLbrSupport();
+#else
+    return llvm::make_error<llvm::StringError>(
+        "LBR not supported on this kernel and/or platform",
+        llvm::errc::not_supported);
+#endif
+  }
+
   static const unsigned kUnavailableRegisters[4];
 };
 

llvm/tools/llvm-exegesis/lib/X86/X86Counter.cpp

@@ -21,6 +21,7 @@
 #endif // HAVE_LIBPFM
 
 #include <atomic>
+#include <chrono>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
@@ -35,6 +36,8 @@
 namespace llvm {
 namespace exegesis {
 
+// Number of entries in the LBR.
+static constexpr int kLbrEntries = 16;
 static constexpr size_t kBufferPages = 8;
 static const size_t kDataBufferSize = kBufferPages * getpagesize();
 
@@ -70,7 +73,6 @@ static void copyDataBuffer(void *MMappedBuffer, char *Buf, uint64_t Tail,
 static llvm::Error parseDataBuffer(const char *DataBuf, size_t DataSize,
                                    const void *From, const void *To,
                                    llvm::SmallVector<int64_t, 4> *CycleArray) {
-  assert(From != nullptr && To != nullptr);
   const char *DataPtr = DataBuf;
   while (DataPtr < DataBuf + DataSize) {
     struct perf_event_header Header;
@@ -149,21 +151,47 @@ void X86LbrCounter::start() {
   ioctl(FileDescriptor, PERF_EVENT_IOC_REFRESH, 1024 /* kMaxPollsPerFd */);
 }
 
+llvm::Error X86LbrCounter::checkLbrSupport() {
+  // Do a sample read and check if the results contain non-zero values.
+
+  X86LbrCounter counter(X86LbrPerfEvent(123));
+  counter.start();
+
+  // Prevent the compiler from unrolling the loop and get rid of all the
+  // branches. We need at least 16 iterations.
+  int Sum = 0;
+  int V = 1;
+
+  volatile int *P = &V;
+  auto TimeLimit =
+      std::chrono::high_resolution_clock::now() + std::chrono::microseconds(5);
+
+  for (int I = 0;
+       I < kLbrEntries || std::chrono::high_resolution_clock::now() < TimeLimit;
+       ++I) {
+    Sum += *P;
+  }
+
+  counter.stop();
+
+  auto ResultOrError = counter.doReadCounter(nullptr, nullptr);
+  if (ResultOrError)
+    if (!ResultOrError.get().empty())
+      // If there is at least one non-zero entry, then LBR is supported.
+      for (const int64_t &Value : ResultOrError.get())
+        if (Value != 0)
+          return Error::success();
+
+  return llvm::make_error<llvm::StringError>(
+      "LBR format with cycles is not suppported on the host.",
+      llvm::errc::not_supported);
+}
+
 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 X86LbrCounter::readOrError(StringRef FunctionBytes) const {
-  // The max number of time-outs/retries before we give up.
-  static constexpr int kMaxTimeouts = 160;
-
   // Disable the event before reading
   ioctl(FileDescriptor, PERF_EVENT_IOC_DISABLE, 0);
 
-  // Parses the LBR buffer and fills CycleArray with the sequence of cycle
-  // counts from the buffer.
-  llvm::SmallVector<int64_t, 4> CycleArray;
-  std::unique_ptr<char[]> DataBuf(new char[kDataBufferSize]);
-  int NumTimeouts = 0;
-  int PollResult = 0;
-
   // Find the boundary of the function so that we could filter the LBRs
   // to keep only the relevant records.
   if (FunctionBytes.empty())
@@ -172,6 +200,21 @@ X86LbrCounter::readOrError(StringRef FunctionBytes) const {
   const void *From = reinterpret_cast<const void *>(FunctionBytes.data());
   const void *To = reinterpret_cast<const void *>(FunctionBytes.data() +
                                                   FunctionBytes.size());
+  return doReadCounter(From, To);
+}
+
+llvm::Expected<llvm::SmallVector<int64_t, 4>>
+X86LbrCounter::doReadCounter(const void *From, const void *To) const {
+  // The max number of time-outs/retries before we give up.
+  static constexpr int kMaxTimeouts = 160;
+
+  // Parses the LBR buffer and fills CycleArray with the sequence of cycle
+  // counts from the buffer.
+  llvm::SmallVector<int64_t, 4> CycleArray;
+  auto DataBuf = std::make_unique<char[]>(kDataBufferSize);
+  int NumTimeouts = 0;
+  int PollResult = 0;
+
   while (PollResult <= 0) {
     PollResult = pollLbrPerfEvent(FileDescriptor);
     if (PollResult > 0)

llvm/tools/llvm-exegesis/lib/X86/X86Counter.h

@@ -33,6 +33,8 @@ public:
 
 class X86LbrCounter : public pfm::Counter {
 public:
+  static llvm::Error checkLbrSupport();
+
   explicit X86LbrCounter(pfm::PerfEvent &&Event);
 
   virtual ~X86LbrCounter();
@@ -43,6 +45,9 @@ public:
   readOrError(StringRef FunctionBytes) const override;
 
 private:
+  llvm::Expected<llvm::SmallVector<int64_t, 4>>
+  doReadCounter(const void *From, const void *To) const;
+
   void *MMappedBuffer = nullptr;
 };
 

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

@@ -160,12 +160,6 @@ static cl::opt<std::string>
                                       cl::desc(""), cl::cat(AnalysisOptions),
                                       cl::init(""));
 
-static cl::list<std::string>
-    AllowedHostCpus("allowed-host-cpu",
-                    cl::desc("If specified, only run the benchmark if the host "
-                             "CPU matches the names"),
-                    cl::cat(Options), cl::ZeroOrMore);
-
 static cl::opt<bool> AnalysisDisplayUnstableOpcodes(
     "analysis-display-unstable-clusters",
     cl::desc("if there is more than one benchmark for an opcode, said "
@@ -302,12 +296,9 @@ void benchmarkMain() {
 
   const LLVMState State(CpuName);
 
-  llvm::StringRef ActualCpu = State.getTargetMachine().getTargetCPU();
-  for (auto Begin = AllowedHostCpus.begin(); Begin != AllowedHostCpus.end();
-       ++Begin) {
-    if (ActualCpu != *Begin)
-      ExitWithError(llvm::Twine("Unexpected host CPU ").concat(ActualCpu));
-  }
+  // Preliminary check to ensure features needed for requested
+  // benchmark mode are present on target CPU and/or OS.
+  ExitOnErr(State.getExegesisTarget().checkFeatureSupport());
 
   const std::unique_ptr<BenchmarkRunner> Runner =
       ExitOnErr(State.getExegesisTarget().createBenchmarkRunner(