1 //===-- llvm-exegesis.cpp ---------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// Measures execution properties (latencies/uops) of an instruction. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "lib/Analysis.h" 15 #include "lib/BenchmarkResult.h" 16 #include "lib/BenchmarkRunner.h" 17 #include "lib/Clustering.h" 18 #include "lib/Error.h" 19 #include "lib/LlvmState.h" 20 #include "lib/PerfHelper.h" 21 #include "lib/SnippetFile.h" 22 #include "lib/SnippetRepetitor.h" 23 #include "lib/Target.h" 24 #include "lib/TargetSelect.h" 25 #include "llvm/ADT/StringExtras.h" 26 #include "llvm/ADT/Twine.h" 27 #include "llvm/MC/MCInstBuilder.h" 28 #include "llvm/MC/MCObjectFileInfo.h" 29 #include "llvm/MC/MCParser/MCAsmParser.h" 30 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 31 #include "llvm/MC/MCRegisterInfo.h" 32 #include "llvm/MC/MCSubtargetInfo.h" 33 #include "llvm/Object/ObjectFile.h" 34 #include "llvm/Support/CommandLine.h" 35 #include "llvm/Support/FileSystem.h" 36 #include "llvm/Support/Format.h" 37 #include "llvm/Support/Path.h" 38 #include "llvm/Support/SourceMgr.h" 39 #include "llvm/Support/TargetRegistry.h" 40 #include "llvm/Support/TargetSelect.h" 41 #include <algorithm> 42 #include <string> 43 44 namespace llvm { 45 namespace exegesis { 46 47 static cl::OptionCategory Options("llvm-exegesis options"); 48 static cl::OptionCategory BenchmarkOptions("llvm-exegesis benchmark options"); 49 static cl::OptionCategory AnalysisOptions("llvm-exegesis analysis options"); 50 51 static cl::opt<int> OpcodeIndex( 52 "opcode-index", 53 cl::desc("opcode to measure, by index, or -1 to measure all opcodes"), 54 cl::cat(BenchmarkOptions), cl::init(0)); 55 56 static cl::opt<std::string> 57 OpcodeNames("opcode-name", 58 cl::desc("comma-separated list of opcodes to measure, by name"), 59 cl::cat(BenchmarkOptions), cl::init("")); 60 61 static cl::opt<std::string> SnippetsFile("snippets-file", 62 cl::desc("code snippets to measure"), 63 cl::cat(BenchmarkOptions), 64 cl::init("")); 65 66 static cl::opt<std::string> 67 BenchmarkFile("benchmarks-file", 68 cl::desc("File to read (analysis mode) or write " 69 "(latency/uops/inverse_throughput modes) benchmark " 70 "results. - uses stdin/stdout."), 71 cl::cat(Options), cl::init("")); 72 73 static cl::opt<exegesis::InstructionBenchmark::ModeE> BenchmarkMode( 74 "mode", cl::desc("the mode to run"), cl::cat(Options), 75 cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency, "latency", 76 "Instruction Latency"), 77 clEnumValN(exegesis::InstructionBenchmark::InverseThroughput, 78 "inverse_throughput", 79 "Instruction Inverse Throughput"), 80 clEnumValN(exegesis::InstructionBenchmark::Uops, "uops", 81 "Uop Decomposition"), 82 // When not asking for a specific benchmark mode, 83 // we'll analyse the results. 84 clEnumValN(exegesis::InstructionBenchmark::Unknown, "analysis", 85 "Analysis"))); 86 87 static cl::opt<exegesis::InstructionBenchmark::ResultAggregationModeE> 88 ResultAggMode( 89 "result-aggregation-mode", 90 cl::desc("How to aggregate multi-values result"), cl::cat(Options), 91 cl::values(clEnumValN(exegesis::InstructionBenchmark::Min, "min", 92 "Keep min reading"), 93 clEnumValN(exegesis::InstructionBenchmark::Max, "max", 94 "Keep max reading"), 95 clEnumValN(exegesis::InstructionBenchmark::Mean, "mean", 96 "Compute mean of all readings"), 97 clEnumValN(exegesis::InstructionBenchmark::MinVariance, 98 "min-variance", 99 "Keep readings set with min-variance")), 100 cl::init(exegesis::InstructionBenchmark::Min)); 101 102 static cl::opt<exegesis::InstructionBenchmark::RepetitionModeE> RepetitionMode( 103 "repetition-mode", cl::desc("how to repeat the instruction snippet"), 104 cl::cat(BenchmarkOptions), 105 cl::values( 106 clEnumValN(exegesis::InstructionBenchmark::Duplicate, "duplicate", 107 "Duplicate the snippet"), 108 clEnumValN(exegesis::InstructionBenchmark::Loop, "loop", 109 "Loop over the snippet"), 110 clEnumValN(exegesis::InstructionBenchmark::AggregateMin, "min", 111 "All of the above and take the minimum of measurements")), 112 cl::init(exegesis::InstructionBenchmark::Duplicate)); 113 114 static cl::opt<unsigned> 115 NumRepetitions("num-repetitions", 116 cl::desc("number of time to repeat the asm snippet"), 117 cl::cat(BenchmarkOptions), cl::init(10000)); 118 119 static cl::opt<unsigned> MaxConfigsPerOpcode( 120 "max-configs-per-opcode", 121 cl::desc( 122 "allow to snippet generator to generate at most that many configs"), 123 cl::cat(BenchmarkOptions), cl::init(1)); 124 125 static cl::opt<bool> IgnoreInvalidSchedClass( 126 "ignore-invalid-sched-class", 127 cl::desc("ignore instructions that do not define a sched class"), 128 cl::cat(BenchmarkOptions), cl::init(false)); 129 130 static cl::opt<exegesis::InstructionBenchmarkClustering::ModeE> 131 AnalysisClusteringAlgorithm( 132 "analysis-clustering", cl::desc("the clustering algorithm to use"), 133 cl::cat(AnalysisOptions), 134 cl::values(clEnumValN(exegesis::InstructionBenchmarkClustering::Dbscan, 135 "dbscan", "use DBSCAN/OPTICS algorithm"), 136 clEnumValN(exegesis::InstructionBenchmarkClustering::Naive, 137 "naive", "one cluster per opcode")), 138 cl::init(exegesis::InstructionBenchmarkClustering::Dbscan)); 139 140 static cl::opt<unsigned> AnalysisDbscanNumPoints( 141 "analysis-numpoints", 142 cl::desc("minimum number of points in an analysis cluster (dbscan only)"), 143 cl::cat(AnalysisOptions), cl::init(3)); 144 145 static cl::opt<float> AnalysisClusteringEpsilon( 146 "analysis-clustering-epsilon", 147 cl::desc("epsilon for benchmark point clustering"), 148 cl::cat(AnalysisOptions), cl::init(0.1)); 149 150 static cl::opt<float> AnalysisInconsistencyEpsilon( 151 "analysis-inconsistency-epsilon", 152 cl::desc("epsilon for detection of when the cluster is different from the " 153 "LLVM schedule profile values"), 154 cl::cat(AnalysisOptions), cl::init(0.1)); 155 156 static cl::opt<std::string> 157 AnalysisClustersOutputFile("analysis-clusters-output-file", cl::desc(""), 158 cl::cat(AnalysisOptions), cl::init("")); 159 static cl::opt<std::string> 160 AnalysisInconsistenciesOutputFile("analysis-inconsistencies-output-file", 161 cl::desc(""), cl::cat(AnalysisOptions), 162 cl::init("")); 163 164 static cl::opt<bool> AnalysisDisplayUnstableOpcodes( 165 "analysis-display-unstable-clusters", 166 cl::desc("if there is more than one benchmark for an opcode, said " 167 "benchmarks may end up not being clustered into the same cluster " 168 "if the measured performance characteristics are different. by " 169 "default all such opcodes are filtered out. this flag will " 170 "instead show only such unstable opcodes"), 171 cl::cat(AnalysisOptions), cl::init(false)); 172 173 static cl::opt<std::string> CpuName( 174 "mcpu", 175 cl::desc("cpu name to use for pfm counters, leave empty to autodetect"), 176 cl::cat(Options), cl::init("")); 177 178 static cl::opt<bool> 179 DumpObjectToDisk("dump-object-to-disk", 180 cl::desc("dumps the generated benchmark object to disk " 181 "and prints a message to access it"), 182 cl::cat(BenchmarkOptions), cl::init(true)); 183 184 static ExitOnError ExitOnErr("llvm-exegesis error: "); 185 186 // Helper function that logs the error(s) and exits. 187 template <typename... ArgTs> static void ExitWithError(ArgTs &&... Args) { 188 ExitOnErr(make_error<Failure>(std::forward<ArgTs>(Args)...)); 189 } 190 191 // Check Err. If it's in a failure state log the file error(s) and exit. 192 static void ExitOnFileError(const Twine &FileName, Error Err) { 193 if (Err) { 194 ExitOnErr(createFileError(FileName, std::move(Err))); 195 } 196 } 197 198 // Check E. If it's in a success state then return the contained value. 199 // If it's in a failure state log the file error(s) and exit. 200 template <typename T> 201 T ExitOnFileError(const Twine &FileName, Expected<T> &&E) { 202 ExitOnFileError(FileName, E.takeError()); 203 return std::move(*E); 204 } 205 206 // Checks that only one of OpcodeNames, OpcodeIndex or SnippetsFile is provided, 207 // and returns the opcode indices or {} if snippets should be read from 208 // `SnippetsFile`. 209 static std::vector<unsigned> getOpcodesOrDie(const MCInstrInfo &MCInstrInfo) { 210 const size_t NumSetFlags = (OpcodeNames.empty() ? 0 : 1) + 211 (OpcodeIndex == 0 ? 0 : 1) + 212 (SnippetsFile.empty() ? 0 : 1); 213 if (NumSetFlags != 1) { 214 ExitOnErr.setBanner("llvm-exegesis: "); 215 ExitWithError("please provide one and only one of 'opcode-index', " 216 "'opcode-name' or 'snippets-file'"); 217 } 218 if (!SnippetsFile.empty()) 219 return {}; 220 if (OpcodeIndex > 0) 221 return {static_cast<unsigned>(OpcodeIndex)}; 222 if (OpcodeIndex < 0) { 223 std::vector<unsigned> Result; 224 for (unsigned I = 1, E = MCInstrInfo.getNumOpcodes(); I < E; ++I) 225 Result.push_back(I); 226 return Result; 227 } 228 // Resolve opcode name -> opcode. 229 const auto ResolveName = [&MCInstrInfo](StringRef OpcodeName) -> unsigned { 230 for (unsigned I = 1, E = MCInstrInfo.getNumOpcodes(); I < E; ++I) 231 if (MCInstrInfo.getName(I) == OpcodeName) 232 return I; 233 return 0u; 234 }; 235 SmallVector<StringRef, 2> Pieces; 236 StringRef(OpcodeNames.getValue()) 237 .split(Pieces, ",", /* MaxSplit */ -1, /* KeepEmpty */ false); 238 std::vector<unsigned> Result; 239 for (const StringRef &OpcodeName : Pieces) { 240 if (unsigned Opcode = ResolveName(OpcodeName)) 241 Result.push_back(Opcode); 242 else 243 ExitWithError(Twine("unknown opcode ").concat(OpcodeName)); 244 } 245 return Result; 246 } 247 248 // Generates code snippets for opcode `Opcode`. 249 static Expected<std::vector<BenchmarkCode>> 250 generateSnippets(const LLVMState &State, unsigned Opcode, 251 const BitVector &ForbiddenRegs) { 252 const Instruction &Instr = State.getIC().getInstr(Opcode); 253 const MCInstrDesc &InstrDesc = Instr.Description; 254 // Ignore instructions that we cannot run. 255 if (InstrDesc.isPseudo() || InstrDesc.usesCustomInsertionHook()) 256 return make_error<Failure>( 257 "Unsupported opcode: isPseudo/usesCustomInserter"); 258 if (InstrDesc.isBranch() || InstrDesc.isIndirectBranch()) 259 return make_error<Failure>("Unsupported opcode: isBranch/isIndirectBranch"); 260 if (InstrDesc.isCall() || InstrDesc.isReturn()) 261 return make_error<Failure>("Unsupported opcode: isCall/isReturn"); 262 263 const std::vector<InstructionTemplate> InstructionVariants = 264 State.getExegesisTarget().generateInstructionVariants( 265 Instr, MaxConfigsPerOpcode); 266 267 SnippetGenerator::Options SnippetOptions; 268 SnippetOptions.MaxConfigsPerOpcode = MaxConfigsPerOpcode; 269 const std::unique_ptr<SnippetGenerator> Generator = 270 State.getExegesisTarget().createSnippetGenerator(BenchmarkMode, State, 271 SnippetOptions); 272 if (!Generator) 273 ExitWithError("cannot create snippet generator"); 274 275 std::vector<BenchmarkCode> Benchmarks; 276 for (const InstructionTemplate &Variant : InstructionVariants) { 277 if (Benchmarks.size() >= MaxConfigsPerOpcode) 278 break; 279 if (auto Err = Generator->generateConfigurations(Variant, Benchmarks, 280 ForbiddenRegs)) 281 return std::move(Err); 282 } 283 return Benchmarks; 284 } 285 286 void benchmarkMain() { 287 #ifndef HAVE_LIBPFM 288 ExitWithError("benchmarking unavailable, LLVM was built without libpfm."); 289 #endif 290 291 if (exegesis::pfm::pfmInitialize()) 292 ExitWithError("cannot initialize libpfm"); 293 294 InitializeNativeTarget(); 295 InitializeNativeTargetAsmPrinter(); 296 InitializeNativeTargetAsmParser(); 297 InitializeNativeExegesisTarget(); 298 299 const LLVMState State(CpuName); 300 301 // Preliminary check to ensure features needed for requested 302 // benchmark mode are present on target CPU and/or OS. 303 ExitOnErr(State.getExegesisTarget().checkFeatureSupport()); 304 305 const std::unique_ptr<BenchmarkRunner> Runner = 306 ExitOnErr(State.getExegesisTarget().createBenchmarkRunner( 307 BenchmarkMode, State, ResultAggMode)); 308 if (!Runner) { 309 ExitWithError("cannot create benchmark runner"); 310 } 311 312 const auto Opcodes = getOpcodesOrDie(State.getInstrInfo()); 313 314 SmallVector<std::unique_ptr<const SnippetRepetitor>, 2> Repetitors; 315 if (RepetitionMode != InstructionBenchmark::RepetitionModeE::AggregateMin) 316 Repetitors.emplace_back(SnippetRepetitor::Create(RepetitionMode, State)); 317 else { 318 for (InstructionBenchmark::RepetitionModeE RepMode : 319 {InstructionBenchmark::RepetitionModeE::Duplicate, 320 InstructionBenchmark::RepetitionModeE::Loop}) 321 Repetitors.emplace_back(SnippetRepetitor::Create(RepMode, State)); 322 } 323 324 BitVector AllReservedRegs; 325 llvm::for_each(Repetitors, 326 [&AllReservedRegs]( 327 const std::unique_ptr<const SnippetRepetitor> &Repetitor) { 328 AllReservedRegs |= Repetitor->getReservedRegs(); 329 }); 330 331 std::vector<BenchmarkCode> Configurations; 332 if (!Opcodes.empty()) { 333 for (const unsigned Opcode : Opcodes) { 334 // Ignore instructions without a sched class if 335 // -ignore-invalid-sched-class is passed. 336 if (IgnoreInvalidSchedClass && 337 State.getInstrInfo().get(Opcode).getSchedClass() == 0) { 338 errs() << State.getInstrInfo().getName(Opcode) 339 << ": ignoring instruction without sched class\n"; 340 continue; 341 } 342 343 auto ConfigsForInstr = generateSnippets(State, Opcode, AllReservedRegs); 344 if (!ConfigsForInstr) { 345 logAllUnhandledErrors( 346 ConfigsForInstr.takeError(), errs(), 347 Twine(State.getInstrInfo().getName(Opcode)).concat(": ")); 348 continue; 349 } 350 std::move(ConfigsForInstr->begin(), ConfigsForInstr->end(), 351 std::back_inserter(Configurations)); 352 } 353 } else { 354 Configurations = ExitOnErr(readSnippets(State, SnippetsFile)); 355 } 356 357 if (NumRepetitions == 0) { 358 ExitOnErr.setBanner("llvm-exegesis: "); 359 ExitWithError("--num-repetitions must be greater than zero"); 360 } 361 362 // Write to standard output if file is not set. 363 if (BenchmarkFile.empty()) 364 BenchmarkFile = "-"; 365 366 for (const BenchmarkCode &Conf : Configurations) { 367 InstructionBenchmark Result = ExitOnErr(Runner->runConfiguration( 368 Conf, NumRepetitions, Repetitors, DumpObjectToDisk)); 369 ExitOnFileError(BenchmarkFile, Result.writeYaml(State, BenchmarkFile)); 370 } 371 exegesis::pfm::pfmTerminate(); 372 } 373 374 // Prints the results of running analysis pass `Pass` to file `OutputFilename` 375 // if OutputFilename is non-empty. 376 template <typename Pass> 377 static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name, 378 const std::string &OutputFilename) { 379 if (OutputFilename.empty()) 380 return; 381 if (OutputFilename != "-") { 382 errs() << "Printing " << Name << " results to file '" << OutputFilename 383 << "'\n"; 384 } 385 std::error_code ErrorCode; 386 raw_fd_ostream ClustersOS(OutputFilename, ErrorCode, 387 sys::fs::FA_Read | sys::fs::FA_Write); 388 if (ErrorCode) 389 ExitOnFileError(OutputFilename, errorCodeToError(ErrorCode)); 390 if (auto Err = Analyzer.run<Pass>(ClustersOS)) 391 ExitOnFileError(OutputFilename, std::move(Err)); 392 } 393 394 static void analysisMain() { 395 ExitOnErr.setBanner("llvm-exegesis: "); 396 if (BenchmarkFile.empty()) 397 ExitWithError("--benchmarks-file must be set"); 398 399 if (AnalysisClustersOutputFile.empty() && 400 AnalysisInconsistenciesOutputFile.empty()) { 401 ExitWithError( 402 "for --mode=analysis: At least one of --analysis-clusters-output-file " 403 "and --analysis-inconsistencies-output-file must be specified"); 404 } 405 406 InitializeNativeTarget(); 407 InitializeNativeTargetAsmPrinter(); 408 InitializeNativeTargetDisassembler(); 409 410 // Read benchmarks. 411 const LLVMState State(""); 412 const std::vector<InstructionBenchmark> Points = ExitOnFileError( 413 BenchmarkFile, InstructionBenchmark::readYamls(State, BenchmarkFile)); 414 415 outs() << "Parsed " << Points.size() << " benchmark points\n"; 416 if (Points.empty()) { 417 errs() << "no benchmarks to analyze\n"; 418 return; 419 } 420 // FIXME: Check that all points have the same triple/cpu. 421 // FIXME: Merge points from several runs (latency and uops). 422 423 std::string Error; 424 const auto *TheTarget = 425 TargetRegistry::lookupTarget(Points[0].LLVMTriple, Error); 426 if (!TheTarget) { 427 errs() << "unknown target '" << Points[0].LLVMTriple << "'\n"; 428 return; 429 } 430 431 std::unique_ptr<MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo()); 432 assert(InstrInfo && "Unable to create instruction info!"); 433 434 const auto Clustering = ExitOnErr(InstructionBenchmarkClustering::create( 435 Points, AnalysisClusteringAlgorithm, AnalysisDbscanNumPoints, 436 AnalysisClusteringEpsilon, InstrInfo->getNumOpcodes())); 437 438 const Analysis Analyzer(*TheTarget, std::move(InstrInfo), Clustering, 439 AnalysisInconsistencyEpsilon, 440 AnalysisDisplayUnstableOpcodes, CpuName); 441 442 maybeRunAnalysis<Analysis::PrintClusters>(Analyzer, "analysis clusters", 443 AnalysisClustersOutputFile); 444 maybeRunAnalysis<Analysis::PrintSchedClassInconsistencies>( 445 Analyzer, "sched class consistency analysis", 446 AnalysisInconsistenciesOutputFile); 447 } 448 449 } // namespace exegesis 450 } // namespace llvm 451 452 int main(int Argc, char **Argv) { 453 using namespace llvm; 454 cl::ParseCommandLineOptions(Argc, Argv, ""); 455 456 exegesis::ExitOnErr.setExitCodeMapper([](const Error &Err) { 457 if (Err.isA<exegesis::ClusteringError>()) 458 return EXIT_SUCCESS; 459 return EXIT_FAILURE; 460 }); 461 462 if (exegesis::BenchmarkMode == exegesis::InstructionBenchmark::Unknown) { 463 exegesis::analysisMain(); 464 } else { 465 exegesis::benchmarkMain(); 466 } 467 return EXIT_SUCCESS; 468 } 469
Indexes created Sat Sep 12 00:25:55 UTC 2026