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"
46 #include <sys/prctl.h>
49 static struct perf_counter_attr default_attrs
[] = {
51 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_TASK_CLOCK
},
52 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CONTEXT_SWITCHES
},
53 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CPU_MIGRATIONS
},
54 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_PAGE_FAULTS
},
56 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CPU_CYCLES
},
57 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_INSTRUCTIONS
},
58 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_REFERENCES
},
59 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_MISSES
},
65 static int system_wide
= 0;
66 static int verbose
= 0;
67 static int nr_cpus
= 0;
68 static int run_idx
= 0;
70 static int run_count
= 1;
71 static int inherit
= 1;
73 static int target_pid
= -1;
74 static int null_run
= 0;
76 static int fd
[MAX_NR_CPUS
][MAX_COUNTERS
];
78 static u64 runtime_nsecs
[MAX_RUN
];
79 static u64 walltime_nsecs
[MAX_RUN
];
80 static u64 runtime_cycles
[MAX_RUN
];
82 static u64 event_res
[MAX_RUN
][MAX_COUNTERS
][3];
83 static u64 event_scaled
[MAX_RUN
][MAX_COUNTERS
];
85 static u64 event_res_avg
[MAX_COUNTERS
][3];
86 static u64 event_res_noise
[MAX_COUNTERS
][3];
88 static u64 event_scaled_avg
[MAX_COUNTERS
];
90 static u64 runtime_nsecs_avg
;
91 static u64 runtime_nsecs_noise
;
93 static u64 walltime_nsecs_avg
;
94 static u64 walltime_nsecs_noise
;
96 static u64 runtime_cycles_avg
;
97 static u64 runtime_cycles_noise
;
99 #define ERR_PERF_OPEN \
100 "Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"
102 static void create_perf_stat_counter(int counter
, int pid
)
104 struct perf_counter_attr
*attr
= attrs
+ counter
;
107 attr
->read_format
= PERF_FORMAT_TOTAL_TIME_ENABLED
|
108 PERF_FORMAT_TOTAL_TIME_RUNNING
;
112 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
113 fd
[cpu
][counter
] = sys_perf_counter_open(attr
, -1, cpu
, -1, 0);
114 if (fd
[cpu
][counter
] < 0 && verbose
)
115 fprintf(stderr
, ERR_PERF_OPEN
, counter
,
116 fd
[cpu
][counter
], strerror(errno
));
119 attr
->inherit
= inherit
;
121 attr
->enable_on_exec
= 1;
123 fd
[0][counter
] = sys_perf_counter_open(attr
, pid
, -1, -1, 0);
124 if (fd
[0][counter
] < 0 && verbose
)
125 fprintf(stderr
, ERR_PERF_OPEN
, counter
,
126 fd
[0][counter
], strerror(errno
));
131 * Does the counter have nsecs as a unit?
133 static inline int nsec_counter(int counter
)
135 if (attrs
[counter
].type
!= PERF_TYPE_SOFTWARE
)
138 if (attrs
[counter
].config
== PERF_COUNT_SW_CPU_CLOCK
)
141 if (attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
)
148 * Read out the results of a single counter:
150 static void read_counter(int counter
)
152 u64
*count
, single_count
[3];
157 count
= event_res
[run_idx
][counter
];
159 count
[0] = count
[1] = count
[2] = 0;
162 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
163 if (fd
[cpu
][counter
] < 0)
166 res
= read(fd
[cpu
][counter
], single_count
, nv
* sizeof(u64
));
167 assert(res
== nv
* sizeof(u64
));
168 close(fd
[cpu
][counter
]);
169 fd
[cpu
][counter
] = -1;
171 count
[0] += single_count
[0];
173 count
[1] += single_count
[1];
174 count
[2] += single_count
[2];
181 event_scaled
[run_idx
][counter
] = -1;
186 if (count
[2] < count
[1]) {
187 event_scaled
[run_idx
][counter
] = 1;
188 count
[0] = (unsigned long long)
189 ((double)count
[0] * count
[1] / count
[2] + 0.5);
193 * Save the full runtime - to allow normalization during printout:
195 if (attrs
[counter
].type
== PERF_TYPE_SOFTWARE
&&
196 attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
)
197 runtime_nsecs
[run_idx
] = count
[0];
198 if (attrs
[counter
].type
== PERF_TYPE_HARDWARE
&&
199 attrs
[counter
].config
== PERF_COUNT_HW_CPU_CYCLES
)
200 runtime_cycles
[run_idx
] = count
[0];
203 static int run_perf_stat(int argc
, const char **argv
)
205 unsigned long long t0
, t1
;
209 int child_ready_pipe
[2], go_pipe
[2];
215 if (pipe(child_ready_pipe
) < 0 || pipe(go_pipe
) < 0) {
216 perror("failed to create pipes");
220 if ((pid
= fork()) < 0)
221 perror("failed to fork");
224 close(child_ready_pipe
[0]);
226 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
229 * Do a dummy execvp to get the PLT entry resolved,
230 * so we avoid the resolver overhead on the real
233 execvp("", (char **)argv
);
236 * Tell the parent we're ready to go
238 close(child_ready_pipe
[1]);
241 * Wait until the parent tells us to go.
243 read(go_pipe
[0], &buf
, 1);
245 execvp(argv
[0], (char **)argv
);
252 * Wait for the child to be ready to exec.
254 close(child_ready_pipe
[1]);
256 read(child_ready_pipe
[0], &buf
, 1);
257 close(child_ready_pipe
[0]);
259 for (counter
= 0; counter
< nr_counters
; counter
++)
260 create_perf_stat_counter(counter
, pid
);
263 * Enable counters and exec the command:
272 walltime_nsecs
[run_idx
] = t1
- t0
;
274 for (counter
= 0; counter
< nr_counters
; counter
++)
275 read_counter(counter
);
277 return WEXITSTATUS(status
);
280 static void print_noise(u64
*count
, u64
*noise
)
283 fprintf(stderr
, " ( +- %7.3f%% )",
284 (double)noise
[0]/(count
[0]+1)*100.0);
287 static void nsec_printout(int counter
, u64
*count
, u64
*noise
)
289 double msecs
= (double)count
[0] / 1000000;
291 fprintf(stderr
, " %14.6f %-24s", msecs
, event_name(counter
));
293 if (attrs
[counter
].type
== PERF_TYPE_SOFTWARE
&&
294 attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
) {
296 if (walltime_nsecs_avg
)
297 fprintf(stderr
, " # %10.3f CPUs ",
298 (double)count
[0] / (double)walltime_nsecs_avg
);
300 print_noise(count
, noise
);
303 static void abs_printout(int counter
, u64
*count
, u64
*noise
)
305 fprintf(stderr
, " %14Ld %-24s", count
[0], event_name(counter
));
307 if (runtime_cycles_avg
&&
308 attrs
[counter
].type
== PERF_TYPE_HARDWARE
&&
309 attrs
[counter
].config
== PERF_COUNT_HW_INSTRUCTIONS
) {
311 fprintf(stderr
, " # %10.3f IPC ",
312 (double)count
[0] / (double)runtime_cycles_avg
);
314 if (runtime_nsecs_avg
) {
315 fprintf(stderr
, " # %10.3f M/sec",
316 (double)count
[0]/runtime_nsecs_avg
*1000.0);
319 print_noise(count
, noise
);
323 * Print out the results of a single counter:
325 static void print_counter(int counter
)
330 count
= event_res_avg
[counter
];
331 noise
= event_res_noise
[counter
];
332 scaled
= event_scaled_avg
[counter
];
335 fprintf(stderr
, " %14s %-24s\n",
336 "<not counted>", event_name(counter
));
340 if (nsec_counter(counter
))
341 nsec_printout(counter
, count
, noise
);
343 abs_printout(counter
, count
, noise
);
346 fprintf(stderr
, " (scaled from %.2f%%)",
347 (double) count
[2] / count
[1] * 100);
349 fprintf(stderr
, "\n");
353 * normalize_noise noise values down to stddev:
355 static void normalize_noise(u64
*val
)
359 res
= (double)*val
/ (run_count
* sqrt((double)run_count
));
364 static void update_avg(const char *name
, int idx
, u64
*avg
, u64
*val
)
369 fprintf(stderr
, "debug: %20s[%d]: %Ld\n", name
, idx
, *val
);
372 * Calculate the averages and noises:
374 static void calc_avg(void)
379 fprintf(stderr
, "\n");
381 for (i
= 0; i
< run_count
; i
++) {
382 update_avg("runtime", 0, &runtime_nsecs_avg
, runtime_nsecs
+ i
);
383 update_avg("walltime", 0, &walltime_nsecs_avg
, walltime_nsecs
+ i
);
384 update_avg("runtime_cycles", 0, &runtime_cycles_avg
, runtime_cycles
+ i
);
386 for (j
= 0; j
< nr_counters
; j
++) {
387 update_avg("counter/0", j
,
388 event_res_avg
[j
]+0, event_res
[i
][j
]+0);
389 update_avg("counter/1", j
,
390 event_res_avg
[j
]+1, event_res
[i
][j
]+1);
391 update_avg("counter/2", j
,
392 event_res_avg
[j
]+2, event_res
[i
][j
]+2);
393 if (event_scaled
[i
][j
] != -1)
394 update_avg("scaled", j
,
395 event_scaled_avg
+ j
, event_scaled
[i
]+j
);
397 event_scaled_avg
[j
] = -1;
400 runtime_nsecs_avg
/= run_count
;
401 walltime_nsecs_avg
/= run_count
;
402 runtime_cycles_avg
/= run_count
;
404 for (j
= 0; j
< nr_counters
; j
++) {
405 event_res_avg
[j
][0] /= run_count
;
406 event_res_avg
[j
][1] /= run_count
;
407 event_res_avg
[j
][2] /= run_count
;
410 for (i
= 0; i
< run_count
; i
++) {
411 runtime_nsecs_noise
+=
412 abs((s64
)(runtime_nsecs
[i
] - runtime_nsecs_avg
));
413 walltime_nsecs_noise
+=
414 abs((s64
)(walltime_nsecs
[i
] - walltime_nsecs_avg
));
415 runtime_cycles_noise
+=
416 abs((s64
)(runtime_cycles
[i
] - runtime_cycles_avg
));
418 for (j
= 0; j
< nr_counters
; j
++) {
419 event_res_noise
[j
][0] +=
420 abs((s64
)(event_res
[i
][j
][0] - event_res_avg
[j
][0]));
421 event_res_noise
[j
][1] +=
422 abs((s64
)(event_res
[i
][j
][1] - event_res_avg
[j
][1]));
423 event_res_noise
[j
][2] +=
424 abs((s64
)(event_res
[i
][j
][2] - event_res_avg
[j
][2]));
428 normalize_noise(&runtime_nsecs_noise
);
429 normalize_noise(&walltime_nsecs_noise
);
430 normalize_noise(&runtime_cycles_noise
);
432 for (j
= 0; j
< nr_counters
; j
++) {
433 normalize_noise(&event_res_noise
[j
][0]);
434 normalize_noise(&event_res_noise
[j
][1]);
435 normalize_noise(&event_res_noise
[j
][2]);
439 static void print_stat(int argc
, const char **argv
)
447 fprintf(stderr
, "\n");
448 fprintf(stderr
, " Performance counter stats for \'%s", argv
[0]);
450 for (i
= 1; i
< argc
; i
++)
451 fprintf(stderr
, " %s", argv
[i
]);
453 fprintf(stderr
, "\'");
455 fprintf(stderr
, " (%d runs)", run_count
);
456 fprintf(stderr
, ":\n\n");
458 for (counter
= 0; counter
< nr_counters
; counter
++)
459 print_counter(counter
);
461 fprintf(stderr
, "\n");
462 fprintf(stderr
, " %14.9f seconds time elapsed",
463 (double)walltime_nsecs_avg
/1e9
);
465 fprintf(stderr
, " ( +- %7.3f%% )",
466 100.0*(double)walltime_nsecs_noise
/(double)walltime_nsecs_avg
);
468 fprintf(stderr
, "\n\n");
471 static volatile int signr
= -1;
473 static void skip_signal(int signo
)
478 static void sig_atexit(void)
483 signal(signr
, SIG_DFL
);
484 kill(getpid(), signr
);
487 static const char * const stat_usage
[] = {
488 "perf stat [<options>] <command>",
492 static const struct option options
[] = {
493 OPT_CALLBACK('e', "event", NULL
, "event",
494 "event selector. use 'perf list' to list available events",
496 OPT_BOOLEAN('i', "inherit", &inherit
,
497 "child tasks inherit counters"),
498 OPT_INTEGER('p', "pid", &target_pid
,
499 "stat events on existing pid"),
500 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
501 "system-wide collection from all CPUs"),
502 OPT_BOOLEAN('S', "scale", &scale
,
503 "scale/normalize counters"),
504 OPT_BOOLEAN('v', "verbose", &verbose
,
505 "be more verbose (show counter open errors, etc)"),
506 OPT_INTEGER('r', "repeat", &run_count
,
507 "repeat command and print average + stddev (max: 100)"),
508 OPT_BOOLEAN('n', "null", &null_run
,
509 "null run - dont start any counters"),
513 int cmd_stat(int argc
, const char **argv
, const char *prefix
)
517 argc
= parse_options(argc
, argv
, options
, stat_usage
, 0);
519 usage_with_options(stat_usage
, options
);
520 if (run_count
<= 0 || run_count
> MAX_RUN
)
521 usage_with_options(stat_usage
, options
);
523 /* Set attrs and nr_counters if no event is selected and !null_run */
524 if (!null_run
&& !nr_counters
) {
525 memcpy(attrs
, default_attrs
, sizeof(default_attrs
));
526 nr_counters
= ARRAY_SIZE(default_attrs
);
529 nr_cpus
= sysconf(_SC_NPROCESSORS_ONLN
);
530 assert(nr_cpus
<= MAX_NR_CPUS
);
531 assert(nr_cpus
>= 0);
534 * We dont want to block the signals - that would cause
535 * child tasks to inherit that and Ctrl-C would not work.
536 * What we want is for Ctrl-C to work in the exec()-ed
537 * task, but being ignored by perf stat itself:
540 signal(SIGINT
, skip_signal
);
541 signal(SIGALRM
, skip_signal
);
542 signal(SIGABRT
, skip_signal
);
545 for (run_idx
= 0; run_idx
< run_count
; run_idx
++) {
546 if (run_count
!= 1 && verbose
)
547 fprintf(stderr
, "[ perf stat: executing run #%d ... ]\n", run_idx
+ 1);
548 status
= run_perf_stat(argc
, argv
);
551 print_stat(argc
, argv
);