tools/perf/builtin-stat.c

   1 /*
   2  * builtin-stat.c
   3  *
   4  * Builtin stat command: Give a precise performance counters summary
   5  * overview about any workload, CPU or specific PID.
   6  *
   7  * Sample output:
   8
   9    $ perf stat ./hackbench 10
  10
  11   Time: 0.118
  12
  13   Performance counter stats for './hackbench 10':
  14
  15        1708.761321 task-clock                #   11.037 CPUs utilized
  16             41,190 context-switches          #    0.024 M/sec
  17              6,735 CPU-migrations            #    0.004 M/sec
  18             17,318 page-faults               #    0.010 M/sec
  19      5,205,202,243 cycles                    #    3.046 GHz
  20      3,856,436,920 stalled-cycles-frontend   #   74.09% frontend cycles idle
  21      1,600,790,871 stalled-cycles-backend    #   30.75% backend  cycles idle
  22      2,603,501,247 instructions              #    0.50  insns per cycle
  23                                              #    1.48  stalled cycles per insn
  24        484,357,498 branches                  #  283.455 M/sec
  25          6,388,934 branch-misses             #    1.32% of all branches
  26
  27         0.154822978  seconds time elapsed
  28
  29  *
  30  * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  31  *
  32  * Improvements and fixes by:
  33  *
  34  *   Arjan van de Ven <arjan@linux.intel.com>
  35  *   Yanmin Zhang <yanmin.zhang@intel.com>
  36  *   Wu Fengguang <fengguang.wu@intel.com>
  37  *   Mike Galbraith <efault@gmx.de>
  38  *   Paul Mackerras <paulus@samba.org>
  39  *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  40  *
  41  * Released under the GPL v2. (and only v2, not any later version)
  42  */
  43
  44 #include "perf.h"
  45 #include "builtin.h"
  46 #include "util/util.h"
  47 #include "util/parse-options.h"
  48 #include "util/parse-events.h"
  49 #include "util/pmu.h"
  50 #include "util/event.h"
  51 #include "util/evlist.h"
  52 #include "util/evsel.h"
  53 #include "util/debug.h"
  54 #include "util/color.h"
  55 #include "util/stat.h"
  56 #include "util/header.h"
  57 #include "util/cpumap.h"
  58 #include "util/thread.h"
  59 #include "util/thread_map.h"
  60
  61 #include <stdlib.h>
  62 #include <sys/prctl.h>
  63 #include <locale.h>
  64
  65 #define DEFAULT_SEPARATOR       " "
  66 #define CNTR_NOT_SUPPORTED      "<not supported>"
  67 #define CNTR_NOT_COUNTED        "<not counted>"
  68
  69 static void print_stat(int argc, const char **argv);
  70 static void print_counter_aggr(struct perf_evsel *counter, char *prefix);
  71 static void print_counter(struct perf_evsel *counter, char *prefix);
  72 static void print_aggr(char *prefix);
  73
  74 /* Default events used for perf stat -T */
  75 static const char * const transaction_attrs[] = {
  76         "task-clock",
  77         "{"
  78         "instructions,"
  79         "cycles,"
  80         "cpu/cycles-t/,"
  81         "cpu/tx-start/,"
  82         "cpu/el-start/,"
  83         "cpu/cycles-ct/"
  84         "}"
  85 };
  86
  87 /* More limited version when the CPU does not have all events. */
  88 static const char * const transaction_limited_attrs[] = {
  89         "task-clock",
  90         "{"
  91         "instructions,"
  92         "cycles,"
  93         "cpu/cycles-t/,"
  94         "cpu/tx-start/"
  95         "}"
  96 };
  97
  98 /* must match transaction_attrs and the beginning limited_attrs */
  99 enum {
 100         T_TASK_CLOCK,
 101         T_INSTRUCTIONS,
 102         T_CYCLES,
 103         T_CYCLES_IN_TX,
 104         T_TRANSACTION_START,
 105         T_ELISION_START,
 106         T_CYCLES_IN_TX_CP,
 107 };
 108
 109 static struct perf_evlist       *evsel_list;
 110
 111 static struct target target = {
 112         .uid    = UINT_MAX,
 113 };
 114
 115 enum aggr_mode {
 116         AGGR_NONE,
 117         AGGR_GLOBAL,
 118         AGGR_SOCKET,
 119         AGGR_CORE,
 120 };
 121
 122 static int                      run_count                       =  1;
 123 static bool                     no_inherit                      = false;
 124 static bool                     scale                           =  true;
 125 static enum aggr_mode           aggr_mode                       = AGGR_GLOBAL;
 126 static volatile pid_t           child_pid                       = -1;
 127 static bool                     null_run                        =  false;
 128 static int                      detailed_run                    =  0;
 129 static bool                     transaction_run;
 130 static bool                     big_num                         =  true;
 131 static int                      big_num_opt                     =  -1;
 132 static const char               *csv_sep                        = NULL;
 133 static bool                     csv_output                      = false;
 134 static bool                     group                           = false;
 135 static FILE                     *output                         = NULL;
 136 static const char               *pre_cmd                        = NULL;
 137 static const char               *post_cmd                       = NULL;
 138 static bool                     sync_run                        = false;
 139 static unsigned int             interval                        = 0;
 140 static unsigned int             initial_delay                   = 0;
 141 static unsigned int             unit_width                      = 4; /* strlen("unit") */
 142 static bool                     forever                         = false;
 143 static struct timespec          ref_time;
 144 static struct cpu_map           *aggr_map;
 145 static int                      (*aggr_get_id)(struct cpu_map *m, int cpu);
 146
 147 static volatile int done = 0;
 148
 149 struct perf_stat {
 150         struct stats      res_stats[3];
 151 };
 152
 153 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 154                                  struct timespec *b)
 155 {
 156         r->tv_sec = a->tv_sec - b->tv_sec;
 157         if (a->tv_nsec < b->tv_nsec) {
 158                 r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
 159                 r->tv_sec--;
 160         } else {
 161                 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
 162         }
 163 }
 164
 165 static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
 166 {
 167         return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
 168 }
 169
 170 static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
 171 {
 172         return perf_evsel__cpus(evsel)->nr;
 173 }
 174
 175 static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
 176 {
 177         int i;
 178         struct perf_stat *ps = evsel->priv;
 179
 180         for (i = 0; i < 3; i++)
 181                 init_stats(&ps->res_stats[i]);
 182 }
 183
 184 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 185 {
 186         evsel->priv = zalloc(sizeof(struct perf_stat));
 187         if (evsel->priv == NULL)
 188                 return -ENOMEM;
 189         perf_evsel__reset_stat_priv(evsel);
 190         return 0;
 191 }
 192
 193 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
 194 {
 195         zfree(&evsel->priv);
 196 }
 197
 198 static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel)
 199 {
 200         void *addr;
 201         size_t sz;
 202
 203         sz = sizeof(*evsel->counts) +
 204              (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values));
 205
 206         addr = zalloc(sz);
 207         if (!addr)
 208                 return -ENOMEM;
 209
 210         evsel->prev_raw_counts =  addr;
 211
 212         return 0;
 213 }
 214
 215 static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
 216 {
 217         zfree(&evsel->prev_raw_counts);
 218 }
 219
 220 static void perf_evlist__free_stats(struct perf_evlist *evlist)
 221 {
 222         struct perf_evsel *evsel;
 223
 224         evlist__for_each(evlist, evsel) {
 225                 perf_evsel__free_stat_priv(evsel);
 226                 perf_evsel__free_counts(evsel);
 227                 perf_evsel__free_prev_raw_counts(evsel);
 228         }
 229 }
 230
 231 static int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
 232 {
 233         struct perf_evsel *evsel;
 234
 235         evlist__for_each(evlist, evsel) {
 236                 if (perf_evsel__alloc_stat_priv(evsel) < 0 ||
 237                     perf_evsel__alloc_counts(evsel, perf_evsel__nr_cpus(evsel)) < 0 ||
 238                     (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel) < 0))
 239                         goto out_free;
 240         }
 241
 242         return 0;
 243
 244 out_free:
 245         perf_evlist__free_stats(evlist);
 246         return -1;
 247 }
 248
 249 static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
 250 static struct stats runtime_cycles_stats[MAX_NR_CPUS];
 251 static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
 252 static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
 253 static struct stats runtime_branches_stats[MAX_NR_CPUS];
 254 static struct stats runtime_cacherefs_stats[MAX_NR_CPUS];
 255 static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS];
 256 static struct stats runtime_l1_icache_stats[MAX_NR_CPUS];
 257 static struct stats runtime_ll_cache_stats[MAX_NR_CPUS];
 258 static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
 259 static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
 260 static struct stats runtime_cycles_in_tx_stats[MAX_NR_CPUS];
 261 static struct stats walltime_nsecs_stats;
 262 static struct stats runtime_transaction_stats[MAX_NR_CPUS];
 263 static struct stats runtime_elision_stats[MAX_NR_CPUS];
 264
 265 static void perf_stat__reset_stats(struct perf_evlist *evlist)
 266 {
 267         struct perf_evsel *evsel;
 268
 269         evlist__for_each(evlist, evsel) {
 270                 perf_evsel__reset_stat_priv(evsel);
 271                 perf_evsel__reset_counts(evsel, perf_evsel__nr_cpus(evsel));
 272         }
 273
 274         memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
 275         memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
 276         memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
 277         memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats));
 278         memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats));
 279         memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats));
 280         memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats));
 281         memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats));
 282         memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats));
 283         memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats));
 284         memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats));
 285         memset(runtime_cycles_in_tx_stats, 0,
 286                         sizeof(runtime_cycles_in_tx_stats));
 287         memset(runtime_transaction_stats, 0,
 288                 sizeof(runtime_transaction_stats));
 289         memset(runtime_elision_stats, 0, sizeof(runtime_elision_stats));
 290         memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
 291 }
 292
 293 static int create_perf_stat_counter(struct perf_evsel *evsel)
 294 {
 295         struct perf_event_attr *attr = &evsel->attr;
 296
 297         if (scale)
 298                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 299                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 300
 301         attr->inherit = !no_inherit;
 302
 303         if (target__has_cpu(&target))
 304                 return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
 305
 306         if (!target__has_task(&target) && perf_evsel__is_group_leader(evsel)) {
 307                 attr->disabled = 1;
 308                 if (!initial_delay)
 309                         attr->enable_on_exec = 1;
 310         }
 311
 312         return perf_evsel__open_per_thread(evsel, evsel_list->threads);
 313 }
 314
 315 /*
 316  * Does the counter have nsecs as a unit?
 317  */
 318 static inline int nsec_counter(struct perf_evsel *evsel)
 319 {
 320         if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
 321             perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 322                 return 1;
 323
 324         return 0;
 325 }
 326
 327 static struct perf_evsel *nth_evsel(int n)
 328 {
 329         static struct perf_evsel **array;
 330         static int array_len;
 331         struct perf_evsel *ev;
 332         int j;
 333
 334         /* Assumes this only called when evsel_list does not change anymore. */
 335         if (!array) {
 336                 evlist__for_each(evsel_list, ev)
 337                         array_len++;
 338                 array = malloc(array_len * sizeof(void *));
 339                 if (!array)
 340                         exit(ENOMEM);
 341                 j = 0;
 342                 evlist__for_each(evsel_list, ev)
 343                         array[j++] = ev;
 344         }
 345         if (n < array_len)
 346                 return array[n];
 347         return NULL;
 348 }
 349
 350 /*
 351  * Update various tracking values we maintain to print
 352  * more semantic information such as miss/hit ratios,
 353  * instruction rates, etc:
 354  */
 355 static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
 356 {
 357         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
 358                 update_stats(&runtime_nsecs_stats[0], count[0]);
 359         else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
 360                 update_stats(&runtime_cycles_stats[0], count[0]);
 361         else if (transaction_run &&
 362                  perf_evsel__cmp(counter, nth_evsel(T_CYCLES_IN_TX)))
 363                 update_stats(&runtime_cycles_in_tx_stats[0], count[0]);
 364         else if (transaction_run &&
 365                  perf_evsel__cmp(counter, nth_evsel(T_TRANSACTION_START)))
 366                 update_stats(&runtime_transaction_stats[0], count[0]);
 367         else if (transaction_run &&
 368                  perf_evsel__cmp(counter, nth_evsel(T_ELISION_START)))
 369                 update_stats(&runtime_elision_stats[0], count[0]);
 370         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
 371                 update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
 372         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
 373                 update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
 374         else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
 375                 update_stats(&runtime_branches_stats[0], count[0]);
 376         else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
 377                 update_stats(&runtime_cacherefs_stats[0], count[0]);
 378         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
 379                 update_stats(&runtime_l1_dcache_stats[0], count[0]);
 380         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
 381                 update_stats(&runtime_l1_icache_stats[0], count[0]);
 382         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
 383                 update_stats(&runtime_ll_cache_stats[0], count[0]);
 384         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
 385                 update_stats(&runtime_dtlb_cache_stats[0], count[0]);
 386         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
 387                 update_stats(&runtime_itlb_cache_stats[0], count[0]);
 388 }
 389
 390 /*
 391  * Read out the results of a single counter:
 392  * aggregate counts across CPUs in system-wide mode
 393  */
 394 static int read_counter_aggr(struct perf_evsel *counter)
 395 {
 396         struct perf_stat *ps = counter->priv;
 397         u64 *count = counter->counts->aggr.values;
 398         int i;
 399
 400         if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter),
 401                                thread_map__nr(evsel_list->threads), scale) < 0)
 402                 return -1;
 403
 404         for (i = 0; i < 3; i++)
 405                 update_stats(&ps->res_stats[i], count[i]);
 406
 407         if (verbose) {
 408                 fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
 409                         perf_evsel__name(counter), count[0], count[1], count[2]);
 410         }
 411
 412         /*
 413          * Save the full runtime - to allow normalization during printout:
 414          */
 415         update_shadow_stats(counter, count);
 416
 417         return 0;
 418 }
 419
 420 /*
 421  * Read out the results of a single counter:
 422  * do not aggregate counts across CPUs in system-wide mode
 423  */
 424 static int read_counter(struct perf_evsel *counter)
 425 {
 426         u64 *count;
 427         int cpu;
 428
 429         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
 430                 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
 431                         return -1;
 432
 433                 count = counter->counts->cpu[cpu].values;
 434
 435                 update_shadow_stats(counter, count);
 436         }
 437
 438         return 0;
 439 }
 440
 441 static void print_interval(void)
 442 {
 443         static int num_print_interval;
 444         struct perf_evsel *counter;
 445         struct perf_stat *ps;
 446         struct timespec ts, rs;
 447         char prefix[64];
 448
 449         if (aggr_mode == AGGR_GLOBAL) {
 450                 evlist__for_each(evsel_list, counter) {
 451                         ps = counter->priv;
 452                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
 453                         read_counter_aggr(counter);
 454                 }
 455         } else  {
 456                 evlist__for_each(evsel_list, counter) {
 457                         ps = counter->priv;
 458                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
 459                         read_counter(counter);
 460                 }
 461         }
 462
 463         clock_gettime(CLOCK_MONOTONIC, &ts);
 464         diff_timespec(&rs, &ts, &ref_time);
 465         sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep);
 466
 467         if (num_print_interval == 0 && !csv_output) {
 468                 switch (aggr_mode) {
 469                 case AGGR_SOCKET:
 470                         fprintf(output, "#           time socket cpus             counts %*s events\n", unit_width, "unit");
 471                         break;
 472                 case AGGR_CORE:
 473                         fprintf(output, "#           time core         cpus             counts %*s events\n", unit_width, "unit");
 474                         break;
 475                 case AGGR_NONE:
 476                         fprintf(output, "#           time CPU                counts %*s events\n", unit_width, "unit");
 477                         break;
 478                 case AGGR_GLOBAL:
 479                 default:
 480                         fprintf(output, "#           time             counts %*s events\n", unit_width, "unit");
 481                 }
 482         }
 483
 484         if (++num_print_interval == 25)
 485                 num_print_interval = 0;
 486
 487         switch (aggr_mode) {
 488         case AGGR_CORE:
 489         case AGGR_SOCKET:
 490                 print_aggr(prefix);
 491                 break;
 492         case AGGR_NONE:
 493                 evlist__for_each(evsel_list, counter)
 494                         print_counter(counter, prefix);
 495                 break;
 496         case AGGR_GLOBAL:
 497         default:
 498                 evlist__for_each(evsel_list, counter)
 499                         print_counter_aggr(counter, prefix);
 500         }
 501
 502         fflush(output);
 503 }
 504
 505 static void handle_initial_delay(void)
 506 {
 507         struct perf_evsel *counter;
 508
 509         if (initial_delay) {
 510                 const int ncpus = cpu_map__nr(evsel_list->cpus),
 511                         nthreads = thread_map__nr(evsel_list->threads);
 512
 513                 usleep(initial_delay * 1000);
 514                 evlist__for_each(evsel_list, counter)
 515                         perf_evsel__enable(counter, ncpus, nthreads);
 516         }
 517 }
 518
 519 static volatile int workload_exec_errno;
 520
 521 /*
 522  * perf_evlist__prepare_workload will send a SIGUSR1
 523  * if the fork fails, since we asked by setting its
 524  * want_signal to true.
 525  */
 526 static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info,
 527                                         void *ucontext __maybe_unused)
 528 {
 529         workload_exec_errno = info->si_value.sival_int;
 530 }
 531
 532 static int __run_perf_stat(int argc, const char **argv)
 533 {
 534         char msg[512];
 535         unsigned long long t0, t1;
 536         struct perf_evsel *counter;
 537         struct timespec ts;
 538         size_t l;
 539         int status = 0;
 540         const bool forks = (argc > 0);
 541
 542         if (interval) {
 543                 ts.tv_sec  = interval / 1000;
 544                 ts.tv_nsec = (interval % 1000) * 1000000;
 545         } else {
 546                 ts.tv_sec  = 1;
 547                 ts.tv_nsec = 0;
 548         }
 549
 550         if (forks) {
 551                 if (perf_evlist__prepare_workload(evsel_list, &target, argv, false,
 552                                                   workload_exec_failed_signal) < 0) {
 553                         perror("failed to prepare workload");
 554                         return -1;
 555                 }
 556                 child_pid = evsel_list->workload.pid;
 557         }
 558
 559         if (group)
 560                 perf_evlist__set_leader(evsel_list);
 561
 562         evlist__for_each(evsel_list, counter) {
 563                 if (create_perf_stat_counter(counter) < 0) {
 564                         /*
 565                          * PPC returns ENXIO for HW counters until 2.6.37
 566                          * (behavior changed with commit b0a873e).
 567                          */
 568                         if (errno == EINVAL || errno == ENOSYS ||
 569                             errno == ENOENT || errno == EOPNOTSUPP ||
 570                             errno == ENXIO) {
 571                                 if (verbose)
 572                                         ui__warning("%s event is not supported by the kernel.\n",
 573                                                     perf_evsel__name(counter));
 574                                 counter->supported = false;
 575                                 continue;
 576                         }
 577
 578                         perf_evsel__open_strerror(counter, &target,
 579                                                   errno, msg, sizeof(msg));
 580                         ui__error("%s\n", msg);
 581
 582                         if (child_pid != -1)
 583                                 kill(child_pid, SIGTERM);
 584
 585                         return -1;
 586                 }
 587                 counter->supported = true;
 588
 589                 l = strlen(counter->unit);
 590                 if (l > unit_width)
 591                         unit_width = l;
 592         }
 593
 594         if (perf_evlist__apply_filters(evsel_list)) {
 595                 error("failed to set filter with %d (%s)\n", errno,
 596                         strerror_r(errno, msg, sizeof(msg)));
 597                 return -1;
 598         }
 599
 600         /*
 601          * Enable counters and exec the command:
 602          */
 603         t0 = rdclock();
 604         clock_gettime(CLOCK_MONOTONIC, &ref_time);
 605
 606         if (forks) {
 607                 perf_evlist__start_workload(evsel_list);
 608                 handle_initial_delay();
 609
 610                 if (interval) {
 611                         while (!waitpid(child_pid, &status, WNOHANG)) {
 612                                 nanosleep(&ts, NULL);
 613                                 print_interval();
 614                         }
 615                 }
 616                 wait(&status);
 617
 618                 if (workload_exec_errno) {
 619                         const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
 620                         pr_err("Workload failed: %s\n", emsg);
 621                         return -1;
 622                 }
 623
 624                 if (WIFSIGNALED(status))
 625                         psignal(WTERMSIG(status), argv[0]);
 626         } else {
 627                 handle_initial_delay();
 628                 while (!done) {
 629                         nanosleep(&ts, NULL);
 630                         if (interval)
 631                                 print_interval();
 632                 }
 633         }
 634
 635         t1 = rdclock();
 636
 637         update_stats(&walltime_nsecs_stats, t1 - t0);
 638
 639         if (aggr_mode == AGGR_GLOBAL) {
 640                 evlist__for_each(evsel_list, counter) {
 641                         read_counter_aggr(counter);
 642                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
 643                                              thread_map__nr(evsel_list->threads));
 644                 }
 645         } else {
 646                 evlist__for_each(evsel_list, counter) {
 647                         read_counter(counter);
 648                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
 649                 }
 650         }
 651
 652         return WEXITSTATUS(status);
 653 }
 654
 655 static int run_perf_stat(int argc, const char **argv)
 656 {
 657         int ret;
 658
 659         if (pre_cmd) {
 660                 ret = system(pre_cmd);
 661                 if (ret)
 662                         return ret;
 663         }
 664
 665         if (sync_run)
 666                 sync();
 667
 668         ret = __run_perf_stat(argc, argv);
 669         if (ret)
 670                 return ret;
 671
 672         if (post_cmd) {
 673                 ret = system(post_cmd);
 674                 if (ret)
 675                         return ret;
 676         }
 677
 678         return ret;
 679 }
 680
 681 static void print_noise_pct(double total, double avg)
 682 {
 683         double pct = rel_stddev_stats(total, avg);
 684
 685         if (csv_output)
 686                 fprintf(output, "%s%.2f%%", csv_sep, pct);
 687         else if (pct)
 688                 fprintf(output, "  ( +-%6.2f%% )", pct);
 689 }
 690
 691 static void print_noise(struct perf_evsel *evsel, double avg)
 692 {
 693         struct perf_stat *ps;
 694
 695         if (run_count == 1)
 696                 return;
 697
 698         ps = evsel->priv;
 699         print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
 700 }
 701
 702 static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
 703 {
 704         switch (aggr_mode) {
 705         case AGGR_CORE:
 706                 fprintf(output, "S%d-C%*d%s%*d%s",
 707                         cpu_map__id_to_socket(id),
 708                         csv_output ? 0 : -8,
 709                         cpu_map__id_to_cpu(id),
 710                         csv_sep,
 711                         csv_output ? 0 : 4,
 712                         nr,
 713                         csv_sep);
 714                 break;
 715         case AGGR_SOCKET:
 716                 fprintf(output, "S%*d%s%*d%s",
 717                         csv_output ? 0 : -5,
 718                         id,
 719                         csv_sep,
 720                         csv_output ? 0 : 4,
 721                         nr,
 722                         csv_sep);
 723                         break;
 724         case AGGR_NONE:
 725                 fprintf(output, "CPU%*d%s",
 726                         csv_output ? 0 : -4,
 727                         perf_evsel__cpus(evsel)->map[id], csv_sep);
 728                 break;
 729         case AGGR_GLOBAL:
 730         default:
 731                 break;
 732         }
 733 }
 734
 735 static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 736 {
 737         double msecs = avg / 1e6;
 738         const char *fmt_v, *fmt_n;
 739         char name[25];
 740
 741         fmt_v = csv_output ? "%.6f%s" : "%18.6f%s";
 742         fmt_n = csv_output ? "%s" : "%-25s";
 743
 744         aggr_printout(evsel, id, nr);
 745
 746         scnprintf(name, sizeof(name), "%s%s",
 747                   perf_evsel__name(evsel), csv_output ? "" : " (msec)");
 748
 749         fprintf(output, fmt_v, msecs, csv_sep);
 750
 751         if (csv_output)
 752                 fprintf(output, "%s%s", evsel->unit, csv_sep);
 753         else
 754                 fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep);
 755
 756         fprintf(output, fmt_n, name);
 757
 758         if (evsel->cgrp)
 759                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 760
 761         if (csv_output || interval)
 762                 return;
 763
 764         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
 765                 fprintf(output, " # %8.3f CPUs utilized          ",
 766                         avg / avg_stats(&walltime_nsecs_stats));
 767         else
 768                 fprintf(output, "                                   ");
 769 }
 770
 771 /* used for get_ratio_color() */
 772 enum grc_type {
 773         GRC_STALLED_CYCLES_FE,
 774         GRC_STALLED_CYCLES_BE,
 775         GRC_CACHE_MISSES,
 776         GRC_MAX_NR
 777 };
 778
 779 static const char *get_ratio_color(enum grc_type type, double ratio)
 780 {
 781         static const double grc_table[GRC_MAX_NR][3] = {
 782                 [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
 783                 [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
 784                 [GRC_CACHE_MISSES]      = { 20.0, 10.0, 5.0 },
 785         };
 786         const char *color = PERF_COLOR_NORMAL;
 787
 788         if (ratio > grc_table[type][0])
 789                 color = PERF_COLOR_RED;
 790         else if (ratio > grc_table[type][1])
 791                 color = PERF_COLOR_MAGENTA;
 792         else if (ratio > grc_table[type][2])
 793                 color = PERF_COLOR_YELLOW;
 794
 795         return color;
 796 }
 797
 798 static void print_stalled_cycles_frontend(int cpu,
 799                                           struct perf_evsel *evsel
 800                                           __maybe_unused, double avg)
 801 {
 802         double total, ratio = 0.0;
 803         const char *color;
 804
 805         total = avg_stats(&runtime_cycles_stats[cpu]);
 806
 807         if (total)
 808                 ratio = avg / total * 100.0;
 809
 810         color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
 811
 812         fprintf(output, " #  ");
 813         color_fprintf(output, color, "%6.2f%%", ratio);
 814         fprintf(output, " frontend cycles idle   ");
 815 }
 816
 817 static void print_stalled_cycles_backend(int cpu,
 818                                          struct perf_evsel *evsel
 819                                          __maybe_unused, double avg)
 820 {
 821         double total, ratio = 0.0;
 822         const char *color;
 823
 824         total = avg_stats(&runtime_cycles_stats[cpu]);
 825
 826         if (total)
 827                 ratio = avg / total * 100.0;
 828
 829         color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
 830
 831         fprintf(output, " #  ");
 832         color_fprintf(output, color, "%6.2f%%", ratio);
 833         fprintf(output, " backend  cycles idle   ");
 834 }
 835
 836 static void print_branch_misses(int cpu,
 837                                 struct perf_evsel *evsel __maybe_unused,
 838                                 double avg)
 839 {
 840         double total, ratio = 0.0;
 841         const char *color;
 842
 843         total = avg_stats(&runtime_branches_stats[cpu]);
 844
 845         if (total)
 846                 ratio = avg / total * 100.0;
 847
 848         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 849
 850         fprintf(output, " #  ");
 851         color_fprintf(output, color, "%6.2f%%", ratio);
 852         fprintf(output, " of all branches        ");
 853 }
 854
 855 static void print_l1_dcache_misses(int cpu,
 856                                    struct perf_evsel *evsel __maybe_unused,
 857                                    double avg)
 858 {
 859         double total, ratio = 0.0;
 860         const char *color;
 861
 862         total = avg_stats(&runtime_l1_dcache_stats[cpu]);
 863
 864         if (total)
 865                 ratio = avg / total * 100.0;
 866
 867         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 868
 869         fprintf(output, " #  ");
 870         color_fprintf(output, color, "%6.2f%%", ratio);
 871         fprintf(output, " of all L1-dcache hits  ");
 872 }
 873
 874 static void print_l1_icache_misses(int cpu,
 875                                    struct perf_evsel *evsel __maybe_unused,
 876                                    double avg)
 877 {
 878         double total, ratio = 0.0;
 879         const char *color;
 880
 881         total = avg_stats(&runtime_l1_icache_stats[cpu]);
 882
 883         if (total)
 884                 ratio = avg / total * 100.0;
 885
 886         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 887
 888         fprintf(output, " #  ");
 889         color_fprintf(output, color, "%6.2f%%", ratio);
 890         fprintf(output, " of all L1-icache hits  ");
 891 }
 892
 893 static void print_dtlb_cache_misses(int cpu,
 894                                     struct perf_evsel *evsel __maybe_unused,
 895                                     double avg)
 896 {
 897         double total, ratio = 0.0;
 898         const char *color;
 899
 900         total = avg_stats(&runtime_dtlb_cache_stats[cpu]);
 901
 902         if (total)
 903                 ratio = avg / total * 100.0;
 904
 905         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 906
 907         fprintf(output, " #  ");
 908         color_fprintf(output, color, "%6.2f%%", ratio);
 909         fprintf(output, " of all dTLB cache hits ");
 910 }
 911
 912 static void print_itlb_cache_misses(int cpu,
 913                                     struct perf_evsel *evsel __maybe_unused,
 914                                     double avg)
 915 {
 916         double total, ratio = 0.0;
 917         const char *color;
 918
 919         total = avg_stats(&runtime_itlb_cache_stats[cpu]);
 920
 921         if (total)
 922                 ratio = avg / total * 100.0;
 923
 924         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 925
 926         fprintf(output, " #  ");
 927         color_fprintf(output, color, "%6.2f%%", ratio);
 928         fprintf(output, " of all iTLB cache hits ");
 929 }
 930
 931 static void print_ll_cache_misses(int cpu,
 932                                   struct perf_evsel *evsel __maybe_unused,
 933                                   double avg)
 934 {
 935         double total, ratio = 0.0;
 936         const char *color;
 937
 938         total = avg_stats(&runtime_ll_cache_stats[cpu]);
 939
 940         if (total)
 941                 ratio = avg / total * 100.0;
 942
 943         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 944
 945         fprintf(output, " #  ");
 946         color_fprintf(output, color, "%6.2f%%", ratio);
 947         fprintf(output, " of all LL-cache hits   ");
 948 }
 949
 950 static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 951 {
 952         double total, ratio = 0.0, total2;
 953         double sc =  evsel->scale;
 954         const char *fmt;
 955         int cpu = cpu_map__id_to_cpu(id);
 956
 957         if (csv_output) {
 958                 fmt = sc != 1.0 ?  "%.2f%s" : "%.0f%s";
 959         } else {
 960                 if (big_num)
 961                         fmt = sc != 1.0 ? "%'18.2f%s" : "%'18.0f%s";
 962                 else
 963                         fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s";
 964         }
 965
 966         aggr_printout(evsel, id, nr);
 967
 968         if (aggr_mode == AGGR_GLOBAL)
 969                 cpu = 0;
 970
 971         fprintf(output, fmt, avg, csv_sep);
 972
 973         if (evsel->unit)
 974                 fprintf(output, "%-*s%s",
 975                         csv_output ? 0 : unit_width,
 976                         evsel->unit, csv_sep);
 977
 978         fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel));
 979
 980         if (evsel->cgrp)
 981                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 982
 983         if (csv_output || interval)
 984                 return;
 985
 986         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
 987                 total = avg_stats(&runtime_cycles_stats[cpu]);
 988                 if (total) {
 989                         ratio = avg / total;
 990                         fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
 991                 }
 992                 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
 993                 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
 994
 995                 if (total && avg) {
 996                         ratio = total / avg;
 997                         fprintf(output, "\n");
 998                         if (aggr_mode == AGGR_NONE)
 999                                 fprintf(output, "        ");
1000                         fprintf(output, "                                                  #   %5.2f  stalled cycles per insn", ratio);
1001                 }
1002
1003         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
1004                         runtime_branches_stats[cpu].n != 0) {
1005                 print_branch_misses(cpu, evsel, avg);
1006         } else if (
1007                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
1008                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
1009                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
1010                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
1011                         runtime_l1_dcache_stats[cpu].n != 0) {
1012                 print_l1_dcache_misses(cpu, evsel, avg);
1013         } else if (
1014                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
1015                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
1016                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
1017                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
1018                         runtime_l1_icache_stats[cpu].n != 0) {
1019                 print_l1_icache_misses(cpu, evsel, avg);
1020         } else if (
1021                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
1022                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
1023                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
1024                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
1025                         runtime_dtlb_cache_stats[cpu].n != 0) {
1026                 print_dtlb_cache_misses(cpu, evsel, avg);
1027         } else if (
1028                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
1029                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
1030                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
1031                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
1032                         runtime_itlb_cache_stats[cpu].n != 0) {
1033                 print_itlb_cache_misses(cpu, evsel, avg);
1034         } else if (
1035                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
1036                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
1037                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
1038                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
1039                         runtime_ll_cache_stats[cpu].n != 0) {
1040                 print_ll_cache_misses(cpu, evsel, avg);
1041         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
1042                         runtime_cacherefs_stats[cpu].n != 0) {
1043                 total = avg_stats(&runtime_cacherefs_stats[cpu]);
1044
1045                 if (total)
1046                         ratio = avg * 100 / total;
1047
1048                 fprintf(output, " # %8.3f %% of all cache refs    ", ratio);
1049
1050         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
1051                 print_stalled_cycles_frontend(cpu, evsel, avg);
1052         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
1053                 print_stalled_cycles_backend(cpu, evsel, avg);
1054         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
1055                 total = avg_stats(&runtime_nsecs_stats[cpu]);
1056
1057                 if (total) {
1058                         ratio = avg / total;
1059                         fprintf(output, " # %8.3f GHz                    ", ratio);
1060                 }
1061         } else if (transaction_run &&
1062                    perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) {
1063                 total = avg_stats(&runtime_cycles_stats[cpu]);
1064                 if (total)
1065                         fprintf(output,
1066                                 " #   %5.2f%% transactional cycles   ",
1067                                 100.0 * (avg / total));
1068         } else if (transaction_run &&
1069                    perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX_CP))) {
1070                 total = avg_stats(&runtime_cycles_stats[cpu]);
1071                 total2 = avg_stats(&runtime_cycles_in_tx_stats[cpu]);
1072                 if (total2 < avg)
1073                         total2 = avg;
1074                 if (total)
1075                         fprintf(output,
1076                                 " #   %5.2f%% aborted cycles         ",
1077                                 100.0 * ((total2-avg) / total));
1078         } else if (transaction_run &&
1079                    perf_evsel__cmp(evsel, nth_evsel(T_TRANSACTION_START)) &&
1080                    avg > 0 &&
1081                    runtime_cycles_in_tx_stats[cpu].n != 0) {
1082                 total = avg_stats(&runtime_cycles_in_tx_stats[cpu]);
1083
1084                 if (total)
1085                         ratio = total / avg;
1086
1087                 fprintf(output, " # %8.0f cycles / transaction   ", ratio);
1088         } else if (transaction_run &&
1089                    perf_evsel__cmp(evsel, nth_evsel(T_ELISION_START)) &&
1090                    avg > 0 &&
1091                    runtime_cycles_in_tx_stats[cpu].n != 0) {
1092                 total = avg_stats(&runtime_cycles_in_tx_stats[cpu]);
1093
1094                 if (total)
1095                         ratio = total / avg;
1096
1097                 fprintf(output, " # %8.0f cycles / elision       ", ratio);
1098         } else if (runtime_nsecs_stats[cpu].n != 0) {
1099                 char unit = 'M';
1100
1101                 total = avg_stats(&runtime_nsecs_stats[cpu]);
1102
1103                 if (total)
1104                         ratio = 1000.0 * avg / total;
1105                 if (ratio < 0.001) {
1106                         ratio *= 1000;
1107                         unit = 'K';
1108                 }
1109
1110                 fprintf(output, " # %8.3f %c/sec                  ", ratio, unit);
1111         } else {
1112                 fprintf(output, "                                   ");
1113         }
1114 }
1115
1116 static void print_aggr(char *prefix)
1117 {
1118         struct perf_evsel *counter;
1119         int cpu, cpu2, s, s2, id, nr;
1120         double uval;
1121         u64 ena, run, val;
1122
1123         if (!(aggr_map || aggr_get_id))
1124                 return;
1125
1126         for (s = 0; s < aggr_map->nr; s++) {
1127                 id = aggr_map->map[s];
1128                 evlist__for_each(evsel_list, counter) {
1129                         val = ena = run = 0;
1130                         nr = 0;
1131                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
1132                                 cpu2 = perf_evsel__cpus(counter)->map[cpu];
1133                                 s2 = aggr_get_id(evsel_list->cpus, cpu2);
1134                                 if (s2 != id)
1135                                         continue;
1136                                 val += counter->counts->cpu[cpu].val;
1137                                 ena += counter->counts->cpu[cpu].ena;
1138                                 run += counter->counts->cpu[cpu].run;
1139                                 nr++;
1140                         }
1141                         if (prefix)
1142                                 fprintf(output, "%s", prefix);
1143
1144                         if (run == 0 || ena == 0) {
1145                                 aggr_printout(counter, id, nr);
1146
1147                                 fprintf(output, "%*s%s",
1148                                         csv_output ? 0 : 18,
1149                                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
1150                                         csv_sep);
1151
1152                                 fprintf(output, "%-*s%s",
1153                                         csv_output ? 0 : unit_width,
1154                                         counter->unit, csv_sep);
1155
1156                                 fprintf(output, "%*s",
1157                                         csv_output ? 0 : -25,
1158                                         perf_evsel__name(counter));
1159
1160                                 if (counter->cgrp)
1161                                         fprintf(output, "%s%s",
1162                                                 csv_sep, counter->cgrp->name);
1163
1164                                 fputc('\n', output);
1165                                 continue;
1166                         }
1167                         uval = val * counter->scale;
1168
1169                         if (nsec_counter(counter))
1170                                 nsec_printout(id, nr, counter, uval);
1171                         else
1172                                 abs_printout(id, nr, counter, uval);
1173
1174                         if (!csv_output) {
1175                                 print_noise(counter, 1.0);
1176
1177                                 if (run != ena)
1178                                         fprintf(output, "  (%.2f%%)",
1179                                                 100.0 * run / ena);
1180                         }
1181                         fputc('\n', output);
1182                 }
1183         }
1184 }
1185
1186 /*
1187  * Print out the results of a single counter:
1188  * aggregated counts in system-wide mode
1189  */
1190 static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
1191 {
1192         struct perf_stat *ps = counter->priv;
1193         double avg = avg_stats(&ps->res_stats[0]);
1194         int scaled = counter->counts->scaled;
1195         double uval;
1196
1197         if (prefix)
1198                 fprintf(output, "%s", prefix);
1199
1200         if (scaled == -1) {
1201                 fprintf(output, "%*s%s",
1202                         csv_output ? 0 : 18,
1203                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
1204                         csv_sep);
1205                 fprintf(output, "%-*s%s",
1206                         csv_output ? 0 : unit_width,
1207                         counter->unit, csv_sep);
1208                 fprintf(output, "%*s",
1209                         csv_output ? 0 : -25,
1210                         perf_evsel__name(counter));
1211
1212                 if (counter->cgrp)
1213                         fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
1214
1215                 fputc('\n', output);
1216                 return;
1217         }
1218
1219         uval = avg * counter->scale;
1220
1221         if (nsec_counter(counter))
1222                 nsec_printout(-1, 0, counter, uval);
1223         else
1224                 abs_printout(-1, 0, counter, uval);
1225
1226         print_noise(counter, avg);
1227
1228         if (csv_output) {
1229                 fputc('\n', output);
1230                 return;
1231         }
1232
1233         if (scaled) {
1234                 double avg_enabled, avg_running;
1235
1236                 avg_enabled = avg_stats(&ps->res_stats[1]);
1237                 avg_running = avg_stats(&ps->res_stats[2]);
1238
1239                 fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
1240         }
1241         fprintf(output, "\n");
1242 }
1243
1244 /*
1245  * Print out the results of a single counter:
1246  * does not use aggregated count in system-wide
1247  */
1248 static void print_counter(struct perf_evsel *counter, char *prefix)
1249 {
1250         u64 ena, run, val;
1251         double uval;
1252         int cpu;
1253
1254         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
1255                 val = counter->counts->cpu[cpu].val;
1256                 ena = counter->counts->cpu[cpu].ena;
1257                 run = counter->counts->cpu[cpu].run;
1258
1259                 if (prefix)
1260                         fprintf(output, "%s", prefix);
1261
1262                 if (run == 0 || ena == 0) {
1263                         fprintf(output, "CPU%*d%s%*s%s",
1264                                 csv_output ? 0 : -4,
1265                                 perf_evsel__cpus(counter)->map[cpu], csv_sep,
1266                                 csv_output ? 0 : 18,
1267                                 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
1268                                 csv_sep);
1269
1270                                 fprintf(output, "%-*s%s",
1271                                         csv_output ? 0 : unit_width,
1272                                         counter->unit, csv_sep);
1273
1274                                 fprintf(output, "%*s",
1275                                         csv_output ? 0 : -25,
1276                                         perf_evsel__name(counter));
1277
1278                         if (counter->cgrp)
1279                                 fprintf(output, "%s%s",
1280                                         csv_sep, counter->cgrp->name);
1281
1282                         fputc('\n', output);
1283                         continue;
1284                 }
1285
1286                 uval = val * counter->scale;
1287
1288                 if (nsec_counter(counter))
1289                         nsec_printout(cpu, 0, counter, uval);
1290                 else
1291                         abs_printout(cpu, 0, counter, uval);
1292
1293                 if (!csv_output) {
1294                         print_noise(counter, 1.0);
1295
1296                         if (run != ena)
1297                                 fprintf(output, "  (%.2f%%)",
1298                                         100.0 * run / ena);
1299                 }
1300                 fputc('\n', output);
1301         }
1302 }
1303
1304 static void print_stat(int argc, const char **argv)
1305 {
1306         struct perf_evsel *counter;
1307         int i;
1308
1309         fflush(stdout);
1310
1311         if (!csv_output) {
1312                 fprintf(output, "\n");
1313                 fprintf(output, " Performance counter stats for ");
1314                 if (target.system_wide)
1315                         fprintf(output, "\'system wide");
1316                 else if (target.cpu_list)
1317                         fprintf(output, "\'CPU(s) %s", target.cpu_list);
1318                 else if (!target__has_task(&target)) {
1319                         fprintf(output, "\'%s", argv[0]);
1320                         for (i = 1; i < argc; i++)
1321                                 fprintf(output, " %s", argv[i]);
1322                 } else if (target.pid)
1323                         fprintf(output, "process id \'%s", target.pid);
1324                 else
1325                         fprintf(output, "thread id \'%s", target.tid);
1326
1327                 fprintf(output, "\'");
1328                 if (run_count > 1)
1329                         fprintf(output, " (%d runs)", run_count);
1330                 fprintf(output, ":\n\n");
1331         }
1332
1333         switch (aggr_mode) {
1334         case AGGR_CORE:
1335         case AGGR_SOCKET:
1336                 print_aggr(NULL);
1337                 break;
1338         case AGGR_GLOBAL:
1339                 evlist__for_each(evsel_list, counter)
1340                         print_counter_aggr(counter, NULL);
1341                 break;
1342         case AGGR_NONE:
1343                 evlist__for_each(evsel_list, counter)
1344                         print_counter(counter, NULL);
1345                 break;
1346         default:
1347                 break;
1348         }
1349
1350         if (!csv_output) {
1351                 if (!null_run)
1352                         fprintf(output, "\n");
1353                 fprintf(output, " %17.9f seconds time elapsed",
1354                                 avg_stats(&walltime_nsecs_stats)/1e9);
1355                 if (run_count > 1) {
1356                         fprintf(output, "                                        ");
1357                         print_noise_pct(stddev_stats(&walltime_nsecs_stats),
1358                                         avg_stats(&walltime_nsecs_stats));
1359                 }
1360                 fprintf(output, "\n\n");
1361         }
1362 }
1363
1364 static volatile int signr = -1;
1365
1366 static void skip_signal(int signo)
1367 {
1368         if ((child_pid == -1) || interval)
1369                 done = 1;
1370
1371         signr = signo;
1372         /*
1373          * render child_pid harmless
1374          * won't send SIGTERM to a random
1375          * process in case of race condition
1376          * and fast PID recycling
1377          */
1378         child_pid = -1;
1379 }
1380
1381 static void sig_atexit(void)
1382 {
1383         sigset_t set, oset;
1384
1385         /*
1386          * avoid race condition with SIGCHLD handler
1387          * in skip_signal() which is modifying child_pid
1388          * goal is to avoid send SIGTERM to a random
1389          * process
1390          */
1391         sigemptyset(&set);
1392         sigaddset(&set, SIGCHLD);
1393         sigprocmask(SIG_BLOCK, &set, &oset);
1394
1395         if (child_pid != -1)
1396                 kill(child_pid, SIGTERM);
1397
1398         sigprocmask(SIG_SETMASK, &oset, NULL);
1399
1400         if (signr == -1)
1401                 return;
1402
1403         signal(signr, SIG_DFL);
1404         kill(getpid(), signr);
1405 }
1406
1407 static int stat__set_big_num(const struct option *opt __maybe_unused,
1408                              const char *s __maybe_unused, int unset)
1409 {
1410         big_num_opt = unset ? 0 : 1;
1411         return 0;
1412 }
1413
1414 static int perf_stat_init_aggr_mode(void)
1415 {
1416         switch (aggr_mode) {
1417         case AGGR_SOCKET:
1418                 if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
1419                         perror("cannot build socket map");
1420                         return -1;
1421                 }
1422                 aggr_get_id = cpu_map__get_socket;
1423                 break;
1424         case AGGR_CORE:
1425                 if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
1426                         perror("cannot build core map");
1427                         return -1;
1428                 }
1429                 aggr_get_id = cpu_map__get_core;
1430                 break;
1431         case AGGR_NONE:
1432         case AGGR_GLOBAL:
1433         default:
1434                 break;
1435         }
1436         return 0;
1437 }
1438
1439 static int setup_events(const char * const *attrs, unsigned len)
1440 {
1441         unsigned i;
1442
1443         for (i = 0; i < len; i++) {
1444                 if (parse_events(evsel_list, attrs[i]))
1445                         return -1;
1446         }
1447         return 0;
1448 }
1449
1450 /*
1451  * Add default attributes, if there were no attributes specified or
1452  * if -d/--detailed, -d -d or -d -d -d is used:
1453  */
1454 static int add_default_attributes(void)
1455 {
1456         struct perf_event_attr default_attrs[] = {
1457
1458   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
1459   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
1460   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
1461   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
1462
1463   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
1464   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
1465   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND  },
1466   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
1467   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
1468   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
1469
1470 };
1471
1472 /*
1473  * Detailed stats (-d), covering the L1 and last level data caches:
1474  */
1475         struct perf_event_attr detailed_attrs[] = {
1476
1477   { .type = PERF_TYPE_HW_CACHE,
1478     .config =
1479          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1480         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1481         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1482
1483   { .type = PERF_TYPE_HW_CACHE,
1484     .config =
1485          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1486         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1487         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1488
1489   { .type = PERF_TYPE_HW_CACHE,
1490     .config =
1491          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1492         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1493         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1494
1495   { .type = PERF_TYPE_HW_CACHE,
1496     .config =
1497          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1498         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1499         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1500 };
1501
1502 /*
1503  * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1504  */
1505         struct perf_event_attr very_detailed_attrs[] = {
1506
1507   { .type = PERF_TYPE_HW_CACHE,
1508     .config =
1509          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1510         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1511         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1512
1513   { .type = PERF_TYPE_HW_CACHE,
1514     .config =
1515          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1516         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1517         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1518
1519   { .type = PERF_TYPE_HW_CACHE,
1520     .config =
1521          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1522         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1523         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1524
1525   { .type = PERF_TYPE_HW_CACHE,
1526     .config =
1527          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1528         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1529         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1530
1531   { .type = PERF_TYPE_HW_CACHE,
1532     .config =
1533          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1534         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1535         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1536
1537   { .type = PERF_TYPE_HW_CACHE,
1538     .config =
1539          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1540         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1541         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1542
1543 };
1544
1545 /*
1546  * Very, very detailed stats (-d -d -d), adding prefetch events:
1547  */
1548         struct perf_event_attr very_very_detailed_attrs[] = {
1549
1550   { .type = PERF_TYPE_HW_CACHE,
1551     .config =
1552          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1553         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1554         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1555
1556   { .type = PERF_TYPE_HW_CACHE,
1557     .config =
1558          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1559         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1560         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1561 };
1562
1563         /* Set attrs if no event is selected and !null_run: */
1564         if (null_run)
1565                 return 0;
1566
1567         if (transaction_run) {
1568                 int err;
1569                 if (pmu_have_event("cpu", "cycles-ct") &&
1570                     pmu_have_event("cpu", "el-start"))
1571                         err = setup_events(transaction_attrs,
1572                                         ARRAY_SIZE(transaction_attrs));
1573                 else
1574                         err = setup_events(transaction_limited_attrs,
1575                                  ARRAY_SIZE(transaction_limited_attrs));
1576                 if (err < 0) {
1577                         fprintf(stderr, "Cannot set up transaction events\n");
1578                         return -1;
1579                 }
1580                 return 0;
1581         }
1582
1583         if (!evsel_list->nr_entries) {
1584                 if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0)
1585                         return -1;
1586         }
1587
1588         /* Detailed events get appended to the event list: */
1589
1590         if (detailed_run <  1)
1591                 return 0;
1592
1593         /* Append detailed run extra attributes: */
1594         if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
1595                 return -1;
1596
1597         if (detailed_run < 2)
1598                 return 0;
1599
1600         /* Append very detailed run extra attributes: */
1601         if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
1602                 return -1;
1603
1604         if (detailed_run < 3)
1605                 return 0;
1606
1607         /* Append very, very detailed run extra attributes: */
1608         return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
1609 }
1610
1611 int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
1612 {
1613         bool append_file = false;
1614         int output_fd = 0;
1615         const char *output_name = NULL;
1616         const struct option options[] = {
1617         OPT_BOOLEAN('T', "transaction", &transaction_run,
1618                     "hardware transaction statistics"),
1619         OPT_CALLBACK('e', "event", &evsel_list, "event",
1620                      "event selector. use 'perf list' to list available events",
1621                      parse_events_option),
1622         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
1623                      "event filter", parse_filter),
1624         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
1625                     "child tasks do not inherit counters"),
1626         OPT_STRING('p', "pid", &target.pid, "pid",
1627                    "stat events on existing process id"),
1628         OPT_STRING('t', "tid", &target.tid, "tid",
1629                    "stat events on existing thread id"),
1630         OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
1631                     "system-wide collection from all CPUs"),
1632         OPT_BOOLEAN('g', "group", &group,
1633                     "put the counters into a counter group"),
1634         OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"),
1635         OPT_INCR('v', "verbose", &verbose,
1636                     "be more verbose (show counter open errors, etc)"),
1637         OPT_INTEGER('r', "repeat", &run_count,
1638                     "repeat command and print average + stddev (max: 100, forever: 0)"),
1639         OPT_BOOLEAN('n', "null", &null_run,
1640                     "null run - dont start any counters"),
1641         OPT_INCR('d', "detailed", &detailed_run,
1642                     "detailed run - start a lot of events"),
1643         OPT_BOOLEAN('S', "sync", &sync_run,
1644                     "call sync() before starting a run"),
1645         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
1646                            "print large numbers with thousands\' separators",
1647                            stat__set_big_num),
1648         OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
1649                     "list of cpus to monitor in system-wide"),
1650         OPT_SET_UINT('A', "no-aggr", &aggr_mode,
1651                     "disable CPU count aggregation", AGGR_NONE),
1652         OPT_STRING('x', "field-separator", &csv_sep, "separator",
1653                    "print counts with custom separator"),
1654         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1655                      "monitor event in cgroup name only", parse_cgroups),
1656         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1657         OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
1658         OPT_INTEGER(0, "log-fd", &output_fd,
1659                     "log output to fd, instead of stderr"),
1660         OPT_STRING(0, "pre", &pre_cmd, "command",
1661                         "command to run prior to the measured command"),
1662         OPT_STRING(0, "post", &post_cmd, "command",
1663                         "command to run after to the measured command"),
1664         OPT_UINTEGER('I', "interval-print", &interval,
1665                     "print counts at regular interval in ms (>= 100)"),
1666         OPT_SET_UINT(0, "per-socket", &aggr_mode,
1667                      "aggregate counts per processor socket", AGGR_SOCKET),
1668         OPT_SET_UINT(0, "per-core", &aggr_mode,
1669                      "aggregate counts per physical processor core", AGGR_CORE),
1670         OPT_UINTEGER('D', "delay", &initial_delay,
1671                      "ms to wait before starting measurement after program start"),
1672         OPT_END()
1673         };
1674         const char * const stat_usage[] = {
1675                 "perf stat [<options>] [<command>]",
1676                 NULL
1677         };
1678         int status = -EINVAL, run_idx;
1679         const char *mode;
1680
1681         setlocale(LC_ALL, "");
1682
1683         evsel_list = perf_evlist__new();
1684         if (evsel_list == NULL)
1685                 return -ENOMEM;
1686
1687         argc = parse_options(argc, argv, options, stat_usage,
1688                 PARSE_OPT_STOP_AT_NON_OPTION);
1689
1690         output = stderr;
1691         if (output_name && strcmp(output_name, "-"))
1692                 output = NULL;
1693
1694         if (output_name && output_fd) {
1695                 fprintf(stderr, "cannot use both --output and --log-fd\n");
1696                 parse_options_usage(stat_usage, options, "o", 1);
1697                 parse_options_usage(NULL, options, "log-fd", 0);
1698                 goto out;
1699         }
1700
1701         if (output_fd < 0) {
1702                 fprintf(stderr, "argument to --log-fd must be a > 0\n");
1703                 parse_options_usage(stat_usage, options, "log-fd", 0);
1704                 goto out;
1705         }
1706
1707         if (!output) {
1708                 struct timespec tm;
1709                 mode = append_file ? "a" : "w";
1710
1711                 output = fopen(output_name, mode);
1712                 if (!output) {
1713                         perror("failed to create output file");
1714                         return -1;
1715                 }
1716                 clock_gettime(CLOCK_REALTIME, &tm);
1717                 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
1718         } else if (output_fd > 0) {
1719                 mode = append_file ? "a" : "w";
1720                 output = fdopen(output_fd, mode);
1721                 if (!output) {
1722                         perror("Failed opening logfd");
1723                         return -errno;
1724                 }
1725         }
1726
1727         if (csv_sep) {
1728                 csv_output = true;
1729                 if (!strcmp(csv_sep, "\\t"))
1730                         csv_sep = "\t";
1731         } else
1732                 csv_sep = DEFAULT_SEPARATOR;
1733
1734         /*
1735          * let the spreadsheet do the pretty-printing
1736          */
1737         if (csv_output) {
1738                 /* User explicitly passed -B? */
1739                 if (big_num_opt == 1) {
1740                         fprintf(stderr, "-B option not supported with -x\n");
1741                         parse_options_usage(stat_usage, options, "B", 1);
1742                         parse_options_usage(NULL, options, "x", 1);
1743                         goto out;
1744                 } else /* Nope, so disable big number formatting */
1745                         big_num = false;
1746         } else if (big_num_opt == 0) /* User passed --no-big-num */
1747                 big_num = false;
1748
1749         if (!argc && target__none(&target))
1750                 usage_with_options(stat_usage, options);
1751
1752         if (run_count < 0) {
1753                 pr_err("Run count must be a positive number\n");
1754                 parse_options_usage(stat_usage, options, "r", 1);
1755                 goto out;
1756         } else if (run_count == 0) {
1757                 forever = true;
1758                 run_count = 1;
1759         }
1760
1761         /* no_aggr, cgroup are for system-wide only */
1762         if ((aggr_mode != AGGR_GLOBAL || nr_cgroups) &&
1763             !target__has_cpu(&target)) {
1764                 fprintf(stderr, "both cgroup and no-aggregation "
1765                         "modes only available in system-wide mode\n");
1766
1767                 parse_options_usage(stat_usage, options, "G", 1);
1768                 parse_options_usage(NULL, options, "A", 1);
1769                 parse_options_usage(NULL, options, "a", 1);
1770                 goto out;
1771         }
1772
1773         if (add_default_attributes())
1774                 goto out;
1775
1776         target__validate(&target);
1777
1778         if (perf_evlist__create_maps(evsel_list, &target) < 0) {
1779                 if (target__has_task(&target)) {
1780                         pr_err("Problems finding threads of monitor\n");
1781                         parse_options_usage(stat_usage, options, "p", 1);
1782                         parse_options_usage(NULL, options, "t", 1);
1783                 } else if (target__has_cpu(&target)) {
1784                         perror("failed to parse CPUs map");
1785                         parse_options_usage(stat_usage, options, "C", 1);
1786                         parse_options_usage(NULL, options, "a", 1);
1787                 }
1788                 goto out;
1789         }
1790         if (interval && interval < 100) {
1791                 pr_err("print interval must be >= 100ms\n");
1792                 parse_options_usage(stat_usage, options, "I", 1);
1793                 goto out;
1794         }
1795
1796         if (perf_evlist__alloc_stats(evsel_list, interval))
1797                 goto out;
1798
1799         if (perf_stat_init_aggr_mode())
1800                 goto out;
1801
1802         /*
1803          * We dont want to block the signals - that would cause
1804          * child tasks to inherit that and Ctrl-C would not work.
1805          * What we want is for Ctrl-C to work in the exec()-ed
1806          * task, but being ignored by perf stat itself:
1807          */
1808         atexit(sig_atexit);
1809         if (!forever)
1810                 signal(SIGINT,  skip_signal);
1811         signal(SIGCHLD, skip_signal);
1812         signal(SIGALRM, skip_signal);
1813         signal(SIGABRT, skip_signal);
1814
1815         status = 0;
1816         for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
1817                 if (run_count != 1 && verbose)
1818                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1819                                 run_idx + 1);
1820
1821                 status = run_perf_stat(argc, argv);
1822                 if (forever && status != -1) {
1823                         print_stat(argc, argv);
1824                         perf_stat__reset_stats(evsel_list);
1825                 }
1826         }
1827
1828         if (!forever && status != -1 && !interval)
1829                 print_stat(argc, argv);
1830
1831         perf_evlist__free_stats(evsel_list);
1832 out:
1833         perf_evlist__delete(evsel_list);
1834         return status;
1835 }