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>
36 * Released under the GPL v2. (and only v2, not any later version)
41 #include "util/util.h"
42 #include "util/parse-options.h"
43 #include "util/parse-events.h"
45 #include <sys/prctl.h>
47 static struct perf_counter_attr default_attrs
[MAX_COUNTERS
] = {
49 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_TASK_CLOCK
},
50 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CONTEXT_SWITCHES
},
51 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_CPU_MIGRATIONS
},
52 { .type
= PERF_TYPE_SOFTWARE
, .config
= PERF_COUNT_SW_PAGE_FAULTS
},
54 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CPU_CYCLES
},
55 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_INSTRUCTIONS
},
56 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_REFERENCES
},
57 { .type
= PERF_TYPE_HARDWARE
, .config
= PERF_COUNT_HW_CACHE_MISSES
},
61 static int system_wide
= 0;
62 static int inherit
= 1;
63 static int verbose
= 0;
65 static int fd
[MAX_NR_CPUS
][MAX_COUNTERS
];
67 static int target_pid
= -1;
68 static int nr_cpus
= 0;
69 static unsigned int page_size
;
73 static const unsigned int default_count
[] = {
82 static __u64 event_res
[MAX_COUNTERS
][3];
83 static __u64 event_scaled
[MAX_COUNTERS
];
85 static __u64 runtime_nsecs
;
86 static __u64 walltime_nsecs
;
87 static __u64 runtime_cycles
;
89 static void create_perf_stat_counter(int counter
)
91 struct perf_counter_attr
*attr
= attrs
+ counter
;
94 attr
->read_format
= PERF_FORMAT_TOTAL_TIME_ENABLED
|
95 PERF_FORMAT_TOTAL_TIME_RUNNING
;
99 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
100 fd
[cpu
][counter
] = sys_perf_counter_open(attr
, -1, cpu
, -1, 0);
101 if (fd
[cpu
][counter
] < 0 && verbose
) {
102 printf("Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n", counter
, fd
[cpu
][counter
], strerror(errno
));
106 attr
->inherit
= inherit
;
109 fd
[0][counter
] = sys_perf_counter_open(attr
, 0, -1, -1, 0);
110 if (fd
[0][counter
] < 0 && verbose
) {
111 printf("Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n", counter
, fd
[0][counter
], strerror(errno
));
117 * Does the counter have nsecs as a unit?
119 static inline int nsec_counter(int counter
)
121 if (attrs
[counter
].type
!= PERF_TYPE_SOFTWARE
)
124 if (attrs
[counter
].config
== PERF_COUNT_SW_CPU_CLOCK
)
127 if (attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
)
134 * Read out the results of a single counter:
136 static void read_counter(int counter
)
138 __u64
*count
, single_count
[3];
143 count
= event_res
[counter
];
145 count
[0] = count
[1] = count
[2] = 0;
148 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
149 if (fd
[cpu
][counter
] < 0)
152 res
= read(fd
[cpu
][counter
], single_count
, nv
* sizeof(__u64
));
153 assert(res
== nv
* sizeof(__u64
));
155 count
[0] += single_count
[0];
157 count
[1] += single_count
[1];
158 count
[2] += single_count
[2];
165 event_scaled
[counter
] = -1;
170 if (count
[2] < count
[1]) {
171 event_scaled
[counter
] = 1;
172 count
[0] = (unsigned long long)
173 ((double)count
[0] * count
[1] / count
[2] + 0.5);
177 * Save the full runtime - to allow normalization during printout:
179 if (attrs
[counter
].type
== PERF_TYPE_SOFTWARE
&&
180 attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
)
181 runtime_nsecs
= count
[0];
182 if (attrs
[counter
].type
== PERF_TYPE_HARDWARE
&&
183 attrs
[counter
].config
== PERF_COUNT_HW_CPU_CYCLES
)
184 runtime_cycles
= count
[0];
187 static void nsec_printout(int counter
, __u64
*count
)
189 double msecs
= (double)count
[0] / 1000000;
191 fprintf(stderr
, " %14.6f %-20s", msecs
, event_name(counter
));
193 if (attrs
[counter
].type
== PERF_TYPE_SOFTWARE
&&
194 attrs
[counter
].config
== PERF_COUNT_SW_TASK_CLOCK
) {
197 fprintf(stderr
, " # %10.3f CPUs",
198 (double)count
[0] / (double)walltime_nsecs
);
202 static void abs_printout(int counter
, __u64
*count
)
204 fprintf(stderr
, " %14Ld %-20s", count
[0], event_name(counter
));
206 if (runtime_cycles
&&
207 attrs
[counter
].type
== PERF_TYPE_HARDWARE
&&
208 attrs
[counter
].config
== PERF_COUNT_HW_INSTRUCTIONS
) {
210 fprintf(stderr
, " # %10.3f IPC",
211 (double)count
[0] / (double)runtime_cycles
);
217 fprintf(stderr
, " # %10.3f M/sec",
218 (double)count
[0]/runtime_nsecs
*1000.0);
222 * Print out the results of a single counter:
224 static void print_counter(int counter
)
229 count
= event_res
[counter
];
230 scaled
= event_scaled
[counter
];
233 fprintf(stderr
, " %14s %-20s\n",
234 "<not counted>", event_name(counter
));
238 if (nsec_counter(counter
))
239 nsec_printout(counter
, count
);
241 abs_printout(counter
, count
);
244 fprintf(stderr
, " (scaled from %.2f%%)",
245 (double) count
[2] / count
[1] * 100);
247 fprintf(stderr
, "\n");
250 static int do_perf_stat(int argc
, const char **argv
)
252 unsigned long long t0
, t1
;
261 for (counter
= 0; counter
< nr_counters
; counter
++)
262 create_perf_stat_counter(counter
);
265 * Enable counters and exec the command:
268 prctl(PR_TASK_PERF_COUNTERS_ENABLE
);
270 if ((pid
= fork()) < 0)
271 perror("failed to fork");
274 if (execvp(argv
[0], (char **)argv
)) {
280 while (wait(&status
) >= 0)
283 prctl(PR_TASK_PERF_COUNTERS_DISABLE
);
286 walltime_nsecs
= t1
- t0
;
290 fprintf(stderr
, "\n");
291 fprintf(stderr
, " Performance counter stats for \'%s", argv
[0]);
293 for (i
= 1; i
< argc
; i
++)
294 fprintf(stderr
, " %s", argv
[i
]);
296 fprintf(stderr
, "\':\n");
297 fprintf(stderr
, "\n");
299 for (counter
= 0; counter
< nr_counters
; counter
++)
300 read_counter(counter
);
302 for (counter
= 0; counter
< nr_counters
; counter
++)
303 print_counter(counter
);
306 fprintf(stderr
, "\n");
307 fprintf(stderr
, " %14.9f seconds time elapsed.\n", (double)(t1
-t0
)/1e9
);
308 fprintf(stderr
, "\n");
313 static volatile int signr
= -1;
315 static void skip_signal(int signo
)
320 static void sig_atexit(void)
325 signal(signr
, SIG_DFL
);
326 kill(getpid(), signr
);
329 static const char * const stat_usage
[] = {
330 "perf stat [<options>] <command>",
334 static const struct option options
[] = {
335 OPT_CALLBACK('e', "event", NULL
, "event",
336 "event selector. use 'perf list' to list available events",
338 OPT_BOOLEAN('i', "inherit", &inherit
,
339 "child tasks inherit counters"),
340 OPT_INTEGER('p', "pid", &target_pid
,
341 "stat events on existing pid"),
342 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
343 "system-wide collection from all CPUs"),
344 OPT_BOOLEAN('S', "scale", &scale
,
345 "scale/normalize counters"),
346 OPT_BOOLEAN('v', "verbose", &verbose
,
347 "be more verbose (show counter open errors, etc)"),
351 int cmd_stat(int argc
, const char **argv
, const char *prefix
)
353 page_size
= sysconf(_SC_PAGE_SIZE
);
355 memcpy(attrs
, default_attrs
, sizeof(attrs
));
357 argc
= parse_options(argc
, argv
, options
, stat_usage
, 0);
359 usage_with_options(stat_usage
, options
);
364 nr_cpus
= sysconf(_SC_NPROCESSORS_ONLN
);
365 assert(nr_cpus
<= MAX_NR_CPUS
);
366 assert(nr_cpus
>= 0);
369 * We dont want to block the signals - that would cause
370 * child tasks to inherit that and Ctrl-C would not work.
371 * What we want is for Ctrl-C to work in the exec()-ed
372 * task, but being ignored by perf stat itself:
375 signal(SIGINT
, skip_signal
);
376 signal(SIGALRM
, skip_signal
);
377 signal(SIGABRT
, skip_signal
);
379 return do_perf_stat(argc
, argv
);