blob: 352fbd7ff4a1a16eda225109a9fb7e92460f6ed6 [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 Molnar2cba3ff2011-05-19 13:30:56 +02009 $ perf stat ./hackbench 10
Ingo Molnarddcacfa2009-04-20 15:37:32 +020010
Ingo Molnar2cba3ff2011-05-19 13:30:56 +020011 Time: 0.118
Ingo Molnarddcacfa2009-04-20 15:37:32 +020012
Ingo Molnar2cba3ff2011-05-19 13:30:56 +020013 Performance counter stats for './hackbench 10':
Ingo Molnarddcacfa2009-04-20 15:37:32 +020014
Ingo Molnar2cba3ff2011-05-19 13:30:56 +020015 1708.761321 task-clock # 11.037 CPUs utilized
16 41,190 context-switches # 0.024 M/sec
17 6,735 CPU-migrations # 0.004 M/sec
18 17,318 page-faults # 0.010 M/sec
19 5,205,202,243 cycles # 3.046 GHz
20 3,856,436,920 stalled-cycles-frontend # 74.09% frontend cycles idle
21 1,600,790,871 stalled-cycles-backend # 30.75% backend cycles idle
22 2,603,501,247 instructions # 0.50 insns per cycle
23 # 1.48 stalled cycles per insn
24 484,357,498 branches # 283.455 M/sec
25 6,388,934 branch-misses # 1.32% of all branches
26
27 0.154822978 seconds time elapsed
Ingo Molnarddcacfa2009-04-20 15:37:32 +020028
Ingo Molnar52425192009-05-26 09:17:18 +020029 *
Ingo Molnar2cba3ff2011-05-19 13:30:56 +020030 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
Ingo Molnar52425192009-05-26 09:17:18 +020031 *
32 * Improvements and fixes by:
33 *
34 * Arjan van de Ven <arjan@linux.intel.com>
35 * Yanmin Zhang <yanmin.zhang@intel.com>
36 * Wu Fengguang <fengguang.wu@intel.com>
37 * Mike Galbraith <efault@gmx.de>
38 * Paul Mackerras <paulus@samba.org>
Jaswinder Singh Rajput6e750a8f2009-06-27 03:02:07 +053039 * Jaswinder Singh Rajput <jaswinder@kernel.org>
Ingo Molnar52425192009-05-26 09:17:18 +020040 *
41 * Released under the GPL v2. (and only v2, not any later version)
Ingo Molnarddcacfa2009-04-20 15:37:32 +020042 */
43
Peter Zijlstra1a482f32009-05-23 18:28:58 +020044#include "perf.h"
Ingo Molnar16f762a2009-05-27 09:10:38 +020045#include "builtin.h"
Ingo Molnar148be2c2009-04-27 08:02:14 +020046#include "util/util.h"
Ingo Molnar52425192009-05-26 09:17:18 +020047#include "util/parse-options.h"
48#include "util/parse-events.h"
Frederic Weisbecker8f28827a2009-08-16 22:05:48 +020049#include "util/event.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020050#include "util/evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -020051#include "util/evsel.h"
Frederic Weisbecker8f28827a2009-08-16 22:05:48 +020052#include "util/debug.h"
Ingo Molnara5d243d2011-04-27 05:39:24 +020053#include "util/color.h"
Xiao Guangrong0007ece2012-09-17 16:31:14 +080054#include "util/stat.h"
Liming Wang60666c62009-12-31 16:05:50 +080055#include "util/header.h"
Paul Mackerrasa12b51c2010-03-10 20:36:09 +110056#include "util/cpumap.h"
Zhang, Yanmind6d901c2010-03-18 11:36:05 -030057#include "util/thread.h"
Arnaldo Carvalho de Melofd782602011-01-18 15:15:24 -020058#include "util/thread_map.h"
Ingo Molnarddcacfa2009-04-20 15:37:32 +020059
Peter Zijlstra1f16c572012-10-23 13:40:14 +020060#include <stdlib.h>
Ingo Molnarddcacfa2009-04-20 15:37:32 +020061#include <sys/prctl.h>
Stephane Eranian5af52b52010-05-18 15:00:01 +020062#include <locale.h>
Peter Zijlstra16c8a102009-05-05 17:50:27 +020063
Stephane Eraniand7470b62010-12-01 18:49:05 +020064#define DEFAULT_SEPARATOR " "
David Ahern2cee77c2011-05-30 08:55:59 -060065#define CNTR_NOT_SUPPORTED "<not supported>"
66#define CNTR_NOT_COUNTED "<not counted>"
Stephane Eraniand7470b62010-12-01 18:49:05 +020067
Stephane Eranian13370a92013-01-29 12:47:44 +010068static void print_stat(int argc, const char **argv);
69static void print_counter_aggr(struct perf_evsel *counter, char *prefix);
70static void print_counter(struct perf_evsel *counter, char *prefix);
Stephane Eranian86ee6e12013-02-14 13:57:27 +010071static void print_aggr(char *prefix);
Stephane Eranian13370a92013-01-29 12:47:44 +010072
Robert Richter666e6d42012-04-05 18:26:27 +020073static struct perf_evlist *evsel_list;
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020074
Namhyung Kim77a6f012012-05-07 14:09:04 +090075static struct perf_target target = {
76 .uid = UINT_MAX,
77};
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +053078
Stephane Eranian86ee6e12013-02-14 13:57:27 +010079enum aggr_mode {
80 AGGR_NONE,
81 AGGR_GLOBAL,
82 AGGR_SOCKET,
Stephane Eranian12c08a92013-02-14 13:57:29 +010083 AGGR_CORE,
Stephane Eranian86ee6e12013-02-14 13:57:27 +010084};
85
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +053086static int run_count = 1;
Stephane Eranian2e6cdf92010-05-12 10:40:01 +020087static bool no_inherit = false;
Ian Munsiec0555642010-04-13 18:37:33 +100088static bool scale = true;
Stephane Eranian86ee6e12013-02-14 13:57:27 +010089static enum aggr_mode aggr_mode = AGGR_GLOBAL;
Stephane Eraniand07f0b12013-06-04 17:44:26 +020090static volatile pid_t child_pid = -1;
Ian Munsiec0555642010-04-13 18:37:33 +100091static bool null_run = false;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +020092static int detailed_run = 0;
Arnaldo Carvalho de Melo201e0b02010-12-01 17:53:27 -020093static bool big_num = true;
Stephane Eraniand7470b62010-12-01 18:49:05 +020094static int big_num_opt = -1;
Stephane Eraniand7470b62010-12-01 18:49:05 +020095static const char *csv_sep = NULL;
96static bool csv_output = false;
Lin Ming43bece72011-08-17 18:42:07 +080097static bool group = false;
Stephane Eranian4aa90152011-08-15 22:22:33 +020098static FILE *output = NULL;
Peter Zijlstra1f16c572012-10-23 13:40:14 +020099static const char *pre_cmd = NULL;
100static const char *post_cmd = NULL;
101static bool sync_run = false;
Stephane Eranian13370a92013-01-29 12:47:44 +0100102static unsigned int interval = 0;
Frederik Deweerdta7e191c2013-03-01 13:02:27 -0500103static bool forever = false;
Stephane Eranian13370a92013-01-29 12:47:44 +0100104static struct timespec ref_time;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100105static struct cpu_map *aggr_map;
106static int (*aggr_get_id)(struct cpu_map *m, int cpu);
Stephane Eranian5af52b52010-05-18 15:00:01 +0200107
Liming Wang60666c62009-12-31 16:05:50 +0800108static volatile int done = 0;
109
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200110struct perf_stat {
111 struct stats res_stats[3];
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200112};
113
Stephane Eranian13370a92013-01-29 12:47:44 +0100114static inline void diff_timespec(struct timespec *r, struct timespec *a,
115 struct timespec *b)
116{
117 r->tv_sec = a->tv_sec - b->tv_sec;
118 if (a->tv_nsec < b->tv_nsec) {
119 r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
120 r->tv_sec--;
121 } else {
122 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
123 }
124}
125
126static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
127{
128 return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
129}
130
131static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
132{
133 return perf_evsel__cpus(evsel)->nr;
134}
135
Frederik Deweerdta7e191c2013-03-01 13:02:27 -0500136static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
137{
138 memset(evsel->priv, 0, sizeof(struct perf_stat));
139}
140
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200141static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200142{
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200143 evsel->priv = zalloc(sizeof(struct perf_stat));
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200144 return evsel->priv == NULL ? -ENOMEM : 0;
145}
146
147static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
148{
149 free(evsel->priv);
150 evsel->priv = NULL;
151}
152
Stephane Eranian13370a92013-01-29 12:47:44 +0100153static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel)
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800154{
Stephane Eranian13370a92013-01-29 12:47:44 +0100155 void *addr;
156 size_t sz;
157
158 sz = sizeof(*evsel->counts) +
159 (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values));
160
161 addr = zalloc(sz);
162 if (!addr)
163 return -ENOMEM;
164
165 evsel->prev_raw_counts = addr;
166
167 return 0;
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800168}
169
Stephane Eranian13370a92013-01-29 12:47:44 +0100170static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800171{
Stephane Eranian13370a92013-01-29 12:47:44 +0100172 free(evsel->prev_raw_counts);
173 evsel->prev_raw_counts = NULL;
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800174}
175
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -0300176static void perf_evlist__free_stats(struct perf_evlist *evlist)
177{
178 struct perf_evsel *evsel;
179
180 list_for_each_entry(evsel, &evlist->entries, node) {
181 perf_evsel__free_stat_priv(evsel);
182 perf_evsel__free_counts(evsel);
183 perf_evsel__free_prev_raw_counts(evsel);
184 }
185}
186
187static int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
188{
189 struct perf_evsel *evsel;
190
191 list_for_each_entry(evsel, &evlist->entries, node) {
192 if (perf_evsel__alloc_stat_priv(evsel) < 0 ||
193 perf_evsel__alloc_counts(evsel, perf_evsel__nr_cpus(evsel)) < 0 ||
194 (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel) < 0))
195 goto out_free;
196 }
197
198 return 0;
199
200out_free:
201 perf_evlist__free_stats(evlist);
202 return -1;
203}
204
Robert Richter666e6d42012-04-05 18:26:27 +0200205static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
206static struct stats runtime_cycles_stats[MAX_NR_CPUS];
207static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
208static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
209static struct stats runtime_branches_stats[MAX_NR_CPUS];
210static struct stats runtime_cacherefs_stats[MAX_NR_CPUS];
211static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS];
212static struct stats runtime_l1_icache_stats[MAX_NR_CPUS];
213static struct stats runtime_ll_cache_stats[MAX_NR_CPUS];
214static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
215static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
216static struct stats walltime_nsecs_stats;
Ingo Molnarbe1ac0d2009-05-29 09:10:54 +0200217
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -0300218static void perf_stat__reset_stats(struct perf_evlist *evlist)
Frederik Deweerdta7e191c2013-03-01 13:02:27 -0500219{
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -0300220 struct perf_evsel *evsel;
221
222 list_for_each_entry(evsel, &evlist->entries, node) {
223 perf_evsel__reset_stat_priv(evsel);
224 perf_evsel__reset_counts(evsel, perf_evsel__nr_cpus(evsel));
225 }
226
Frederik Deweerdta7e191c2013-03-01 13:02:27 -0500227 memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
228 memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
229 memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
230 memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats));
231 memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats));
232 memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats));
233 memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats));
234 memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats));
235 memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats));
236 memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats));
237 memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats));
238 memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
239}
240
Jiri Olsacac21422012-11-12 18:34:00 +0100241static int create_perf_stat_counter(struct perf_evsel *evsel)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200242{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200243 struct perf_event_attr *attr = &evsel->attr;
Arnaldo Carvalho de Melo727ab042011-10-25 10:42:19 -0200244
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200245 if (scale)
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200246 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
247 PERF_FORMAT_TOTAL_TIME_RUNNING;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200248
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200249 attr->inherit = !no_inherit;
Arnaldo Carvalho de Melo5d2cd902011-04-14 11:20:14 -0300250
Arnaldo Carvalho de Melo594ac612012-12-13 13:13:07 -0300251 if (perf_target__has_cpu(&target))
252 return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
Stephane Eranian5622c072012-04-27 14:45:38 +0200253
Arnaldo Carvalho de Melo07ac0022012-11-13 17:27:28 -0300254 if (!perf_target__has_task(&target) &&
Namhyung Kim823254e2012-11-29 15:38:30 +0900255 perf_evsel__is_group_leader(evsel)) {
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200256 attr->disabled = 1;
257 attr->enable_on_exec = 1;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200258 }
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300259
Arnaldo Carvalho de Melo594ac612012-12-13 13:13:07 -0300260 return perf_evsel__open_per_thread(evsel, evsel_list->threads);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200261}
262
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200263/*
264 * Does the counter have nsecs as a unit?
265 */
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200266static inline int nsec_counter(struct perf_evsel *evsel)
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200267{
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200268 if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
269 perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200270 return 1;
271
272 return 0;
273}
274
275/*
Ingo Molnardcd99362011-04-27 04:36:37 +0200276 * Update various tracking values we maintain to print
277 * more semantic information such as miss/hit ratios,
278 * instruction rates, etc:
279 */
280static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
281{
282 if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
283 update_stats(&runtime_nsecs_stats[0], count[0]);
284 else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
285 update_stats(&runtime_cycles_stats[0], count[0]);
Ingo Molnard3d1e862011-04-29 13:49:08 +0200286 else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
287 update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
Ingo Molnar129c04c2011-04-29 14:41:28 +0200288 else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
Ingo Molnard3d1e862011-04-29 13:49:08 +0200289 update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
Ingo Molnardcd99362011-04-27 04:36:37 +0200290 else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
291 update_stats(&runtime_branches_stats[0], count[0]);
292 else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
293 update_stats(&runtime_cacherefs_stats[0], count[0]);
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200294 else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
295 update_stats(&runtime_l1_dcache_stats[0], count[0]);
Ingo Molnarc3305252011-05-19 14:01:42 +0200296 else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
297 update_stats(&runtime_l1_icache_stats[0], count[0]);
298 else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
299 update_stats(&runtime_ll_cache_stats[0], count[0]);
300 else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
301 update_stats(&runtime_dtlb_cache_stats[0], count[0]);
302 else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
303 update_stats(&runtime_itlb_cache_stats[0], count[0]);
Ingo Molnardcd99362011-04-27 04:36:37 +0200304}
305
306/*
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200307 * Read out the results of a single counter:
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200308 * aggregate counts across CPUs in system-wide mode
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200309 */
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200310static int read_counter_aggr(struct perf_evsel *counter)
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200311{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200312 struct perf_stat *ps = counter->priv;
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200313 u64 *count = counter->counts->aggr.values;
314 int i;
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200315
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800316 if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter),
Namhyung Kimb3a319d2013-03-11 16:43:14 +0900317 thread_map__nr(evsel_list->threads), scale) < 0)
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200318 return -1;
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200319
320 for (i = 0; i < 3; i++)
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200321 update_stats(&ps->res_stats[i], count[i]);
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200322
323 if (verbose) {
Stephane Eranian4aa90152011-08-15 22:22:33 +0200324 fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -0300325 perf_evsel__name(counter), count[0], count[1], count[2]);
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200326 }
327
Ingo Molnarbe1ac0d2009-05-29 09:10:54 +0200328 /*
329 * Save the full runtime - to allow normalization during printout:
330 */
Ingo Molnardcd99362011-04-27 04:36:37 +0200331 update_shadow_stats(counter, count);
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200332
333 return 0;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200334}
335
336/*
337 * Read out the results of a single counter:
338 * do not aggregate counts across CPUs in system-wide mode
339 */
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200340static int read_counter(struct perf_evsel *counter)
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200341{
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200342 u64 *count;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200343 int cpu;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200344
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800345 for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200346 if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
347 return -1;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200348
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200349 count = counter->counts->cpu[cpu].values;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200350
Ingo Molnardcd99362011-04-27 04:36:37 +0200351 update_shadow_stats(counter, count);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200352 }
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200353
354 return 0;
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200355}
356
Stephane Eranian13370a92013-01-29 12:47:44 +0100357static void print_interval(void)
358{
359 static int num_print_interval;
360 struct perf_evsel *counter;
361 struct perf_stat *ps;
362 struct timespec ts, rs;
363 char prefix[64];
364
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100365 if (aggr_mode == AGGR_GLOBAL) {
Stephane Eranian13370a92013-01-29 12:47:44 +0100366 list_for_each_entry(counter, &evsel_list->entries, node) {
367 ps = counter->priv;
368 memset(ps->res_stats, 0, sizeof(ps->res_stats));
369 read_counter_aggr(counter);
370 }
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100371 } else {
372 list_for_each_entry(counter, &evsel_list->entries, node) {
373 ps = counter->priv;
374 memset(ps->res_stats, 0, sizeof(ps->res_stats));
375 read_counter(counter);
376 }
Stephane Eranian13370a92013-01-29 12:47:44 +0100377 }
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100378
Stephane Eranian13370a92013-01-29 12:47:44 +0100379 clock_gettime(CLOCK_MONOTONIC, &ts);
380 diff_timespec(&rs, &ts, &ref_time);
381 sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep);
382
383 if (num_print_interval == 0 && !csv_output) {
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100384 switch (aggr_mode) {
385 case AGGR_SOCKET:
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100386 fprintf(output, "# time socket cpus counts events\n");
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100387 break;
Stephane Eranian12c08a92013-02-14 13:57:29 +0100388 case AGGR_CORE:
389 fprintf(output, "# time core cpus counts events\n");
390 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100391 case AGGR_NONE:
Stephane Eranian13370a92013-01-29 12:47:44 +0100392 fprintf(output, "# time CPU counts events\n");
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100393 break;
394 case AGGR_GLOBAL:
395 default:
Stephane Eranian13370a92013-01-29 12:47:44 +0100396 fprintf(output, "# time counts events\n");
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100397 }
Stephane Eranian13370a92013-01-29 12:47:44 +0100398 }
399
400 if (++num_print_interval == 25)
401 num_print_interval = 0;
402
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100403 switch (aggr_mode) {
Stephane Eranian12c08a92013-02-14 13:57:29 +0100404 case AGGR_CORE:
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100405 case AGGR_SOCKET:
406 print_aggr(prefix);
407 break;
408 case AGGR_NONE:
Stephane Eranian13370a92013-01-29 12:47:44 +0100409 list_for_each_entry(counter, &evsel_list->entries, node)
410 print_counter(counter, prefix);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100411 break;
412 case AGGR_GLOBAL:
413 default:
Stephane Eranian13370a92013-01-29 12:47:44 +0100414 list_for_each_entry(counter, &evsel_list->entries, node)
415 print_counter_aggr(counter, prefix);
416 }
417}
418
Namhyung Kimacf28922013-03-11 16:43:18 +0900419static int __run_perf_stat(int argc, const char **argv)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200420{
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300421 char msg[512];
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200422 unsigned long long t0, t1;
Jiri Olsacac21422012-11-12 18:34:00 +0100423 struct perf_evsel *counter;
Stephane Eranian13370a92013-01-29 12:47:44 +0100424 struct timespec ts;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200425 int status = 0;
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300426 const bool forks = (argc > 0);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200427
Stephane Eranian13370a92013-01-29 12:47:44 +0100428 if (interval) {
429 ts.tv_sec = interval / 1000;
430 ts.tv_nsec = (interval % 1000) * 1000000;
431 } else {
432 ts.tv_sec = 1;
433 ts.tv_nsec = 0;
434 }
435
Liming Wang60666c62009-12-31 16:05:50 +0800436 if (forks) {
Namhyung Kimacf28922013-03-11 16:43:18 +0900437 if (perf_evlist__prepare_workload(evsel_list, &target, argv,
438 false, false) < 0) {
439 perror("failed to prepare workload");
440 return -1;
Liming Wang60666c62009-12-31 16:05:50 +0800441 }
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000442 }
443
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200444 if (group)
Arnaldo Carvalho de Melo63dab222012-08-14 16:35:48 -0300445 perf_evlist__set_leader(evsel_list);
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200446
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -0200447 list_for_each_entry(counter, &evsel_list->entries, node) {
Jiri Olsacac21422012-11-12 18:34:00 +0100448 if (create_perf_stat_counter(counter) < 0) {
David Ahern979987a2012-05-08 09:29:16 -0600449 /*
450 * PPC returns ENXIO for HW counters until 2.6.37
451 * (behavior changed with commit b0a873e).
452 */
Anton Blanchard38f6ae12011-12-02 09:38:33 +1100453 if (errno == EINVAL || errno == ENOSYS ||
David Ahern979987a2012-05-08 09:29:16 -0600454 errno == ENOENT || errno == EOPNOTSUPP ||
455 errno == ENXIO) {
David Ahernc63ca0c2011-04-29 16:04:15 -0600456 if (verbose)
457 ui__warning("%s event is not supported by the kernel.\n",
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -0300458 perf_evsel__name(counter));
David Ahern2cee77c2011-05-30 08:55:59 -0600459 counter->supported = false;
Ingo Molnarede70292011-04-28 08:48:42 +0200460 continue;
David Ahernc63ca0c2011-04-29 16:04:15 -0600461 }
Ingo Molnarede70292011-04-28 08:48:42 +0200462
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300463 perf_evsel__open_strerror(counter, &target,
464 errno, msg, sizeof(msg));
465 ui__error("%s\n", msg);
466
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200467 if (child_pid != -1)
468 kill(child_pid, SIGTERM);
David Ahernfceda7f2012-08-26 12:24:44 -0600469
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200470 return -1;
471 }
David Ahern2cee77c2011-05-30 08:55:59 -0600472 counter->supported = true;
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300473 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200474
Arnaldo Carvalho de Melo1491a632012-09-26 14:43:13 -0300475 if (perf_evlist__apply_filters(evsel_list)) {
Frederic Weisbeckercfd748a2011-03-14 16:40:30 +0100476 error("failed to set filter with %d (%s)\n", errno,
477 strerror(errno));
478 return -1;
479 }
480
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200481 /*
482 * Enable counters and exec the command:
483 */
484 t0 = rdclock();
Stephane Eranian13370a92013-01-29 12:47:44 +0100485 clock_gettime(CLOCK_MONOTONIC, &ref_time);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200486
Liming Wang60666c62009-12-31 16:05:50 +0800487 if (forks) {
Namhyung Kimacf28922013-03-11 16:43:18 +0900488 perf_evlist__start_workload(evsel_list);
489
Stephane Eranian13370a92013-01-29 12:47:44 +0100490 if (interval) {
491 while (!waitpid(child_pid, &status, WNOHANG)) {
492 nanosleep(&ts, NULL);
493 print_interval();
494 }
495 }
Liming Wang60666c62009-12-31 16:05:50 +0800496 wait(&status);
Andi Kleen33e49ea2011-09-15 14:31:40 -0700497 if (WIFSIGNALED(status))
498 psignal(WTERMSIG(status), argv[0]);
Liming Wang60666c62009-12-31 16:05:50 +0800499 } else {
Stephane Eranian13370a92013-01-29 12:47:44 +0100500 while (!done) {
501 nanosleep(&ts, NULL);
502 if (interval)
503 print_interval();
504 }
Liming Wang60666c62009-12-31 16:05:50 +0800505 }
Ingo Molnar44db76c2009-06-03 19:36:07 +0200506
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200507 t1 = rdclock();
508
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200509 update_stats(&walltime_nsecs_stats, t1 - t0);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200510
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100511 if (aggr_mode == AGGR_GLOBAL) {
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -0200512 list_for_each_entry(counter, &evsel_list->entries, node) {
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200513 read_counter_aggr(counter);
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800514 perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
Namhyung Kimb3a319d2013-03-11 16:43:14 +0900515 thread_map__nr(evsel_list->threads));
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200516 }
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100517 } else {
518 list_for_each_entry(counter, &evsel_list->entries, node) {
519 read_counter(counter);
520 perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
521 }
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200522 }
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200523
Ingo Molnar42202dd2009-06-13 14:57:28 +0200524 return WEXITSTATUS(status);
525}
526
Peter Zijlstra1f16c572012-10-23 13:40:14 +0200527static int run_perf_stat(int argc __maybe_unused, const char **argv)
528{
529 int ret;
530
531 if (pre_cmd) {
532 ret = system(pre_cmd);
533 if (ret)
534 return ret;
535 }
536
537 if (sync_run)
538 sync();
539
540 ret = __run_perf_stat(argc, argv);
541 if (ret)
542 return ret;
543
544 if (post_cmd) {
545 ret = system(post_cmd);
546 if (ret)
547 return ret;
548 }
549
550 return ret;
551}
552
Ingo Molnarf99844c2011-04-27 05:35:39 +0200553static void print_noise_pct(double total, double avg)
554{
Xiao Guangrong0007ece2012-09-17 16:31:14 +0800555 double pct = rel_stddev_stats(total, avg);
Ingo Molnarf99844c2011-04-27 05:35:39 +0200556
Zhengyu He3ae9a34d2011-06-23 13:45:42 -0700557 if (csv_output)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200558 fprintf(output, "%s%.2f%%", csv_sep, pct);
Jim Cromiea1bca6c2011-09-07 17:14:02 -0600559 else if (pct)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200560 fprintf(output, " ( +-%6.2f%% )", pct);
Ingo Molnarf99844c2011-04-27 05:35:39 +0200561}
562
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200563static void print_noise(struct perf_evsel *evsel, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200564{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200565 struct perf_stat *ps;
566
Peter Zijlstra849abde2009-09-04 18:23:38 +0200567 if (run_count == 1)
568 return;
569
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200570 ps = evsel->priv;
Ingo Molnarf99844c2011-04-27 05:35:39 +0200571 print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200572}
573
Stephane Eranian12c08a92013-02-14 13:57:29 +0100574static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200575{
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100576 switch (aggr_mode) {
Stephane Eranian12c08a92013-02-14 13:57:29 +0100577 case AGGR_CORE:
578 fprintf(output, "S%d-C%*d%s%*d%s",
579 cpu_map__id_to_socket(id),
580 csv_output ? 0 : -8,
581 cpu_map__id_to_cpu(id),
582 csv_sep,
583 csv_output ? 0 : 4,
584 nr,
585 csv_sep);
586 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100587 case AGGR_SOCKET:
588 fprintf(output, "S%*d%s%*d%s",
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100589 csv_output ? 0 : -5,
Stephane Eranian12c08a92013-02-14 13:57:29 +0100590 id,
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100591 csv_sep,
592 csv_output ? 0 : 4,
593 nr,
594 csv_sep);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100595 break;
596 case AGGR_NONE:
597 fprintf(output, "CPU%*d%s",
Stephane Eraniand7470b62010-12-01 18:49:05 +0200598 csv_output ? 0 : -4,
Stephane Eranian12c08a92013-02-14 13:57:29 +0100599 perf_evsel__cpus(evsel)->map[id], csv_sep);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100600 break;
601 case AGGR_GLOBAL:
602 default:
603 break;
604 }
605}
Stephane Eraniand7470b62010-12-01 18:49:05 +0200606
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100607static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
608{
609 double msecs = avg / 1e6;
610 const char *fmt = csv_output ? "%.6f%s%s" : "%18.6f%s%-25s";
611
612 aggr_printout(evsel, cpu, nr);
613
614 fprintf(output, fmt, msecs, csv_sep, perf_evsel__name(evsel));
Stephane Eraniand7470b62010-12-01 18:49:05 +0200615
Stephane Eranian023695d2011-02-14 11:20:01 +0200616 if (evsel->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200617 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +0200618
Stephane Eranian13370a92013-01-29 12:47:44 +0100619 if (csv_output || interval)
Stephane Eraniand7470b62010-12-01 18:49:05 +0200620 return;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200621
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200622 if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
Stephane Eranian4aa90152011-08-15 22:22:33 +0200623 fprintf(output, " # %8.3f CPUs utilized ",
624 avg / avg_stats(&walltime_nsecs_stats));
Namhyung Kim9dac6a22012-02-06 16:44:45 +0900625 else
626 fprintf(output, " ");
Ingo Molnar42202dd2009-06-13 14:57:28 +0200627}
628
Namhyung Kim15e63922011-12-28 00:35:49 +0900629/* used for get_ratio_color() */
630enum grc_type {
631 GRC_STALLED_CYCLES_FE,
632 GRC_STALLED_CYCLES_BE,
633 GRC_CACHE_MISSES,
634 GRC_MAX_NR
635};
636
637static const char *get_ratio_color(enum grc_type type, double ratio)
638{
639 static const double grc_table[GRC_MAX_NR][3] = {
640 [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 },
641 [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 },
642 [GRC_CACHE_MISSES] = { 20.0, 10.0, 5.0 },
643 };
644 const char *color = PERF_COLOR_NORMAL;
645
646 if (ratio > grc_table[type][0])
647 color = PERF_COLOR_RED;
648 else if (ratio > grc_table[type][1])
649 color = PERF_COLOR_MAGENTA;
650 else if (ratio > grc_table[type][2])
651 color = PERF_COLOR_YELLOW;
652
653 return color;
654}
655
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300656static void print_stalled_cycles_frontend(int cpu,
657 struct perf_evsel *evsel
658 __maybe_unused, double avg)
Ingo Molnard3d1e862011-04-29 13:49:08 +0200659{
660 double total, ratio = 0.0;
661 const char *color;
662
663 total = avg_stats(&runtime_cycles_stats[cpu]);
664
665 if (total)
666 ratio = avg / total * 100.0;
667
Namhyung Kim15e63922011-12-28 00:35:49 +0900668 color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
Ingo Molnard3d1e862011-04-29 13:49:08 +0200669
Stephane Eranian4aa90152011-08-15 22:22:33 +0200670 fprintf(output, " # ");
671 color_fprintf(output, color, "%6.2f%%", ratio);
672 fprintf(output, " frontend cycles idle ");
Ingo Molnard3d1e862011-04-29 13:49:08 +0200673}
674
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300675static void print_stalled_cycles_backend(int cpu,
676 struct perf_evsel *evsel
677 __maybe_unused, double avg)
Ingo Molnara5d243d2011-04-27 05:39:24 +0200678{
679 double total, ratio = 0.0;
680 const char *color;
681
682 total = avg_stats(&runtime_cycles_stats[cpu]);
683
684 if (total)
685 ratio = avg / total * 100.0;
686
Namhyung Kim15e63922011-12-28 00:35:49 +0900687 color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
Ingo Molnara5d243d2011-04-27 05:39:24 +0200688
Stephane Eranian4aa90152011-08-15 22:22:33 +0200689 fprintf(output, " # ");
690 color_fprintf(output, color, "%6.2f%%", ratio);
691 fprintf(output, " backend cycles idle ");
Ingo Molnara5d243d2011-04-27 05:39:24 +0200692}
693
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300694static void print_branch_misses(int cpu,
695 struct perf_evsel *evsel __maybe_unused,
696 double avg)
Ingo Molnarc78df6c2011-04-27 12:16:10 +0200697{
698 double total, ratio = 0.0;
699 const char *color;
700
701 total = avg_stats(&runtime_branches_stats[cpu]);
702
703 if (total)
704 ratio = avg / total * 100.0;
705
Namhyung Kim15e63922011-12-28 00:35:49 +0900706 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnarc78df6c2011-04-27 12:16:10 +0200707
Stephane Eranian4aa90152011-08-15 22:22:33 +0200708 fprintf(output, " # ");
709 color_fprintf(output, color, "%6.2f%%", ratio);
710 fprintf(output, " of all branches ");
Ingo Molnarc78df6c2011-04-27 12:16:10 +0200711}
712
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300713static void print_l1_dcache_misses(int cpu,
714 struct perf_evsel *evsel __maybe_unused,
715 double avg)
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200716{
717 double total, ratio = 0.0;
718 const char *color;
719
720 total = avg_stats(&runtime_l1_dcache_stats[cpu]);
721
722 if (total)
723 ratio = avg / total * 100.0;
724
Namhyung Kim15e63922011-12-28 00:35:49 +0900725 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200726
Stephane Eranian4aa90152011-08-15 22:22:33 +0200727 fprintf(output, " # ");
728 color_fprintf(output, color, "%6.2f%%", ratio);
729 fprintf(output, " of all L1-dcache hits ");
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200730}
731
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300732static void print_l1_icache_misses(int cpu,
733 struct perf_evsel *evsel __maybe_unused,
734 double avg)
Ingo Molnarc3305252011-05-19 14:01:42 +0200735{
736 double total, ratio = 0.0;
737 const char *color;
738
739 total = avg_stats(&runtime_l1_icache_stats[cpu]);
740
741 if (total)
742 ratio = avg / total * 100.0;
743
Namhyung Kim15e63922011-12-28 00:35:49 +0900744 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnarc3305252011-05-19 14:01:42 +0200745
Stephane Eranian4aa90152011-08-15 22:22:33 +0200746 fprintf(output, " # ");
747 color_fprintf(output, color, "%6.2f%%", ratio);
748 fprintf(output, " of all L1-icache hits ");
Ingo Molnarc3305252011-05-19 14:01:42 +0200749}
750
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300751static void print_dtlb_cache_misses(int cpu,
752 struct perf_evsel *evsel __maybe_unused,
753 double avg)
Ingo Molnarc3305252011-05-19 14:01:42 +0200754{
755 double total, ratio = 0.0;
756 const char *color;
757
758 total = avg_stats(&runtime_dtlb_cache_stats[cpu]);
759
760 if (total)
761 ratio = avg / total * 100.0;
762
Namhyung Kim15e63922011-12-28 00:35:49 +0900763 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnarc3305252011-05-19 14:01:42 +0200764
Stephane Eranian4aa90152011-08-15 22:22:33 +0200765 fprintf(output, " # ");
766 color_fprintf(output, color, "%6.2f%%", ratio);
767 fprintf(output, " of all dTLB cache hits ");
Ingo Molnarc3305252011-05-19 14:01:42 +0200768}
769
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300770static void print_itlb_cache_misses(int cpu,
771 struct perf_evsel *evsel __maybe_unused,
772 double avg)
Ingo Molnarc3305252011-05-19 14:01:42 +0200773{
774 double total, ratio = 0.0;
775 const char *color;
776
777 total = avg_stats(&runtime_itlb_cache_stats[cpu]);
778
779 if (total)
780 ratio = avg / total * 100.0;
781
Namhyung Kim15e63922011-12-28 00:35:49 +0900782 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnarc3305252011-05-19 14:01:42 +0200783
Stephane Eranian4aa90152011-08-15 22:22:33 +0200784 fprintf(output, " # ");
785 color_fprintf(output, color, "%6.2f%%", ratio);
786 fprintf(output, " of all iTLB cache hits ");
Ingo Molnarc3305252011-05-19 14:01:42 +0200787}
788
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300789static void print_ll_cache_misses(int cpu,
790 struct perf_evsel *evsel __maybe_unused,
791 double avg)
Ingo Molnarc3305252011-05-19 14:01:42 +0200792{
793 double total, ratio = 0.0;
794 const char *color;
795
796 total = avg_stats(&runtime_ll_cache_stats[cpu]);
797
798 if (total)
799 ratio = avg / total * 100.0;
800
Namhyung Kim15e63922011-12-28 00:35:49 +0900801 color = get_ratio_color(GRC_CACHE_MISSES, ratio);
Ingo Molnarc3305252011-05-19 14:01:42 +0200802
Stephane Eranian4aa90152011-08-15 22:22:33 +0200803 fprintf(output, " # ");
804 color_fprintf(output, color, "%6.2f%%", ratio);
805 fprintf(output, " of all LL-cache hits ");
Ingo Molnarc3305252011-05-19 14:01:42 +0200806}
807
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100808static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200809{
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200810 double total, ratio = 0.0;
Stephane Eraniand7470b62010-12-01 18:49:05 +0200811 const char *fmt;
812
813 if (csv_output)
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100814 fmt = "%.0f%s%s";
Stephane Eraniand7470b62010-12-01 18:49:05 +0200815 else if (big_num)
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100816 fmt = "%'18.0f%s%-25s";
Stephane Eraniand7470b62010-12-01 18:49:05 +0200817 else
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100818 fmt = "%18.0f%s%-25s";
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200819
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100820 aggr_printout(evsel, cpu, nr);
821
822 if (aggr_mode == AGGR_GLOBAL)
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200823 cpu = 0;
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200824
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100825 fprintf(output, fmt, avg, csv_sep, perf_evsel__name(evsel));
Stephane Eraniand7470b62010-12-01 18:49:05 +0200826
Stephane Eranian023695d2011-02-14 11:20:01 +0200827 if (evsel->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200828 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +0200829
Stephane Eranian13370a92013-01-29 12:47:44 +0100830 if (csv_output || interval)
Stephane Eraniand7470b62010-12-01 18:49:05 +0200831 return;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200832
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200833 if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200834 total = avg_stats(&runtime_cycles_stats[cpu]);
Ingo Molnarc7f7fea2009-09-22 14:53:51 +0200835 if (total)
836 ratio = avg / total;
837
Stephane Eranian4aa90152011-08-15 22:22:33 +0200838 fprintf(output, " # %5.2f insns per cycle ", ratio);
Ingo Molnar481f9882011-04-27 04:34:16 +0200839
Ingo Molnard3d1e862011-04-29 13:49:08 +0200840 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
841 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
Ingo Molnar481f9882011-04-27 04:34:16 +0200842
843 if (total && avg) {
844 ratio = total / avg;
Stephane Eranian4aa90152011-08-15 22:22:33 +0200845 fprintf(output, "\n # %5.2f stalled cycles per insn", ratio);
Ingo Molnar481f9882011-04-27 04:34:16 +0200846 }
847
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200848 } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200849 runtime_branches_stats[cpu].n != 0) {
Ingo Molnarc78df6c2011-04-27 12:16:10 +0200850 print_branch_misses(cpu, evsel, avg);
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200851 } else if (
852 evsel->attr.type == PERF_TYPE_HW_CACHE &&
853 evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D |
854 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
855 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
Ingo Molnarc6264de2011-04-27 13:50:47 +0200856 runtime_l1_dcache_stats[cpu].n != 0) {
Ingo Molnar8bb6c792011-04-27 13:25:24 +0200857 print_l1_dcache_misses(cpu, evsel, avg);
Ingo Molnarc3305252011-05-19 14:01:42 +0200858 } else if (
859 evsel->attr.type == PERF_TYPE_HW_CACHE &&
860 evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1I |
861 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
862 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
863 runtime_l1_icache_stats[cpu].n != 0) {
864 print_l1_icache_misses(cpu, evsel, avg);
865 } else if (
866 evsel->attr.type == PERF_TYPE_HW_CACHE &&
867 evsel->attr.config == ( PERF_COUNT_HW_CACHE_DTLB |
868 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
869 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
870 runtime_dtlb_cache_stats[cpu].n != 0) {
871 print_dtlb_cache_misses(cpu, evsel, avg);
872 } else if (
873 evsel->attr.type == PERF_TYPE_HW_CACHE &&
874 evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB |
875 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
876 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
877 runtime_itlb_cache_stats[cpu].n != 0) {
878 print_itlb_cache_misses(cpu, evsel, avg);
879 } else if (
880 evsel->attr.type == PERF_TYPE_HW_CACHE &&
881 evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL |
882 ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
883 ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) &&
884 runtime_ll_cache_stats[cpu].n != 0) {
885 print_ll_cache_misses(cpu, evsel, avg);
Ingo Molnard58f4c82011-04-27 03:42:18 +0200886 } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) &&
887 runtime_cacherefs_stats[cpu].n != 0) {
888 total = avg_stats(&runtime_cacherefs_stats[cpu]);
889
890 if (total)
891 ratio = avg * 100 / total;
892
Stephane Eranian4aa90152011-08-15 22:22:33 +0200893 fprintf(output, " # %8.3f %% of all cache refs ", ratio);
Ingo Molnard58f4c82011-04-27 03:42:18 +0200894
Ingo Molnard3d1e862011-04-29 13:49:08 +0200895 } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
896 print_stalled_cycles_frontend(cpu, evsel, avg);
Ingo Molnar129c04c2011-04-29 14:41:28 +0200897 } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
Ingo Molnard3d1e862011-04-29 13:49:08 +0200898 print_stalled_cycles_backend(cpu, evsel, avg);
Ingo Molnar481f9882011-04-27 04:34:16 +0200899 } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
900 total = avg_stats(&runtime_nsecs_stats[cpu]);
901
902 if (total)
903 ratio = 1.0 * avg / total;
904
Stephane Eranian4aa90152011-08-15 22:22:33 +0200905 fprintf(output, " # %8.3f GHz ", ratio);
Ingo Molnar481f9882011-04-27 04:34:16 +0200906 } else if (runtime_nsecs_stats[cpu].n != 0) {
Namhyung Kim5fde2522012-02-06 16:44:44 +0900907 char unit = 'M';
908
Ingo Molnar481f9882011-04-27 04:34:16 +0200909 total = avg_stats(&runtime_nsecs_stats[cpu]);
910
911 if (total)
912 ratio = 1000.0 * avg / total;
Namhyung Kim5fde2522012-02-06 16:44:44 +0900913 if (ratio < 0.001) {
914 ratio *= 1000;
915 unit = 'K';
916 }
Ingo Molnar481f9882011-04-27 04:34:16 +0200917
Namhyung Kim5fde2522012-02-06 16:44:44 +0900918 fprintf(output, " # %8.3f %c/sec ", ratio, unit);
Ingo Molnara5d243d2011-04-27 05:39:24 +0200919 } else {
Stephane Eranian4aa90152011-08-15 22:22:33 +0200920 fprintf(output, " ");
Ingo Molnar42202dd2009-06-13 14:57:28 +0200921 }
Ingo Molnar42202dd2009-06-13 14:57:28 +0200922}
923
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100924static void print_aggr(char *prefix)
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100925{
926 struct perf_evsel *counter;
Stephane Eranian582ec0822013-07-05 19:06:45 +0200927 int cpu, cpu2, s, s2, id, nr;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100928 u64 ena, run, val;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100929
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100930 if (!(aggr_map || aggr_get_id))
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100931 return;
932
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100933 for (s = 0; s < aggr_map->nr; s++) {
934 id = aggr_map->map[s];
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100935 list_for_each_entry(counter, &evsel_list->entries, node) {
936 val = ena = run = 0;
937 nr = 0;
938 for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
Stephane Eranian582ec0822013-07-05 19:06:45 +0200939 cpu2 = perf_evsel__cpus(counter)->map[cpu];
940 s2 = aggr_get_id(evsel_list->cpus, cpu2);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100941 if (s2 != id)
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100942 continue;
943 val += counter->counts->cpu[cpu].val;
944 ena += counter->counts->cpu[cpu].ena;
945 run += counter->counts->cpu[cpu].run;
946 nr++;
947 }
948 if (prefix)
949 fprintf(output, "%s", prefix);
950
951 if (run == 0 || ena == 0) {
Stephane Eranian582ec0822013-07-05 19:06:45 +0200952 aggr_printout(counter, id, nr);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100953
954 fprintf(output, "%*s%s%*s",
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100955 csv_output ? 0 : 18,
956 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
957 csv_sep,
958 csv_output ? 0 : -24,
959 perf_evsel__name(counter));
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100960
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100961 if (counter->cgrp)
962 fprintf(output, "%s%s",
963 csv_sep, counter->cgrp->name);
964
965 fputc('\n', output);
966 continue;
967 }
968
969 if (nsec_counter(counter))
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100970 nsec_printout(id, nr, counter, val);
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100971 else
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100972 abs_printout(id, nr, counter, val);
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100973
974 if (!csv_output) {
975 print_noise(counter, 1.0);
976
977 if (run != ena)
978 fprintf(output, " (%.2f%%)",
979 100.0 * run / ena);
980 }
981 fputc('\n', output);
982 }
983 }
984}
985
Ingo Molnar42202dd2009-06-13 14:57:28 +0200986/*
987 * Print out the results of a single counter:
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200988 * aggregated counts in system-wide mode
Ingo Molnar42202dd2009-06-13 14:57:28 +0200989 */
Stephane Eranian13370a92013-01-29 12:47:44 +0100990static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200991{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200992 struct perf_stat *ps = counter->priv;
993 double avg = avg_stats(&ps->res_stats[0]);
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200994 int scaled = counter->counts->scaled;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200995
Stephane Eranian13370a92013-01-29 12:47:44 +0100996 if (prefix)
997 fprintf(output, "%s", prefix);
998
Ingo Molnar42202dd2009-06-13 14:57:28 +0200999 if (scaled == -1) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001000 fprintf(output, "%*s%s%*s",
Stephane Eraniand7470b62010-12-01 18:49:05 +02001001 csv_output ? 0 : 18,
David Ahern2cee77c2011-05-30 08:55:59 -06001002 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
Stephane Eranian023695d2011-02-14 11:20:01 +02001003 csv_sep,
1004 csv_output ? 0 : -24,
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -03001005 perf_evsel__name(counter));
Stephane Eranian023695d2011-02-14 11:20:01 +02001006
1007 if (counter->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001008 fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +02001009
Stephane Eranian4aa90152011-08-15 22:22:33 +02001010 fputc('\n', output);
Ingo Molnar42202dd2009-06-13 14:57:28 +02001011 return;
1012 }
1013
1014 if (nsec_counter(counter))
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001015 nsec_printout(-1, 0, counter, avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +02001016 else
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001017 abs_printout(-1, 0, counter, avg);
Peter Zijlstra849abde2009-09-04 18:23:38 +02001018
Zhengyu He3ae9a34d2011-06-23 13:45:42 -07001019 print_noise(counter, avg);
1020
Stephane Eraniand7470b62010-12-01 18:49:05 +02001021 if (csv_output) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001022 fputc('\n', output);
Stephane Eraniand7470b62010-12-01 18:49:05 +02001023 return;
1024 }
1025
Peter Zijlstra506d4bc2009-09-04 15:36:12 +02001026 if (scaled) {
1027 double avg_enabled, avg_running;
1028
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001029 avg_enabled = avg_stats(&ps->res_stats[1]);
1030 avg_running = avg_stats(&ps->res_stats[2]);
Peter Zijlstra506d4bc2009-09-04 15:36:12 +02001031
Stephane Eranian4aa90152011-08-15 22:22:33 +02001032 fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
Peter Zijlstra506d4bc2009-09-04 15:36:12 +02001033 }
Stephane Eranian4aa90152011-08-15 22:22:33 +02001034 fprintf(output, "\n");
Ingo Molnar42202dd2009-06-13 14:57:28 +02001035}
1036
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001037/*
1038 * Print out the results of a single counter:
1039 * does not use aggregated count in system-wide
1040 */
Stephane Eranian13370a92013-01-29 12:47:44 +01001041static void print_counter(struct perf_evsel *counter, char *prefix)
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001042{
1043 u64 ena, run, val;
1044 int cpu;
1045
Yan, Zheng7ae92e72012-09-10 15:53:50 +08001046 for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -02001047 val = counter->counts->cpu[cpu].val;
1048 ena = counter->counts->cpu[cpu].ena;
1049 run = counter->counts->cpu[cpu].run;
Stephane Eranian13370a92013-01-29 12:47:44 +01001050
1051 if (prefix)
1052 fprintf(output, "%s", prefix);
1053
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001054 if (run == 0 || ena == 0) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001055 fprintf(output, "CPU%*d%s%*s%s%*s",
Stephane Eraniand7470b62010-12-01 18:49:05 +02001056 csv_output ? 0 : -4,
Yan, Zheng7ae92e72012-09-10 15:53:50 +08001057 perf_evsel__cpus(counter)->map[cpu], csv_sep,
Stephane Eraniand7470b62010-12-01 18:49:05 +02001058 csv_output ? 0 : 18,
David Ahern2cee77c2011-05-30 08:55:59 -06001059 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
1060 csv_sep,
Stephane Eranian023695d2011-02-14 11:20:01 +02001061 csv_output ? 0 : -24,
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -03001062 perf_evsel__name(counter));
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001063
Stephane Eranian023695d2011-02-14 11:20:01 +02001064 if (counter->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001065 fprintf(output, "%s%s",
1066 csv_sep, counter->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +02001067
Stephane Eranian4aa90152011-08-15 22:22:33 +02001068 fputc('\n', output);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001069 continue;
1070 }
1071
1072 if (nsec_counter(counter))
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001073 nsec_printout(cpu, 0, counter, val);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001074 else
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001075 abs_printout(cpu, 0, counter, val);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001076
Stephane Eraniand7470b62010-12-01 18:49:05 +02001077 if (!csv_output) {
1078 print_noise(counter, 1.0);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001079
Ingo Molnarc6264de2011-04-27 13:50:47 +02001080 if (run != ena)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001081 fprintf(output, " (%.2f%%)",
1082 100.0 * run / ena);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001083 }
Stephane Eranian4aa90152011-08-15 22:22:33 +02001084 fputc('\n', output);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001085 }
1086}
1087
Ingo Molnar42202dd2009-06-13 14:57:28 +02001088static void print_stat(int argc, const char **argv)
1089{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001090 struct perf_evsel *counter;
1091 int i;
Ingo Molnar42202dd2009-06-13 14:57:28 +02001092
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001093 fflush(stdout);
1094
Stephane Eraniand7470b62010-12-01 18:49:05 +02001095 if (!csv_output) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001096 fprintf(output, "\n");
1097 fprintf(output, " Performance counter stats for ");
Namhyung Kimaa22dd42012-05-16 18:45:47 +09001098 if (!perf_target__has_task(&target)) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001099 fprintf(output, "\'%s", argv[0]);
Stephane Eraniand7470b62010-12-01 18:49:05 +02001100 for (i = 1; i < argc; i++)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001101 fprintf(output, " %s", argv[i]);
Namhyung Kim20f946b2012-04-26 14:15:16 +09001102 } else if (target.pid)
1103 fprintf(output, "process id \'%s", target.pid);
Stephane Eraniand7470b62010-12-01 18:49:05 +02001104 else
Namhyung Kim20f946b2012-04-26 14:15:16 +09001105 fprintf(output, "thread id \'%s", target.tid);
Ingo Molnar44db76c2009-06-03 19:36:07 +02001106
Stephane Eranian4aa90152011-08-15 22:22:33 +02001107 fprintf(output, "\'");
Stephane Eraniand7470b62010-12-01 18:49:05 +02001108 if (run_count > 1)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001109 fprintf(output, " (%d runs)", run_count);
1110 fprintf(output, ":\n\n");
Stephane Eraniand7470b62010-12-01 18:49:05 +02001111 }
Ingo Molnar2996f5d2009-05-29 09:10:54 +02001112
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001113 switch (aggr_mode) {
Stephane Eranian12c08a92013-02-14 13:57:29 +01001114 case AGGR_CORE:
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001115 case AGGR_SOCKET:
1116 print_aggr(NULL);
1117 break;
1118 case AGGR_GLOBAL:
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001119 list_for_each_entry(counter, &evsel_list->entries, node)
Stephane Eranian13370a92013-01-29 12:47:44 +01001120 print_counter_aggr(counter, NULL);
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001121 break;
1122 case AGGR_NONE:
1123 list_for_each_entry(counter, &evsel_list->entries, node)
1124 print_counter(counter, NULL);
1125 break;
1126 default:
1127 break;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001128 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001129
Stephane Eraniand7470b62010-12-01 18:49:05 +02001130 if (!csv_output) {
Ingo Molnarc3305252011-05-19 14:01:42 +02001131 if (!null_run)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001132 fprintf(output, "\n");
1133 fprintf(output, " %17.9f seconds time elapsed",
Stephane Eraniand7470b62010-12-01 18:49:05 +02001134 avg_stats(&walltime_nsecs_stats)/1e9);
1135 if (run_count > 1) {
Stephane Eranian4aa90152011-08-15 22:22:33 +02001136 fprintf(output, " ");
Ingo Molnarf99844c2011-04-27 05:35:39 +02001137 print_noise_pct(stddev_stats(&walltime_nsecs_stats),
1138 avg_stats(&walltime_nsecs_stats));
Stephane Eraniand7470b62010-12-01 18:49:05 +02001139 }
Stephane Eranian4aa90152011-08-15 22:22:33 +02001140 fprintf(output, "\n\n");
Ingo Molnar566747e2009-06-27 06:24:32 +02001141 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001142}
1143
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001144static volatile int signr = -1;
1145
Ingo Molnar52425192009-05-26 09:17:18 +02001146static void skip_signal(int signo)
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001147{
Stephane Eranian13370a92013-01-29 12:47:44 +01001148 if ((child_pid == -1) || interval)
Liming Wang60666c62009-12-31 16:05:50 +08001149 done = 1;
1150
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001151 signr = signo;
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001152 /*
1153 * render child_pid harmless
1154 * won't send SIGTERM to a random
1155 * process in case of race condition
1156 * and fast PID recycling
1157 */
1158 child_pid = -1;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001159}
1160
1161static void sig_atexit(void)
1162{
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001163 sigset_t set, oset;
1164
1165 /*
1166 * avoid race condition with SIGCHLD handler
1167 * in skip_signal() which is modifying child_pid
1168 * goal is to avoid send SIGTERM to a random
1169 * process
1170 */
1171 sigemptyset(&set);
1172 sigaddset(&set, SIGCHLD);
1173 sigprocmask(SIG_BLOCK, &set, &oset);
1174
Chris Wilson933da832009-10-04 01:35:01 +01001175 if (child_pid != -1)
1176 kill(child_pid, SIGTERM);
1177
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001178 sigprocmask(SIG_SETMASK, &oset, NULL);
1179
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001180 if (signr == -1)
1181 return;
1182
1183 signal(signr, SIG_DFL);
1184 kill(getpid(), signr);
Ingo Molnar52425192009-05-26 09:17:18 +02001185}
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001186
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001187static int stat__set_big_num(const struct option *opt __maybe_unused,
1188 const char *s __maybe_unused, int unset)
Stephane Eraniand7470b62010-12-01 18:49:05 +02001189{
1190 big_num_opt = unset ? 0 : 1;
1191 return 0;
1192}
1193
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001194static int perf_stat_init_aggr_mode(void)
1195{
1196 switch (aggr_mode) {
1197 case AGGR_SOCKET:
1198 if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
1199 perror("cannot build socket map");
1200 return -1;
1201 }
1202 aggr_get_id = cpu_map__get_socket;
1203 break;
Stephane Eranian12c08a92013-02-14 13:57:29 +01001204 case AGGR_CORE:
1205 if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
1206 perror("cannot build core map");
1207 return -1;
1208 }
1209 aggr_get_id = cpu_map__get_core;
1210 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001211 case AGGR_NONE:
1212 case AGGR_GLOBAL:
1213 default:
1214 break;
1215 }
1216 return 0;
1217}
1218
1219
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001220/*
1221 * Add default attributes, if there were no attributes specified or
1222 * if -d/--detailed, -d -d or -d -d -d is used:
1223 */
1224static int add_default_attributes(void)
1225{
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001226 struct perf_event_attr default_attrs[] = {
1227
1228 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK },
1229 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES },
1230 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS },
1231 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS },
1232
1233 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES },
1234 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
1235 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND },
1236 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS },
1237 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
1238 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES },
1239
1240};
1241
1242/*
1243 * Detailed stats (-d), covering the L1 and last level data caches:
1244 */
1245 struct perf_event_attr detailed_attrs[] = {
1246
1247 { .type = PERF_TYPE_HW_CACHE,
1248 .config =
1249 PERF_COUNT_HW_CACHE_L1D << 0 |
1250 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1251 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1252
1253 { .type = PERF_TYPE_HW_CACHE,
1254 .config =
1255 PERF_COUNT_HW_CACHE_L1D << 0 |
1256 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1257 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1258
1259 { .type = PERF_TYPE_HW_CACHE,
1260 .config =
1261 PERF_COUNT_HW_CACHE_LL << 0 |
1262 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1263 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1264
1265 { .type = PERF_TYPE_HW_CACHE,
1266 .config =
1267 PERF_COUNT_HW_CACHE_LL << 0 |
1268 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1269 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1270};
1271
1272/*
1273 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1274 */
1275 struct perf_event_attr very_detailed_attrs[] = {
1276
1277 { .type = PERF_TYPE_HW_CACHE,
1278 .config =
1279 PERF_COUNT_HW_CACHE_L1I << 0 |
1280 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1281 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1282
1283 { .type = PERF_TYPE_HW_CACHE,
1284 .config =
1285 PERF_COUNT_HW_CACHE_L1I << 0 |
1286 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1287 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1288
1289 { .type = PERF_TYPE_HW_CACHE,
1290 .config =
1291 PERF_COUNT_HW_CACHE_DTLB << 0 |
1292 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1293 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1294
1295 { .type = PERF_TYPE_HW_CACHE,
1296 .config =
1297 PERF_COUNT_HW_CACHE_DTLB << 0 |
1298 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1299 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1300
1301 { .type = PERF_TYPE_HW_CACHE,
1302 .config =
1303 PERF_COUNT_HW_CACHE_ITLB << 0 |
1304 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1305 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1306
1307 { .type = PERF_TYPE_HW_CACHE,
1308 .config =
1309 PERF_COUNT_HW_CACHE_ITLB << 0 |
1310 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1311 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1312
1313};
1314
1315/*
1316 * Very, very detailed stats (-d -d -d), adding prefetch events:
1317 */
1318 struct perf_event_attr very_very_detailed_attrs[] = {
1319
1320 { .type = PERF_TYPE_HW_CACHE,
1321 .config =
1322 PERF_COUNT_HW_CACHE_L1D << 0 |
1323 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) |
1324 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1325
1326 { .type = PERF_TYPE_HW_CACHE,
1327 .config =
1328 PERF_COUNT_HW_CACHE_L1D << 0 |
1329 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) |
1330 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1331};
1332
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001333 /* Set attrs if no event is selected and !null_run: */
1334 if (null_run)
1335 return 0;
1336
1337 if (!evsel_list->nr_entries) {
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001338 if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001339 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001340 }
1341
1342 /* Detailed events get appended to the event list: */
1343
1344 if (detailed_run < 1)
1345 return 0;
1346
1347 /* Append detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001348 if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001349 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001350
1351 if (detailed_run < 2)
1352 return 0;
1353
1354 /* Append very detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001355 if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001356 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001357
1358 if (detailed_run < 3)
1359 return 0;
1360
1361 /* Append very, very detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001362 return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001363}
1364
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001365int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
Ingo Molnar52425192009-05-26 09:17:18 +02001366{
Peter Zijlstra1f16c572012-10-23 13:40:14 +02001367 bool append_file = false;
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001368 int output_fd = 0;
1369 const char *output_name = NULL;
1370 const struct option options[] = {
1371 OPT_CALLBACK('e', "event", &evsel_list, "event",
1372 "event selector. use 'perf list' to list available events",
1373 parse_events_option),
1374 OPT_CALLBACK(0, "filter", &evsel_list, "filter",
1375 "event filter", parse_filter),
1376 OPT_BOOLEAN('i', "no-inherit", &no_inherit,
1377 "child tasks do not inherit counters"),
1378 OPT_STRING('p', "pid", &target.pid, "pid",
1379 "stat events on existing process id"),
1380 OPT_STRING('t', "tid", &target.tid, "tid",
1381 "stat events on existing thread id"),
1382 OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
1383 "system-wide collection from all CPUs"),
1384 OPT_BOOLEAN('g', "group", &group,
1385 "put the counters into a counter group"),
1386 OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"),
1387 OPT_INCR('v', "verbose", &verbose,
1388 "be more verbose (show counter open errors, etc)"),
1389 OPT_INTEGER('r', "repeat", &run_count,
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001390 "repeat command and print average + stddev (max: 100, forever: 0)"),
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001391 OPT_BOOLEAN('n', "null", &null_run,
1392 "null run - dont start any counters"),
1393 OPT_INCR('d', "detailed", &detailed_run,
1394 "detailed run - start a lot of events"),
1395 OPT_BOOLEAN('S', "sync", &sync_run,
1396 "call sync() before starting a run"),
1397 OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
1398 "print large numbers with thousands\' separators",
1399 stat__set_big_num),
1400 OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
1401 "list of cpus to monitor in system-wide"),
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001402 OPT_SET_UINT('A', "no-aggr", &aggr_mode,
1403 "disable CPU count aggregation", AGGR_NONE),
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001404 OPT_STRING('x', "field-separator", &csv_sep, "separator",
1405 "print counts with custom separator"),
1406 OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1407 "monitor event in cgroup name only", parse_cgroups),
1408 OPT_STRING('o', "output", &output_name, "file", "output file name"),
1409 OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
1410 OPT_INTEGER(0, "log-fd", &output_fd,
1411 "log output to fd, instead of stderr"),
Peter Zijlstra1f16c572012-10-23 13:40:14 +02001412 OPT_STRING(0, "pre", &pre_cmd, "command",
1413 "command to run prior to the measured command"),
1414 OPT_STRING(0, "post", &post_cmd, "command",
1415 "command to run after to the measured command"),
Stephane Eranian13370a92013-01-29 12:47:44 +01001416 OPT_UINTEGER('I', "interval-print", &interval,
1417 "print counts at regular interval in ms (>= 100)"),
Stephane Eraniand4304952013-02-14 13:57:28 +01001418 OPT_SET_UINT(0, "per-socket", &aggr_mode,
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001419 "aggregate counts per processor socket", AGGR_SOCKET),
Stephane Eranian12c08a92013-02-14 13:57:29 +01001420 OPT_SET_UINT(0, "per-core", &aggr_mode,
1421 "aggregate counts per physical processor core", AGGR_CORE),
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001422 OPT_END()
1423 };
1424 const char * const stat_usage[] = {
1425 "perf stat [<options>] [<command>]",
1426 NULL
1427 };
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001428 int status = -ENOMEM, run_idx;
Stephane Eranian4aa90152011-08-15 22:22:33 +02001429 const char *mode;
Ingo Molnar42202dd2009-06-13 14:57:28 +02001430
Stephane Eranian5af52b52010-05-18 15:00:01 +02001431 setlocale(LC_ALL, "");
1432
Namhyung Kim334fe7a2013-03-11 16:43:12 +09001433 evsel_list = perf_evlist__new();
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001434 if (evsel_list == NULL)
1435 return -ENOMEM;
1436
Anton Blancharda0541232009-07-22 23:04:12 +10001437 argc = parse_options(argc, argv, options, stat_usage,
1438 PARSE_OPT_STOP_AT_NON_OPTION);
Stephane Eraniand7470b62010-12-01 18:49:05 +02001439
Stephane Eranian4aa90152011-08-15 22:22:33 +02001440 output = stderr;
1441 if (output_name && strcmp(output_name, "-"))
1442 output = NULL;
1443
Jim Cromie56f3bae2011-09-07 17:14:00 -06001444 if (output_name && output_fd) {
1445 fprintf(stderr, "cannot use both --output and --log-fd\n");
1446 usage_with_options(stat_usage, options);
1447 }
Stephane Eranianfc3e4d02012-05-15 13:11:11 +02001448
1449 if (output_fd < 0) {
1450 fprintf(stderr, "argument to --log-fd must be a > 0\n");
1451 usage_with_options(stat_usage, options);
1452 }
1453
Stephane Eranian4aa90152011-08-15 22:22:33 +02001454 if (!output) {
1455 struct timespec tm;
1456 mode = append_file ? "a" : "w";
1457
1458 output = fopen(output_name, mode);
1459 if (!output) {
1460 perror("failed to create output file");
David Ahernfceda7f2012-08-26 12:24:44 -06001461 return -1;
Stephane Eranian4aa90152011-08-15 22:22:33 +02001462 }
1463 clock_gettime(CLOCK_REALTIME, &tm);
1464 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
Stephane Eranianfc3e4d02012-05-15 13:11:11 +02001465 } else if (output_fd > 0) {
Jim Cromie56f3bae2011-09-07 17:14:00 -06001466 mode = append_file ? "a" : "w";
1467 output = fdopen(output_fd, mode);
1468 if (!output) {
1469 perror("Failed opening logfd");
1470 return -errno;
1471 }
Stephane Eranian4aa90152011-08-15 22:22:33 +02001472 }
1473
Jim Cromied4ffd042011-09-07 17:14:03 -06001474 if (csv_sep) {
Stephane Eraniand7470b62010-12-01 18:49:05 +02001475 csv_output = true;
Jim Cromied4ffd042011-09-07 17:14:03 -06001476 if (!strcmp(csv_sep, "\\t"))
1477 csv_sep = "\t";
1478 } else
Stephane Eraniand7470b62010-12-01 18:49:05 +02001479 csv_sep = DEFAULT_SEPARATOR;
1480
1481 /*
1482 * let the spreadsheet do the pretty-printing
1483 */
1484 if (csv_output) {
Jim Cromie61a9f322011-09-07 17:14:04 -06001485 /* User explicitly passed -B? */
Stephane Eraniand7470b62010-12-01 18:49:05 +02001486 if (big_num_opt == 1) {
1487 fprintf(stderr, "-B option not supported with -x\n");
1488 usage_with_options(stat_usage, options);
1489 } else /* Nope, so disable big number formatting */
1490 big_num = false;
1491 } else if (big_num_opt == 0) /* User passed --no-big-num */
1492 big_num = false;
1493
Namhyung Kimaa22dd42012-05-16 18:45:47 +09001494 if (!argc && !perf_target__has_task(&target))
Ingo Molnar52425192009-05-26 09:17:18 +02001495 usage_with_options(stat_usage, options);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001496 if (run_count < 0) {
Ingo Molnar42202dd2009-06-13 14:57:28 +02001497 usage_with_options(stat_usage, options);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001498 } else if (run_count == 0) {
1499 forever = true;
1500 run_count = 1;
1501 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001502
Stephane Eranian023695d2011-02-14 11:20:01 +02001503 /* no_aggr, cgroup are for system-wide only */
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001504 if ((aggr_mode != AGGR_GLOBAL || nr_cgroups)
1505 && !perf_target__has_cpu(&target)) {
Stephane Eranian023695d2011-02-14 11:20:01 +02001506 fprintf(stderr, "both cgroup and no-aggregation "
1507 "modes only available in system-wide mode\n");
1508
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001509 usage_with_options(stat_usage, options);
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001510 return -1;
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001511 }
1512
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001513 if (add_default_attributes())
1514 goto out;
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001515
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09001516 perf_target__validate(&target);
Arnaldo Carvalho de Melo5c98d4662011-01-03 17:53:33 -02001517
Namhyung Kim77a6f012012-05-07 14:09:04 +09001518 if (perf_evlist__create_maps(evsel_list, &target) < 0) {
Namhyung Kimaa22dd42012-05-16 18:45:47 +09001519 if (perf_target__has_task(&target))
Namhyung Kim77a6f012012-05-07 14:09:04 +09001520 pr_err("Problems finding threads of monitor\n");
Namhyung Kimaa22dd42012-05-16 18:45:47 +09001521 if (perf_target__has_cpu(&target))
Namhyung Kim77a6f012012-05-07 14:09:04 +09001522 perror("failed to parse CPUs map");
Arnaldo Carvalho de Melo5c98d4662011-01-03 17:53:33 -02001523
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001524 usage_with_options(stat_usage, options);
Arnaldo Carvalho de Melo60d567e2011-01-03 17:49:48 -02001525 return -1;
1526 }
Stephane Eranian13370a92013-01-29 12:47:44 +01001527 if (interval && interval < 100) {
1528 pr_err("print interval must be >= 100ms\n");
1529 usage_with_options(stat_usage, options);
1530 return -1;
1531 }
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001532
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001533 if (perf_evlist__alloc_stats(evsel_list, interval))
1534 goto out_free_maps;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001535
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001536 if (perf_stat_init_aggr_mode())
1537 goto out;
1538
Ingo Molnar58d7e992009-05-15 11:03:23 +02001539 /*
1540 * We dont want to block the signals - that would cause
1541 * child tasks to inherit that and Ctrl-C would not work.
1542 * What we want is for Ctrl-C to work in the exec()-ed
1543 * task, but being ignored by perf stat itself:
1544 */
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001545 atexit(sig_atexit);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001546 if (!forever)
1547 signal(SIGINT, skip_signal);
Stephane Eranian13370a92013-01-29 12:47:44 +01001548 signal(SIGCHLD, skip_signal);
Ingo Molnar58d7e992009-05-15 11:03:23 +02001549 signal(SIGALRM, skip_signal);
1550 signal(SIGABRT, skip_signal);
1551
Ingo Molnar42202dd2009-06-13 14:57:28 +02001552 status = 0;
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001553 for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
Ingo Molnar42202dd2009-06-13 14:57:28 +02001554 if (run_count != 1 && verbose)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001555 fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1556 run_idx + 1);
Ingo Molnarf9cef0a2011-04-28 18:17:11 +02001557
Ingo Molnar42202dd2009-06-13 14:57:28 +02001558 status = run_perf_stat(argc, argv);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001559 if (forever && status != -1) {
1560 print_stat(argc, argv);
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001561 perf_stat__reset_stats(evsel_list);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001562 }
Ingo Molnar42202dd2009-06-13 14:57:28 +02001563 }
1564
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001565 if (!forever && status != -1 && !interval)
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -03001566 print_stat(argc, argv);
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001567
1568 perf_evlist__free_stats(evsel_list);
1569out_free_maps:
Arnaldo Carvalho de Melo7e2ed092011-01-30 11:59:43 -02001570 perf_evlist__delete_maps(evsel_list);
Arnaldo Carvalho de Melo0015e2e2011-02-01 16:18:10 -02001571out:
1572 perf_evlist__delete(evsel_list);
Ingo Molnar42202dd2009-06-13 14:57:28 +02001573 return status;
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001574}