blob: fcece42c2611925c571c6f90f4f25ac33a7d4035 [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"
Arnaldo Carvalho de Melof14d5702014-10-17 12:17:40 -030046#include "util/cgroup.h"
Ingo Molnar148be2c2009-04-27 08:02:14 +020047#include "util/util.h"
Josh Poimboeuf4b6ab942015-12-15 09:39:39 -060048#include <subcmd/parse-options.h>
Ingo Molnar52425192009-05-26 09:17:18 +020049#include "util/parse-events.h"
Andi Kleen4cabc3d2013-08-21 16:47:26 -070050#include "util/pmu.h"
Frederic Weisbecker8f28827a2009-08-16 22:05:48 +020051#include "util/event.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020052#include "util/evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -020053#include "util/evsel.h"
Frederic Weisbecker8f28827a2009-08-16 22:05:48 +020054#include "util/debug.h"
Ingo Molnara5d243d2011-04-27 05:39:24 +020055#include "util/color.h"
Xiao Guangrong0007ece2012-09-17 16:31:14 +080056#include "util/stat.h"
Liming Wang60666c62009-12-31 16:05:50 +080057#include "util/header.h"
Paul Mackerrasa12b51c2010-03-10 20:36:09 +110058#include "util/cpumap.h"
Zhang, Yanmind6d901c2010-03-18 11:36:05 -030059#include "util/thread.h"
Arnaldo Carvalho de Melofd782602011-01-18 15:15:24 -020060#include "util/thread_map.h"
Jiri Olsad8095602015-08-07 12:51:03 +020061#include "util/counts.h"
Jiri Olsa4979d0c2015-11-05 15:40:46 +010062#include "util/session.h"
Ingo Molnarddcacfa2009-04-20 15:37:32 +020063
Peter Zijlstra1f16c572012-10-23 13:40:14 +020064#include <stdlib.h>
Ingo Molnarddcacfa2009-04-20 15:37:32 +020065#include <sys/prctl.h>
Stephane Eranian5af52b52010-05-18 15:00:01 +020066#include <locale.h>
Peter Zijlstra16c8a102009-05-05 17:50:27 +020067
Stephane Eraniand7470b62010-12-01 18:49:05 +020068#define DEFAULT_SEPARATOR " "
David Ahern2cee77c2011-05-30 08:55:59 -060069#define CNTR_NOT_SUPPORTED "<not supported>"
70#define CNTR_NOT_COUNTED "<not counted>"
Stephane Eraniand7470b62010-12-01 18:49:05 +020071
Jiri Olsad4f63a42015-06-26 11:29:26 +020072static void print_counters(struct timespec *ts, int argc, const char **argv);
Stephane Eranian13370a92013-01-29 12:47:44 +010073
Andi Kleen4cabc3d2013-08-21 16:47:26 -070074/* Default events used for perf stat -T */
Jiri Olsaa4547422015-06-03 16:25:53 +020075static const char *transaction_attrs = {
76 "task-clock,"
Andi Kleen4cabc3d2013-08-21 16:47:26 -070077 "{"
78 "instructions,"
79 "cycles,"
80 "cpu/cycles-t/,"
81 "cpu/tx-start/,"
82 "cpu/el-start/,"
83 "cpu/cycles-ct/"
84 "}"
85};
86
87/* More limited version when the CPU does not have all events. */
Jiri Olsaa4547422015-06-03 16:25:53 +020088static const char * transaction_limited_attrs = {
89 "task-clock,"
Andi Kleen4cabc3d2013-08-21 16:47:26 -070090 "{"
91 "instructions,"
92 "cycles,"
93 "cpu/cycles-t/,"
94 "cpu/tx-start/"
95 "}"
96};
97
Robert Richter666e6d42012-04-05 18:26:27 +020098static struct perf_evlist *evsel_list;
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020099
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -0300100static struct target target = {
Namhyung Kim77a6f012012-05-07 14:09:04 +0900101 .uid = UINT_MAX,
102};
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +0530103
Jiri Olsa1e5a2932015-10-25 15:51:18 +0100104typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);
105
Jaswinder Singh Rajput3d632592009-06-24 18:19:34 +0530106static int run_count = 1;
Stephane Eranian2e6cdf92010-05-12 10:40:01 +0200107static bool no_inherit = false;
Stephane Eraniand07f0b12013-06-04 17:44:26 +0200108static volatile pid_t child_pid = -1;
Ian Munsiec0555642010-04-13 18:37:33 +1000109static bool null_run = false;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +0200110static int detailed_run = 0;
Andi Kleen4cabc3d2013-08-21 16:47:26 -0700111static bool transaction_run;
Arnaldo Carvalho de Melo201e0b02010-12-01 17:53:27 -0200112static bool big_num = true;
Stephane Eraniand7470b62010-12-01 18:49:05 +0200113static int big_num_opt = -1;
Stephane Eraniand7470b62010-12-01 18:49:05 +0200114static const char *csv_sep = NULL;
115static bool csv_output = false;
Lin Ming43bece72011-08-17 18:42:07 +0800116static bool group = false;
Peter Zijlstra1f16c572012-10-23 13:40:14 +0200117static const char *pre_cmd = NULL;
118static const char *post_cmd = NULL;
119static bool sync_run = false;
Andi Kleen41191682013-08-02 17:41:11 -0700120static unsigned int initial_delay = 0;
Stephane Eranian410136f2013-11-12 17:58:49 +0100121static unsigned int unit_width = 4; /* strlen("unit") */
Frederik Deweerdta7e191c2013-03-01 13:02:27 -0500122static bool forever = false;
Stephane Eranian13370a92013-01-29 12:47:44 +0100123static struct timespec ref_time;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100124static struct cpu_map *aggr_map;
Jiri Olsa1e5a2932015-10-25 15:51:18 +0100125static aggr_get_id_t aggr_get_id;
Jiri Olsae0547312015-11-05 15:40:45 +0100126static bool append_file;
127static const char *output_name;
128static int output_fd;
Stephane Eranian5af52b52010-05-18 15:00:01 +0200129
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100130struct perf_stat {
131 bool record;
132 struct perf_data_file file;
133 struct perf_session *session;
134 u64 bytes_written;
135};
136
137static struct perf_stat perf_stat;
138#define STAT_RECORD perf_stat.record
139
Liming Wang60666c62009-12-31 16:05:50 +0800140static volatile int done = 0;
141
Jiri Olsa421a50f2015-07-21 14:31:22 +0200142static struct perf_stat_config stat_config = {
143 .aggr_mode = AGGR_GLOBAL,
Jiri Olsa711a5722015-07-21 14:31:23 +0200144 .scale = true,
Jiri Olsa421a50f2015-07-21 14:31:22 +0200145};
146
Stephane Eranian13370a92013-01-29 12:47:44 +0100147static inline void diff_timespec(struct timespec *r, struct timespec *a,
148 struct timespec *b)
149{
150 r->tv_sec = a->tv_sec - b->tv_sec;
151 if (a->tv_nsec < b->tv_nsec) {
152 r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
153 r->tv_sec--;
154 } else {
155 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
156 }
157}
158
Jiri Olsa254ecbc2015-06-26 11:29:13 +0200159static void perf_stat__reset_stats(void)
160{
161 perf_evlist__reset_stats(evsel_list);
Jiri Olsaf87027b2015-06-03 16:25:59 +0200162 perf_stat__reset_shadow_stats();
Jiri Olsa1eda3b22015-06-03 16:25:55 +0200163}
164
Jiri Olsacac21422012-11-12 18:34:00 +0100165static int create_perf_stat_counter(struct perf_evsel *evsel)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200166{
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200167 struct perf_event_attr *attr = &evsel->attr;
Arnaldo Carvalho de Melo727ab042011-10-25 10:42:19 -0200168
Jiri Olsa711a5722015-07-21 14:31:23 +0200169 if (stat_config.scale)
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200170 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
171 PERF_FORMAT_TOTAL_TIME_RUNNING;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200172
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200173 attr->inherit = !no_inherit;
Arnaldo Carvalho de Melo5d2cd902011-04-14 11:20:14 -0300174
Jiri Olsa6acd8e92015-11-25 16:36:54 +0100175 /*
176 * Some events get initialized with sample_(period/type) set,
177 * like tracepoints. Clear it up for counting.
178 */
179 attr->sample_period = 0;
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100180 /*
181 * But set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
182 * while avoiding that older tools show confusing messages.
183 */
184 attr->sample_type = PERF_SAMPLE_IDENTIFIER;
Jiri Olsa6acd8e92015-11-25 16:36:54 +0100185
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100186 /*
187 * Disabling all counters initially, they will be enabled
188 * either manually by us or by kernel via enable_on_exec
189 * set later.
190 */
Jiri Olsac8280ce2015-12-03 10:06:45 +0100191 if (perf_evsel__is_group_leader(evsel)) {
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100192 attr->disabled = 1;
193
Jiri Olsac8280ce2015-12-03 10:06:45 +0100194 /*
195 * In case of initial_delay we enable tracee
196 * events manually.
197 */
198 if (target__none(&target) && !initial_delay)
199 attr->enable_on_exec = 1;
200 }
201
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -0300202 if (target__has_cpu(&target))
Arnaldo Carvalho de Melo594ac612012-12-13 13:13:07 -0300203 return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
Stephane Eranian5622c072012-04-27 14:45:38 +0200204
Arnaldo Carvalho de Melo594ac612012-12-13 13:13:07 -0300205 return perf_evsel__open_per_thread(evsel, evsel_list->threads);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200206}
207
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200208/*
209 * Does the counter have nsecs as a unit?
210 */
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200211static inline int nsec_counter(struct perf_evsel *evsel)
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200212{
Arnaldo Carvalho de Melodaec78a2011-01-03 16:49:44 -0200213 if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
214 perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
Ingo Molnarc04f5e52009-05-29 09:10:54 +0200215 return 1;
216
217 return 0;
218}
219
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100220static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100221 union perf_event *event,
222 struct perf_sample *sample __maybe_unused,
223 struct machine *machine __maybe_unused)
224{
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100225 if (perf_data_file__write(&perf_stat.file, event, event->header.size) < 0) {
226 pr_err("failed to write perf data, error: %m\n");
227 return -1;
228 }
229
230 perf_stat.bytes_written += event->header.size;
231 return 0;
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100232}
233
Jiri Olsa7aad0c32015-11-05 15:40:52 +0100234static int write_stat_round_event(u64 time, u64 type)
235{
236 return perf_event__synthesize_stat_round(NULL, time, type,
237 process_synthesized_event,
238 NULL);
239}
240
241#define WRITE_STAT_ROUND_EVENT(time, interval) \
242 write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval)
243
Jiri Olsa5a6ea812015-11-05 15:40:51 +0100244#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
245
246static int
247perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread,
248 struct perf_counts_values *count)
249{
250 struct perf_sample_id *sid = SID(counter, cpu, thread);
251
252 return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count,
253 process_synthesized_event, NULL);
254}
255
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200256/*
257 * Read out the results of a single counter:
258 * do not aggregate counts across CPUs in system-wide mode
259 */
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200260static int read_counter(struct perf_evsel *counter)
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200261{
Jiri Olsa9bf1a522014-11-21 10:31:09 +0100262 int nthreads = thread_map__nr(evsel_list->threads);
263 int ncpus = perf_evsel__nr_cpus(counter);
264 int cpu, thread;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200265
Suzuki K. Poulose3b4331d2015-02-13 18:40:58 +0000266 if (!counter->supported)
267 return -ENOENT;
268
Jiri Olsa9bf1a522014-11-21 10:31:09 +0100269 if (counter->system_wide)
270 nthreads = 1;
271
272 for (thread = 0; thread < nthreads; thread++) {
273 for (cpu = 0; cpu < ncpus; cpu++) {
Jiri Olsa3b3eb042015-06-26 11:29:20 +0200274 struct perf_counts_values *count;
275
276 count = perf_counts(counter->counts, cpu, thread);
277 if (perf_evsel__read(counter, cpu, thread, count))
Jiri Olsa9bf1a522014-11-21 10:31:09 +0100278 return -1;
Jiri Olsa5a6ea812015-11-05 15:40:51 +0100279
280 if (STAT_RECORD) {
281 if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
282 pr_err("failed to write stat event\n");
283 return -1;
284 }
285 }
Jiri Olsa9bf1a522014-11-21 10:31:09 +0100286 }
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200287 }
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200288
289 return 0;
Ingo Molnar2996f5d2009-05-29 09:10:54 +0200290}
291
Jiri Olsa5fc472a2015-07-08 13:17:31 +0200292static void read_counters(bool close_counters)
Jiri Olsa106a94a2015-06-26 11:29:19 +0200293{
294 struct perf_evsel *counter;
Jiri Olsa106a94a2015-06-26 11:29:19 +0200295
296 evlist__for_each(evsel_list, counter) {
Jiri Olsa3b3eb042015-06-26 11:29:20 +0200297 if (read_counter(counter))
Andi Kleen245bad82015-09-01 15:52:46 -0700298 pr_debug("failed to read counter %s\n", counter->name);
Jiri Olsa3b3eb042015-06-26 11:29:20 +0200299
Jiri Olsaf80010e2015-07-21 14:31:27 +0200300 if (perf_stat_process_counter(&stat_config, counter))
Jiri Olsa3b3eb042015-06-26 11:29:20 +0200301 pr_warning("failed to process counter %s\n", counter->name);
Jiri Olsa106a94a2015-06-26 11:29:19 +0200302
Jiri Olsa5fc472a2015-07-08 13:17:31 +0200303 if (close_counters) {
Jiri Olsa106a94a2015-06-26 11:29:19 +0200304 perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
305 thread_map__nr(evsel_list->threads));
306 }
307 }
308}
309
Jiri Olsaba411a92015-06-26 11:29:24 +0200310static void process_interval(void)
Stephane Eranian13370a92013-01-29 12:47:44 +0100311{
Stephane Eranian13370a92013-01-29 12:47:44 +0100312 struct timespec ts, rs;
Stephane Eranian13370a92013-01-29 12:47:44 +0100313
Jiri Olsa106a94a2015-06-26 11:29:19 +0200314 read_counters(false);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100315
Stephane Eranian13370a92013-01-29 12:47:44 +0100316 clock_gettime(CLOCK_MONOTONIC, &ts);
317 diff_timespec(&rs, &ts, &ref_time);
Stephane Eranian13370a92013-01-29 12:47:44 +0100318
Jiri Olsa7aad0c32015-11-05 15:40:52 +0100319 if (STAT_RECORD) {
320 if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSECS_PER_SEC + rs.tv_nsec, INTERVAL))
321 pr_err("failed to write stat round event\n");
322 }
323
Jiri Olsad4f63a42015-06-26 11:29:26 +0200324 print_counters(&rs, 0, NULL);
Stephane Eranian13370a92013-01-29 12:47:44 +0100325}
326
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100327static void enable_counters(void)
Andi Kleen41191682013-08-02 17:41:11 -0700328{
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100329 if (initial_delay)
Andi Kleen41191682013-08-02 17:41:11 -0700330 usleep(initial_delay * 1000);
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100331
332 /*
333 * We need to enable counters only if:
334 * - we don't have tracee (attaching to task or cpu)
335 * - we have initial delay configured
336 */
337 if (!target__none(&target) || initial_delay)
Jiri Olsaab46db02015-12-03 10:06:43 +0100338 perf_evlist__enable(evsel_list);
Andi Kleen41191682013-08-02 17:41:11 -0700339}
340
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300341static volatile int workload_exec_errno;
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300342
343/*
344 * perf_evlist__prepare_workload will send a SIGUSR1
345 * if the fork fails, since we asked by setting its
346 * want_signal to true.
347 */
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300348static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info,
349 void *ucontext __maybe_unused)
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300350{
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300351 workload_exec_errno = info->si_value.sival_int;
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300352}
353
Jiri Olsa664c98d2015-11-05 15:40:50 +0100354static int perf_stat_synthesize_config(bool is_pipe)
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100355{
356 int err;
357
Jiri Olsa664c98d2015-11-05 15:40:50 +0100358 if (is_pipe) {
359 err = perf_event__synthesize_attrs(NULL, perf_stat.session,
360 process_synthesized_event);
361 if (err < 0) {
362 pr_err("Couldn't synthesize attrs.\n");
363 return err;
364 }
365 }
366
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100367 err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads,
368 process_synthesized_event,
369 NULL);
370 if (err < 0) {
371 pr_err("Couldn't synthesize thread map.\n");
372 return err;
373 }
374
375 err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus,
376 process_synthesized_event, NULL);
377 if (err < 0) {
378 pr_err("Couldn't synthesize thread map.\n");
379 return err;
380 }
381
382 err = perf_event__synthesize_stat_config(NULL, &stat_config,
383 process_synthesized_event, NULL);
384 if (err < 0) {
385 pr_err("Couldn't synthesize config.\n");
386 return err;
387 }
388
389 return 0;
390}
391
Jiri Olsa2af46462015-11-05 15:40:49 +0100392#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
393
394static int __store_counter_ids(struct perf_evsel *counter,
395 struct cpu_map *cpus,
396 struct thread_map *threads)
397{
398 int cpu, thread;
399
400 for (cpu = 0; cpu < cpus->nr; cpu++) {
401 for (thread = 0; thread < threads->nr; thread++) {
402 int fd = FD(counter, cpu, thread);
403
404 if (perf_evlist__id_add_fd(evsel_list, counter,
405 cpu, thread, fd) < 0)
406 return -1;
407 }
408 }
409
410 return 0;
411}
412
413static int store_counter_ids(struct perf_evsel *counter)
414{
415 struct cpu_map *cpus = counter->cpus;
416 struct thread_map *threads = counter->threads;
417
418 if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr))
419 return -ENOMEM;
420
421 return __store_counter_ids(counter, cpus, threads);
422}
423
Namhyung Kimacf28922013-03-11 16:43:18 +0900424static int __run_perf_stat(int argc, const char **argv)
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200425{
Jiri Olsaec0d3d12015-07-21 14:31:25 +0200426 int interval = stat_config.interval;
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300427 char msg[512];
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200428 unsigned long long t0, t1;
Jiri Olsacac21422012-11-12 18:34:00 +0100429 struct perf_evsel *counter;
Stephane Eranian13370a92013-01-29 12:47:44 +0100430 struct timespec ts;
Stephane Eranian410136f2013-11-12 17:58:49 +0100431 size_t l;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200432 int status = 0;
Zhang, Yanmin6be28502010-03-18 11:36:03 -0300433 const bool forks = (argc > 0);
Jiri Olsa664c98d2015-11-05 15:40:50 +0100434 bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false;
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200435
Stephane Eranian13370a92013-01-29 12:47:44 +0100436 if (interval) {
437 ts.tv_sec = interval / 1000;
438 ts.tv_nsec = (interval % 1000) * 1000000;
439 } else {
440 ts.tv_sec = 1;
441 ts.tv_nsec = 0;
442 }
443
Liming Wang60666c62009-12-31 16:05:50 +0800444 if (forks) {
Jiri Olsa664c98d2015-11-05 15:40:50 +0100445 if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -0300446 workload_exec_failed_signal) < 0) {
Namhyung Kimacf28922013-03-11 16:43:18 +0900447 perror("failed to prepare workload");
448 return -1;
Liming Wang60666c62009-12-31 16:05:50 +0800449 }
Namhyung Kimd20a47e2013-09-30 18:01:11 +0900450 child_pid = evsel_list->workload.pid;
Paul Mackerras051ae7f2009-06-29 21:13:21 +1000451 }
452
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200453 if (group)
Arnaldo Carvalho de Melo63dab222012-08-14 16:35:48 -0300454 perf_evlist__set_leader(evsel_list);
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200455
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -0300456 evlist__for_each(evsel_list, counter) {
Jiri Olsacac21422012-11-12 18:34:00 +0100457 if (create_perf_stat_counter(counter) < 0) {
David Ahern979987a2012-05-08 09:29:16 -0600458 /*
459 * PPC returns ENXIO for HW counters until 2.6.37
460 * (behavior changed with commit b0a873e).
461 */
Anton Blanchard38f6ae12011-12-02 09:38:33 +1100462 if (errno == EINVAL || errno == ENOSYS ||
David Ahern979987a2012-05-08 09:29:16 -0600463 errno == ENOENT || errno == EOPNOTSUPP ||
464 errno == ENXIO) {
David Ahernc63ca0c2011-04-29 16:04:15 -0600465 if (verbose)
466 ui__warning("%s event is not supported by the kernel.\n",
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -0300467 perf_evsel__name(counter));
David Ahern2cee77c2011-05-30 08:55:59 -0600468 counter->supported = false;
Kan Liangcb5ef602015-06-11 02:32:40 -0400469
470 if ((counter->leader != counter) ||
471 !(counter->leader->nr_members > 1))
472 continue;
David Ahernc63ca0c2011-04-29 16:04:15 -0600473 }
Ingo Molnarede70292011-04-28 08:48:42 +0200474
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300475 perf_evsel__open_strerror(counter, &target,
476 errno, msg, sizeof(msg));
477 ui__error("%s\n", msg);
478
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200479 if (child_pid != -1)
480 kill(child_pid, SIGTERM);
David Ahernfceda7f2012-08-26 12:24:44 -0600481
Arnaldo Carvalho de Melo48290602011-01-03 17:48:12 -0200482 return -1;
483 }
David Ahern2cee77c2011-05-30 08:55:59 -0600484 counter->supported = true;
Stephane Eranian410136f2013-11-12 17:58:49 +0100485
486 l = strlen(counter->unit);
487 if (l > unit_width)
488 unit_width = l;
Jiri Olsa2af46462015-11-05 15:40:49 +0100489
490 if (STAT_RECORD && store_counter_ids(counter))
491 return -1;
Arnaldo Carvalho de Melo084ab9f2010-03-22 13:10:28 -0300492 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200493
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300494 if (perf_evlist__apply_filters(evsel_list, &counter)) {
495 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
496 counter->filter, perf_evsel__name(counter), errno,
Masami Hiramatsu759e6122014-08-14 02:22:55 +0000497 strerror_r(errno, msg, sizeof(msg)));
Frederic Weisbeckercfd748a2011-03-14 16:40:30 +0100498 return -1;
499 }
500
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100501 if (STAT_RECORD) {
502 int err, fd = perf_data_file__fd(&perf_stat.file);
503
Jiri Olsa664c98d2015-11-05 15:40:50 +0100504 if (is_pipe) {
505 err = perf_header__write_pipe(perf_data_file__fd(&perf_stat.file));
506 } else {
507 err = perf_session__write_header(perf_stat.session, evsel_list,
508 fd, false);
509 }
510
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100511 if (err < 0)
512 return err;
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100513
Jiri Olsa664c98d2015-11-05 15:40:50 +0100514 err = perf_stat_synthesize_config(is_pipe);
Jiri Olsa8b99b1a2015-11-05 15:40:48 +0100515 if (err < 0)
516 return err;
Jiri Olsa4979d0c2015-11-05 15:40:46 +0100517 }
518
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200519 /*
520 * Enable counters and exec the command:
521 */
522 t0 = rdclock();
Stephane Eranian13370a92013-01-29 12:47:44 +0100523 clock_gettime(CLOCK_MONOTONIC, &ref_time);
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200524
Liming Wang60666c62009-12-31 16:05:50 +0800525 if (forks) {
Namhyung Kimacf28922013-03-11 16:43:18 +0900526 perf_evlist__start_workload(evsel_list);
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100527 enable_counters();
Namhyung Kimacf28922013-03-11 16:43:18 +0900528
Stephane Eranian13370a92013-01-29 12:47:44 +0100529 if (interval) {
530 while (!waitpid(child_pid, &status, WNOHANG)) {
531 nanosleep(&ts, NULL);
Jiri Olsaba411a92015-06-26 11:29:24 +0200532 process_interval();
Stephane Eranian13370a92013-01-29 12:47:44 +0100533 }
534 }
Liming Wang60666c62009-12-31 16:05:50 +0800535 wait(&status);
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300536
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300537 if (workload_exec_errno) {
538 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
539 pr_err("Workload failed: %s\n", emsg);
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300540 return -1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300541 }
Arnaldo Carvalho de Melo6af206f2013-12-28 15:45:08 -0300542
Andi Kleen33e49ea2011-09-15 14:31:40 -0700543 if (WIFSIGNALED(status))
544 psignal(WTERMSIG(status), argv[0]);
Liming Wang60666c62009-12-31 16:05:50 +0800545 } else {
Jiri Olsa67ccdec2015-12-03 10:06:44 +0100546 enable_counters();
Stephane Eranian13370a92013-01-29 12:47:44 +0100547 while (!done) {
548 nanosleep(&ts, NULL);
549 if (interval)
Jiri Olsaba411a92015-06-26 11:29:24 +0200550 process_interval();
Stephane Eranian13370a92013-01-29 12:47:44 +0100551 }
Liming Wang60666c62009-12-31 16:05:50 +0800552 }
Ingo Molnar44db76c2009-06-03 19:36:07 +0200553
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200554 t1 = rdclock();
555
Peter Zijlstra9e9772c2009-09-04 15:36:08 +0200556 update_stats(&walltime_nsecs_stats, t1 - t0);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200557
Jiri Olsa106a94a2015-06-26 11:29:19 +0200558 read_counters(true);
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200559
Ingo Molnar42202dd2009-06-13 14:57:28 +0200560 return WEXITSTATUS(status);
561}
562
Arnaldo Carvalho de Melo41cde472014-01-03 17:34:42 -0300563static int run_perf_stat(int argc, const char **argv)
Peter Zijlstra1f16c572012-10-23 13:40:14 +0200564{
565 int ret;
566
567 if (pre_cmd) {
568 ret = system(pre_cmd);
569 if (ret)
570 return ret;
571 }
572
573 if (sync_run)
574 sync();
575
576 ret = __run_perf_stat(argc, argv);
577 if (ret)
578 return ret;
579
580 if (post_cmd) {
581 ret = system(post_cmd);
582 if (ret)
583 return ret;
584 }
585
586 return ret;
587}
588
Andi Kleend73515c2015-03-11 07:16:27 -0700589static void print_running(u64 run, u64 ena)
590{
591 if (csv_output) {
Jiri Olsa58215222015-07-21 14:31:24 +0200592 fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f",
Andi Kleend73515c2015-03-11 07:16:27 -0700593 csv_sep,
594 run,
595 csv_sep,
596 ena ? 100.0 * run / ena : 100.0);
597 } else if (run != ena) {
Jiri Olsa58215222015-07-21 14:31:24 +0200598 fprintf(stat_config.output, " (%.2f%%)", 100.0 * run / ena);
Andi Kleend73515c2015-03-11 07:16:27 -0700599 }
600}
601
Ingo Molnarf99844c2011-04-27 05:35:39 +0200602static void print_noise_pct(double total, double avg)
603{
Xiao Guangrong0007ece2012-09-17 16:31:14 +0800604 double pct = rel_stddev_stats(total, avg);
Ingo Molnarf99844c2011-04-27 05:35:39 +0200605
Zhengyu He3ae9a34d2011-06-23 13:45:42 -0700606 if (csv_output)
Jiri Olsa58215222015-07-21 14:31:24 +0200607 fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct);
Jim Cromiea1bca6c2011-09-07 17:14:02 -0600608 else if (pct)
Jiri Olsa58215222015-07-21 14:31:24 +0200609 fprintf(stat_config.output, " ( +-%6.2f%% )", pct);
Ingo Molnarf99844c2011-04-27 05:35:39 +0200610}
611
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200612static void print_noise(struct perf_evsel *evsel, double avg)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200613{
Jiri Olsa581cc8a2015-10-16 12:41:03 +0200614 struct perf_stat_evsel *ps;
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200615
Peter Zijlstra849abde2009-09-04 18:23:38 +0200616 if (run_count == 1)
617 return;
618
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200619 ps = evsel->priv;
Ingo Molnarf99844c2011-04-27 05:35:39 +0200620 print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200621}
622
Stephane Eranian12c08a92013-02-14 13:57:29 +0100623static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200624{
Jiri Olsa421a50f2015-07-21 14:31:22 +0200625 switch (stat_config.aggr_mode) {
Stephane Eranian12c08a92013-02-14 13:57:29 +0100626 case AGGR_CORE:
Jiri Olsa58215222015-07-21 14:31:24 +0200627 fprintf(stat_config.output, "S%d-C%*d%s%*d%s",
Stephane Eranian12c08a92013-02-14 13:57:29 +0100628 cpu_map__id_to_socket(id),
629 csv_output ? 0 : -8,
630 cpu_map__id_to_cpu(id),
631 csv_sep,
632 csv_output ? 0 : 4,
633 nr,
634 csv_sep);
635 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100636 case AGGR_SOCKET:
Jiri Olsa58215222015-07-21 14:31:24 +0200637 fprintf(stat_config.output, "S%*d%s%*d%s",
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100638 csv_output ? 0 : -5,
Stephane Eranian12c08a92013-02-14 13:57:29 +0100639 id,
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100640 csv_sep,
641 csv_output ? 0 : 4,
642 nr,
643 csv_sep);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100644 break;
645 case AGGR_NONE:
Jiri Olsa58215222015-07-21 14:31:24 +0200646 fprintf(stat_config.output, "CPU%*d%s",
Stephane Eraniand7470b62010-12-01 18:49:05 +0200647 csv_output ? 0 : -4,
Stephane Eranian12c08a92013-02-14 13:57:29 +0100648 perf_evsel__cpus(evsel)->map[id], csv_sep);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100649 break;
Jiri Olsa32b8af82015-06-26 11:29:27 +0200650 case AGGR_THREAD:
Jiri Olsa58215222015-07-21 14:31:24 +0200651 fprintf(stat_config.output, "%*s-%*d%s",
Jiri Olsa32b8af82015-06-26 11:29:27 +0200652 csv_output ? 0 : 16,
653 thread_map__comm(evsel->threads, id),
654 csv_output ? 0 : -8,
655 thread_map__pid(evsel->threads, id),
656 csv_sep);
657 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100658 case AGGR_GLOBAL:
Jiri Olsa208df992015-10-16 12:41:04 +0200659 case AGGR_UNSET:
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100660 default:
661 break;
662 }
663}
Stephane Eraniand7470b62010-12-01 18:49:05 +0200664
Andi Kleenda88c7f2014-09-24 13:50:46 -0700665static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100666{
Jiri Olsa58215222015-07-21 14:31:24 +0200667 FILE *output = stat_config.output;
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100668 double msecs = avg / 1e6;
Stephane Eranian410136f2013-11-12 17:58:49 +0100669 const char *fmt_v, *fmt_n;
David Ahern4bbe5a62013-09-28 14:28:00 -0600670 char name[25];
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100671
Stephane Eranian410136f2013-11-12 17:58:49 +0100672 fmt_v = csv_output ? "%.6f%s" : "%18.6f%s";
673 fmt_n = csv_output ? "%s" : "%-25s";
674
Andi Kleenda88c7f2014-09-24 13:50:46 -0700675 aggr_printout(evsel, id, nr);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100676
David Ahern4bbe5a62013-09-28 14:28:00 -0600677 scnprintf(name, sizeof(name), "%s%s",
678 perf_evsel__name(evsel), csv_output ? "" : " (msec)");
Stephane Eranian410136f2013-11-12 17:58:49 +0100679
680 fprintf(output, fmt_v, msecs, csv_sep);
681
682 if (csv_output)
683 fprintf(output, "%s%s", evsel->unit, csv_sep);
684 else
685 fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep);
686
687 fprintf(output, fmt_n, name);
Stephane Eraniand7470b62010-12-01 18:49:05 +0200688
Stephane Eranian023695d2011-02-14 11:20:01 +0200689 if (evsel->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200690 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200691}
692
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200693static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
694{
Jiri Olsa58215222015-07-21 14:31:24 +0200695 FILE *output = stat_config.output;
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200696 double sc = evsel->scale;
697 const char *fmt;
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200698
699 if (csv_output) {
700 fmt = sc != 1.0 ? "%.2f%s" : "%.0f%s";
701 } else {
702 if (big_num)
703 fmt = sc != 1.0 ? "%'18.2f%s" : "%'18.0f%s";
704 else
705 fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s";
706 }
707
708 aggr_printout(evsel, id, nr);
709
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200710 fprintf(output, fmt, avg, csv_sep);
711
712 if (evsel->unit)
713 fprintf(output, "%-*s%s",
714 csv_output ? 0 : unit_width,
715 evsel->unit, csv_sep);
716
717 fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel));
718
719 if (evsel->cgrp)
720 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
Andi Kleeneedfcb42015-11-02 17:50:21 -0800721}
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200722
Andi Kleeneedfcb42015-11-02 17:50:21 -0800723static void printout(int id, int nr, struct perf_evsel *counter, double uval)
724{
725 int cpu = cpu_map__id_to_cpu(id);
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200726
Andi Kleeneedfcb42015-11-02 17:50:21 -0800727 if (stat_config.aggr_mode == AGGR_GLOBAL)
728 cpu = 0;
729
730 if (nsec_counter(counter))
731 nsec_printout(id, nr, counter, uval);
732 else
733 abs_printout(id, nr, counter, uval);
734
735 if (!csv_output && !stat_config.interval)
736 perf_stat__print_shadow_stats(stat_config.output, counter,
737 uval, cpu,
738 stat_config.aggr_mode);
Jiri Olsa556b1fb2015-06-03 16:25:56 +0200739}
740
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100741static void print_aggr(char *prefix)
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100742{
Jiri Olsa58215222015-07-21 14:31:24 +0200743 FILE *output = stat_config.output;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100744 struct perf_evsel *counter;
Kan Liang601083c2015-07-02 03:08:43 -0400745 int cpu, s, s2, id, nr;
Stephane Eranian410136f2013-11-12 17:58:49 +0100746 double uval;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100747 u64 ena, run, val;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100748
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100749 if (!(aggr_map || aggr_get_id))
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100750 return;
751
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100752 for (s = 0; s < aggr_map->nr; s++) {
753 id = aggr_map->map[s];
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -0300754 evlist__for_each(evsel_list, counter) {
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100755 val = ena = run = 0;
756 nr = 0;
757 for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
Kan Liang601083c2015-07-02 03:08:43 -0400758 s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100759 if (s2 != id)
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100760 continue;
Jiri Olsaa6fa0032015-06-26 11:29:11 +0200761 val += perf_counts(counter->counts, cpu, 0)->val;
762 ena += perf_counts(counter->counts, cpu, 0)->ena;
763 run += perf_counts(counter->counts, cpu, 0)->run;
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100764 nr++;
765 }
766 if (prefix)
767 fprintf(output, "%s", prefix);
768
769 if (run == 0 || ena == 0) {
Stephane Eranian582ec0822013-07-05 19:06:45 +0200770 aggr_printout(counter, id, nr);
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100771
Stephane Eranian410136f2013-11-12 17:58:49 +0100772 fprintf(output, "%*s%s",
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100773 csv_output ? 0 : 18,
774 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
Stephane Eranian410136f2013-11-12 17:58:49 +0100775 csv_sep);
776
777 fprintf(output, "%-*s%s",
778 csv_output ? 0 : unit_width,
779 counter->unit, csv_sep);
780
781 fprintf(output, "%*s",
782 csv_output ? 0 : -25,
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100783 perf_evsel__name(counter));
Stephane Eranian86ee6e12013-02-14 13:57:27 +0100784
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100785 if (counter->cgrp)
786 fprintf(output, "%s%s",
787 csv_sep, counter->cgrp->name);
788
Andi Kleend73515c2015-03-11 07:16:27 -0700789 print_running(run, ena);
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100790 fputc('\n', output);
791 continue;
792 }
Stephane Eranian410136f2013-11-12 17:58:49 +0100793 uval = val * counter->scale;
Andi Kleeneedfcb42015-11-02 17:50:21 -0800794 printout(id, nr, counter, uval);
Andi Kleend73515c2015-03-11 07:16:27 -0700795 if (!csv_output)
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100796 print_noise(counter, 1.0);
797
Andi Kleend73515c2015-03-11 07:16:27 -0700798 print_running(run, ena);
Stephane Eraniand7e7a452013-02-06 15:46:02 +0100799 fputc('\n', output);
800 }
801 }
802}
803
Jiri Olsa32b8af82015-06-26 11:29:27 +0200804static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
805{
Jiri Olsa58215222015-07-21 14:31:24 +0200806 FILE *output = stat_config.output;
Jiri Olsa32b8af82015-06-26 11:29:27 +0200807 int nthreads = thread_map__nr(counter->threads);
808 int ncpus = cpu_map__nr(counter->cpus);
809 int cpu, thread;
810 double uval;
811
812 for (thread = 0; thread < nthreads; thread++) {
813 u64 ena = 0, run = 0, val = 0;
814
815 for (cpu = 0; cpu < ncpus; cpu++) {
816 val += perf_counts(counter->counts, cpu, thread)->val;
817 ena += perf_counts(counter->counts, cpu, thread)->ena;
818 run += perf_counts(counter->counts, cpu, thread)->run;
819 }
820
821 if (prefix)
822 fprintf(output, "%s", prefix);
823
824 uval = val * counter->scale;
Andi Kleeneedfcb42015-11-02 17:50:21 -0800825 printout(thread, 0, counter, uval);
Jiri Olsa32b8af82015-06-26 11:29:27 +0200826
827 if (!csv_output)
828 print_noise(counter, 1.0);
829
830 print_running(run, ena);
831 fputc('\n', output);
832 }
833}
834
Ingo Molnar42202dd2009-06-13 14:57:28 +0200835/*
836 * Print out the results of a single counter:
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200837 * aggregated counts in system-wide mode
Ingo Molnar42202dd2009-06-13 14:57:28 +0200838 */
Stephane Eranian13370a92013-01-29 12:47:44 +0100839static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200840{
Jiri Olsa58215222015-07-21 14:31:24 +0200841 FILE *output = stat_config.output;
Jiri Olsa581cc8a2015-10-16 12:41:03 +0200842 struct perf_stat_evsel *ps = counter->priv;
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200843 double avg = avg_stats(&ps->res_stats[0]);
Arnaldo Carvalho de Meloc52b12e2011-01-03 17:45:52 -0200844 int scaled = counter->counts->scaled;
Stephane Eranian410136f2013-11-12 17:58:49 +0100845 double uval;
Andi Kleend73515c2015-03-11 07:16:27 -0700846 double avg_enabled, avg_running;
847
848 avg_enabled = avg_stats(&ps->res_stats[1]);
849 avg_running = avg_stats(&ps->res_stats[2]);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200850
Stephane Eranian13370a92013-01-29 12:47:44 +0100851 if (prefix)
852 fprintf(output, "%s", prefix);
853
Suzuki K. Poulose3b4331d2015-02-13 18:40:58 +0000854 if (scaled == -1 || !counter->supported) {
Stephane Eranian410136f2013-11-12 17:58:49 +0100855 fprintf(output, "%*s%s",
Stephane Eraniand7470b62010-12-01 18:49:05 +0200856 csv_output ? 0 : 18,
David Ahern2cee77c2011-05-30 08:55:59 -0600857 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
Stephane Eranian410136f2013-11-12 17:58:49 +0100858 csv_sep);
859 fprintf(output, "%-*s%s",
860 csv_output ? 0 : unit_width,
861 counter->unit, csv_sep);
862 fprintf(output, "%*s",
863 csv_output ? 0 : -25,
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -0300864 perf_evsel__name(counter));
Stephane Eranian023695d2011-02-14 11:20:01 +0200865
866 if (counter->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200867 fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +0200868
Andi Kleend73515c2015-03-11 07:16:27 -0700869 print_running(avg_running, avg_enabled);
Stephane Eranian4aa90152011-08-15 22:22:33 +0200870 fputc('\n', output);
Ingo Molnar42202dd2009-06-13 14:57:28 +0200871 return;
872 }
873
Stephane Eranian410136f2013-11-12 17:58:49 +0100874 uval = avg * counter->scale;
Andi Kleeneedfcb42015-11-02 17:50:21 -0800875 printout(-1, 0, counter, uval);
Peter Zijlstra849abde2009-09-04 18:23:38 +0200876
Zhengyu He3ae9a34d2011-06-23 13:45:42 -0700877 print_noise(counter, avg);
878
Andi Kleend73515c2015-03-11 07:16:27 -0700879 print_running(avg_running, avg_enabled);
Stephane Eranian4aa90152011-08-15 22:22:33 +0200880 fprintf(output, "\n");
Ingo Molnar42202dd2009-06-13 14:57:28 +0200881}
882
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200883/*
884 * Print out the results of a single counter:
885 * does not use aggregated count in system-wide
886 */
Stephane Eranian13370a92013-01-29 12:47:44 +0100887static void print_counter(struct perf_evsel *counter, char *prefix)
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200888{
Jiri Olsa58215222015-07-21 14:31:24 +0200889 FILE *output = stat_config.output;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200890 u64 ena, run, val;
Stephane Eranian410136f2013-11-12 17:58:49 +0100891 double uval;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200892 int cpu;
893
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800894 for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
Jiri Olsaa6fa0032015-06-26 11:29:11 +0200895 val = perf_counts(counter->counts, cpu, 0)->val;
896 ena = perf_counts(counter->counts, cpu, 0)->ena;
897 run = perf_counts(counter->counts, cpu, 0)->run;
Stephane Eranian13370a92013-01-29 12:47:44 +0100898
899 if (prefix)
900 fprintf(output, "%s", prefix);
901
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200902 if (run == 0 || ena == 0) {
Stephane Eranian410136f2013-11-12 17:58:49 +0100903 fprintf(output, "CPU%*d%s%*s%s",
Stephane Eraniand7470b62010-12-01 18:49:05 +0200904 csv_output ? 0 : -4,
Yan, Zheng7ae92e72012-09-10 15:53:50 +0800905 perf_evsel__cpus(counter)->map[cpu], csv_sep,
Stephane Eraniand7470b62010-12-01 18:49:05 +0200906 csv_output ? 0 : 18,
David Ahern2cee77c2011-05-30 08:55:59 -0600907 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
Stephane Eranian410136f2013-11-12 17:58:49 +0100908 csv_sep);
909
910 fprintf(output, "%-*s%s",
911 csv_output ? 0 : unit_width,
912 counter->unit, csv_sep);
913
914 fprintf(output, "%*s",
915 csv_output ? 0 : -25,
916 perf_evsel__name(counter));
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200917
Stephane Eranian023695d2011-02-14 11:20:01 +0200918 if (counter->cgrp)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200919 fprintf(output, "%s%s",
920 csv_sep, counter->cgrp->name);
Stephane Eranian023695d2011-02-14 11:20:01 +0200921
Andi Kleend73515c2015-03-11 07:16:27 -0700922 print_running(run, ena);
Stephane Eranian4aa90152011-08-15 22:22:33 +0200923 fputc('\n', output);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200924 continue;
925 }
926
Stephane Eranian410136f2013-11-12 17:58:49 +0100927 uval = val * counter->scale;
Andi Kleeneedfcb42015-11-02 17:50:21 -0800928 printout(cpu, 0, counter, uval);
Andi Kleend73515c2015-03-11 07:16:27 -0700929 if (!csv_output)
Stephane Eraniand7470b62010-12-01 18:49:05 +0200930 print_noise(counter, 1.0);
Andi Kleend73515c2015-03-11 07:16:27 -0700931 print_running(run, ena);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200932
Stephane Eranian4aa90152011-08-15 22:22:33 +0200933 fputc('\n', output);
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +0200934 }
935}
936
Jiri Olsad4f63a42015-06-26 11:29:26 +0200937static void print_interval(char *prefix, struct timespec *ts)
Ingo Molnar42202dd2009-06-13 14:57:28 +0200938{
Jiri Olsa58215222015-07-21 14:31:24 +0200939 FILE *output = stat_config.output;
Jiri Olsad4f63a42015-06-26 11:29:26 +0200940 static int num_print_interval;
941
942 sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);
943
944 if (num_print_interval == 0 && !csv_output) {
Jiri Olsa421a50f2015-07-21 14:31:22 +0200945 switch (stat_config.aggr_mode) {
Jiri Olsad4f63a42015-06-26 11:29:26 +0200946 case AGGR_SOCKET:
947 fprintf(output, "# time socket cpus counts %*s events\n", unit_width, "unit");
948 break;
949 case AGGR_CORE:
950 fprintf(output, "# time core cpus counts %*s events\n", unit_width, "unit");
951 break;
952 case AGGR_NONE:
953 fprintf(output, "# time CPU counts %*s events\n", unit_width, "unit");
954 break;
Jiri Olsa32b8af82015-06-26 11:29:27 +0200955 case AGGR_THREAD:
956 fprintf(output, "# time comm-pid counts %*s events\n", unit_width, "unit");
957 break;
Jiri Olsad4f63a42015-06-26 11:29:26 +0200958 case AGGR_GLOBAL:
959 default:
960 fprintf(output, "# time counts %*s events\n", unit_width, "unit");
Jiri Olsa208df992015-10-16 12:41:04 +0200961 case AGGR_UNSET:
962 break;
Jiri Olsad4f63a42015-06-26 11:29:26 +0200963 }
964 }
965
966 if (++num_print_interval == 25)
967 num_print_interval = 0;
968}
969
970static void print_header(int argc, const char **argv)
971{
Jiri Olsa58215222015-07-21 14:31:24 +0200972 FILE *output = stat_config.output;
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -0200973 int i;
Ingo Molnar42202dd2009-06-13 14:57:28 +0200974
Ingo Molnarddcacfa2009-04-20 15:37:32 +0200975 fflush(stdout);
976
Stephane Eraniand7470b62010-12-01 18:49:05 +0200977 if (!csv_output) {
Stephane Eranian4aa90152011-08-15 22:22:33 +0200978 fprintf(output, "\n");
979 fprintf(output, " Performance counter stats for ");
David Ahern62d3b612013-09-28 14:27:58 -0600980 if (target.system_wide)
981 fprintf(output, "\'system wide");
982 else if (target.cpu_list)
983 fprintf(output, "\'CPU(s) %s", target.cpu_list);
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -0300984 else if (!target__has_task(&target)) {
Stephane Eranian4aa90152011-08-15 22:22:33 +0200985 fprintf(output, "\'%s", argv[0]);
Stephane Eraniand7470b62010-12-01 18:49:05 +0200986 for (i = 1; i < argc; i++)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200987 fprintf(output, " %s", argv[i]);
Namhyung Kim20f946b2012-04-26 14:15:16 +0900988 } else if (target.pid)
989 fprintf(output, "process id \'%s", target.pid);
Stephane Eraniand7470b62010-12-01 18:49:05 +0200990 else
Namhyung Kim20f946b2012-04-26 14:15:16 +0900991 fprintf(output, "thread id \'%s", target.tid);
Ingo Molnar44db76c2009-06-03 19:36:07 +0200992
Stephane Eranian4aa90152011-08-15 22:22:33 +0200993 fprintf(output, "\'");
Stephane Eraniand7470b62010-12-01 18:49:05 +0200994 if (run_count > 1)
Stephane Eranian4aa90152011-08-15 22:22:33 +0200995 fprintf(output, " (%d runs)", run_count);
996 fprintf(output, ":\n\n");
Stephane Eraniand7470b62010-12-01 18:49:05 +0200997 }
Jiri Olsad4f63a42015-06-26 11:29:26 +0200998}
999
1000static void print_footer(void)
1001{
Jiri Olsa58215222015-07-21 14:31:24 +02001002 FILE *output = stat_config.output;
1003
Jiri Olsad4f63a42015-06-26 11:29:26 +02001004 if (!null_run)
1005 fprintf(output, "\n");
1006 fprintf(output, " %17.9f seconds time elapsed",
1007 avg_stats(&walltime_nsecs_stats)/1e9);
1008 if (run_count > 1) {
1009 fprintf(output, " ");
1010 print_noise_pct(stddev_stats(&walltime_nsecs_stats),
1011 avg_stats(&walltime_nsecs_stats));
1012 }
1013 fprintf(output, "\n\n");
1014}
1015
1016static void print_counters(struct timespec *ts, int argc, const char **argv)
1017{
Jiri Olsaec0d3d12015-07-21 14:31:25 +02001018 int interval = stat_config.interval;
Jiri Olsad4f63a42015-06-26 11:29:26 +02001019 struct perf_evsel *counter;
1020 char buf[64], *prefix = NULL;
1021
Jiri Olsa664c98d2015-11-05 15:40:50 +01001022 /* Do not print anything if we record to the pipe. */
1023 if (STAT_RECORD && perf_stat.file.is_pipe)
1024 return;
1025
Jiri Olsad4f63a42015-06-26 11:29:26 +02001026 if (interval)
1027 print_interval(prefix = buf, ts);
1028 else
1029 print_header(argc, argv);
Ingo Molnar2996f5d2009-05-29 09:10:54 +02001030
Jiri Olsa421a50f2015-07-21 14:31:22 +02001031 switch (stat_config.aggr_mode) {
Stephane Eranian12c08a92013-02-14 13:57:29 +01001032 case AGGR_CORE:
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001033 case AGGR_SOCKET:
Jiri Olsad4f63a42015-06-26 11:29:26 +02001034 print_aggr(prefix);
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001035 break;
Jiri Olsa32b8af82015-06-26 11:29:27 +02001036 case AGGR_THREAD:
1037 evlist__for_each(evsel_list, counter)
1038 print_aggr_thread(counter, prefix);
1039 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001040 case AGGR_GLOBAL:
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001041 evlist__for_each(evsel_list, counter)
Jiri Olsad4f63a42015-06-26 11:29:26 +02001042 print_counter_aggr(counter, prefix);
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001043 break;
1044 case AGGR_NONE:
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001045 evlist__for_each(evsel_list, counter)
Jiri Olsad4f63a42015-06-26 11:29:26 +02001046 print_counter(counter, prefix);
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001047 break;
Jiri Olsa208df992015-10-16 12:41:04 +02001048 case AGGR_UNSET:
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001049 default:
1050 break;
Stephane Eranianf5b4a9c32010-11-16 11:05:01 +02001051 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001052
Jiri Olsad4f63a42015-06-26 11:29:26 +02001053 if (!interval && !csv_output)
1054 print_footer();
1055
Jiri Olsa58215222015-07-21 14:31:24 +02001056 fflush(stat_config.output);
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001057}
1058
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001059static volatile int signr = -1;
1060
Ingo Molnar52425192009-05-26 09:17:18 +02001061static void skip_signal(int signo)
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001062{
Jiri Olsaec0d3d12015-07-21 14:31:25 +02001063 if ((child_pid == -1) || stat_config.interval)
Liming Wang60666c62009-12-31 16:05:50 +08001064 done = 1;
1065
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001066 signr = signo;
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001067 /*
1068 * render child_pid harmless
1069 * won't send SIGTERM to a random
1070 * process in case of race condition
1071 * and fast PID recycling
1072 */
1073 child_pid = -1;
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001074}
1075
1076static void sig_atexit(void)
1077{
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001078 sigset_t set, oset;
1079
1080 /*
1081 * avoid race condition with SIGCHLD handler
1082 * in skip_signal() which is modifying child_pid
1083 * goal is to avoid send SIGTERM to a random
1084 * process
1085 */
1086 sigemptyset(&set);
1087 sigaddset(&set, SIGCHLD);
1088 sigprocmask(SIG_BLOCK, &set, &oset);
1089
Chris Wilson933da832009-10-04 01:35:01 +01001090 if (child_pid != -1)
1091 kill(child_pid, SIGTERM);
1092
Stephane Eraniand07f0b12013-06-04 17:44:26 +02001093 sigprocmask(SIG_SETMASK, &oset, NULL);
1094
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001095 if (signr == -1)
1096 return;
1097
1098 signal(signr, SIG_DFL);
1099 kill(getpid(), signr);
Ingo Molnar52425192009-05-26 09:17:18 +02001100}
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001101
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001102static int stat__set_big_num(const struct option *opt __maybe_unused,
1103 const char *s __maybe_unused, int unset)
Stephane Eraniand7470b62010-12-01 18:49:05 +02001104{
1105 big_num_opt = unset ? 0 : 1;
1106 return 0;
1107}
1108
Jiri Olsae0547312015-11-05 15:40:45 +01001109static const struct option stat_options[] = {
1110 OPT_BOOLEAN('T', "transaction", &transaction_run,
1111 "hardware transaction statistics"),
1112 OPT_CALLBACK('e', "event", &evsel_list, "event",
1113 "event selector. use 'perf list' to list available events",
1114 parse_events_option),
1115 OPT_CALLBACK(0, "filter", &evsel_list, "filter",
1116 "event filter", parse_filter),
1117 OPT_BOOLEAN('i', "no-inherit", &no_inherit,
1118 "child tasks do not inherit counters"),
1119 OPT_STRING('p', "pid", &target.pid, "pid",
1120 "stat events on existing process id"),
1121 OPT_STRING('t', "tid", &target.tid, "tid",
1122 "stat events on existing thread id"),
1123 OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
1124 "system-wide collection from all CPUs"),
1125 OPT_BOOLEAN('g', "group", &group,
1126 "put the counters into a counter group"),
1127 OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"),
1128 OPT_INCR('v', "verbose", &verbose,
1129 "be more verbose (show counter open errors, etc)"),
1130 OPT_INTEGER('r', "repeat", &run_count,
1131 "repeat command and print average + stddev (max: 100, forever: 0)"),
1132 OPT_BOOLEAN('n', "null", &null_run,
1133 "null run - dont start any counters"),
1134 OPT_INCR('d', "detailed", &detailed_run,
1135 "detailed run - start a lot of events"),
1136 OPT_BOOLEAN('S', "sync", &sync_run,
1137 "call sync() before starting a run"),
1138 OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
1139 "print large numbers with thousands\' separators",
1140 stat__set_big_num),
1141 OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
1142 "list of cpus to monitor in system-wide"),
1143 OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
1144 "disable CPU count aggregation", AGGR_NONE),
1145 OPT_STRING('x', "field-separator", &csv_sep, "separator",
1146 "print counts with custom separator"),
1147 OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1148 "monitor event in cgroup name only", parse_cgroups),
1149 OPT_STRING('o', "output", &output_name, "file", "output file name"),
1150 OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
1151 OPT_INTEGER(0, "log-fd", &output_fd,
1152 "log output to fd, instead of stderr"),
1153 OPT_STRING(0, "pre", &pre_cmd, "command",
1154 "command to run prior to the measured command"),
1155 OPT_STRING(0, "post", &post_cmd, "command",
1156 "command to run after to the measured command"),
1157 OPT_UINTEGER('I', "interval-print", &stat_config.interval,
1158 "print counts at regular interval in ms (>= 10)"),
1159 OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode,
1160 "aggregate counts per processor socket", AGGR_SOCKET),
1161 OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode,
1162 "aggregate counts per physical processor core", AGGR_CORE),
1163 OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
1164 "aggregate counts per thread", AGGR_THREAD),
1165 OPT_UINTEGER('D', "delay", &initial_delay,
1166 "ms to wait before starting measurement after program start"),
1167 OPT_END()
1168};
1169
Jiri Olsa1fe7a302015-10-16 12:41:15 +02001170static int perf_stat__get_socket(struct cpu_map *map, int cpu)
1171{
1172 return cpu_map__get_socket(map, cpu, NULL);
1173}
1174
1175static int perf_stat__get_core(struct cpu_map *map, int cpu)
1176{
1177 return cpu_map__get_core(map, cpu, NULL);
1178}
1179
Jiri Olsa1e5a2932015-10-25 15:51:18 +01001180static int cpu_map__get_max(struct cpu_map *map)
1181{
1182 int i, max = -1;
1183
1184 for (i = 0; i < map->nr; i++) {
1185 if (map->map[i] > max)
1186 max = map->map[i];
1187 }
1188
1189 return max;
1190}
1191
1192static struct cpu_map *cpus_aggr_map;
1193
1194static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx)
1195{
1196 int cpu;
1197
1198 if (idx >= map->nr)
1199 return -1;
1200
1201 cpu = map->map[idx];
1202
1203 if (cpus_aggr_map->map[cpu] == -1)
1204 cpus_aggr_map->map[cpu] = get_id(map, idx);
1205
1206 return cpus_aggr_map->map[cpu];
1207}
1208
1209static int perf_stat__get_socket_cached(struct cpu_map *map, int idx)
1210{
1211 return perf_stat__get_aggr(perf_stat__get_socket, map, idx);
1212}
1213
1214static int perf_stat__get_core_cached(struct cpu_map *map, int idx)
1215{
1216 return perf_stat__get_aggr(perf_stat__get_core, map, idx);
1217}
1218
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001219static int perf_stat_init_aggr_mode(void)
1220{
Jiri Olsa1e5a2932015-10-25 15:51:18 +01001221 int nr;
1222
Jiri Olsa421a50f2015-07-21 14:31:22 +02001223 switch (stat_config.aggr_mode) {
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001224 case AGGR_SOCKET:
1225 if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
1226 perror("cannot build socket map");
1227 return -1;
1228 }
Jiri Olsa1e5a2932015-10-25 15:51:18 +01001229 aggr_get_id = perf_stat__get_socket_cached;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001230 break;
Stephane Eranian12c08a92013-02-14 13:57:29 +01001231 case AGGR_CORE:
1232 if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
1233 perror("cannot build core map");
1234 return -1;
1235 }
Jiri Olsa1e5a2932015-10-25 15:51:18 +01001236 aggr_get_id = perf_stat__get_core_cached;
Stephane Eranian12c08a92013-02-14 13:57:29 +01001237 break;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001238 case AGGR_NONE:
1239 case AGGR_GLOBAL:
Jiri Olsa32b8af82015-06-26 11:29:27 +02001240 case AGGR_THREAD:
Jiri Olsa208df992015-10-16 12:41:04 +02001241 case AGGR_UNSET:
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001242 default:
1243 break;
1244 }
Jiri Olsa1e5a2932015-10-25 15:51:18 +01001245
1246 /*
1247 * The evsel_list->cpus is the base we operate on,
1248 * taking the highest cpu number to be the size of
1249 * the aggregation translate cpumap.
1250 */
1251 nr = cpu_map__get_max(evsel_list->cpus);
1252 cpus_aggr_map = cpu_map__empty_new(nr + 1);
1253 return cpus_aggr_map ? 0 : -ENOMEM;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001254}
1255
Masami Hiramatsu544c2ae2015-12-09 11:11:27 +09001256static void perf_stat__exit_aggr_mode(void)
1257{
1258 cpu_map__put(aggr_map);
1259 cpu_map__put(cpus_aggr_map);
1260 aggr_map = NULL;
1261 cpus_aggr_map = NULL;
1262}
1263
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001264/*
1265 * Add default attributes, if there were no attributes specified or
1266 * if -d/--detailed, -d -d or -d -d -d is used:
1267 */
1268static int add_default_attributes(void)
1269{
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001270 struct perf_event_attr default_attrs[] = {
1271
1272 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK },
1273 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES },
1274 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS },
1275 { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS },
1276
1277 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES },
1278 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND },
1279 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND },
1280 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS },
1281 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS },
1282 { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES },
1283
1284};
1285
1286/*
1287 * Detailed stats (-d), covering the L1 and last level data caches:
1288 */
1289 struct perf_event_attr detailed_attrs[] = {
1290
1291 { .type = PERF_TYPE_HW_CACHE,
1292 .config =
1293 PERF_COUNT_HW_CACHE_L1D << 0 |
1294 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1295 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1296
1297 { .type = PERF_TYPE_HW_CACHE,
1298 .config =
1299 PERF_COUNT_HW_CACHE_L1D << 0 |
1300 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1301 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1302
1303 { .type = PERF_TYPE_HW_CACHE,
1304 .config =
1305 PERF_COUNT_HW_CACHE_LL << 0 |
1306 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1307 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1308
1309 { .type = PERF_TYPE_HW_CACHE,
1310 .config =
1311 PERF_COUNT_HW_CACHE_LL << 0 |
1312 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1313 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1314};
1315
1316/*
1317 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1318 */
1319 struct perf_event_attr very_detailed_attrs[] = {
1320
1321 { .type = PERF_TYPE_HW_CACHE,
1322 .config =
1323 PERF_COUNT_HW_CACHE_L1I << 0 |
1324 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1325 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1326
1327 { .type = PERF_TYPE_HW_CACHE,
1328 .config =
1329 PERF_COUNT_HW_CACHE_L1I << 0 |
1330 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1331 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1332
1333 { .type = PERF_TYPE_HW_CACHE,
1334 .config =
1335 PERF_COUNT_HW_CACHE_DTLB << 0 |
1336 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1337 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1338
1339 { .type = PERF_TYPE_HW_CACHE,
1340 .config =
1341 PERF_COUNT_HW_CACHE_DTLB << 0 |
1342 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1343 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1344
1345 { .type = PERF_TYPE_HW_CACHE,
1346 .config =
1347 PERF_COUNT_HW_CACHE_ITLB << 0 |
1348 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1349 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1350
1351 { .type = PERF_TYPE_HW_CACHE,
1352 .config =
1353 PERF_COUNT_HW_CACHE_ITLB << 0 |
1354 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1355 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1356
1357};
1358
1359/*
1360 * Very, very detailed stats (-d -d -d), adding prefetch events:
1361 */
1362 struct perf_event_attr very_very_detailed_attrs[] = {
1363
1364 { .type = PERF_TYPE_HW_CACHE,
1365 .config =
1366 PERF_COUNT_HW_CACHE_L1D << 0 |
1367 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) |
1368 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) },
1369
1370 { .type = PERF_TYPE_HW_CACHE,
1371 .config =
1372 PERF_COUNT_HW_CACHE_L1D << 0 |
1373 (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) |
1374 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) },
1375};
1376
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001377 /* Set attrs if no event is selected and !null_run: */
1378 if (null_run)
1379 return 0;
1380
Andi Kleen4cabc3d2013-08-21 16:47:26 -07001381 if (transaction_run) {
1382 int err;
1383 if (pmu_have_event("cpu", "cycles-ct") &&
1384 pmu_have_event("cpu", "el-start"))
Jiri Olsaa4547422015-06-03 16:25:53 +02001385 err = parse_events(evsel_list, transaction_attrs, NULL);
Andi Kleen4cabc3d2013-08-21 16:47:26 -07001386 else
Jiri Olsaa4547422015-06-03 16:25:53 +02001387 err = parse_events(evsel_list, transaction_limited_attrs, NULL);
1388 if (err) {
Andi Kleen4cabc3d2013-08-21 16:47:26 -07001389 fprintf(stderr, "Cannot set up transaction events\n");
1390 return -1;
1391 }
1392 return 0;
1393 }
1394
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001395 if (!evsel_list->nr_entries) {
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001396 if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001397 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001398 }
1399
1400 /* Detailed events get appended to the event list: */
1401
1402 if (detailed_run < 1)
1403 return 0;
1404
1405 /* Append detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001406 if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001407 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001408
1409 if (detailed_run < 2)
1410 return 0;
1411
1412 /* Append very detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001413 if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
Arnaldo Carvalho de Melo50d08e42011-11-04 09:10:59 -02001414 return -1;
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001415
1416 if (detailed_run < 3)
1417 return 0;
1418
1419 /* Append very, very detailed run extra attributes: */
Arnaldo Carvalho de Melo79695e12012-05-30 13:53:54 -03001420 return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001421}
1422
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001423static const char * const recort_usage[] = {
1424 "perf stat record [<options>]",
1425 NULL,
1426};
1427
Jiri Olsa3ba78bd2015-11-05 15:40:47 +01001428static void init_features(struct perf_session *session)
1429{
1430 int feat;
1431
1432 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
1433 perf_header__set_feat(&session->header, feat);
1434
1435 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
1436 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
1437 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
1438 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
1439}
1440
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001441static int __cmd_record(int argc, const char **argv)
1442{
1443 struct perf_session *session;
1444 struct perf_data_file *file = &perf_stat.file;
1445
1446 argc = parse_options(argc, argv, stat_options, record_usage,
1447 PARSE_OPT_STOP_AT_NON_OPTION);
1448
1449 if (output_name)
1450 file->path = output_name;
1451
1452 session = perf_session__new(file, false, NULL);
1453 if (session == NULL) {
1454 pr_err("Perf session creation failed.\n");
1455 return -1;
1456 }
1457
Jiri Olsa3ba78bd2015-11-05 15:40:47 +01001458 init_features(session);
1459
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001460 session->evlist = evsel_list;
1461 perf_stat.session = session;
1462 perf_stat.record = true;
1463 return argc;
1464}
1465
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001466int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
Ingo Molnar52425192009-05-26 09:17:18 +02001467{
Arnaldo Carvalho de Melob070a542012-10-01 15:20:58 -03001468 const char * const stat_usage[] = {
1469 "perf stat [<options>] [<command>]",
1470 NULL
1471 };
Namhyung Kimcc03c542013-11-01 16:33:15 +09001472 int status = -EINVAL, run_idx;
Stephane Eranian4aa90152011-08-15 22:22:33 +02001473 const char *mode;
Jiri Olsa58215222015-07-21 14:31:24 +02001474 FILE *output = stderr;
Jiri Olsaec0d3d12015-07-21 14:31:25 +02001475 unsigned int interval;
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001476 const char * const stat_subcommands[] = { "record" };
Ingo Molnar42202dd2009-06-13 14:57:28 +02001477
Stephane Eranian5af52b52010-05-18 15:00:01 +02001478 setlocale(LC_ALL, "");
1479
Namhyung Kim334fe7a2013-03-11 16:43:12 +09001480 evsel_list = perf_evlist__new();
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001481 if (evsel_list == NULL)
1482 return -ENOMEM;
1483
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001484 argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
1485 (const char **) stat_usage,
1486 PARSE_OPT_STOP_AT_NON_OPTION);
1487
1488 if (argc && !strncmp(argv[0], "rec", 3)) {
1489 argc = __cmd_record(argc, argv);
1490 if (argc < 0)
1491 return -1;
1492 }
Stephane Eraniand7470b62010-12-01 18:49:05 +02001493
Jiri Olsaec0d3d12015-07-21 14:31:25 +02001494 interval = stat_config.interval;
1495
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001496 /*
1497 * For record command the -o is already taken care of.
1498 */
1499 if (!STAT_RECORD && output_name && strcmp(output_name, "-"))
Stephane Eranian4aa90152011-08-15 22:22:33 +02001500 output = NULL;
1501
Jim Cromie56f3bae2011-09-07 17:14:00 -06001502 if (output_name && output_fd) {
1503 fprintf(stderr, "cannot use both --output and --log-fd\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001504 parse_options_usage(stat_usage, stat_options, "o", 1);
1505 parse_options_usage(NULL, stat_options, "log-fd", 0);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001506 goto out;
Jim Cromie56f3bae2011-09-07 17:14:00 -06001507 }
Stephane Eranianfc3e4d02012-05-15 13:11:11 +02001508
1509 if (output_fd < 0) {
1510 fprintf(stderr, "argument to --log-fd must be a > 0\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001511 parse_options_usage(stat_usage, stat_options, "log-fd", 0);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001512 goto out;
Stephane Eranianfc3e4d02012-05-15 13:11:11 +02001513 }
1514
Stephane Eranian4aa90152011-08-15 22:22:33 +02001515 if (!output) {
1516 struct timespec tm;
1517 mode = append_file ? "a" : "w";
1518
1519 output = fopen(output_name, mode);
1520 if (!output) {
1521 perror("failed to create output file");
David Ahernfceda7f2012-08-26 12:24:44 -06001522 return -1;
Stephane Eranian4aa90152011-08-15 22:22:33 +02001523 }
1524 clock_gettime(CLOCK_REALTIME, &tm);
1525 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
Stephane Eranianfc3e4d02012-05-15 13:11:11 +02001526 } else if (output_fd > 0) {
Jim Cromie56f3bae2011-09-07 17:14:00 -06001527 mode = append_file ? "a" : "w";
1528 output = fdopen(output_fd, mode);
1529 if (!output) {
1530 perror("Failed opening logfd");
1531 return -errno;
1532 }
Stephane Eranian4aa90152011-08-15 22:22:33 +02001533 }
1534
Jiri Olsa58215222015-07-21 14:31:24 +02001535 stat_config.output = output;
1536
Jim Cromied4ffd042011-09-07 17:14:03 -06001537 if (csv_sep) {
Stephane Eraniand7470b62010-12-01 18:49:05 +02001538 csv_output = true;
Jim Cromied4ffd042011-09-07 17:14:03 -06001539 if (!strcmp(csv_sep, "\\t"))
1540 csv_sep = "\t";
1541 } else
Stephane Eraniand7470b62010-12-01 18:49:05 +02001542 csv_sep = DEFAULT_SEPARATOR;
1543
1544 /*
1545 * let the spreadsheet do the pretty-printing
1546 */
1547 if (csv_output) {
Jim Cromie61a9f322011-09-07 17:14:04 -06001548 /* User explicitly passed -B? */
Stephane Eraniand7470b62010-12-01 18:49:05 +02001549 if (big_num_opt == 1) {
1550 fprintf(stderr, "-B option not supported with -x\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001551 parse_options_usage(stat_usage, stat_options, "B", 1);
1552 parse_options_usage(NULL, stat_options, "x", 1);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001553 goto out;
Stephane Eraniand7470b62010-12-01 18:49:05 +02001554 } else /* Nope, so disable big number formatting */
1555 big_num = false;
1556 } else if (big_num_opt == 0) /* User passed --no-big-num */
1557 big_num = false;
1558
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001559 if (!argc && target__none(&target))
Jiri Olsae0547312015-11-05 15:40:45 +01001560 usage_with_options(stat_usage, stat_options);
David Ahernac3063b2013-09-30 07:37:37 -06001561
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001562 if (run_count < 0) {
Namhyung Kimcc03c542013-11-01 16:33:15 +09001563 pr_err("Run count must be a positive number\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001564 parse_options_usage(stat_usage, stat_options, "r", 1);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001565 goto out;
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001566 } else if (run_count == 0) {
1567 forever = true;
1568 run_count = 1;
1569 }
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001570
Jiri Olsa421a50f2015-07-21 14:31:22 +02001571 if ((stat_config.aggr_mode == AGGR_THREAD) && !target__has_task(&target)) {
Jiri Olsa32b8af82015-06-26 11:29:27 +02001572 fprintf(stderr, "The --per-thread option is only available "
1573 "when monitoring via -p -t options.\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001574 parse_options_usage(NULL, stat_options, "p", 1);
1575 parse_options_usage(NULL, stat_options, "t", 1);
Jiri Olsa32b8af82015-06-26 11:29:27 +02001576 goto out;
1577 }
1578
1579 /*
1580 * no_aggr, cgroup are for system-wide only
1581 * --per-thread is aggregated per thread, we dont mix it with cpu mode
1582 */
Jiri Olsa421a50f2015-07-21 14:31:22 +02001583 if (((stat_config.aggr_mode != AGGR_GLOBAL &&
1584 stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) &&
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001585 !target__has_cpu(&target)) {
Stephane Eranian023695d2011-02-14 11:20:01 +02001586 fprintf(stderr, "both cgroup and no-aggregation "
1587 "modes only available in system-wide mode\n");
1588
Jiri Olsae0547312015-11-05 15:40:45 +01001589 parse_options_usage(stat_usage, stat_options, "G", 1);
1590 parse_options_usage(NULL, stat_options, "A", 1);
1591 parse_options_usage(NULL, stat_options, "a", 1);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001592 goto out;
Stephane Eraniand7e7a452013-02-06 15:46:02 +01001593 }
1594
Ingo Molnar2cba3ff2011-05-19 13:30:56 +02001595 if (add_default_attributes())
1596 goto out;
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001597
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001598 target__validate(&target);
Arnaldo Carvalho de Melo5c98d4662011-01-03 17:53:33 -02001599
Namhyung Kim77a6f012012-05-07 14:09:04 +09001600 if (perf_evlist__create_maps(evsel_list, &target) < 0) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001601 if (target__has_task(&target)) {
Namhyung Kim77a6f012012-05-07 14:09:04 +09001602 pr_err("Problems finding threads of monitor\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001603 parse_options_usage(stat_usage, stat_options, "p", 1);
1604 parse_options_usage(NULL, stat_options, "t", 1);
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001605 } else if (target__has_cpu(&target)) {
Namhyung Kim77a6f012012-05-07 14:09:04 +09001606 perror("failed to parse CPUs map");
Jiri Olsae0547312015-11-05 15:40:45 +01001607 parse_options_usage(stat_usage, stat_options, "C", 1);
1608 parse_options_usage(NULL, stat_options, "a", 1);
Namhyung Kimcc03c542013-11-01 16:33:15 +09001609 }
1610 goto out;
Arnaldo Carvalho de Melo60d567e2011-01-03 17:49:48 -02001611 }
Jiri Olsa32b8af82015-06-26 11:29:27 +02001612
1613 /*
1614 * Initialize thread_map with comm names,
1615 * so we could print it out on output.
1616 */
Jiri Olsa421a50f2015-07-21 14:31:22 +02001617 if (stat_config.aggr_mode == AGGR_THREAD)
Jiri Olsa32b8af82015-06-26 11:29:27 +02001618 thread_map__read_comms(evsel_list->threads);
1619
Stephane Eranian13370a92013-01-29 12:47:44 +01001620 if (interval && interval < 100) {
Kan Liang19afd102015-10-02 05:04:34 -04001621 if (interval < 10) {
1622 pr_err("print interval must be >= 10ms\n");
Jiri Olsae0547312015-11-05 15:40:45 +01001623 parse_options_usage(stat_usage, stat_options, "I", 1);
Kan Liang19afd102015-10-02 05:04:34 -04001624 goto out;
1625 } else
1626 pr_warning("print interval < 100ms. "
1627 "The overhead percentage could be high in some cases. "
1628 "Please proceed with caution.\n");
Stephane Eranian13370a92013-01-29 12:47:44 +01001629 }
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001630
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001631 if (perf_evlist__alloc_stats(evsel_list, interval))
Arnaldo Carvalho de Melo03ad9742014-01-03 15:56:06 -03001632 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001633
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001634 if (perf_stat_init_aggr_mode())
Arnaldo Carvalho de Melo03ad9742014-01-03 15:56:06 -03001635 goto out;
Stephane Eranian86ee6e12013-02-14 13:57:27 +01001636
Ingo Molnar58d7e992009-05-15 11:03:23 +02001637 /*
1638 * We dont want to block the signals - that would cause
1639 * child tasks to inherit that and Ctrl-C would not work.
1640 * What we want is for Ctrl-C to work in the exec()-ed
1641 * task, but being ignored by perf stat itself:
1642 */
Peter Zijlstraf7b7c262009-06-10 15:55:59 +02001643 atexit(sig_atexit);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001644 if (!forever)
1645 signal(SIGINT, skip_signal);
Stephane Eranian13370a92013-01-29 12:47:44 +01001646 signal(SIGCHLD, skip_signal);
Ingo Molnar58d7e992009-05-15 11:03:23 +02001647 signal(SIGALRM, skip_signal);
1648 signal(SIGABRT, skip_signal);
1649
Ingo Molnar42202dd2009-06-13 14:57:28 +02001650 status = 0;
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001651 for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
Ingo Molnar42202dd2009-06-13 14:57:28 +02001652 if (run_count != 1 && verbose)
Stephane Eranian4aa90152011-08-15 22:22:33 +02001653 fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1654 run_idx + 1);
Ingo Molnarf9cef0a2011-04-28 18:17:11 +02001655
Ingo Molnar42202dd2009-06-13 14:57:28 +02001656 status = run_perf_stat(argc, argv);
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001657 if (forever && status != -1) {
Jiri Olsad4f63a42015-06-26 11:29:26 +02001658 print_counters(NULL, argc, argv);
Jiri Olsa254ecbc2015-06-26 11:29:13 +02001659 perf_stat__reset_stats();
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001660 }
Ingo Molnar42202dd2009-06-13 14:57:28 +02001661 }
1662
Frederik Deweerdta7e191c2013-03-01 13:02:27 -05001663 if (!forever && status != -1 && !interval)
Jiri Olsad4f63a42015-06-26 11:29:26 +02001664 print_counters(NULL, argc, argv);
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001665
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001666 if (STAT_RECORD) {
1667 /*
1668 * We synthesize the kernel mmap record just so that older tools
1669 * don't emit warnings about not being able to resolve symbols
1670 * due to /proc/sys/kernel/kptr_restrict settings and instear provide
1671 * a saner message about no samples being in the perf.data file.
1672 *
1673 * This also serves to suppress a warning about f_header.data.size == 0
Jiri Olsa8b99b1a2015-11-05 15:40:48 +01001674 * in header.c at the moment 'perf stat record' gets introduced, which
1675 * is not really needed once we start adding the stat specific PERF_RECORD_
1676 * records, but the need to suppress the kptr_restrict messages in older
1677 * tools remain -acme
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001678 */
1679 int fd = perf_data_file__fd(&perf_stat.file);
1680 int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat,
1681 process_synthesized_event,
1682 &perf_stat.session->machines.host);
1683 if (err) {
1684 pr_warning("Couldn't synthesize the kernel mmap record, harmless, "
1685 "older tools may produce warnings about this file\n.");
1686 }
1687
Jiri Olsa7aad0c32015-11-05 15:40:52 +01001688 if (!interval) {
1689 if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL))
1690 pr_err("failed to write stat round event\n");
1691 }
1692
Jiri Olsa664c98d2015-11-05 15:40:50 +01001693 if (!perf_stat.file.is_pipe) {
1694 perf_stat.session->header.data_size += perf_stat.bytes_written;
1695 perf_session__write_header(perf_stat.session, evsel_list, fd, true);
1696 }
Jiri Olsa4979d0c2015-11-05 15:40:46 +01001697
1698 perf_session__delete(perf_stat.session);
1699 }
1700
Masami Hiramatsu544c2ae2015-12-09 11:11:27 +09001701 perf_stat__exit_aggr_mode();
Arnaldo Carvalho de Melod134ffb2013-03-18 11:24:21 -03001702 perf_evlist__free_stats(evsel_list);
Arnaldo Carvalho de Melo0015e2e2011-02-01 16:18:10 -02001703out:
1704 perf_evlist__delete(evsel_list);
Ingo Molnar42202dd2009-06-13 14:57:28 +02001705 return status;
Ingo Molnarddcacfa2009-04-20 15:37:32 +02001706}