69fe6ed89627a1dc6425101cc1f733e8277d4ab5
[linux-3.10.git] / 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/event.h"
50 #include "util/evlist.h"
51 #include "util/evsel.h"
52 #include "util/debug.h"
53 #include "util/color.h"
54 #include "util/stat.h"
55 #include "util/header.h"
56 #include "util/cpumap.h"
57 #include "util/thread.h"
58 #include "util/thread_map.h"
59
60 #include <stdlib.h>
61 #include <sys/prctl.h>
62 #include <locale.h>
63
64 #define DEFAULT_SEPARATOR       " "
65 #define CNTR_NOT_SUPPORTED      "<not supported>"
66 #define CNTR_NOT_COUNTED        "<not counted>"
67
68 static void print_stat(int argc, const char **argv);
69 static void print_counter_aggr(struct perf_evsel *counter, char *prefix);
70 static void print_counter(struct perf_evsel *counter, char *prefix);
71 static void print_aggr_socket(char *prefix);
72
73 static struct perf_evlist       *evsel_list;
74
75 static struct perf_target       target = {
76         .uid    = UINT_MAX,
77 };
78
79 static int                      run_count                       =  1;
80 static bool                     no_inherit                      = false;
81 static bool                     scale                           =  true;
82 static bool                     no_aggr                         = false;
83 static bool                     aggr_socket                     = false;
84 static pid_t                    child_pid                       = -1;
85 static bool                     null_run                        =  false;
86 static int                      detailed_run                    =  0;
87 static bool                     big_num                         =  true;
88 static int                      big_num_opt                     =  -1;
89 static const char               *csv_sep                        = NULL;
90 static bool                     csv_output                      = false;
91 static bool                     group                           = false;
92 static FILE                     *output                         = NULL;
93 static const char               *pre_cmd                        = NULL;
94 static const char               *post_cmd                       = NULL;
95 static bool                     sync_run                        = false;
96 static unsigned int             interval                        = 0;
97 static struct timespec          ref_time;
98 static struct cpu_map           *sock_map;
99
100 static volatile int done = 0;
101
102 struct perf_stat {
103         struct stats      res_stats[3];
104 };
105
106 static inline void diff_timespec(struct timespec *r, struct timespec *a,
107                                  struct timespec *b)
108 {
109         r->tv_sec = a->tv_sec - b->tv_sec;
110         if (a->tv_nsec < b->tv_nsec) {
111                 r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
112                 r->tv_sec--;
113         } else {
114                 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
115         }
116 }
117
118 static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
119 {
120         return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
121 }
122
123 static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
124 {
125         return perf_evsel__cpus(evsel)->nr;
126 }
127
128 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
129 {
130         evsel->priv = zalloc(sizeof(struct perf_stat));
131         return evsel->priv == NULL ? -ENOMEM : 0;
132 }
133
134 static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
135 {
136         free(evsel->priv);
137         evsel->priv = NULL;
138 }
139
140 static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel)
141 {
142         void *addr;
143         size_t sz;
144
145         sz = sizeof(*evsel->counts) +
146              (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values));
147
148         addr = zalloc(sz);
149         if (!addr)
150                 return -ENOMEM;
151
152         evsel->prev_raw_counts =  addr;
153
154         return 0;
155 }
156
157 static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
158 {
159         free(evsel->prev_raw_counts);
160         evsel->prev_raw_counts = NULL;
161 }
162
163 static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
164 static struct stats runtime_cycles_stats[MAX_NR_CPUS];
165 static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
166 static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
167 static struct stats runtime_branches_stats[MAX_NR_CPUS];
168 static struct stats runtime_cacherefs_stats[MAX_NR_CPUS];
169 static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS];
170 static struct stats runtime_l1_icache_stats[MAX_NR_CPUS];
171 static struct stats runtime_ll_cache_stats[MAX_NR_CPUS];
172 static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
173 static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
174 static struct stats walltime_nsecs_stats;
175
176 static int create_perf_stat_counter(struct perf_evsel *evsel)
177 {
178         struct perf_event_attr *attr = &evsel->attr;
179
180         if (scale)
181                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
182                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
183
184         attr->inherit = !no_inherit;
185
186         if (perf_target__has_cpu(&target))
187                 return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
188
189         if (!perf_target__has_task(&target) &&
190             perf_evsel__is_group_leader(evsel)) {
191                 attr->disabled = 1;
192                 attr->enable_on_exec = 1;
193         }
194
195         return perf_evsel__open_per_thread(evsel, evsel_list->threads);
196 }
197
198 /*
199  * Does the counter have nsecs as a unit?
200  */
201 static inline int nsec_counter(struct perf_evsel *evsel)
202 {
203         if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
204             perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
205                 return 1;
206
207         return 0;
208 }
209
210 /*
211  * Update various tracking values we maintain to print
212  * more semantic information such as miss/hit ratios,
213  * instruction rates, etc:
214  */
215 static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
216 {
217         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
218                 update_stats(&runtime_nsecs_stats[0], count[0]);
219         else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
220                 update_stats(&runtime_cycles_stats[0], count[0]);
221         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
222                 update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
223         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
224                 update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
225         else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
226                 update_stats(&runtime_branches_stats[0], count[0]);
227         else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
228                 update_stats(&runtime_cacherefs_stats[0], count[0]);
229         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
230                 update_stats(&runtime_l1_dcache_stats[0], count[0]);
231         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
232                 update_stats(&runtime_l1_icache_stats[0], count[0]);
233         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
234                 update_stats(&runtime_ll_cache_stats[0], count[0]);
235         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
236                 update_stats(&runtime_dtlb_cache_stats[0], count[0]);
237         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
238                 update_stats(&runtime_itlb_cache_stats[0], count[0]);
239 }
240
241 /*
242  * Read out the results of a single counter:
243  * aggregate counts across CPUs in system-wide mode
244  */
245 static int read_counter_aggr(struct perf_evsel *counter)
246 {
247         struct perf_stat *ps = counter->priv;
248         u64 *count = counter->counts->aggr.values;
249         int i;
250
251         if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter),
252                                thread_map__nr(evsel_list->threads), scale) < 0)
253                 return -1;
254
255         for (i = 0; i < 3; i++)
256                 update_stats(&ps->res_stats[i], count[i]);
257
258         if (verbose) {
259                 fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
260                         perf_evsel__name(counter), count[0], count[1], count[2]);
261         }
262
263         /*
264          * Save the full runtime - to allow normalization during printout:
265          */
266         update_shadow_stats(counter, count);
267
268         return 0;
269 }
270
271 /*
272  * Read out the results of a single counter:
273  * do not aggregate counts across CPUs in system-wide mode
274  */
275 static int read_counter(struct perf_evsel *counter)
276 {
277         u64 *count;
278         int cpu;
279
280         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
281                 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
282                         return -1;
283
284                 count = counter->counts->cpu[cpu].values;
285
286                 update_shadow_stats(counter, count);
287         }
288
289         return 0;
290 }
291
292 static void print_interval(void)
293 {
294         static int num_print_interval;
295         struct perf_evsel *counter;
296         struct perf_stat *ps;
297         struct timespec ts, rs;
298         char prefix[64];
299
300         if (no_aggr) {
301                 list_for_each_entry(counter, &evsel_list->entries, node) {
302                         ps = counter->priv;
303                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
304                         read_counter(counter);
305                 }
306         } else {
307                 list_for_each_entry(counter, &evsel_list->entries, node) {
308                         ps = counter->priv;
309                         memset(ps->res_stats, 0, sizeof(ps->res_stats));
310                         read_counter_aggr(counter);
311                 }
312         }
313         clock_gettime(CLOCK_MONOTONIC, &ts);
314         diff_timespec(&rs, &ts, &ref_time);
315         sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep);
316
317         if (num_print_interval == 0 && !csv_output) {
318                 if (aggr_socket)
319                         fprintf(output, "#           time socket cpus             counts events\n");
320                 else if (no_aggr)
321                         fprintf(output, "#           time CPU                 counts events\n");
322                 else
323                         fprintf(output, "#           time             counts events\n");
324         }
325
326         if (++num_print_interval == 25)
327                 num_print_interval = 0;
328
329         if (aggr_socket)
330                 print_aggr_socket(prefix);
331         else if (no_aggr) {
332                 list_for_each_entry(counter, &evsel_list->entries, node)
333                         print_counter(counter, prefix);
334         } else {
335                 list_for_each_entry(counter, &evsel_list->entries, node)
336                         print_counter_aggr(counter, prefix);
337         }
338 }
339
340 static int __run_perf_stat(int argc, const char **argv)
341 {
342         char msg[512];
343         unsigned long long t0, t1;
344         struct perf_evsel *counter;
345         struct timespec ts;
346         int status = 0;
347         const bool forks = (argc > 0);
348
349         if (interval) {
350                 ts.tv_sec  = interval / 1000;
351                 ts.tv_nsec = (interval % 1000) * 1000000;
352         } else {
353                 ts.tv_sec  = 1;
354                 ts.tv_nsec = 0;
355         }
356
357         if (aggr_socket
358             && cpu_map__build_socket_map(evsel_list->cpus, &sock_map)) {
359                 perror("cannot build socket map");
360                 return -1;
361         }
362
363         if (forks) {
364                 if (perf_evlist__prepare_workload(evsel_list, &target, argv,
365                                                   false, false) < 0) {
366                         perror("failed to prepare workload");
367                         return -1;
368                 }
369         }
370
371         if (group)
372                 perf_evlist__set_leader(evsel_list);
373
374         list_for_each_entry(counter, &evsel_list->entries, node) {
375                 if (create_perf_stat_counter(counter) < 0) {
376                         /*
377                          * PPC returns ENXIO for HW counters until 2.6.37
378                          * (behavior changed with commit b0a873e).
379                          */
380                         if (errno == EINVAL || errno == ENOSYS ||
381                             errno == ENOENT || errno == EOPNOTSUPP ||
382                             errno == ENXIO) {
383                                 if (verbose)
384                                         ui__warning("%s event is not supported by the kernel.\n",
385                                                     perf_evsel__name(counter));
386                                 counter->supported = false;
387                                 continue;
388                         }
389
390                         perf_evsel__open_strerror(counter, &target,
391                                                   errno, msg, sizeof(msg));
392                         ui__error("%s\n", msg);
393
394                         if (child_pid != -1)
395                                 kill(child_pid, SIGTERM);
396
397                         return -1;
398                 }
399                 counter->supported = true;
400         }
401
402         if (perf_evlist__apply_filters(evsel_list)) {
403                 error("failed to set filter with %d (%s)\n", errno,
404                         strerror(errno));
405                 return -1;
406         }
407
408         /*
409          * Enable counters and exec the command:
410          */
411         t0 = rdclock();
412         clock_gettime(CLOCK_MONOTONIC, &ref_time);
413
414         if (forks) {
415                 perf_evlist__start_workload(evsel_list);
416
417                 if (interval) {
418                         while (!waitpid(child_pid, &status, WNOHANG)) {
419                                 nanosleep(&ts, NULL);
420                                 print_interval();
421                         }
422                 }
423                 wait(&status);
424                 if (WIFSIGNALED(status))
425                         psignal(WTERMSIG(status), argv[0]);
426         } else {
427                 while (!done) {
428                         nanosleep(&ts, NULL);
429                         if (interval)
430                                 print_interval();
431                 }
432         }
433
434         t1 = rdclock();
435
436         update_stats(&walltime_nsecs_stats, t1 - t0);
437
438         if (no_aggr) {
439                 list_for_each_entry(counter, &evsel_list->entries, node) {
440                         read_counter(counter);
441                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
442                 }
443         } else {
444                 list_for_each_entry(counter, &evsel_list->entries, node) {
445                         read_counter_aggr(counter);
446                         perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
447                                              thread_map__nr(evsel_list->threads));
448                 }
449         }
450
451         return WEXITSTATUS(status);
452 }
453
454 static int run_perf_stat(int argc __maybe_unused, const char **argv)
455 {
456         int ret;
457
458         if (pre_cmd) {
459                 ret = system(pre_cmd);
460                 if (ret)
461                         return ret;
462         }
463
464         if (sync_run)
465                 sync();
466
467         ret = __run_perf_stat(argc, argv);
468         if (ret)
469                 return ret;
470
471         if (post_cmd) {
472                 ret = system(post_cmd);
473                 if (ret)
474                         return ret;
475         }
476
477         return ret;
478 }
479
480 static void print_noise_pct(double total, double avg)
481 {
482         double pct = rel_stddev_stats(total, avg);
483
484         if (csv_output)
485                 fprintf(output, "%s%.2f%%", csv_sep, pct);
486         else if (pct)
487                 fprintf(output, "  ( +-%6.2f%% )", pct);
488 }
489
490 static void print_noise(struct perf_evsel *evsel, double avg)
491 {
492         struct perf_stat *ps;
493
494         if (run_count == 1)
495                 return;
496
497         ps = evsel->priv;
498         print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
499 }
500
501 static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
502 {
503         double msecs = avg / 1e6;
504         char cpustr[16] = { '\0', };
505         const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-25s";
506
507         if (aggr_socket)
508                 sprintf(cpustr, "S%*d%s%*d%s",
509                         csv_output ? 0 : -5,
510                         cpu,
511                         csv_sep,
512                         csv_output ? 0 : 4,
513                         nr,
514                         csv_sep);
515         else if (no_aggr)
516                 sprintf(cpustr, "CPU%*d%s",
517                         csv_output ? 0 : -4,
518                         perf_evsel__cpus(evsel)->map[cpu], csv_sep);
519
520         fprintf(output, fmt, cpustr, msecs, csv_sep, perf_evsel__name(evsel));
521
522         if (evsel->cgrp)
523                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
524
525         if (csv_output || interval)
526                 return;
527
528         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
529                 fprintf(output, " # %8.3f CPUs utilized          ",
530                         avg / avg_stats(&walltime_nsecs_stats));
531         else
532                 fprintf(output, "                                   ");
533 }
534
535 /* used for get_ratio_color() */
536 enum grc_type {
537         GRC_STALLED_CYCLES_FE,
538         GRC_STALLED_CYCLES_BE,
539         GRC_CACHE_MISSES,
540         GRC_MAX_NR
541 };
542
543 static const char *get_ratio_color(enum grc_type type, double ratio)
544 {
545         static const double grc_table[GRC_MAX_NR][3] = {
546                 [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
547                 [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
548                 [GRC_CACHE_MISSES]      = { 20.0, 10.0, 5.0 },
549         };
550         const char *color = PERF_COLOR_NORMAL;
551
552         if (ratio > grc_table[type][0])
553                 color = PERF_COLOR_RED;
554         else if (ratio > grc_table[type][1])
555                 color = PERF_COLOR_MAGENTA;
556         else if (ratio > grc_table[type][2])
557                 color = PERF_COLOR_YELLOW;
558
559         return color;
560 }
561
562 static void print_stalled_cycles_frontend(int cpu,
563                                           struct perf_evsel *evsel
564                                           __maybe_unused, double avg)
565 {
566         double total, ratio = 0.0;
567         const char *color;
568
569         total = avg_stats(&runtime_cycles_stats[cpu]);
570
571         if (total)
572                 ratio = avg / total * 100.0;
573
574         color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
575
576         fprintf(output, " #  ");
577         color_fprintf(output, color, "%6.2f%%", ratio);
578         fprintf(output, " frontend cycles idle   ");
579 }
580
581 static void print_stalled_cycles_backend(int cpu,
582                                          struct perf_evsel *evsel
583                                          __maybe_unused, double avg)
584 {
585         double total, ratio = 0.0;
586         const char *color;
587
588         total = avg_stats(&runtime_cycles_stats[cpu]);
589
590         if (total)
591                 ratio = avg / total * 100.0;
592
593         color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
594
595         fprintf(output, " #  ");
596         color_fprintf(output, color, "%6.2f%%", ratio);
597         fprintf(output, " backend  cycles idle   ");
598 }
599
600 static void print_branch_misses(int cpu,
601                                 struct perf_evsel *evsel __maybe_unused,
602                                 double avg)
603 {
604         double total, ratio = 0.0;
605         const char *color;
606
607         total = avg_stats(&runtime_branches_stats[cpu]);
608
609         if (total)
610                 ratio = avg / total * 100.0;
611
612         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
613
614         fprintf(output, " #  ");
615         color_fprintf(output, color, "%6.2f%%", ratio);
616         fprintf(output, " of all branches        ");
617 }
618
619 static void print_l1_dcache_misses(int cpu,
620                                    struct perf_evsel *evsel __maybe_unused,
621                                    double avg)
622 {
623         double total, ratio = 0.0;
624         const char *color;
625
626         total = avg_stats(&runtime_l1_dcache_stats[cpu]);
627
628         if (total)
629                 ratio = avg / total * 100.0;
630
631         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
632
633         fprintf(output, " #  ");
634         color_fprintf(output, color, "%6.2f%%", ratio);
635         fprintf(output, " of all L1-dcache hits  ");
636 }
637
638 static void print_l1_icache_misses(int cpu,
639                                    struct perf_evsel *evsel __maybe_unused,
640                                    double avg)
641 {
642         double total, ratio = 0.0;
643         const char *color;
644
645         total = avg_stats(&runtime_l1_icache_stats[cpu]);
646
647         if (total)
648                 ratio = avg / total * 100.0;
649
650         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
651
652         fprintf(output, " #  ");
653         color_fprintf(output, color, "%6.2f%%", ratio);
654         fprintf(output, " of all L1-icache hits  ");
655 }
656
657 static void print_dtlb_cache_misses(int cpu,
658                                     struct perf_evsel *evsel __maybe_unused,
659                                     double avg)
660 {
661         double total, ratio = 0.0;
662         const char *color;
663
664         total = avg_stats(&runtime_dtlb_cache_stats[cpu]);
665
666         if (total)
667                 ratio = avg / total * 100.0;
668
669         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
670
671         fprintf(output, " #  ");
672         color_fprintf(output, color, "%6.2f%%", ratio);
673         fprintf(output, " of all dTLB cache hits ");
674 }
675
676 static void print_itlb_cache_misses(int cpu,
677                                     struct perf_evsel *evsel __maybe_unused,
678                                     double avg)
679 {
680         double total, ratio = 0.0;
681         const char *color;
682
683         total = avg_stats(&runtime_itlb_cache_stats[cpu]);
684
685         if (total)
686                 ratio = avg / total * 100.0;
687
688         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
689
690         fprintf(output, " #  ");
691         color_fprintf(output, color, "%6.2f%%", ratio);
692         fprintf(output, " of all iTLB cache hits ");
693 }
694
695 static void print_ll_cache_misses(int cpu,
696                                   struct perf_evsel *evsel __maybe_unused,
697                                   double avg)
698 {
699         double total, ratio = 0.0;
700         const char *color;
701
702         total = avg_stats(&runtime_ll_cache_stats[cpu]);
703
704         if (total)
705                 ratio = avg / total * 100.0;
706
707         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
708
709         fprintf(output, " #  ");
710         color_fprintf(output, color, "%6.2f%%", ratio);
711         fprintf(output, " of all LL-cache hits   ");
712 }
713
714 static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
715 {
716         double total, ratio = 0.0;
717         char cpustr[16] = { '\0', };
718         const char *fmt;
719
720         if (csv_output)
721                 fmt = "%s%.0f%s%s";
722         else if (big_num)
723                 fmt = "%s%'18.0f%s%-25s";
724         else
725                 fmt = "%s%18.0f%s%-25s";
726
727         if (aggr_socket)
728                 sprintf(cpustr, "S%*d%s%*d%s",
729                         csv_output ? 0 : -5,
730                         cpu,
731                         csv_sep,
732                         csv_output ? 0 : 4,
733                         nr,
734                         csv_sep);
735         else if (no_aggr)
736                 sprintf(cpustr, "CPU%*d%s",
737                         csv_output ? 0 : -4,
738                         perf_evsel__cpus(evsel)->map[cpu], csv_sep);
739         else
740                 cpu = 0;
741
742         fprintf(output, fmt, cpustr, avg, csv_sep, perf_evsel__name(evsel));
743
744         if (evsel->cgrp)
745                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
746
747         if (csv_output || interval)
748                 return;
749
750         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
751                 total = avg_stats(&runtime_cycles_stats[cpu]);
752                 if (total)
753                         ratio = avg / total;
754
755                 fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
756
757                 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
758                 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
759
760                 if (total && avg) {
761                         ratio = total / avg;
762                         fprintf(output, "\n                                             #   %5.2f  stalled cycles per insn", ratio);
763                 }
764
765         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
766                         runtime_branches_stats[cpu].n != 0) {
767                 print_branch_misses(cpu, evsel, avg);
768         } else if (
769                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
770                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
771                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
772                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
773                         runtime_l1_dcache_stats[cpu].n != 0) {
774                 print_l1_dcache_misses(cpu, evsel, avg);
775         } else if (
776                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
777                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
778                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
779                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
780                         runtime_l1_icache_stats[cpu].n != 0) {
781                 print_l1_icache_misses(cpu, evsel, avg);
782         } else if (
783                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
784                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
785                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
786                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
787                         runtime_dtlb_cache_stats[cpu].n != 0) {
788                 print_dtlb_cache_misses(cpu, evsel, avg);
789         } else if (
790                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
791                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
792                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
793                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
794                         runtime_itlb_cache_stats[cpu].n != 0) {
795                 print_itlb_cache_misses(cpu, evsel, avg);
796         } else if (
797                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
798                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
799                                         ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
800                                         ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
801                         runtime_ll_cache_stats[cpu].n != 0) {
802                 print_ll_cache_misses(cpu, evsel, avg);
803         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
804                         runtime_cacherefs_stats[cpu].n != 0) {
805                 total = avg_stats(&runtime_cacherefs_stats[cpu]);
806
807                 if (total)
808                         ratio = avg * 100 / total;
809
810                 fprintf(output, " # %8.3f %% of all cache refs    ", ratio);
811
812         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
813                 print_stalled_cycles_frontend(cpu, evsel, avg);
814         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
815                 print_stalled_cycles_backend(cpu, evsel, avg);
816         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
817                 total = avg_stats(&runtime_nsecs_stats[cpu]);
818
819                 if (total)
820                         ratio = 1.0 * avg / total;
821
822                 fprintf(output, " # %8.3f GHz                    ", ratio);
823         } else if (runtime_nsecs_stats[cpu].n != 0) {
824                 char unit = 'M';
825
826                 total = avg_stats(&runtime_nsecs_stats[cpu]);
827
828                 if (total)
829                         ratio = 1000.0 * avg / total;
830                 if (ratio < 0.001) {
831                         ratio *= 1000;
832                         unit = 'K';
833                 }
834
835                 fprintf(output, " # %8.3f %c/sec                  ", ratio, unit);
836         } else {
837                 fprintf(output, "                                   ");
838         }
839 }
840
841 static void print_aggr_socket(char *prefix)
842 {
843         struct perf_evsel *counter;
844         u64 ena, run, val;
845         int cpu, s, s2, sock, nr;
846
847         if (!sock_map)
848                 return;
849
850         for (s = 0; s < sock_map->nr; s++) {
851                 sock = cpu_map__socket(sock_map, s);
852                 list_for_each_entry(counter, &evsel_list->entries, node) {
853                         val = ena = run = 0;
854                         nr = 0;
855                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
856                                 s2 = cpu_map__get_socket(evsel_list->cpus, cpu);
857                                 if (s2 != sock)
858                                         continue;
859                                 val += counter->counts->cpu[cpu].val;
860                                 ena += counter->counts->cpu[cpu].ena;
861                                 run += counter->counts->cpu[cpu].run;
862                                 nr++;
863                         }
864                         if (prefix)
865                                 fprintf(output, "%s", prefix);
866
867                         if (run == 0 || ena == 0) {
868                                 fprintf(output, "S%*d%s%*d%s%*s%s%*s",
869                                         csv_output ? 0 : -5,
870                                         s,
871                                         csv_sep,
872                                         csv_output ? 0 : 4,
873                                         nr,
874                                         csv_sep,
875                                         csv_output ? 0 : 18,
876                                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
877                                         csv_sep,
878                                         csv_output ? 0 : -24,
879                                         perf_evsel__name(counter));
880                                 if (counter->cgrp)
881                                         fprintf(output, "%s%s",
882                                                 csv_sep, counter->cgrp->name);
883
884                                 fputc('\n', output);
885                                 continue;
886                         }
887
888                         if (nsec_counter(counter))
889                                 nsec_printout(sock, nr, counter, val);
890                         else
891                                 abs_printout(sock, nr, counter, val);
892
893                         if (!csv_output) {
894                                 print_noise(counter, 1.0);
895
896                                 if (run != ena)
897                                         fprintf(output, "  (%.2f%%)",
898                                                 100.0 * run / ena);
899                         }
900                         fputc('\n', output);
901                 }
902         }
903 }
904
905 /*
906  * Print out the results of a single counter:
907  * aggregated counts in system-wide mode
908  */
909 static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
910 {
911         struct perf_stat *ps = counter->priv;
912         double avg = avg_stats(&ps->res_stats[0]);
913         int scaled = counter->counts->scaled;
914
915         if (prefix)
916                 fprintf(output, "%s", prefix);
917
918         if (scaled == -1) {
919                 fprintf(output, "%*s%s%*s",
920                         csv_output ? 0 : 18,
921                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
922                         csv_sep,
923                         csv_output ? 0 : -24,
924                         perf_evsel__name(counter));
925
926                 if (counter->cgrp)
927                         fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
928
929                 fputc('\n', output);
930                 return;
931         }
932
933         if (nsec_counter(counter))
934                 nsec_printout(-1, 0, counter, avg);
935         else
936                 abs_printout(-1, 0, counter, avg);
937
938         print_noise(counter, avg);
939
940         if (csv_output) {
941                 fputc('\n', output);
942                 return;
943         }
944
945         if (scaled) {
946                 double avg_enabled, avg_running;
947
948                 avg_enabled = avg_stats(&ps->res_stats[1]);
949                 avg_running = avg_stats(&ps->res_stats[2]);
950
951                 fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
952         }
953         fprintf(output, "\n");
954 }
955
956 /*
957  * Print out the results of a single counter:
958  * does not use aggregated count in system-wide
959  */
960 static void print_counter(struct perf_evsel *counter, char *prefix)
961 {
962         u64 ena, run, val;
963         int cpu;
964
965         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
966                 val = counter->counts->cpu[cpu].val;
967                 ena = counter->counts->cpu[cpu].ena;
968                 run = counter->counts->cpu[cpu].run;
969
970                 if (prefix)
971                         fprintf(output, "%s", prefix);
972
973                 if (run == 0 || ena == 0) {
974                         fprintf(output, "CPU%*d%s%*s%s%*s",
975                                 csv_output ? 0 : -4,
976                                 perf_evsel__cpus(counter)->map[cpu], csv_sep,
977                                 csv_output ? 0 : 18,
978                                 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
979                                 csv_sep,
980                                 csv_output ? 0 : -24,
981                                 perf_evsel__name(counter));
982
983                         if (counter->cgrp)
984                                 fprintf(output, "%s%s",
985                                         csv_sep, counter->cgrp->name);
986
987                         fputc('\n', output);
988                         continue;
989                 }
990
991                 if (nsec_counter(counter))
992                         nsec_printout(cpu, 0, counter, val);
993                 else
994                         abs_printout(cpu, 0, counter, val);
995
996                 if (!csv_output) {
997                         print_noise(counter, 1.0);
998
999                         if (run != ena)
1000                                 fprintf(output, "  (%.2f%%)",
1001                                         100.0 * run / ena);
1002                 }
1003                 fputc('\n', output);
1004         }
1005 }
1006
1007 static void print_stat(int argc, const char **argv)
1008 {
1009         struct perf_evsel *counter;
1010         int i;
1011
1012         fflush(stdout);
1013
1014         if (!csv_output) {
1015                 fprintf(output, "\n");
1016                 fprintf(output, " Performance counter stats for ");
1017                 if (!perf_target__has_task(&target)) {
1018                         fprintf(output, "\'%s", argv[0]);
1019                         for (i = 1; i < argc; i++)
1020                                 fprintf(output, " %s", argv[i]);
1021                 } else if (target.pid)
1022                         fprintf(output, "process id \'%s", target.pid);
1023                 else
1024                         fprintf(output, "thread id \'%s", target.tid);
1025
1026                 fprintf(output, "\'");
1027                 if (run_count > 1)
1028                         fprintf(output, " (%d runs)", run_count);
1029                 fprintf(output, ":\n\n");
1030         }
1031
1032         if (aggr_socket)
1033                 print_aggr_socket(NULL);
1034         else if (no_aggr) {
1035                 list_for_each_entry(counter, &evsel_list->entries, node)
1036                         print_counter(counter, NULL);
1037         } else {
1038                 list_for_each_entry(counter, &evsel_list->entries, node)
1039                         print_counter_aggr(counter, NULL);
1040         }
1041
1042         if (!csv_output) {
1043                 if (!null_run)
1044                         fprintf(output, "\n");
1045                 fprintf(output, " %17.9f seconds time elapsed",
1046                                 avg_stats(&walltime_nsecs_stats)/1e9);
1047                 if (run_count > 1) {
1048                         fprintf(output, "                                        ");
1049                         print_noise_pct(stddev_stats(&walltime_nsecs_stats),
1050                                         avg_stats(&walltime_nsecs_stats));
1051                 }
1052                 fprintf(output, "\n\n");
1053         }
1054 }
1055
1056 static volatile int signr = -1;
1057
1058 static void skip_signal(int signo)
1059 {
1060         if ((child_pid == -1) || interval)
1061                 done = 1;
1062
1063         signr = signo;
1064 }
1065
1066 static void sig_atexit(void)
1067 {
1068         if (child_pid != -1)
1069                 kill(child_pid, SIGTERM);
1070
1071         if (signr == -1)
1072                 return;
1073
1074         signal(signr, SIG_DFL);
1075         kill(getpid(), signr);
1076 }
1077
1078 static int stat__set_big_num(const struct option *opt __maybe_unused,
1079                              const char *s __maybe_unused, int unset)
1080 {
1081         big_num_opt = unset ? 0 : 1;
1082         return 0;
1083 }
1084
1085 /*
1086  * Add default attributes, if there were no attributes specified or
1087  * if -d/--detailed, -d -d or -d -d -d is used:
1088  */
1089 static int add_default_attributes(void)
1090 {
1091         struct perf_event_attr default_attrs[] = {
1092
1093   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
1094   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
1095   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
1096   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
1097
1098   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
1099   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
1100   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND  },
1101   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
1102   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
1103   { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
1104
1105 };
1106
1107 /*
1108  * Detailed stats (-d), covering the L1 and last level data caches:
1109  */
1110         struct perf_event_attr detailed_attrs[] = {
1111
1112   { .type = PERF_TYPE_HW_CACHE,
1113     .config =
1114          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1115         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1116         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1117
1118   { .type = PERF_TYPE_HW_CACHE,
1119     .config =
1120          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1121         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1122         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1123
1124   { .type = PERF_TYPE_HW_CACHE,
1125     .config =
1126          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1127         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1128         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1129
1130   { .type = PERF_TYPE_HW_CACHE,
1131     .config =
1132          PERF_COUNT_HW_CACHE_LL                 <<  0  |
1133         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1134         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1135 };
1136
1137 /*
1138  * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1139  */
1140         struct perf_event_attr very_detailed_attrs[] = {
1141
1142   { .type = PERF_TYPE_HW_CACHE,
1143     .config =
1144          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1145         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1146         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1147
1148   { .type = PERF_TYPE_HW_CACHE,
1149     .config =
1150          PERF_COUNT_HW_CACHE_L1I                <<  0  |
1151         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1152         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1153
1154   { .type = PERF_TYPE_HW_CACHE,
1155     .config =
1156          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1157         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1158         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1159
1160   { .type = PERF_TYPE_HW_CACHE,
1161     .config =
1162          PERF_COUNT_HW_CACHE_DTLB               <<  0  |
1163         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1164         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1165
1166   { .type = PERF_TYPE_HW_CACHE,
1167     .config =
1168          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1169         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1170         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1171
1172   { .type = PERF_TYPE_HW_CACHE,
1173     .config =
1174          PERF_COUNT_HW_CACHE_ITLB               <<  0  |
1175         (PERF_COUNT_HW_CACHE_OP_READ            <<  8) |
1176         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1177
1178 };
1179
1180 /*
1181  * Very, very detailed stats (-d -d -d), adding prefetch events:
1182  */
1183         struct perf_event_attr very_very_detailed_attrs[] = {
1184
1185   { .type = PERF_TYPE_HW_CACHE,
1186     .config =
1187          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1188         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1189         (PERF_COUNT_HW_CACHE_RESULT_ACCESS      << 16)                          },
1190
1191   { .type = PERF_TYPE_HW_CACHE,
1192     .config =
1193          PERF_COUNT_HW_CACHE_L1D                <<  0  |
1194         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
1195         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
1196 };
1197
1198         /* Set attrs if no event is selected and !null_run: */
1199         if (null_run)
1200                 return 0;
1201
1202         if (!evsel_list->nr_entries) {
1203                 if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0)
1204                         return -1;
1205         }
1206
1207         /* Detailed events get appended to the event list: */
1208
1209         if (detailed_run <  1)
1210                 return 0;
1211
1212         /* Append detailed run extra attributes: */
1213         if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
1214                 return -1;
1215
1216         if (detailed_run < 2)
1217                 return 0;
1218
1219         /* Append very detailed run extra attributes: */
1220         if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
1221                 return -1;
1222
1223         if (detailed_run < 3)
1224                 return 0;
1225
1226         /* Append very, very detailed run extra attributes: */
1227         return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
1228 }
1229
1230 int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
1231 {
1232         bool append_file = false;
1233         int output_fd = 0;
1234         const char *output_name = NULL;
1235         const struct option options[] = {
1236         OPT_CALLBACK('e', "event", &evsel_list, "event",
1237                      "event selector. use 'perf list' to list available events",
1238                      parse_events_option),
1239         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
1240                      "event filter", parse_filter),
1241         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
1242                     "child tasks do not inherit counters"),
1243         OPT_STRING('p', "pid", &target.pid, "pid",
1244                    "stat events on existing process id"),
1245         OPT_STRING('t', "tid", &target.tid, "tid",
1246                    "stat events on existing thread id"),
1247         OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
1248                     "system-wide collection from all CPUs"),
1249         OPT_BOOLEAN('g', "group", &group,
1250                     "put the counters into a counter group"),
1251         OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"),
1252         OPT_INCR('v', "verbose", &verbose,
1253                     "be more verbose (show counter open errors, etc)"),
1254         OPT_INTEGER('r', "repeat", &run_count,
1255                     "repeat command and print average + stddev (max: 100)"),
1256         OPT_BOOLEAN('n', "null", &null_run,
1257                     "null run - dont start any counters"),
1258         OPT_INCR('d', "detailed", &detailed_run,
1259                     "detailed run - start a lot of events"),
1260         OPT_BOOLEAN('S', "sync", &sync_run,
1261                     "call sync() before starting a run"),
1262         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 
1263                            "print large numbers with thousands\' separators",
1264                            stat__set_big_num),
1265         OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
1266                     "list of cpus to monitor in system-wide"),
1267         OPT_BOOLEAN('A', "no-aggr", &no_aggr, "disable CPU count aggregation"),
1268         OPT_STRING('x', "field-separator", &csv_sep, "separator",
1269                    "print counts with custom separator"),
1270         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1271                      "monitor event in cgroup name only", parse_cgroups),
1272         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1273         OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
1274         OPT_INTEGER(0, "log-fd", &output_fd,
1275                     "log output to fd, instead of stderr"),
1276         OPT_STRING(0, "pre", &pre_cmd, "command",
1277                         "command to run prior to the measured command"),
1278         OPT_STRING(0, "post", &post_cmd, "command",
1279                         "command to run after to the measured command"),
1280         OPT_UINTEGER('I', "interval-print", &interval,
1281                     "print counts at regular interval in ms (>= 100)"),
1282         OPT_BOOLEAN(0, "aggr-socket", &aggr_socket, "aggregate counts per processor socket"),
1283         OPT_END()
1284         };
1285         const char * const stat_usage[] = {
1286                 "perf stat [<options>] [<command>]",
1287                 NULL
1288         };
1289         struct perf_evsel *pos;
1290         int status = -ENOMEM, run_idx;
1291         const char *mode;
1292
1293         setlocale(LC_ALL, "");
1294
1295         evsel_list = perf_evlist__new();
1296         if (evsel_list == NULL)
1297                 return -ENOMEM;
1298
1299         argc = parse_options(argc, argv, options, stat_usage,
1300                 PARSE_OPT_STOP_AT_NON_OPTION);
1301
1302         output = stderr;
1303         if (output_name && strcmp(output_name, "-"))
1304                 output = NULL;
1305
1306         if (output_name && output_fd) {
1307                 fprintf(stderr, "cannot use both --output and --log-fd\n");
1308                 usage_with_options(stat_usage, options);
1309         }
1310
1311         if (output_fd < 0) {
1312                 fprintf(stderr, "argument to --log-fd must be a > 0\n");
1313                 usage_with_options(stat_usage, options);
1314         }
1315
1316         if (!output) {
1317                 struct timespec tm;
1318                 mode = append_file ? "a" : "w";
1319
1320                 output = fopen(output_name, mode);
1321                 if (!output) {
1322                         perror("failed to create output file");
1323                         return -1;
1324                 }
1325                 clock_gettime(CLOCK_REALTIME, &tm);
1326                 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
1327         } else if (output_fd > 0) {
1328                 mode = append_file ? "a" : "w";
1329                 output = fdopen(output_fd, mode);
1330                 if (!output) {
1331                         perror("Failed opening logfd");
1332                         return -errno;
1333                 }
1334         }
1335
1336         if (csv_sep) {
1337                 csv_output = true;
1338                 if (!strcmp(csv_sep, "\\t"))
1339                         csv_sep = "\t";
1340         } else
1341                 csv_sep = DEFAULT_SEPARATOR;
1342
1343         /*
1344          * let the spreadsheet do the pretty-printing
1345          */
1346         if (csv_output) {
1347                 /* User explicitly passed -B? */
1348                 if (big_num_opt == 1) {
1349                         fprintf(stderr, "-B option not supported with -x\n");
1350                         usage_with_options(stat_usage, options);
1351                 } else /* Nope, so disable big number formatting */
1352                         big_num = false;
1353         } else if (big_num_opt == 0) /* User passed --no-big-num */
1354                 big_num = false;
1355
1356         if (!argc && !perf_target__has_task(&target))
1357                 usage_with_options(stat_usage, options);
1358         if (run_count <= 0)
1359                 usage_with_options(stat_usage, options);
1360
1361         /* no_aggr, cgroup are for system-wide only */
1362         if ((no_aggr || nr_cgroups) && !perf_target__has_cpu(&target)) {
1363                 fprintf(stderr, "both cgroup and no-aggregation "
1364                         "modes only available in system-wide mode\n");
1365
1366                 usage_with_options(stat_usage, options);
1367         }
1368
1369         if (aggr_socket) {
1370                 if (!perf_target__has_cpu(&target)) {
1371                         fprintf(stderr, "--aggr-socket only available in system-wide mode (-a)\n");
1372                         usage_with_options(stat_usage, options);
1373                 }
1374                 no_aggr = true;
1375         }
1376
1377         if (add_default_attributes())
1378                 goto out;
1379
1380         perf_target__validate(&target);
1381
1382         if (perf_evlist__create_maps(evsel_list, &target) < 0) {
1383                 if (perf_target__has_task(&target))
1384                         pr_err("Problems finding threads of monitor\n");
1385                 if (perf_target__has_cpu(&target))
1386                         perror("failed to parse CPUs map");
1387
1388                 usage_with_options(stat_usage, options);
1389                 return -1;
1390         }
1391         if (interval && interval < 100) {
1392                 pr_err("print interval must be >= 100ms\n");
1393                 usage_with_options(stat_usage, options);
1394                 return -1;
1395         }
1396
1397         list_for_each_entry(pos, &evsel_list->entries, node) {
1398                 if (perf_evsel__alloc_stat_priv(pos) < 0 ||
1399                     perf_evsel__alloc_counts(pos, perf_evsel__nr_cpus(pos)) < 0)
1400                         goto out_free_fd;
1401         }
1402         if (interval) {
1403                 list_for_each_entry(pos, &evsel_list->entries, node) {
1404                         if (perf_evsel__alloc_prev_raw_counts(pos) < 0)
1405                                 goto out_free_fd;
1406                 }
1407         }
1408
1409         /*
1410          * We dont want to block the signals - that would cause
1411          * child tasks to inherit that and Ctrl-C would not work.
1412          * What we want is for Ctrl-C to work in the exec()-ed
1413          * task, but being ignored by perf stat itself:
1414          */
1415         atexit(sig_atexit);
1416         signal(SIGINT,  skip_signal);
1417         signal(SIGCHLD, skip_signal);
1418         signal(SIGALRM, skip_signal);
1419         signal(SIGABRT, skip_signal);
1420
1421         status = 0;
1422         for (run_idx = 0; run_idx < run_count; run_idx++) {
1423                 if (run_count != 1 && verbose)
1424                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1425                                 run_idx + 1);
1426
1427                 status = run_perf_stat(argc, argv);
1428         }
1429
1430         if (status != -1 && !interval)
1431                 print_stat(argc, argv);
1432 out_free_fd:
1433         list_for_each_entry(pos, &evsel_list->entries, node) {
1434                 perf_evsel__free_stat_priv(pos);
1435                 perf_evsel__free_counts(pos);
1436                 perf_evsel__free_prev_raw_counts(pos);
1437         }
1438         perf_evlist__delete_maps(evsel_list);
1439 out:
1440         perf_evlist__delete(evsel_list);
1441         return status;
1442 }