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