1 // SPDX-License-Identifier: GPL-2.0 2 #include <math.h> 3 #include <stdio.h> 4 #include "evsel.h" 5 #include "stat.h" 6 #include "color.h" 7 #include "debug.h" 8 #include "pmu.h" 9 #include "rblist.h" 10 #include "evlist.h" 11 #include "expr.h" 12 #include "metricgroup.h" 13 #include "cgroup.h" 14 #include "units.h" 15 #include <linux/zalloc.h> 16 #include "iostat.h" 17 #include "util/hashmap.h" 18 19 struct stats walltime_nsecs_stats; 20 struct rusage_stats ru_stats; 21 22 enum { 23 CTX_BIT_USER = 1 << 0, 24 CTX_BIT_KERNEL = 1 << 1, 25 CTX_BIT_HV = 1 << 2, 26 CTX_BIT_HOST = 1 << 3, 27 CTX_BIT_IDLE = 1 << 4, 28 CTX_BIT_MAX = 1 << 5, 29 }; 30 31 enum stat_type { 32 STAT_NONE = 0, 33 STAT_NSECS, 34 STAT_CYCLES, 35 STAT_INSTRUCTIONS, 36 STAT_STALLED_CYCLES_FRONT, 37 STAT_STALLED_CYCLES_BACK, 38 STAT_BRANCHES, 39 STAT_BRANCH_MISS, 40 STAT_CACHE_REFS, 41 STAT_CACHE_MISSES, 42 STAT_L1_DCACHE, 43 STAT_L1_ICACHE, 44 STAT_LL_CACHE, 45 STAT_ITLB_CACHE, 46 STAT_DTLB_CACHE, 47 STAT_L1D_MISS, 48 STAT_L1I_MISS, 49 STAT_LL_MISS, 50 STAT_DTLB_MISS, 51 STAT_ITLB_MISS, 52 STAT_MAX 53 }; 54 55 static int evsel_context(const struct evsel *evsel) 56 { 57 int ctx = 0; 58 59 if (evsel->core.attr.exclude_kernel) 60 ctx |= CTX_BIT_KERNEL; 61 if (evsel->core.attr.exclude_user) 62 ctx |= CTX_BIT_USER; 63 if (evsel->core.attr.exclude_hv) 64 ctx |= CTX_BIT_HV; 65 if (evsel->core.attr.exclude_host) 66 ctx |= CTX_BIT_HOST; 67 if (evsel->core.attr.exclude_idle) 68 ctx |= CTX_BIT_IDLE; 69 70 return ctx; 71 } 72 73 void perf_stat__reset_shadow_stats(void) 74 { 75 memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats)); 76 memset(&ru_stats, 0, sizeof(ru_stats)); 77 } 78 79 static enum stat_type evsel__stat_type(const struct evsel *evsel) 80 { 81 /* Fake perf_hw_cache_op_id values for use with evsel__match. */ 82 u64 PERF_COUNT_hw_cache_l1d_miss = PERF_COUNT_HW_CACHE_L1D | 83 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 84 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16); 85 u64 PERF_COUNT_hw_cache_l1i_miss = PERF_COUNT_HW_CACHE_L1I | 86 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 87 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16); 88 u64 PERF_COUNT_hw_cache_ll_miss = PERF_COUNT_HW_CACHE_LL | 89 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 90 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16); 91 u64 PERF_COUNT_hw_cache_dtlb_miss = PERF_COUNT_HW_CACHE_DTLB | 92 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 93 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16); 94 u64 PERF_COUNT_hw_cache_itlb_miss = PERF_COUNT_HW_CACHE_ITLB | 95 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 96 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16); 97 98 if (evsel__is_clock(evsel)) 99 return STAT_NSECS; 100 else if (evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) 101 return STAT_CYCLES; 102 else if (evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) 103 return STAT_INSTRUCTIONS; 104 else if (evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) 105 return STAT_STALLED_CYCLES_FRONT; 106 else if (evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) 107 return STAT_STALLED_CYCLES_BACK; 108 else if (evsel__match(evsel, HARDWARE, HW_BRANCH_INSTRUCTIONS)) 109 return STAT_BRANCHES; 110 else if (evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) 111 return STAT_BRANCH_MISS; 112 else if (evsel__match(evsel, HARDWARE, HW_CACHE_REFERENCES)) 113 return STAT_CACHE_REFS; 114 else if (evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) 115 return STAT_CACHE_MISSES; 116 else if (evsel__match(evsel, HW_CACHE, HW_CACHE_L1D)) 117 return STAT_L1_DCACHE; 118 else if (evsel__match(evsel, HW_CACHE, HW_CACHE_L1I)) 119 return STAT_L1_ICACHE; 120 else if (evsel__match(evsel, HW_CACHE, HW_CACHE_LL)) 121 return STAT_LL_CACHE; 122 else if (evsel__match(evsel, HW_CACHE, HW_CACHE_DTLB)) 123 return STAT_DTLB_CACHE; 124 else if (evsel__match(evsel, HW_CACHE, HW_CACHE_ITLB)) 125 return STAT_ITLB_CACHE; 126 else if (evsel__match(evsel, HW_CACHE, hw_cache_l1d_miss)) 127 return STAT_L1D_MISS; 128 else if (evsel__match(evsel, HW_CACHE, hw_cache_l1i_miss)) 129 return STAT_L1I_MISS; 130 else if (evsel__match(evsel, HW_CACHE, hw_cache_ll_miss)) 131 return STAT_LL_MISS; 132 else if (evsel__match(evsel, HW_CACHE, hw_cache_dtlb_miss)) 133 return STAT_DTLB_MISS; 134 else if (evsel__match(evsel, HW_CACHE, hw_cache_itlb_miss)) 135 return STAT_ITLB_MISS; 136 return STAT_NONE; 137 } 138 139 static const char *get_ratio_color(const double ratios[3], double val) 140 { 141 const char *color = PERF_COLOR_NORMAL; 142 143 if (val > ratios[0]) 144 color = PERF_COLOR_RED; 145 else if (val > ratios[1]) 146 color = PERF_COLOR_MAGENTA; 147 else if (val > ratios[2]) 148 color = PERF_COLOR_YELLOW; 149 150 return color; 151 } 152 153 static double find_stat(const struct evsel *evsel, int aggr_idx, enum stat_type type) 154 { 155 const struct evsel *cur; 156 int evsel_ctx = evsel_context(evsel); 157 158 evlist__for_each_entry(evsel->evlist, cur) { 159 struct perf_stat_aggr *aggr; 160 161 /* Ignore the evsel that is being searched from. */ 162 if (evsel == cur) 163 continue; 164 165 /* Ignore evsels that are part of different groups. */ 166 if (evsel->core.leader->nr_members > 1 && 167 evsel->core.leader != cur->core.leader) 168 continue; 169 /* Ignore evsels with mismatched modifiers. */ 170 if (evsel_ctx != evsel_context(cur)) 171 continue; 172 /* Ignore if not the cgroup we're looking for. */ 173 if (evsel->cgrp != cur->cgrp) 174 continue; 175 /* Ignore if not the stat we're looking for. */ 176 if (type != evsel__stat_type(cur)) 177 continue; 178 179 /* 180 * Except the SW CLOCK events, 181 * ignore if not the PMU we're looking for. 182 */ 183 if ((type != STAT_NSECS) && (evsel->pmu != cur->pmu)) 184 continue; 185 186 aggr = &cur->stats->aggr[aggr_idx]; 187 if (type == STAT_NSECS) 188 return aggr->counts.val; 189 return aggr->counts.val * cur->scale; 190 } 191 return 0.0; 192 } 193 194 static void print_ratio(struct perf_stat_config *config, 195 const struct evsel *evsel, int aggr_idx, 196 double numerator, struct perf_stat_output_ctx *out, 197 enum stat_type denominator_type, 198 const double color_ratios[3], const char *unit) 199 { 200 double denominator = find_stat(evsel, aggr_idx, denominator_type); 201 202 if (numerator && denominator) { 203 double ratio = numerator / denominator * 100.0; 204 const char *color = get_ratio_color(color_ratios, ratio); 205 206 out->print_metric(config, out->ctx, color, "%7.2f%%", unit, ratio); 207 } else 208 out->print_metric(config, out->ctx, NULL, NULL, unit, 0); 209 } 210 211 static void print_stalled_cycles_front(struct perf_stat_config *config, 212 const struct evsel *evsel, 213 int aggr_idx, double stalled, 214 struct perf_stat_output_ctx *out) 215 { 216 static const double color_ratios[3] = {50.0, 30.0, 10.0}; 217 218 print_ratio(config, evsel, aggr_idx, stalled, out, STAT_CYCLES, color_ratios, 219 "frontend cycles idle"); 220 } 221 222 static void print_stalled_cycles_back(struct perf_stat_config *config, 223 const struct evsel *evsel, 224 int aggr_idx, double stalled, 225 struct perf_stat_output_ctx *out) 226 { 227 static const double color_ratios[3] = {75.0, 50.0, 20.0}; 228 229 print_ratio(config, evsel, aggr_idx, stalled, out, STAT_CYCLES, color_ratios, 230 "backend cycles idle"); 231 } 232 233 static void print_branch_miss(struct perf_stat_config *config, 234 const struct evsel *evsel, 235 int aggr_idx, double misses, 236 struct perf_stat_output_ctx *out) 237 { 238 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 239 240 print_ratio(config, evsel, aggr_idx, misses, out, STAT_BRANCHES, color_ratios, 241 "of all branches"); 242 } 243 244 static void print_l1d_miss(struct perf_stat_config *config, 245 const struct evsel *evsel, 246 int aggr_idx, double misses, 247 struct perf_stat_output_ctx *out) 248 { 249 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 250 251 print_ratio(config, evsel, aggr_idx, misses, out, STAT_L1_DCACHE, color_ratios, 252 "of all L1-dcache accesses"); 253 } 254 255 static void print_l1i_miss(struct perf_stat_config *config, 256 const struct evsel *evsel, 257 int aggr_idx, double misses, 258 struct perf_stat_output_ctx *out) 259 { 260 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 261 262 print_ratio(config, evsel, aggr_idx, misses, out, STAT_L1_ICACHE, color_ratios, 263 "of all L1-icache accesses"); 264 } 265 266 static void print_ll_miss(struct perf_stat_config *config, 267 const struct evsel *evsel, 268 int aggr_idx, double misses, 269 struct perf_stat_output_ctx *out) 270 { 271 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 272 273 print_ratio(config, evsel, aggr_idx, misses, out, STAT_LL_CACHE, color_ratios, 274 "of all LL-cache accesses"); 275 } 276 277 static void print_dtlb_miss(struct perf_stat_config *config, 278 const struct evsel *evsel, 279 int aggr_idx, double misses, 280 struct perf_stat_output_ctx *out) 281 { 282 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 283 284 print_ratio(config, evsel, aggr_idx, misses, out, STAT_DTLB_CACHE, color_ratios, 285 "of all dTLB cache accesses"); 286 } 287 288 static void print_itlb_miss(struct perf_stat_config *config, 289 const struct evsel *evsel, 290 int aggr_idx, double misses, 291 struct perf_stat_output_ctx *out) 292 { 293 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 294 295 print_ratio(config, evsel, aggr_idx, misses, out, STAT_ITLB_CACHE, color_ratios, 296 "of all iTLB cache accesses"); 297 } 298 299 static void print_cache_miss(struct perf_stat_config *config, 300 const struct evsel *evsel, 301 int aggr_idx, double misses, 302 struct perf_stat_output_ctx *out) 303 { 304 static const double color_ratios[3] = {20.0, 10.0, 5.0}; 305 306 print_ratio(config, evsel, aggr_idx, misses, out, STAT_CACHE_REFS, color_ratios, 307 "of all cache refs"); 308 } 309 310 static void print_instructions(struct perf_stat_config *config, 311 const struct evsel *evsel, 312 int aggr_idx, double instructions, 313 struct perf_stat_output_ctx *out) 314 { 315 print_metric_t print_metric = out->print_metric; 316 void *ctxp = out->ctx; 317 double cycles = find_stat(evsel, aggr_idx, STAT_CYCLES); 318 double max_stalled = max(find_stat(evsel, aggr_idx, STAT_STALLED_CYCLES_FRONT), 319 find_stat(evsel, aggr_idx, STAT_STALLED_CYCLES_BACK)); 320 321 if (cycles) { 322 print_metric(config, ctxp, NULL, "%7.2f ", "insn per cycle", 323 instructions / cycles); 324 } else 325 print_metric(config, ctxp, NULL, NULL, "insn per cycle", 0); 326 327 if (max_stalled && instructions) { 328 out->new_line(config, ctxp); 329 print_metric(config, ctxp, NULL, "%7.2f ", "stalled cycles per insn", 330 max_stalled / instructions); 331 } 332 } 333 334 static void print_cycles(struct perf_stat_config *config, 335 const struct evsel *evsel, 336 int aggr_idx, double cycles, 337 struct perf_stat_output_ctx *out) 338 { 339 double nsecs = find_stat(evsel, aggr_idx, STAT_NSECS); 340 341 if (cycles && nsecs) { 342 double ratio = cycles / nsecs; 343 344 out->print_metric(config, out->ctx, NULL, "%8.3f", "GHz", ratio); 345 } else 346 out->print_metric(config, out->ctx, NULL, NULL, "GHz", 0); 347 } 348 349 static void print_nsecs(struct perf_stat_config *config, 350 const struct evsel *evsel, 351 int aggr_idx __maybe_unused, double nsecs, 352 struct perf_stat_output_ctx *out) 353 { 354 print_metric_t print_metric = out->print_metric; 355 void *ctxp = out->ctx; 356 double wall_time = avg_stats(&walltime_nsecs_stats); 357 358 if (wall_time) { 359 print_metric(config, ctxp, NULL, "%8.3f", "CPUs utilized", 360 nsecs / (wall_time * evsel->scale)); 361 } else 362 print_metric(config, ctxp, NULL, NULL, "CPUs utilized", 0); 363 } 364 365 static int prepare_metric(const struct metric_expr *mexp, 366 const struct evsel *evsel, 367 struct expr_parse_ctx *pctx, 368 int aggr_idx) 369 { 370 struct evsel * const *metric_events = mexp->metric_events; 371 struct metric_ref *metric_refs = mexp->metric_refs; 372 int i; 373 374 for (i = 0; metric_events[i]; i++) { 375 char *n; 376 double val; 377 int source_count = 0; 378 379 if (evsel__is_tool(metric_events[i])) { 380 struct stats *stats; 381 double scale; 382 383 switch (metric_events[i]->tool_event) { 384 case PERF_TOOL_DURATION_TIME: 385 stats = &walltime_nsecs_stats; 386 scale = 1e-9; 387 break; 388 case PERF_TOOL_USER_TIME: 389 stats = &ru_stats.ru_utime_usec_stat; 390 scale = 1e-6; 391 break; 392 case PERF_TOOL_SYSTEM_TIME: 393 stats = &ru_stats.ru_stime_usec_stat; 394 scale = 1e-6; 395 break; 396 case PERF_TOOL_NONE: 397 pr_err("Invalid tool event 'none'"); 398 abort(); 399 case PERF_TOOL_MAX: 400 pr_err("Invalid tool event 'max'"); 401 abort(); 402 default: 403 pr_err("Unknown tool event '%s'", evsel__name(metric_events[i])); 404 abort(); 405 } 406 val = avg_stats(stats) * scale; 407 source_count = 1; 408 } else { 409 struct perf_stat_evsel *ps = metric_events[i]->stats; 410 struct perf_stat_aggr *aggr; 411 412 /* 413 * If there are multiple uncore PMUs and we're not 414 * reading the leader's stats, determine the stats for 415 * the appropriate uncore PMU. 416 */ 417 if (evsel && evsel->metric_leader && 418 evsel->pmu != evsel->metric_leader->pmu && 419 mexp->metric_events[i]->pmu == evsel->metric_leader->pmu) { 420 struct evsel *pos; 421 422 evlist__for_each_entry(evsel->evlist, pos) { 423 if (pos->pmu != evsel->pmu) 424 continue; 425 if (pos->metric_leader != mexp->metric_events[i]) 426 continue; 427 ps = pos->stats; 428 source_count = 1; 429 break; 430 } 431 } 432 aggr = &ps->aggr[aggr_idx]; 433 if (!aggr) 434 break; 435 436 if (!metric_events[i]->supported) { 437 /* 438 * Not supported events will have a count of 0, 439 * which can be confusing in a 440 * metric. Explicitly set the value to NAN. Not 441 * counted events (enable time of 0) are read as 442 * 0. 443 */ 444 val = NAN; 445 source_count = 0; 446 } else { 447 val = aggr->counts.val; 448 if (!source_count) 449 source_count = evsel__source_count(metric_events[i]); 450 } 451 } 452 n = strdup(evsel__metric_id(metric_events[i])); 453 if (!n) 454 return -ENOMEM; 455 456 expr__add_id_val_source_count(pctx, n, val, source_count); 457 } 458 459 for (int j = 0; metric_refs && metric_refs[j].metric_name; j++) { 460 int ret = expr__add_ref(pctx, &metric_refs[j]); 461 462 if (ret) 463 return ret; 464 } 465 466 return i; 467 } 468 469 static void generic_metric(struct perf_stat_config *config, 470 struct metric_expr *mexp, 471 struct evsel *evsel, 472 int aggr_idx, 473 struct perf_stat_output_ctx *out) 474 { 475 print_metric_t print_metric = out->print_metric; 476 const char *metric_name = mexp->metric_name; 477 const char *metric_expr = mexp->metric_expr; 478 const char *metric_threshold = mexp->metric_threshold; 479 const char *metric_unit = mexp->metric_unit; 480 struct evsel * const *metric_events = mexp->metric_events; 481 int runtime = mexp->runtime; 482 struct expr_parse_ctx *pctx; 483 double ratio, scale, threshold; 484 int i; 485 void *ctxp = out->ctx; 486 const char *color = NULL; 487 488 pctx = expr__ctx_new(); 489 if (!pctx) 490 return; 491 492 if (config->user_requested_cpu_list) 493 pctx->sctx.user_requested_cpu_list = strdup(config->user_requested_cpu_list); 494 pctx->sctx.runtime = runtime; 495 pctx->sctx.system_wide = config->system_wide; 496 i = prepare_metric(mexp, evsel, pctx, aggr_idx); 497 if (i < 0) { 498 expr__ctx_free(pctx); 499 return; 500 } 501 if (!metric_events[i]) { 502 if (expr__parse(&ratio, pctx, metric_expr) == 0) { 503 char *unit; 504 char metric_bf[64]; 505 506 if (metric_threshold && 507 expr__parse(&threshold, pctx, metric_threshold) == 0 && 508 !isnan(threshold)) { 509 color = fpclassify(threshold) == FP_ZERO 510 ? PERF_COLOR_GREEN : PERF_COLOR_RED; 511 } 512 513 if (metric_unit && metric_name) { 514 if (perf_pmu__convert_scale(metric_unit, 515 &unit, &scale) >= 0) { 516 ratio *= scale; 517 } 518 if (strstr(metric_expr, "?")) 519 scnprintf(metric_bf, sizeof(metric_bf), 520 "%s %s_%d", unit, metric_name, runtime); 521 else 522 scnprintf(metric_bf, sizeof(metric_bf), 523 "%s %s", unit, metric_name); 524 525 print_metric(config, ctxp, color, "%8.1f", 526 metric_bf, ratio); 527 } else { 528 print_metric(config, ctxp, color, "%8.2f", 529 metric_name ? 530 metric_name : 531 out->force_header ? evsel->name : "", 532 ratio); 533 } 534 } else { 535 print_metric(config, ctxp, color, /*unit=*/NULL, 536 out->force_header ? 537 (metric_name ?: evsel->name) : "", 0); 538 } 539 } else { 540 print_metric(config, ctxp, color, /*unit=*/NULL, 541 out->force_header ? 542 (metric_name ?: evsel->name) : "", 0); 543 } 544 545 expr__ctx_free(pctx); 546 } 547 548 double test_generic_metric(struct metric_expr *mexp, int aggr_idx) 549 { 550 struct expr_parse_ctx *pctx; 551 double ratio = 0.0; 552 553 pctx = expr__ctx_new(); 554 if (!pctx) 555 return NAN; 556 557 if (prepare_metric(mexp, /*evsel=*/NULL, pctx, aggr_idx) < 0) 558 goto out; 559 560 if (expr__parse(&ratio, pctx, mexp->metric_expr)) 561 ratio = 0.0; 562 563 out: 564 expr__ctx_free(pctx); 565 return ratio; 566 } 567 568 static void perf_stat__print_metricgroup_header(struct perf_stat_config *config, 569 struct evsel *evsel, 570 void *ctxp, 571 const char *name, 572 struct perf_stat_output_ctx *out) 573 { 574 bool need_full_name = perf_pmus__num_core_pmus() > 1; 575 static const char *last_name; 576 static const char *last_pmu; 577 char full_name[64]; 578 579 /* 580 * A metricgroup may have several metric events, 581 * e.g.,TopdownL1 on e-core of ADL. 582 * The name has been output by the first metric 583 * event. Only align with other metics from 584 * different metric events. 585 */ 586 if (last_name && !strcmp(last_name, name)) { 587 if (!need_full_name || !strcmp(last_pmu, evsel->pmu_name)) { 588 out->print_metricgroup_header(config, ctxp, NULL); 589 return; 590 } 591 } 592 593 if (need_full_name) 594 scnprintf(full_name, sizeof(full_name), "%s (%s)", name, evsel->pmu_name); 595 else 596 scnprintf(full_name, sizeof(full_name), "%s", name); 597 598 out->print_metricgroup_header(config, ctxp, full_name); 599 600 last_name = name; 601 last_pmu = evsel->pmu_name; 602 } 603 604 /** 605 * perf_stat__print_shadow_stats_metricgroup - Print out metrics associated with the evsel 606 * For the non-default, all metrics associated 607 * with the evsel are printed. 608 * For the default mode, only the metrics from 609 * the same metricgroup and the name of the 610 * metricgroup are printed. To print the metrics 611 * from the next metricgroup (if available), 612 * invoke the function with correspoinding 613 * metric_expr. 614 */ 615 void *perf_stat__print_shadow_stats_metricgroup(struct perf_stat_config *config, 616 struct evsel *evsel, 617 int aggr_idx, 618 int *num, 619 void *from, 620 struct perf_stat_output_ctx *out, 621 struct rblist *metric_events) 622 { 623 struct metric_event *me; 624 struct metric_expr *mexp = from; 625 void *ctxp = out->ctx; 626 bool header_printed = false; 627 const char *name = NULL; 628 629 me = metricgroup__lookup(metric_events, evsel, false); 630 if (me == NULL) 631 return NULL; 632 633 if (!mexp) 634 mexp = list_first_entry(&me->head, typeof(*mexp), nd); 635 636 list_for_each_entry_from(mexp, &me->head, nd) { 637 /* Print the display name of the Default metricgroup */ 638 if (!config->metric_only && me->is_default) { 639 if (!name) 640 name = mexp->default_metricgroup_name; 641 /* 642 * Two or more metricgroup may share the same metric 643 * event, e.g., TopdownL1 and TopdownL2 on SPR. 644 * Return and print the prefix, e.g., noise, running 645 * for the next metricgroup. 646 */ 647 if (strcmp(name, mexp->default_metricgroup_name)) 648 return (void *)mexp; 649 /* Only print the name of the metricgroup once */ 650 if (!header_printed) { 651 header_printed = true; 652 perf_stat__print_metricgroup_header(config, evsel, ctxp, 653 name, out); 654 } 655 } 656 657 if ((*num)++ > 0) 658 out->new_line(config, ctxp); 659 generic_metric(config, mexp, evsel, aggr_idx, out); 660 } 661 662 return NULL; 663 } 664 665 void perf_stat__print_shadow_stats(struct perf_stat_config *config, 666 struct evsel *evsel, 667 double avg, int aggr_idx, 668 struct perf_stat_output_ctx *out, 669 struct rblist *metric_events) 670 { 671 typedef void (*stat_print_function_t)(struct perf_stat_config *config, 672 const struct evsel *evsel, 673 int aggr_idx, double misses, 674 struct perf_stat_output_ctx *out); 675 static const stat_print_function_t stat_print_function[STAT_MAX] = { 676 [STAT_INSTRUCTIONS] = print_instructions, 677 [STAT_BRANCH_MISS] = print_branch_miss, 678 [STAT_L1D_MISS] = print_l1d_miss, 679 [STAT_L1I_MISS] = print_l1i_miss, 680 [STAT_DTLB_MISS] = print_dtlb_miss, 681 [STAT_ITLB_MISS] = print_itlb_miss, 682 [STAT_LL_MISS] = print_ll_miss, 683 [STAT_CACHE_MISSES] = print_cache_miss, 684 [STAT_STALLED_CYCLES_FRONT] = print_stalled_cycles_front, 685 [STAT_STALLED_CYCLES_BACK] = print_stalled_cycles_back, 686 [STAT_CYCLES] = print_cycles, 687 [STAT_NSECS] = print_nsecs, 688 }; 689 print_metric_t print_metric = out->print_metric; 690 void *ctxp = out->ctx; 691 int num = 1; 692 693 if (config->iostat_run) { 694 iostat_print_metric(config, evsel, out); 695 } else { 696 stat_print_function_t fn = stat_print_function[evsel__stat_type(evsel)]; 697 698 if (fn) 699 fn(config, evsel, aggr_idx, avg, out); 700 else { 701 double nsecs = find_stat(evsel, aggr_idx, STAT_NSECS); 702 703 if (nsecs) { 704 char unit = ' '; 705 char unit_buf[10] = "/sec"; 706 double ratio = convert_unit_double(1000000000.0 * avg / nsecs, 707 &unit); 708 709 if (unit != ' ') 710 snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit); 711 print_metric(config, ctxp, NULL, "%8.3f", unit_buf, ratio); 712 } else 713 num = 0; 714 } 715 } 716 717 perf_stat__print_shadow_stats_metricgroup(config, evsel, aggr_idx, 718 &num, NULL, out, metric_events); 719 720 if (num == 0) 721 print_metric(config, ctxp, NULL, NULL, NULL, 0); 722 } 723 724 /** 725 * perf_stat__skip_metric_event - Skip the evsel in the Default metricgroup, 726 * if it's not running or not the metric event. 727 */ 728 bool perf_stat__skip_metric_event(struct evsel *evsel, 729 struct rblist *metric_events, 730 u64 ena, u64 run) 731 { 732 if (!evsel->default_metricgroup) 733 return false; 734 735 if (!ena || !run) 736 return true; 737 738 return !metricgroup__lookup(metric_events, evsel, false); 739 } 740