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