blob: e619ac89dff5068ad7c7c73f3b532fc6b551834a [file] [log] [blame]
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001/*
Ingo Molnarbf9e1872009-06-02 23:37:05 +02002 * builtin-stat.c
3 *
4 * Builtin stat command: Give a precise performance counters summary
5 * overview about any workload, CPU or specific PID.
6 *
7 * Sample output:
Ingo Molnarddcacfa2009-04-20 15:37:32 +02008
Ingo Molnarbf9e1872009-06-02 23:37:05 +02009 $ perf stat ~/hackbench 10
10 Time: 0.104
Ingo Molnarddcacfa2009-04-20 15:37:32 +020011
Ingo Molnarbf9e1872009-06-02 23:37:05 +020012 Performance counter stats for '/home/mingo/hackbench':
Ingo Molnarddcacfa2009-04-20 15:37:32 +020013
Ingo Molnarbf9e1872009-06-02 23:37:05 +020014 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
Ingo Molnarddcacfa2009-04-20 15:37:32 +020022
Ingo Molnarbf9e1872009-06-02 23:37:05 +020023 Wall-clock time elapsed: 123.786620 msecs
Ingo Molnarddcacfa2009-04-20 15:37:32 +020024
Ingo Molnar52425192009-05-26 09:17:18 +020025 *
26 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
27 *
28 * Improvements and fixes by:
29 *
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>
Jaswinder Singh Rajput6e750a8f2009-06-27 03:02:07 +053035 * Jaswinder Singh Rajput <jaswinder@kernel.org>
Ingo Molnar52425192009-05-26 09:17:18 +020036 *
37 * Released under the GPL v2. (and only v2, not any later version)
Ingo Molnarddcacfa2009-04-20 15:37:32 +020038 */
39
Peter Zijlstra1a482f32009-05-23 18:28:58 +020040#include "perf.h"
Ingo Molnar16f762a2009-05-27 09:10:38 +020041#include "builtin.h"
Ingo Molnar148be2c2009-04-27 08:02:14 +020042#include "util/util.h"
Ingo Molnar52425192009-05-26 09:17:18 +020043#include "util/parse-options.h"
44#include "util/parse-events.h"
Frederic Weisbecker8f28827a2009-08-16 22:05:48 +020045#include "util/event.h"
46#include "util/debug.h"
Liming Wang60666c62009-12-31 16:05:50 +080047#include "util/header.h"
Paul Mackerrasa12b51c2010-03-10 20:36:09 +110048#include "util/cpumap.h"
Zhang, Yanmind6d901c2010-03-18 11:36:05 -030049#include "util/thread.h"
Ingo Molnarddcacfa2009-04-20 15:37:32 +020050
Ingo Molnarddcacfa2009-04-20 15:37:32 +020051#include <sys/prctl.h>
Ingo Molnar42202dd2009-06-13 14:57:28 +020052#include <math.h>
Peter Zijlstra16c8a102009-05-05 17:50:27 +020053
Ingo Molnarcdd6c482009-09-21 12:02:48 +020054static struct perf_event_attr default_attrs[] = {
Ingo Molnara21ca2c2009-06-06 09:58:57 +020055
Ingo Molnar56aab462009-10-19 13:27:08 +020056 { .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 },
Ingo Molnara21ca2c2009-06-06 09:58:57 +020060
Ingo Molnar56aab462009-10-19 13:27:08 +020061 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES },
62 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS },
Ingo Molnar56aab462009-10-19 13:27:08 +020063 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
64 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES },
Ingo Molnardd86e722009-10-19 13:33:03 +020065 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES },
66 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES },
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +020067
Ingo Molnara21ca2c2009-06-06 09:58:57 +020068};
69
Ian Munsiec0555642010-04-13 18:37:33 +100070static bool system_wide = false;
Ingo Molnarf37a2912009-07-01 12:37:06 +020071static unsigned int nr_cpus = 0;
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +053072static int run_idx = 0;
73
74static int run_count = 1;
Ian Munsiec0555642010-04-13 18:37:33 +100075static bool inherit = true;
76static bool scale = true;
Chris Wilson933da832009-10-04 01:35:01 +010077static pid_t target_pid = -1;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -030078static pid_t target_tid = -1;
79static pid_t *all_tids = NULL;
80static int thread_num = 0;
Chris Wilson933da832009-10-04 01:35:01 +010081static pid_t child_pid = -1;
Ian Munsiec0555642010-04-13 18:37:33 +100082static bool null_run = false;
Ingo Molnarddcacfa2009-04-20 15:37:32 +020083
Zhang, Yanmind6d901c2010-03-18 11:36:05 -030084static int *fd[MAX_NR_CPUS][MAX_COUNTERS];
Ingo Molnarddcacfa2009-04-20 15:37:32 +020085
Peter Zijlstra63d40de2009-09-04 17:03:13 +020086static int event_scaled[MAX_COUNTERS];
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +053087
Liming Wang60666c62009-12-31 16:05:50 +080088static volatile int done = 0;
89
Peter Zijlstra506d4bc2009-09-04 15:36:12 +020090struct stats
91{
Peter Zijlstra8a026312009-09-04 17:26:26 +020092 double n, mean, M2;
Peter Zijlstra506d4bc2009-09-04 15:36:12 +020093};
Ingo Molnar42202dd2009-06-13 14:57:28 +020094
Peter Zijlstra9e9772c2009-09-04 15:36:08 +020095static void update_stats(struct stats *stats, u64 val)
96{
Peter Zijlstra8a026312009-09-04 17:26:26 +020097 double delta;
Peter Zijlstra9e9772c2009-09-04 15:36:08 +020098
Peter Zijlstra8a026312009-09-04 17:26:26 +020099 stats->n++;
100 delta = val - stats->mean;
101 stats->mean += delta / stats->n;
102 stats->M2 += delta*(val - stats->mean);
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200103}
104
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200105static double avg_stats(struct stats *stats)
106{
Peter Zijlstra8a026312009-09-04 17:26:26 +0200107 return stats->mean;
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200108}
Ingo Molnar42202dd2009-06-13 14:57:28 +0200109
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200110/*
Peter Zijlstra63d40de2009-09-04 17:03:13 +0200111 * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
112 *
Peter Zijlstra8a026312009-09-04 17:26:26 +0200113 * (\Sum n_i^2) - ((\Sum n_i)^2)/n
114 * s^2 = -------------------------------
115 * n - 1
Peter Zijlstra63d40de2009-09-04 17:03:13 +0200116 *
117 * http://en.wikipedia.org/wiki/Stddev
118 *
119 * The std dev of the mean is related to the std dev by:
120 *
121 * s
122 * s_mean = -------
123 * sqrt(n)
124 *
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200125 */
126static double stddev_stats(struct stats *stats)
127{
Peter Zijlstra8a026312009-09-04 17:26:26 +0200128 double variance = stats->M2 / (stats->n - 1);
129 double variance_mean = variance / stats->n;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200130
Peter Zijlstra63d40de2009-09-04 17:03:13 +0200131 return sqrt(variance_mean);
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200132}
Ingo Molnar42202dd2009-06-13 14:57:28 +0200133
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200134struct stats event_res_stats[MAX_COUNTERS][3];
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200135struct stats runtime_nsecs_stats;
136struct stats walltime_nsecs_stats;
137struct stats runtime_cycles_stats;
Anton Blanchard11018202009-10-18 22:29:23 +1100138struct stats runtime_branches_stats;
Ingo Molnarbe1ac0d2009-05-29 09:10:54 +0200139
Jaswinder Singh Rajputb9ebdcc2009-07-01 15:05:09 +0530140#define MATCH_EVENT(t, c, counter) \
141 (attrs[counter].type == PERF_TYPE_##t && \
142 attrs[counter].config == PERF_COUNT_##c)
143
Jaswinder Singh Rajputcca03c02009-06-23 17:12:49 +0530144#define ERR_PERF_OPEN \
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200145"Error: counter %d, sys_perf_event_open() syscall returned with %d (%s)\n"
Jaswinder Singh Rajputcca03c02009-06-23 17:12:49 +0530146
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300147static int create_perf_stat_counter(int counter)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200148{
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200149 struct perf_event_attr *attr = attrs + counter;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300150 int thread;
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300151 int ncreated = 0;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200152
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200153 if (scale)
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200154 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
155 PERF_FORMAT_TOTAL_TIME_RUNNING;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200156
157 if (system_wide) {
Ingo Molnarf37a2912009-07-01 12:37:06 +0200158 unsigned int cpu;
159
Jaswinder Singh Rajputcca03c02009-06-23 17:12:49 +0530160 for (cpu = 0; cpu < nr_cpus; cpu++) {
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300161 fd[cpu][counter][0] = sys_perf_event_open(attr,
162 -1, cpumap[cpu], -1, 0);
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300163 if (fd[cpu][counter][0] < 0)
164 pr_debug(ERR_PERF_OPEN, counter,
165 fd[cpu][counter][0], strerror(errno));
166 else
167 ++ncreated;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200168 }
169 } else {
Paul Mackerras57e79862009-06-30 16:07:19 +1000170 attr->inherit = inherit;
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300171 if (target_pid == -1) {
172 attr->disabled = 1;
173 attr->enable_on_exec = 1;
174 }
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300175 for (thread = 0; thread < thread_num; thread++) {
176 fd[0][counter][thread] = sys_perf_event_open(attr,
177 all_tids[thread], -1, -1, 0);
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300178 if (fd[0][counter][thread] < 0)
179 pr_debug(ERR_PERF_OPEN, counter,
180 fd[0][counter][thread],
181 strerror(errno));
182 else
183 ++ncreated;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300184 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200185 }
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300186
187 return ncreated;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200188}
189
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200190/*
191 * Does the counter have nsecs as a unit?
192 */
193static inline int nsec_counter(int counter)
194{
Jaswinder Singh Rajputb9ebdcc2009-07-01 15:05:09 +0530195 if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
196 MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200197 return 1;
198
199 return 0;
200}
201
202/*
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200203 * Read out the results of a single counter:
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200204 */
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200205static void read_counter(int counter)
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200206{
Peter Zijlstra849abde2009-09-04 18:23:38 +0200207 u64 count[3], single_count[3];
Ingo Molnarf37a2912009-07-01 12:37:06 +0200208 unsigned int cpu;
209 size_t res, nv;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200210 int scaled;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300211 int i, thread;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200212
213 count[0] = count[1] = count[2] = 0;
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200214
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200215 nv = scale ? 3 : 1;
Jaswinder Singh Rajputcca03c02009-06-23 17:12:49 +0530216 for (cpu = 0; cpu < nr_cpus; cpu++) {
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300217 for (thread = 0; thread < thread_num; thread++) {
218 if (fd[cpu][counter][thread] < 0)
219 continue;
Ingo Molnar743ee1f2009-06-07 17:06:46 +0200220
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300221 res = read(fd[cpu][counter][thread],
222 single_count, nv * sizeof(u64));
223 assert(res == nv * sizeof(u64));
Ingo Molnarf37a2912009-07-01 12:37:06 +0200224
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300225 close(fd[cpu][counter][thread]);
226 fd[cpu][counter][thread] = -1;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200227
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300228 count[0] += single_count[0];
229 if (scale) {
230 count[1] += single_count[1];
231 count[2] += single_count[2];
232 }
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200233 }
234 }
235
236 scaled = 0;
237 if (scale) {
238 if (count[2] == 0) {
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200239 event_scaled[counter] = -1;
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200240 count[0] = 0;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200241 return;
242 }
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200243
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200244 if (count[2] < count[1]) {
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200245 event_scaled[counter] = 1;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200246 count[0] = (unsigned long long)
247 ((double)count[0] * count[1] / count[2] + 0.5);
248 }
249 }
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200250
251 for (i = 0; i < 3; i++)
252 update_stats(&event_res_stats[counter][i], count[i]);
253
254 if (verbose) {
255 fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
256 count[0], count[1], count[2]);
257 }
258
Ingo Molnarbe1ac0d2009-05-29 09:10:54 +0200259 /*
260 * Save the full runtime - to allow normalization during printout:
261 */
Jaswinder Singh Rajputb9ebdcc2009-07-01 15:05:09 +0530262 if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200263 update_stats(&runtime_nsecs_stats, count[0]);
Jaswinder Singh Rajputb9ebdcc2009-07-01 15:05:09 +0530264 if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200265 update_stats(&runtime_cycles_stats, count[0]);
Anton Blanchard11018202009-10-18 22:29:23 +1100266 if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
267 update_stats(&runtime_branches_stats, count[0]);
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200268}
269
Ingo Molnarf37a2912009-07-01 12:37:06 +0200270static int run_perf_stat(int argc __used, const char **argv)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200271{
272 unsigned long long t0, t1;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200273 int status = 0;
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300274 int counter, ncreated = 0;
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000275 int child_ready_pipe[2], go_pipe[2];
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300276 const bool forks = (argc > 0);
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000277 char buf;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200278
279 if (!system_wide)
280 nr_cpus = 1;
281
Liming Wang60666c62009-12-31 16:05:50 +0800282 if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000283 perror("failed to create pipes");
284 exit(1);
285 }
286
Liming Wang60666c62009-12-31 16:05:50 +0800287 if (forks) {
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300288 if ((child_pid = fork()) < 0)
Liming Wang60666c62009-12-31 16:05:50 +0800289 perror("failed to fork");
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000290
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300291 if (!child_pid) {
Liming Wang60666c62009-12-31 16:05:50 +0800292 close(child_ready_pipe[0]);
293 close(go_pipe[1]);
294 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
295
296 /*
297 * Do a dummy execvp to get the PLT entry resolved,
298 * so we avoid the resolver overhead on the real
299 * execvp call.
300 */
301 execvp("", (char **)argv);
302
303 /*
304 * Tell the parent we're ready to go
305 */
306 close(child_ready_pipe[1]);
307
308 /*
309 * Wait until the parent tells us to go.
310 */
311 if (read(go_pipe[0], &buf, 1) == -1)
312 perror("unable to read pipe");
313
314 execvp(argv[0], (char **)argv);
315
316 perror(argv[0]);
317 exit(-1);
318 }
319
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300320 if (target_tid == -1 && target_pid == -1 && !system_wide)
321 all_tids[0] = child_pid;
322
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000323 /*
Liming Wang60666c62009-12-31 16:05:50 +0800324 * Wait for the child to be ready to exec.
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000325 */
326 close(child_ready_pipe[1]);
Liming Wang60666c62009-12-31 16:05:50 +0800327 close(go_pipe[0]);
328 if (read(child_ready_pipe[0], &buf, 1) == -1)
Frederic Weisbeckera92bef02009-07-01 21:02:10 +0200329 perror("unable to read pipe");
Liming Wang60666c62009-12-31 16:05:50 +0800330 close(child_ready_pipe[0]);
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000331 }
332
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200333 for (counter = 0; counter < nr_counters; counter++)
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300334 ncreated += create_perf_stat_counter(counter);
335
336 if (ncreated == 0) {
337 pr_err("No permission to collect %sstats.\n"
338 "Consider tweaking /proc/sys/kernel/perf_event_paranoid.\n",
339 system_wide ? "system-wide " : "");
340 if (child_pid != -1)
341 kill(child_pid, SIGTERM);
342 return -1;
343 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200344
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200345 /*
346 * Enable counters and exec the command:
347 */
348 t0 = rdclock();
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200349
Liming Wang60666c62009-12-31 16:05:50 +0800350 if (forks) {
351 close(go_pipe[1]);
352 wait(&status);
353 } else {
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300354 while(!done) sleep(1);
Liming Wang60666c62009-12-31 16:05:50 +0800355 }
Ingo Molnar44db76c2009-06-03 19:36:07 +0200356
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200357 t1 = rdclock();
358
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200359 update_stats(&walltime_nsecs_stats, t1 - t0);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200360
361 for (counter = 0; counter < nr_counters; counter++)
362 read_counter(counter);
363
364 return WEXITSTATUS(status);
365}
366
Peter Zijlstra849abde2009-09-04 18:23:38 +0200367static void print_noise(int counter, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200368{
Peter Zijlstra849abde2009-09-04 18:23:38 +0200369 if (run_count == 1)
370 return;
371
372 fprintf(stderr, " ( +- %7.3f%% )",
373 100 * stddev_stats(&event_res_stats[counter][0]) / avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200374}
375
Peter Zijlstra849abde2009-09-04 18:23:38 +0200376static void nsec_printout(int counter, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200377{
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200378 double msecs = avg / 1e6;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200379
Jaswinder Singh Rajput6e750a8f2009-06-27 03:02:07 +0530380 fprintf(stderr, " %14.6f %-24s", msecs, event_name(counter));
Ingo Molnar42202dd2009-06-13 14:57:28 +0200381
Jaswinder Singh Rajputb9ebdcc2009-07-01 15:05:09 +0530382 if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200383 fprintf(stderr, " # %10.3f CPUs ",
384 avg / avg_stats(&walltime_nsecs_stats));
Ingo Molnar42202dd2009-06-13 14:57:28 +0200385 }
Ingo Molnar42202dd2009-06-13 14:57:28 +0200386}
387
Peter Zijlstra849abde2009-09-04 18:23:38 +0200388static void abs_printout(int counter, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200389{
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200390 double total, ratio = 0.0;
391
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200392 fprintf(stderr, " %14.0f %-24s", avg, event_name(counter));
Ingo Molnar42202dd2009-06-13 14:57:28 +0200393
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200394 if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200395 total = avg_stats(&runtime_cycles_stats);
396
397 if (total)
398 ratio = avg / total;
399
400 fprintf(stderr, " # %10.3f IPC ", ratio);
Lucas De Marchi7255fe22009-11-15 12:05:08 -0200401 } else if (MATCH_EVENT(HARDWARE, HW_BRANCH_MISSES, counter) &&
402 runtime_branches_stats.n != 0) {
Anton Blanchard11018202009-10-18 22:29:23 +1100403 total = avg_stats(&runtime_branches_stats);
404
405 if (total)
406 ratio = avg * 100 / total;
407
Ingo Molnardd86e722009-10-19 13:33:03 +0200408 fprintf(stderr, " # %10.3f %% ", ratio);
Anton Blanchard11018202009-10-18 22:29:23 +1100409
Lucas De Marchi7255fe22009-11-15 12:05:08 -0200410 } else if (runtime_nsecs_stats.n != 0) {
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200411 total = avg_stats(&runtime_nsecs_stats);
412
413 if (total)
414 ratio = 1000.0 * avg / total;
415
416 fprintf(stderr, " # %10.3f M/sec", ratio);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200417 }
Ingo Molnar42202dd2009-06-13 14:57:28 +0200418}
419
420/*
421 * Print out the results of a single counter:
422 */
423static void print_counter(int counter)
424{
Peter Zijlstra849abde2009-09-04 18:23:38 +0200425 double avg = avg_stats(&event_res_stats[counter][0]);
Peter Zijlstra63d40de2009-09-04 17:03:13 +0200426 int scaled = event_scaled[counter];
Ingo Molnar42202dd2009-06-13 14:57:28 +0200427
Ingo Molnar42202dd2009-06-13 14:57:28 +0200428 if (scaled == -1) {
Jaswinder Singh Rajput6e750a8f2009-06-27 03:02:07 +0530429 fprintf(stderr, " %14s %-24s\n",
Ingo Molnar42202dd2009-06-13 14:57:28 +0200430 "<not counted>", event_name(counter));
431 return;
432 }
433
434 if (nsec_counter(counter))
Peter Zijlstra849abde2009-09-04 18:23:38 +0200435 nsec_printout(counter, avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200436 else
Peter Zijlstra849abde2009-09-04 18:23:38 +0200437 abs_printout(counter, avg);
438
439 print_noise(counter, avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200440
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200441 if (scaled) {
442 double avg_enabled, avg_running;
443
444 avg_enabled = avg_stats(&event_res_stats[counter][1]);
445 avg_running = avg_stats(&event_res_stats[counter][2]);
446
Ingo Molnar210ad392009-06-29 21:50:54 +0200447 fprintf(stderr, " (scaled from %.2f%%)",
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200448 100 * avg_running / avg_enabled);
449 }
Ingo Molnar42202dd2009-06-13 14:57:28 +0200450
451 fprintf(stderr, "\n");
452}
453
Ingo Molnar42202dd2009-06-13 14:57:28 +0200454static void print_stat(int argc, const char **argv)
455{
456 int i, counter;
457
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200458 fflush(stdout);
459
460 fprintf(stderr, "\n");
Liming Wang60666c62009-12-31 16:05:50 +0800461 fprintf(stderr, " Performance counter stats for ");
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300462 if(target_pid == -1 && target_tid == -1) {
Liming Wang60666c62009-12-31 16:05:50 +0800463 fprintf(stderr, "\'%s", argv[0]);
464 for (i = 1; i < argc; i++)
465 fprintf(stderr, " %s", argv[i]);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300466 } else if (target_pid != -1)
467 fprintf(stderr, "process id \'%d", target_pid);
468 else
469 fprintf(stderr, "thread id \'%d", target_tid);
Ingo Molnar44db76c2009-06-03 19:36:07 +0200470
Ingo Molnar42202dd2009-06-13 14:57:28 +0200471 fprintf(stderr, "\'");
472 if (run_count > 1)
473 fprintf(stderr, " (%d runs)", run_count);
474 fprintf(stderr, ":\n\n");
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200475
476 for (counter = 0; counter < nr_counters; counter++)
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200477 print_counter(counter);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200478
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200479 fprintf(stderr, "\n");
Ingo Molnar566747e2009-06-27 06:24:32 +0200480 fprintf(stderr, " %14.9f seconds time elapsed",
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200481 avg_stats(&walltime_nsecs_stats)/1e9);
Ingo Molnar566747e2009-06-27 06:24:32 +0200482 if (run_count > 1) {
483 fprintf(stderr, " ( +- %7.3f%% )",
Peter Zijlstra506d4bc2009-09-04 15:36:12 +0200484 100*stddev_stats(&walltime_nsecs_stats) /
485 avg_stats(&walltime_nsecs_stats));
Ingo Molnar566747e2009-06-27 06:24:32 +0200486 }
487 fprintf(stderr, "\n\n");
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200488}
489
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200490static volatile int signr = -1;
491
Ingo Molnar52425192009-05-26 09:17:18 +0200492static void skip_signal(int signo)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200493{
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300494 if(child_pid == -1)
Liming Wang60666c62009-12-31 16:05:50 +0800495 done = 1;
496
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200497 signr = signo;
498}
499
500static void sig_atexit(void)
501{
Chris Wilson933da832009-10-04 01:35:01 +0100502 if (child_pid != -1)
503 kill(child_pid, SIGTERM);
504
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200505 if (signr == -1)
506 return;
507
508 signal(signr, SIG_DFL);
509 kill(getpid(), signr);
Ingo Molnar52425192009-05-26 09:17:18 +0200510}
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200511
Ingo Molnar52425192009-05-26 09:17:18 +0200512static const char * const stat_usage[] = {
Liming Wang60666c62009-12-31 16:05:50 +0800513 "perf stat [<options>] [<command>]",
Ingo Molnar52425192009-05-26 09:17:18 +0200514 NULL
515};
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200516
Ingo Molnar52425192009-05-26 09:17:18 +0200517static const struct option options[] = {
518 OPT_CALLBACK('e', "event", NULL, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +0200519 "event selector. use 'perf list' to list available events",
520 parse_events),
Ingo Molnar52425192009-05-26 09:17:18 +0200521 OPT_BOOLEAN('i', "inherit", &inherit,
522 "child tasks inherit counters"),
523 OPT_INTEGER('p', "pid", &target_pid,
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300524 "stat events on existing process id"),
525 OPT_INTEGER('t', "tid", &target_tid,
526 "stat events on existing thread id"),
Ingo Molnar52425192009-05-26 09:17:18 +0200527 OPT_BOOLEAN('a', "all-cpus", &system_wide,
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +0530528 "system-wide collection from all CPUs"),
Brice Goglinb26bc5a2009-08-07 10:18:39 +0200529 OPT_BOOLEAN('c', "scale", &scale,
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +0530530 "scale/normalize counters"),
Ian Munsiec0555642010-04-13 18:37:33 +1000531 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar743ee1f2009-06-07 17:06:46 +0200532 "be more verbose (show counter open errors, etc)"),
Ingo Molnar42202dd2009-06-13 14:57:28 +0200533 OPT_INTEGER('r', "repeat", &run_count,
534 "repeat command and print average + stddev (max: 100)"),
Ingo Molnar0cfb7a12009-06-27 06:10:30 +0200535 OPT_BOOLEAN('n', "null", &null_run,
536 "null run - dont start any counters"),
Ingo Molnar52425192009-05-26 09:17:18 +0200537 OPT_END()
538};
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200539
Ingo Molnarf37a2912009-07-01 12:37:06 +0200540int cmd_stat(int argc, const char **argv, const char *prefix __used)
Ingo Molnar52425192009-05-26 09:17:18 +0200541{
Ingo Molnar42202dd2009-06-13 14:57:28 +0200542 int status;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300543 int i,j;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200544
Anton Blancharda0541232009-07-22 23:04:12 +1000545 argc = parse_options(argc, argv, options, stat_usage,
546 PARSE_OPT_STOP_AT_NON_OPTION);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300547 if (!argc && target_pid == -1 && target_tid == -1)
Ingo Molnar52425192009-05-26 09:17:18 +0200548 usage_with_options(stat_usage, options);
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200549 if (run_count <= 0)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200550 usage_with_options(stat_usage, options);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200551
Jaswinder Singh Rajputc3043562009-06-27 23:49:09 +0530552 /* 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);
556 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200557
Paul Mackerrasa12b51c2010-03-10 20:36:09 +1100558 if (system_wide)
559 nr_cpus = read_cpu_map();
560 else
561 nr_cpus = 1;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200562
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300563 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",
568 target_pid);
569 usage_with_options(stat_usage, options);
570 }
571 } else {
572 all_tids=malloc(sizeof(pid_t));
573 if (!all_tids)
574 return -ENOMEM;
575
576 all_tids[0] = target_tid;
577 thread_num = 1;
578 }
579
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);
583 if (!fd[i][j])
584 return -ENOMEM;
585 }
586 }
587
Ingo Molnar58d7e992009-05-15 11:03:23 +0200588 /*
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:
593 */
Peter Zijlstraf7b7c262009-06-10 15:55:59 +0200594 atexit(sig_atexit);
Ingo Molnar58d7e992009-05-15 11:03:23 +0200595 signal(SIGINT, skip_signal);
596 signal(SIGALRM, skip_signal);
597 signal(SIGABRT, skip_signal);
598
Ingo Molnar42202dd2009-06-13 14:57:28 +0200599 status = 0;
600 for (run_idx = 0; run_idx < run_count; run_idx++) {
601 if (run_count != 1 && verbose)
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +0530602 fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200603 status = run_perf_stat(argc, argv);
604 }
605
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300606 if (status != -1)
607 print_stat(argc, argv);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200608
609 return status;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200610}