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