tools/perf/builtin-stat.c

   1 /*
   2  * builtin-stat.c
   3  *
   4  * Builtin stat command: Give a precise performance counters summary
   5  * overview about any workload, CPU or specific PID.
   6  *
   7  * Sample output:
   8
   9    $ perf stat ./hackbench 10
  10
  11   Time: 0.118
  12
  13   Performance counter stats for './hackbench 10':
  14
  15        1708.761321 task-clock                #   11.037 CPUs utilized
  16             41,190 context-switches          #    0.024 M/sec
  17              6,735 CPU-migrations            #    0.004 M/sec
  18             17,318 page-faults               #    0.010 M/sec
  19      5,205,202,243 cycles                    #    3.046 GHz
  20      3,856,436,920 stalled-cycles-frontend   #   74.09% frontend cycles idle
  21      1,600,790,871 stalled-cycles-backend    #   30.75% backend  cycles idle
  22      2,603,501,247 instructions              #    0.50  insns per cycle
  23                                              #    1.48  stalled cycles per insn
  24        484,357,498 branches                  #  283.455 M/sec
  25          6,388,934 branch-misses             #    1.32% of all branches
  26
  27         0.154822978  seconds time elapsed
  28
  29  *
  30  * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  31  *
  32  * Improvements and fixes by:
  33  *
  34  *   Arjan van de Ven <arjan@linux.intel.com>
  35  *   Yanmin Zhang <yanmin.zhang@intel.com>
  36  *   Wu Fengguang <fengguang.wu@intel.com>
  37  *   Mike Galbraith <efault@gmx.de>
  38  *   Paul Mackerras <paulus@samba.org>
  39  *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  40  *
  41  * Released under the GPL v2. (and only v2, not any later version)
  42  */
  43
  44 #include "perf.h"
  45 #include "builtin.h"
  46 #include "util/util.h"
  47 #include "util/parse-options.h"
  48 #include "util/parse-events.h"
  49 #include "util/event.h"
  50 #include "util/evlist.h"
  51 #include "util/evsel.h"
  52 #include "util/debug.h"
  53 #include "util/color.h"
  54 #include "util/stat.h"
  55 #include "util/header.h"
  56 #include "util/cpumap.h"
  57 #include "util/thread.h"
  58 #include "util/thread_map.h"
  59
  60 #include <stdlib.h>
  61 #include <sys/prctl.h>
  62 #include <locale.h>
  63
  64 #define DEFAULT_SEPARATOR       " "
  65 #define CNTR_NOT_SUPPORTED      "<not supported>"
  66 #define CNTR_NOT_COUNTED        "<not counted>"
  67
  68 static void print_stat(int argc, const char **argv);
  69 static void print_counter_aggr(struct perf_evsel *counter, char *prefix);
  70 static void print_counter(struct perf_evsel *counter, char *prefix);
  71 static void print_aggr_socket(char *prefix);
  72
  73 static struct perf_evlist       *evsel_list;
  74
  75 static struct perf_target       target = {
  76         .uid    = UINT_MAX,
  77 };
  78
  79 static int                      run_count                       =  1;
  80 static bool                     no_inherit                      = false;
  81 static bool                     scale                           =  true;
  82 static bool                     no_aggr                         = false;
  83 static bool                     aggr_socket                     = false;
  84 static pid_t                    child_pid                       = -1;
  85 static bool                     null_run                        =  false;
  86 static int                      detailed_run                    =  0;
  87 static bool                     big_num                         =  true;
  88 static int                      big_num_opt                     =  -1;
  89 static const char               *csv_sep                        = NULL;
  90 static bool                     csv_output                      = false;
  91 static bool                     group                           = false;
  92 static FILE                     *output                         = NULL;
  93 static const char               *pre_cmd                        = NULL;
  94 static const char               *post_cmd                       = NULL;
  95 static bool                     sync_run                        = false;
  96 static unsigned int             interval                        = 0;
  97 static struct timespec          ref_time;
  98 static struct cpu_map           *sock_map;
  99
 100 static volatile int done = 0;
 101
 102 struct perf_stat {
 103         struct stats      res_stats[3];
 104 };
 105
 106 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 107                                  struct timespec *b)
 108 {
 109         r->tv_sec = a->tv_sec - b->tv_sec;
 110         if (a->tv_nsec < b->tv_nsec) {
 111                 r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
 112                 r->tv_sec--;
 113         } else {
 114                 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
 115         }
 116 }
 117
 118 static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
 119 {
 120         return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
 121 }
 122
 123 static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
 124 {
 125         return perf_evsel__cpus(evsel)->nr;
 126 }
 127
 128 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 129 {
 130         evsel->priv = zalloc(sizeof(struct perf_stat));
 131         return evsel->priv == NULL ? -ENOMEM : 0;
 132 }
 133
 134 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
 135 {
 136         free(evsel->priv);
 137         evsel->priv = NULL;
 138 }
 139
 140 static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel)
 141 {
 142         void *addr;
 143         size_t sz;
 144
 145         sz = sizeof(*evsel->counts) +
 146              (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values));
 147
 148         addr = zalloc(sz);
 149         if (!addr)
 150                 return -ENOMEM;
 151
 152         evsel->prev_raw_counts =  addr;
 153
 154         return 0;
 155 }
 156
 157 static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
 158 {
 159         free(evsel->prev_raw_counts);
 160         evsel->prev_raw_counts = NULL;
 161 }
 162
 163 static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
 164 static struct stats runtime_cycles_stats[MAX_NR_CPUS];
 165 static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
 166 static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
 167 static struct stats runtime_branches_stats[MAX_NR_CPUS];
 168 static struct stats runtime_cacherefs_stats[MAX_NR_CPUS];
 169 static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS];
 170 static struct stats runtime_l1_icache_stats[MAX_NR_CPUS];
 171 static struct stats runtime_ll_cache_stats[MAX_NR_CPUS];
 172 static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
 173 static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
 174 static struct stats walltime_nsecs_stats;
 175
 176 static int create_perf_stat_counter(struct perf_evsel *evsel)
 177 {
 178         struct perf_event_attr *attr = &evsel->attr;
 179
 180         if (scale)
 181                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 182                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 183
 184         attr->inherit = !no_inherit;
 185
 186         if (perf_target__has_cpu(&target))
 187                 return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
 188
 189         if (!perf_target__has_task(&target) &&
 190             perf_evsel__is_group_leader(evsel)) {
 191                 attr->disabled = 1;
 192                 attr->enable_on_exec = 1;
 193         }
 194
 195         return perf_evsel__open_per_thread(evsel, evsel_list->threads);
 196 }
 197
 198 /*
 199  * Does the counter have nsecs as a unit?
 200  */
 201 static inline int nsec_counter(struct perf_evsel *evsel)
 202 {
 203         if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
 204             perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 205                 return 1;
 206
 207         return 0;
 208 }
 209
 210 /*
 211  * Update various tracking values we maintain to print
 212  * more semantic information such as miss/hit ratios,
 213  * instruction rates, etc:
 214  */
 215 static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
 216 {
 217         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
 218                 update_stats(&runtime_nsecs_stats[0], count[0]);
 219         else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
 220                 update_stats(&runtime_cycles_stats[0], count[0]);
 221         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
 222                 update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
 223         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
 224                 update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
 225         else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
 226                 update_stats(&runtime_branches_stats[0], count[0]);
 227         else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
 228                 update_stats(&runtime_cacherefs_stats[0], count[0]);
 229         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
 230                 update_stats(&runtime_l1_dcache_stats[0], count[0]);
 231         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
 232                 update_stats(&runtime_l1_icache_stats[0], count[0]);
 233         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
 234                 update_stats(&runtime_ll_cache_stats[0], count[0]);
 235         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
 236                 update_stats(&runtime_dtlb_cache_stats[0], count[0]);
 237         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
 238                 update_stats(&runtime_itlb_cache_stats[0], count[0]);
 239 }
 240
 241 /*
 242  * Read out the results of a single counter:
 243  * aggregate counts across CPUs in system-wide mode
 244  */
 245 static int read_counter_aggr(struct perf_evsel *counter)
 246 {
 247         struct perf_stat *ps = counter->priv;
 248         u64 *count = counter->counts->aggr.values;
 249         int i;
 250
 251         if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter),
 252                                thread_map__nr(evsel_list->threads), scale) < 0)
 253                 return -1;
 254
 255         for (i = 0; i < 3; i++)
 256                 update_stats(&ps->res_stats[i], count[i]);
 257
 258         if (verbose) {
 259                 fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
 260                         perf_evsel__name(counter), count[0], count[1], count[2]);
 261         }
 262
 263         /*
 264          * Save the full runtime - to allow normalization during printout:
 265          */
 266         update_shadow_stats(counter, count);
 267
 268         return 0;
 269 }
 270
 271 /*
 272  * Read out the results of a single counter:
 273  * do not aggregate counts across CPUs in system-wide mode
 274  */
 275 static int read_counter(struct perf_evsel *counter)
 276 {
 277         u64 *count;
 278         int cpu;
 279
 280         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
 281                 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
 282                         return -1;
 283
 284                 count = counter->counts->cpu[cpu].values;
 285
 286                 update_shadow_stats(counter, count);
 287         }
 288
 289         return 0;
 290 }
 291
 292 static void print_interval(void)
 293 {
 294         static int num_print_interval;
 295         struct perf_evsel *counter;
 296         struct perf_stat *ps;
 297         struct timespec ts, rs;
 298         char prefix[64];
 299
 300         if (no_aggr) {
 301                 list_for_each_entry(counter, &evsel_list->entries, node) {
 302                         ps = counter->priv;
 303                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
 304                         read_counter(counter);
 305                 }
 306         } else {
 307                 list_for_each_entry(counter, &evsel_list->entries, node) {
 308                         ps = counter->priv;
 309                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
 310                         read_counter_aggr(counter);
 311                 }
 312         }
 313         clock_gettime(CLOCK_MONOTONIC, &ts);
 314         diff_timespec(&rs, &ts, &ref_time);
 315         sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep);
 316
 317         if (num_print_interval == 0 && !csv_output) {
 318                 if (aggr_socket)
 319                         fprintf(output, "#           time socket cpus             counts events\n");
 320                 else if (no_aggr)
 321                         fprintf(output, "#           time CPU                 counts events\n");
 322                 else
 323                         fprintf(output, "#           time             counts events\n");
 324         }
 325
 326         if (++num_print_interval == 25)
 327                 num_print_interval = 0;
 328
 329         if (aggr_socket)
 330                 print_aggr_socket(prefix);
 331         else if (no_aggr) {
 332                 list_for_each_entry(counter, &evsel_list->entries, node)
 333                         print_counter(counter, prefix);
 334         } else {
 335                 list_for_each_entry(counter, &evsel_list->entries, node)
 336                         print_counter_aggr(counter, prefix);
 337         }
 338 }
 339
 340 static int __run_perf_stat(int argc, const char **argv)
 341 {
 342         char msg[512];
 343         unsigned long long t0, t1;
 344         struct perf_evsel *counter;
 345         struct timespec ts;
 346         int status = 0;
 347         const bool forks = (argc > 0);
 348
 349         if (interval) {
 350                 ts.tv_sec  = interval / 1000;
 351                 ts.tv_nsec = (interval % 1000) * 1000000;
 352         } else {
 353                 ts.tv_sec  = 1;
 354                 ts.tv_nsec = 0;
 355         }
 356
 357         if (aggr_socket
 358             && cpu_map__build_socket_map(evsel_list->cpus, &sock_map)) {
 359                 perror("cannot build socket map");
 360                 return -1;
 361         }
 362
 363         if (forks) {
 364                 if (perf_evlist__prepare_workload(evsel_list, &target, argv,
 365                                                   false, false) < 0) {
 366                         perror("failed to prepare workload");
 367                         return -1;
 368                 }
 369         }
 370
 371         if (group)
 372                 perf_evlist__set_leader(evsel_list);
 373
 374         list_for_each_entry(counter, &evsel_list->entries, node) {
 375                 if (create_perf_stat_counter(counter) < 0) {
 376                         /*
 377                          * PPC returns ENXIO for HW counters until 2.6.37
 378                          * (behavior changed with commit b0a873e).
 379                          */
 380                         if (errno == EINVAL || errno == ENOSYS ||
 381                             errno == ENOENT || errno == EOPNOTSUPP ||
 382                             errno == ENXIO) {
 383                                 if (verbose)
 384                                         ui__warning("%s event is not supported by the kernel.\n",
 385                                                     perf_evsel__name(counter));
 386                                 counter->supported = false;
 387                                 continue;
 388                         }
 389
 390                         perf_evsel__open_strerror(counter, &target,
 391                                                   errno, msg, sizeof(msg));
 392                         ui__error("%s\n", msg);
 393
 394                         if (child_pid != -1)
 395                                 kill(child_pid, SIGTERM);
 396
 397                         return -1;
 398                 }
 399                 counter->supported = true;
 400         }
 401
 402         if (perf_evlist__apply_filters(evsel_list)) {
 403                 error("failed to set filter with %d (%s)\n", errno,
 404                         strerror(errno));
 405                 return -1;
 406         }
 407
 408         /*
 409          * Enable counters and exec the command:
 410          */
 411         t0 = rdclock();
 412         clock_gettime(CLOCK_MONOTONIC, &ref_time);
 413
 414         if (forks) {
 415                 perf_evlist__start_workload(evsel_list);
 416
 417                 if (interval) {
 418                         while (!waitpid(child_pid, &status, WNOHANG)) {
 419                                 nanosleep(&ts, NULL);
 420                                 print_interval();
 421                         }
 422                 }
 423                 wait(&status);
 424                 if (WIFSIGNALED(status))
 425                         psignal(WTERMSIG(status), argv[0]);
 426         } else {
 427                 while (!done) {
 428                         nanosleep(&ts, NULL);
 429                         if (interval)
 430                                 print_interval();
 431                 }
 432         }
 433
 434         t1 = rdclock();
 435
 436         update_stats(&walltime_nsecs_stats, t1 - t0);
 437
 438         if (no_aggr) {
 439                 list_for_each_entry(counter, &evsel_list->entries, node) {
 440                         read_counter(counter);
 441                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
 442                 }
 443         } else {
 444                 list_for_each_entry(counter, &evsel_list->entries, node) {
 445                         read_counter_aggr(counter);
 446                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
 447                                              thread_map__nr(evsel_list->threads));
 448                 }
 449         }
 450
 451         return WEXITSTATUS(status);
 452 }
 453
 454 static int run_perf_stat(int argc __maybe_unused, const char **argv)
 455 {
 456         int ret;
 457
 458         if (pre_cmd) {
 459                 ret = system(pre_cmd);
 460                 if (ret)
 461                         return ret;
 462         }
 463
 464         if (sync_run)
 465                 sync();
 466
 467         ret = __run_perf_stat(argc, argv);
 468         if (ret)
 469                 return ret;
 470
 471         if (post_cmd) {
 472                 ret = system(post_cmd);
 473                 if (ret)
 474                         return ret;
 475         }
 476
 477         return ret;
 478 }
 479
 480 static void print_noise_pct(double total, double avg)
 481 {
 482         double pct = rel_stddev_stats(total, avg);
 483
 484         if (csv_output)
 485                 fprintf(output, "%s%.2f%%", csv_sep, pct);
 486         else if (pct)
 487                 fprintf(output, "  ( +-%6.2f%% )", pct);
 488 }
 489
 490 static void print_noise(struct perf_evsel *evsel, double avg)
 491 {
 492         struct perf_stat *ps;
 493
 494         if (run_count == 1)
 495                 return;
 496
 497         ps = evsel->priv;
 498         print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
 499 }
 500
 501 static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
 502 {
 503         double msecs = avg / 1e6;
 504         char cpustr[16] = { '\0', };
 505         const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-25s";
 506
 507         if (aggr_socket)
 508                 sprintf(cpustr, "S%*d%s%*d%s",
 509                         csv_output ? 0 : -5,
 510                         cpu,
 511                         csv_sep,
 512                         csv_output ? 0 : 4,
 513                         nr,
 514                         csv_sep);
 515         else if (no_aggr)
 516                 sprintf(cpustr, "CPU%*d%s",
 517                         csv_output ? 0 : -4,
 518                         perf_evsel__cpus(evsel)->map[cpu], csv_sep);
 519
 520         fprintf(output, fmt, cpustr, msecs, csv_sep, perf_evsel__name(evsel));
 521
 522         if (evsel->cgrp)
 523                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 524
 525         if (csv_output || interval)
 526                 return;
 527
 528         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 529                 fprintf(output, " # %8.3f CPUs utilized          ",
 530                         avg / avg_stats(&walltime_nsecs_stats));
 531         else
 532                 fprintf(output, "                                   ");
 533 }
 534
 535 /* used for get_ratio_color() */
 536 enum grc_type {
 537         GRC_STALLED_CYCLES_FE,
 538         GRC_STALLED_CYCLES_BE,
 539         GRC_CACHE_MISSES,
 540         GRC_MAX_NR
 541 };
 542
 543 static const char *get_ratio_color(enum grc_type type, double ratio)
 544 {
 545         static const double grc_table[GRC_MAX_NR][3] = {
 546                 [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
 547                 [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
 548                 [GRC_CACHE_MISSES]      = { 20.0, 10.0, 5.0 },
 549         };
 550         const char *color = PERF_COLOR_NORMAL;
 551
 552         if (ratio > grc_table[type][0])
 553                 color = PERF_COLOR_RED;
 554         else if (ratio > grc_table[type][1])
 555                 color = PERF_COLOR_MAGENTA;
 556         else if (ratio > grc_table[type][2])
 557                 color = PERF_COLOR_YELLOW;
 558
 559         return color;
 560 }
 561
 562 static void print_stalled_cycles_frontend(int cpu,
 563                                           struct perf_evsel *evsel
 564                                           __maybe_unused, double avg)
 565 {
 566         double total, ratio = 0.0;
 567         const char *color;
 568
 569         total = avg_stats(&runtime_cycles_stats[cpu]);
 570
 571         if (total)
 572                 ratio = avg / total * 100.0;
 573
 574         color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
 575
 576         fprintf(output, " #  ");
 577         color_fprintf(output, color, "%6.2f%%", ratio);
 578         fprintf(output, " frontend cycles idle   ");
 579 }
 580
 581 static void print_stalled_cycles_backend(int cpu,
 582                                          struct perf_evsel *evsel
 583                                          __maybe_unused, double avg)
 584 {
 585         double total, ratio = 0.0;
 586         const char *color;
 587
 588         total = avg_stats(&runtime_cycles_stats[cpu]);
 589
 590         if (total)
 591                 ratio = avg / total * 100.0;
 592
 593         color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
 594
 595         fprintf(output, " #  ");
 596         color_fprintf(output, color, "%6.2f%%", ratio);
 597         fprintf(output, " backend  cycles idle   ");
 598 }
 599
 600 static void print_branch_misses(int cpu,
 601                                 struct perf_evsel *evsel __maybe_unused,
 602                                 double avg)
 603 {
 604         double total, ratio = 0.0;
 605         const char *color;
 606
 607         total = avg_stats(&runtime_branches_stats[cpu]);
 608
 609         if (total)
 610                 ratio = avg / total * 100.0;
 611
 612         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 613
 614         fprintf(output, " #  ");
 615         color_fprintf(output, color, "%6.2f%%", ratio);
 616         fprintf(output, " of all branches        ");
 617 }
 618
 619 static void print_l1_dcache_misses(int cpu,
 620                                    struct perf_evsel *evsel __maybe_unused,
 621                                    double avg)
 622 {
 623         double total, ratio = 0.0;
 624         const char *color;
 625
 626         total = avg_stats(&runtime_l1_dcache_stats[cpu]);
 627
 628         if (total)
 629                 ratio = avg / total * 100.0;
 630
 631         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 632
 633         fprintf(output, " #  ");
 634         color_fprintf(output, color, "%6.2f%%", ratio);
 635         fprintf(output, " of all L1-dcache hits  ");
 636 }
 637
 638 static void print_l1_icache_misses(int cpu,
 639                                    struct perf_evsel *evsel __maybe_unused,
 640                                    double avg)
 641 {
 642         double total, ratio = 0.0;
 643         const char *color;
 644
 645         total = avg_stats(&runtime_l1_icache_stats[cpu]);
 646
 647         if (total)
 648                 ratio = avg / total * 100.0;
 649
 650         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 651
 652         fprintf(output, " #  ");
 653         color_fprintf(output, color, "%6.2f%%", ratio);
 654         fprintf(output, " of all L1-icache hits  ");
 655 }
 656
 657 static void print_dtlb_cache_misses(int cpu,
 658                                     struct perf_evsel *evsel __maybe_unused,
 659                                     double avg)
 660 {
 661         double total, ratio = 0.0;
 662         const char *color;
 663
 664         total = avg_stats(&runtime_dtlb_cache_stats[cpu]);
 665
 666         if (total)
 667                 ratio = avg / total * 100.0;
 668
 669         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 670
 671         fprintf(output, " #  ");
 672         color_fprintf(output, color, "%6.2f%%", ratio);
 673         fprintf(output, " of all dTLB cache hits ");
 674 }
 675
 676 static void print_itlb_cache_misses(int cpu,
 677                                     struct perf_evsel *evsel __maybe_unused,
 678                                     double avg)
 679 {
 680         double total, ratio = 0.0;
 681         const char *color;
 682
 683         total = avg_stats(&runtime_itlb_cache_stats[cpu]);
 684
 685         if (total)
 686                 ratio = avg / total * 100.0;
 687
 688         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 689
 690         fprintf(output, " #  ");
 691         color_fprintf(output, color, "%6.2f%%", ratio);
 692         fprintf(output, " of all iTLB cache hits ");
 693 }
 694
 695 static void print_ll_cache_misses(int cpu,
 696                                   struct perf_evsel *evsel __maybe_unused,
 697                                   double avg)
 698 {
 699         double total, ratio = 0.0;
 700         const char *color;
 701
 702         total = avg_stats(&runtime_ll_cache_stats[cpu]);
 703
 704         if (total)
 705                 ratio = avg / total * 100.0;
 706
 707         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 708
 709         fprintf(output, " #  ");
 710         color_fprintf(output, color, "%6.2f%%", ratio);
 711         fprintf(output, " of all LL-cache hits   ");
 712 }
 713
 714 static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
 715 {
 716         double total, ratio = 0.0;
 717         char cpustr[16] = { '\0', };
 718         const char *fmt;
 719
 720         if (csv_output)
 721                 fmt = "%s%.0f%s%s";
 722         else if (big_num)
 723                 fmt = "%s%'18.0f%s%-25s";
 724         else
 725                 fmt = "%s%18.0f%s%-25s";
 726
 727         if (aggr_socket)
 728                 sprintf(cpustr, "S%*d%s%*d%s",
 729                         csv_output ? 0 : -5,
 730                         cpu,
 731                         csv_sep,
 732                         csv_output ? 0 : 4,
 733                         nr,
 734                         csv_sep);
 735         else if (no_aggr)
 736                 sprintf(cpustr, "CPU%*d%s",
 737                         csv_output ? 0 : -4,
 738                         perf_evsel__cpus(evsel)->map[cpu], csv_sep);
 739         else
 740                 cpu = 0;
 741
 742         fprintf(output, fmt, cpustr, avg, csv_sep, perf_evsel__name(evsel));
 743
 744         if (evsel->cgrp)
 745                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 746
 747         if (csv_output || interval)
 748                 return;
 749
 750         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
 751                 total = avg_stats(&runtime_cycles_stats[cpu]);
 752                 if (total)
 753                         ratio = avg / total;
 754
 755                 fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
 756
 757                 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
 758                 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
 759
 760                 if (total && avg) {
 761                         ratio = total / avg;
 762                         fprintf(output, "\n                                             #   %5.2f  stalled cycles per insn", ratio);
 763                 }
 764
 765         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
 766                         runtime_branches_stats[cpu].n != 0) {
 767                 print_branch_misses(cpu, evsel, avg);
 768         } else if (
 769                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 770                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
 771                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 772                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 773                         runtime_l1_dcache_stats[cpu].n != 0) {
 774                 print_l1_dcache_misses(cpu, evsel, avg);
 775         } else if (
 776                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 777                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
 778                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 779                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 780                         runtime_l1_icache_stats[cpu].n != 0) {
 781                 print_l1_icache_misses(cpu, evsel, avg);
 782         } else if (
 783                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 784                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
 785                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 786                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 787                         runtime_dtlb_cache_stats[cpu].n != 0) {
 788                 print_dtlb_cache_misses(cpu, evsel, avg);
 789         } else if (
 790                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 791                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
 792                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 793                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 794                         runtime_itlb_cache_stats[cpu].n != 0) {
 795                 print_itlb_cache_misses(cpu, evsel, avg);
 796         } else if (
 797                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 798                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
 799                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 800                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 801                         runtime_ll_cache_stats[cpu].n != 0) {
 802                 print_ll_cache_misses(cpu, evsel, avg);
 803         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
 804                         runtime_cacherefs_stats[cpu].n != 0) {
 805                 total = avg_stats(&runtime_cacherefs_stats[cpu]);
 806
 807                 if (total)
 808                         ratio = avg * 100 / total;
 809
 810                 fprintf(output, " # %8.3f %% of all cache refs    ", ratio);
 811
 812         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
 813                 print_stalled_cycles_frontend(cpu, evsel, avg);
 814         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
 815                 print_stalled_cycles_backend(cpu, evsel, avg);
 816         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
 817                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 818
 819                 if (total)
 820                         ratio = 1.0 * avg / total;
 821
 822                 fprintf(output, " # %8.3f GHz                    ", ratio);
 823         } else if (runtime_nsecs_stats[cpu].n != 0) {
 824                 char unit = 'M';
 825
 826                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 827
 828                 if (total)
 829                         ratio = 1000.0 * avg / total;
 830                 if (ratio < 0.001) {
 831                         ratio *= 1000;
 832                         unit = 'K';
 833                 }
 834
 835                 fprintf(output, " # %8.3f %c/sec                  ", ratio, unit);
 836         } else {
 837                 fprintf(output, "                                   ");
 838         }
 839 }
 840
 841 static void print_aggr_socket(char *prefix)
 842 {
 843         struct perf_evsel *counter;
 844         u64 ena, run, val;
 845         int cpu, s, s2, sock, nr;
 846
 847         if (!sock_map)
 848                 return;
 849
 850         for (s = 0; s < sock_map->nr; s++) {
 851                 sock = cpu_map__socket(sock_map, s);
 852                 list_for_each_entry(counter, &evsel_list->entries, node) {
 853                         val = ena = run = 0;
 854                         nr = 0;
 855                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
 856                                 s2 = cpu_map__get_socket(evsel_list->cpus, cpu);
 857                                 if (s2 != sock)
 858                                         continue;
 859                                 val += counter->counts->cpu[cpu].val;
 860                                 ena += counter->counts->cpu[cpu].ena;
 861                                 run += counter->counts->cpu[cpu].run;
 862                                 nr++;
 863                         }
 864                         if (prefix)
 865                                 fprintf(output, "%s", prefix);
 866
 867                         if (run == 0 || ena == 0) {
 868                                 fprintf(output, "S%*d%s%*d%s%*s%s%*s",
 869                                         csv_output ? 0 : -5,
 870                                         s,
 871                                         csv_sep,
 872                                         csv_output ? 0 : 4,
 873                                         nr,
 874                                         csv_sep,
 875                                         csv_output ? 0 : 18,
 876                                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
 877                                         csv_sep,
 878                                         csv_output ? 0 : -24,
 879                                         perf_evsel__name(counter));
 880                                 if (counter->cgrp)
 881                                         fprintf(output, "%s%s",
 882                                                 csv_sep, counter->cgrp->name);
 883
 884                                 fputc('\n', output);
 885                                 continue;
 886                         }
 887
 888                         if (nsec_counter(counter))
 889                                 nsec_printout(sock, nr, counter, val);
 890                         else
 891                                 abs_printout(sock, nr, counter, val);
 892
 893                         if (!csv_output) {
 894                                 print_noise(counter, 1.0);
 895
 896                                 if (run != ena)
 897                                         fprintf(output, "  (%.2f%%)",
 898                                                 100.0 * run / ena);
 899                         }
 900                         fputc('\n', output);
 901                 }
 902         }
 903 }
 904
 905 /*
 906  * Print out the results of a single counter:
 907  * aggregated counts in system-wide mode
 908  */
 909 static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
 910 {
 911         struct perf_stat *ps = counter->priv;
 912         double avg = avg_stats(&ps->res_stats[0]);
 913         int scaled = counter->counts->scaled;
 914
 915         if (prefix)
 916                 fprintf(output, "%s", prefix);
 917
 918         if (scaled == -1) {
 919                 fprintf(output, "%*s%s%*s",
 920                         csv_output ? 0 : 18,
 921                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
 922                         csv_sep,
 923                         csv_output ? 0 : -24,
 924                         perf_evsel__name(counter));
 925
 926                 if (counter->cgrp)
 927                         fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
 928
 929                 fputc('\n', output);
 930                 return;
 931         }
 932
 933         if (nsec_counter(counter))
 934                 nsec_printout(-1, 0, counter, avg);
 935         else
 936                 abs_printout(-1, 0, counter, avg);
 937
 938         print_noise(counter, avg);
 939
 940         if (csv_output) {
 941                 fputc('\n', output);
 942                 return;
 943         }
 944
 945         if (scaled) {
 946                 double avg_enabled, avg_running;
 947
 948                 avg_enabled = avg_stats(&ps->res_stats[1]);
 949                 avg_running = avg_stats(&ps->res_stats[2]);
 950
 951                 fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
 952         }
 953         fprintf(output, "\n");
 954 }
 955
 956 /*
 957  * Print out the results of a single counter:
 958  * does not use aggregated count in system-wide
 959  */
 960 static void print_counter(struct perf_evsel *counter, char *prefix)
 961 {
 962         u64 ena, run, val;
 963         int cpu;
 964
 965         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
 966                 val = counter->counts->cpu[cpu].val;
 967                 ena = counter->counts->cpu[cpu].ena;
 968                 run = counter->counts->cpu[cpu].run;
 969
 970                 if (prefix)
 971                         fprintf(output, "%s", prefix);
 972
 973                 if (run == 0 || ena == 0) {
 974                         fprintf(output, "CPU%*d%s%*s%s%*s",
 975                                 csv_output ? 0 : -4,
 976                                 perf_evsel__cpus(counter)->map[cpu], csv_sep,
 977                                 csv_output ? 0 : 18,
 978                                 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
 979                                 csv_sep,
 980                                 csv_output ? 0 : -24,
 981                                 perf_evsel__name(counter));
 982
 983                         if (counter->cgrp)
 984                                 fprintf(output, "%s%s",
 985                                         csv_sep, counter->cgrp->name);
 986
 987                         fputc('\n', output);
 988                         continue;
 989                 }
 990
 991                 if (nsec_counter(counter))
 992                         nsec_printout(cpu, 0, counter, val);
 993                 else
 994                         abs_printout(cpu, 0, counter, val);
 995
 996                 if (!csv_output) {
 997                         print_noise(counter, 1.0);
 998
 999                         if (run != ena)
1000                                 fprintf(output, "  (%.2f%%)",
1001                                         100.0 * run / ena);
1002                 }
1003                 fputc('\n', output);
1004         }
1005 }
1006
1007 static void print_stat(int argc, const char **argv)
1008 {
1009         struct perf_evsel *counter;
1010         int i;
1011
1012         fflush(stdout);
1013
1014         if (!csv_output) {
1015                 fprintf(output, "\n");
1016                 fprintf(output, " Performance counter stats for ");
1017                 if (!perf_target__has_task(&target)) {
1018                         fprintf(output, "\'%s", argv[0]);
1019                         for (i = 1; i < argc; i++)
1020                                 fprintf(output, " %s", argv[i]);
1021                 } else if (target.pid)
1022                         fprintf(output, "process id \'%s", target.pid);
1023                 else
1024                         fprintf(output, "thread id \'%s", target.tid);
1025
1026                 fprintf(output, "\'");
1027                 if (run_count > 1)
1028                         fprintf(output, " (%d runs)", run_count);
1029                 fprintf(output, ":\n\n");
1030         }
1031
1032         if (aggr_socket)
1033                 print_aggr_socket(NULL);
1034         else if (no_aggr) {
1035                 list_for_each_entry(counter, &evsel_list->entries, node)
1036                         print_counter(counter, NULL);
1037         } else {
1038                 list_for_each_entry(counter, &evsel_list->entries, node)
1039                         print_counter_aggr(counter, NULL);
1040         }
1041
1042         if (!csv_output) {
1043                 if (!null_run)
1044                         fprintf(output, "\n");
1045                 fprintf(output, " %17.9f seconds time elapsed",
1046                                 avg_stats(&walltime_nsecs_stats)/1e9);
1047                 if (run_count > 1) {
1048                         fprintf(output, "                                        ");
1049                         print_noise_pct(stddev_stats(&walltime_nsecs_stats),
1050                                         avg_stats(&walltime_nsecs_stats));
1051                 }
1052                 fprintf(output, "\n\n");
1053         }
1054 }
1055
1056 static volatile int signr = -1;
1057
1058 static void skip_signal(int signo)
1059 {
1060         if ((child_pid == -1) || interval)
1061                 done = 1;
1062
1063         signr = signo;
1064 }
1065
1066 static void sig_atexit(void)
1067 {
1068         if (child_pid != -1)
1069                 kill(child_pid, SIGTERM);
1070
1071         if (signr == -1)
1072                 return;
1073
1074         signal(signr, SIG_DFL);
1075         kill(getpid(), signr);
1076 }
1077
1078 static int stat__set_big_num(const struct option *opt __maybe_unused,
1079                              const char *s __maybe_unused, int unset)
1080 {
1081         big_num_opt = unset ? 0 : 1;
1082         return 0;
1083 }
1084
1085 /*
1086  * Add default attributes, if there were no attributes specified or
1087  * if -d/--detailed, -d -d or -d -d -d is used:
1088  */
1089 static int add_default_attributes(void)
1090 {
1091         struct perf_event_attr default_attrs[] = {
1092
1093   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
1094   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
1095   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
1096   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
1097
1098   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
1099   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
1100   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND  },
1101   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
1102   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
1103   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
1104
1105 };
1106
1107 /*
1108  * Detailed stats (-d), covering the L1 and last level data caches:
1109  */
1110         struct perf_event_attr detailed_attrs[] = {
1111
1112   { .type = PERF_TYPE_HW_CACHE,
1113     .config =
1114          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1115         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1116         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1117
1118   { .type = PERF_TYPE_HW_CACHE,
1119     .config =
1120          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1121         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1122         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1123
1124   { .type = PERF_TYPE_HW_CACHE,
1125     .config =
1126          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1127         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1128         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1129
1130   { .type = PERF_TYPE_HW_CACHE,
1131     .config =
1132          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1133         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1134         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1135 };
1136
1137 /*
1138  * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1139  */
1140         struct perf_event_attr very_detailed_attrs[] = {
1141
1142   { .type = PERF_TYPE_HW_CACHE,
1143     .config =
1144          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1145         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1146         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1147
1148   { .type = PERF_TYPE_HW_CACHE,
1149     .config =
1150          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1151         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1152         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1153
1154   { .type = PERF_TYPE_HW_CACHE,
1155     .config =
1156          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1157         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1158         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1159
1160   { .type = PERF_TYPE_HW_CACHE,
1161     .config =
1162          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1163         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1164         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1165
1166   { .type = PERF_TYPE_HW_CACHE,
1167     .config =
1168          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1169         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1170         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1171
1172   { .type = PERF_TYPE_HW_CACHE,
1173     .config =
1174          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1175         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1176         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1177
1178 };
1179
1180 /*
1181  * Very, very detailed stats (-d -d -d), adding prefetch events:
1182  */
1183         struct perf_event_attr very_very_detailed_attrs[] = {
1184
1185   { .type = PERF_TYPE_HW_CACHE,
1186     .config =
1187          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1188         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1189         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1190
1191   { .type = PERF_TYPE_HW_CACHE,
1192     .config =
1193          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1194         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1195         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1196 };
1197
1198         /* Set attrs if no event is selected and !null_run: */
1199         if (null_run)
1200                 return 0;
1201
1202         if (!evsel_list->nr_entries) {
1203                 if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0)
1204                         return -1;
1205         }
1206
1207         /* Detailed events get appended to the event list: */
1208
1209         if (detailed_run <  1)
1210                 return 0;
1211
1212         /* Append detailed run extra attributes: */
1213         if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
1214                 return -1;
1215
1216         if (detailed_run < 2)
1217                 return 0;
1218
1219         /* Append very detailed run extra attributes: */
1220         if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
1221                 return -1;
1222
1223         if (detailed_run < 3)
1224                 return 0;
1225
1226         /* Append very, very detailed run extra attributes: */
1227         return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
1228 }
1229
1230 int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
1231 {
1232         bool append_file = false;
1233         int output_fd = 0;
1234         const char *output_name = NULL;
1235         const struct option options[] = {
1236         OPT_CALLBACK('e', "event", &evsel_list, "event",
1237                      "event selector. use 'perf list' to list available events",
1238                      parse_events_option),
1239         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
1240                      "event filter", parse_filter),
1241         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
1242                     "child tasks do not inherit counters"),
1243         OPT_STRING('p', "pid", &target.pid, "pid",
1244                    "stat events on existing process id"),
1245         OPT_STRING('t', "tid", &target.tid, "tid",
1246                    "stat events on existing thread id"),
1247         OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
1248                     "system-wide collection from all CPUs"),
1249         OPT_BOOLEAN('g', "group", &group,
1250                     "put the counters into a counter group"),
1251         OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"),
1252         OPT_INCR('v', "verbose", &verbose,
1253                     "be more verbose (show counter open errors, etc)"),
1254         OPT_INTEGER('r', "repeat", &run_count,
1255                     "repeat command and print average + stddev (max: 100)"),
1256         OPT_BOOLEAN('n', "null", &null_run,
1257                     "null run - dont start any counters"),
1258         OPT_INCR('d', "detailed", &detailed_run,
1259                     "detailed run - start a lot of events"),
1260         OPT_BOOLEAN('S', "sync", &sync_run,
1261                     "call sync() before starting a run"),
1262         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
1263                            "print large numbers with thousands\' separators",
1264                            stat__set_big_num),
1265         OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
1266                     "list of cpus to monitor in system-wide"),
1267         OPT_BOOLEAN('A', "no-aggr", &no_aggr, "disable CPU count aggregation"),
1268         OPT_STRING('x', "field-separator", &csv_sep, "separator",
1269                    "print counts with custom separator"),
1270         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1271                      "monitor event in cgroup name only", parse_cgroups),
1272         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1273         OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
1274         OPT_INTEGER(0, "log-fd", &output_fd,
1275                     "log output to fd, instead of stderr"),
1276         OPT_STRING(0, "pre", &pre_cmd, "command",
1277                         "command to run prior to the measured command"),
1278         OPT_STRING(0, "post", &post_cmd, "command",
1279                         "command to run after to the measured command"),
1280         OPT_UINTEGER('I', "interval-print", &interval,
1281                     "print counts at regular interval in ms (>= 100)"),
1282         OPT_BOOLEAN(0, "aggr-socket", &aggr_socket, "aggregate counts per processor socket"),
1283         OPT_END()
1284         };
1285         const char * const stat_usage[] = {
1286                 "perf stat [<options>] [<command>]",
1287                 NULL
1288         };
1289         struct perf_evsel *pos;
1290         int status = -ENOMEM, run_idx;
1291         const char *mode;
1292
1293         setlocale(LC_ALL, "");
1294
1295         evsel_list = perf_evlist__new();
1296         if (evsel_list == NULL)
1297                 return -ENOMEM;
1298
1299         argc = parse_options(argc, argv, options, stat_usage,
1300                 PARSE_OPT_STOP_AT_NON_OPTION);
1301
1302         output = stderr;
1303         if (output_name && strcmp(output_name, "-"))
1304                 output = NULL;
1305
1306         if (output_name && output_fd) {
1307                 fprintf(stderr, "cannot use both --output and --log-fd\n");
1308                 usage_with_options(stat_usage, options);
1309         }
1310
1311         if (output_fd < 0) {
1312                 fprintf(stderr, "argument to --log-fd must be a > 0\n");
1313                 usage_with_options(stat_usage, options);
1314         }
1315
1316         if (!output) {
1317                 struct timespec tm;
1318                 mode = append_file ? "a" : "w";
1319
1320                 output = fopen(output_name, mode);
1321                 if (!output) {
1322                         perror("failed to create output file");
1323                         return -1;
1324                 }
1325                 clock_gettime(CLOCK_REALTIME, &tm);
1326                 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
1327         } else if (output_fd > 0) {
1328                 mode = append_file ? "a" : "w";
1329                 output = fdopen(output_fd, mode);
1330                 if (!output) {
1331                         perror("Failed opening logfd");
1332                         return -errno;
1333                 }
1334         }
1335
1336         if (csv_sep) {
1337                 csv_output = true;
1338                 if (!strcmp(csv_sep, "\\t"))
1339                         csv_sep = "\t";
1340         } else
1341                 csv_sep = DEFAULT_SEPARATOR;
1342
1343         /*
1344          * let the spreadsheet do the pretty-printing
1345          */
1346         if (csv_output) {
1347                 /* User explicitly passed -B? */
1348                 if (big_num_opt == 1) {
1349                         fprintf(stderr, "-B option not supported with -x\n");
1350                         usage_with_options(stat_usage, options);
1351                 } else /* Nope, so disable big number formatting */
1352                         big_num = false;
1353         } else if (big_num_opt == 0) /* User passed --no-big-num */
1354                 big_num = false;
1355
1356         if (!argc && !perf_target__has_task(&target))
1357                 usage_with_options(stat_usage, options);
1358         if (run_count <= 0)
1359                 usage_with_options(stat_usage, options);
1360
1361         /* no_aggr, cgroup are for system-wide only */
1362         if ((no_aggr || nr_cgroups) && !perf_target__has_cpu(&target)) {
1363                 fprintf(stderr, "both cgroup and no-aggregation "
1364                         "modes only available in system-wide mode\n");
1365
1366                 usage_with_options(stat_usage, options);
1367         }
1368
1369         if (aggr_socket) {
1370                 if (!perf_target__has_cpu(&target)) {
1371                         fprintf(stderr, "--aggr-socket only available in system-wide mode (-a)\n");
1372                         usage_with_options(stat_usage, options);
1373                 }
1374                 no_aggr = true;
1375         }
1376
1377         if (add_default_attributes())
1378                 goto out;
1379
1380         perf_target__validate(&target);
1381
1382         if (perf_evlist__create_maps(evsel_list, &target) < 0) {
1383                 if (perf_target__has_task(&target))
1384                         pr_err("Problems finding threads of monitor\n");
1385                 if (perf_target__has_cpu(&target))
1386                         perror("failed to parse CPUs map");
1387
1388                 usage_with_options(stat_usage, options);
1389                 return -1;
1390         }
1391         if (interval && interval < 100) {
1392                 pr_err("print interval must be >= 100ms\n");
1393                 usage_with_options(stat_usage, options);
1394                 return -1;
1395         }
1396
1397         list_for_each_entry(pos, &evsel_list->entries, node) {
1398                 if (perf_evsel__alloc_stat_priv(pos) < 0 ||
1399                     perf_evsel__alloc_counts(pos, perf_evsel__nr_cpus(pos)) < 0)
1400                         goto out_free_fd;
1401         }
1402         if (interval) {
1403                 list_for_each_entry(pos, &evsel_list->entries, node) {
1404                         if (perf_evsel__alloc_prev_raw_counts(pos) < 0)
1405                                 goto out_free_fd;
1406                 }
1407         }
1408
1409         /*
1410          * We dont want to block the signals - that would cause
1411          * child tasks to inherit that and Ctrl-C would not work.
1412          * What we want is for Ctrl-C to work in the exec()-ed
1413          * task, but being ignored by perf stat itself:
1414          */
1415         atexit(sig_atexit);
1416         signal(SIGINT,  skip_signal);
1417         signal(SIGCHLD, skip_signal);
1418         signal(SIGALRM, skip_signal);
1419         signal(SIGABRT, skip_signal);
1420
1421         status = 0;
1422         for (run_idx = 0; run_idx < run_count; run_idx++) {
1423                 if (run_count != 1 && verbose)
1424                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1425                                 run_idx + 1);
1426
1427                 status = run_perf_stat(argc, argv);
1428         }
1429
1430         if (status != -1 && !interval)
1431                 print_stat(argc, argv);
1432 out_free_fd:
1433         list_for_each_entry(pos, &evsel_list->entries, node) {
1434                 perf_evsel__free_stat_priv(pos);
1435                 perf_evsel__free_counts(pos);
1436                 perf_evsel__free_prev_raw_counts(pos);
1437         }
1438         perf_evlist__delete_maps(evsel_list);
1439 out:
1440         perf_evlist__delete(evsel_list);
1441         return status;
1442 }