740 lines · c
1// SPDX-License-Identifier: GPL-2.02#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 19struct stats walltime_nsecs_stats;20struct rusage_stats ru_stats;21 22enum {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 31enum 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_MAX53};54 55static 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 73void 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 79static 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 139static 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 153static 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 194static 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 } else208 out->print_metric(config, out->ctx, NULL, NULL, unit, 0);209}210 211static 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 222static 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 233static 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 244static 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 255static 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 266static 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 277static 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 288static 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 299static 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 310static 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 } else325 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 334static 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 } else346 out->print_metric(config, out->ctx, NULL, NULL, "GHz", 0);347}348 349static 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 } else362 print_metric(config, ctxp, NULL, NULL, "CPUs utilized", 0);363}364 365static 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 (evsel__tool_event(metric_events[i])) {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 not414 * reading the leader's stats, determine the stats for415 * 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 a440 * metric. Explicitly set the value to NAN. Not441 * counted events (enable time of 0) are read as442 * 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 469static 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_ZERO510 ? 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 else522 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 548double 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 563out:564 expr__ctx_free(pctx);565 return ratio;566}567 568static 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 metric583 * event. Only align with other metics from584 * 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 else596 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 evsel606 * For the non-default, all metrics associated607 * with the evsel are printed.608 * For the default mode, only the metrics from609 * the same metricgroup and the name of the610 * metricgroup are printed. To print the metrics611 * from the next metricgroup (if available),612 * invoke the function with correspoinding613 * metric_expr.614 */615void *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 metric643 * event, e.g., TopdownL1 and TopdownL2 on SPR.644 * Return and print the prefix, e.g., noise, running645 * 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 665void 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 } else713 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 */728bool 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