tools/perf/util/stat-shadow.c

   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 }