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"
48 #include <sys/prctl.h>
51 static struct perf_counter_attr default_attrs
[] = {
53 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_TASK_CLOCK
},
54 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CONTEXT_SWITCHES
},
55 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CPU_MIGRATIONS
},
56 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_PAGE_FAULTS
},
58 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CPU_CYCLES
},
59 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_INSTRUCTIONS
},
60 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_REFERENCES
},
61 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_MISSES
},
65 static int system_wide
= 0;
66 static unsigned int nr_cpus
= 0;
67 static int run_idx
= 0;
69 static int run_count
= 1;
70 static int inherit
= 1;
72 static int target_pid
= -1;
73 static int null_run
= 0;
75 static int fd
[MAX_NR_CPUS
][MAX_COUNTERS
];
77 static u64 event_res
[MAX_COUNTERS
][3];
78 static u64 event_scaled
[MAX_COUNTERS
];
86 static void update_stats(struct stats
*stats
, u64 val
)
91 stats
->sum_sq
+= sq
* sq
;
94 static double avg_stats(struct stats
*stats
)
96 return stats
->sum
/ run_count
;
100 * stddev = sqrt(1/N (\Sum n_i^2) - avg(n)^2)
102 static double stddev_stats(struct stats
*stats
)
104 double avg
= stats
->sum
/ run_count
;
106 return sqrt(stats
->sum_sq
/run_count
- avg
*avg
);
109 struct stats event_res_stats
[MAX_COUNTERS
][3];
110 struct stats event_scaled_stats
[MAX_COUNTERS
];
111 struct stats runtime_nsecs_stats
;
112 struct stats walltime_nsecs_stats
;
113 struct stats runtime_cycles_stats
;
115 #define MATCH_EVENT(t, c, counter) \
116 (attrs[counter].type == PERF_TYPE_##t && \
117 attrs[counter].config == PERF_COUNT_##c)
119 #define ERR_PERF_OPEN \
120 "Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"
122 static void create_perf_stat_counter(int counter
, int pid
)
124 struct perf_counter_attr
*attr
= attrs
+ counter
;
127 attr
->read_format
= PERF_FORMAT_TOTAL_TIME_ENABLED
|
128 PERF_FORMAT_TOTAL_TIME_RUNNING
;
133 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
134 fd
[cpu
][counter
] = sys_perf_counter_open(attr
, -1, cpu
, -1, 0);
135 if (fd
[cpu
][counter
] < 0 && verbose
)
136 fprintf(stderr
, ERR_PERF_OPEN
, counter
,
137 fd
[cpu
][counter
], strerror(errno
));
140 attr
->inherit
= inherit
;
142 attr
->enable_on_exec
= 1;
144 fd
[0][counter
] = sys_perf_counter_open(attr
, pid
, -1, -1, 0);
145 if (fd
[0][counter
] < 0 && verbose
)
146 fprintf(stderr
, ERR_PERF_OPEN
, counter
,
147 fd
[0][counter
], strerror(errno
));
152 * Does the counter have nsecs as a unit?
154 static inline int nsec_counter(int counter
)
156 if (MATCH_EVENT(SOFTWARE
, SW_CPU_CLOCK
, counter
) ||
157 MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
))
164 * Read out the results of a single counter:
166 static void read_counter(int counter
)
168 u64
*count
, single_count
[3];
174 count
= event_res
[counter
];
176 count
[0] = count
[1] = count
[2] = 0;
179 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
180 if (fd
[cpu
][counter
] < 0)
183 res
= read(fd
[cpu
][counter
], single_count
, nv
* sizeof(u64
));
184 assert(res
== nv
* sizeof(u64
));
186 close(fd
[cpu
][counter
]);
187 fd
[cpu
][counter
] = -1;
189 count
[0] += single_count
[0];
191 count
[1] += single_count
[1];
192 count
[2] += single_count
[2];
199 event_scaled
[counter
] = -1;
204 if (count
[2] < count
[1]) {
205 event_scaled
[counter
] = 1;
206 count
[0] = (unsigned long long)
207 ((double)count
[0] * count
[1] / count
[2] + 0.5);
211 for (i
= 0; i
< 3; i
++)
212 update_stats(&event_res_stats
[counter
][i
], count
[i
]);
215 fprintf(stderr
, "%s: %Ld %Ld %Ld\n", event_name(counter
),
216 count
[0], count
[1], count
[2]);
220 * Save the full runtime - to allow normalization during printout:
222 if (MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
))
223 update_stats(&runtime_nsecs_stats
, count
[0]);
224 if (MATCH_EVENT(HARDWARE
, HW_CPU_CYCLES
, counter
))
225 update_stats(&runtime_cycles_stats
, count
[0]);
228 static int run_perf_stat(int argc __used
, const char **argv
)
230 unsigned long long t0
, t1
;
234 int child_ready_pipe
[2], go_pipe
[2];
240 if (pipe(child_ready_pipe
) < 0 || pipe(go_pipe
) < 0) {
241 perror("failed to create pipes");
245 if ((pid
= fork()) < 0)
246 perror("failed to fork");
249 close(child_ready_pipe
[0]);
251 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
254 * Do a dummy execvp to get the PLT entry resolved,
255 * so we avoid the resolver overhead on the real
258 execvp("", (char **)argv
);
261 * Tell the parent we're ready to go
263 close(child_ready_pipe
[1]);
266 * Wait until the parent tells us to go.
268 if (read(go_pipe
[0], &buf
, 1) == -1)
269 perror("unable to read pipe");
271 execvp(argv
[0], (char **)argv
);
278 * Wait for the child to be ready to exec.
280 close(child_ready_pipe
[1]);
282 if (read(child_ready_pipe
[0], &buf
, 1) == -1)
283 perror("unable to read pipe");
284 close(child_ready_pipe
[0]);
286 for (counter
= 0; counter
< nr_counters
; counter
++)
287 create_perf_stat_counter(counter
, pid
);
290 * Enable counters and exec the command:
299 update_stats(&walltime_nsecs_stats
, t1
- t0
);
301 for (counter
= 0; counter
< nr_counters
; counter
++)
302 read_counter(counter
);
304 return WEXITSTATUS(status
);
307 static void print_noise(double avg
, double stddev
)
310 fprintf(stderr
, " ( +- %7.3f%% )", 100*stddev
/ avg
);
313 static void nsec_printout(int counter
, double avg
, double stddev
)
315 double msecs
= avg
/ 1e6
;
317 fprintf(stderr
, " %14.6f %-24s", msecs
, event_name(counter
));
319 if (MATCH_EVENT(SOFTWARE
, SW_TASK_CLOCK
, counter
)) {
320 fprintf(stderr
, " # %10.3f CPUs ",
321 avg
/ avg_stats(&walltime_nsecs_stats
));
323 print_noise(avg
, stddev
);
326 static void abs_printout(int counter
, double avg
, double stddev
)
328 fprintf(stderr
, " %14.0f %-24s", avg
, event_name(counter
));
330 if (MATCH_EVENT(HARDWARE
, HW_INSTRUCTIONS
, counter
)) {
331 fprintf(stderr
, " # %10.3f IPC ",
332 avg
/ avg_stats(&runtime_cycles_stats
));
334 fprintf(stderr
, " # %10.3f M/sec",
335 1000.0 * avg
/ avg_stats(&runtime_nsecs_stats
));
337 print_noise(avg
, stddev
);
341 * Print out the results of a single counter:
343 static void print_counter(int counter
)
348 avg
= avg_stats(&event_res_stats
[counter
][0]);
349 stddev
= stddev_stats(&event_res_stats
[counter
][0]);
350 scaled
= avg_stats(&event_scaled_stats
[counter
]);
353 fprintf(stderr
, " %14s %-24s\n",
354 "<not counted>", event_name(counter
));
358 if (nsec_counter(counter
))
359 nsec_printout(counter
, avg
, stddev
);
361 abs_printout(counter
, avg
, stddev
);
364 double avg_enabled
, avg_running
;
366 avg_enabled
= avg_stats(&event_res_stats
[counter
][1]);
367 avg_running
= avg_stats(&event_res_stats
[counter
][2]);
369 fprintf(stderr
, " (scaled from %.2f%%)",
370 100 * avg_running
/ avg_enabled
);
373 fprintf(stderr
, "\n");
376 static void print_stat(int argc
, const char **argv
)
382 fprintf(stderr
, "\n");
383 fprintf(stderr
, " Performance counter stats for \'%s", argv
[0]);
385 for (i
= 1; i
< argc
; i
++)
386 fprintf(stderr
, " %s", argv
[i
]);
388 fprintf(stderr
, "\'");
390 fprintf(stderr
, " (%d runs)", run_count
);
391 fprintf(stderr
, ":\n\n");
393 for (counter
= 0; counter
< nr_counters
; counter
++)
394 print_counter(counter
);
396 fprintf(stderr
, "\n");
397 fprintf(stderr
, " %14.9f seconds time elapsed",
398 avg_stats(&walltime_nsecs_stats
)/1e9
);
400 fprintf(stderr
, " ( +- %7.3f%% )",
401 100*stddev_stats(&walltime_nsecs_stats
) /
402 avg_stats(&walltime_nsecs_stats
));
404 fprintf(stderr
, "\n\n");
407 static volatile int signr
= -1;
409 static void skip_signal(int signo
)
414 static void sig_atexit(void)
419 signal(signr
, SIG_DFL
);
420 kill(getpid(), signr
);
423 static const char * const stat_usage
[] = {
424 "perf stat [<options>] <command>",
428 static const struct option options
[] = {
429 OPT_CALLBACK('e', "event", NULL
, "event",
430 "event selector. use 'perf list' to list available events",
432 OPT_BOOLEAN('i', "inherit", &inherit
,
433 "child tasks inherit counters"),
434 OPT_INTEGER('p', "pid", &target_pid
,
435 "stat events on existing pid"),
436 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
437 "system-wide collection from all CPUs"),
438 OPT_BOOLEAN('c', "scale", &scale
,
439 "scale/normalize counters"),
440 OPT_BOOLEAN('v', "verbose", &verbose
,
441 "be more verbose (show counter open errors, etc)"),
442 OPT_INTEGER('r', "repeat", &run_count
,
443 "repeat command and print average + stddev (max: 100)"),
444 OPT_BOOLEAN('n', "null", &null_run
,
445 "null run - dont start any counters"),
449 int cmd_stat(int argc
, const char **argv
, const char *prefix __used
)
453 argc
= parse_options(argc
, argv
, options
, stat_usage
,
454 PARSE_OPT_STOP_AT_NON_OPTION
);
456 usage_with_options(stat_usage
, options
);
458 usage_with_options(stat_usage
, options
);
460 /* Set attrs and nr_counters if no event is selected and !null_run */
461 if (!null_run
&& !nr_counters
) {
462 memcpy(attrs
, default_attrs
, sizeof(default_attrs
));
463 nr_counters
= ARRAY_SIZE(default_attrs
);
466 nr_cpus
= sysconf(_SC_NPROCESSORS_ONLN
);
467 assert(nr_cpus
<= MAX_NR_CPUS
);
468 assert((int)nr_cpus
>= 0);
471 * We dont want to block the signals - that would cause
472 * child tasks to inherit that and Ctrl-C would not work.
473 * What we want is for Ctrl-C to work in the exec()-ed
474 * task, but being ignored by perf stat itself:
477 signal(SIGINT
, skip_signal
);
478 signal(SIGALRM
, skip_signal
);
479 signal(SIGABRT
, skip_signal
);
482 for (run_idx
= 0; run_idx
< run_count
; run_idx
++) {
483 if (run_count
!= 1 && verbose
)
484 fprintf(stderr
, "[ perf stat: executing run #%d ... ]\n", run_idx
+ 1);
485 status
= run_perf_stat(argc
, argv
);
488 print_stat(argc
, argv
);