[llvm-exegesis] Make possible to execute snippets without perf counters

[kpdev42]

Summary

Performance counters may be unavailable due to various reasons (such as
access restriction via sysctl properties or the CPU model being unknown
to libpfm). On the other hand, for debugging llvm-exegesis itself it is
still useful to be able to run generated code snippets to ensure that
the snippet does not crash at run time.

The --use-dummy-perf-counters command line option makes llvm-exegesis
behave just as usual except for using fake event counts instead of asking
the kernel for actual values.

~~

Huawei RRI, OS Lab

[courbet]

Thanks. In principle that sounds goods, my only real remark is about what flags we use to communicate that intent to the tool.

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

129–132

I think you can add something about not using actual perf counters if that's waht the user wants:

"If you are debugging and you don't want to actually read performance counters, use --use-dummy-perf-events

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

137–140

I think this should be its own separate flag. This is only really used in main to parameterize how to measure, but we're still "measuring" stuff.

[kpdev42]

Address review notes. Change patch's description accordingly

[kpdev42]

Fixed running with LLVM_ENABLE_LIBPFM=OFF and updated the text of one more error message

[kpdev42]

Updated after D146302 and rebased

[kpdev42]

Fix test

llvm/test/tools/llvm-exegesis/X86/latency/dummy-counters.test

+# RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mode=latency -opcode-name=LEA64r --use-dummy-perf-counters | FileCheck %s
+# TODO Support non-Linux systems
+# REQUIRES: exegesis-can-execute-x86_64, system-linux
+
+CHECK:      ---
+CHECK-NEXT: mode: latency
+CHECK-NEXT: key:
+CHECK-NEXT:   instructions:
+CHECK-NEXT:     LEA64r
+# 'measurements' field should not contain misleading values
+CHECK:      measurements:    []
+CHECK:      assembled_snippet: {{[A-Z0-9]+}}{{$}}

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

 
 // An object to initialize LLVM and prepare objects needed to run the
 // measurements.
 class LLVMState {
 public:
   // Factory function.
   // If `Triple` is empty, uses the host triple.
   // If `CpuName` is empty, uses the host CPU.
-  // `Features` is intended for tests.
+  // If `UseDummyPerfCounters` is set, does not query the kernel
+  // for event counts.
+  // `UseDummyPerfCounters` and `Features` are intended for tests.
   static Expected<LLVMState> Create(std::string TripleName, std::string CpuName,
-                                    StringRef Features = "");
+                                    StringRef Features = "",
+                                    bool UseDummyPerfCounters = false);
 
   const TargetMachine &getTargetMachine() const { return *TheTargetMachine; }
   std::unique_ptr<LLVMTargetMachine> createTargetMachine() const;
 
   const ExegesisTarget &getExegesisTarget() const { return *TheExegesisTarget; }
 
   bool canAssemble(const MCInst &mc_inst) const;
 

 private:
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
   createOpcodeNameToOpcodeIdxMapping() const;
 
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
   createRegNameToRegNoMapping() const;
 
   LLVMState(std::unique_ptr<const TargetMachine> TM, const ExegesisTarget *ET,
-            StringRef CpuName);
+            const PfmCountersInfo *PCI);
 
   const ExegesisTarget *TheExegesisTarget;
   std::unique_ptr<const TargetMachine> TheTargetMachine;
   std::unique_ptr<const RegisterAliasingTrackerCache> RATC;
   std::unique_ptr<const InstructionsCache> IC;
   const PfmCountersInfo *PfmCounters;
   std::unique_ptr<const DenseMap<StringRef, unsigned>>
       OpcodeNameToOpcodeIdxMapping;
   std::unique_ptr<const DenseMap<StringRef, unsigned>> RegNameToRegNoMapping;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_LLVMSTATE_H

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

 #include "llvm/Target/TargetOptions.h"
 #include "llvm/TargetParser/Host.h"
 
 namespace llvm {
 namespace exegesis {
 
 Expected<LLVMState> LLVMState::Create(std::string TripleName,
                                       std::string CpuName,
-                                      const StringRef Features) {
+                                      const StringRef Features,
+                                      bool UseDummyPerfCounters) {
   if (TripleName.empty())
     TripleName = Triple::normalize(sys::getDefaultTargetTriple());
 
   Triple TheTriple(TripleName);
 
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget =
Expected<LLVMState> LLVMState::Create(std::string TripleName,
   const ExegesisTarget *ET =
       TripleName.empty() ? &ExegesisTarget::getDefault()
                          : ExegesisTarget::lookup(TM->getTargetTriple());
   if (!ET) {
     return llvm::make_error<llvm::StringError>(
         "no Exegesis target for triple " + TripleName,
         llvm::inconvertibleErrorCode());
   }
-  return LLVMState(std::move(TM), ET, CpuName);
+  const PfmCountersInfo &PCI = UseDummyPerfCounters
+                                   ? ET->getDummyPfmCounters()
+                                   : ET->getPfmCounters(CpuName);
+  return LLVMState(std::move(TM), ET, &PCI);
 }
 
 LLVMState::LLVMState(std::unique_ptr<const TargetMachine> TM,
-                     const ExegesisTarget *ET, const StringRef CpuName)
-    : TheExegesisTarget(ET), TheTargetMachine(std::move(TM)),
+                     const ExegesisTarget *ET, const PfmCountersInfo *PCI)
+    : TheExegesisTarget(ET), TheTargetMachine(std::move(TM)), PfmCounters(PCI),
       OpcodeNameToOpcodeIdxMapping(createOpcodeNameToOpcodeIdxMapping()),
       RegNameToRegNoMapping(createRegNameToRegNoMapping()) {
-  PfmCounters = &TheExegesisTarget->getPfmCounters(CpuName);
-
   BitVector ReservedRegs = getFunctionReservedRegs(getTargetMachine());
   for (const unsigned Reg : TheExegesisTarget->getUnavailableRegisters())
     ReservedRegs.set(Reg);
   RATC.reset(
       new RegisterAliasingTrackerCache(getRegInfo(), std::move(ReservedRegs)));
   IC.reset(new InstructionsCache(getInstrInfo(), getRATC()));
 }
 

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

 // Returns true on error.
 bool pfmInitialize();
 void pfmTerminate();
 
 // Retrieves the encoding for the event described by pfm_event_string.
 // NOTE: pfm_initialize() must be called before creating PerfEvent objects.
 class PerfEvent {
 public:
+  // Dummy event that does not require access to counters (for tests).
+  static const char *const DummyEventString;
+
   // http://perfmon2.sourceforge.net/manv4/libpfm.html
   // Events are expressed as strings. e.g. "INSTRUCTION_RETIRED"
   explicit PerfEvent(StringRef PfmEventString);
 
   PerfEvent(const PerfEvent &) = delete;
   PerfEvent(PerfEvent &&other);
   ~PerfEvent();
 
public:
   // e.g. "snb_ep::INSTRUCTION_RETIRED:e=0:i=0:c=0:t=0:u=1:k=0:mg=0:mh=1"
   StringRef getPfmEventString() const;
 
 protected:
   PerfEvent() = default;
   std::string EventString;
   std::string FullQualifiedEventString;
   perf_event_attr *Attr;
+
+private:
+  void initRealEvent(StringRef PfmEventString);
 };
 
 // Uses a valid PerfEvent to configure the Kernel so we can measure the
 // underlying event.
 class Counter {
 public:
   // event: the PerfEvent to measure.
   explicit Counter(PerfEvent &&event);
public:
 
   virtual int numValues() const;
 
 protected:
   PerfEvent Event;
 #ifdef HAVE_LIBPFM
   int FileDescriptor = -1;
 #endif
+  bool IsDummyEvent;
+
+private:
+  void initRealEvent(const PerfEvent &E);
 };
 
 } // namespace pfm
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_PERFHELPER_H

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

 }
 
 void pfmTerminate() {
 #ifdef HAVE_LIBPFM
   pfm_terminate();
 #endif
 }
 
+// Performance counters may be unavailable for a number of reasons (such as
+// kernel.perf_event_paranoid restriction or CPU being unknown to libpfm).
+//
+// Dummy event can be specified to skip interaction with real performance
+// counters while still passing control to the generated code snippet.
+const char *const PerfEvent::DummyEventString = "not-really-an-event";
+
 PerfEvent::~PerfEvent() {
 #ifdef HAVE_LIBPFM
   delete Attr;
   ;
 #endif
 }
 
 PerfEvent::PerfEvent(PerfEvent &&Other)
     : EventString(std::move(Other.EventString)),
       FullQualifiedEventString(std::move(Other.FullQualifiedEventString)),
       Attr(Other.Attr) {
   Other.Attr = nullptr;
 }
 
 PerfEvent::PerfEvent(StringRef PfmEventString)
     : EventString(PfmEventString.str()), Attr(nullptr) {
+  if (PfmEventString != DummyEventString)
+    initRealEvent(PfmEventString);
+  else
+    FullQualifiedEventString = PfmEventString;
+}
+
+void PerfEvent::initRealEvent(StringRef PfmEventString) {
 #ifdef HAVE_LIBPFM
   char *Fstr = nullptr;
   pfm_perf_encode_arg_t Arg = {};
   Attr = new perf_event_attr();
   Arg.attr = Attr;
   Arg.fstr = &Fstr;
   Arg.size = sizeof(pfm_perf_encode_arg_t);
   const int Result = pfm_get_os_event_encoding(EventString.c_str(), PFM_PLM3,

 bool PerfEvent::valid() const { return !FullQualifiedEventString.empty(); }
 
 const perf_event_attr *PerfEvent::attribute() const { return Attr; }
 
 StringRef PerfEvent::getPfmEventString() const {
   return FullQualifiedEventString;
 }
 
-#ifdef HAVE_LIBPFM
 Counter::Counter(PerfEvent &&E) : Event(std::move(E)){
   assert(Event.valid());
+  IsDummyEvent = Event.name() == PerfEvent::DummyEventString;
+  if (!IsDummyEvent)
+    initRealEvent(E);
+}
+
+#ifdef HAVE_LIBPFM
+void Counter::initRealEvent(const PerfEvent &E) {
   const pid_t Pid = 0;    // measure current process/thread.
   const int Cpu = -1;     // measure any processor.
   const int GroupFd = -1; // no grouping of counters.
   const uint32_t Flags = 0;
   perf_event_attr AttrCopy = *Event.attribute();
   FileDescriptor = perf_event_open(&AttrCopy, Pid, Cpu, GroupFd, Flags);
   if (FileDescriptor == -1) {
     errs() << "Unable to open event. ERRNO: " << strerror(errno)
            << ". Make sure your kernel allows user "
               "space perf monitoring.\nYou may want to try:\n$ sudo sh "
-              "-c 'echo -1 > /proc/sys/kernel/perf_event_paranoid'\n";
+              "-c 'echo -1 > /proc/sys/kernel/perf_event_paranoid'.\n"
+           << "If you are debugging and just want to execute the snippet "
+              "without actually reading performance counters, "
+              "pass --use-dummy-perf-counters command line option.\n";
   }
   assert(FileDescriptor != -1 && "Unable to open event");
 }
 
-Counter::~Counter() { close(FileDescriptor); }
+Counter::~Counter() {
+  if (!IsDummyEvent)
+    close(FileDescriptor);
+}
 
-void Counter::start() { ioctl(FileDescriptor, PERF_EVENT_IOC_RESET, 0); }
+void Counter::start() {
+  if (!IsDummyEvent)
+    ioctl(FileDescriptor, PERF_EVENT_IOC_RESET, 0);
+}
 
-void Counter::stop() { ioctl(FileDescriptor, PERF_EVENT_IOC_DISABLE, 0); }
+void Counter::stop() {
+  if (!IsDummyEvent)
+    ioctl(FileDescriptor, PERF_EVENT_IOC_DISABLE, 0);
+}
 
 int64_t Counter::read() const {
   auto ValueOrError = readOrError();
   if (ValueOrError) {
     if (!ValueOrError.get().empty())
       return ValueOrError.get()[0];
     errs() << "Counter has no reading\n";
   } else
     errs() << ValueOrError.takeError() << "\n";
   return -1;
 }
 
 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 Counter::readOrError(StringRef /*unused*/) const {
   int64_t Count = 0;
+  if (!IsDummyEvent) {
     ssize_t ReadSize = ::read(FileDescriptor, &Count, sizeof(Count));
     if (ReadSize != sizeof(Count))
       return llvm::make_error<llvm::StringError>("Failed to read event counter",
                                                  llvm::errc::io_error);
+  } else {
+    Count = 42;
+  }
+
   llvm::SmallVector<int64_t, 4> Result;
   Result.push_back(Count);
   return Result;
 }
 
 int Counter::numValues() const { return 1; }
 #else
 
-Counter::Counter(PerfEvent &&Event) : Event(std::move(Event)) {}
+void Counter::initRealEvent(const PerfEvent &) {}
 
 Counter::~Counter() = default;
 
 void Counter::start() {}
 
 void Counter::stop() {}
 
 int64_t Counter::read() const { return 42; }
 
 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 Counter::readOrError(StringRef /*unused*/) const {
+  if (IsDummyEvent) {
+    llvm::SmallVector<int64_t, 4> Result;
+    Result.push_back(42);
+    return Result;
+  }
   return llvm::make_error<llvm::StringError>("Not implemented",
                                              llvm::errc::io_error);
 }
 
 int Counter::numValues() const { return 1; }
 
 #endif
 
 } // namespace pfm
 } // namespace exegesis
 } // namespace llvm

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

struct IssueCounter {
     // The name of the ProcResource that this counter measures.
     const char *ProcResName;
   };
   // An optional list of IssueCounters.
   const IssueCounter *IssueCounters;
   unsigned NumIssueCounters;
 
   static const PfmCountersInfo Default;
+  static const PfmCountersInfo Dummy;
 };
 
 struct CpuAndPfmCounters {
   const char *CpuName;
   const PfmCountersInfo *PCI;
   bool operator<(StringRef S) const { return StringRef(CpuName) < S; }
 };
 
public:
   static void registerTarget(ExegesisTarget *T);
 
   virtual ~ExegesisTarget();
 
   // Returns the Pfm counters for the given CPU (or the default if no pfm
   // counters are defined for this CPU).
   const PfmCountersInfo &getPfmCounters(StringRef CpuName) const;
 
+  // Returns dummy Pfm counters which can be used to execute generated snippet
+  // without access to performance counters.
+  const PfmCountersInfo &getDummyPfmCounters() const;
+
   // Saves the CPU state that needs to be preserved when running a benchmark,
   // and returns and RAII object that restores the state on destruction.
   // By default no state is preserved.
   struct SavedState {
     virtual ~SavedState();
   };
   virtual std::unique_ptr<SavedState> withSavedState() const {
     return std::make_unique<SavedState>();

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

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "Target.h"
 
 #include "LatencyBenchmarkRunner.h"
 #include "ParallelSnippetGenerator.h"
+#include "PerfHelper.h"
 #include "SerialSnippetGenerator.h"
 #include "UopsBenchmarkRunner.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace exegesis {
 
if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure &&
       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."));
+                  "can pass --benchmark-phase=... to skip the actual "
+                  "benchmarking or --use-dummy-perf-counters to not query "
+                  "the kernel for real event counts."));
     }
     return createLatencyBenchmarkRunner(State, Mode, BenchmarkPhaseSelector,
                                         ResultAggMode);
   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.");
+          "counters. You can pass --benchmark-phase=... to skip the actual "
+          "benchmarking or --use-dummy-perf-counters to not query the kernel "
+          "for real event counts.");
     return createUopsBenchmarkRunner(State, BenchmarkPhaseSelector,
                                      ResultAggMode);
   }
   return nullptr;
 }
 
 std::unique_ptr<SnippetGenerator> ExegesisTarget::createSerialSnippetGenerator(
     const LLVMState &State, const SnippetGenerator::Options &Opts) const {
std::unique_ptr<BenchmarkRunner> ExegesisTarget::createUopsBenchmarkRunner(
     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};
+const PfmCountersInfo PfmCountersInfo::Dummy = {
+    pfm::PerfEvent::DummyEventString, pfm::PerfEvent::DummyEventString, nullptr,
+    0u};
 
 const PfmCountersInfo &ExegesisTarget::getPfmCounters(StringRef CpuName) const {
   assert(llvm::is_sorted(
              CpuPfmCounters,
              [](const CpuAndPfmCounters &LHS, const CpuAndPfmCounters &RHS) {
                return strcmp(LHS.CpuName, RHS.CpuName) < 0;
              }) &&
          "CpuPfmCounters table is not sorted");
 
   // Find entry
   auto Found = llvm::lower_bound(CpuPfmCounters, CpuName);
   if (Found == CpuPfmCounters.end() || StringRef(Found->CpuName) != CpuName) {
     // Use the default.
     if (!CpuPfmCounters.empty() && CpuPfmCounters.begin()->CpuName[0] == '\0') {
       Found = CpuPfmCounters.begin(); // The target specifies a default.
     } else {
       return PfmCountersInfo::Default; // No default for the target.
     }
   }
   assert(Found->PCI && "Missing counters");
   return *Found->PCI;
 }
 
+const PfmCountersInfo &ExegesisTarget::getDummyPfmCounters() const {
+  return PfmCountersInfo::Dummy;
+}
+
 ExegesisTarget::SavedState::~SavedState() {} // anchor.
 
 namespace {
 
 // Default implementation.
 class ExegesisDefaultTarget : public ExegesisTarget {
 public:
   ExegesisDefaultTarget() : ExegesisTarget({}) {}

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

cl::values(
                    "prepare-and-assemble-snippet",
                    "Same as prepare-snippet, but also dumps an excerpt of the "
                    "sequence (hex encoded)"),
         clEnumValN(exegesis::BenchmarkPhaseSelectorE::AssembleMeasuredCode,
                    "assemble-measured-code",
                    "Same as prepare-and-assemble-snippet, but also creates the "
                    "full sequence "
                    "that can be dumped to a file using --dump-object-to-disk"),
         clEnumValN(
             exegesis::BenchmarkPhaseSelectorE::Measure, "measure",
             "Same as prepare-measured-code, but also runs the measurement "
             "(default)")),
     cl::init(exegesis::BenchmarkPhaseSelectorE::Measure));
 
+static cl::opt<bool>
+    UseDummyPerfCounters("use-dummy-perf-counters",
+                         cl::desc("Do not read real performance counters, use "
+                                  "dummy values (for testing)"),
+                         cl::cat(BenchmarkOptions), cl::init(false));
+
 static cl::opt<unsigned>
     NumRepetitions("num-repetitions",
                    cl::desc("number of time to repeat the asm snippet"),
                    cl::cat(BenchmarkOptions), cl::init(10000));
 
 static cl::opt<unsigned>
     LoopBodySize("loop-body-size",
                  cl::desc("when repeating the instruction snippet by looping "
if (RepetitionMode == Benchmark::RepetitionModeE::AggregateMin) {
               std::min(Measurement.PerInstructionValue,
                        NewMeasurement.PerInstructionValue);
           Measurement.PerSnippetValue = std::min(
               Measurement.PerSnippetValue, NewMeasurement.PerSnippetValue);
         }
       }
     }
 
+    // With dummy counters, measurements are rather meaningless,
+    // so drop them altogether.
+    if (UseDummyPerfCounters)
+      Result.Measurements.clear();
+
     ExitOnFileError(BenchmarkFile, Result.writeYamlTo(State, Ostr));
   }
 }
 
 void benchmarkMain() {
-  if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure) {
+  if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure &&
+      !UseDummyPerfCounters) {
 #ifndef HAVE_LIBPFM
     ExitWithError(
-        "benchmarking unavailable, LLVM was built without libpfm. You can pass "
-        "--skip-measurements to skip the actual benchmarking.");
+        "benchmarking unavailable, LLVM was built without libpfm. You can "
+        "pass --benchmark-phase=... to skip the actual benchmarking or "
+        "--use-dummy-perf-counters to not query the kernel for real event "
+        "counts.");
 #else
     if (exegesis::pfm::pfmInitialize())
       ExitWithError("cannot initialize libpfm");
 #endif
   }
 
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
   InitializeAllExegesisTargets();
 
-  const LLVMState State = ExitOnErr(LLVMState::Create(TripleName, MCPU));
+  const LLVMState State =
+      ExitOnErr(LLVMState::Create(TripleName, MCPU, "", UseDummyPerfCounters));
 
   // Preliminary check to ensure features needed for requested
   // benchmark mode are present on target CPU and/or OS.
   if (BenchmarkPhaseSelector == BenchmarkPhaseSelectorE::Measure)
     ExitOnErr(State.getExegesisTarget().checkFeatureSupport());
 
   const std::unique_ptr<BenchmarkRunner> Runner =
       ExitOnErr(State.getExegesisTarget().createBenchmarkRunner(