]>
Commit | Line | Data |
---|---|---|
8ad8db37 IM |
1 | |
2 | #include "../perf.h" | |
3 | #include "util.h" | |
4 | #include "parse-options.h" | |
5 | #include "parse-events.h" | |
6 | #include "exec_cmd.h" | |
a0055ae2 | 7 | #include "string.h" |
8ad8db37 | 8 | |
8326f44d IM |
9 | extern char *strcasestr(const char *haystack, const char *needle); |
10 | ||
a21ca2ca | 11 | int nr_counters; |
8ad8db37 | 12 | |
a21ca2ca | 13 | struct perf_counter_attr attrs[MAX_COUNTERS]; |
8ad8db37 IM |
14 | |
15 | struct event_symbol { | |
9cffa8d5 PM |
16 | u8 type; |
17 | u64 config; | |
a21ca2ca | 18 | char *symbol; |
74d5b588 | 19 | char *alias; |
8ad8db37 IM |
20 | }; |
21 | ||
51e26842 JSR |
22 | #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x |
23 | #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x | |
a21ca2ca | 24 | |
8ad8db37 | 25 | static struct event_symbol event_symbols[] = { |
74d5b588 JSR |
26 | { CHW(CPU_CYCLES), "cpu-cycles", "cycles" }, |
27 | { CHW(INSTRUCTIONS), "instructions", "" }, | |
28 | { CHW(CACHE_REFERENCES), "cache-references", "" }, | |
29 | { CHW(CACHE_MISSES), "cache-misses", "" }, | |
30 | { CHW(BRANCH_INSTRUCTIONS), "branch-instructions", "branches" }, | |
31 | { CHW(BRANCH_MISSES), "branch-misses", "" }, | |
32 | { CHW(BUS_CYCLES), "bus-cycles", "" }, | |
33 | ||
34 | { CSW(CPU_CLOCK), "cpu-clock", "" }, | |
35 | { CSW(TASK_CLOCK), "task-clock", "" }, | |
c0c22dbf | 36 | { CSW(PAGE_FAULTS), "page-faults", "faults" }, |
74d5b588 JSR |
37 | { CSW(PAGE_FAULTS_MIN), "minor-faults", "" }, |
38 | { CSW(PAGE_FAULTS_MAJ), "major-faults", "" }, | |
39 | { CSW(CONTEXT_SWITCHES), "context-switches", "cs" }, | |
40 | { CSW(CPU_MIGRATIONS), "cpu-migrations", "migrations" }, | |
8ad8db37 IM |
41 | }; |
42 | ||
5242519b IM |
43 | #define __PERF_COUNTER_FIELD(config, name) \ |
44 | ((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT) | |
45 | ||
46 | #define PERF_COUNTER_RAW(config) __PERF_COUNTER_FIELD(config, RAW) | |
47 | #define PERF_COUNTER_CONFIG(config) __PERF_COUNTER_FIELD(config, CONFIG) | |
48 | #define PERF_COUNTER_TYPE(config) __PERF_COUNTER_FIELD(config, TYPE) | |
49 | #define PERF_COUNTER_ID(config) __PERF_COUNTER_FIELD(config, EVENT) | |
50 | ||
51 | static char *hw_event_names[] = { | |
8faf3b54 | 52 | "cycles", |
5242519b | 53 | "instructions", |
8faf3b54 IM |
54 | "cache-references", |
55 | "cache-misses", | |
5242519b | 56 | "branches", |
8faf3b54 IM |
57 | "branch-misses", |
58 | "bus-cycles", | |
5242519b IM |
59 | }; |
60 | ||
61 | static char *sw_event_names[] = { | |
44175b6f IM |
62 | "cpu-clock-msecs", |
63 | "task-clock-msecs", | |
8faf3b54 IM |
64 | "page-faults", |
65 | "context-switches", | |
66 | "CPU-migrations", | |
67 | "minor-faults", | |
68 | "major-faults", | |
5242519b IM |
69 | }; |
70 | ||
8326f44d IM |
71 | #define MAX_ALIASES 8 |
72 | ||
c0c22dbf | 73 | static char *hw_cache[][MAX_ALIASES] = { |
4418351f JSR |
74 | { "L1-d$", "l1-d", "l1d", "L1-data", }, |
75 | { "L1-i$", "l1-i", "l1i", "L1-instruction", }, | |
e5c59547 JSR |
76 | { "LLC", "L2" }, |
77 | { "dTLB", "d-tlb", "Data-TLB", }, | |
78 | { "iTLB", "i-tlb", "Instruction-TLB", }, | |
79 | { "branch", "branches", "bpu", "btb", "bpc", }, | |
8326f44d IM |
80 | }; |
81 | ||
c0c22dbf | 82 | static char *hw_cache_op[][MAX_ALIASES] = { |
e5c59547 JSR |
83 | { "load", "loads", "read", }, |
84 | { "store", "stores", "write", }, | |
85 | { "prefetch", "prefetches", "speculative-read", "speculative-load", }, | |
8326f44d IM |
86 | }; |
87 | ||
c0c22dbf | 88 | static char *hw_cache_result[][MAX_ALIASES] = { |
e5c59547 JSR |
89 | { "refs", "Reference", "ops", "access", }, |
90 | { "misses", "miss", }, | |
8326f44d IM |
91 | }; |
92 | ||
06813f6c JSR |
93 | #define C(x) PERF_COUNT_HW_CACHE_##x |
94 | #define CACHE_READ (1 << C(OP_READ)) | |
95 | #define CACHE_WRITE (1 << C(OP_WRITE)) | |
96 | #define CACHE_PREFETCH (1 << C(OP_PREFETCH)) | |
97 | #define COP(x) (1 << x) | |
98 | ||
99 | /* | |
100 | * cache operartion stat | |
101 | * L1I : Read and prefetch only | |
102 | * ITLB and BPU : Read-only | |
103 | */ | |
104 | static unsigned long hw_cache_stat[C(MAX)] = { | |
105 | [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), | |
106 | [C(L1I)] = (CACHE_READ | CACHE_PREFETCH), | |
107 | [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), | |
108 | [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), | |
109 | [C(ITLB)] = (CACHE_READ), | |
110 | [C(BPU)] = (CACHE_READ), | |
111 | }; | |
112 | ||
113 | static int is_cache_op_valid(u8 cache_type, u8 cache_op) | |
114 | { | |
115 | if (hw_cache_stat[cache_type] & COP(cache_op)) | |
116 | return 1; /* valid */ | |
117 | else | |
118 | return 0; /* invalid */ | |
119 | } | |
120 | ||
e5c59547 JSR |
121 | static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result) |
122 | { | |
123 | static char name[50]; | |
124 | ||
125 | if (cache_result) { | |
126 | sprintf(name, "%s-%s-%s", hw_cache[cache_type][0], | |
127 | hw_cache_op[cache_op][0], | |
128 | hw_cache_result[cache_result][0]); | |
129 | } else { | |
130 | sprintf(name, "%s-%s", hw_cache[cache_type][0], | |
131 | hw_cache_op[cache_op][1]); | |
132 | } | |
133 | ||
134 | return name; | |
135 | } | |
136 | ||
a21ca2ca | 137 | char *event_name(int counter) |
5242519b | 138 | { |
9cffa8d5 | 139 | u64 config = attrs[counter].config; |
a21ca2ca | 140 | int type = attrs[counter].type; |
5242519b IM |
141 | static char buf[32]; |
142 | ||
a21ca2ca IM |
143 | if (attrs[counter].type == PERF_TYPE_RAW) { |
144 | sprintf(buf, "raw 0x%llx", config); | |
5242519b IM |
145 | return buf; |
146 | } | |
147 | ||
148 | switch (type) { | |
149 | case PERF_TYPE_HARDWARE: | |
f4dbfa8f | 150 | if (config < PERF_COUNT_HW_MAX) |
a21ca2ca | 151 | return hw_event_names[config]; |
5242519b IM |
152 | return "unknown-hardware"; |
153 | ||
8326f44d | 154 | case PERF_TYPE_HW_CACHE: { |
9cffa8d5 | 155 | u8 cache_type, cache_op, cache_result; |
8326f44d IM |
156 | |
157 | cache_type = (config >> 0) & 0xff; | |
158 | if (cache_type > PERF_COUNT_HW_CACHE_MAX) | |
159 | return "unknown-ext-hardware-cache-type"; | |
160 | ||
161 | cache_op = (config >> 8) & 0xff; | |
8faf3b54 IM |
162 | if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX) |
163 | return "unknown-ext-hardware-cache-op"; | |
8326f44d IM |
164 | |
165 | cache_result = (config >> 16) & 0xff; | |
8faf3b54 IM |
166 | if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX) |
167 | return "unknown-ext-hardware-cache-result"; | |
8326f44d | 168 | |
06813f6c JSR |
169 | if (!is_cache_op_valid(cache_type, cache_op)) |
170 | return "invalid-cache"; | |
8326f44d | 171 | |
e5c59547 | 172 | return event_cache_name(cache_type, cache_op, cache_result); |
8326f44d IM |
173 | } |
174 | ||
5242519b | 175 | case PERF_TYPE_SOFTWARE: |
f4dbfa8f | 176 | if (config < PERF_COUNT_SW_MAX) |
a21ca2ca | 177 | return sw_event_names[config]; |
5242519b IM |
178 | return "unknown-software"; |
179 | ||
180 | default: | |
181 | break; | |
182 | } | |
183 | ||
184 | return "unknown"; | |
185 | } | |
186 | ||
61c45981 | 187 | static int parse_aliases(const char **str, char *names[][MAX_ALIASES], int size) |
8326f44d IM |
188 | { |
189 | int i, j; | |
61c45981 | 190 | int n, longest = -1; |
8326f44d IM |
191 | |
192 | for (i = 0; i < size; i++) { | |
61c45981 PM |
193 | for (j = 0; j < MAX_ALIASES && names[i][j]; j++) { |
194 | n = strlen(names[i][j]); | |
195 | if (n > longest && !strncasecmp(*str, names[i][j], n)) | |
196 | longest = n; | |
197 | } | |
198 | if (longest > 0) { | |
199 | *str += longest; | |
200 | return i; | |
8326f44d IM |
201 | } |
202 | } | |
203 | ||
8953645f | 204 | return -1; |
8326f44d IM |
205 | } |
206 | ||
c0c22dbf | 207 | static int |
61c45981 | 208 | parse_generic_hw_event(const char **str, struct perf_counter_attr *attr) |
8326f44d | 209 | { |
61c45981 PM |
210 | const char *s = *str; |
211 | int cache_type = -1, cache_op = -1, cache_result = -1; | |
8326f44d | 212 | |
61c45981 | 213 | cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX); |
8326f44d IM |
214 | /* |
215 | * No fallback - if we cannot get a clear cache type | |
216 | * then bail out: | |
217 | */ | |
218 | if (cache_type == -1) | |
61c45981 PM |
219 | return 0; |
220 | ||
221 | while ((cache_op == -1 || cache_result == -1) && *s == '-') { | |
222 | ++s; | |
223 | ||
224 | if (cache_op == -1) { | |
225 | cache_op = parse_aliases(&s, hw_cache_op, | |
226 | PERF_COUNT_HW_CACHE_OP_MAX); | |
227 | if (cache_op >= 0) { | |
228 | if (!is_cache_op_valid(cache_type, cache_op)) | |
229 | return 0; | |
230 | continue; | |
231 | } | |
232 | } | |
233 | ||
234 | if (cache_result == -1) { | |
235 | cache_result = parse_aliases(&s, hw_cache_result, | |
236 | PERF_COUNT_HW_CACHE_RESULT_MAX); | |
237 | if (cache_result >= 0) | |
238 | continue; | |
239 | } | |
240 | ||
241 | /* | |
242 | * Can't parse this as a cache op or result, so back up | |
243 | * to the '-'. | |
244 | */ | |
245 | --s; | |
246 | break; | |
247 | } | |
8326f44d | 248 | |
8326f44d IM |
249 | /* |
250 | * Fall back to reads: | |
251 | */ | |
8953645f IM |
252 | if (cache_op == -1) |
253 | cache_op = PERF_COUNT_HW_CACHE_OP_READ; | |
8326f44d | 254 | |
8326f44d IM |
255 | /* |
256 | * Fall back to accesses: | |
257 | */ | |
258 | if (cache_result == -1) | |
259 | cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; | |
260 | ||
261 | attr->config = cache_type | (cache_op << 8) | (cache_result << 16); | |
262 | attr->type = PERF_TYPE_HW_CACHE; | |
263 | ||
61c45981 PM |
264 | *str = s; |
265 | return 1; | |
8326f44d IM |
266 | } |
267 | ||
74d5b588 JSR |
268 | static int check_events(const char *str, unsigned int i) |
269 | { | |
61c45981 | 270 | int n; |
74d5b588 | 271 | |
61c45981 PM |
272 | n = strlen(event_symbols[i].symbol); |
273 | if (!strncmp(str, event_symbols[i].symbol, n)) | |
274 | return n; | |
275 | ||
276 | n = strlen(event_symbols[i].alias); | |
277 | if (n) | |
278 | if (!strncmp(str, event_symbols[i].alias, n)) | |
279 | return n; | |
74d5b588 JSR |
280 | return 0; |
281 | } | |
282 | ||
61c45981 PM |
283 | static int |
284 | parse_symbolic_event(const char **strp, struct perf_counter_attr *attr) | |
8ad8db37 | 285 | { |
61c45981 | 286 | const char *str = *strp; |
8ad8db37 | 287 | unsigned int i; |
61c45981 | 288 | int n; |
8ad8db37 | 289 | |
61c45981 PM |
290 | for (i = 0; i < ARRAY_SIZE(event_symbols); i++) { |
291 | n = check_events(str, i); | |
292 | if (n > 0) { | |
293 | attr->type = event_symbols[i].type; | |
294 | attr->config = event_symbols[i].config; | |
295 | *strp = str + n; | |
296 | return 1; | |
297 | } | |
298 | } | |
299 | return 0; | |
300 | } | |
301 | ||
302 | static int parse_raw_event(const char **strp, struct perf_counter_attr *attr) | |
303 | { | |
304 | const char *str = *strp; | |
305 | u64 config; | |
306 | int n; | |
a21ca2ca | 307 | |
61c45981 | 308 | if (*str != 'r') |
a21ca2ca | 309 | return 0; |
61c45981 PM |
310 | n = hex2u64(str + 1, &config); |
311 | if (n > 0) { | |
312 | *strp = str + n + 1; | |
313 | attr->type = PERF_TYPE_RAW; | |
314 | attr->config = config; | |
315 | return 1; | |
a21ca2ca | 316 | } |
61c45981 PM |
317 | return 0; |
318 | } | |
8ad8db37 | 319 | |
61c45981 PM |
320 | static int |
321 | parse_numeric_event(const char **strp, struct perf_counter_attr *attr) | |
322 | { | |
323 | const char *str = *strp; | |
324 | char *endp; | |
325 | unsigned long type; | |
326 | u64 config; | |
327 | ||
328 | type = strtoul(str, &endp, 0); | |
329 | if (endp > str && type < PERF_TYPE_MAX && *endp == ':') { | |
330 | str = endp + 1; | |
331 | config = strtoul(str, &endp, 0); | |
332 | if (endp > str) { | |
333 | attr->type = type; | |
334 | attr->config = config; | |
335 | *strp = endp; | |
336 | return 1; | |
a0055ae2 | 337 | } |
61c45981 PM |
338 | } |
339 | return 0; | |
340 | } | |
341 | ||
342 | static int | |
343 | parse_event_modifier(const char **strp, struct perf_counter_attr *attr) | |
344 | { | |
345 | const char *str = *strp; | |
346 | int eu = 1, ek = 1, eh = 1; | |
a21ca2ca | 347 | |
61c45981 | 348 | if (*str++ != ':') |
a21ca2ca | 349 | return 0; |
61c45981 PM |
350 | while (*str) { |
351 | if (*str == 'u') | |
352 | eu = 0; | |
353 | else if (*str == 'k') | |
354 | ek = 0; | |
355 | else if (*str == 'h') | |
356 | eh = 0; | |
357 | else | |
358 | break; | |
359 | ++str; | |
5242519b | 360 | } |
61c45981 PM |
361 | if (str >= *strp + 2) { |
362 | *strp = str; | |
363 | attr->exclude_user = eu; | |
364 | attr->exclude_kernel = ek; | |
365 | attr->exclude_hv = eh; | |
366 | return 1; | |
367 | } | |
368 | return 0; | |
369 | } | |
8ad8db37 | 370 | |
61c45981 PM |
371 | /* |
372 | * Each event can have multiple symbolic names. | |
373 | * Symbolic names are (almost) exactly matched. | |
374 | */ | |
375 | static int parse_event_symbols(const char **str, struct perf_counter_attr *attr) | |
376 | { | |
377 | if (!(parse_raw_event(str, attr) || | |
378 | parse_numeric_event(str, attr) || | |
379 | parse_symbolic_event(str, attr) || | |
380 | parse_generic_hw_event(str, attr))) | |
381 | return 0; | |
a21ca2ca | 382 | |
61c45981 | 383 | parse_event_modifier(str, attr); |
8ad8db37 | 384 | |
61c45981 | 385 | return 1; |
8ad8db37 IM |
386 | } |
387 | ||
f37a291c | 388 | int parse_events(const struct option *opt __used, const char *str, int unset __used) |
8ad8db37 | 389 | { |
a21ca2ca | 390 | struct perf_counter_attr attr; |
8ad8db37 | 391 | |
61c45981 PM |
392 | for (;;) { |
393 | if (nr_counters == MAX_COUNTERS) | |
394 | return -1; | |
395 | ||
396 | memset(&attr, 0, sizeof(attr)); | |
397 | if (!parse_event_symbols(&str, &attr)) | |
398 | return -1; | |
8ad8db37 | 399 | |
61c45981 PM |
400 | if (!(*str == 0 || *str == ',' || isspace(*str))) |
401 | return -1; | |
8ad8db37 | 402 | |
61c45981 PM |
403 | attrs[nr_counters] = attr; |
404 | nr_counters++; | |
8ad8db37 | 405 | |
61c45981 PM |
406 | if (*str == 0) |
407 | break; | |
408 | if (*str == ',') | |
409 | ++str; | |
410 | while (isspace(*str)) | |
411 | ++str; | |
8ad8db37 IM |
412 | } |
413 | ||
414 | return 0; | |
415 | } | |
416 | ||
86847b62 TG |
417 | static const char * const event_type_descriptors[] = { |
418 | "", | |
419 | "Hardware event", | |
420 | "Software event", | |
421 | "Tracepoint event", | |
422 | "Hardware cache event", | |
423 | }; | |
424 | ||
8ad8db37 | 425 | /* |
86847b62 | 426 | * Print the help text for the event symbols: |
8ad8db37 | 427 | */ |
86847b62 | 428 | void print_events(void) |
8ad8db37 | 429 | { |
86847b62 TG |
430 | struct event_symbol *syms = event_symbols; |
431 | unsigned int i, type, prev_type = -1; | |
74d5b588 | 432 | char name[40]; |
8ad8db37 | 433 | |
86847b62 TG |
434 | fprintf(stderr, "\n"); |
435 | fprintf(stderr, "List of pre-defined events (to be used in -e):\n"); | |
8ad8db37 | 436 | |
86847b62 TG |
437 | for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) { |
438 | type = syms->type + 1; | |
439 | if (type > ARRAY_SIZE(event_type_descriptors)) | |
440 | type = 0; | |
8ad8db37 | 441 | |
86847b62 TG |
442 | if (type != prev_type) |
443 | fprintf(stderr, "\n"); | |
8ad8db37 | 444 | |
74d5b588 JSR |
445 | if (strlen(syms->alias)) |
446 | sprintf(name, "%s OR %s", syms->symbol, syms->alias); | |
447 | else | |
448 | strcpy(name, syms->symbol); | |
449 | fprintf(stderr, " %-40s [%s]\n", name, | |
86847b62 | 450 | event_type_descriptors[type]); |
8ad8db37 | 451 | |
86847b62 | 452 | prev_type = type; |
8ad8db37 IM |
453 | } |
454 | ||
86847b62 | 455 | fprintf(stderr, "\n"); |
74d5b588 | 456 | fprintf(stderr, " %-40s [raw hardware event descriptor]\n", |
86847b62 TG |
457 | "rNNN"); |
458 | fprintf(stderr, "\n"); | |
459 | ||
460 | exit(129); | |
8ad8db37 | 461 | } |