1 //===-- llvm-exegesis.cpp ---------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// Measures execution properties (latencies/uops) of an instruction.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #include "lib/Analysis.h"
16 #include "lib/BenchmarkResult.h"
17 #include "lib/BenchmarkRunner.h"
18 #include "lib/Clustering.h"
19 #include "lib/LlvmState.h"
20 #include "lib/PerfHelper.h"
21 #include "lib/Target.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/Twine.h"
24 #include "llvm/MC/MCInstBuilder.h"
25 #include "llvm/MC/MCRegisterInfo.h"
26 #include "llvm/MC/MCSubtargetInfo.h"
27 #include "llvm/Support/CommandLine.h"
28 #include "llvm/Support/Format.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/TargetRegistry.h"
31 #include "llvm/Support/TargetSelect.h"
32 #include <algorithm>
33 #include <random>
34 #include <string>
35 #include <unordered_map>
36
37 static llvm::cl::opt<unsigned>
38 OpcodeIndex("opcode-index", llvm::cl::desc("opcode to measure, by index"),
39 llvm::cl::init(0));
40
41 static llvm::cl::opt<std::string>
42 OpcodeName("opcode-name", llvm::cl::desc("opcode to measure, by name"),
43 llvm::cl::init(""));
44
45 static llvm::cl::opt<std::string>
46 BenchmarkFile("benchmarks-file", llvm::cl::desc(""), llvm::cl::init(""));
47
48 static llvm::cl::opt<exegesis::InstructionBenchmark::ModeE> BenchmarkMode(
49 "mode", llvm::cl::desc("the mode to run"),
50 llvm::cl::values(clEnumValN(exegesis::InstructionBenchmark::Latency,
51 "latency", "Instruction Latency"),
52 clEnumValN(exegesis::InstructionBenchmark::Uops, "uops",
53 "Uop Decomposition"),
54 // When not asking for a specific benchmark mode, we'll
55 // analyse the results.
56 clEnumValN(exegesis::InstructionBenchmark::Unknown,
57 "analysis", "Analysis")));
58
59 static llvm::cl::opt<unsigned>
60 NumRepetitions("num-repetitions",
61 llvm::cl::desc("number of time to repeat the asm snippet"),
62 llvm::cl::init(10000));
63
64 static llvm::cl::opt<bool> IgnoreInvalidSchedClass(
65 "ignore-invalid-sched-class",
66 llvm::cl::desc("ignore instructions that do not define a sched class"),
67 llvm::cl::init(false));
68
69 static llvm::cl::opt<unsigned> AnalysisNumPoints(
70 "analysis-numpoints",
71 llvm::cl::desc("minimum number of points in an analysis cluster"),
72 llvm::cl::init(3));
73
74 static llvm::cl::opt<float>
75 AnalysisEpsilon("analysis-epsilon",
76 llvm::cl::desc("dbscan epsilon for analysis clustering"),
77 llvm::cl::init(0.1));
78
79 static llvm::cl::opt<std::string>
80 AnalysisClustersOutputFile("analysis-clusters-output-file",
81 llvm::cl::desc(""), llvm::cl::init("-"));
82 static llvm::cl::opt<std::string>
83 AnalysisInconsistenciesOutputFile("analysis-inconsistencies-output-file",
84 llvm::cl::desc(""), llvm::cl::init("-"));
85
86 namespace exegesis {
87
88 static llvm::ExitOnError ExitOnErr;
89
90 #ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
91 void LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
92 #endif
93
GetOpcodeOrDie(const llvm::MCInstrInfo & MCInstrInfo)94 static unsigned GetOpcodeOrDie(const llvm::MCInstrInfo &MCInstrInfo) {
95 if (OpcodeName.empty() && (OpcodeIndex == 0))
96 llvm::report_fatal_error(
97 "please provide one and only one of 'opcode-index' or 'opcode-name'");
98 if (OpcodeIndex > 0)
99 return OpcodeIndex;
100 // Resolve opcode name -> opcode.
101 for (unsigned I = 0, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)
102 if (MCInstrInfo.getName(I) == OpcodeName)
103 return I;
104 llvm::report_fatal_error(llvm::Twine("unknown opcode ").concat(OpcodeName));
105 }
106
107 static BenchmarkResultContext
getBenchmarkResultContext(const LLVMState & State)108 getBenchmarkResultContext(const LLVMState &State) {
109 BenchmarkResultContext Ctx;
110
111 const llvm::MCInstrInfo &InstrInfo = State.getInstrInfo();
112 for (unsigned E = InstrInfo.getNumOpcodes(), I = 0; I < E; ++I)
113 Ctx.addInstrEntry(I, InstrInfo.getName(I).data());
114
115 const llvm::MCRegisterInfo &RegInfo = State.getRegInfo();
116 for (unsigned E = RegInfo.getNumRegs(), I = 0; I < E; ++I)
117 Ctx.addRegEntry(I, RegInfo.getName(I));
118
119 return Ctx;
120 }
121
benchmarkMain()122 void benchmarkMain() {
123 if (exegesis::pfm::pfmInitialize())
124 llvm::report_fatal_error("cannot initialize libpfm");
125
126 llvm::InitializeNativeTarget();
127 llvm::InitializeNativeTargetAsmPrinter();
128 #ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
129 LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
130 #endif
131
132 const LLVMState State;
133 const auto Opcode = GetOpcodeOrDie(State.getInstrInfo());
134
135 // Ignore instructions without a sched class if -ignore-invalid-sched-class is
136 // passed.
137 if (IgnoreInvalidSchedClass &&
138 State.getInstrInfo().get(Opcode).getSchedClass() == 0) {
139 llvm::errs() << "ignoring instruction without sched class\n";
140 return;
141 }
142
143 const std::unique_ptr<BenchmarkRunner> Runner =
144 State.getExegesisTarget().createBenchmarkRunner(BenchmarkMode, State);
145 if (!Runner) {
146 llvm::report_fatal_error("cannot create benchmark runner");
147 }
148
149 if (NumRepetitions == 0)
150 llvm::report_fatal_error("--num-repetitions must be greater than zero");
151
152 // Write to standard output if file is not set.
153 if (BenchmarkFile.empty())
154 BenchmarkFile = "-";
155
156 const BenchmarkResultContext Context = getBenchmarkResultContext(State);
157 std::vector<InstructionBenchmark> Results =
158 ExitOnErr(Runner->run(Opcode, NumRepetitions));
159 for (InstructionBenchmark &Result : Results)
160 ExitOnErr(Result.writeYaml(Context, BenchmarkFile));
161
162 exegesis::pfm::pfmTerminate();
163 }
164
165 // Prints the results of running analysis pass `Pass` to file `OutputFilename`
166 // if OutputFilename is non-empty.
167 template <typename Pass>
maybeRunAnalysis(const Analysis & Analyzer,const std::string & Name,const std::string & OutputFilename)168 static void maybeRunAnalysis(const Analysis &Analyzer, const std::string &Name,
169 const std::string &OutputFilename) {
170 if (OutputFilename.empty())
171 return;
172 if (OutputFilename != "-") {
173 llvm::errs() << "Printing " << Name << " results to file '"
174 << OutputFilename << "'\n";
175 }
176 std::error_code ErrorCode;
177 llvm::raw_fd_ostream ClustersOS(OutputFilename, ErrorCode,
178 llvm::sys::fs::FA_Read |
179 llvm::sys::fs::FA_Write);
180 if (ErrorCode)
181 llvm::report_fatal_error("cannot open out file: " + OutputFilename);
182 if (auto Err = Analyzer.run<Pass>(ClustersOS))
183 llvm::report_fatal_error(std::move(Err));
184 }
185
analysisMain()186 static void analysisMain() {
187 if (BenchmarkFile.empty())
188 llvm::report_fatal_error("--benchmarks-file must be set.");
189
190 llvm::InitializeNativeTarget();
191 llvm::InitializeNativeTargetAsmPrinter();
192 llvm::InitializeNativeTargetDisassembler();
193 // Read benchmarks.
194 const LLVMState State;
195 const std::vector<InstructionBenchmark> Points =
196 ExitOnErr(InstructionBenchmark::readYamls(
197 getBenchmarkResultContext(State), BenchmarkFile));
198 llvm::outs() << "Parsed " << Points.size() << " benchmark points\n";
199 if (Points.empty()) {
200 llvm::errs() << "no benchmarks to analyze\n";
201 return;
202 }
203 // FIXME: Check that all points have the same triple/cpu.
204 // FIXME: Merge points from several runs (latency and uops).
205
206 std::string Error;
207 const auto *TheTarget =
208 llvm::TargetRegistry::lookupTarget(Points[0].LLVMTriple, Error);
209 if (!TheTarget) {
210 llvm::errs() << "unknown target '" << Points[0].LLVMTriple << "'\n";
211 return;
212 }
213 const auto Clustering = ExitOnErr(InstructionBenchmarkClustering::create(
214 Points, AnalysisNumPoints, AnalysisEpsilon));
215
216 const Analysis Analyzer(*TheTarget, Clustering);
217
218 maybeRunAnalysis<Analysis::PrintClusters>(Analyzer, "analysis clusters",
219 AnalysisClustersOutputFile);
220 maybeRunAnalysis<Analysis::PrintSchedClassInconsistencies>(
221 Analyzer, "sched class consistency analysis",
222 AnalysisInconsistenciesOutputFile);
223 }
224
225 } // namespace exegesis
226
main(int Argc,char ** Argv)227 int main(int Argc, char **Argv) {
228 llvm::cl::ParseCommandLineOptions(Argc, Argv, "");
229
230 exegesis::ExitOnErr.setExitCodeMapper([](const llvm::Error &Err) {
231 if (Err.isA<llvm::StringError>())
232 return EXIT_SUCCESS;
233 return EXIT_FAILURE;
234 });
235
236 if (BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
237 exegesis::analysisMain();
238 } else {
239 exegesis::benchmarkMain();
240 }
241 return EXIT_SUCCESS;
242 }
243