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 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, cpus->nr, cpus->map);
 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, cpus->nr, 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 < cpus->nr; 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 (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 263                 perror("failed to create pipes");
 264                 exit(1);
 265         }
 266
 267         if (forks) {
 268                 if ((child_pid = fork()) < 0)
 269                         perror("failed to fork");
 270
 271                 if (!child_pid) {
 272                         close(child_ready_pipe[0]);
 273                         close(go_pipe[1]);
 274                         fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 275
 276                         /*
 277                          * Do a dummy execvp to get the PLT entry resolved,
 278                          * so we avoid the resolver overhead on the real
 279                          * execvp call.
 280                          */
 281                         execvp("", (char **)argv);
 282
 283                         /*
 284                          * Tell the parent we're ready to go
 285                          */
 286                         close(child_ready_pipe[1]);
 287
 288                         /*
 289                          * Wait until the parent tells us to go.
 290                          */
 291                         if (read(go_pipe[0], &buf, 1) == -1)
 292                                 perror("unable to read pipe");
 293
 294                         execvp(argv[0], (char **)argv);
 295
 296                         perror(argv[0]);
 297                         exit(-1);
 298                 }
 299
 300                 if (target_tid == -1 && target_pid == -1 && !system_wide)
 301                         all_tids[0] = child_pid;
 302
 303                 /*
 304                  * Wait for the child to be ready to exec.
 305                  */
 306                 close(child_ready_pipe[1]);
 307                 close(go_pipe[0]);
 308                 if (read(child_ready_pipe[0], &buf, 1) == -1)
 309                         perror("unable to read pipe");
 310                 close(child_ready_pipe[0]);
 311         }
 312
 313         list_for_each_entry(counter, &evsel_list, node) {
 314                 if (create_perf_stat_counter(counter) < 0) {
 315                         if (errno == -EPERM || errno == -EACCES) {
 316                                 error("You may not have permission to collect %sstats.\n"
 317                                       "\t Consider tweaking"
 318                                       " /proc/sys/kernel/perf_event_paranoid or running as root.",
 319                                       system_wide ? "system-wide " : "");
 320                         } else {
 321                                 error("open_counter returned with %d (%s). "
 322                                       "/bin/dmesg may provide additional information.\n",
 323                                        errno, strerror(errno));
 324                         }
 325                         if (child_pid != -1)
 326                                 kill(child_pid, SIGTERM);
 327                         die("Not all events could be opened.\n");
 328                         return -1;
 329                 }
 330         }
 331
 332         /*
 333          * Enable counters and exec the command:
 334          */
 335         t0 = rdclock();
 336
 337         if (forks) {
 338                 close(go_pipe[1]);
 339                 wait(&status);
 340         } else {
 341                 while(!done) sleep(1);
 342         }
 343
 344         t1 = rdclock();
 345
 346         update_stats(&walltime_nsecs_stats, t1 - t0);
 347
 348         if (no_aggr) {
 349                 list_for_each_entry(counter, &evsel_list, node) {
 350                         read_counter(counter);
 351                         perf_evsel__close_fd(counter, cpus->nr, 1);
 352                 }
 353         } else {
 354                 list_for_each_entry(counter, &evsel_list, node) {
 355                         read_counter_aggr(counter);
 356                         perf_evsel__close_fd(counter, cpus->nr, thread_num);
 357                 }
 358         }
 359
 360         return WEXITSTATUS(status);
 361 }
 362
 363 static void print_noise(struct perf_evsel *evsel, double avg)
 364 {
 365         struct perf_stat *ps;
 366
 367         if (run_count == 1)
 368                 return;
 369
 370         ps = evsel->priv;
 371         fprintf(stderr, "   ( +- %7.3f%% )",
 372                         100 * stddev_stats(&ps->res_stats[0]) / avg);
 373 }
 374
 375 static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
 376 {
 377         double msecs = avg / 1e6;
 378         char cpustr[16] = { '\0', };
 379         const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-24s";
 380
 381         if (no_aggr)
 382                 sprintf(cpustr, "CPU%*d%s",
 383                         csv_output ? 0 : -4,
 384                         cpus->map[cpu], csv_sep);
 385
 386         fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel));
 387
 388         if (csv_output)
 389                 return;
 390
 391         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 392                 fprintf(stderr, " # %10.3f CPUs ",
 393                                 avg / avg_stats(&walltime_nsecs_stats));
 394 }
 395
 396 static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
 397 {
 398         double total, ratio = 0.0;
 399         char cpustr[16] = { '\0', };
 400         const char *fmt;
 401
 402         if (csv_output)
 403                 fmt = "%s%.0f%s%s";
 404         else if (big_num)
 405                 fmt = "%s%'18.0f%s%-24s";
 406         else
 407                 fmt = "%s%18.0f%s%-24s";
 408
 409         if (no_aggr)
 410                 sprintf(cpustr, "CPU%*d%s",
 411                         csv_output ? 0 : -4,
 412                         cpus->map[cpu], csv_sep);
 413         else
 414                 cpu = 0;
 415
 416         fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel));
 417
 418         if (csv_output)
 419                 return;
 420
 421         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
 422                 total = avg_stats(&runtime_cycles_stats[cpu]);
 423
 424                 if (total)
 425                         ratio = avg / total;
 426
 427                 fprintf(stderr, " # %10.3f IPC  ", ratio);
 428         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
 429                         runtime_branches_stats[cpu].n != 0) {
 430                 total = avg_stats(&runtime_branches_stats[cpu]);
 431
 432                 if (total)
 433                         ratio = avg * 100 / total;
 434
 435                 fprintf(stderr, " # %10.3f %%    ", ratio);
 436
 437         } else if (runtime_nsecs_stats[cpu].n != 0) {
 438                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 439
 440                 if (total)
 441                         ratio = 1000.0 * avg / total;
 442
 443                 fprintf(stderr, " # %10.3f M/sec", ratio);
 444         }
 445 }
 446
 447 /*
 448  * Print out the results of a single counter:
 449  * aggregated counts in system-wide mode
 450  */
 451 static void print_counter_aggr(struct perf_evsel *counter)
 452 {
 453         struct perf_stat *ps = counter->priv;
 454         double avg = avg_stats(&ps->res_stats[0]);
 455         int scaled = counter->counts->scaled;
 456
 457         if (scaled == -1) {
 458                 fprintf(stderr, "%*s%s%-24s\n",
 459                         csv_output ? 0 : 18,
 460                         "<not counted>", csv_sep, event_name(counter));
 461                 return;
 462         }
 463
 464         if (nsec_counter(counter))
 465                 nsec_printout(-1, counter, avg);
 466         else
 467                 abs_printout(-1, counter, avg);
 468
 469         if (csv_output) {
 470                 fputc('\n', stderr);
 471                 return;
 472         }
 473
 474         print_noise(counter, avg);
 475
 476         if (scaled) {
 477                 double avg_enabled, avg_running;
 478
 479                 avg_enabled = avg_stats(&ps->res_stats[1]);
 480                 avg_running = avg_stats(&ps->res_stats[2]);
 481
 482                 fprintf(stderr, "  (scaled from %.2f%%)",
 483                                 100 * avg_running / avg_enabled);
 484         }
 485
 486         fprintf(stderr, "\n");
 487 }
 488
 489 /*
 490  * Print out the results of a single counter:
 491  * does not use aggregated count in system-wide
 492  */
 493 static void print_counter(struct perf_evsel *counter)
 494 {
 495         u64 ena, run, val;
 496         int cpu;
 497
 498         for (cpu = 0; cpu < cpus->nr; cpu++) {
 499                 val = counter->counts->cpu[cpu].val;
 500                 ena = counter->counts->cpu[cpu].ena;
 501                 run = counter->counts->cpu[cpu].run;
 502                 if (run == 0 || ena == 0) {
 503                         fprintf(stderr, "CPU%*d%s%*s%s%-24s",
 504                                 csv_output ? 0 : -4,
 505                                 cpus->map[cpu], csv_sep,
 506                                 csv_output ? 0 : 18,
 507                                 "<not counted>", csv_sep,
 508                                 event_name(counter));
 509
 510                         fprintf(stderr, "\n");
 511                         continue;
 512                 }
 513
 514                 if (nsec_counter(counter))
 515                         nsec_printout(cpu, counter, val);
 516                 else
 517                         abs_printout(cpu, counter, val);
 518
 519                 if (!csv_output) {
 520                         print_noise(counter, 1.0);
 521
 522                         if (run != ena) {
 523                                 fprintf(stderr, "  (scaled from %.2f%%)",
 524                                         100.0 * run / ena);
 525                         }
 526                 }
 527                 fprintf(stderr, "\n");
 528         }
 529 }
 530
 531 static void print_stat(int argc, const char **argv)
 532 {
 533         struct perf_evsel *counter;
 534         int i;
 535
 536         fflush(stdout);
 537
 538         if (!csv_output) {
 539                 fprintf(stderr, "\n");
 540                 fprintf(stderr, " Performance counter stats for ");
 541                 if(target_pid == -1 && target_tid == -1) {
 542                         fprintf(stderr, "\'%s", argv[0]);
 543                         for (i = 1; i < argc; i++)
 544                                 fprintf(stderr, " %s", argv[i]);
 545                 } else if (target_pid != -1)
 546                         fprintf(stderr, "process id \'%d", target_pid);
 547                 else
 548                         fprintf(stderr, "thread id \'%d", target_tid);
 549
 550                 fprintf(stderr, "\'");
 551                 if (run_count > 1)
 552                         fprintf(stderr, " (%d runs)", run_count);
 553                 fprintf(stderr, ":\n\n");
 554         }
 555
 556         if (no_aggr) {
 557                 list_for_each_entry(counter, &evsel_list, node)
 558                         print_counter(counter);
 559         } else {
 560                 list_for_each_entry(counter, &evsel_list, node)
 561                         print_counter_aggr(counter);
 562         }
 563
 564         if (!csv_output) {
 565                 fprintf(stderr, "\n");
 566                 fprintf(stderr, " %18.9f  seconds time elapsed",
 567                                 avg_stats(&walltime_nsecs_stats)/1e9);
 568                 if (run_count > 1) {
 569                         fprintf(stderr, "   ( +- %7.3f%% )",
 570                                 100*stddev_stats(&walltime_nsecs_stats) /
 571                                 avg_stats(&walltime_nsecs_stats));
 572                 }
 573                 fprintf(stderr, "\n\n");
 574         }
 575 }
 576
 577 static volatile int signr = -1;
 578
 579 static void skip_signal(int signo)
 580 {
 581         if(child_pid == -1)
 582                 done = 1;
 583
 584         signr = signo;
 585 }
 586
 587 static void sig_atexit(void)
 588 {
 589         if (child_pid != -1)
 590                 kill(child_pid, SIGTERM);
 591
 592         if (signr == -1)
 593                 return;
 594
 595         signal(signr, SIG_DFL);
 596         kill(getpid(), signr);
 597 }
 598
 599 static const char * const stat_usage[] = {
 600         "perf stat [<options>] [<command>]",
 601         NULL
 602 };
 603
 604 static int stat__set_big_num(const struct option *opt __used,
 605                              const char *s __used, int unset)
 606 {
 607         big_num_opt = unset ? 0 : 1;
 608         return 0;
 609 }
 610
 611 static const struct option options[] = {
 612         OPT_CALLBACK('e', "event", NULL, "event",
 613                      "event selector. use 'perf list' to list available events",
 614                      parse_events),
 615         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 616                     "child tasks do not inherit counters"),
 617         OPT_INTEGER('p', "pid", &target_pid,
 618                     "stat events on existing process id"),
 619         OPT_INTEGER('t', "tid", &target_tid,
 620                     "stat events on existing thread id"),
 621         OPT_BOOLEAN('a', "all-cpus", &system_wide,
 622                     "system-wide collection from all CPUs"),
 623         OPT_BOOLEAN('c', "scale", &scale,
 624                     "scale/normalize counters"),
 625         OPT_INCR('v', "verbose", &verbose,
 626                     "be more verbose (show counter open errors, etc)"),
 627         OPT_INTEGER('r', "repeat", &run_count,
 628                     "repeat command and print average + stddev (max: 100)"),
 629         OPT_BOOLEAN('n', "null", &null_run,
 630                     "null run - dont start any counters"),
 631         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
 632                            "print large numbers with thousands\' separators",
 633                            stat__set_big_num),
 634         OPT_STRING('C', "cpu", &cpu_list, "cpu",
 635                     "list of cpus to monitor in system-wide"),
 636         OPT_BOOLEAN('A', "no-aggr", &no_aggr,
 637                     "disable CPU count aggregation"),
 638         OPT_STRING('x', "field-separator", &csv_sep, "separator",
 639                    "print counts with custom separator"),
 640         OPT_END()
 641 };
 642
 643 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 644 {
 645         struct perf_evsel *pos;
 646         int status = -ENOMEM;
 647
 648         setlocale(LC_ALL, "");
 649
 650         argc = parse_options(argc, argv, options, stat_usage,
 651                 PARSE_OPT_STOP_AT_NON_OPTION);
 652
 653         if (csv_sep)
 654                 csv_output = true;
 655         else
 656                 csv_sep = DEFAULT_SEPARATOR;
 657
 658         /*
 659          * let the spreadsheet do the pretty-printing
 660          */
 661         if (csv_output) {
 662                 /* User explicitely passed -B? */
 663                 if (big_num_opt == 1) {
 664                         fprintf(stderr, "-B option not supported with -x\n");
 665                         usage_with_options(stat_usage, options);
 666                 } else /* Nope, so disable big number formatting */
 667                         big_num = false;
 668         } else if (big_num_opt == 0) /* User passed --no-big-num */
 669                 big_num = false;
 670
 671         if (!argc && target_pid == -1 && target_tid == -1)
 672                 usage_with_options(stat_usage, options);
 673         if (run_count <= 0)
 674                 usage_with_options(stat_usage, options);
 675
 676         /* no_aggr is for system-wide only */
 677         if (no_aggr && !system_wide)
 678                 usage_with_options(stat_usage, options);
 679
 680         /* Set attrs and nr_counters if no event is selected and !null_run */
 681         if (!null_run && !nr_counters) {
 682                 size_t c;
 683
 684                 nr_counters = ARRAY_SIZE(default_attrs);
 685
 686                 for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
 687                         pos = perf_evsel__new(default_attrs[c].type,
 688                                               default_attrs[c].config,
 689                                               nr_counters);
 690                         if (pos == NULL)
 691                                 goto out;
 692                         list_add(&pos->node, &evsel_list);
 693                 }
 694         }
 695
 696         if (system_wide)
 697                 cpus = cpu_map__new(cpu_list);
 698         else
 699                 cpus = cpu_map__dummy_new();
 700
 701         if (cpus == NULL) {
 702                 perror("failed to parse CPUs map");
 703                 usage_with_options(stat_usage, options);
 704                 return -1;
 705         }
 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, cpus->nr) < 0 ||
 727                     perf_evsel__alloc_fd(pos, cpus->nr, 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 }