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
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)
+ [llvm_exegesis_exe, '-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', '-snippets-file', '/dev/null'], stdout=quiet, stderr=quiet)
except OSError:
print('could not exec llvm-exegesis')
config.unsupported = True
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,
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];
};
#endif // HAVE_LIBPFM
#include <atomic>
+#include <chrono>
#include <cstddef>
#include <cstdint>
#include <limits>
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();
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;
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())
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)
class X86LbrCounter : public pfm::Counter {
public:
+ static llvm::Error checkLbrSupport();
+
explicit X86LbrCounter(pfm::PerfEvent &&Event);
virtual ~X86LbrCounter();
readOrError(StringRef FunctionBytes) const override;
private:
+ llvm::Expected<llvm::SmallVector<int64_t, 4>>
+ doReadCounter(const void *From, const void *To) const;
+
void *MMappedBuffer = nullptr;
};
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 "
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(