4 * Builtin stat command: Give a precise performance counters summary
5 * overview about any workload, CPU or specific PID.
9 $ perf stat ./hackbench 10
13 Performance counter stats for './hackbench 10':
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
27 0.154822978 seconds time elapsed
30 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
32 * Improvements and fixes by:
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>
41 * Released under the GPL v2. (and only v2, not any later version)
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/header.h"
55 #include "util/cpumap.h"
56 #include "util/thread.h"
57 #include "util/thread_map.h"
59 #include <sys/prctl.h>
63 #define DEFAULT_SEPARATOR " "
64 #define CNTR_NOT_SUPPORTED "<not supported>"
65 #define CNTR_NOT_COUNTED "<not counted>"
67 static struct perf_event_attr default_attrs
[] = {
69 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_TASK_CLOCK
},
70 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CONTEXT_SWITCHES
},
71 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CPU_MIGRATIONS
},
72 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_PAGE_FAULTS
},
74 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CPU_CYCLES
},
75 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_STALLED_CYCLES_FRONTEND
},
76 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_STALLED_CYCLES_BACKEND
},
77 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_INSTRUCTIONS
},
78 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_BRANCH_INSTRUCTIONS
},
79 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_BRANCH_MISSES
},
84 * Detailed stats (-d), covering the L1 and last level data caches:
86 static struct perf_event_attr detailed_attrs
[] = {
88 { .type
= PERF_TYPE_HW_CACHE
,
90 PERF_COUNT_HW_CACHE_L1D
<< 0 |
91 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
92 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
94 { .type
= PERF_TYPE_HW_CACHE
,
96 PERF_COUNT_HW_CACHE_L1D
<< 0 |
97 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
98 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
100 { .type
= PERF_TYPE_HW_CACHE
,
102 PERF_COUNT_HW_CACHE_LL
<< 0 |
103 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
104 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
106 { .type
= PERF_TYPE_HW_CACHE
,
108 PERF_COUNT_HW_CACHE_LL
<< 0 |
109 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
110 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
114 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
116 static struct perf_event_attr very_detailed_attrs
[] = {
118 { .type
= PERF_TYPE_HW_CACHE
,
120 PERF_COUNT_HW_CACHE_L1I
<< 0 |
121 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
122 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
124 { .type
= PERF_TYPE_HW_CACHE
,
126 PERF_COUNT_HW_CACHE_L1I
<< 0 |
127 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
128 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
130 { .type
= PERF_TYPE_HW_CACHE
,
132 PERF_COUNT_HW_CACHE_DTLB
<< 0 |
133 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
134 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
136 { .type
= PERF_TYPE_HW_CACHE
,
138 PERF_COUNT_HW_CACHE_DTLB
<< 0 |
139 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
140 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
142 { .type
= PERF_TYPE_HW_CACHE
,
144 PERF_COUNT_HW_CACHE_ITLB
<< 0 |
145 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
146 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
148 { .type
= PERF_TYPE_HW_CACHE
,
150 PERF_COUNT_HW_CACHE_ITLB
<< 0 |
151 (PERF_COUNT_HW_CACHE_OP_READ
<< 8) |
152 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
157 * Very, very detailed stats (-d -d -d), adding prefetch events:
159 static struct perf_event_attr very_very_detailed_attrs
[] = {
161 { .type
= PERF_TYPE_HW_CACHE
,
163 PERF_COUNT_HW_CACHE_L1D
<< 0 |
164 (PERF_COUNT_HW_CACHE_OP_PREFETCH
<< 8) |
165 (PERF_COUNT_HW_CACHE_RESULT_ACCESS
<< 16) },
167 { .type
= PERF_TYPE_HW_CACHE
,
169 PERF_COUNT_HW_CACHE_L1D
<< 0 |
170 (PERF_COUNT_HW_CACHE_OP_PREFETCH
<< 8) |
171 (PERF_COUNT_HW_CACHE_RESULT_MISS
<< 16) },
176 struct perf_evlist
*evsel_list
;
178 static bool system_wide
= false;
179 static int run_idx
= 0;
181 static int run_count
= 1;
182 static bool no_inherit
= false;
183 static bool scale
= true;
184 static bool no_aggr
= false;
185 static pid_t target_pid
= -1;
186 static pid_t target_tid
= -1;
187 static pid_t child_pid
= -1;
188 static bool null_run
= false;
189 static int detailed_run
= 0;
190 static bool sync_run
= false;
191 static bool big_num
= true;
192 static int big_num_opt
= -1;
193 static const char *cpu_list
;
194 static const char *csv_sep
= NULL
;
195 static bool csv_output
= false;
197 static volatile int done
= 0;
205 struct stats res_stats
[3];
208 static int perf_evsel__alloc_stat_priv(struct perf_evsel
*evsel
)
210 evsel
->priv
= zalloc(sizeof(struct perf_stat
));
211 return evsel
->priv
== NULL
? -ENOMEM
: 0;
214 static void perf_evsel__free_stat_priv(struct perf_evsel
*evsel
)
220 static void update_stats(struct stats
*stats
, u64 val
)
225 delta
= val
- stats
->mean
;
226 stats
->mean
+= delta
/ stats
->n
;
227 stats
->M2
+= delta
*(val
- stats
->mean
);
230 static double avg_stats(struct stats
*stats
)
236 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
238 * (\Sum n_i^2) - ((\Sum n_i)^2)/n
239 * s^2 = -------------------------------
242 * http://en.wikipedia.org/wiki/Stddev
244 * The std dev of the mean is related to the std dev by:
251 static double stddev_stats(struct stats
*stats
)
253 double variance
= stats
->M2
/ (stats
->n
- 1);
254 double variance_mean
= variance
/ stats
->n
;
256 return sqrt(variance_mean
);
259 struct stats runtime_nsecs_stats
[MAX_NR_CPUS
];
260 struct stats runtime_cycles_stats
[MAX_NR_CPUS
];
261 struct stats runtime_stalled_cycles_front_stats
[MAX_NR_CPUS
];
262 struct stats runtime_stalled_cycles_back_stats
[MAX_NR_CPUS
];
263 struct stats runtime_branches_stats
[MAX_NR_CPUS
];
264 struct stats runtime_cacherefs_stats
[MAX_NR_CPUS
];
265 struct stats runtime_l1_dcache_stats
[MAX_NR_CPUS
];
266 struct stats runtime_l1_icache_stats
[MAX_NR_CPUS
];
267 struct stats runtime_ll_cache_stats
[MAX_NR_CPUS
];
268 struct stats runtime_itlb_cache_stats
[MAX_NR_CPUS
];
269 struct stats runtime_dtlb_cache_stats
[MAX_NR_CPUS
];
270 struct stats walltime_nsecs_stats
;
272 static int create_perf_stat_counter(struct perf_evsel
*evsel
)
274 struct perf_event_attr
*attr
= &evsel
->attr
;
277 attr
->read_format
= PERF_FORMAT_TOTAL_TIME_ENABLED
|
278 PERF_FORMAT_TOTAL_TIME_RUNNING
;
280 attr
->inherit
= !no_inherit
;
283 return perf_evsel__open_per_cpu(evsel
, evsel_list
->cpus
, false);
285 if (target_pid
== -1 && target_tid
== -1) {
287 attr
->enable_on_exec
= 1;
290 return perf_evsel__open_per_thread(evsel
, evsel_list
->threads
, false);
294 * Does the counter have nsecs as a unit?
296 static inline int nsec_counter(struct perf_evsel
*evsel
)
298 if (perf_evsel__match(evsel
, SOFTWARE
, SW_CPU_CLOCK
) ||
299 perf_evsel__match(evsel
, SOFTWARE
, SW_TASK_CLOCK
))
306 * Update various tracking values we maintain to print
307 * more semantic information such as miss/hit ratios,
308 * instruction rates, etc:
310 static void update_shadow_stats(struct perf_evsel
*counter
, u64
*count
)
312 if (perf_evsel__match(counter
, SOFTWARE
, SW_TASK_CLOCK
))
313 update_stats(&runtime_nsecs_stats
[0], count
[0]);
314 else if (perf_evsel__match(counter
, HARDWARE
, HW_CPU_CYCLES
))
315 update_stats(&runtime_cycles_stats
[0], count
[0]);
316 else if (perf_evsel__match(counter
, HARDWARE
, HW_STALLED_CYCLES_FRONTEND
))
317 update_stats(&runtime_stalled_cycles_front_stats
[0], count
[0]);
318 else if (perf_evsel__match(counter
, HARDWARE
, HW_STALLED_CYCLES_BACKEND
))
319 update_stats(&runtime_stalled_cycles_back_stats
[0], count
[0]);
320 else if (perf_evsel__match(counter
, HARDWARE
, HW_BRANCH_INSTRUCTIONS
))
321 update_stats(&runtime_branches_stats
[0], count
[0]);
322 else if (perf_evsel__match(counter
, HARDWARE
, HW_CACHE_REFERENCES
))
323 update_stats(&runtime_cacherefs_stats
[0], count
[0]);
324 else if (perf_evsel__match(counter
, HW_CACHE
, HW_CACHE_L1D
))
325 update_stats(&runtime_l1_dcache_stats
[0], count
[0]);
326 else if (perf_evsel__match(counter
, HW_CACHE
, HW_CACHE_L1I
))
327 update_stats(&runtime_l1_icache_stats
[0], count
[0]);
328 else if (perf_evsel__match(counter
, HW_CACHE
, HW_CACHE_LL
))
329 update_stats(&runtime_ll_cache_stats
[0], count
[0]);
330 else if (perf_evsel__match(counter
, HW_CACHE
, HW_CACHE_DTLB
))
331 update_stats(&runtime_dtlb_cache_stats
[0], count
[0]);
332 else if (perf_evsel__match(counter
, HW_CACHE
, HW_CACHE_ITLB
))
333 update_stats(&runtime_itlb_cache_stats
[0], count
[0]);
337 * Read out the results of a single counter:
338 * aggregate counts across CPUs in system-wide mode
340 static int read_counter_aggr(struct perf_evsel
*counter
)
342 struct perf_stat
*ps
= counter
->priv
;
343 u64
*count
= counter
->counts
->aggr
.values
;
346 if (__perf_evsel__read(counter
, evsel_list
->cpus
->nr
,
347 evsel_list
->threads
->nr
, scale
) < 0)
350 for (i
= 0; i
< 3; i
++)
351 update_stats(&ps
->res_stats
[i
], count
[i
]);
354 fprintf(stderr
, "%s: %" PRIu64
" %" PRIu64
" %" PRIu64
"\n",
355 event_name(counter
), count
[0], count
[1], count
[2]);
359 * Save the full runtime - to allow normalization during printout:
361 update_shadow_stats(counter
, count
);
367 * Read out the results of a single counter:
368 * do not aggregate counts across CPUs in system-wide mode
370 static int read_counter(struct perf_evsel
*counter
)
375 for (cpu
= 0; cpu
< evsel_list
->cpus
->nr
; cpu
++) {
376 if (__perf_evsel__read_on_cpu(counter
, cpu
, 0, scale
) < 0)
379 count
= counter
->counts
->cpu
[cpu
].values
;
381 update_shadow_stats(counter
, count
);
387 static int run_perf_stat(int argc __used
, const char **argv
)
389 unsigned long long t0
, t1
;
390 struct perf_evsel
*counter
;
392 int child_ready_pipe
[2], go_pipe
[2];
393 const bool forks
= (argc
> 0);
396 if (forks
&& (pipe(child_ready_pipe
) < 0 || pipe(go_pipe
) < 0)) {
397 perror("failed to create pipes");
402 if ((child_pid
= fork()) < 0)
403 perror("failed to fork");
406 close(child_ready_pipe
[0]);
408 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
411 * Do a dummy execvp to get the PLT entry resolved,
412 * so we avoid the resolver overhead on the real
415 execvp("", (char **)argv
);
418 * Tell the parent we're ready to go
420 close(child_ready_pipe
[1]);
423 * Wait until the parent tells us to go.
425 if (read(go_pipe
[0], &buf
, 1) == -1)
426 perror("unable to read pipe");
428 execvp(argv
[0], (char **)argv
);
434 if (target_tid
== -1 && target_pid
== -1 && !system_wide
)
435 evsel_list
->threads
->map
[0] = child_pid
;
438 * Wait for the child to be ready to exec.
440 close(child_ready_pipe
[1]);
442 if (read(child_ready_pipe
[0], &buf
, 1) == -1)
443 perror("unable to read pipe");
444 close(child_ready_pipe
[0]);
447 list_for_each_entry(counter
, &evsel_list
->entries
, node
) {
448 if (create_perf_stat_counter(counter
) < 0) {
449 if (errno
== EINVAL
|| errno
== ENOSYS
|| errno
== ENOENT
) {
451 ui__warning("%s event is not supported by the kernel.\n",
452 event_name(counter
));
453 counter
->supported
= false;
457 if (errno
== EPERM
|| errno
== EACCES
) {
458 error("You may not have permission to collect %sstats.\n"
459 "\t Consider tweaking"
460 " /proc/sys/kernel/perf_event_paranoid or running as root.",
461 system_wide
? "system-wide " : "");
463 error("open_counter returned with %d (%s). "
464 "/bin/dmesg may provide additional information.\n",
465 errno
, strerror(errno
));
468 kill(child_pid
, SIGTERM
);
469 die("Not all events could be opened.\n");
472 counter
->supported
= true;
475 if (perf_evlist__set_filters(evsel_list
)) {
476 error("failed to set filter with %d (%s)\n", errno
,
482 * Enable counters and exec the command:
490 while(!done
) sleep(1);
495 update_stats(&walltime_nsecs_stats
, t1
- t0
);
498 list_for_each_entry(counter
, &evsel_list
->entries
, node
) {
499 read_counter(counter
);
500 perf_evsel__close_fd(counter
, evsel_list
->cpus
->nr
, 1);
503 list_for_each_entry(counter
, &evsel_list
->entries
, node
) {
504 read_counter_aggr(counter
);
505 perf_evsel__close_fd(counter
, evsel_list
->cpus
->nr
,
506 evsel_list
->threads
->nr
);
510 return WEXITSTATUS(status
);
513 static void print_noise_pct(double total
, double avg
)
518 pct
= 100.0*total
/avg
;
521 fprintf(stderr
, "%s%.2f%%", csv_sep
, pct
);
523 fprintf(stderr
, " ( +-%6.2f%% )", pct
);
526 static void print_noise(struct perf_evsel
*evsel
, double avg
)
528 struct perf_stat
*ps
;
534 print_noise_pct(stddev_stats(&ps
->res_stats
[0]), avg
);
537 static void nsec_printout(int cpu
, struct perf_evsel
*evsel
, double avg
)
539 double msecs
= avg
/ 1e6
;
540 char cpustr
[16] = { '\0', };
541 const char *fmt
= csv_output
? "%s%.6f%s%s" : "%s%18.6f%s%-25s";
544 sprintf(cpustr
, "CPU%*d%s",
546 evsel_list
->cpus
->map
[cpu
], csv_sep
);
548 fprintf(stderr
, fmt
, cpustr
, msecs
, csv_sep
, event_name(evsel
));
551 fprintf(stderr
, "%s%s", csv_sep
, evsel
->cgrp
->name
);
556 if (perf_evsel__match(evsel
, SOFTWARE
, SW_TASK_CLOCK
))
557 fprintf(stderr
, " # %8.3f CPUs utilized ", avg
/ avg_stats(&walltime_nsecs_stats
));
560 static void print_stalled_cycles_frontend(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
562 double total
, ratio
= 0.0;
565 total
= avg_stats(&runtime_cycles_stats
[cpu
]);
568 ratio
= avg
/ total
* 100.0;
570 color
= PERF_COLOR_NORMAL
;
572 color
= PERF_COLOR_RED
;
573 else if (ratio
> 30.0)
574 color
= PERF_COLOR_MAGENTA
;
575 else if (ratio
> 10.0)
576 color
= PERF_COLOR_YELLOW
;
578 fprintf(stderr
, " # ");
579 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
580 fprintf(stderr
, " frontend cycles idle ");
583 static void print_stalled_cycles_backend(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
585 double total
, ratio
= 0.0;
588 total
= avg_stats(&runtime_cycles_stats
[cpu
]);
591 ratio
= avg
/ total
* 100.0;
593 color
= PERF_COLOR_NORMAL
;
595 color
= PERF_COLOR_RED
;
596 else if (ratio
> 50.0)
597 color
= PERF_COLOR_MAGENTA
;
598 else if (ratio
> 20.0)
599 color
= PERF_COLOR_YELLOW
;
601 fprintf(stderr
, " # ");
602 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
603 fprintf(stderr
, " backend cycles idle ");
606 static void print_branch_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
608 double total
, ratio
= 0.0;
611 total
= avg_stats(&runtime_branches_stats
[cpu
]);
614 ratio
= avg
/ total
* 100.0;
616 color
= PERF_COLOR_NORMAL
;
618 color
= PERF_COLOR_RED
;
619 else if (ratio
> 10.0)
620 color
= PERF_COLOR_MAGENTA
;
621 else if (ratio
> 5.0)
622 color
= PERF_COLOR_YELLOW
;
624 fprintf(stderr
, " # ");
625 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
626 fprintf(stderr
, " of all branches ");
629 static void print_l1_dcache_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
631 double total
, ratio
= 0.0;
634 total
= avg_stats(&runtime_l1_dcache_stats
[cpu
]);
637 ratio
= avg
/ total
* 100.0;
639 color
= PERF_COLOR_NORMAL
;
641 color
= PERF_COLOR_RED
;
642 else if (ratio
> 10.0)
643 color
= PERF_COLOR_MAGENTA
;
644 else if (ratio
> 5.0)
645 color
= PERF_COLOR_YELLOW
;
647 fprintf(stderr
, " # ");
648 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
649 fprintf(stderr
, " of all L1-dcache hits ");
652 static void print_l1_icache_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
654 double total
, ratio
= 0.0;
657 total
= avg_stats(&runtime_l1_icache_stats
[cpu
]);
660 ratio
= avg
/ total
* 100.0;
662 color
= PERF_COLOR_NORMAL
;
664 color
= PERF_COLOR_RED
;
665 else if (ratio
> 10.0)
666 color
= PERF_COLOR_MAGENTA
;
667 else if (ratio
> 5.0)
668 color
= PERF_COLOR_YELLOW
;
670 fprintf(stderr
, " # ");
671 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
672 fprintf(stderr
, " of all L1-icache hits ");
675 static void print_dtlb_cache_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
677 double total
, ratio
= 0.0;
680 total
= avg_stats(&runtime_dtlb_cache_stats
[cpu
]);
683 ratio
= avg
/ total
* 100.0;
685 color
= PERF_COLOR_NORMAL
;
687 color
= PERF_COLOR_RED
;
688 else if (ratio
> 10.0)
689 color
= PERF_COLOR_MAGENTA
;
690 else if (ratio
> 5.0)
691 color
= PERF_COLOR_YELLOW
;
693 fprintf(stderr
, " # ");
694 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
695 fprintf(stderr
, " of all dTLB cache hits ");
698 static void print_itlb_cache_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
700 double total
, ratio
= 0.0;
703 total
= avg_stats(&runtime_itlb_cache_stats
[cpu
]);
706 ratio
= avg
/ total
* 100.0;
708 color
= PERF_COLOR_NORMAL
;
710 color
= PERF_COLOR_RED
;
711 else if (ratio
> 10.0)
712 color
= PERF_COLOR_MAGENTA
;
713 else if (ratio
> 5.0)
714 color
= PERF_COLOR_YELLOW
;
716 fprintf(stderr
, " # ");
717 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
718 fprintf(stderr
, " of all iTLB cache hits ");
721 static void print_ll_cache_misses(int cpu
, struct perf_evsel
*evsel __used
, double avg
)
723 double total
, ratio
= 0.0;
726 total
= avg_stats(&runtime_ll_cache_stats
[cpu
]);
729 ratio
= avg
/ total
* 100.0;
731 color
= PERF_COLOR_NORMAL
;
733 color
= PERF_COLOR_RED
;
734 else if (ratio
> 10.0)
735 color
= PERF_COLOR_MAGENTA
;
736 else if (ratio
> 5.0)
737 color
= PERF_COLOR_YELLOW
;
739 fprintf(stderr
, " # ");
740 color_fprintf(stderr
, color
, "%6.2f%%", ratio
);
741 fprintf(stderr
, " of all LL-cache hits ");
744 static void abs_printout(int cpu
, struct perf_evsel
*evsel
, double avg
)
746 double total
, ratio
= 0.0;
747 char cpustr
[16] = { '\0', };
753 fmt
= "%s%'18.0f%s%-25s";
755 fmt
= "%s%18.0f%s%-25s";
758 sprintf(cpustr
, "CPU%*d%s",
760 evsel_list
->cpus
->map
[cpu
], csv_sep
);
764 fprintf(stderr
, fmt
, cpustr
, avg
, csv_sep
, event_name(evsel
));
767 fprintf(stderr
, "%s%s", csv_sep
, evsel
->cgrp
->name
);
772 if (perf_evsel__match(evsel
, HARDWARE
, HW_INSTRUCTIONS
)) {
773 total
= avg_stats(&runtime_cycles_stats
[cpu
]);
778 fprintf(stderr
, " # %5.2f insns per cycle ", ratio
);
780 total
= avg_stats(&runtime_stalled_cycles_front_stats
[cpu
]);
781 total
= max(total
, avg_stats(&runtime_stalled_cycles_back_stats
[cpu
]));
785 fprintf(stderr
, "\n # %5.2f stalled cycles per insn", ratio
);
788 } else if (perf_evsel__match(evsel
, HARDWARE
, HW_BRANCH_MISSES
) &&
789 runtime_branches_stats
[cpu
].n
!= 0) {
790 print_branch_misses(cpu
, evsel
, avg
);
792 evsel
->attr
.type
== PERF_TYPE_HW_CACHE
&&
793 evsel
->attr
.config
== ( PERF_COUNT_HW_CACHE_L1D
|
794 ((PERF_COUNT_HW_CACHE_OP_READ
) << 8) |
795 ((PERF_COUNT_HW_CACHE_RESULT_MISS
) << 16)) &&
796 runtime_l1_dcache_stats
[cpu
].n
!= 0) {
797 print_l1_dcache_misses(cpu
, evsel
, avg
);
799 evsel
->attr
.type
== PERF_TYPE_HW_CACHE
&&
800 evsel
->attr
.config
== ( PERF_COUNT_HW_CACHE_L1I
|
801 ((PERF_COUNT_HW_CACHE_OP_READ
) << 8) |
802 ((PERF_COUNT_HW_CACHE_RESULT_MISS
) << 16)) &&
803 runtime_l1_icache_stats
[cpu
].n
!= 0) {
804 print_l1_icache_misses(cpu
, evsel
, avg
);
806 evsel
->attr
.type
== PERF_TYPE_HW_CACHE
&&
807 evsel
->attr
.config
== ( PERF_COUNT_HW_CACHE_DTLB
|
808 ((PERF_COUNT_HW_CACHE_OP_READ
) << 8) |
809 ((PERF_COUNT_HW_CACHE_RESULT_MISS
) << 16)) &&
810 runtime_dtlb_cache_stats
[cpu
].n
!= 0) {
811 print_dtlb_cache_misses(cpu
, evsel
, avg
);
813 evsel
->attr
.type
== PERF_TYPE_HW_CACHE
&&
814 evsel
->attr
.config
== ( PERF_COUNT_HW_CACHE_ITLB
|
815 ((PERF_COUNT_HW_CACHE_OP_READ
) << 8) |
816 ((PERF_COUNT_HW_CACHE_RESULT_MISS
) << 16)) &&
817 runtime_itlb_cache_stats
[cpu
].n
!= 0) {
818 print_itlb_cache_misses(cpu
, evsel
, avg
);
820 evsel
->attr
.type
== PERF_TYPE_HW_CACHE
&&
821 evsel
->attr
.config
== ( PERF_COUNT_HW_CACHE_LL
|
822 ((PERF_COUNT_HW_CACHE_OP_READ
) << 8) |
823 ((PERF_COUNT_HW_CACHE_RESULT_MISS
) << 16)) &&
824 runtime_ll_cache_stats
[cpu
].n
!= 0) {
825 print_ll_cache_misses(cpu
, evsel
, avg
);
826 } else if (perf_evsel__match(evsel
, HARDWARE
, HW_CACHE_MISSES
) &&
827 runtime_cacherefs_stats
[cpu
].n
!= 0) {
828 total
= avg_stats(&runtime_cacherefs_stats
[cpu
]);
831 ratio
= avg
* 100 / total
;
833 fprintf(stderr
, " # %8.3f %% of all cache refs ", ratio
);
835 } else if (perf_evsel__match(evsel
, HARDWARE
, HW_STALLED_CYCLES_FRONTEND
)) {
836 print_stalled_cycles_frontend(cpu
, evsel
, avg
);
837 } else if (perf_evsel__match(evsel
, HARDWARE
, HW_STALLED_CYCLES_BACKEND
)) {
838 print_stalled_cycles_backend(cpu
, evsel
, avg
);
839 } else if (perf_evsel__match(evsel
, HARDWARE
, HW_CPU_CYCLES
)) {
840 total
= avg_stats(&runtime_nsecs_stats
[cpu
]);
843 ratio
= 1.0 * avg
/ total
;
845 fprintf(stderr
, " # %8.3f GHz ", ratio
);
846 } else if (runtime_nsecs_stats
[cpu
].n
!= 0) {
847 total
= avg_stats(&runtime_nsecs_stats
[cpu
]);
850 ratio
= 1000.0 * avg
/ total
;
852 fprintf(stderr
, " # %8.3f M/sec ", ratio
);
854 fprintf(stderr
, " ");
859 * Print out the results of a single counter:
860 * aggregated counts in system-wide mode
862 static void print_counter_aggr(struct perf_evsel
*counter
)
864 struct perf_stat
*ps
= counter
->priv
;
865 double avg
= avg_stats(&ps
->res_stats
[0]);
866 int scaled
= counter
->counts
->scaled
;
869 fprintf(stderr
, "%*s%s%*s",
871 counter
->supported
? CNTR_NOT_COUNTED
: CNTR_NOT_SUPPORTED
,
873 csv_output
? 0 : -24,
874 event_name(counter
));
877 fprintf(stderr
, "%s%s", csv_sep
, counter
->cgrp
->name
);
883 if (nsec_counter(counter
))
884 nsec_printout(-1, counter
, avg
);
886 abs_printout(-1, counter
, avg
);
888 print_noise(counter
, avg
);
896 double avg_enabled
, avg_running
;
898 avg_enabled
= avg_stats(&ps
->res_stats
[1]);
899 avg_running
= avg_stats(&ps
->res_stats
[2]);
901 fprintf(stderr
, " [%5.2f%%]", 100 * avg_running
/ avg_enabled
);
903 fprintf(stderr
, "\n");
907 * Print out the results of a single counter:
908 * does not use aggregated count in system-wide
910 static void print_counter(struct perf_evsel
*counter
)
915 for (cpu
= 0; cpu
< evsel_list
->cpus
->nr
; cpu
++) {
916 val
= counter
->counts
->cpu
[cpu
].val
;
917 ena
= counter
->counts
->cpu
[cpu
].ena
;
918 run
= counter
->counts
->cpu
[cpu
].run
;
919 if (run
== 0 || ena
== 0) {
920 fprintf(stderr
, "CPU%*d%s%*s%s%*s",
922 evsel_list
->cpus
->map
[cpu
], csv_sep
,
924 counter
->supported
? CNTR_NOT_COUNTED
: CNTR_NOT_SUPPORTED
,
926 csv_output
? 0 : -24,
927 event_name(counter
));
930 fprintf(stderr
, "%s%s", csv_sep
, counter
->cgrp
->name
);
936 if (nsec_counter(counter
))
937 nsec_printout(cpu
, counter
, val
);
939 abs_printout(cpu
, counter
, val
);
942 print_noise(counter
, 1.0);
945 fprintf(stderr
, " (%.2f%%)", 100.0 * run
/ ena
);
951 static void print_stat(int argc
, const char **argv
)
953 struct perf_evsel
*counter
;
959 fprintf(stderr
, "\n");
960 fprintf(stderr
, " Performance counter stats for ");
961 if(target_pid
== -1 && target_tid
== -1) {
962 fprintf(stderr
, "\'%s", argv
[0]);
963 for (i
= 1; i
< argc
; i
++)
964 fprintf(stderr
, " %s", argv
[i
]);
965 } else if (target_pid
!= -1)
966 fprintf(stderr
, "process id \'%d", target_pid
);
968 fprintf(stderr
, "thread id \'%d", target_tid
);
970 fprintf(stderr
, "\'");
972 fprintf(stderr
, " (%d runs)", run_count
);
973 fprintf(stderr
, ":\n\n");
977 list_for_each_entry(counter
, &evsel_list
->entries
, node
)
978 print_counter(counter
);
980 list_for_each_entry(counter
, &evsel_list
->entries
, node
)
981 print_counter_aggr(counter
);
986 fprintf(stderr
, "\n");
987 fprintf(stderr
, " %17.9f seconds time elapsed",
988 avg_stats(&walltime_nsecs_stats
)/1e9
);
990 fprintf(stderr
, " ");
991 print_noise_pct(stddev_stats(&walltime_nsecs_stats
),
992 avg_stats(&walltime_nsecs_stats
));
994 fprintf(stderr
, "\n\n");
998 static volatile int signr
= -1;
1000 static void skip_signal(int signo
)
1008 static void sig_atexit(void)
1010 if (child_pid
!= -1)
1011 kill(child_pid
, SIGTERM
);
1016 signal(signr
, SIG_DFL
);
1017 kill(getpid(), signr
);
1020 static const char * const stat_usage
[] = {
1021 "perf stat [<options>] [<command>]",
1025 static int stat__set_big_num(const struct option
*opt __used
,
1026 const char *s __used
, int unset
)
1028 big_num_opt
= unset
? 0 : 1;
1032 static const struct option options
[] = {
1033 OPT_CALLBACK('e', "event", &evsel_list
, "event",
1034 "event selector. use 'perf list' to list available events",
1036 OPT_CALLBACK(0, "filter", &evsel_list
, "filter",
1037 "event filter", parse_filter
),
1038 OPT_BOOLEAN('i', "no-inherit", &no_inherit
,
1039 "child tasks do not inherit counters"),
1040 OPT_INTEGER('p', "pid", &target_pid
,
1041 "stat events on existing process id"),
1042 OPT_INTEGER('t', "tid", &target_tid
,
1043 "stat events on existing thread id"),
1044 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
1045 "system-wide collection from all CPUs"),
1046 OPT_BOOLEAN('c', "scale", &scale
,
1047 "scale/normalize counters"),
1048 OPT_INCR('v', "verbose", &verbose
,
1049 "be more verbose (show counter open errors, etc)"),
1050 OPT_INTEGER('r', "repeat", &run_count
,
1051 "repeat command and print average + stddev (max: 100)"),
1052 OPT_BOOLEAN('n', "null", &null_run
,
1053 "null run - dont start any counters"),
1054 OPT_INCR('d', "detailed", &detailed_run
,
1055 "detailed run - start a lot of events"),
1056 OPT_BOOLEAN('S', "sync", &sync_run
,
1057 "call sync() before starting a run"),
1058 OPT_CALLBACK_NOOPT('B', "big-num", NULL
, NULL
,
1059 "print large numbers with thousands\' separators",
1061 OPT_STRING('C', "cpu", &cpu_list
, "cpu",
1062 "list of cpus to monitor in system-wide"),
1063 OPT_BOOLEAN('A', "no-aggr", &no_aggr
,
1064 "disable CPU count aggregation"),
1065 OPT_STRING('x', "field-separator", &csv_sep
, "separator",
1066 "print counts with custom separator"),
1067 OPT_CALLBACK('G', "cgroup", &evsel_list
, "name",
1068 "monitor event in cgroup name only",
1074 * Add default attributes, if there were no attributes specified or
1075 * if -d/--detailed, -d -d or -d -d -d is used:
1077 static int add_default_attributes(void)
1079 struct perf_evsel
*pos
;
1083 /* Set attrs if no event is selected and !null_run: */
1087 if (!evsel_list
->nr_entries
) {
1088 for (c
= 0; c
< ARRAY_SIZE(default_attrs
); c
++) {
1089 pos
= perf_evsel__new(default_attrs
+ c
, c
+ attr_nr
);
1092 perf_evlist__add(evsel_list
, pos
);
1097 /* Detailed events get appended to the event list: */
1099 if (detailed_run
< 1)
1102 /* Append detailed run extra attributes: */
1103 for (c
= 0; c
< ARRAY_SIZE(detailed_attrs
); c
++) {
1104 pos
= perf_evsel__new(detailed_attrs
+ c
, c
+ attr_nr
);
1107 perf_evlist__add(evsel_list
, pos
);
1111 if (detailed_run
< 2)
1114 /* Append very detailed run extra attributes: */
1115 for (c
= 0; c
< ARRAY_SIZE(very_detailed_attrs
); c
++) {
1116 pos
= perf_evsel__new(very_detailed_attrs
+ c
, c
+ attr_nr
);
1119 perf_evlist__add(evsel_list
, pos
);
1122 if (detailed_run
< 3)
1125 /* Append very, very detailed run extra attributes: */
1126 for (c
= 0; c
< ARRAY_SIZE(very_very_detailed_attrs
); c
++) {
1127 pos
= perf_evsel__new(very_very_detailed_attrs
+ c
, c
+ attr_nr
);
1130 perf_evlist__add(evsel_list
, pos
);
1137 int cmd_stat(int argc
, const char **argv
, const char *prefix __used
)
1139 struct perf_evsel
*pos
;
1140 int status
= -ENOMEM
;
1142 setlocale(LC_ALL
, "");
1144 evsel_list
= perf_evlist__new(NULL
, NULL
);
1145 if (evsel_list
== NULL
)
1148 argc
= parse_options(argc
, argv
, options
, stat_usage
,
1149 PARSE_OPT_STOP_AT_NON_OPTION
);
1154 csv_sep
= DEFAULT_SEPARATOR
;
1157 * let the spreadsheet do the pretty-printing
1160 /* User explicitely passed -B? */
1161 if (big_num_opt
== 1) {
1162 fprintf(stderr
, "-B option not supported with -x\n");
1163 usage_with_options(stat_usage
, options
);
1164 } else /* Nope, so disable big number formatting */
1166 } else if (big_num_opt
== 0) /* User passed --no-big-num */
1169 if (!argc
&& target_pid
== -1 && target_tid
== -1)
1170 usage_with_options(stat_usage
, options
);
1172 usage_with_options(stat_usage
, options
);
1174 /* no_aggr, cgroup are for system-wide only */
1175 if ((no_aggr
|| nr_cgroups
) && !system_wide
) {
1176 fprintf(stderr
, "both cgroup and no-aggregation "
1177 "modes only available in system-wide mode\n");
1179 usage_with_options(stat_usage
, options
);
1182 if (add_default_attributes())
1185 if (target_pid
!= -1)
1186 target_tid
= target_pid
;
1188 evsel_list
->threads
= thread_map__new(target_pid
, target_tid
);
1189 if (evsel_list
->threads
== NULL
) {
1190 pr_err("Problems finding threads of monitor\n");
1191 usage_with_options(stat_usage
, options
);
1195 evsel_list
->cpus
= cpu_map__new(cpu_list
);
1197 evsel_list
->cpus
= cpu_map__dummy_new();
1199 if (evsel_list
->cpus
== NULL
) {
1200 perror("failed to parse CPUs map");
1201 usage_with_options(stat_usage
, options
);
1205 list_for_each_entry(pos
, &evsel_list
->entries
, node
) {
1206 if (perf_evsel__alloc_stat_priv(pos
) < 0 ||
1207 perf_evsel__alloc_counts(pos
, evsel_list
->cpus
->nr
) < 0 ||
1208 perf_evsel__alloc_fd(pos
, evsel_list
->cpus
->nr
, evsel_list
->threads
->nr
) < 0)
1213 * We dont want to block the signals - that would cause
1214 * child tasks to inherit that and Ctrl-C would not work.
1215 * What we want is for Ctrl-C to work in the exec()-ed
1216 * task, but being ignored by perf stat itself:
1219 signal(SIGINT
, skip_signal
);
1220 signal(SIGALRM
, skip_signal
);
1221 signal(SIGABRT
, skip_signal
);
1224 for (run_idx
= 0; run_idx
< run_count
; run_idx
++) {
1225 if (run_count
!= 1 && verbose
)
1226 fprintf(stderr
, "[ perf stat: executing run #%d ... ]\n", run_idx
+ 1);
1231 status
= run_perf_stat(argc
, argv
);
1235 print_stat(argc
, argv
);
1237 list_for_each_entry(pos
, &evsel_list
->entries
, node
)
1238 perf_evsel__free_stat_priv(pos
);
1239 perf_evlist__delete_maps(evsel_list
);
1241 perf_evlist__delete(evsel_list
);