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/evlist.h"
  47 #include "util/evsel.h"
  48 #include "util/debug.h"
  49 #include "util/color.h"
  50 #include "util/header.h"
  51 #include "util/cpumap.h"
  52 #include "util/thread.h"
  53 #include "util/thread_map.h"
  54
  55 #include <sys/prctl.h>
  56 #include <math.h>
  57 #include <locale.h>
  58
  59 #define DEFAULT_SEPARATOR       " "
  60
  61 static struct perf_event_attr default_attrs[] = {
  62
  63   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
  64   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
  65   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
  66   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
  67
  68   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
  69   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES          },
  70   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
  71   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
  72   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
  73
  74 };
  75
  76 struct perf_evlist              *evsel_list;
  77
  78 static bool                     system_wide                     =  false;
  79 static int                      run_idx                         =  0;
  80
  81 static int                      run_count                       =  1;
  82 static bool                     no_inherit                      = false;
  83 static bool                     scale                           =  true;
  84 static bool                     no_aggr                         = false;
  85 static pid_t                    target_pid                      = -1;
  86 static pid_t                    target_tid                      = -1;
  87 static pid_t                    child_pid                       = -1;
  88 static bool                     null_run                        =  false;
  89 static bool                     big_num                         =  true;
  90 static int                      big_num_opt                     =  -1;
  91 static const char               *cpu_list;
  92 static const char               *csv_sep                        = NULL;
  93 static bool                     csv_output                      = false;
  94
  95 static volatile int done = 0;
  96
  97 struct stats
  98 {
  99         double n, mean, M2;
 100 };
 101
 102 struct perf_stat {
 103         struct stats      res_stats[3];
 104 };
 105
 106 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 107 {
 108         evsel->priv = zalloc(sizeof(struct perf_stat));
 109         return evsel->priv == NULL ? -ENOMEM : 0;
 110 }
 111
 112 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
 113 {
 114         free(evsel->priv);
 115         evsel->priv = NULL;
 116 }
 117
 118 static void update_stats(struct stats *stats, u64 val)
 119 {
 120         double delta;
 121
 122         stats->n++;
 123         delta = val - stats->mean;
 124         stats->mean += delta / stats->n;
 125         stats->M2 += delta*(val - stats->mean);
 126 }
 127
 128 static double avg_stats(struct stats *stats)
 129 {
 130         return stats->mean;
 131 }
 132
 133 /*
 134  * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
 135  *
 136  *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
 137  * s^2 = -------------------------------
 138  *                  n - 1
 139  *
 140  * http://en.wikipedia.org/wiki/Stddev
 141  *
 142  * The std dev of the mean is related to the std dev by:
 143  *
 144  *             s
 145  * s_mean = -------
 146  *          sqrt(n)
 147  *
 148  */
 149 static double stddev_stats(struct stats *stats)
 150 {
 151         double variance = stats->M2 / (stats->n - 1);
 152         double variance_mean = variance / stats->n;
 153
 154         return sqrt(variance_mean);
 155 }
 156
 157 struct stats                    runtime_nsecs_stats[MAX_NR_CPUS];
 158 struct stats                    runtime_cycles_stats[MAX_NR_CPUS];
 159 struct stats                    runtime_stalled_cycles_stats[MAX_NR_CPUS];
 160 struct stats                    runtime_branches_stats[MAX_NR_CPUS];
 161 struct stats                    runtime_cacherefs_stats[MAX_NR_CPUS];
 162 struct stats                    runtime_l1_dcache_stats[MAX_NR_CPUS];
 163 struct stats                    walltime_nsecs_stats;
 164
 165 static int create_perf_stat_counter(struct perf_evsel *evsel)
 166 {
 167         struct perf_event_attr *attr = &evsel->attr;
 168
 169         if (scale)
 170                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 171                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 172
 173         attr->inherit = !no_inherit;
 174
 175         if (system_wide)
 176                 return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, false);
 177
 178         if (target_pid == -1 && target_tid == -1) {
 179                 attr->disabled = 1;
 180                 attr->enable_on_exec = 1;
 181         }
 182
 183         return perf_evsel__open_per_thread(evsel, evsel_list->threads, false);
 184 }
 185
 186 /*
 187  * Does the counter have nsecs as a unit?
 188  */
 189 static inline int nsec_counter(struct perf_evsel *evsel)
 190 {
 191         if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
 192             perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 193                 return 1;
 194
 195         return 0;
 196 }
 197
 198 /*
 199  * Update various tracking values we maintain to print
 200  * more semantic information such as miss/hit ratios,
 201  * instruction rates, etc:
 202  */
 203 static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
 204 {
 205         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
 206                 update_stats(&runtime_nsecs_stats[0], count[0]);
 207         else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
 208                 update_stats(&runtime_cycles_stats[0], count[0]);
 209         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES))
 210                 update_stats(&runtime_stalled_cycles_stats[0], count[0]);
 211         else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
 212                 update_stats(&runtime_branches_stats[0], count[0]);
 213         else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
 214                 update_stats(&runtime_cacherefs_stats[0], count[0]);
 215         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
 216                 update_stats(&runtime_l1_dcache_stats[0], count[0]);
 217 }
 218
 219 /*
 220  * Read out the results of a single counter:
 221  * aggregate counts across CPUs in system-wide mode
 222  */
 223 static int read_counter_aggr(struct perf_evsel *counter)
 224 {
 225         struct perf_stat *ps = counter->priv;
 226         u64 *count = counter->counts->aggr.values;
 227         int i;
 228
 229         if (__perf_evsel__read(counter, evsel_list->cpus->nr,
 230                                evsel_list->threads->nr, scale) < 0)
 231                 return -1;
 232
 233         for (i = 0; i < 3; i++)
 234                 update_stats(&ps->res_stats[i], count[i]);
 235
 236         if (verbose) {
 237                 fprintf(stderr, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
 238                         event_name(counter), count[0], count[1], count[2]);
 239         }
 240
 241         /*
 242          * Save the full runtime - to allow normalization during printout:
 243          */
 244         update_shadow_stats(counter, count);
 245
 246         return 0;
 247 }
 248
 249 /*
 250  * Read out the results of a single counter:
 251  * do not aggregate counts across CPUs in system-wide mode
 252  */
 253 static int read_counter(struct perf_evsel *counter)
 254 {
 255         u64 *count;
 256         int cpu;
 257
 258         for (cpu = 0; cpu < evsel_list->cpus->nr; cpu++) {
 259                 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
 260                         return -1;
 261
 262                 count = counter->counts->cpu[cpu].values;
 263
 264                 update_shadow_stats(counter, count);
 265         }
 266
 267         return 0;
 268 }
 269
 270 static int run_perf_stat(int argc __used, const char **argv)
 271 {
 272         unsigned long long t0, t1;
 273         struct perf_evsel *counter;
 274         int status = 0;
 275         int child_ready_pipe[2], go_pipe[2];
 276         const bool forks = (argc > 0);
 277         char buf;
 278
 279         if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 280                 perror("failed to create pipes");
 281                 exit(1);
 282         }
 283
 284         if (forks) {
 285                 if ((child_pid = fork()) < 0)
 286                         perror("failed to fork");
 287
 288                 if (!child_pid) {
 289                         close(child_ready_pipe[0]);
 290                         close(go_pipe[1]);
 291                         fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 292
 293                         /*
 294                          * Do a dummy execvp to get the PLT entry resolved,
 295                          * so we avoid the resolver overhead on the real
 296                          * execvp call.
 297                          */
 298                         execvp("", (char **)argv);
 299
 300                         /*
 301                          * Tell the parent we're ready to go
 302                          */
 303                         close(child_ready_pipe[1]);
 304
 305                         /*
 306                          * Wait until the parent tells us to go.
 307                          */
 308                         if (read(go_pipe[0], &buf, 1) == -1)
 309                                 perror("unable to read pipe");
 310
 311                         execvp(argv[0], (char **)argv);
 312
 313                         perror(argv[0]);
 314                         exit(-1);
 315                 }
 316
 317                 if (target_tid == -1 && target_pid == -1 && !system_wide)
 318                         evsel_list->threads->map[0] = child_pid;
 319
 320                 /*
 321                  * Wait for the child to be ready to exec.
 322                  */
 323                 close(child_ready_pipe[1]);
 324                 close(go_pipe[0]);
 325                 if (read(child_ready_pipe[0], &buf, 1) == -1)
 326                         perror("unable to read pipe");
 327                 close(child_ready_pipe[0]);
 328         }
 329
 330         list_for_each_entry(counter, &evsel_list->entries, node) {
 331                 if (create_perf_stat_counter(counter) < 0) {
 332                         if (errno == -EPERM || errno == -EACCES) {
 333                                 error("You may not have permission to collect %sstats.\n"
 334                                       "\t Consider tweaking"
 335                                       " /proc/sys/kernel/perf_event_paranoid or running as root.",
 336                                       system_wide ? "system-wide " : "");
 337                         } else if (errno == ENOENT) {
 338                                 error("%s event is not supported. ", event_name(counter));
 339                         } else {
 340                                 error("open_counter returned with %d (%s). "
 341                                       "/bin/dmesg may provide additional information.\n",
 342                                        errno, strerror(errno));
 343                         }
 344                         if (child_pid != -1)
 345                                 kill(child_pid, SIGTERM);
 346                         die("Not all events could be opened.\n");
 347                         return -1;
 348                 }
 349         }
 350
 351         if (perf_evlist__set_filters(evsel_list)) {
 352                 error("failed to set filter with %d (%s)\n", errno,
 353                         strerror(errno));
 354                 return -1;
 355         }
 356
 357         /*
 358          * Enable counters and exec the command:
 359          */
 360         t0 = rdclock();
 361
 362         if (forks) {
 363                 close(go_pipe[1]);
 364                 wait(&status);
 365         } else {
 366                 while(!done) sleep(1);
 367         }
 368
 369         t1 = rdclock();
 370
 371         update_stats(&walltime_nsecs_stats, t1 - t0);
 372
 373         if (no_aggr) {
 374                 list_for_each_entry(counter, &evsel_list->entries, node) {
 375                         read_counter(counter);
 376                         perf_evsel__close_fd(counter, evsel_list->cpus->nr, 1);
 377                 }
 378         } else {
 379                 list_for_each_entry(counter, &evsel_list->entries, node) {
 380                         read_counter_aggr(counter);
 381                         perf_evsel__close_fd(counter, evsel_list->cpus->nr,
 382                                              evsel_list->threads->nr);
 383                 }
 384         }
 385
 386         return WEXITSTATUS(status);
 387 }
 388
 389 static void print_noise_pct(double total, double avg)
 390 {
 391         double pct = 0.0;
 392
 393         if (avg)
 394                 pct = 100.0*total/avg;
 395
 396         fprintf(stderr, "  ( +-%6.2f%% )", pct);
 397 }
 398
 399 static void print_noise(struct perf_evsel *evsel, double avg)
 400 {
 401         struct perf_stat *ps;
 402
 403         if (run_count == 1)
 404                 return;
 405
 406         ps = evsel->priv;
 407         print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
 408 }
 409
 410 static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
 411 {
 412         double msecs = avg / 1e6;
 413         char cpustr[16] = { '\0', };
 414         const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-24s";
 415
 416         if (no_aggr)
 417                 sprintf(cpustr, "CPU%*d%s",
 418                         csv_output ? 0 : -4,
 419                         evsel_list->cpus->map[cpu], csv_sep);
 420
 421         fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel));
 422
 423         if (evsel->cgrp)
 424                 fprintf(stderr, "%s%s", csv_sep, evsel->cgrp->name);
 425
 426         if (csv_output)
 427                 return;
 428
 429         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 430                 fprintf(stderr, " # %8.3f CPUs utilized          ", avg / avg_stats(&walltime_nsecs_stats));
 431 }
 432
 433 static void print_stalled_cycles(int cpu, struct perf_evsel *evsel __used, double avg)
 434 {
 435         double total, ratio = 0.0;
 436         const char *color;
 437
 438         total = avg_stats(&runtime_cycles_stats[cpu]);
 439
 440         if (total)
 441                 ratio = avg / total * 100.0;
 442
 443         color = PERF_COLOR_NORMAL;
 444         if (ratio > 75.0)
 445                 color = PERF_COLOR_RED;
 446         else if (ratio > 50.0)
 447                 color = PERF_COLOR_MAGENTA;
 448         else if (ratio > 25.0)
 449                 color = PERF_COLOR_YELLOW;
 450
 451         fprintf(stderr, " #   ");
 452         color_fprintf(stderr, color, "%5.2f%%", ratio);
 453         fprintf(stderr, " of all cycles are idle ");
 454 }
 455
 456 static void print_branch_misses(int cpu, struct perf_evsel *evsel __used, double avg)
 457 {
 458         double total, ratio = 0.0;
 459         const char *color;
 460
 461         total = avg_stats(&runtime_branches_stats[cpu]);
 462
 463         if (total)
 464                 ratio = avg / total * 100.0;
 465
 466         color = PERF_COLOR_NORMAL;
 467         if (ratio > 20.0)
 468                 color = PERF_COLOR_RED;
 469         else if (ratio > 10.0)
 470                 color = PERF_COLOR_MAGENTA;
 471         else if (ratio > 5.0)
 472                 color = PERF_COLOR_YELLOW;
 473
 474         fprintf(stderr, " #   ");
 475         color_fprintf(stderr, color, "%5.2f%%", ratio);
 476         fprintf(stderr, " of all branches        ");
 477 }
 478
 479 static void print_l1_dcache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
 480 {
 481         double total, ratio = 0.0;
 482         const char *color;
 483
 484         total = avg_stats(&runtime_l1_dcache_stats[cpu]);
 485
 486         if (total)
 487                 ratio = avg / total * 100.0;
 488
 489         color = PERF_COLOR_NORMAL;
 490         if (ratio > 20.0)
 491                 color = PERF_COLOR_RED;
 492         else if (ratio > 10.0)
 493                 color = PERF_COLOR_MAGENTA;
 494         else if (ratio > 5.0)
 495                 color = PERF_COLOR_YELLOW;
 496
 497         fprintf(stderr, " #   ");
 498         color_fprintf(stderr, color, "%5.2f%%", ratio);
 499         fprintf(stderr, " of all L1-dcache hits  ");
 500 }
 501
 502 static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
 503 {
 504         double total, ratio = 0.0;
 505         char cpustr[16] = { '\0', };
 506         const char *fmt;
 507
 508         if (csv_output)
 509                 fmt = "%s%.0f%s%s";
 510         else if (big_num)
 511                 fmt = "%s%'18.0f%s%-24s";
 512         else
 513                 fmt = "%s%18.0f%s%-24s";
 514
 515         if (no_aggr)
 516                 sprintf(cpustr, "CPU%*d%s",
 517                         csv_output ? 0 : -4,
 518                         evsel_list->cpus->map[cpu], csv_sep);
 519         else
 520                 cpu = 0;
 521
 522         fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel));
 523
 524         if (evsel->cgrp)
 525                 fprintf(stderr, "%s%s", csv_sep, evsel->cgrp->name);
 526
 527         if (csv_output)
 528                 return;
 529
 530         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
 531                 total = avg_stats(&runtime_cycles_stats[cpu]);
 532
 533                 if (total)
 534                         ratio = avg / total;
 535
 536                 fprintf(stderr, " #    %4.2f  insns per cycle", ratio);
 537
 538                 total = avg_stats(&runtime_stalled_cycles_stats[cpu]);
 539
 540                 if (total && avg) {
 541                         ratio = total / avg;
 542                         fprintf(stderr, "\n                                            #    %4.2f  stalled cycles per insn", ratio);
 543                 }
 544
 545         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
 546                         runtime_branches_stats[cpu].n != 0) {
 547                 print_branch_misses(cpu, evsel, avg);
 548         } else if (
 549                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
 550                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
 551                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
 552                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
 553                         runtime_branches_stats[cpu].n != 0) {
 554                 print_l1_dcache_misses(cpu, evsel, avg);
 555         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
 556                         runtime_cacherefs_stats[cpu].n != 0) {
 557                 total = avg_stats(&runtime_cacherefs_stats[cpu]);
 558
 559                 if (total)
 560                         ratio = avg * 100 / total;
 561
 562                 fprintf(stderr, " # %8.3f %% of all cache refs    ", ratio);
 563
 564         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES)) {
 565                 print_stalled_cycles(cpu, evsel, avg);
 566         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
 567                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 568
 569                 if (total)
 570                         ratio = 1.0 * avg / total;
 571
 572                 fprintf(stderr, " # %8.3f GHz                    ", ratio);
 573         } else if (runtime_nsecs_stats[cpu].n != 0) {
 574                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 575
 576                 if (total)
 577                         ratio = 1000.0 * avg / total;
 578
 579                 fprintf(stderr, " # %8.3f M/sec                  ", ratio);
 580         } else {
 581                 fprintf(stderr, "                                   ");
 582         }
 583 }
 584
 585 /*
 586  * Print out the results of a single counter:
 587  * aggregated counts in system-wide mode
 588  */
 589 static void print_counter_aggr(struct perf_evsel *counter)
 590 {
 591         struct perf_stat *ps = counter->priv;
 592         double avg = avg_stats(&ps->res_stats[0]);
 593         int scaled = counter->counts->scaled;
 594
 595         if (scaled == -1) {
 596                 fprintf(stderr, "%*s%s%*s",
 597                         csv_output ? 0 : 18,
 598                         "<not counted>",
 599                         csv_sep,
 600                         csv_output ? 0 : -24,
 601                         event_name(counter));
 602
 603                 if (counter->cgrp)
 604                         fprintf(stderr, "%s%s", csv_sep, counter->cgrp->name);
 605
 606                 fputc('\n', stderr);
 607                 return;
 608         }
 609
 610         if (nsec_counter(counter))
 611                 nsec_printout(-1, counter, avg);
 612         else
 613                 abs_printout(-1, counter, avg);
 614
 615         if (csv_output) {
 616                 fputc('\n', stderr);
 617                 return;
 618         }
 619
 620         print_noise(counter, avg);
 621
 622         if (scaled) {
 623                 double avg_enabled, avg_running;
 624
 625                 avg_enabled = avg_stats(&ps->res_stats[1]);
 626                 avg_running = avg_stats(&ps->res_stats[2]);
 627
 628                 fprintf(stderr, "  (scaled from %.2f%%)",
 629                                 100 * avg_running / avg_enabled);
 630         }
 631         fprintf(stderr, "\n");
 632 }
 633
 634 /*
 635  * Print out the results of a single counter:
 636  * does not use aggregated count in system-wide
 637  */
 638 static void print_counter(struct perf_evsel *counter)
 639 {
 640         u64 ena, run, val;
 641         int cpu;
 642
 643         for (cpu = 0; cpu < evsel_list->cpus->nr; cpu++) {
 644                 val = counter->counts->cpu[cpu].val;
 645                 ena = counter->counts->cpu[cpu].ena;
 646                 run = counter->counts->cpu[cpu].run;
 647                 if (run == 0 || ena == 0) {
 648                         fprintf(stderr, "CPU%*d%s%*s%s%*s",
 649                                 csv_output ? 0 : -4,
 650                                 evsel_list->cpus->map[cpu], csv_sep,
 651                                 csv_output ? 0 : 18,
 652                                 "<not counted>", csv_sep,
 653                                 csv_output ? 0 : -24,
 654                                 event_name(counter));
 655
 656                         if (counter->cgrp)
 657                                 fprintf(stderr, "%s%s", csv_sep, counter->cgrp->name);
 658
 659                         fputc('\n', stderr);
 660                         continue;
 661                 }
 662
 663                 if (nsec_counter(counter))
 664                         nsec_printout(cpu, counter, val);
 665                 else
 666                         abs_printout(cpu, counter, val);
 667
 668                 if (!csv_output) {
 669                         print_noise(counter, 1.0);
 670
 671                         if (run != ena) {
 672                                 fprintf(stderr, "  (scaled from %.2f%%)",
 673                                         100.0 * run / ena);
 674                         }
 675                 }
 676                 fputc('\n', stderr);
 677         }
 678 }
 679
 680 static void print_stat(int argc, const char **argv)
 681 {
 682         struct perf_evsel *counter;
 683         int i;
 684
 685         fflush(stdout);
 686
 687         if (!csv_output) {
 688                 fprintf(stderr, "\n");
 689                 fprintf(stderr, " Performance counter stats for ");
 690                 if(target_pid == -1 && target_tid == -1) {
 691                         fprintf(stderr, "\'%s", argv[0]);
 692                         for (i = 1; i < argc; i++)
 693                                 fprintf(stderr, " %s", argv[i]);
 694                 } else if (target_pid != -1)
 695                         fprintf(stderr, "process id \'%d", target_pid);
 696                 else
 697                         fprintf(stderr, "thread id \'%d", target_tid);
 698
 699                 fprintf(stderr, "\'");
 700                 if (run_count > 1)
 701                         fprintf(stderr, " (%d runs)", run_count);
 702                 fprintf(stderr, ":\n\n");
 703         }
 704
 705         if (no_aggr) {
 706                 list_for_each_entry(counter, &evsel_list->entries, node)
 707                         print_counter(counter);
 708         } else {
 709                 list_for_each_entry(counter, &evsel_list->entries, node)
 710                         print_counter_aggr(counter);
 711         }
 712
 713         if (!csv_output) {
 714                 fprintf(stderr, "\n");
 715                 fprintf(stderr, " %18.9f  seconds time elapsed",
 716                                 avg_stats(&walltime_nsecs_stats)/1e9);
 717                 if (run_count > 1) {
 718                         print_noise_pct(stddev_stats(&walltime_nsecs_stats),
 719                                         avg_stats(&walltime_nsecs_stats));
 720                 }
 721                 fprintf(stderr, "\n\n");
 722         }
 723 }
 724
 725 static volatile int signr = -1;
 726
 727 static void skip_signal(int signo)
 728 {
 729         if(child_pid == -1)
 730                 done = 1;
 731
 732         signr = signo;
 733 }
 734
 735 static void sig_atexit(void)
 736 {
 737         if (child_pid != -1)
 738                 kill(child_pid, SIGTERM);
 739
 740         if (signr == -1)
 741                 return;
 742
 743         signal(signr, SIG_DFL);
 744         kill(getpid(), signr);
 745 }
 746
 747 static const char * const stat_usage[] = {
 748         "perf stat [<options>] [<command>]",
 749         NULL
 750 };
 751
 752 static int stat__set_big_num(const struct option *opt __used,
 753                              const char *s __used, int unset)
 754 {
 755         big_num_opt = unset ? 0 : 1;
 756         return 0;
 757 }
 758
 759 static const struct option options[] = {
 760         OPT_CALLBACK('e', "event", &evsel_list, "event",
 761                      "event selector. use 'perf list' to list available events",
 762                      parse_events),
 763         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
 764                      "event filter", parse_filter),
 765         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 766                     "child tasks do not inherit counters"),
 767         OPT_INTEGER('p', "pid", &target_pid,
 768                     "stat events on existing process id"),
 769         OPT_INTEGER('t', "tid", &target_tid,
 770                     "stat events on existing thread id"),
 771         OPT_BOOLEAN('a', "all-cpus", &system_wide,
 772                     "system-wide collection from all CPUs"),
 773         OPT_BOOLEAN('c', "scale", &scale,
 774                     "scale/normalize counters"),
 775         OPT_INCR('v', "verbose", &verbose,
 776                     "be more verbose (show counter open errors, etc)"),
 777         OPT_INTEGER('r', "repeat", &run_count,
 778                     "repeat command and print average + stddev (max: 100)"),
 779         OPT_BOOLEAN('n', "null", &null_run,
 780                     "null run - dont start any counters"),
 781         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
 782                            "print large numbers with thousands\' separators",
 783                            stat__set_big_num),
 784         OPT_STRING('C', "cpu", &cpu_list, "cpu",
 785                     "list of cpus to monitor in system-wide"),
 786         OPT_BOOLEAN('A', "no-aggr", &no_aggr,
 787                     "disable CPU count aggregation"),
 788         OPT_STRING('x', "field-separator", &csv_sep, "separator",
 789                    "print counts with custom separator"),
 790         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
 791                      "monitor event in cgroup name only",
 792                      parse_cgroups),
 793         OPT_END()
 794 };
 795
 796 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 797 {
 798         struct perf_evsel *pos;
 799         int status = -ENOMEM;
 800
 801         setlocale(LC_ALL, "");
 802
 803         evsel_list = perf_evlist__new(NULL, NULL);
 804         if (evsel_list == NULL)
 805                 return -ENOMEM;
 806
 807         argc = parse_options(argc, argv, options, stat_usage,
 808                 PARSE_OPT_STOP_AT_NON_OPTION);
 809
 810         if (csv_sep)
 811                 csv_output = true;
 812         else
 813                 csv_sep = DEFAULT_SEPARATOR;
 814
 815         /*
 816          * let the spreadsheet do the pretty-printing
 817          */
 818         if (csv_output) {
 819                 /* User explicitely passed -B? */
 820                 if (big_num_opt == 1) {
 821                         fprintf(stderr, "-B option not supported with -x\n");
 822                         usage_with_options(stat_usage, options);
 823                 } else /* Nope, so disable big number formatting */
 824                         big_num = false;
 825         } else if (big_num_opt == 0) /* User passed --no-big-num */
 826                 big_num = false;
 827
 828         if (!argc && target_pid == -1 && target_tid == -1)
 829                 usage_with_options(stat_usage, options);
 830         if (run_count <= 0)
 831                 usage_with_options(stat_usage, options);
 832
 833         /* no_aggr, cgroup are for system-wide only */
 834         if ((no_aggr || nr_cgroups) && !system_wide) {
 835                 fprintf(stderr, "both cgroup and no-aggregation "
 836                         "modes only available in system-wide mode\n");
 837
 838                 usage_with_options(stat_usage, options);
 839         }
 840
 841         /* Set attrs and nr_counters if no event is selected and !null_run */
 842         if (!null_run && !evsel_list->nr_entries) {
 843                 size_t c;
 844
 845                 for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
 846                         pos = perf_evsel__new(&default_attrs[c], c);
 847                         if (pos == NULL)
 848                                 goto out;
 849                         perf_evlist__add(evsel_list, pos);
 850                 }
 851         }
 852
 853         if (target_pid != -1)
 854                 target_tid = target_pid;
 855
 856         evsel_list->threads = thread_map__new(target_pid, target_tid);
 857         if (evsel_list->threads == NULL) {
 858                 pr_err("Problems finding threads of monitor\n");
 859                 usage_with_options(stat_usage, options);
 860         }
 861
 862         if (system_wide)
 863                 evsel_list->cpus = cpu_map__new(cpu_list);
 864         else
 865                 evsel_list->cpus = cpu_map__dummy_new();
 866
 867         if (evsel_list->cpus == NULL) {
 868                 perror("failed to parse CPUs map");
 869                 usage_with_options(stat_usage, options);
 870                 return -1;
 871         }
 872
 873         list_for_each_entry(pos, &evsel_list->entries, node) {
 874                 if (perf_evsel__alloc_stat_priv(pos) < 0 ||
 875                     perf_evsel__alloc_counts(pos, evsel_list->cpus->nr) < 0 ||
 876                     perf_evsel__alloc_fd(pos, evsel_list->cpus->nr, evsel_list->threads->nr) < 0)
 877                         goto out_free_fd;
 878         }
 879
 880         /*
 881          * We dont want to block the signals - that would cause
 882          * child tasks to inherit that and Ctrl-C would not work.
 883          * What we want is for Ctrl-C to work in the exec()-ed
 884          * task, but being ignored by perf stat itself:
 885          */
 886         atexit(sig_atexit);
 887         signal(SIGINT,  skip_signal);
 888         signal(SIGALRM, skip_signal);
 889         signal(SIGABRT, skip_signal);
 890
 891         status = 0;
 892         for (run_idx = 0; run_idx < run_count; run_idx++) {
 893                 if (run_count != 1 && verbose)
 894                         fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
 895                 status = run_perf_stat(argc, argv);
 896         }
 897
 898         if (status != -1)
 899                 print_stat(argc, argv);
 900 out_free_fd:
 901         list_for_each_entry(pos, &evsel_list->entries, node)
 902                 perf_evsel__free_stat_priv(pos);
 903         perf_evlist__delete_maps(evsel_list);
 904 out:
 905         perf_evlist__delete(evsel_list);
 906         return status;
 907 }