Index: docs/CommandGuide/llvm-exegesis.rst =================================================================== --- docs/CommandGuide/llvm-exegesis.rst +++ docs/CommandGuide/llvm-exegesis.rst @@ -10,13 +10,13 @@ ----------- :program:`llvm-exegesis` is a benchmarking tool that uses information available -in LLVM to measure host machine instruction characteristics like latency or port -decomposition. +in LLVM to measure host machine instruction characteristics like latency, +throughput, or port decomposition. Given an LLVM opcode name and a benchmarking mode, :program:`llvm-exegesis` generates a code snippet that makes execution as serial (resp. as parallel) as -possible so that we can measure the latency (resp. uop decomposition) of the -instruction. +possible so that we can measure the latency (resp. inverse throughput/uop decomposition) +of the instruction. The code snippet is jitted and executed on the host subtarget. The time taken (resp. resource usage) is measured using hardware performance counters. The result is printed out as YAML to the standard output. @@ -37,11 +37,13 @@ $ llvm-exegesis -mode=latency -opcode-name=ADD64rr -Measuring the uop decomposition of an instruction works similarly: +Measuring the uop decomposition or inverse throughput of an instruction works similarly: .. code-block:: bash $ llvm-exegesis -mode=uops -opcode-name=ADD64rr + $ llvm-exegesis -mode=inverse_throughput -opcode-name=ADD64rr + The output is a YAML document (the default is to write to stdout, but you can redirect the output to a file using `-benchmarks-file`): @@ -186,7 +188,7 @@ Specify the custom code snippet to measure. See example 2 for details. Either `opcode-index`, `opcode-name` or `snippets-file` must be set. -.. option:: -mode=[latency|uops|analysis] +.. option:: -mode=[latency|uops|inverse_throughput|analysis] Specify the run mode. @@ -197,8 +199,8 @@ .. option:: -benchmarks-file= - File to read (`analysis` mode) or write (`latency`/`uops` modes) benchmark - results. "-" uses stdin/stdout. + File to read (`analysis` mode) or write (`latency`/`uops`/`inverse_throughput` + modes) benchmark results. "-" uses stdin/stdout. .. option:: -analysis-clusters-output-file= Index: test/tools/llvm-exegesis/X86/inverse_throughput-by-opcode-name.s =================================================================== --- /dev/null +++ test/tools/llvm-exegesis/X86/inverse_throughput-by-opcode-name.s @@ -0,0 +1,8 @@ +# RUN: llvm-exegesis -mode=inverse_throughput -opcode-name=ADD32rr | FileCheck %s + +CHECK: --- +CHECK-NEXT: mode: inverse_throughput +CHECK-NEXT: key: +CHECK-NEXT: instructions: +CHECK-NEXT: ADD32rr +CHECK: key: inverse_throughput Index: tools/llvm-exegesis/lib/BenchmarkResult.h =================================================================== --- tools/llvm-exegesis/lib/BenchmarkResult.h +++ tools/llvm-exegesis/lib/BenchmarkResult.h @@ -58,7 +58,7 @@ // The result of an instruction benchmark. struct InstructionBenchmark { InstructionBenchmarkKey Key; - enum ModeE { Unknown, Latency, Uops }; + enum ModeE { Unknown, Latency, Uops, InverseThroughput }; ModeE Mode; std::string CpuName; std::string LLVMTriple; Index: tools/llvm-exegesis/lib/BenchmarkResult.cpp =================================================================== --- tools/llvm-exegesis/lib/BenchmarkResult.cpp +++ tools/llvm-exegesis/lib/BenchmarkResult.cpp @@ -210,6 +210,8 @@ Io.enumCase(Value, "", exegesis::InstructionBenchmark::Unknown); Io.enumCase(Value, "latency", exegesis::InstructionBenchmark::Latency); Io.enumCase(Value, "uops", exegesis::InstructionBenchmark::Uops); + Io.enumCase(Value, "inverse_throughput", + exegesis::InstructionBenchmark::InverseThroughput); } }; Index: tools/llvm-exegesis/lib/BenchmarkRunner.h =================================================================== --- tools/llvm-exegesis/lib/BenchmarkRunner.h +++ tools/llvm-exegesis/lib/BenchmarkRunner.h @@ -76,6 +76,7 @@ protected: const LLVMState &State; + const InstructionBenchmark::ModeE Mode; private: virtual llvm::Expected> @@ -85,7 +86,6 @@ writeObjectFile(const BenchmarkCode &Configuration, llvm::ArrayRef Code) const; - const InstructionBenchmark::ModeE Mode; const std::unique_ptr Scratch; }; Index: tools/llvm-exegesis/lib/Latency.h =================================================================== --- tools/llvm-exegesis/lib/Latency.h +++ tools/llvm-exegesis/lib/Latency.h @@ -33,8 +33,8 @@ class LatencyBenchmarkRunner : public BenchmarkRunner { public: - LatencyBenchmarkRunner(const LLVMState &State) - : BenchmarkRunner(State, InstructionBenchmark::Latency) {} + LatencyBenchmarkRunner(const LLVMState &State, + InstructionBenchmark::ModeE Mode); ~LatencyBenchmarkRunner() override; private: Index: tools/llvm-exegesis/lib/Latency.cpp =================================================================== --- tools/llvm-exegesis/lib/Latency.cpp +++ tools/llvm-exegesis/lib/Latency.cpp @@ -166,6 +166,14 @@ return std::move(Results); } +LatencyBenchmarkRunner::LatencyBenchmarkRunner(const LLVMState &State, + InstructionBenchmark::ModeE Mode) + : BenchmarkRunner(State, Mode) { + assert((Mode == InstructionBenchmark::Latency || + Mode == InstructionBenchmark::InverseThroughput) && + "invalid mode"); +} + LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default; llvm::Expected> @@ -185,8 +193,17 @@ if (*ExpectedCounterValue < MinValue) MinValue = *ExpectedCounterValue; } - std::vector Result = { - BenchmarkMeasure::Create("latency", MinValue)}; + std::vector Result; + switch (Mode) { + case InstructionBenchmark::Latency: + Result = {BenchmarkMeasure::Create("latency", MinValue)}; + break; + case InstructionBenchmark::InverseThroughput: + Result = {BenchmarkMeasure::Create("inverse_throughput", MinValue)}; + break; + default: + break; + } return std::move(Result); } Index: tools/llvm-exegesis/lib/Target.h =================================================================== --- tools/llvm-exegesis/lib/Target.h +++ tools/llvm-exegesis/lib/Target.h @@ -131,7 +131,7 @@ std::unique_ptr virtual createUopsSnippetGenerator( const LLVMState &State) const; std::unique_ptr virtual createLatencyBenchmarkRunner( - const LLVMState &State) const; + const LLVMState &State, InstructionBenchmark::ModeE Mode) const; std::unique_ptr virtual createUopsBenchmarkRunner( const LLVMState &State) const; Index: tools/llvm-exegesis/lib/Target.cpp =================================================================== --- tools/llvm-exegesis/lib/Target.cpp +++ tools/llvm-exegesis/lib/Target.cpp @@ -46,6 +46,7 @@ case InstructionBenchmark::Latency: return createLatencySnippetGenerator(State); case InstructionBenchmark::Uops: + case InstructionBenchmark::InverseThroughput: return createUopsSnippetGenerator(State); } return nullptr; @@ -58,7 +59,8 @@ case InstructionBenchmark::Unknown: return nullptr; case InstructionBenchmark::Latency: - return createLatencyBenchmarkRunner(State); + case InstructionBenchmark::InverseThroughput: + return createLatencyBenchmarkRunner(State, Mode); case InstructionBenchmark::Uops: return createUopsBenchmarkRunner(State); } @@ -75,9 +77,9 @@ return llvm::make_unique(State); } -std::unique_ptr -ExegesisTarget::createLatencyBenchmarkRunner(const LLVMState &State) const { - return llvm::make_unique(State); +std::unique_ptr ExegesisTarget::createLatencyBenchmarkRunner( + const LLVMState &State, InstructionBenchmark::ModeE Mode) const { + return llvm::make_unique(State, Mode); } std::unique_ptr Index: tools/llvm-exegesis/llvm-exegesis.cpp =================================================================== --- tools/llvm-exegesis/llvm-exegesis.cpp +++ tools/llvm-exegesis/llvm-exegesis.cpp @@ -57,16 +57,19 @@ static cl::opt BenchmarkFile("benchmarks-file", cl::desc(""), cl::init("")); -static cl::opt - BenchmarkMode("mode", cl::desc("the mode to run"), - cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency, - "latency", "Instruction Latency"), - clEnumValN(exegesis::InstructionBenchmark::Uops, - "uops", "Uop Decomposition"), - // When not asking for a specific benchmark mode, - // we'll analyse the results. - clEnumValN(exegesis::InstructionBenchmark::Unknown, - "analysis", "Analysis"))); +static cl::opt BenchmarkMode( + "mode", cl::desc("the mode to run"), + cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency, "latency", + "Instruction Latency"), + clEnumValN(exegesis::InstructionBenchmark::InverseThroughput, + "inverse_throughput", + "Instruction Inverse Throughput"), + clEnumValN(exegesis::InstructionBenchmark::Uops, "uops", + "Uop Decomposition"), + // When not asking for a specific benchmark mode, + // we'll analyse the results. + clEnumValN(exegesis::InstructionBenchmark::Unknown, "analysis", + "Analysis"))); static cl::opt NumRepetitions("num-repetitions",