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    Time: 0.104
  11
  12     Performance counter stats for '/home/mingo/hackbench':
  13
  14        1255.538611  task clock ticks     #      10.143 CPU utilization factor
  15              54011  context switches     #       0.043 M/sec
  16                385  CPU migrations       #       0.000 M/sec
  17              17755  pagefaults           #       0.014 M/sec
  18         3808323185  CPU cycles           #    3033.219 M/sec
  19         1575111190  instructions         #    1254.530 M/sec
  20           17367895  cache references     #      13.833 M/sec
  21            7674421  cache misses         #       6.112 M/sec
  22
  23     Wall-clock time elapsed:   123.786620 msecs
  24
  25  *
  26  * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  27  *
  28  * Improvements and fixes by:
  29  *
  30  *   Arjan van de Ven <arjan@linux.intel.com>
  31  *   Yanmin Zhang <yanmin.zhang@intel.com>
  32  *   Wu Fengguang <fengguang.wu@intel.com>
  33  *   Mike Galbraith <efault@gmx.de>
  34  *   Paul Mackerras <paulus@samba.org>
  35  *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  36  *
  37  * Released under the GPL v2. (and only v2, not any later version)
  38  */
  39
  40 #include "perf.h"
  41 #include "builtin.h"
  42 #include "util/util.h"
  43 #include "util/parse-options.h"
  44 #include "util/parse-events.h"
  45 #include "util/event.h"
  46 #include "util/evsel.h"
  47 #include "util/debug.h"
  48 #include "util/header.h"
  49 #include "util/cpumap.h"
  50 #include "util/thread.h"
  51
  52 #include <sys/prctl.h>
  53 #include <math.h>
  54 #include <locale.h>
  55
  56 #define DEFAULT_SEPARATOR       " "
  57
  58 static struct perf_event_attr default_attrs[] = {
  59
  60   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
  61   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
  62   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
  63   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
  64
  65   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
  66   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
  67   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
  68   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
  69   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES        },
  70   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES            },
  71
  72 };
  73
  74 static bool                     system_wide                     =  false;
  75 static int                      nr_cpus                         =  0;
  76 static int                      run_idx                         =  0;
  77
  78 static int                      run_count                       =  1;
  79 static bool                     no_inherit                      = false;
  80 static bool                     scale                           =  true;
  81 static bool                     no_aggr                         = false;
  82 static pid_t                    target_pid                      = -1;
  83 static pid_t                    target_tid                      = -1;
  84 static pid_t                    *all_tids                       =  NULL;
  85 static int                      thread_num                      =  0;
  86 static pid_t                    child_pid                       = -1;
  87 static bool                     null_run                        =  false;
  88 static bool                     big_num                         =  true;
  89 static int                      big_num_opt                     =  -1;
  90 static const char               *cpu_list;
  91 static const char               *csv_sep                        = NULL;
  92 static bool                     csv_output                      = false;
  93
  94 static volatile int done = 0;
  95
  96 struct stats
  97 {
  98         double n, mean, M2;
  99 };
 100
 101 struct perf_stat {
 102         struct stats      res_stats[3];
 103 };
 104
 105 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 106 {
 107         evsel->priv = zalloc(sizeof(struct perf_stat));
 108         return evsel->priv == NULL ? -ENOMEM : 0;
 109 }
 110
 111 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
 112 {
 113         free(evsel->priv);
 114         evsel->priv = NULL;
 115 }
 116
 117 static void update_stats(struct stats *stats, u64 val)
 118 {
 119         double delta;
 120
 121         stats->n++;
 122         delta = val - stats->mean;
 123         stats->mean += delta / stats->n;
 124         stats->M2 += delta*(val - stats->mean);
 125 }
 126
 127 static double avg_stats(struct stats *stats)
 128 {
 129         return stats->mean;
 130 }
 131
 132 /*
 133  * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
 134  *
 135  *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
 136  * s^2 = -------------------------------
 137  *                  n - 1
 138  *
 139  * http://en.wikipedia.org/wiki/Stddev
 140  *
 141  * The std dev of the mean is related to the std dev by:
 142  *
 143  *             s
 144  * s_mean = -------
 145  *          sqrt(n)
 146  *
 147  */
 148 static double stddev_stats(struct stats *stats)
 149 {
 150         double variance = stats->M2 / (stats->n - 1);
 151         double variance_mean = variance / stats->n;
 152
 153         return sqrt(variance_mean);
 154 }
 155
 156 struct stats                    runtime_nsecs_stats[MAX_NR_CPUS];
 157 struct stats                    runtime_cycles_stats[MAX_NR_CPUS];
 158 struct stats                    runtime_branches_stats[MAX_NR_CPUS];
 159 struct stats                    walltime_nsecs_stats;
 160
 161 static int create_perf_stat_counter(struct perf_evsel *evsel)
 162 {
 163         struct perf_event_attr *attr = &evsel->attr;
 164
 165         if (scale)
 166                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 167                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 168
 169         if (system_wide)
 170                 return perf_evsel__open_per_cpu(evsel, nr_cpus, cpumap);
 171
 172         attr->inherit = !no_inherit;
 173         if (target_pid == -1 && target_tid == -1) {
 174                 attr->disabled = 1;
 175                 attr->enable_on_exec = 1;
 176         }
 177
 178         return perf_evsel__open_per_thread(evsel, thread_num, all_tids);
 179 }
 180
 181 /*
 182  * Does the counter have nsecs as a unit?
 183  */
 184 static inline int nsec_counter(struct perf_evsel *evsel)
 185 {
 186         if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
 187             perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 188                 return 1;
 189
 190         return 0;
 191 }
 192
 193 /*
 194  * Read out the results of a single counter:
 195  * aggregate counts across CPUs in system-wide mode
 196  */
 197 static int read_counter_aggr(struct perf_evsel *counter)
 198 {
 199         struct perf_stat *ps = counter->priv;
 200         u64 *count = counter->counts->aggr.values;
 201         int i;
 202
 203         if (__perf_evsel__read(counter, nr_cpus, thread_num, scale) < 0)
 204                 return -1;
 205
 206         for (i = 0; i < 3; i++)
 207                 update_stats(&ps->res_stats[i], count[i]);
 208
 209         if (verbose) {
 210                 fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
 211                                 count[0], count[1], count[2]);
 212         }
 213
 214         /*
 215          * Save the full runtime - to allow normalization during printout:
 216          */
 217         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
 218                 update_stats(&runtime_nsecs_stats[0], count[0]);
 219         if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
 220                 update_stats(&runtime_cycles_stats[0], count[0]);
 221         if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
 222                 update_stats(&runtime_branches_stats[0], count[0]);
 223
 224         return 0;
 225 }
 226
 227 /*
 228  * Read out the results of a single counter:
 229  * do not aggregate counts across CPUs in system-wide mode
 230  */
 231 static int read_counter(struct perf_evsel *counter)
 232 {
 233         u64 *count;
 234         int cpu;
 235
 236         for (cpu = 0; cpu < nr_cpus; cpu++) {
 237                 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
 238                         return -1;
 239
 240                 count = counter->counts->cpu[cpu].values;
 241
 242                 if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
 243                         update_stats(&runtime_nsecs_stats[cpu], count[0]);
 244                 if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
 245                         update_stats(&runtime_cycles_stats[cpu], count[0]);
 246                 if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
 247                         update_stats(&runtime_branches_stats[cpu], count[0]);
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int run_perf_stat(int argc __used, const char **argv)
 254 {
 255         unsigned long long t0, t1;
 256         struct perf_evsel *counter;
 257         int status = 0;
 258         int child_ready_pipe[2], go_pipe[2];
 259         const bool forks = (argc > 0);
 260         char buf;
 261
 262         if (!system_wide)
 263                 nr_cpus = 1;
 264
 265         if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 266                 perror("failed to create pipes");
 267                 exit(1);
 268         }
 269
 270         if (forks) {
 271                 if ((child_pid = fork()) < 0)
 272                         perror("failed to fork");
 273
 274                 if (!child_pid) {
 275                         close(child_ready_pipe[0]);
 276                         close(go_pipe[1]);
 277                         fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 278
 279                         /*
 280                          * Do a dummy execvp to get the PLT entry resolved,
 281                          * so we avoid the resolver overhead on the real
 282                          * execvp call.
 283                          */
 284                         execvp("", (char **)argv);
 285
 286                         /*
 287                          * Tell the parent we're ready to go
 288                          */
 289                         close(child_ready_pipe[1]);
 290
 291                         /*
 292                          * Wait until the parent tells us to go.
 293                          */
 294                         if (read(go_pipe[0], &buf, 1) == -1)
 295                                 perror("unable to read pipe");
 296
 297                         execvp(argv[0], (char **)argv);
 298
 299                         perror(argv[0]);
 300                         exit(-1);
 301                 }
 302
 303                 if (target_tid == -1 && target_pid == -1 && !system_wide)
 304                         all_tids[0] = child_pid;
 305
 306                 /*
 307                  * Wait for the child to be ready to exec.
 308                  */
 309                 close(child_ready_pipe[1]);
 310                 close(go_pipe[0]);
 311                 if (read(child_ready_pipe[0], &buf, 1) == -1)
 312                         perror("unable to read pipe");
 313                 close(child_ready_pipe[0]);
 314         }
 315
 316         list_for_each_entry(counter, &evsel_list, node) {
 317                 if (create_perf_stat_counter(counter) < 0) {
 318                         if (errno == -EPERM || errno == -EACCES) {
 319                                 error("You may not have permission to collect %sstats.\n"
 320                                       "\t Consider tweaking"
 321                                       " /proc/sys/kernel/perf_event_paranoid or running as root.",
 322                                       system_wide ? "system-wide " : "");
 323                         } else {
 324                                 error("open_counter returned with %d (%s). "
 325                                       "/bin/dmesg may provide additional information.\n",
 326                                        errno, strerror(errno));
 327                         }
 328                         if (child_pid != -1)
 329                                 kill(child_pid, SIGTERM);
 330                         die("Not all events could be opened.\n");
 331                         return -1;
 332                 }
 333         }
 334
 335         /*
 336          * Enable counters and exec the command:
 337          */
 338         t0 = rdclock();
 339
 340         if (forks) {
 341                 close(go_pipe[1]);
 342                 wait(&status);
 343         } else {
 344                 while(!done) sleep(1);
 345         }
 346
 347         t1 = rdclock();
 348
 349         update_stats(&walltime_nsecs_stats, t1 - t0);
 350
 351         if (no_aggr) {
 352                 list_for_each_entry(counter, &evsel_list, node) {
 353                         read_counter(counter);
 354                         perf_evsel__close_fd(counter, nr_cpus, 1);
 355                 }
 356         } else {
 357                 list_for_each_entry(counter, &evsel_list, node) {
 358                         read_counter_aggr(counter);
 359                         perf_evsel__close_fd(counter, nr_cpus, thread_num);
 360                 }
 361         }
 362
 363         return WEXITSTATUS(status);
 364 }
 365
 366 static void print_noise(struct perf_evsel *evsel, double avg)
 367 {
 368         struct perf_stat *ps;
 369
 370         if (run_count == 1)
 371                 return;
 372
 373         ps = evsel->priv;
 374         fprintf(stderr, "   ( +- %7.3f%% )",
 375                         100 * stddev_stats(&ps->res_stats[0]) / avg);
 376 }
 377
 378 static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
 379 {
 380         double msecs = avg / 1e6;
 381         char cpustr[16] = { '\0', };
 382         const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-24s";
 383
 384         if (no_aggr)
 385                 sprintf(cpustr, "CPU%*d%s",
 386                         csv_output ? 0 : -4,
 387                         cpumap[cpu], csv_sep);
 388
 389         fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel));
 390
 391         if (csv_output)
 392                 return;
 393
 394         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 395                 fprintf(stderr, " # %10.3f CPUs ",
 396                                 avg / avg_stats(&walltime_nsecs_stats));
 397 }
 398
 399 static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
 400 {
 401         double total, ratio = 0.0;
 402         char cpustr[16] = { '\0', };
 403         const char *fmt;
 404
 405         if (csv_output)
 406                 fmt = "%s%.0f%s%s";
 407         else if (big_num)
 408                 fmt = "%s%'18.0f%s%-24s";
 409         else
 410                 fmt = "%s%18.0f%s%-24s";
 411
 412         if (no_aggr)
 413                 sprintf(cpustr, "CPU%*d%s",
 414                         csv_output ? 0 : -4,
 415                         cpumap[cpu], csv_sep);
 416         else
 417                 cpu = 0;
 418
 419         fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel));
 420
 421         if (csv_output)
 422                 return;
 423
 424         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
 425                 total = avg_stats(&runtime_cycles_stats[cpu]);
 426
 427                 if (total)
 428                         ratio = avg / total;
 429
 430                 fprintf(stderr, " # %10.3f IPC  ", ratio);
 431         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
 432                         runtime_branches_stats[cpu].n != 0) {
 433                 total = avg_stats(&runtime_branches_stats[cpu]);
 434
 435                 if (total)
 436                         ratio = avg * 100 / total;
 437
 438                 fprintf(stderr, " # %10.3f %%    ", ratio);
 439
 440         } else if (runtime_nsecs_stats[cpu].n != 0) {
 441                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 442
 443                 if (total)
 444                         ratio = 1000.0 * avg / total;
 445
 446                 fprintf(stderr, " # %10.3f M/sec", ratio);
 447         }
 448 }
 449
 450 /*
 451  * Print out the results of a single counter:
 452  * aggregated counts in system-wide mode
 453  */
 454 static void print_counter_aggr(struct perf_evsel *counter)
 455 {
 456         struct perf_stat *ps = counter->priv;
 457         double avg = avg_stats(&ps->res_stats[0]);
 458         int scaled = counter->counts->scaled;
 459
 460         if (scaled == -1) {
 461                 fprintf(stderr, "%*s%s%-24s\n",
 462                         csv_output ? 0 : 18,
 463                         "<not counted>", csv_sep, event_name(counter));
 464                 return;
 465         }
 466
 467         if (nsec_counter(counter))
 468                 nsec_printout(-1, counter, avg);
 469         else
 470                 abs_printout(-1, counter, avg);
 471
 472         if (csv_output) {
 473                 fputc('\n', stderr);
 474                 return;
 475         }
 476
 477         print_noise(counter, avg);
 478
 479         if (scaled) {
 480                 double avg_enabled, avg_running;
 481
 482                 avg_enabled = avg_stats(&ps->res_stats[1]);
 483                 avg_running = avg_stats(&ps->res_stats[2]);
 484
 485                 fprintf(stderr, "  (scaled from %.2f%%)",
 486                                 100 * avg_running / avg_enabled);
 487         }
 488
 489         fprintf(stderr, "\n");
 490 }
 491
 492 /*
 493  * Print out the results of a single counter:
 494  * does not use aggregated count in system-wide
 495  */
 496 static void print_counter(struct perf_evsel *counter)
 497 {
 498         u64 ena, run, val;
 499         int cpu;
 500
 501         for (cpu = 0; cpu < nr_cpus; cpu++) {
 502                 val = counter->counts->cpu[cpu].val;
 503                 ena = counter->counts->cpu[cpu].ena;
 504                 run = counter->counts->cpu[cpu].run;
 505                 if (run == 0 || ena == 0) {
 506                         fprintf(stderr, "CPU%*d%s%*s%s%-24s",
 507                                 csv_output ? 0 : -4,
 508                                 cpumap[cpu], csv_sep,
 509                                 csv_output ? 0 : 18,
 510                                 "<not counted>", csv_sep,
 511                                 event_name(counter));
 512
 513                         fprintf(stderr, "\n");
 514                         continue;
 515                 }
 516
 517                 if (nsec_counter(counter))
 518                         nsec_printout(cpu, counter, val);
 519                 else
 520                         abs_printout(cpu, counter, val);
 521
 522                 if (!csv_output) {
 523                         print_noise(counter, 1.0);
 524
 525                         if (run != ena) {
 526                                 fprintf(stderr, "  (scaled from %.2f%%)",
 527                                         100.0 * run / ena);
 528                         }
 529                 }
 530                 fprintf(stderr, "\n");
 531         }
 532 }
 533
 534 static void print_stat(int argc, const char **argv)
 535 {
 536         struct perf_evsel *counter;
 537         int i;
 538
 539         fflush(stdout);
 540
 541         if (!csv_output) {
 542                 fprintf(stderr, "\n");
 543                 fprintf(stderr, " Performance counter stats for ");
 544                 if(target_pid == -1 && target_tid == -1) {
 545                         fprintf(stderr, "\'%s", argv[0]);
 546                         for (i = 1; i < argc; i++)
 547                                 fprintf(stderr, " %s", argv[i]);
 548                 } else if (target_pid != -1)
 549                         fprintf(stderr, "process id \'%d", target_pid);
 550                 else
 551                         fprintf(stderr, "thread id \'%d", target_tid);
 552
 553                 fprintf(stderr, "\'");
 554                 if (run_count > 1)
 555                         fprintf(stderr, " (%d runs)", run_count);
 556                 fprintf(stderr, ":\n\n");
 557         }
 558
 559         if (no_aggr) {
 560                 list_for_each_entry(counter, &evsel_list, node)
 561                         print_counter(counter);
 562         } else {
 563                 list_for_each_entry(counter, &evsel_list, node)
 564                         print_counter_aggr(counter);
 565         }
 566
 567         if (!csv_output) {
 568                 fprintf(stderr, "\n");
 569                 fprintf(stderr, " %18.9f  seconds time elapsed",
 570                                 avg_stats(&walltime_nsecs_stats)/1e9);
 571                 if (run_count > 1) {
 572                         fprintf(stderr, "   ( +- %7.3f%% )",
 573                                 100*stddev_stats(&walltime_nsecs_stats) /
 574                                 avg_stats(&walltime_nsecs_stats));
 575                 }
 576                 fprintf(stderr, "\n\n");
 577         }
 578 }
 579
 580 static volatile int signr = -1;
 581
 582 static void skip_signal(int signo)
 583 {
 584         if(child_pid == -1)
 585                 done = 1;
 586
 587         signr = signo;
 588 }
 589
 590 static void sig_atexit(void)
 591 {
 592         if (child_pid != -1)
 593                 kill(child_pid, SIGTERM);
 594
 595         if (signr == -1)
 596                 return;
 597
 598         signal(signr, SIG_DFL);
 599         kill(getpid(), signr);
 600 }
 601
 602 static const char * const stat_usage[] = {
 603         "perf stat [<options>] [<command>]",
 604         NULL
 605 };
 606
 607 static int stat__set_big_num(const struct option *opt __used,
 608                              const char *s __used, int unset)
 609 {
 610         big_num_opt = unset ? 0 : 1;
 611         return 0;
 612 }
 613
 614 static const struct option options[] = {
 615         OPT_CALLBACK('e', "event", NULL, "event",
 616                      "event selector. use 'perf list' to list available events",
 617                      parse_events),
 618         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 619                     "child tasks do not inherit counters"),
 620         OPT_INTEGER('p', "pid", &target_pid,
 621                     "stat events on existing process id"),
 622         OPT_INTEGER('t', "tid", &target_tid,
 623                     "stat events on existing thread id"),
 624         OPT_BOOLEAN('a', "all-cpus", &system_wide,
 625                     "system-wide collection from all CPUs"),
 626         OPT_BOOLEAN('c', "scale", &scale,
 627                     "scale/normalize counters"),
 628         OPT_INCR('v', "verbose", &verbose,
 629                     "be more verbose (show counter open errors, etc)"),
 630         OPT_INTEGER('r', "repeat", &run_count,
 631                     "repeat command and print average + stddev (max: 100)"),
 632         OPT_BOOLEAN('n', "null", &null_run,
 633                     "null run - dont start any counters"),
 634         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
 635                            "print large numbers with thousands\' separators",
 636                            stat__set_big_num),
 637         OPT_STRING('C', "cpu", &cpu_list, "cpu",
 638                     "list of cpus to monitor in system-wide"),
 639         OPT_BOOLEAN('A', "no-aggr", &no_aggr,
 640                     "disable CPU count aggregation"),
 641         OPT_STRING('x', "field-separator", &csv_sep, "separator",
 642                    "print counts with custom separator"),
 643         OPT_END()
 644 };
 645
 646 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 647 {
 648         struct perf_evsel *pos;
 649         int status = -ENOMEM;
 650
 651         setlocale(LC_ALL, "");
 652
 653         argc = parse_options(argc, argv, options, stat_usage,
 654                 PARSE_OPT_STOP_AT_NON_OPTION);
 655
 656         if (csv_sep)
 657                 csv_output = true;
 658         else
 659                 csv_sep = DEFAULT_SEPARATOR;
 660
 661         /*
 662          * let the spreadsheet do the pretty-printing
 663          */
 664         if (csv_output) {
 665                 /* User explicitely passed -B? */
 666                 if (big_num_opt == 1) {
 667                         fprintf(stderr, "-B option not supported with -x\n");
 668                         usage_with_options(stat_usage, options);
 669                 } else /* Nope, so disable big number formatting */
 670                         big_num = false;
 671         } else if (big_num_opt == 0) /* User passed --no-big-num */
 672                 big_num = false;
 673
 674         if (!argc && target_pid == -1 && target_tid == -1)
 675                 usage_with_options(stat_usage, options);
 676         if (run_count <= 0)
 677                 usage_with_options(stat_usage, options);
 678
 679         /* no_aggr is for system-wide only */
 680         if (no_aggr && !system_wide)
 681                 usage_with_options(stat_usage, options);
 682
 683         /* Set attrs and nr_counters if no event is selected and !null_run */
 684         if (!null_run && !nr_counters) {
 685                 size_t c;
 686
 687                 nr_counters = ARRAY_SIZE(default_attrs);
 688
 689                 for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
 690                         pos = perf_evsel__new(default_attrs[c].type,
 691                                               default_attrs[c].config,
 692                                               nr_counters);
 693                         if (pos == NULL)
 694                                 goto out;
 695                         list_add(&pos->node, &evsel_list);
 696                 }
 697         }
 698
 699         if (system_wide)
 700                 nr_cpus = read_cpu_map(cpu_list);
 701         else
 702                 nr_cpus = 1;
 703
 704         if (nr_cpus < 1)
 705                 usage_with_options(stat_usage, options);
 706
 707         if (target_pid != -1) {
 708                 target_tid = target_pid;
 709                 thread_num = find_all_tid(target_pid, &all_tids);
 710                 if (thread_num <= 0) {
 711                         fprintf(stderr, "Can't find all threads of pid %d\n",
 712                                         target_pid);
 713                         usage_with_options(stat_usage, options);
 714                 }
 715         } else {
 716                 all_tids=malloc(sizeof(pid_t));
 717                 if (!all_tids)
 718                         return -ENOMEM;
 719
 720                 all_tids[0] = target_tid;
 721                 thread_num = 1;
 722         }
 723
 724         list_for_each_entry(pos, &evsel_list, node) {
 725                 if (perf_evsel__alloc_stat_priv(pos) < 0 ||
 726                     perf_evsel__alloc_counts(pos, nr_cpus) < 0 ||
 727                     perf_evsel__alloc_fd(pos, nr_cpus, thread_num) < 0)
 728                         goto out_free_fd;
 729         }
 730
 731         /*
 732          * We dont want to block the signals - that would cause
 733          * child tasks to inherit that and Ctrl-C would not work.
 734          * What we want is for Ctrl-C to work in the exec()-ed
 735          * task, but being ignored by perf stat itself:
 736          */
 737         atexit(sig_atexit);
 738         signal(SIGINT,  skip_signal);
 739         signal(SIGALRM, skip_signal);
 740         signal(SIGABRT, skip_signal);
 741
 742         status = 0;
 743         for (run_idx = 0; run_idx < run_count; run_idx++) {
 744                 if (run_count != 1 && verbose)
 745                         fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
 746                 status = run_perf_stat(argc, argv);
 747         }
 748
 749         if (status != -1)
 750                 print_stat(argc, argv);
 751 out_free_fd:
 752         list_for_each_entry(pos, &evsel_list, node)
 753                 perf_evsel__free_stat_priv(pos);
 754 out:
 755         return status;
 756 }