4 * Builtin stat command: Give a precise performance counters summary
5 * overview about any workload, CPU or specific PID.
9 $ perf stat ~/hackbench 10
12 Performance counter stats for '/home/mingo/hackbench':
14 1255.538611 task clock ticks # 10.143 CPU utilization factor
15 54011 context switches # 0.043 M/sec
16 385 CPU migrations # 0.000 M/sec
17 17755 pagefaults # 0.014 M/sec
18 3808323185 CPU cycles # 3033.219 M/sec
19 1575111190 instructions # 1254.530 M/sec
20 17367895 cache references # 13.833 M/sec
21 7674421 cache misses # 6.112 M/sec
23 Wall-clock time elapsed: 123.786620 msecs
26 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
28 * Improvements and fixes by:
30 * Arjan van de Ven <arjan@linux.intel.com>
31 * Yanmin Zhang <yanmin.zhang@intel.com>
32 * Wu Fengguang <fengguang.wu@intel.com>
33 * Mike Galbraith <efault@gmx.de>
34 * Paul Mackerras <paulus@samba.org>
35 * Jaswinder Singh Rajput <jaswinder@kernel.org>
37 * Released under the GPL v2. (and only v2, not any later version)
42 #include "util/util.h"
43 #include "util/parse-options.h"
44 #include "util/parse-events.h"
45 #include "util/event.h"
46 #include "util/debug.h"
47 #include "util/header.h"
48 #include "util/cpumap.h"
49 #include "util/thread.h"
51 #include <sys/prctl.h>
54 static struct perf_event_attr default_attrs
[] = {
56 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_TASK_CLOCK
},
57 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CONTEXT_SWITCHES
},
58 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CPU_MIGRATIONS
},
59 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_PAGE_FAULTS
},
61 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CPU_CYCLES
},
62 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_INSTRUCTIONS
},
63 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_BRANCH_INSTRUCTIONS
},
64 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_BRANCH_MISSES
},
65 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_REFERENCES
},
66 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_MISSES
},
70 static bool system_wide
= false;
71 static unsigned int nr_cpus
= 0;
72 static int run_idx
= 0;
74 static int run_count
= 1;
75 static bool no_inherit
= false;
76 static bool scale
= true;
77 static pid_t target_pid
= -1;
78 static pid_t target_tid
= -1;
79 static pid_t
*all_tids
= NULL
;
80 static int thread_num
= 0;
81 static pid_t child_pid
= -1;
82 static bool null_run
= false;
84 static int *fd
[MAX_NR_CPUS
][MAX_COUNTERS
];
86 static int event_scaled
[MAX_COUNTERS
];
88 static volatile int done
= 0;
95 static void update_stats(struct stats
*stats
, u64 val
)
100 delta
= val
- stats
->mean
;
101 stats
->mean
+= delta
/ stats
->n
;
102 stats
->M2
+= delta
*(val
- stats
->mean
);
105 static double avg_stats(struct stats
*stats
)
111 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
113 * (\Sum n_i^2) - ((\Sum n_i)^2)/n
114 * s^2 = -------------------------------
117 * http://en.wikipedia.org/wiki/Stddev
119 * The std dev of the mean is related to the std dev by:
126 static double stddev_stats(struct stats
*stats
)
128 double variance
= stats
->M2
/ (stats
->n
- 1);
129 double variance_mean
= variance
/ stats
->n
;
131 return sqrt(variance_mean
);
134 struct stats event_res_stats
[MAX_COUNTERS
][3];
135 struct stats runtime_nsecs_stats
;
136 struct stats walltime_nsecs_stats
;
137 struct stats runtime_cycles_stats
;
138 struct stats runtime_branches_stats
;
140 #define MATCH_EVENT(t, c, counter) \
141 (attrs[counter].type == PERF_TYPE_##t && \
142 attrs[counter].config == PERF_COUNT_##c)
144 #define ERR_PERF_OPEN \
145 "Error: counter %d, sys_perf_event_open() syscall returned with %d (%s)\n"
147 static int create_perf_stat_counter(int counter
)
149 struct perf_event_attr
*attr
= attrs
+ counter
;
154 attr
->read_format
= PERF_FORMAT_TOTAL_TIME_ENABLED
|
155 PERF_FORMAT_TOTAL_TIME_RUNNING
;
160 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
161 fd
[cpu
][counter
][0] = sys_perf_event_open(attr
,
162 -1, cpumap
[cpu
], -1, 0);
163 if (fd
[cpu
][counter
][0] < 0)
164 pr_debug(ERR_PERF_OPEN
, counter
,
165 fd
[cpu
][counter
][0], strerror(errno
));
170 attr
->inherit
= !no_inherit
;
171 if (target_pid
== -1 && target_tid
== -1) {
173 attr
->enable_on_exec
= 1;
175 for (thread
= 0; thread
< thread_num
; thread
++) {
176 fd
[0][counter
][thread
] = sys_perf_event_open(attr
,
177 all_tids
[thread
], -1, -1, 0);
178 if (fd
[0][counter
][thread
] < 0)
179 pr_debug(ERR_PERF_OPEN
, counter
,
180 fd
[0][counter
][thread
],
191 * Does the counter have nsecs as a unit?
193 static inline int nsec_counter(int counter
)
195 if (MATCH_EVENT(SOFTWARE
, SW_CPU_CLOCK
, counter
) ||
196 MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
))
203 * Read out the results of a single counter:
205 static void read_counter(int counter
)
207 u64 count
[3], single_count
[3];
213 count
[0] = count
[1] = count
[2] = 0;
216 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
217 for (thread
= 0; thread
< thread_num
; thread
++) {
218 if (fd
[cpu
][counter
][thread
] < 0)
221 res
= read(fd
[cpu
][counter
][thread
],
222 single_count
, nv
* sizeof(u64
));
223 assert(res
== nv
* sizeof(u64
));
225 close(fd
[cpu
][counter
][thread
]);
226 fd
[cpu
][counter
][thread
] = -1;
228 count
[0] += single_count
[0];
230 count
[1] += single_count
[1];
231 count
[2] += single_count
[2];
239 event_scaled
[counter
] = -1;
244 if (count
[2] < count
[1]) {
245 event_scaled
[counter
] = 1;
246 count
[0] = (unsigned long long)
247 ((double)count
[0] * count
[1] / count
[2] + 0.5);
251 for (i
= 0; i
< 3; i
++)
252 update_stats(&event_res_stats
[counter
][i
], count
[i
]);
255 fprintf(stderr
, "%s: %Ld %Ld %Ld\n", event_name(counter
),
256 count
[0], count
[1], count
[2]);
260 * Save the full runtime - to allow normalization during printout:
262 if (MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
))
263 update_stats(&runtime_nsecs_stats
, count
[0]);
264 if (MATCH_EVENT(HARDWARE
, HW_CPU_CYCLES
, counter
))
265 update_stats(&runtime_cycles_stats
, count
[0]);
266 if (MATCH_EVENT(HARDWARE
, HW_BRANCH_INSTRUCTIONS
, counter
))
267 update_stats(&runtime_branches_stats
, count
[0]);
270 static int run_perf_stat(int argc __used
, const char **argv
)
272 unsigned long long t0
, t1
;
274 int counter
, ncreated
= 0;
275 int child_ready_pipe
[2], go_pipe
[2];
276 const bool forks
= (argc
> 0);
282 if (forks
&& (pipe(child_ready_pipe
) < 0 || pipe(go_pipe
) < 0)) {
283 perror("failed to create pipes");
288 if ((child_pid
= fork()) < 0)
289 perror("failed to fork");
292 close(child_ready_pipe
[0]);
294 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
297 * Do a dummy execvp to get the PLT entry resolved,
298 * so we avoid the resolver overhead on the real
301 execvp("", (char **)argv
);
304 * Tell the parent we're ready to go
306 close(child_ready_pipe
[1]);
309 * Wait until the parent tells us to go.
311 if (read(go_pipe
[0], &buf
, 1) == -1)
312 perror("unable to read pipe");
314 execvp(argv
[0], (char **)argv
);
320 if (target_tid
== -1 && target_pid
== -1 && !system_wide
)
321 all_tids
[0] = child_pid
;
324 * Wait for the child to be ready to exec.
326 close(child_ready_pipe
[1]);
328 if (read(child_ready_pipe
[0], &buf
, 1) == -1)
329 perror("unable to read pipe");
330 close(child_ready_pipe
[0]);
333 for (counter
= 0; counter
< nr_counters
; counter
++)
334 ncreated
+= create_perf_stat_counter(counter
);
337 pr_err("No permission to collect %sstats.\n"
338 "Consider tweaking /proc/sys/kernel/perf_event_paranoid.\n",
339 system_wide
? "system-wide " : "");
341 kill(child_pid
, SIGTERM
);
346 * Enable counters and exec the command:
354 while(!done
) sleep(1);
359 update_stats(&walltime_nsecs_stats
, t1
- t0
);
361 for (counter
= 0; counter
< nr_counters
; counter
++)
362 read_counter(counter
);
364 return WEXITSTATUS(status
);
367 static void print_noise(int counter
, double avg
)
372 fprintf(stderr
, " ( +- %7.3f%% )",
373 100 * stddev_stats(&event_res_stats
[counter
][0]) / avg
);
376 static void nsec_printout(int counter
, double avg
)
378 double msecs
= avg
/ 1e6
;
380 fprintf(stderr
, " %14.6f %-24s", msecs
, event_name(counter
));
382 if (MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
)) {
383 fprintf(stderr
, " # %10.3f CPUs ",
384 avg
/ avg_stats(&walltime_nsecs_stats
));
388 static void abs_printout(int counter
, double avg
)
390 double total
, ratio
= 0.0;
392 fprintf(stderr
, " %14.0f %-24s", avg
, event_name(counter
));
394 if (MATCH_EVENT(HARDWARE
, HW_INSTRUCTIONS
, counter
)) {
395 total
= avg_stats(&runtime_cycles_stats
);
400 fprintf(stderr
, " # %10.3f IPC ", ratio
);
401 } else if (MATCH_EVENT(HARDWARE
, HW_BRANCH_MISSES
, counter
) &&
402 runtime_branches_stats
.n
!= 0) {
403 total
= avg_stats(&runtime_branches_stats
);
406 ratio
= avg
* 100 / total
;
408 fprintf(stderr
, " # %10.3f %% ", ratio
);
410 } else if (runtime_nsecs_stats
.n
!= 0) {
411 total
= avg_stats(&runtime_nsecs_stats
);
414 ratio
= 1000.0 * avg
/ total
;
416 fprintf(stderr
, " # %10.3f M/sec", ratio
);
421 * Print out the results of a single counter:
423 static void print_counter(int counter
)
425 double avg
= avg_stats(&event_res_stats
[counter
][0]);
426 int scaled
= event_scaled
[counter
];
429 fprintf(stderr
, " %14s %-24s\n",
430 "<not counted>", event_name(counter
));
434 if (nsec_counter(counter
))
435 nsec_printout(counter
, avg
);
437 abs_printout(counter
, avg
);
439 print_noise(counter
, avg
);
442 double avg_enabled
, avg_running
;
444 avg_enabled
= avg_stats(&event_res_stats
[counter
][1]);
445 avg_running
= avg_stats(&event_res_stats
[counter
][2]);
447 fprintf(stderr
, " (scaled from %.2f%%)",
448 100 * avg_running
/ avg_enabled
);
451 fprintf(stderr
, "\n");
454 static void print_stat(int argc
, const char **argv
)
460 fprintf(stderr
, "\n");
461 fprintf(stderr
, " Performance counter stats for ");
462 if(target_pid
== -1 && target_tid
== -1) {
463 fprintf(stderr
, "\'%s", argv
[0]);
464 for (i
= 1; i
< argc
; i
++)
465 fprintf(stderr
, " %s", argv
[i
]);
466 } else if (target_pid
!= -1)
467 fprintf(stderr
, "process id \'%d", target_pid
);
469 fprintf(stderr
, "thread id \'%d", target_tid
);
471 fprintf(stderr
, "\'");
473 fprintf(stderr
, " (%d runs)", run_count
);
474 fprintf(stderr
, ":\n\n");
476 for (counter
= 0; counter
< nr_counters
; counter
++)
477 print_counter(counter
);
479 fprintf(stderr
, "\n");
480 fprintf(stderr
, " %14.9f seconds time elapsed",
481 avg_stats(&walltime_nsecs_stats
)/1e9
);
483 fprintf(stderr
, " ( +- %7.3f%% )",
484 100*stddev_stats(&walltime_nsecs_stats
) /
485 avg_stats(&walltime_nsecs_stats
));
487 fprintf(stderr
, "\n\n");
490 static volatile int signr
= -1;
492 static void skip_signal(int signo
)
500 static void sig_atexit(void)
503 kill(child_pid
, SIGTERM
);
508 signal(signr
, SIG_DFL
);
509 kill(getpid(), signr
);
512 static const char * const stat_usage
[] = {
513 "perf stat [<options>] [<command>]",
517 static const struct option options
[] = {
518 OPT_CALLBACK('e', "event", NULL
, "event",
519 "event selector. use 'perf list' to list available events",
521 OPT_BOOLEAN('i', "no-inherit", &no_inherit
,
522 "child tasks do not inherit counters"),
523 OPT_INTEGER('p', "pid", &target_pid
,
524 "stat events on existing process id"),
525 OPT_INTEGER('t', "tid", &target_tid
,
526 "stat events on existing thread id"),
527 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
528 "system-wide collection from all CPUs"),
529 OPT_BOOLEAN('c', "scale", &scale
,
530 "scale/normalize counters"),
531 OPT_INCR('v', "verbose", &verbose
,
532 "be more verbose (show counter open errors, etc)"),
533 OPT_INTEGER('r', "repeat", &run_count
,
534 "repeat command and print average + stddev (max: 100)"),
535 OPT_BOOLEAN('n', "null", &null_run
,
536 "null run - dont start any counters"),
540 int cmd_stat(int argc
, const char **argv
, const char *prefix __used
)
545 argc
= parse_options(argc
, argv
, options
, stat_usage
,
546 PARSE_OPT_STOP_AT_NON_OPTION
);
547 if (!argc
&& target_pid
== -1 && target_tid
== -1)
548 usage_with_options(stat_usage
, options
);
550 usage_with_options(stat_usage
, options
);
552 /* Set attrs and nr_counters if no event is selected and !null_run */
553 if (!null_run
&& !nr_counters
) {
554 memcpy(attrs
, default_attrs
, sizeof(default_attrs
));
555 nr_counters
= ARRAY_SIZE(default_attrs
);
559 nr_cpus
= read_cpu_map();
563 if (target_pid
!= -1) {
564 target_tid
= target_pid
;
565 thread_num
= find_all_tid(target_pid
, &all_tids
);
566 if (thread_num
<= 0) {
567 fprintf(stderr
, "Can't find all threads of pid %d\n",
569 usage_with_options(stat_usage
, options
);
572 all_tids
=malloc(sizeof(pid_t
));
576 all_tids
[0] = target_tid
;
580 for (i
= 0; i
< MAX_NR_CPUS
; i
++) {
581 for (j
= 0; j
< MAX_COUNTERS
; j
++) {
582 fd
[i
][j
] = malloc(sizeof(int)*thread_num
);
589 * We dont want to block the signals - that would cause
590 * child tasks to inherit that and Ctrl-C would not work.
591 * What we want is for Ctrl-C to work in the exec()-ed
592 * task, but being ignored by perf stat itself:
595 signal(SIGINT
, skip_signal
);
596 signal(SIGALRM
, skip_signal
);
597 signal(SIGABRT
, skip_signal
);
600 for (run_idx
= 0; run_idx
< run_count
; run_idx
++) {
601 if (run_count
!= 1 && verbose
)
602 fprintf(stderr
, "[ perf stat: executing run #%d ... ]\n", run_idx
+ 1);
603 status
= run_perf_stat(argc
, argv
);
607 print_stat(argc
, argv
);