tools/perf/util/stat-display.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <inttypes.h>
   4 #include <linux/string.h>
   5 #include <linux/time64.h>
   6 #include <math.h>
   7 #include <perf/cpumap.h>
   8 #include "color.h"
   9 #include "counts.h"
  10 #include "evlist.h"
  11 #include "evsel.h"
  12 #include "stat.h"
  13 #include "top.h"
  14 #include "thread_map.h"
  15 #include "cpumap.h"
  16 #include "string2.h"
  17 #include <linux/ctype.h>
  18 #include "cgroup.h"
  19 #include <api/fs/fs.h>
  20 #include "util.h"
  21 #include "iostat.h"
  22 #include "pmu-hybrid.h"
  23 #include "evlist-hybrid.h"
  24
  25 #define CNTR_NOT_SUPPORTED      "<not supported>"
  26 #define CNTR_NOT_COUNTED        "<not counted>"
  27
  28 static void print_running(struct perf_stat_config *config,
  29                           u64 run, u64 ena)
  30 {
  31         if (config->csv_output) {
  32                 fprintf(config->output, "%s%" PRIu64 "%s%.2f",
  33                                         config->csv_sep,
  34                                         run,
  35                                         config->csv_sep,
  36                                         ena ? 100.0 * run / ena : 100.0);
  37         } else if (run != ena) {
  38                 fprintf(config->output, "  (%.2f%%)", 100.0 * run / ena);
  39         }
  40 }
  41
  42 static void print_noise_pct(struct perf_stat_config *config,
  43                             double total, double avg)
  44 {
  45         double pct = rel_stddev_stats(total, avg);
  46
  47         if (config->csv_output)
  48                 fprintf(config->output, "%s%.2f%%", config->csv_sep, pct);
  49         else if (pct)
  50                 fprintf(config->output, "  ( +-%6.2f%% )", pct);
  51 }
  52
  53 static void print_noise(struct perf_stat_config *config,
  54                         struct evsel *evsel, double avg)
  55 {
  56         struct perf_stat_evsel *ps;
  57
  58         if (config->run_count == 1)
  59                 return;
  60
  61         ps = evsel->stats;
  62         print_noise_pct(config, stddev_stats(&ps->res_stats[0]), avg);
  63 }
  64
  65 static void print_cgroup(struct perf_stat_config *config, struct evsel *evsel)
  66 {
  67         if (nr_cgroups) {
  68                 const char *cgrp_name = evsel->cgrp ? evsel->cgrp->name  : "";
  69                 fprintf(config->output, "%s%s", config->csv_sep, cgrp_name);
  70         }
  71 }
  72
  73
  74 static void aggr_printout(struct perf_stat_config *config,
  75                           struct evsel *evsel, struct aggr_cpu_id id, int nr)
  76 {
  77         switch (config->aggr_mode) {
  78         case AGGR_CORE:
  79                 fprintf(config->output, "S%d-D%d-C%*d%s%*d%s",
  80                         id.socket,
  81                         id.die,
  82                         config->csv_output ? 0 : -8,
  83                         id.core,
  84                         config->csv_sep,
  85                         config->csv_output ? 0 : 4,
  86                         nr,
  87                         config->csv_sep);
  88                 break;
  89         case AGGR_DIE:
  90                 fprintf(config->output, "S%d-D%*d%s%*d%s",
  91                         id.socket,
  92                         config->csv_output ? 0 : -8,
  93                         id.die,
  94                         config->csv_sep,
  95                         config->csv_output ? 0 : 4,
  96                         nr,
  97                         config->csv_sep);
  98                 break;
  99         case AGGR_SOCKET:
 100                 fprintf(config->output, "S%*d%s%*d%s",
 101                         config->csv_output ? 0 : -5,
 102                         id.socket,
 103                         config->csv_sep,
 104                         config->csv_output ? 0 : 4,
 105                         nr,
 106                         config->csv_sep);
 107                         break;
 108         case AGGR_NODE:
 109                 fprintf(config->output, "N%*d%s%*d%s",
 110                         config->csv_output ? 0 : -5,
 111                         id.node,
 112                         config->csv_sep,
 113                         config->csv_output ? 0 : 4,
 114                         nr,
 115                         config->csv_sep);
 116                         break;
 117         case AGGR_NONE:
 118                 if (evsel->percore && !config->percore_show_thread) {
 119                         fprintf(config->output, "S%d-D%d-C%*d%s",
 120                                 id.socket,
 121                                 id.die,
 122                                 config->csv_output ? 0 : -3,
 123                                 id.core, config->csv_sep);
 124                 } else if (id.cpu.cpu > -1) {
 125                         fprintf(config->output, "CPU%*d%s",
 126                                 config->csv_output ? 0 : -7,
 127                                 id.cpu.cpu, config->csv_sep);
 128                 }
 129                 break;
 130         case AGGR_THREAD:
 131                 fprintf(config->output, "%*s-%*d%s",
 132                         config->csv_output ? 0 : 16,
 133                         perf_thread_map__comm(evsel->core.threads, id.thread),
 134                         config->csv_output ? 0 : -8,
 135                         perf_thread_map__pid(evsel->core.threads, id.thread),
 136                         config->csv_sep);
 137                 break;
 138         case AGGR_GLOBAL:
 139         case AGGR_UNSET:
 140         default:
 141                 break;
 142         }
 143 }
 144
 145 struct outstate {
 146         FILE *fh;
 147         bool newline;
 148         const char *prefix;
 149         int  nfields;
 150         int  nr;
 151         struct aggr_cpu_id id;
 152         struct evsel *evsel;
 153 };
 154
 155 #define METRIC_LEN  35
 156
 157 static void new_line_std(struct perf_stat_config *config __maybe_unused,
 158                          void *ctx)
 159 {
 160         struct outstate *os = ctx;
 161
 162         os->newline = true;
 163 }
 164
 165 static void do_new_line_std(struct perf_stat_config *config,
 166                             struct outstate *os)
 167 {
 168         fputc('\n', os->fh);
 169         fputs(os->prefix, os->fh);
 170         aggr_printout(config, os->evsel, os->id, os->nr);
 171         if (config->aggr_mode == AGGR_NONE)
 172                 fprintf(os->fh, "        ");
 173         fprintf(os->fh, "                                                 ");
 174 }
 175
 176 static void print_metric_std(struct perf_stat_config *config,
 177                              void *ctx, const char *color, const char *fmt,
 178                              const char *unit, double val)
 179 {
 180         struct outstate *os = ctx;
 181         FILE *out = os->fh;
 182         int n;
 183         bool newline = os->newline;
 184
 185         os->newline = false;
 186
 187         if (unit == NULL || fmt == NULL) {
 188                 fprintf(out, "%-*s", METRIC_LEN, "");
 189                 return;
 190         }
 191
 192         if (newline)
 193                 do_new_line_std(config, os);
 194
 195         n = fprintf(out, " # ");
 196         if (color)
 197                 n += color_fprintf(out, color, fmt, val);
 198         else
 199                 n += fprintf(out, fmt, val);
 200         fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
 201 }
 202
 203 static void new_line_csv(struct perf_stat_config *config, void *ctx)
 204 {
 205         struct outstate *os = ctx;
 206         int i;
 207
 208         fputc('\n', os->fh);
 209         if (os->prefix)
 210                 fprintf(os->fh, "%s%s", os->prefix, config->csv_sep);
 211         aggr_printout(config, os->evsel, os->id, os->nr);
 212         for (i = 0; i < os->nfields; i++)
 213                 fputs(config->csv_sep, os->fh);
 214 }
 215
 216 static void print_metric_csv(struct perf_stat_config *config __maybe_unused,
 217                              void *ctx,
 218                              const char *color __maybe_unused,
 219                              const char *fmt, const char *unit, double val)
 220 {
 221         struct outstate *os = ctx;
 222         FILE *out = os->fh;
 223         char buf[64], *vals, *ends;
 224
 225         if (unit == NULL || fmt == NULL) {
 226                 fprintf(out, "%s%s", config->csv_sep, config->csv_sep);
 227                 return;
 228         }
 229         snprintf(buf, sizeof(buf), fmt, val);
 230         ends = vals = skip_spaces(buf);
 231         while (isdigit(*ends) || *ends == '.')
 232                 ends++;
 233         *ends = 0;
 234         fprintf(out, "%s%s%s%s", config->csv_sep, vals, config->csv_sep, skip_spaces(unit));
 235 }
 236
 237 /* Filter out some columns that don't work well in metrics only mode */
 238
 239 static bool valid_only_metric(const char *unit)
 240 {
 241         if (!unit)
 242                 return false;
 243         if (strstr(unit, "/sec") ||
 244             strstr(unit, "CPUs utilized"))
 245                 return false;
 246         return true;
 247 }
 248
 249 static const char *fixunit(char *buf, struct evsel *evsel,
 250                            const char *unit)
 251 {
 252         if (!strncmp(unit, "of all", 6)) {
 253                 snprintf(buf, 1024, "%s %s", evsel__name(evsel),
 254                          unit);
 255                 return buf;
 256         }
 257         return unit;
 258 }
 259
 260 static void print_metric_only(struct perf_stat_config *config,
 261                               void *ctx, const char *color, const char *fmt,
 262                               const char *unit, double val)
 263 {
 264         struct outstate *os = ctx;
 265         FILE *out = os->fh;
 266         char buf[1024], str[1024];
 267         unsigned mlen = config->metric_only_len;
 268
 269         if (!valid_only_metric(unit))
 270                 return;
 271         unit = fixunit(buf, os->evsel, unit);
 272         if (mlen < strlen(unit))
 273                 mlen = strlen(unit) + 1;
 274
 275         if (color)
 276                 mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
 277
 278         color_snprintf(str, sizeof(str), color ?: "", fmt, val);
 279         fprintf(out, "%*s ", mlen, str);
 280 }
 281
 282 static void print_metric_only_csv(struct perf_stat_config *config __maybe_unused,
 283                                   void *ctx, const char *color __maybe_unused,
 284                                   const char *fmt,
 285                                   const char *unit, double val)
 286 {
 287         struct outstate *os = ctx;
 288         FILE *out = os->fh;
 289         char buf[64], *vals, *ends;
 290         char tbuf[1024];
 291
 292         if (!valid_only_metric(unit))
 293                 return;
 294         unit = fixunit(tbuf, os->evsel, unit);
 295         snprintf(buf, sizeof buf, fmt, val);
 296         ends = vals = skip_spaces(buf);
 297         while (isdigit(*ends) || *ends == '.')
 298                 ends++;
 299         *ends = 0;
 300         fprintf(out, "%s%s", vals, config->csv_sep);
 301 }
 302
 303 static void new_line_metric(struct perf_stat_config *config __maybe_unused,
 304                             void *ctx __maybe_unused)
 305 {
 306 }
 307
 308 static void print_metric_header(struct perf_stat_config *config,
 309                                 void *ctx, const char *color __maybe_unused,
 310                                 const char *fmt __maybe_unused,
 311                                 const char *unit, double val __maybe_unused)
 312 {
 313         struct outstate *os = ctx;
 314         char tbuf[1024];
 315
 316         /* In case of iostat, print metric header for first root port only */
 317         if (config->iostat_run &&
 318             os->evsel->priv != os->evsel->evlist->selected->priv)
 319                 return;
 320
 321         if (!valid_only_metric(unit))
 322                 return;
 323         unit = fixunit(tbuf, os->evsel, unit);
 324         if (config->csv_output)
 325                 fprintf(os->fh, "%s%s", unit, config->csv_sep);
 326         else
 327                 fprintf(os->fh, "%*s ", config->metric_only_len, unit);
 328 }
 329
 330 static int first_shadow_cpu_map_idx(struct perf_stat_config *config,
 331                                 struct evsel *evsel, const struct aggr_cpu_id *id)
 332 {
 333         struct perf_cpu_map *cpus = evsel__cpus(evsel);
 334         struct perf_cpu cpu;
 335         int idx;
 336
 337         if (config->aggr_mode == AGGR_NONE)
 338                 return perf_cpu_map__idx(cpus, id->cpu);
 339
 340         if (!config->aggr_get_id)
 341                 return 0;
 342
 343         perf_cpu_map__for_each_cpu(cpu, idx, cpus) {
 344                 struct aggr_cpu_id cpu_id = config->aggr_get_id(config, cpu);
 345
 346                 if (aggr_cpu_id__equal(&cpu_id, id))
 347                         return idx;
 348         }
 349         return 0;
 350 }
 351
 352 static void abs_printout(struct perf_stat_config *config,
 353                          struct aggr_cpu_id id, int nr, struct evsel *evsel, double avg)
 354 {
 355         FILE *output = config->output;
 356         double sc =  evsel->scale;
 357         const char *fmt;
 358
 359         if (config->csv_output) {
 360                 fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
 361         } else {
 362                 if (config->big_num)
 363                         fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
 364                 else
 365                         fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
 366         }
 367
 368         aggr_printout(config, evsel, id, nr);
 369
 370         fprintf(output, fmt, avg, config->csv_sep);
 371
 372         if (evsel->unit)
 373                 fprintf(output, "%-*s%s",
 374                         config->csv_output ? 0 : config->unit_width,
 375                         evsel->unit, config->csv_sep);
 376
 377         fprintf(output, "%-*s", config->csv_output ? 0 : 25, evsel__name(evsel));
 378
 379         print_cgroup(config, evsel);
 380 }
 381
 382 static bool is_mixed_hw_group(struct evsel *counter)
 383 {
 384         struct evlist *evlist = counter->evlist;
 385         u32 pmu_type = counter->core.attr.type;
 386         struct evsel *pos;
 387
 388         if (counter->core.nr_members < 2)
 389                 return false;
 390
 391         evlist__for_each_entry(evlist, pos) {
 392                 /* software events can be part of any hardware group */
 393                 if (pos->core.attr.type == PERF_TYPE_SOFTWARE)
 394                         continue;
 395                 if (pmu_type == PERF_TYPE_SOFTWARE) {
 396                         pmu_type = pos->core.attr.type;
 397                         continue;
 398                 }
 399                 if (pmu_type != pos->core.attr.type)
 400                         return true;
 401         }
 402
 403         return false;
 404 }
 405
 406 static void printout(struct perf_stat_config *config, struct aggr_cpu_id id, int nr,
 407                      struct evsel *counter, double uval,
 408                      char *prefix, u64 run, u64 ena, double noise,
 409                      struct runtime_stat *st)
 410 {
 411         struct perf_stat_output_ctx out;
 412         struct outstate os = {
 413                 .fh = config->output,
 414                 .prefix = prefix ? prefix : "",
 415                 .id = id,
 416                 .nr = nr,
 417                 .evsel = counter,
 418         };
 419         print_metric_t pm = print_metric_std;
 420         new_line_t nl;
 421
 422         if (config->metric_only) {
 423                 nl = new_line_metric;
 424                 if (config->csv_output)
 425                         pm = print_metric_only_csv;
 426                 else
 427                         pm = print_metric_only;
 428         } else
 429                 nl = new_line_std;
 430
 431         if (config->csv_output && !config->metric_only) {
 432                 static int aggr_fields[] = {
 433                         [AGGR_GLOBAL] = 0,
 434                         [AGGR_THREAD] = 1,
 435                         [AGGR_NONE] = 1,
 436                         [AGGR_SOCKET] = 2,
 437                         [AGGR_DIE] = 2,
 438                         [AGGR_CORE] = 2,
 439                 };
 440
 441                 pm = print_metric_csv;
 442                 nl = new_line_csv;
 443                 os.nfields = 3;
 444                 os.nfields += aggr_fields[config->aggr_mode];
 445                 if (counter->cgrp)
 446                         os.nfields++;
 447         }
 448
 449         if (!config->no_csv_summary && config->csv_output &&
 450             config->summary && !config->interval) {
 451                 fprintf(config->output, "%16s%s", "summary", config->csv_sep);
 452         }
 453
 454         if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
 455                 if (config->metric_only) {
 456                         pm(config, &os, NULL, "", "", 0);
 457                         return;
 458                 }
 459                 aggr_printout(config, counter, id, nr);
 460
 461                 fprintf(config->output, "%*s%s",
 462                         config->csv_output ? 0 : 18,
 463                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
 464                         config->csv_sep);
 465
 466                 if (counter->supported) {
 467                         if (!evlist__has_hybrid(counter->evlist)) {
 468                                 config->print_free_counters_hint = 1;
 469                                 if (is_mixed_hw_group(counter))
 470                                         config->print_mixed_hw_group_error = 1;
 471                         }
 472                 }
 473
 474                 fprintf(config->output, "%-*s%s",
 475                         config->csv_output ? 0 : config->unit_width,
 476                         counter->unit, config->csv_sep);
 477
 478                 fprintf(config->output, "%*s",
 479                         config->csv_output ? 0 : -25, evsel__name(counter));
 480
 481                 print_cgroup(config, counter);
 482
 483                 if (!config->csv_output)
 484                         pm(config, &os, NULL, NULL, "", 0);
 485                 print_noise(config, counter, noise);
 486                 print_running(config, run, ena);
 487                 if (config->csv_output)
 488                         pm(config, &os, NULL, NULL, "", 0);
 489                 return;
 490         }
 491
 492         if (!config->metric_only)
 493                 abs_printout(config, id, nr, counter, uval);
 494
 495         out.print_metric = pm;
 496         out.new_line = nl;
 497         out.ctx = &os;
 498         out.force_header = false;
 499
 500         if (config->csv_output && !config->metric_only) {
 501                 print_noise(config, counter, noise);
 502                 print_running(config, run, ena);
 503         }
 504
 505         perf_stat__print_shadow_stats(config, counter, uval,
 506                                 first_shadow_cpu_map_idx(config, counter, &id),
 507                                 &out, &config->metric_events, st);
 508         if (!config->csv_output && !config->metric_only) {
 509                 print_noise(config, counter, noise);
 510                 print_running(config, run, ena);
 511         }
 512 }
 513
 514 static void aggr_update_shadow(struct perf_stat_config *config,
 515                                struct evlist *evlist)
 516 {
 517         int idx, s;
 518         struct perf_cpu cpu;
 519         struct aggr_cpu_id s2, id;
 520         u64 val;
 521         struct evsel *counter;
 522         struct perf_cpu_map *cpus;
 523
 524         for (s = 0; s < config->aggr_map->nr; s++) {
 525                 id = config->aggr_map->map[s];
 526                 evlist__for_each_entry(evlist, counter) {
 527                         cpus = evsel__cpus(counter);
 528                         val = 0;
 529                         perf_cpu_map__for_each_cpu(cpu, idx, cpus) {
 530                                 s2 = config->aggr_get_id(config, cpu);
 531                                 if (!aggr_cpu_id__equal(&s2, &id))
 532                                         continue;
 533                                 val += perf_counts(counter->counts, idx, 0)->val;
 534                         }
 535                         perf_stat__update_shadow_stats(counter, val,
 536                                         first_shadow_cpu_map_idx(config, counter, &id),
 537                                         &rt_stat);
 538                 }
 539         }
 540 }
 541
 542 static void uniquify_event_name(struct evsel *counter)
 543 {
 544         char *new_name;
 545         char *config;
 546         int ret = 0;
 547
 548         if (counter->uniquified_name || counter->use_config_name ||
 549             !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
 550                                            strlen(counter->pmu_name)))
 551                 return;
 552
 553         config = strchr(counter->name, '/');
 554         if (config) {
 555                 if (asprintf(&new_name,
 556                              "%s%s", counter->pmu_name, config) > 0) {
 557                         free(counter->name);
 558                         counter->name = new_name;
 559                 }
 560         } else {
 561                 if (perf_pmu__has_hybrid()) {
 562                         ret = asprintf(&new_name, "%s/%s/",
 563                                        counter->pmu_name, counter->name);
 564                 } else {
 565                         ret = asprintf(&new_name, "%s [%s]",
 566                                        counter->name, counter->pmu_name);
 567                 }
 568
 569                 if (ret) {
 570                         free(counter->name);
 571                         counter->name = new_name;
 572                 }
 573         }
 574
 575         counter->uniquified_name = true;
 576 }
 577
 578 static void collect_all_aliases(struct perf_stat_config *config, struct evsel *counter,
 579                             void (*cb)(struct perf_stat_config *config, struct evsel *counter, void *data,
 580                                        bool first),
 581                             void *data)
 582 {
 583         struct evlist *evlist = counter->evlist;
 584         struct evsel *alias;
 585
 586         alias = list_prepare_entry(counter, &(evlist->core.entries), core.node);
 587         list_for_each_entry_continue (alias, &evlist->core.entries, core.node) {
 588                 /* Merge events with the same name, etc. but on different PMUs. */
 589                 if (!strcmp(evsel__name(alias), evsel__name(counter)) &&
 590                         alias->scale == counter->scale &&
 591                         alias->cgrp == counter->cgrp &&
 592                         !strcmp(alias->unit, counter->unit) &&
 593                         evsel__is_clock(alias) == evsel__is_clock(counter) &&
 594                         strcmp(alias->pmu_name, counter->pmu_name)) {
 595                         alias->merged_stat = true;
 596                         cb(config, alias, data, false);
 597                 }
 598         }
 599 }
 600
 601 static bool is_uncore(struct evsel *evsel)
 602 {
 603         struct perf_pmu *pmu = evsel__find_pmu(evsel);
 604
 605         return pmu && pmu->is_uncore;
 606 }
 607
 608 static bool hybrid_uniquify(struct evsel *evsel)
 609 {
 610         return perf_pmu__has_hybrid() && !is_uncore(evsel);
 611 }
 612
 613 static bool collect_data(struct perf_stat_config *config, struct evsel *counter,
 614                             void (*cb)(struct perf_stat_config *config, struct evsel *counter, void *data,
 615                                        bool first),
 616                             void *data)
 617 {
 618         if (counter->merged_stat)
 619                 return false;
 620         cb(config, counter, data, true);
 621         if (config->no_merge || hybrid_uniquify(counter))
 622                 uniquify_event_name(counter);
 623         else if (counter->auto_merge_stats)
 624                 collect_all_aliases(config, counter, cb, data);
 625         return true;
 626 }
 627
 628 struct aggr_data {
 629         u64 ena, run, val;
 630         struct aggr_cpu_id id;
 631         int nr;
 632         int cpu_map_idx;
 633 };
 634
 635 static void aggr_cb(struct perf_stat_config *config,
 636                     struct evsel *counter, void *data, bool first)
 637 {
 638         struct aggr_data *ad = data;
 639         int idx;
 640         struct perf_cpu cpu;
 641         struct perf_cpu_map *cpus;
 642         struct aggr_cpu_id s2;
 643
 644         cpus = evsel__cpus(counter);
 645         perf_cpu_map__for_each_cpu(cpu, idx, cpus) {
 646                 struct perf_counts_values *counts;
 647
 648                 s2 = config->aggr_get_id(config, cpu);
 649                 if (!aggr_cpu_id__equal(&s2, &ad->id))
 650                         continue;
 651                 if (first)
 652                         ad->nr++;
 653                 counts = perf_counts(counter->counts, idx, 0);
 654                 /*
 655                  * When any result is bad, make them all to give
 656                  * consistent output in interval mode.
 657                  */
 658                 if (counts->ena == 0 || counts->run == 0 ||
 659                     counter->counts->scaled == -1) {
 660                         ad->ena = 0;
 661                         ad->run = 0;
 662                         break;
 663                 }
 664                 ad->val += counts->val;
 665                 ad->ena += counts->ena;
 666                 ad->run += counts->run;
 667         }
 668 }
 669
 670 static void print_counter_aggrdata(struct perf_stat_config *config,
 671                                    struct evsel *counter, int s,
 672                                    char *prefix, bool metric_only,
 673                                    bool *first, struct perf_cpu cpu)
 674 {
 675         struct aggr_data ad;
 676         FILE *output = config->output;
 677         u64 ena, run, val;
 678         int nr;
 679         struct aggr_cpu_id id;
 680         double uval;
 681
 682         ad.id = id = config->aggr_map->map[s];
 683         ad.val = ad.ena = ad.run = 0;
 684         ad.nr = 0;
 685         if (!collect_data(config, counter, aggr_cb, &ad))
 686                 return;
 687
 688         if (perf_pmu__has_hybrid() && ad.ena == 0)
 689                 return;
 690
 691         nr = ad.nr;
 692         ena = ad.ena;
 693         run = ad.run;
 694         val = ad.val;
 695         if (*first && metric_only) {
 696                 *first = false;
 697                 aggr_printout(config, counter, id, nr);
 698         }
 699         if (prefix && !metric_only)
 700                 fprintf(output, "%s", prefix);
 701
 702         uval = val * counter->scale;
 703         if (cpu.cpu != -1)
 704                 id = aggr_cpu_id__cpu(cpu, /*data=*/NULL);
 705
 706         printout(config, id, nr, counter, uval,
 707                  prefix, run, ena, 1.0, &rt_stat);
 708         if (!metric_only)
 709                 fputc('\n', output);
 710 }
 711
 712 static void print_aggr(struct perf_stat_config *config,
 713                        struct evlist *evlist,
 714                        char *prefix)
 715 {
 716         bool metric_only = config->metric_only;
 717         FILE *output = config->output;
 718         struct evsel *counter;
 719         int s;
 720         bool first;
 721
 722         if (!config->aggr_map || !config->aggr_get_id)
 723                 return;
 724
 725         aggr_update_shadow(config, evlist);
 726
 727         /*
 728          * With metric_only everything is on a single line.
 729          * Without each counter has its own line.
 730          */
 731         for (s = 0; s < config->aggr_map->nr; s++) {
 732                 if (prefix && metric_only)
 733                         fprintf(output, "%s", prefix);
 734
 735                 first = true;
 736                 evlist__for_each_entry(evlist, counter) {
 737                         print_counter_aggrdata(config, counter, s,
 738                                         prefix, metric_only,
 739                                         &first, (struct perf_cpu){ .cpu = -1 });
 740                 }
 741                 if (metric_only)
 742                         fputc('\n', output);
 743         }
 744 }
 745
 746 static int cmp_val(const void *a, const void *b)
 747 {
 748         return ((struct perf_aggr_thread_value *)b)->val -
 749                 ((struct perf_aggr_thread_value *)a)->val;
 750 }
 751
 752 static struct perf_aggr_thread_value *sort_aggr_thread(
 753                                         struct evsel *counter,
 754                                         int nthreads, int ncpus,
 755                                         int *ret,
 756                                         struct target *_target)
 757 {
 758         int cpu, thread, i = 0;
 759         double uval;
 760         struct perf_aggr_thread_value *buf;
 761
 762         buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
 763         if (!buf)
 764                 return NULL;
 765
 766         for (thread = 0; thread < nthreads; thread++) {
 767                 u64 ena = 0, run = 0, val = 0;
 768
 769                 for (cpu = 0; cpu < ncpus; cpu++) {
 770                         val += perf_counts(counter->counts, cpu, thread)->val;
 771                         ena += perf_counts(counter->counts, cpu, thread)->ena;
 772                         run += perf_counts(counter->counts, cpu, thread)->run;
 773                 }
 774
 775                 uval = val * counter->scale;
 776
 777                 /*
 778                  * Skip value 0 when enabling --per-thread globally,
 779                  * otherwise too many 0 output.
 780                  */
 781                 if (uval == 0.0 && target__has_per_thread(_target))
 782                         continue;
 783
 784                 buf[i].counter = counter;
 785                 buf[i].id = aggr_cpu_id__empty();
 786                 buf[i].id.thread = thread;
 787                 buf[i].uval = uval;
 788                 buf[i].val = val;
 789                 buf[i].run = run;
 790                 buf[i].ena = ena;
 791                 i++;
 792         }
 793
 794         qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
 795
 796         if (ret)
 797                 *ret = i;
 798
 799         return buf;
 800 }
 801
 802 static void print_aggr_thread(struct perf_stat_config *config,
 803                               struct target *_target,
 804                               struct evsel *counter, char *prefix)
 805 {
 806         FILE *output = config->output;
 807         int nthreads = perf_thread_map__nr(counter->core.threads);
 808         int ncpus = perf_cpu_map__nr(counter->core.cpus);
 809         int thread, sorted_threads;
 810         struct aggr_cpu_id id;
 811         struct perf_aggr_thread_value *buf;
 812
 813         buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads, _target);
 814         if (!buf) {
 815                 perror("cannot sort aggr thread");
 816                 return;
 817         }
 818
 819         for (thread = 0; thread < sorted_threads; thread++) {
 820                 if (prefix)
 821                         fprintf(output, "%s", prefix);
 822
 823                 id = buf[thread].id;
 824                 if (config->stats)
 825                         printout(config, id, 0, buf[thread].counter, buf[thread].uval,
 826                                  prefix, buf[thread].run, buf[thread].ena, 1.0,
 827                                  &config->stats[id.thread]);
 828                 else
 829                         printout(config, id, 0, buf[thread].counter, buf[thread].uval,
 830                                  prefix, buf[thread].run, buf[thread].ena, 1.0,
 831                                  &rt_stat);
 832                 fputc('\n', output);
 833         }
 834
 835         free(buf);
 836 }
 837
 838 struct caggr_data {
 839         double avg, avg_enabled, avg_running;
 840 };
 841
 842 static void counter_aggr_cb(struct perf_stat_config *config __maybe_unused,
 843                             struct evsel *counter, void *data,
 844                             bool first __maybe_unused)
 845 {
 846         struct caggr_data *cd = data;
 847         struct perf_counts_values *aggr = &counter->counts->aggr;
 848
 849         cd->avg += aggr->val;
 850         cd->avg_enabled += aggr->ena;
 851         cd->avg_running += aggr->run;
 852 }
 853
 854 /*
 855  * Print out the results of a single counter:
 856  * aggregated counts in system-wide mode
 857  */
 858 static void print_counter_aggr(struct perf_stat_config *config,
 859                                struct evsel *counter, char *prefix)
 860 {
 861         bool metric_only = config->metric_only;
 862         FILE *output = config->output;
 863         double uval;
 864         struct caggr_data cd = { .avg = 0.0 };
 865
 866         if (!collect_data(config, counter, counter_aggr_cb, &cd))
 867                 return;
 868
 869         if (prefix && !metric_only)
 870                 fprintf(output, "%s", prefix);
 871
 872         uval = cd.avg * counter->scale;
 873         printout(config, aggr_cpu_id__empty(), 0, counter, uval, prefix, cd.avg_running,
 874                  cd.avg_enabled, cd.avg, &rt_stat);
 875         if (!metric_only)
 876                 fprintf(output, "\n");
 877 }
 878
 879 static void counter_cb(struct perf_stat_config *config __maybe_unused,
 880                        struct evsel *counter, void *data,
 881                        bool first __maybe_unused)
 882 {
 883         struct aggr_data *ad = data;
 884
 885         ad->val += perf_counts(counter->counts, ad->cpu_map_idx, 0)->val;
 886         ad->ena += perf_counts(counter->counts, ad->cpu_map_idx, 0)->ena;
 887         ad->run += perf_counts(counter->counts, ad->cpu_map_idx, 0)->run;
 888 }
 889
 890 /*
 891  * Print out the results of a single counter:
 892  * does not use aggregated count in system-wide
 893  */
 894 static void print_counter(struct perf_stat_config *config,
 895                           struct evsel *counter, char *prefix)
 896 {
 897         FILE *output = config->output;
 898         u64 ena, run, val;
 899         double uval;
 900         int idx;
 901         struct perf_cpu cpu;
 902         struct aggr_cpu_id id;
 903
 904         perf_cpu_map__for_each_cpu(cpu, idx, evsel__cpus(counter)) {
 905                 struct aggr_data ad = { .cpu_map_idx = idx };
 906
 907                 if (!collect_data(config, counter, counter_cb, &ad))
 908                         return;
 909                 val = ad.val;
 910                 ena = ad.ena;
 911                 run = ad.run;
 912
 913                 if (prefix)
 914                         fprintf(output, "%s", prefix);
 915
 916                 uval = val * counter->scale;
 917                 id = aggr_cpu_id__cpu(cpu, /*data=*/NULL);
 918                 printout(config, id, 0, counter, uval, prefix,
 919                          run, ena, 1.0, &rt_stat);
 920
 921                 fputc('\n', output);
 922         }
 923 }
 924
 925 static void print_no_aggr_metric(struct perf_stat_config *config,
 926                                  struct evlist *evlist,
 927                                  char *prefix)
 928 {
 929         int all_idx;
 930         struct perf_cpu cpu;
 931
 932         perf_cpu_map__for_each_cpu(cpu, all_idx, evlist->core.cpus) {
 933                 struct evsel *counter;
 934                 bool first = true;
 935
 936                 if (prefix)
 937                         fputs(prefix, config->output);
 938                 evlist__for_each_entry(evlist, counter) {
 939                         u64 ena, run, val;
 940                         double uval;
 941                         struct aggr_cpu_id id;
 942                         int counter_idx = perf_cpu_map__idx(evsel__cpus(counter), cpu);
 943
 944                         if (counter_idx < 0)
 945                                 continue;
 946
 947                         id = aggr_cpu_id__cpu(cpu, /*data=*/NULL);
 948                         if (first) {
 949                                 aggr_printout(config, counter, id, 0);
 950                                 first = false;
 951                         }
 952                         val = perf_counts(counter->counts, counter_idx, 0)->val;
 953                         ena = perf_counts(counter->counts, counter_idx, 0)->ena;
 954                         run = perf_counts(counter->counts, counter_idx, 0)->run;
 955
 956                         uval = val * counter->scale;
 957                         printout(config, id, 0, counter, uval, prefix,
 958                                  run, ena, 1.0, &rt_stat);
 959                 }
 960                 fputc('\n', config->output);
 961         }
 962 }
 963
 964 static int aggr_header_lens[] = {
 965         [AGGR_CORE] = 24,
 966         [AGGR_DIE] = 18,
 967         [AGGR_SOCKET] = 12,
 968         [AGGR_NONE] = 6,
 969         [AGGR_THREAD] = 24,
 970         [AGGR_GLOBAL] = 0,
 971 };
 972
 973 static const char *aggr_header_csv[] = {
 974         [AGGR_CORE]     =       "core,cpus,",
 975         [AGGR_DIE]      =       "die,cpus",
 976         [AGGR_SOCKET]   =       "socket,cpus",
 977         [AGGR_NONE]     =       "cpu,",
 978         [AGGR_THREAD]   =       "comm-pid,",
 979         [AGGR_GLOBAL]   =       ""
 980 };
 981
 982 static void print_metric_headers(struct perf_stat_config *config,
 983                                  struct evlist *evlist,
 984                                  const char *prefix, bool no_indent)
 985 {
 986         struct perf_stat_output_ctx out;
 987         struct evsel *counter;
 988         struct outstate os = {
 989                 .fh = config->output
 990         };
 991
 992         if (prefix)
 993                 fprintf(config->output, "%s", prefix);
 994
 995         if (!config->csv_output && !no_indent)
 996                 fprintf(config->output, "%*s",
 997                         aggr_header_lens[config->aggr_mode], "");
 998         if (config->csv_output) {
 999                 if (config->interval)
1000                         fputs("time,", config->output);
1001                 if (!config->iostat_run)
1002                         fputs(aggr_header_csv[config->aggr_mode], config->output);
1003         }
1004         if (config->iostat_run)
1005                 iostat_print_header_prefix(config);
1006
1007         /* Print metrics headers only */
1008         evlist__for_each_entry(evlist, counter) {
1009                 os.evsel = counter;
1010                 out.ctx = &os;
1011                 out.print_metric = print_metric_header;
1012                 out.new_line = new_line_metric;
1013                 out.force_header = true;
1014                 perf_stat__print_shadow_stats(config, counter, 0,
1015                                               0,
1016                                               &out,
1017                                               &config->metric_events,
1018                                               &rt_stat);
1019         }
1020         fputc('\n', config->output);
1021 }
1022
1023 static void print_interval(struct perf_stat_config *config,
1024                            struct evlist *evlist,
1025                            char *prefix, struct timespec *ts)
1026 {
1027         bool metric_only = config->metric_only;
1028         unsigned int unit_width = config->unit_width;
1029         FILE *output = config->output;
1030         static int num_print_interval;
1031
1032         if (config->interval_clear)
1033                 puts(CONSOLE_CLEAR);
1034
1035         if (!config->iostat_run)
1036                 sprintf(prefix, "%6lu.%09lu%s", (unsigned long) ts->tv_sec, ts->tv_nsec, config->csv_sep);
1037
1038         if ((num_print_interval == 0 && !config->csv_output) || config->interval_clear) {
1039                 switch (config->aggr_mode) {
1040                 case AGGR_NODE:
1041                         fprintf(output, "#           time node   cpus");
1042                         if (!metric_only)
1043                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
1044                         break;
1045                 case AGGR_SOCKET:
1046                         fprintf(output, "#           time socket cpus");
1047                         if (!metric_only)
1048                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
1049                         break;
1050                 case AGGR_DIE:
1051                         fprintf(output, "#           time die          cpus");
1052                         if (!metric_only)
1053                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
1054                         break;
1055                 case AGGR_CORE:
1056                         fprintf(output, "#           time core            cpus");
1057                         if (!metric_only)
1058                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
1059                         break;
1060                 case AGGR_NONE:
1061                         fprintf(output, "#           time CPU    ");
1062                         if (!metric_only)
1063                                 fprintf(output, "                counts %*s events\n", unit_width, "unit");
1064                         break;
1065                 case AGGR_THREAD:
1066                         fprintf(output, "#           time             comm-pid");
1067                         if (!metric_only)
1068                                 fprintf(output, "                  counts %*s events\n", unit_width, "unit");
1069                         break;
1070                 case AGGR_GLOBAL:
1071                 default:
1072                         if (!config->iostat_run) {
1073                                 fprintf(output, "#           time");
1074                                 if (!metric_only)
1075                                         fprintf(output, "             counts %*s events\n", unit_width, "unit");
1076                         }
1077                 case AGGR_UNSET:
1078                         break;
1079                 }
1080         }
1081
1082         if ((num_print_interval == 0 || config->interval_clear) && metric_only)
1083                 print_metric_headers(config, evlist, " ", true);
1084         if (++num_print_interval == 25)
1085                 num_print_interval = 0;
1086 }
1087
1088 static void print_header(struct perf_stat_config *config,
1089                          struct target *_target,
1090                          int argc, const char **argv)
1091 {
1092         FILE *output = config->output;
1093         int i;
1094
1095         fflush(stdout);
1096
1097         if (!config->csv_output) {
1098                 fprintf(output, "\n");
1099                 fprintf(output, " Performance counter stats for ");
1100                 if (_target->bpf_str)
1101                         fprintf(output, "\'BPF program(s) %s", _target->bpf_str);
1102                 else if (_target->system_wide)
1103                         fprintf(output, "\'system wide");
1104                 else if (_target->cpu_list)
1105                         fprintf(output, "\'CPU(s) %s", _target->cpu_list);
1106                 else if (!target__has_task(_target)) {
1107                         fprintf(output, "\'%s", argv ? argv[0] : "pipe");
1108                         for (i = 1; argv && (i < argc); i++)
1109                                 fprintf(output, " %s", argv[i]);
1110                 } else if (_target->pid)
1111                         fprintf(output, "process id \'%s", _target->pid);
1112                 else
1113                         fprintf(output, "thread id \'%s", _target->tid);
1114
1115                 fprintf(output, "\'");
1116                 if (config->run_count > 1)
1117                         fprintf(output, " (%d runs)", config->run_count);
1118                 fprintf(output, ":\n\n");
1119         }
1120 }
1121
1122 static int get_precision(double num)
1123 {
1124         if (num > 1)
1125                 return 0;
1126
1127         return lround(ceil(-log10(num)));
1128 }
1129
1130 static void print_table(struct perf_stat_config *config,
1131                         FILE *output, int precision, double avg)
1132 {
1133         char tmp[64];
1134         int idx, indent = 0;
1135
1136         scnprintf(tmp, 64, " %17.*f", precision, avg);
1137         while (tmp[indent] == ' ')
1138                 indent++;
1139
1140         fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
1141
1142         for (idx = 0; idx < config->run_count; idx++) {
1143                 double run = (double) config->walltime_run[idx] / NSEC_PER_SEC;
1144                 int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
1145
1146                 fprintf(output, " %17.*f (%+.*f) ",
1147                         precision, run, precision, run - avg);
1148
1149                 for (h = 0; h < n; h++)
1150                         fprintf(output, "#");
1151
1152                 fprintf(output, "\n");
1153         }
1154
1155         fprintf(output, "\n%*s# Final result:\n", indent, "");
1156 }
1157
1158 static double timeval2double(struct timeval *t)
1159 {
1160         return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
1161 }
1162
1163 static void print_footer(struct perf_stat_config *config)
1164 {
1165         double avg = avg_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
1166         FILE *output = config->output;
1167
1168         if (!config->null_run)
1169                 fprintf(output, "\n");
1170
1171         if (config->run_count == 1) {
1172                 fprintf(output, " %17.9f seconds time elapsed", avg);
1173
1174                 if (config->ru_display) {
1175                         double ru_utime = timeval2double(&config->ru_data.ru_utime);
1176                         double ru_stime = timeval2double(&config->ru_data.ru_stime);
1177
1178                         fprintf(output, "\n\n");
1179                         fprintf(output, " %17.9f seconds user\n", ru_utime);
1180                         fprintf(output, " %17.9f seconds sys\n", ru_stime);
1181                 }
1182         } else {
1183                 double sd = stddev_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
1184                 /*
1185                  * Display at most 2 more significant
1186                  * digits than the stddev inaccuracy.
1187                  */
1188                 int precision = get_precision(sd) + 2;
1189
1190                 if (config->walltime_run_table)
1191                         print_table(config, output, precision, avg);
1192
1193                 fprintf(output, " %17.*f +- %.*f seconds time elapsed",
1194                         precision, avg, precision, sd);
1195
1196                 print_noise_pct(config, sd, avg);
1197         }
1198         fprintf(output, "\n\n");
1199
1200         if (config->print_free_counters_hint && sysctl__nmi_watchdog_enabled())
1201                 fprintf(output,
1202 "Some events weren't counted. Try disabling the NMI watchdog:\n"
1203 "       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
1204 "       perf stat ...\n"
1205 "       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
1206
1207         if (config->print_mixed_hw_group_error)
1208                 fprintf(output,
1209                         "The events in group usually have to be from "
1210                         "the same PMU. Try reorganizing the group.\n");
1211 }
1212
1213 static void print_percore_thread(struct perf_stat_config *config,
1214                                  struct evsel *counter, char *prefix)
1215 {
1216         int s;
1217         struct aggr_cpu_id s2, id;
1218         struct perf_cpu_map *cpus;
1219         bool first = true;
1220         int idx;
1221         struct perf_cpu cpu;
1222
1223         cpus = evsel__cpus(counter);
1224         perf_cpu_map__for_each_cpu(cpu, idx, cpus) {
1225                 s2 = config->aggr_get_id(config, cpu);
1226                 for (s = 0; s < config->aggr_map->nr; s++) {
1227                         id = config->aggr_map->map[s];
1228                         if (aggr_cpu_id__equal(&s2, &id))
1229                                 break;
1230                 }
1231
1232                 print_counter_aggrdata(config, counter, s,
1233                                        prefix, false,
1234                                        &first, cpu);
1235         }
1236 }
1237
1238 static void print_percore(struct perf_stat_config *config,
1239                           struct evsel *counter, char *prefix)
1240 {
1241         bool metric_only = config->metric_only;
1242         FILE *output = config->output;
1243         int s;
1244         bool first = true;
1245
1246         if (!config->aggr_map || !config->aggr_get_id)
1247                 return;
1248
1249         if (config->percore_show_thread)
1250                 return print_percore_thread(config, counter, prefix);
1251
1252         for (s = 0; s < config->aggr_map->nr; s++) {
1253                 if (prefix && metric_only)
1254                         fprintf(output, "%s", prefix);
1255
1256                 print_counter_aggrdata(config, counter, s,
1257                                 prefix, metric_only,
1258                                 &first, (struct perf_cpu){ .cpu = -1 });
1259         }
1260
1261         if (metric_only)
1262                 fputc('\n', output);
1263 }
1264
1265 void evlist__print_counters(struct evlist *evlist, struct perf_stat_config *config,
1266                             struct target *_target, struct timespec *ts, int argc, const char **argv)
1267 {
1268         bool metric_only = config->metric_only;
1269         int interval = config->interval;
1270         struct evsel *counter;
1271         char buf[64], *prefix = NULL;
1272
1273         if (config->iostat_run)
1274                 evlist->selected = evlist__first(evlist);
1275
1276         if (interval)
1277                 print_interval(config, evlist, prefix = buf, ts);
1278         else
1279                 print_header(config, _target, argc, argv);
1280
1281         if (metric_only) {
1282                 static int num_print_iv;
1283
1284                 if (num_print_iv == 0 && !interval)
1285                         print_metric_headers(config, evlist, prefix, false);
1286                 if (num_print_iv++ == 25)
1287                         num_print_iv = 0;
1288                 if (config->aggr_mode == AGGR_GLOBAL && prefix && !config->iostat_run)
1289                         fprintf(config->output, "%s", prefix);
1290         }
1291
1292         switch (config->aggr_mode) {
1293         case AGGR_CORE:
1294         case AGGR_DIE:
1295         case AGGR_SOCKET:
1296         case AGGR_NODE:
1297                 print_aggr(config, evlist, prefix);
1298                 break;
1299         case AGGR_THREAD:
1300                 evlist__for_each_entry(evlist, counter) {
1301                         print_aggr_thread(config, _target, counter, prefix);
1302                 }
1303                 break;
1304         case AGGR_GLOBAL:
1305                 if (config->iostat_run)
1306                         iostat_print_counters(evlist, config, ts, prefix = buf,
1307                                               print_counter_aggr);
1308                 else {
1309                         evlist__for_each_entry(evlist, counter) {
1310                                 print_counter_aggr(config, counter, prefix);
1311                         }
1312                         if (metric_only)
1313                                 fputc('\n', config->output);
1314                 }
1315                 break;
1316         case AGGR_NONE:
1317                 if (metric_only)
1318                         print_no_aggr_metric(config, evlist, prefix);
1319                 else {
1320                         evlist__for_each_entry(evlist, counter) {
1321                                 if (counter->percore)
1322                                         print_percore(config, counter, prefix);
1323                                 else
1324                                         print_counter(config, counter, prefix);
1325                         }
1326                 }
1327                 break;
1328         case AGGR_UNSET:
1329         default:
1330                 break;
1331         }
1332
1333         if (!interval && !config->csv_output)
1334                 print_footer(config);
1335
1336         fflush(config->output);
1337 }