Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
f87027b9 JO |
2 | #include <stdio.h> |
3 | #include "evsel.h" | |
4 | #include "stat.h" | |
5 | #include "color.h" | |
fb4605ba | 6 | #include "pmu.h" |
37932c18 AK |
7 | #include "rblist.h" |
8 | #include "evlist.h" | |
9 | #include "expr.h" | |
b18f3e36 | 10 | #include "metricgroup.h" |
d8f9da24 | 11 | #include <linux/zalloc.h> |
f87027b9 | 12 | |
44d49a60 AK |
13 | /* |
14 | * AGGR_GLOBAL: Use CPU 0 | |
15 | * AGGR_SOCKET: Use first CPU of socket | |
db5742b6 | 16 | * AGGR_DIE: Use first CPU of die |
44d49a60 AK |
17 | * AGGR_CORE: Use first CPU of core |
18 | * AGGR_NONE: Use matching CPU | |
19 | * AGGR_THREAD: Not supported? | |
20 | */ | |
f87027b9 | 21 | |
8efb2df1 | 22 | struct runtime_stat rt_stat; |
f87027b9 JO |
23 | struct stats walltime_nsecs_stats; |
24 | ||
37932c18 AK |
25 | struct saved_value { |
26 | struct rb_node rb_node; | |
32dcd021 | 27 | struct evsel *evsel; |
49cd456a JY |
28 | enum stat_type type; |
29 | int ctx; | |
37932c18 | 30 | int cpu; |
49cd456a | 31 | struct runtime_stat *stat; |
37932c18 | 32 | struct stats stats; |
f01642e4 JY |
33 | u64 metric_total; |
34 | int metric_other; | |
37932c18 AK |
35 | }; |
36 | ||
37 | static int saved_value_cmp(struct rb_node *rb_node, const void *entry) | |
38 | { | |
39 | struct saved_value *a = container_of(rb_node, | |
40 | struct saved_value, | |
41 | rb_node); | |
42 | const struct saved_value *b = entry; | |
43 | ||
37932c18 AK |
44 | if (a->cpu != b->cpu) |
45 | return a->cpu - b->cpu; | |
49cd456a JY |
46 | |
47 | /* | |
48 | * Previously the rbtree was used to link generic metrics. | |
49 | * The keys were evsel/cpu. Now the rbtree is extended to support | |
50 | * per-thread shadow stats. For shadow stats case, the keys | |
51 | * are cpu/type/ctx/stat (evsel is NULL). For generic metrics | |
52 | * case, the keys are still evsel/cpu (type/ctx/stat are 0 or NULL). | |
53 | */ | |
54 | if (a->type != b->type) | |
55 | return a->type - b->type; | |
56 | ||
57 | if (a->ctx != b->ctx) | |
58 | return a->ctx - b->ctx; | |
59 | ||
60 | if (a->evsel == NULL && b->evsel == NULL) { | |
61 | if (a->stat == b->stat) | |
62 | return 0; | |
63 | ||
64 | if ((char *)a->stat < (char *)b->stat) | |
65 | return -1; | |
66 | ||
67 | return 1; | |
68 | } | |
69 | ||
5e97665f AK |
70 | if (a->evsel == b->evsel) |
71 | return 0; | |
72 | if ((char *)a->evsel < (char *)b->evsel) | |
73 | return -1; | |
74 | return +1; | |
37932c18 AK |
75 | } |
76 | ||
77 | static struct rb_node *saved_value_new(struct rblist *rblist __maybe_unused, | |
78 | const void *entry) | |
79 | { | |
80 | struct saved_value *nd = malloc(sizeof(struct saved_value)); | |
81 | ||
82 | if (!nd) | |
83 | return NULL; | |
84 | memcpy(nd, entry, sizeof(struct saved_value)); | |
85 | return &nd->rb_node; | |
86 | } | |
87 | ||
b984aff7 JY |
88 | static void saved_value_delete(struct rblist *rblist __maybe_unused, |
89 | struct rb_node *rb_node) | |
90 | { | |
91 | struct saved_value *v; | |
92 | ||
93 | BUG_ON(!rb_node); | |
94 | v = container_of(rb_node, struct saved_value, rb_node); | |
95 | free(v); | |
96 | } | |
97 | ||
32dcd021 | 98 | static struct saved_value *saved_value_lookup(struct evsel *evsel, |
4e1a0963 | 99 | int cpu, |
1fcd0394 JY |
100 | bool create, |
101 | enum stat_type type, | |
102 | int ctx, | |
103 | struct runtime_stat *st) | |
37932c18 | 104 | { |
1fcd0394 | 105 | struct rblist *rblist; |
37932c18 AK |
106 | struct rb_node *nd; |
107 | struct saved_value dm = { | |
108 | .cpu = cpu, | |
37932c18 | 109 | .evsel = evsel, |
1fcd0394 JY |
110 | .type = type, |
111 | .ctx = ctx, | |
112 | .stat = st, | |
37932c18 | 113 | }; |
1fcd0394 JY |
114 | |
115 | rblist = &st->value_list; | |
116 | ||
117 | nd = rblist__find(rblist, &dm); | |
37932c18 AK |
118 | if (nd) |
119 | return container_of(nd, struct saved_value, rb_node); | |
120 | if (create) { | |
1fcd0394 JY |
121 | rblist__add_node(rblist, &dm); |
122 | nd = rblist__find(rblist, &dm); | |
37932c18 AK |
123 | if (nd) |
124 | return container_of(nd, struct saved_value, rb_node); | |
125 | } | |
126 | return NULL; | |
127 | } | |
128 | ||
8efb2df1 JY |
129 | void runtime_stat__init(struct runtime_stat *st) |
130 | { | |
131 | struct rblist *rblist = &st->value_list; | |
132 | ||
133 | rblist__init(rblist); | |
134 | rblist->node_cmp = saved_value_cmp; | |
135 | rblist->node_new = saved_value_new; | |
136 | rblist->node_delete = saved_value_delete; | |
137 | } | |
138 | ||
139 | void runtime_stat__exit(struct runtime_stat *st) | |
140 | { | |
141 | rblist__exit(&st->value_list); | |
142 | } | |
143 | ||
fb4605ba AK |
144 | void perf_stat__init_shadow_stats(void) |
145 | { | |
8efb2df1 | 146 | runtime_stat__init(&rt_stat); |
fb4605ba AK |
147 | } |
148 | ||
32dcd021 | 149 | static int evsel_context(struct evsel *evsel) |
f87027b9 JO |
150 | { |
151 | int ctx = 0; | |
152 | ||
1fc632ce | 153 | if (evsel->core.attr.exclude_kernel) |
f87027b9 | 154 | ctx |= CTX_BIT_KERNEL; |
1fc632ce | 155 | if (evsel->core.attr.exclude_user) |
f87027b9 | 156 | ctx |= CTX_BIT_USER; |
1fc632ce | 157 | if (evsel->core.attr.exclude_hv) |
f87027b9 | 158 | ctx |= CTX_BIT_HV; |
1fc632ce | 159 | if (evsel->core.attr.exclude_host) |
f87027b9 | 160 | ctx |= CTX_BIT_HOST; |
1fc632ce | 161 | if (evsel->core.attr.exclude_idle) |
f87027b9 JO |
162 | ctx |= CTX_BIT_IDLE; |
163 | ||
164 | return ctx; | |
165 | } | |
166 | ||
6a1e2c5c | 167 | static void reset_stat(struct runtime_stat *st) |
f87027b9 | 168 | { |
6a1e2c5c | 169 | struct rblist *rblist; |
37932c18 AK |
170 | struct rb_node *pos, *next; |
171 | ||
6a1e2c5c | 172 | rblist = &st->value_list; |
ca227029 | 173 | next = rb_first_cached(&rblist->entries); |
37932c18 AK |
174 | while (next) { |
175 | pos = next; | |
176 | next = rb_next(pos); | |
177 | memset(&container_of(pos, struct saved_value, rb_node)->stats, | |
178 | 0, | |
179 | sizeof(struct stats)); | |
180 | } | |
f87027b9 JO |
181 | } |
182 | ||
6a1e2c5c JY |
183 | void perf_stat__reset_shadow_stats(void) |
184 | { | |
185 | reset_stat(&rt_stat); | |
186 | memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats)); | |
187 | } | |
188 | ||
189 | void perf_stat__reset_shadow_per_stat(struct runtime_stat *st) | |
190 | { | |
191 | reset_stat(st); | |
192 | } | |
193 | ||
1fcd0394 JY |
194 | static void update_runtime_stat(struct runtime_stat *st, |
195 | enum stat_type type, | |
196 | int ctx, int cpu, u64 count) | |
197 | { | |
198 | struct saved_value *v = saved_value_lookup(NULL, cpu, true, | |
199 | type, ctx, st); | |
200 | ||
201 | if (v) | |
202 | update_stats(&v->stats, count); | |
203 | } | |
204 | ||
f87027b9 JO |
205 | /* |
206 | * Update various tracking values we maintain to print | |
207 | * more semantic information such as miss/hit ratios, | |
208 | * instruction rates, etc: | |
209 | */ | |
32dcd021 | 210 | void perf_stat__update_shadow_stats(struct evsel *counter, u64 count, |
1fcd0394 | 211 | int cpu, struct runtime_stat *st) |
f87027b9 JO |
212 | { |
213 | int ctx = evsel_context(counter); | |
57ddf091 | 214 | u64 count_ns = count; |
f01642e4 | 215 | struct saved_value *v; |
f87027b9 | 216 | |
54830dd0 JO |
217 | count *= counter->scale; |
218 | ||
c754c382 | 219 | if (evsel__is_clock(counter)) |
57ddf091 | 220 | update_runtime_stat(st, STAT_NSECS, 0, cpu, count_ns); |
c754c382 | 221 | else if (evsel__match(counter, HARDWARE, HW_CPU_CYCLES)) |
1fcd0394 | 222 | update_runtime_stat(st, STAT_CYCLES, ctx, cpu, count); |
f87027b9 | 223 | else if (perf_stat_evsel__is(counter, CYCLES_IN_TX)) |
1fcd0394 | 224 | update_runtime_stat(st, STAT_CYCLES_IN_TX, ctx, cpu, count); |
f87027b9 | 225 | else if (perf_stat_evsel__is(counter, TRANSACTION_START)) |
1fcd0394 | 226 | update_runtime_stat(st, STAT_TRANSACTION, ctx, cpu, count); |
f87027b9 | 227 | else if (perf_stat_evsel__is(counter, ELISION_START)) |
1fcd0394 | 228 | update_runtime_stat(st, STAT_ELISION, ctx, cpu, count); |
239bd47f | 229 | else if (perf_stat_evsel__is(counter, TOPDOWN_TOTAL_SLOTS)) |
1fcd0394 JY |
230 | update_runtime_stat(st, STAT_TOPDOWN_TOTAL_SLOTS, |
231 | ctx, cpu, count); | |
239bd47f | 232 | else if (perf_stat_evsel__is(counter, TOPDOWN_SLOTS_ISSUED)) |
1fcd0394 JY |
233 | update_runtime_stat(st, STAT_TOPDOWN_SLOTS_ISSUED, |
234 | ctx, cpu, count); | |
239bd47f | 235 | else if (perf_stat_evsel__is(counter, TOPDOWN_SLOTS_RETIRED)) |
1fcd0394 JY |
236 | update_runtime_stat(st, STAT_TOPDOWN_SLOTS_RETIRED, |
237 | ctx, cpu, count); | |
239bd47f | 238 | else if (perf_stat_evsel__is(counter, TOPDOWN_FETCH_BUBBLES)) |
1fcd0394 JY |
239 | update_runtime_stat(st, STAT_TOPDOWN_FETCH_BUBBLES, |
240 | ctx, cpu, count); | |
239bd47f | 241 | else if (perf_stat_evsel__is(counter, TOPDOWN_RECOVERY_BUBBLES)) |
1fcd0394 JY |
242 | update_runtime_stat(st, STAT_TOPDOWN_RECOVERY_BUBBLES, |
243 | ctx, cpu, count); | |
c754c382 | 244 | else if (evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) |
1fcd0394 JY |
245 | update_runtime_stat(st, STAT_STALLED_CYCLES_FRONT, |
246 | ctx, cpu, count); | |
c754c382 | 247 | else if (evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND)) |
1fcd0394 JY |
248 | update_runtime_stat(st, STAT_STALLED_CYCLES_BACK, |
249 | ctx, cpu, count); | |
c754c382 | 250 | else if (evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS)) |
1fcd0394 | 251 | update_runtime_stat(st, STAT_BRANCHES, ctx, cpu, count); |
c754c382 | 252 | else if (evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES)) |
1fcd0394 | 253 | update_runtime_stat(st, STAT_CACHEREFS, ctx, cpu, count); |
c754c382 | 254 | else if (evsel__match(counter, HW_CACHE, HW_CACHE_L1D)) |
1fcd0394 | 255 | update_runtime_stat(st, STAT_L1_DCACHE, ctx, cpu, count); |
c754c382 | 256 | else if (evsel__match(counter, HW_CACHE, HW_CACHE_L1I)) |
1fcd0394 | 257 | update_runtime_stat(st, STAT_L1_ICACHE, ctx, cpu, count); |
c754c382 | 258 | else if (evsel__match(counter, HW_CACHE, HW_CACHE_LL)) |
1fcd0394 | 259 | update_runtime_stat(st, STAT_LL_CACHE, ctx, cpu, count); |
c754c382 | 260 | else if (evsel__match(counter, HW_CACHE, HW_CACHE_DTLB)) |
1fcd0394 | 261 | update_runtime_stat(st, STAT_DTLB_CACHE, ctx, cpu, count); |
c754c382 | 262 | else if (evsel__match(counter, HW_CACHE, HW_CACHE_ITLB)) |
1fcd0394 | 263 | update_runtime_stat(st, STAT_ITLB_CACHE, ctx, cpu, count); |
daefd0bc | 264 | else if (perf_stat_evsel__is(counter, SMI_NUM)) |
1fcd0394 | 265 | update_runtime_stat(st, STAT_SMI_NUM, ctx, cpu, count); |
daefd0bc | 266 | else if (perf_stat_evsel__is(counter, APERF)) |
1fcd0394 | 267 | update_runtime_stat(st, STAT_APERF, ctx, cpu, count); |
37932c18 AK |
268 | |
269 | if (counter->collect_stat) { | |
f01642e4 | 270 | v = saved_value_lookup(counter, cpu, true, STAT_NONE, 0, st); |
54830dd0 | 271 | update_stats(&v->stats, count); |
f01642e4 JY |
272 | if (counter->metric_leader) |
273 | v->metric_total += count; | |
274 | } else if (counter->metric_leader) { | |
275 | v = saved_value_lookup(counter->metric_leader, | |
276 | cpu, true, STAT_NONE, 0, st); | |
277 | v->metric_total += count; | |
278 | v->metric_other++; | |
37932c18 | 279 | } |
f87027b9 JO |
280 | } |
281 | ||
282 | /* used for get_ratio_color() */ | |
283 | enum grc_type { | |
284 | GRC_STALLED_CYCLES_FE, | |
285 | GRC_STALLED_CYCLES_BE, | |
286 | GRC_CACHE_MISSES, | |
287 | GRC_MAX_NR | |
288 | }; | |
289 | ||
290 | static const char *get_ratio_color(enum grc_type type, double ratio) | |
291 | { | |
292 | static const double grc_table[GRC_MAX_NR][3] = { | |
293 | [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 }, | |
294 | [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 }, | |
295 | [GRC_CACHE_MISSES] = { 20.0, 10.0, 5.0 }, | |
296 | }; | |
297 | const char *color = PERF_COLOR_NORMAL; | |
298 | ||
299 | if (ratio > grc_table[type][0]) | |
300 | color = PERF_COLOR_RED; | |
301 | else if (ratio > grc_table[type][1]) | |
302 | color = PERF_COLOR_MAGENTA; | |
303 | else if (ratio > grc_table[type][2]) | |
304 | color = PERF_COLOR_YELLOW; | |
305 | ||
306 | return color; | |
307 | } | |
308 | ||
63503dba | 309 | static struct evsel *perf_stat__find_event(struct evlist *evsel_list, |
37932c18 AK |
310 | const char *name) |
311 | { | |
32dcd021 | 312 | struct evsel *c2; |
37932c18 AK |
313 | |
314 | evlist__for_each_entry (evsel_list, c2) { | |
145c407c | 315 | if (!strcasecmp(c2->name, name) && !c2->collect_stat) |
37932c18 AK |
316 | return c2; |
317 | } | |
318 | return NULL; | |
319 | } | |
320 | ||
321 | /* Mark MetricExpr target events and link events using them to them. */ | |
63503dba | 322 | void perf_stat__collect_metric_expr(struct evlist *evsel_list) |
37932c18 | 323 | { |
32dcd021 | 324 | struct evsel *counter, *leader, **metric_events, *oc; |
37932c18 | 325 | bool found; |
ded80bda IR |
326 | struct expr_parse_ctx ctx; |
327 | struct hashmap_entry *cur; | |
328 | size_t bkt; | |
37932c18 | 329 | int i; |
37932c18 | 330 | |
ded80bda | 331 | expr__ctx_init(&ctx); |
37932c18 AK |
332 | evlist__for_each_entry(evsel_list, counter) { |
333 | bool invalid = false; | |
334 | ||
335 | leader = counter->leader; | |
336 | if (!counter->metric_expr) | |
337 | continue; | |
ded80bda IR |
338 | |
339 | expr__ctx_clear(&ctx); | |
37932c18 AK |
340 | metric_events = counter->metric_events; |
341 | if (!metric_events) { | |
ded80bda IR |
342 | if (expr__find_other(counter->metric_expr, |
343 | counter->name, | |
344 | &ctx, 1) < 0) | |
37932c18 AK |
345 | continue; |
346 | ||
32dcd021 | 347 | metric_events = calloc(sizeof(struct evsel *), |
ded80bda IR |
348 | hashmap__size(&ctx.ids) + 1); |
349 | if (!metric_events) { | |
350 | expr__ctx_clear(&ctx); | |
37932c18 | 351 | return; |
ded80bda | 352 | } |
37932c18 AK |
353 | counter->metric_events = metric_events; |
354 | } | |
355 | ||
ded80bda IR |
356 | i = 0; |
357 | hashmap__for_each_entry((&ctx.ids), cur, bkt) { | |
358 | const char *metric_name = (const char *)cur->key; | |
359 | ||
37932c18 AK |
360 | found = false; |
361 | if (leader) { | |
362 | /* Search in group */ | |
363 | for_each_group_member (oc, leader) { | |
ded80bda IR |
364 | if (!strcasecmp(oc->name, |
365 | metric_name) && | |
145c407c | 366 | !oc->collect_stat) { |
37932c18 AK |
367 | found = true; |
368 | break; | |
369 | } | |
370 | } | |
371 | } | |
372 | if (!found) { | |
373 | /* Search ignoring groups */ | |
ded80bda IR |
374 | oc = perf_stat__find_event(evsel_list, |
375 | metric_name); | |
37932c18 AK |
376 | } |
377 | if (!oc) { | |
378 | /* Deduping one is good enough to handle duplicated PMUs. */ | |
379 | static char *printed; | |
380 | ||
381 | /* | |
382 | * Adding events automatically would be difficult, because | |
383 | * it would risk creating groups that are not schedulable. | |
384 | * perf stat doesn't understand all the scheduling constraints | |
385 | * of events. So we ask the user instead to add the missing | |
386 | * events. | |
387 | */ | |
ded80bda IR |
388 | if (!printed || |
389 | strcasecmp(printed, metric_name)) { | |
37932c18 AK |
390 | fprintf(stderr, |
391 | "Add %s event to groups to get metric expression for %s\n", | |
ded80bda | 392 | metric_name, |
37932c18 | 393 | counter->name); |
ded80bda | 394 | printed = strdup(metric_name); |
37932c18 AK |
395 | } |
396 | invalid = true; | |
397 | continue; | |
398 | } | |
ded80bda | 399 | metric_events[i++] = oc; |
37932c18 AK |
400 | oc->collect_stat = true; |
401 | } | |
402 | metric_events[i] = NULL; | |
37932c18 AK |
403 | if (invalid) { |
404 | free(metric_events); | |
405 | counter->metric_events = NULL; | |
406 | counter->metric_expr = NULL; | |
407 | } | |
408 | } | |
ded80bda | 409 | expr__ctx_clear(&ctx); |
37932c18 AK |
410 | } |
411 | ||
e0128b30 JY |
412 | static double runtime_stat_avg(struct runtime_stat *st, |
413 | enum stat_type type, int ctx, int cpu) | |
414 | { | |
415 | struct saved_value *v; | |
416 | ||
417 | v = saved_value_lookup(NULL, cpu, false, type, ctx, st); | |
418 | if (!v) | |
419 | return 0.0; | |
420 | ||
421 | return avg_stats(&v->stats); | |
422 | } | |
423 | ||
424 | static double runtime_stat_n(struct runtime_stat *st, | |
425 | enum stat_type type, int ctx, int cpu) | |
426 | { | |
427 | struct saved_value *v; | |
428 | ||
429 | v = saved_value_lookup(NULL, cpu, false, type, ctx, st); | |
430 | if (!v) | |
431 | return 0.0; | |
432 | ||
433 | return v->stats.n; | |
434 | } | |
435 | ||
6ca9a082 JO |
436 | static void print_stalled_cycles_frontend(struct perf_stat_config *config, |
437 | int cpu, | |
32dcd021 | 438 | struct evsel *evsel, double avg, |
e0128b30 JY |
439 | struct perf_stat_output_ctx *out, |
440 | struct runtime_stat *st) | |
f87027b9 JO |
441 | { |
442 | double total, ratio = 0.0; | |
443 | const char *color; | |
444 | int ctx = evsel_context(evsel); | |
445 | ||
e0128b30 | 446 | total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); |
f87027b9 JO |
447 | |
448 | if (total) | |
449 | ratio = avg / total * 100.0; | |
450 | ||
451 | color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio); | |
452 | ||
140aeadc | 453 | if (ratio) |
6ca9a082 | 454 | out->print_metric(config, out->ctx, color, "%7.2f%%", "frontend cycles idle", |
140aeadc AK |
455 | ratio); |
456 | else | |
6ca9a082 | 457 | out->print_metric(config, out->ctx, NULL, NULL, "frontend cycles idle", 0); |
f87027b9 JO |
458 | } |
459 | ||
6ca9a082 JO |
460 | static void print_stalled_cycles_backend(struct perf_stat_config *config, |
461 | int cpu, | |
32dcd021 | 462 | struct evsel *evsel, double avg, |
e0128b30 JY |
463 | struct perf_stat_output_ctx *out, |
464 | struct runtime_stat *st) | |
f87027b9 JO |
465 | { |
466 | double total, ratio = 0.0; | |
467 | const char *color; | |
468 | int ctx = evsel_context(evsel); | |
469 | ||
e0128b30 | 470 | total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); |
f87027b9 JO |
471 | |
472 | if (total) | |
473 | ratio = avg / total * 100.0; | |
474 | ||
475 | color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio); | |
476 | ||
6ca9a082 | 477 | out->print_metric(config, out->ctx, color, "%7.2f%%", "backend cycles idle", ratio); |
f87027b9 JO |
478 | } |
479 | ||
6ca9a082 JO |
480 | static void print_branch_misses(struct perf_stat_config *config, |
481 | int cpu, | |
32dcd021 | 482 | struct evsel *evsel, |
140aeadc | 483 | double avg, |
e0128b30 JY |
484 | struct perf_stat_output_ctx *out, |
485 | struct runtime_stat *st) | |
f87027b9 JO |
486 | { |
487 | double total, ratio = 0.0; | |
488 | const char *color; | |
489 | int ctx = evsel_context(evsel); | |
490 | ||
e0128b30 | 491 | total = runtime_stat_avg(st, STAT_BRANCHES, ctx, cpu); |
f87027b9 JO |
492 | |
493 | if (total) | |
494 | ratio = avg / total * 100.0; | |
495 | ||
496 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
497 | ||
6ca9a082 | 498 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all branches", ratio); |
f87027b9 JO |
499 | } |
500 | ||
6ca9a082 JO |
501 | static void print_l1_dcache_misses(struct perf_stat_config *config, |
502 | int cpu, | |
32dcd021 | 503 | struct evsel *evsel, |
140aeadc | 504 | double avg, |
e0128b30 JY |
505 | struct perf_stat_output_ctx *out, |
506 | struct runtime_stat *st) | |
507 | ||
f87027b9 JO |
508 | { |
509 | double total, ratio = 0.0; | |
510 | const char *color; | |
511 | int ctx = evsel_context(evsel); | |
512 | ||
e0128b30 | 513 | total = runtime_stat_avg(st, STAT_L1_DCACHE, ctx, cpu); |
f87027b9 JO |
514 | |
515 | if (total) | |
516 | ratio = avg / total * 100.0; | |
517 | ||
518 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
519 | ||
6ca9a082 | 520 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-dcache hits", ratio); |
f87027b9 JO |
521 | } |
522 | ||
6ca9a082 JO |
523 | static void print_l1_icache_misses(struct perf_stat_config *config, |
524 | int cpu, | |
32dcd021 | 525 | struct evsel *evsel, |
140aeadc | 526 | double avg, |
e0128b30 JY |
527 | struct perf_stat_output_ctx *out, |
528 | struct runtime_stat *st) | |
529 | ||
f87027b9 JO |
530 | { |
531 | double total, ratio = 0.0; | |
532 | const char *color; | |
533 | int ctx = evsel_context(evsel); | |
534 | ||
e0128b30 | 535 | total = runtime_stat_avg(st, STAT_L1_ICACHE, ctx, cpu); |
f87027b9 JO |
536 | |
537 | if (total) | |
538 | ratio = avg / total * 100.0; | |
539 | ||
540 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
6ca9a082 | 541 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-icache hits", ratio); |
f87027b9 JO |
542 | } |
543 | ||
6ca9a082 JO |
544 | static void print_dtlb_cache_misses(struct perf_stat_config *config, |
545 | int cpu, | |
32dcd021 | 546 | struct evsel *evsel, |
140aeadc | 547 | double avg, |
e0128b30 JY |
548 | struct perf_stat_output_ctx *out, |
549 | struct runtime_stat *st) | |
f87027b9 JO |
550 | { |
551 | double total, ratio = 0.0; | |
552 | const char *color; | |
553 | int ctx = evsel_context(evsel); | |
554 | ||
e0128b30 | 555 | total = runtime_stat_avg(st, STAT_DTLB_CACHE, ctx, cpu); |
f87027b9 JO |
556 | |
557 | if (total) | |
558 | ratio = avg / total * 100.0; | |
559 | ||
560 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
6ca9a082 | 561 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all dTLB cache hits", ratio); |
f87027b9 JO |
562 | } |
563 | ||
6ca9a082 JO |
564 | static void print_itlb_cache_misses(struct perf_stat_config *config, |
565 | int cpu, | |
32dcd021 | 566 | struct evsel *evsel, |
140aeadc | 567 | double avg, |
e0128b30 JY |
568 | struct perf_stat_output_ctx *out, |
569 | struct runtime_stat *st) | |
f87027b9 JO |
570 | { |
571 | double total, ratio = 0.0; | |
572 | const char *color; | |
573 | int ctx = evsel_context(evsel); | |
574 | ||
e0128b30 | 575 | total = runtime_stat_avg(st, STAT_ITLB_CACHE, ctx, cpu); |
f87027b9 JO |
576 | |
577 | if (total) | |
578 | ratio = avg / total * 100.0; | |
579 | ||
580 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
6ca9a082 | 581 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all iTLB cache hits", ratio); |
f87027b9 JO |
582 | } |
583 | ||
6ca9a082 JO |
584 | static void print_ll_cache_misses(struct perf_stat_config *config, |
585 | int cpu, | |
32dcd021 | 586 | struct evsel *evsel, |
140aeadc | 587 | double avg, |
e0128b30 JY |
588 | struct perf_stat_output_ctx *out, |
589 | struct runtime_stat *st) | |
f87027b9 JO |
590 | { |
591 | double total, ratio = 0.0; | |
592 | const char *color; | |
593 | int ctx = evsel_context(evsel); | |
594 | ||
e0128b30 | 595 | total = runtime_stat_avg(st, STAT_LL_CACHE, ctx, cpu); |
f87027b9 JO |
596 | |
597 | if (total) | |
598 | ratio = avg / total * 100.0; | |
599 | ||
600 | color = get_ratio_color(GRC_CACHE_MISSES, ratio); | |
6ca9a082 | 601 | out->print_metric(config, out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio); |
f87027b9 JO |
602 | } |
603 | ||
239bd47f AK |
604 | /* |
605 | * High level "TopDown" CPU core pipe line bottleneck break down. | |
606 | * | |
607 | * Basic concept following | |
608 | * Yasin, A Top Down Method for Performance analysis and Counter architecture | |
609 | * ISPASS14 | |
610 | * | |
611 | * The CPU pipeline is divided into 4 areas that can be bottlenecks: | |
612 | * | |
613 | * Frontend -> Backend -> Retiring | |
614 | * BadSpeculation in addition means out of order execution that is thrown away | |
615 | * (for example branch mispredictions) | |
616 | * Frontend is instruction decoding. | |
617 | * Backend is execution, like computation and accessing data in memory | |
618 | * Retiring is good execution that is not directly bottlenecked | |
619 | * | |
620 | * The formulas are computed in slots. | |
621 | * A slot is an entry in the pipeline each for the pipeline width | |
622 | * (for example a 4-wide pipeline has 4 slots for each cycle) | |
623 | * | |
624 | * Formulas: | |
625 | * BadSpeculation = ((SlotsIssued - SlotsRetired) + RecoveryBubbles) / | |
626 | * TotalSlots | |
627 | * Retiring = SlotsRetired / TotalSlots | |
628 | * FrontendBound = FetchBubbles / TotalSlots | |
629 | * BackendBound = 1.0 - BadSpeculation - Retiring - FrontendBound | |
630 | * | |
631 | * The kernel provides the mapping to the low level CPU events and any scaling | |
632 | * needed for the CPU pipeline width, for example: | |
633 | * | |
634 | * TotalSlots = Cycles * 4 | |
635 | * | |
636 | * The scaling factor is communicated in the sysfs unit. | |
637 | * | |
638 | * In some cases the CPU may not be able to measure all the formulas due to | |
639 | * missing events. In this case multiple formulas are combined, as possible. | |
640 | * | |
641 | * Full TopDown supports more levels to sub-divide each area: for example | |
642 | * BackendBound into computing bound and memory bound. For now we only | |
643 | * support Level 1 TopDown. | |
644 | */ | |
645 | ||
646 | static double sanitize_val(double x) | |
647 | { | |
648 | if (x < 0 && x >= -0.02) | |
649 | return 0.0; | |
650 | return x; | |
651 | } | |
652 | ||
e0128b30 | 653 | static double td_total_slots(int ctx, int cpu, struct runtime_stat *st) |
239bd47f | 654 | { |
e0128b30 | 655 | return runtime_stat_avg(st, STAT_TOPDOWN_TOTAL_SLOTS, ctx, cpu); |
239bd47f AK |
656 | } |
657 | ||
e0128b30 | 658 | static double td_bad_spec(int ctx, int cpu, struct runtime_stat *st) |
239bd47f AK |
659 | { |
660 | double bad_spec = 0; | |
661 | double total_slots; | |
662 | double total; | |
663 | ||
e0128b30 JY |
664 | total = runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_ISSUED, ctx, cpu) - |
665 | runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_RETIRED, ctx, cpu) + | |
666 | runtime_stat_avg(st, STAT_TOPDOWN_RECOVERY_BUBBLES, ctx, cpu); | |
667 | ||
668 | total_slots = td_total_slots(ctx, cpu, st); | |
239bd47f AK |
669 | if (total_slots) |
670 | bad_spec = total / total_slots; | |
671 | return sanitize_val(bad_spec); | |
672 | } | |
673 | ||
e0128b30 | 674 | static double td_retiring(int ctx, int cpu, struct runtime_stat *st) |
239bd47f AK |
675 | { |
676 | double retiring = 0; | |
e0128b30 JY |
677 | double total_slots = td_total_slots(ctx, cpu, st); |
678 | double ret_slots = runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_RETIRED, | |
679 | ctx, cpu); | |
239bd47f AK |
680 | |
681 | if (total_slots) | |
682 | retiring = ret_slots / total_slots; | |
683 | return retiring; | |
684 | } | |
685 | ||
e0128b30 | 686 | static double td_fe_bound(int ctx, int cpu, struct runtime_stat *st) |
239bd47f AK |
687 | { |
688 | double fe_bound = 0; | |
e0128b30 JY |
689 | double total_slots = td_total_slots(ctx, cpu, st); |
690 | double fetch_bub = runtime_stat_avg(st, STAT_TOPDOWN_FETCH_BUBBLES, | |
691 | ctx, cpu); | |
239bd47f AK |
692 | |
693 | if (total_slots) | |
694 | fe_bound = fetch_bub / total_slots; | |
695 | return fe_bound; | |
696 | } | |
697 | ||
e0128b30 | 698 | static double td_be_bound(int ctx, int cpu, struct runtime_stat *st) |
239bd47f | 699 | { |
e0128b30 JY |
700 | double sum = (td_fe_bound(ctx, cpu, st) + |
701 | td_bad_spec(ctx, cpu, st) + | |
702 | td_retiring(ctx, cpu, st)); | |
239bd47f AK |
703 | if (sum == 0) |
704 | return 0; | |
705 | return sanitize_val(1.0 - sum); | |
706 | } | |
707 | ||
6ca9a082 | 708 | static void print_smi_cost(struct perf_stat_config *config, |
32dcd021 | 709 | int cpu, struct evsel *evsel, |
e0128b30 JY |
710 | struct perf_stat_output_ctx *out, |
711 | struct runtime_stat *st) | |
daefd0bc KL |
712 | { |
713 | double smi_num, aperf, cycles, cost = 0.0; | |
714 | int ctx = evsel_context(evsel); | |
715 | const char *color = NULL; | |
716 | ||
e0128b30 JY |
717 | smi_num = runtime_stat_avg(st, STAT_SMI_NUM, ctx, cpu); |
718 | aperf = runtime_stat_avg(st, STAT_APERF, ctx, cpu); | |
719 | cycles = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); | |
daefd0bc KL |
720 | |
721 | if ((cycles == 0) || (aperf == 0)) | |
722 | return; | |
723 | ||
724 | if (smi_num) | |
725 | cost = (aperf - cycles) / aperf * 100.00; | |
726 | ||
727 | if (cost > 10) | |
728 | color = PERF_COLOR_RED; | |
6ca9a082 JO |
729 | out->print_metric(config, out->ctx, color, "%8.1f%%", "SMI cycles%", cost); |
730 | out->print_metric(config, out->ctx, NULL, "%4.0f", "SMI#", smi_num); | |
daefd0bc KL |
731 | } |
732 | ||
2cfaa853 JO |
733 | static int prepare_metric(struct evsel **metric_events, |
734 | struct expr_parse_ctx *pctx, | |
735 | int cpu, | |
736 | struct runtime_stat *st) | |
bba49af8 | 737 | { |
2cfaa853 | 738 | double scale; |
e3a94273 | 739 | char *n, *pn; |
2cfaa853 | 740 | int i; |
bba49af8 | 741 | |
2cfaa853 | 742 | expr__ctx_init(pctx); |
bba49af8 AK |
743 | for (i = 0; metric_events[i]; i++) { |
744 | struct saved_value *v; | |
fd48aad9 | 745 | struct stats *stats; |
f01642e4 | 746 | u64 metric_total = 0; |
fd48aad9 AK |
747 | |
748 | if (!strcmp(metric_events[i]->name, "duration_time")) { | |
749 | stats = &walltime_nsecs_stats; | |
750 | scale = 1e-9; | |
751 | } else { | |
1fcd0394 | 752 | v = saved_value_lookup(metric_events[i], cpu, false, |
e0128b30 | 753 | STAT_NONE, 0, st); |
fd48aad9 AK |
754 | if (!v) |
755 | break; | |
756 | stats = &v->stats; | |
757 | scale = 1.0; | |
f01642e4 JY |
758 | |
759 | if (v->metric_other) | |
760 | metric_total = v->metric_total; | |
fd48aad9 | 761 | } |
e3a94273 AK |
762 | |
763 | n = strdup(metric_events[i]->name); | |
764 | if (!n) | |
2cfaa853 | 765 | return -ENOMEM; |
e3a94273 AK |
766 | /* |
767 | * This display code with --no-merge adds [cpu] postfixes. | |
768 | * These are not supported by the parser. Remove everything | |
769 | * after the space. | |
770 | */ | |
771 | pn = strchr(n, ' '); | |
772 | if (pn) | |
773 | *pn = 0; | |
f01642e4 JY |
774 | |
775 | if (metric_total) | |
2cfaa853 | 776 | expr__add_id(pctx, n, metric_total); |
f01642e4 | 777 | else |
2cfaa853 | 778 | expr__add_id(pctx, n, avg_stats(stats)*scale); |
bba49af8 | 779 | } |
f01642e4 | 780 | |
2cfaa853 JO |
781 | return i; |
782 | } | |
783 | ||
784 | static void generic_metric(struct perf_stat_config *config, | |
785 | const char *metric_expr, | |
786 | struct evsel **metric_events, | |
787 | char *name, | |
788 | const char *metric_name, | |
789 | const char *metric_unit, | |
790 | int runtime, | |
791 | int cpu, | |
792 | struct perf_stat_output_ctx *out, | |
793 | struct runtime_stat *st) | |
794 | { | |
795 | print_metric_t print_metric = out->print_metric; | |
796 | struct expr_parse_ctx pctx; | |
797 | double ratio, scale; | |
798 | int i; | |
799 | void *ctxp = out->ctx; | |
800 | ||
801 | i = prepare_metric(metric_events, &pctx, cpu, st); | |
802 | if (i < 0) | |
803 | return; | |
804 | ||
bba49af8 | 805 | if (!metric_events[i]) { |
1e1a873d | 806 | if (expr__parse(&ratio, &pctx, metric_expr, runtime) == 0) { |
287f2649 JY |
807 | char *unit; |
808 | char metric_bf[64]; | |
809 | ||
810 | if (metric_unit && metric_name) { | |
811 | if (perf_pmu__convert_scale(metric_unit, | |
812 | &unit, &scale) >= 0) { | |
813 | ratio *= scale; | |
814 | } | |
1e1a873d KJ |
815 | if (strstr(metric_expr, "?")) |
816 | scnprintf(metric_bf, sizeof(metric_bf), | |
817 | "%s %s_%d", unit, metric_name, runtime); | |
818 | else | |
819 | scnprintf(metric_bf, sizeof(metric_bf), | |
287f2649 | 820 | "%s %s", unit, metric_name); |
1e1a873d | 821 | |
287f2649 JY |
822 | print_metric(config, ctxp, NULL, "%8.1f", |
823 | metric_bf, ratio); | |
824 | } else { | |
d4d5ca0b | 825 | print_metric(config, ctxp, NULL, "%8.2f", |
287f2649 JY |
826 | metric_name ? |
827 | metric_name : | |
828 | out->force_header ? name : "", | |
829 | ratio); | |
830 | } | |
831 | } else { | |
6ca9a082 | 832 | print_metric(config, ctxp, NULL, NULL, |
4ed962eb AK |
833 | out->force_header ? |
834 | (metric_name ? metric_name : name) : "", 0); | |
287f2649 | 835 | } |
8358f698 JY |
836 | } else { |
837 | print_metric(config, ctxp, NULL, NULL, | |
838 | out->force_header ? | |
839 | (metric_name ? metric_name : name) : "", 0); | |
840 | } | |
e3a94273 | 841 | |
ded80bda | 842 | expr__ctx_clear(&pctx); |
bba49af8 AK |
843 | } |
844 | ||
6d432c4c JO |
845 | double test_generic_metric(struct metric_expr *mexp, int cpu, struct runtime_stat *st) |
846 | { | |
847 | struct expr_parse_ctx pctx; | |
848 | double ratio; | |
849 | ||
850 | if (prepare_metric(mexp->metric_events, &pctx, cpu, st) < 0) | |
851 | return 0.; | |
852 | ||
853 | if (expr__parse(&ratio, &pctx, mexp->metric_expr, 1)) | |
854 | return 0.; | |
855 | ||
856 | return ratio; | |
857 | } | |
858 | ||
6ca9a082 | 859 | void perf_stat__print_shadow_stats(struct perf_stat_config *config, |
32dcd021 | 860 | struct evsel *evsel, |
140aeadc | 861 | double avg, int cpu, |
b18f3e36 | 862 | struct perf_stat_output_ctx *out, |
e0128b30 JY |
863 | struct rblist *metric_events, |
864 | struct runtime_stat *st) | |
f87027b9 | 865 | { |
140aeadc AK |
866 | void *ctxp = out->ctx; |
867 | print_metric_t print_metric = out->print_metric; | |
f87027b9 | 868 | double total, ratio = 0.0, total2; |
239bd47f | 869 | const char *color = NULL; |
f87027b9 | 870 | int ctx = evsel_context(evsel); |
b18f3e36 AK |
871 | struct metric_event *me; |
872 | int num = 1; | |
f87027b9 | 873 | |
c754c382 | 874 | if (evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { |
e0128b30 JY |
875 | total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); |
876 | ||
f87027b9 JO |
877 | if (total) { |
878 | ratio = avg / total; | |
6ca9a082 | 879 | print_metric(config, ctxp, NULL, "%7.2f ", |
140aeadc | 880 | "insn per cycle", ratio); |
f87027b9 | 881 | } else { |
6ca9a082 | 882 | print_metric(config, ctxp, NULL, NULL, "insn per cycle", 0); |
f87027b9 | 883 | } |
e0128b30 JY |
884 | |
885 | total = runtime_stat_avg(st, STAT_STALLED_CYCLES_FRONT, | |
886 | ctx, cpu); | |
887 | ||
888 | total = max(total, runtime_stat_avg(st, | |
889 | STAT_STALLED_CYCLES_BACK, | |
890 | ctx, cpu)); | |
f87027b9 JO |
891 | |
892 | if (total && avg) { | |
6ca9a082 | 893 | out->new_line(config, ctxp); |
f87027b9 | 894 | ratio = total / avg; |
6ca9a082 | 895 | print_metric(config, ctxp, NULL, "%7.2f ", |
140aeadc AK |
896 | "stalled cycles per insn", |
897 | ratio); | |
f87027b9 | 898 | } |
c754c382 | 899 | } else if (evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) { |
e0128b30 | 900 | if (runtime_stat_n(st, STAT_BRANCHES, ctx, cpu) != 0) |
6ca9a082 | 901 | print_branch_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 902 | else |
6ca9a082 | 903 | print_metric(config, ctxp, NULL, NULL, "of all branches", 0); |
f87027b9 | 904 | } else if ( |
1fc632ce JO |
905 | evsel->core.attr.type == PERF_TYPE_HW_CACHE && |
906 | evsel->core.attr.config == ( PERF_COUNT_HW_CACHE_L1D | | |
f87027b9 | 907 | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | |
140aeadc | 908 | ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { |
e0128b30 JY |
909 | |
910 | if (runtime_stat_n(st, STAT_L1_DCACHE, ctx, cpu) != 0) | |
6ca9a082 | 911 | print_l1_dcache_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 912 | else |
6ca9a082 | 913 | print_metric(config, ctxp, NULL, NULL, "of all L1-dcache hits", 0); |
f87027b9 | 914 | } else if ( |
1fc632ce JO |
915 | evsel->core.attr.type == PERF_TYPE_HW_CACHE && |
916 | evsel->core.attr.config == ( PERF_COUNT_HW_CACHE_L1I | | |
f87027b9 | 917 | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | |
140aeadc | 918 | ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { |
e0128b30 JY |
919 | |
920 | if (runtime_stat_n(st, STAT_L1_ICACHE, ctx, cpu) != 0) | |
6ca9a082 | 921 | print_l1_icache_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 922 | else |
6ca9a082 | 923 | print_metric(config, ctxp, NULL, NULL, "of all L1-icache hits", 0); |
f87027b9 | 924 | } else if ( |
1fc632ce JO |
925 | evsel->core.attr.type == PERF_TYPE_HW_CACHE && |
926 | evsel->core.attr.config == ( PERF_COUNT_HW_CACHE_DTLB | | |
f87027b9 | 927 | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | |
140aeadc | 928 | ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { |
e0128b30 JY |
929 | |
930 | if (runtime_stat_n(st, STAT_DTLB_CACHE, ctx, cpu) != 0) | |
6ca9a082 | 931 | print_dtlb_cache_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 932 | else |
6ca9a082 | 933 | print_metric(config, ctxp, NULL, NULL, "of all dTLB cache hits", 0); |
f87027b9 | 934 | } else if ( |
1fc632ce JO |
935 | evsel->core.attr.type == PERF_TYPE_HW_CACHE && |
936 | evsel->core.attr.config == ( PERF_COUNT_HW_CACHE_ITLB | | |
f87027b9 | 937 | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | |
140aeadc | 938 | ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { |
e0128b30 JY |
939 | |
940 | if (runtime_stat_n(st, STAT_ITLB_CACHE, ctx, cpu) != 0) | |
6ca9a082 | 941 | print_itlb_cache_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 942 | else |
6ca9a082 | 943 | print_metric(config, ctxp, NULL, NULL, "of all iTLB cache hits", 0); |
f87027b9 | 944 | } else if ( |
1fc632ce JO |
945 | evsel->core.attr.type == PERF_TYPE_HW_CACHE && |
946 | evsel->core.attr.config == ( PERF_COUNT_HW_CACHE_LL | | |
f87027b9 | 947 | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | |
140aeadc | 948 | ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { |
e0128b30 JY |
949 | |
950 | if (runtime_stat_n(st, STAT_LL_CACHE, ctx, cpu) != 0) | |
6ca9a082 | 951 | print_ll_cache_misses(config, cpu, evsel, avg, out, st); |
140aeadc | 952 | else |
6ca9a082 | 953 | print_metric(config, ctxp, NULL, NULL, "of all LL-cache hits", 0); |
c754c382 | 954 | } else if (evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) { |
e0128b30 | 955 | total = runtime_stat_avg(st, STAT_CACHEREFS, ctx, cpu); |
f87027b9 JO |
956 | |
957 | if (total) | |
958 | ratio = avg * 100 / total; | |
959 | ||
e0128b30 | 960 | if (runtime_stat_n(st, STAT_CACHEREFS, ctx, cpu) != 0) |
6ca9a082 | 961 | print_metric(config, ctxp, NULL, "%8.3f %%", |
140aeadc AK |
962 | "of all cache refs", ratio); |
963 | else | |
6ca9a082 | 964 | print_metric(config, ctxp, NULL, NULL, "of all cache refs", 0); |
c754c382 | 965 | } else if (evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) { |
6ca9a082 | 966 | print_stalled_cycles_frontend(config, cpu, evsel, avg, out, st); |
c754c382 | 967 | } else if (evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) { |
6ca9a082 | 968 | print_stalled_cycles_backend(config, cpu, evsel, avg, out, st); |
c754c382 | 969 | } else if (evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) { |
e0128b30 | 970 | total = runtime_stat_avg(st, STAT_NSECS, 0, cpu); |
f87027b9 JO |
971 | |
972 | if (total) { | |
973 | ratio = avg / total; | |
6ca9a082 | 974 | print_metric(config, ctxp, NULL, "%8.3f", "GHz", ratio); |
f87027b9 | 975 | } else { |
6ca9a082 | 976 | print_metric(config, ctxp, NULL, NULL, "Ghz", 0); |
f87027b9 JO |
977 | } |
978 | } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) { | |
e0128b30 JY |
979 | total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); |
980 | ||
f87027b9 | 981 | if (total) |
6ca9a082 | 982 | print_metric(config, ctxp, NULL, |
140aeadc AK |
983 | "%7.2f%%", "transactional cycles", |
984 | 100.0 * (avg / total)); | |
985 | else | |
6ca9a082 | 986 | print_metric(config, ctxp, NULL, NULL, "transactional cycles", |
140aeadc | 987 | 0); |
f87027b9 | 988 | } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) { |
e0128b30 JY |
989 | total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu); |
990 | total2 = runtime_stat_avg(st, STAT_CYCLES_IN_TX, ctx, cpu); | |
991 | ||
f87027b9 JO |
992 | if (total2 < avg) |
993 | total2 = avg; | |
994 | if (total) | |
6ca9a082 | 995 | print_metric(config, ctxp, NULL, "%7.2f%%", "aborted cycles", |
f87027b9 | 996 | 100.0 * ((total2-avg) / total)); |
140aeadc | 997 | else |
6ca9a082 | 998 | print_metric(config, ctxp, NULL, NULL, "aborted cycles", 0); |
140aeadc | 999 | } else if (perf_stat_evsel__is(evsel, TRANSACTION_START)) { |
e0128b30 JY |
1000 | total = runtime_stat_avg(st, STAT_CYCLES_IN_TX, |
1001 | ctx, cpu); | |
f87027b9 | 1002 | |
54976285 | 1003 | if (avg) |
f87027b9 JO |
1004 | ratio = total / avg; |
1005 | ||
e0128b30 | 1006 | if (runtime_stat_n(st, STAT_CYCLES_IN_TX, ctx, cpu) != 0) |
6ca9a082 | 1007 | print_metric(config, ctxp, NULL, "%8.0f", |
140aeadc AK |
1008 | "cycles / transaction", ratio); |
1009 | else | |
6ca9a082 | 1010 | print_metric(config, ctxp, NULL, NULL, "cycles / transaction", |
e0128b30 | 1011 | 0); |
140aeadc | 1012 | } else if (perf_stat_evsel__is(evsel, ELISION_START)) { |
e0128b30 JY |
1013 | total = runtime_stat_avg(st, STAT_CYCLES_IN_TX, |
1014 | ctx, cpu); | |
f87027b9 | 1015 | |
54976285 | 1016 | if (avg) |
f87027b9 JO |
1017 | ratio = total / avg; |
1018 | ||
6ca9a082 | 1019 | print_metric(config, ctxp, NULL, "%8.0f", "cycles / elision", ratio); |
c754c382 | 1020 | } else if (evsel__is_clock(evsel)) { |
4579ecc8 | 1021 | if ((ratio = avg_stats(&walltime_nsecs_stats)) != 0) |
6ca9a082 | 1022 | print_metric(config, ctxp, NULL, "%8.3f", "CPUs utilized", |
0aa802a7 | 1023 | avg / (ratio * evsel->scale)); |
4579ecc8 | 1024 | else |
6ca9a082 | 1025 | print_metric(config, ctxp, NULL, NULL, "CPUs utilized", 0); |
239bd47f | 1026 | } else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) { |
e0128b30 | 1027 | double fe_bound = td_fe_bound(ctx, cpu, st); |
239bd47f AK |
1028 | |
1029 | if (fe_bound > 0.2) | |
1030 | color = PERF_COLOR_RED; | |
6ca9a082 | 1031 | print_metric(config, ctxp, color, "%8.1f%%", "frontend bound", |
239bd47f AK |
1032 | fe_bound * 100.); |
1033 | } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) { | |
e0128b30 | 1034 | double retiring = td_retiring(ctx, cpu, st); |
239bd47f AK |
1035 | |
1036 | if (retiring > 0.7) | |
1037 | color = PERF_COLOR_GREEN; | |
6ca9a082 | 1038 | print_metric(config, ctxp, color, "%8.1f%%", "retiring", |
239bd47f AK |
1039 | retiring * 100.); |
1040 | } else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) { | |
e0128b30 | 1041 | double bad_spec = td_bad_spec(ctx, cpu, st); |
239bd47f AK |
1042 | |
1043 | if (bad_spec > 0.1) | |
1044 | color = PERF_COLOR_RED; | |
6ca9a082 | 1045 | print_metric(config, ctxp, color, "%8.1f%%", "bad speculation", |
239bd47f AK |
1046 | bad_spec * 100.); |
1047 | } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) { | |
e0128b30 | 1048 | double be_bound = td_be_bound(ctx, cpu, st); |
239bd47f AK |
1049 | const char *name = "backend bound"; |
1050 | static int have_recovery_bubbles = -1; | |
1051 | ||
1052 | /* In case the CPU does not support topdown-recovery-bubbles */ | |
1053 | if (have_recovery_bubbles < 0) | |
1054 | have_recovery_bubbles = pmu_have_event("cpu", | |
1055 | "topdown-recovery-bubbles"); | |
1056 | if (!have_recovery_bubbles) | |
1057 | name = "backend bound/bad spec"; | |
1058 | ||
1059 | if (be_bound > 0.2) | |
1060 | color = PERF_COLOR_RED; | |
e0128b30 | 1061 | if (td_total_slots(ctx, cpu, st) > 0) |
6ca9a082 | 1062 | print_metric(config, ctxp, color, "%8.1f%%", name, |
239bd47f AK |
1063 | be_bound * 100.); |
1064 | else | |
6ca9a082 | 1065 | print_metric(config, ctxp, NULL, NULL, name, 0); |
37932c18 | 1066 | } else if (evsel->metric_expr) { |
6ca9a082 | 1067 | generic_metric(config, evsel->metric_expr, evsel->metric_events, evsel->name, |
5f09ca5a | 1068 | evsel->metric_name, NULL, 1, cpu, out, st); |
e0128b30 | 1069 | } else if (runtime_stat_n(st, STAT_NSECS, 0, cpu) != 0) { |
f87027b9 | 1070 | char unit = 'M'; |
140aeadc | 1071 | char unit_buf[10]; |
f87027b9 | 1072 | |
e0128b30 | 1073 | total = runtime_stat_avg(st, STAT_NSECS, 0, cpu); |
f87027b9 JO |
1074 | |
1075 | if (total) | |
1076 | ratio = 1000.0 * avg / total; | |
1077 | if (ratio < 0.001) { | |
1078 | ratio *= 1000; | |
1079 | unit = 'K'; | |
1080 | } | |
140aeadc | 1081 | snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit); |
6ca9a082 | 1082 | print_metric(config, ctxp, NULL, "%8.3f", unit_buf, ratio); |
daefd0bc | 1083 | } else if (perf_stat_evsel__is(evsel, SMI_NUM)) { |
6ca9a082 | 1084 | print_smi_cost(config, cpu, evsel, out, st); |
f87027b9 | 1085 | } else { |
b18f3e36 | 1086 | num = 0; |
f87027b9 | 1087 | } |
b18f3e36 AK |
1088 | |
1089 | if ((me = metricgroup__lookup(metric_events, evsel, false)) != NULL) { | |
1090 | struct metric_expr *mexp; | |
1091 | ||
1092 | list_for_each_entry (mexp, &me->head, nd) { | |
1093 | if (num++ > 0) | |
6ca9a082 JO |
1094 | out->new_line(config, ctxp); |
1095 | generic_metric(config, mexp->metric_expr, mexp->metric_events, | |
b18f3e36 | 1096 | evsel->name, mexp->metric_name, |
5f09ca5a | 1097 | mexp->metric_unit, mexp->runtime, cpu, out, st); |
b18f3e36 AK |
1098 | } |
1099 | } | |
1100 | if (num == 0) | |
6ca9a082 | 1101 | print_metric(config, ctxp, NULL, NULL, NULL, 0); |
f87027b9 | 1102 | } |