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