to specify at least one of the `-analysis-clusters-output-file=` and
`-analysis-inconsistencies-output-file=`.
-.. option:: -num-repetitions=<Number of repetition>
+.. option:: -num-repetitions=<Number of repetitions>
Specify the number of repetitions of the asm snippet.
Higher values lead to more accurate measurements but lengthen the benchmark.
+.. option:: -max-configs-per-opcode=<value>
+
+ Specify the maximum configurations that can be generated for each opcode.
+ By default this is `1`, meaning that we assume that a single measurement is
+ enough to characterize an opcode. This might not be true of all instructions:
+ for example, the performance characteristics of the LEA instruction on X86
+ depends on the value of assigned registers and immediates. Setting a value of
+ `-max-configs-per-opcode` larger than `1` allows `llvm-exegesis` to explore
+ more configurations to discover if some register or immediate assignments
+ lead to different performance characteristics.
+
+
.. option:: -benchmarks-file=</path/to/file>
File to read (`analysis` mode) or write (`latency`/`uops`/`inverse_throughput`
--- /dev/null
+# RUN: llvm-exegesis -mode=latency -opcode-name=SBB8rr -max-configs-per-opcode=1 | FileCheck -check-prefixes=CHECK,CHECK1 %s
+# RUN: llvm-exegesis -mode=latency -opcode-name=SBB8rr -max-configs-per-opcode=2 | FileCheck -check-prefixes=CHECK,CHECK2 %s
+
+CHECK: ---
+CHECK-NEXT: mode: latency
+CHECK-NEXT: key:
+CHECK-NEXT: instructions:
+CHECK-NEXT: SBB8rr
+CHECK-NEXT: config: ''
+CHECK-NEXT: register_initial_values:
+CHECK-DAG: - '[[REG1:[A-Z0-9]+]]=0x0'
+CHECK-LAST: ...
+
+CHECK1-NOT: SBB8rr
+
+CHECK2: ---
+CHECK2-NEXT: mode: latency
+CHECK2-NEXT: key:
+CHECK2-NEXT: instructions:
+CHECK2-NEXT: SBB8rr
+CHECK2-NEXT: config: ''
+CHECK2-NEXT: register_initial_values:
+CHECK2-DAG: - '[[REG1:[A-Z0-9]+]]=0x0'
+CHECK2-LAST: ...
class LatencySnippetGenerator : public SnippetGenerator {
public:
- LatencySnippetGenerator(const LLVMState &State) : SnippetGenerator(State) {}
+ using SnippetGenerator::SnippetGenerator;
~LatencySnippetGenerator() override;
llvm::Expected<std::vector<CodeTemplate>>
SnippetGeneratorFailure::SnippetGeneratorFailure(const llvm::Twine &S)
: llvm::StringError(S, llvm::inconvertibleErrorCode()) {}
-SnippetGenerator::SnippetGenerator(const LLVMState &State) : State(State) {}
+SnippetGenerator::SnippetGenerator(const LLVMState &State, const Options &Opts)
+ : State(State), Opts(Opts) {}
SnippetGenerator::~SnippetGenerator() = default;
computeRegisterInitialValues(CT.Instructions);
BC.Key.Config = CT.Config;
Output.push_back(std::move(BC));
+ if (Output.size() >= Opts.MaxConfigsPerOpcode)
+ return Output; // Early exit if we exceeded the number of allowed
+ // configs.
}
}
return Output;
// Common code for all benchmark modes.
class SnippetGenerator {
public:
- explicit SnippetGenerator(const LLVMState &State);
+ struct Options {
+ unsigned MaxConfigsPerOpcode = 1;
+ };
+
+ explicit SnippetGenerator(const LLVMState &State, const Options &Opts);
virtual ~SnippetGenerator();
protected:
const LLVMState &State;
+ const Options Opts;
private:
// API to be implemented by subclasses.
FirstTarget = Target;
}
-std::unique_ptr<SnippetGenerator>
-ExegesisTarget::createSnippetGenerator(InstructionBenchmark::ModeE Mode,
- const LLVMState &State) const {
+std::unique_ptr<SnippetGenerator> ExegesisTarget::createSnippetGenerator(
+ InstructionBenchmark::ModeE Mode, const LLVMState &State,
+ const SnippetGenerator::Options &Opts) const {
switch (Mode) {
case InstructionBenchmark::Unknown:
return nullptr;
case InstructionBenchmark::Latency:
- return createLatencySnippetGenerator(State);
+ return createLatencySnippetGenerator(State, Opts);
case InstructionBenchmark::Uops:
case InstructionBenchmark::InverseThroughput:
- return createUopsSnippetGenerator(State);
+ return createUopsSnippetGenerator(State, Opts);
}
return nullptr;
}
return nullptr;
}
-std::unique_ptr<SnippetGenerator>
-ExegesisTarget::createLatencySnippetGenerator(const LLVMState &State) const {
- return std::make_unique<LatencySnippetGenerator>(State);
+std::unique_ptr<SnippetGenerator> ExegesisTarget::createLatencySnippetGenerator(
+ const LLVMState &State, const SnippetGenerator::Options &Opts) const {
+ return std::make_unique<LatencySnippetGenerator>(State, Opts);
}
-std::unique_ptr<SnippetGenerator>
-ExegesisTarget::createUopsSnippetGenerator(const LLVMState &State) const {
- return std::make_unique<UopsSnippetGenerator>(State);
+std::unique_ptr<SnippetGenerator> ExegesisTarget::createUopsSnippetGenerator(
+ const LLVMState &State, const SnippetGenerator::Options &Opts) const {
+ return std::make_unique<UopsSnippetGenerator>(State, Opts);
}
std::unique_ptr<BenchmarkRunner> ExegesisTarget::createLatencyBenchmarkRunner(
// Creates a snippet generator for the given mode.
std::unique_ptr<SnippetGenerator>
createSnippetGenerator(InstructionBenchmark::ModeE Mode,
- const LLVMState &State) const;
+ const LLVMState &State,
+ const SnippetGenerator::Options &Opts) const;
// Creates a benchmark runner for the given mode.
std::unique_ptr<BenchmarkRunner>
createBenchmarkRunner(InstructionBenchmark::ModeE Mode,
// Targets can implement their own snippet generators/benchmarks runners by
// implementing these.
std::unique_ptr<SnippetGenerator> virtual createLatencySnippetGenerator(
- const LLVMState &State) const;
+ const LLVMState &State, const SnippetGenerator::Options &Opts) const;
std::unique_ptr<SnippetGenerator> virtual createUopsSnippetGenerator(
- const LLVMState &State) const;
+ const LLVMState &State, const SnippetGenerator::Options &Opts) const;
std::unique_ptr<BenchmarkRunner> virtual createLatencyBenchmarkRunner(
const LLVMState &State, InstructionBenchmark::ModeE Mode) const;
std::unique_ptr<BenchmarkRunner> virtual createUopsBenchmarkRunner(
class UopsSnippetGenerator : public SnippetGenerator {
public:
- UopsSnippetGenerator(const LLVMState &State) : SnippetGenerator(State) {}
+ using SnippetGenerator::SnippetGenerator;
~UopsSnippetGenerator() override;
llvm::Expected<std::vector<CodeTemplate>>
sizeof(kUnavailableRegisters[0]));
}
- std::unique_ptr<SnippetGenerator>
- createLatencySnippetGenerator(const LLVMState &State) const override {
- return std::make_unique<X86LatencySnippetGenerator>(State);
+ std::unique_ptr<SnippetGenerator> createLatencySnippetGenerator(
+ const LLVMState &State,
+ const SnippetGenerator::Options &Opts) const override {
+ return std::make_unique<X86LatencySnippetGenerator>(State, Opts);
}
- std::unique_ptr<SnippetGenerator>
- createUopsSnippetGenerator(const LLVMState &State) const override {
- return std::make_unique<X86UopsSnippetGenerator>(State);
+ std::unique_ptr<SnippetGenerator> createUopsSnippetGenerator(
+ const LLVMState &State,
+ const SnippetGenerator::Options &Opts) const override {
+ return std::make_unique<X86UopsSnippetGenerator>(State, Opts);
}
bool matchesArch(llvm::Triple::ArchType Arch) const override {
cl::desc("number of time to repeat the asm snippet"),
cl::cat(BenchmarkOptions), cl::init(10000));
+static cl::opt<unsigned> MaxConfigsPerOpcode(
+ "max-configs-per-opcode",
+ cl::desc(
+ "allow to snippet generator to generate at most that many configs"),
+ cl::cat(BenchmarkOptions), cl::init(1));
+
static cl::opt<bool> IgnoreInvalidSchedClass(
"ignore-invalid-sched-class",
cl::desc("ignore instructions that do not define a sched class"),
if (InstrDesc.isCall() || InstrDesc.isReturn())
return make_error<Failure>("Unsupported opcode: isCall/isReturn");
+ SnippetGenerator::Options Options;
+ Options.MaxConfigsPerOpcode = MaxConfigsPerOpcode;
const std::unique_ptr<SnippetGenerator> Generator =
- State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State);
+ State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State,
+ Options);
if (!Generator)
llvm::report_fatal_error("cannot create snippet generator");
return Generator->generateConfigurations(Instr, ForbiddenRegs);
template <typename SnippetGeneratorT>
class SnippetGeneratorTest : public X86SnippetGeneratorTest {
protected:
- SnippetGeneratorTest() : Generator(State) {}
+ SnippetGeneratorTest() : Generator(State, SnippetGenerator::Options()) {}
std::vector<CodeTemplate> checkAndGetCodeTemplates(unsigned Opcode) {
randomGenerator().seed(0); // Initialize seed.
class FakeSnippetGenerator : public SnippetGenerator {
public:
- FakeSnippetGenerator(const LLVMState &State) : SnippetGenerator(State) {}
+ FakeSnippetGenerator(const LLVMState &State, const Options &Opts)
+ : SnippetGenerator(State, Opts) {}
Instruction createInstruction(unsigned Opcode) {
return State.getIC().getInstr(Opcode);