builtin-stat.c 75 KB
Newer Older
1
/*
2 3 4 5 6 7
 * builtin-stat.c
 *
 * Builtin stat command: Give a precise performance counters summary
 * overview about any workload, CPU or specific PID.
 *
 * Sample output:
8

9
   $ perf stat ./hackbench 10
10

11
  Time: 0.118
12

13
  Performance counter stats for './hackbench 10':
14

15 16 17 18 19 20 21 22 23 24 25 26 27
       1708.761321 task-clock                #   11.037 CPUs utilized
            41,190 context-switches          #    0.024 M/sec
             6,735 CPU-migrations            #    0.004 M/sec
            17,318 page-faults               #    0.010 M/sec
     5,205,202,243 cycles                    #    3.046 GHz
     3,856,436,920 stalled-cycles-frontend   #   74.09% frontend cycles idle
     1,600,790,871 stalled-cycles-backend    #   30.75% backend  cycles idle
     2,603,501,247 instructions              #    0.50  insns per cycle
                                             #    1.48  stalled cycles per insn
       484,357,498 branches                  #  283.455 M/sec
         6,388,934 branch-misses             #    1.32% of all branches

        0.154822978  seconds time elapsed
28

29
 *
30
 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
31 32 33 34 35 36 37 38
 *
 * Improvements and fixes by:
 *
 *   Arjan van de Ven <arjan@linux.intel.com>
 *   Yanmin Zhang <yanmin.zhang@intel.com>
 *   Wu Fengguang <fengguang.wu@intel.com>
 *   Mike Galbraith <efault@gmx.de>
 *   Paul Mackerras <paulus@samba.org>
39
 *   Jaswinder Singh Rajput <jaswinder@kernel.org>
40 41
 *
 * Released under the GPL v2. (and only v2, not any later version)
42 43
 */

44
#include "perf.h"
45
#include "builtin.h"
46
#include "util/cgroup.h"
47
#include "util/util.h"
48
#include <subcmd/parse-options.h>
49
#include "util/parse-events.h"
50
#include "util/pmu.h"
51
#include "util/event.h"
52
#include "util/evlist.h"
53
#include "util/evsel.h"
54
#include "util/debug.h"
55
#include "util/drv_configs.h"
56
#include "util/color.h"
57
#include "util/stat.h"
58
#include "util/header.h"
59
#include "util/cpumap.h"
60
#include "util/thread.h"
61
#include "util/thread_map.h"
62
#include "util/counts.h"
63
#include "util/group.h"
64
#include "util/session.h"
65
#include "util/tool.h"
66
#include "util/string2.h"
67
#include "util/metricgroup.h"
68
#include "util/top.h"
69
#include "asm/bug.h"
70

71
#include <linux/time64.h>
72
#include <api/fs/fs.h>
73
#include <errno.h>
74
#include <signal.h>
75
#include <stdlib.h>
76
#include <sys/prctl.h>
77
#include <inttypes.h>
78
#include <locale.h>
79
#include <math.h>
80 81
#include <sys/types.h>
#include <sys/stat.h>
82
#include <sys/wait.h>
83
#include <unistd.h>
84 85 86
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/wait.h>
87

88 89
#include "sane_ctype.h"

90
#define DEFAULT_SEPARATOR	" "
91 92
#define CNTR_NOT_SUPPORTED	"<not supported>"
#define CNTR_NOT_COUNTED	"<not counted>"
93
#define FREEZE_ON_SMI_PATH	"devices/cpu/freeze_on_smi"
94

95
static void print_counters(struct timespec *ts, int argc, const char **argv);
96

97
/* Default events used for perf stat -T */
98 99
static const char *transaction_attrs = {
	"task-clock,"
100 101 102 103 104 105 106 107 108 109 110
	"{"
	"instructions,"
	"cycles,"
	"cpu/cycles-t/,"
	"cpu/tx-start/,"
	"cpu/el-start/,"
	"cpu/cycles-ct/"
	"}"
};

/* More limited version when the CPU does not have all events. */
111 112
static const char * transaction_limited_attrs = {
	"task-clock,"
113 114 115 116 117 118 119 120
	"{"
	"instructions,"
	"cycles,"
	"cpu/cycles-t/,"
	"cpu/tx-start/"
	"}"
};

121 122 123 124 125 126 127 128 129
static const char * topdown_attrs[] = {
	"topdown-total-slots",
	"topdown-slots-retired",
	"topdown-recovery-bubbles",
	"topdown-fetch-bubbles",
	"topdown-slots-issued",
	NULL,
};

130 131 132 133 134 135 136 137
static const char *smi_cost_attrs = {
	"{"
	"msr/aperf/,"
	"msr/smi/,"
	"cycles"
	"}"
};

138
static struct perf_evlist	*evsel_list;
139

140 141
static struct rblist		 metric_events;

142
static struct target target = {
143 144
	.uid	= UINT_MAX,
};
145

146 147
typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);

148 149
#define METRIC_ONLY_LEN 20

150
static int			run_count			=  1;
151
static volatile pid_t		child_pid			= -1;
152
static bool			null_run			=  false;
153
static int			detailed_run			=  0;
154
static bool			transaction_run;
155
static bool			topdown_run			= false;
156 157
static bool			smi_cost			= false;
static bool			smi_reset			= false;
158
static bool			big_num				=  true;
159 160 161
static int			big_num_opt			=  -1;
static const char		*csv_sep			= NULL;
static bool			csv_output			= false;
162
static bool			group				= false;
163 164 165
static const char		*pre_cmd			= NULL;
static const char		*post_cmd			= NULL;
static bool			sync_run			= false;
166
static unsigned int		unit_width			= 4; /* strlen("unit") */
167
static bool			forever				= false;
168
static bool			metric_only			= false;
169
static bool			force_metric_only		= false;
170
static bool			no_merge			= false;
171
static bool			walltime_run_table		= false;
172
static struct timespec		ref_time;
173
static struct cpu_map		*aggr_map;
174
static aggr_get_id_t		aggr_get_id;
175
static bool			append_file;
176
static bool			interval_count;
177
static bool			interval_clear;
178 179
static const char		*output_name;
static int			output_fd;
180
static int			print_free_counters_hint;
181
static int			print_mixed_hw_group_error;
182
static u64			*walltime_run;
183 184
static bool			ru_display			= false;
static struct rusage		ru_data;
185
static unsigned int		metric_only_len			= METRIC_ONLY_LEN;
186

187 188
struct perf_stat {
	bool			 record;
189
	struct perf_data	 data;
190 191
	struct perf_session	*session;
	u64			 bytes_written;
192
	struct perf_tool	 tool;
193 194 195
	bool			 maps_allocated;
	struct cpu_map		*cpus;
	struct thread_map	*threads;
196
	enum aggr_mode		 aggr_mode;
197 198 199 200 201
};

static struct perf_stat		perf_stat;
#define STAT_RECORD		perf_stat.record

202 203
static volatile int done = 0;

204 205
static struct perf_stat_config stat_config = {
	.aggr_mode	= AGGR_GLOBAL,
206
	.scale		= true,
207 208
};

209 210 211 212 213
static bool is_duration_time(struct perf_evsel *evsel)
{
	return !strcmp(evsel->name, "duration_time");
}

214 215 216 217 218
static inline void diff_timespec(struct timespec *r, struct timespec *a,
				 struct timespec *b)
{
	r->tv_sec = a->tv_sec - b->tv_sec;
	if (a->tv_nsec < b->tv_nsec) {
219
		r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec;
220 221 222 223 224 225
		r->tv_sec--;
	} else {
		r->tv_nsec = a->tv_nsec - b->tv_nsec ;
	}
}

226 227
static void perf_stat__reset_stats(void)
{
228 229
	int i;

230
	perf_evlist__reset_stats(evsel_list);
231
	perf_stat__reset_shadow_stats();
232 233 234

	for (i = 0; i < stat_config.stats_num; i++)
		perf_stat__reset_shadow_per_stat(&stat_config.stats[i]);
235 236
}

237 238 239 240
static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
				     union perf_event *event,
				     struct perf_sample *sample __maybe_unused,
				     struct machine *machine __maybe_unused)
241
{
242
	if (perf_data__write(&perf_stat.data, event, event->header.size) < 0) {
243 244 245 246
		pr_err("failed to write perf data, error: %m\n");
		return -1;
	}

247
	perf_stat.bytes_written += event->header.size;
248 249 250
	return 0;
}

251
static int write_stat_round_event(u64 tm, u64 type)
252
{
253
	return perf_event__synthesize_stat_round(NULL, tm, type,
254 255 256 257 258 259 260
						 process_synthesized_event,
						 NULL);
}

#define WRITE_STAT_ROUND_EVENT(time, interval) \
	write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval)

261 262 263 264 265 266 267 268 269 270 271 272
#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)

static int
perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread,
			     struct perf_counts_values *count)
{
	struct perf_sample_id *sid = SID(counter, cpu, thread);

	return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count,
					   process_synthesized_event, NULL);
}

273 274 275 276
/*
 * Read out the results of a single counter:
 * do not aggregate counts across CPUs in system-wide mode
 */
277
static int read_counter(struct perf_evsel *counter)
278
{
279
	int nthreads = thread_map__nr(evsel_list->threads);
280 281
	int ncpus, cpu, thread;

282
	if (target__has_cpu(&target) && !target__has_per_thread(&target))
283 284 285
		ncpus = perf_evsel__nr_cpus(counter);
	else
		ncpus = 1;
286

287 288 289
	if (!counter->supported)
		return -ENOENT;

290 291 292 293 294
	if (counter->system_wide)
		nthreads = 1;

	for (thread = 0; thread < nthreads; thread++) {
		for (cpu = 0; cpu < ncpus; cpu++) {
295 296 297
			struct perf_counts_values *count;

			count = perf_counts(counter->counts, cpu, thread);
298 299 300 301 302 303 304

			/*
			 * The leader's group read loads data into its group members
			 * (via perf_evsel__read_counter) and sets threir count->loaded.
			 */
			if (!count->loaded &&
			    perf_evsel__read_counter(counter, cpu, thread)) {
305 306 307
				counter->counts->scaled = -1;
				perf_counts(counter->counts, cpu, thread)->ena = 0;
				perf_counts(counter->counts, cpu, thread)->run = 0;
308
				return -1;
309
			}
310

311 312
			count->loaded = false;

313 314 315 316 317 318
			if (STAT_RECORD) {
				if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
					pr_err("failed to write stat event\n");
					return -1;
				}
			}
319 320 321 322 323 324 325 326

			if (verbose > 1) {
				fprintf(stat_config.output,
					"%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
						perf_evsel__name(counter),
						cpu,
						count->val, count->ena, count->run);
			}
327
		}
328
	}
329 330

	return 0;
331 332
}

333
static void read_counters(void)
334 335
{
	struct perf_evsel *counter;
336
	int ret;
337

338
	evlist__for_each_entry(evsel_list, counter) {
339 340
		ret = read_counter(counter);
		if (ret)
341
			pr_debug("failed to read counter %s\n", counter->name);
342

343
		if (ret == 0 && perf_stat_process_counter(&stat_config, counter))
344
			pr_warning("failed to process counter %s\n", counter->name);
345
	}
346 347
}

348
static void process_interval(void)
349 350 351
{
	struct timespec ts, rs;

352
	read_counters();
353

354 355 356
	clock_gettime(CLOCK_MONOTONIC, &ts);
	diff_timespec(&rs, &ts, &ref_time);

357
	if (STAT_RECORD) {
358
		if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL))
359 360 361
			pr_err("failed to write stat round event\n");
	}

362 363
	init_stats(&walltime_nsecs_stats);
	update_stats(&walltime_nsecs_stats, stat_config.interval * 1000000);
364
	print_counters(&rs, 0, NULL);
365 366
}

367
static void enable_counters(void)
368
{
369 370
	if (stat_config.initial_delay)
		usleep(stat_config.initial_delay * USEC_PER_MSEC);
371 372 373 374 375 376

	/*
	 * We need to enable counters only if:
	 * - we don't have tracee (attaching to task or cpu)
	 * - we have initial delay configured
	 */
377
	if (!target__none(&target) || stat_config.initial_delay)
378
		perf_evlist__enable(evsel_list);
379 380
}

381 382 383 384 385 386 387 388 389 390 391
static void disable_counters(void)
{
	/*
	 * If we don't have tracee (attaching to task or cpu), counters may
	 * still be running. To get accurate group ratios, we must stop groups
	 * from counting before reading their constituent counters.
	 */
	if (!target__none(&target))
		perf_evlist__disable(evsel_list);
}

392
static volatile int workload_exec_errno;
393 394 395 396 397 398

/*
 * perf_evlist__prepare_workload will send a SIGUSR1
 * if the fork fails, since we asked by setting its
 * want_signal to true.
 */
399 400
static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info,
					void *ucontext __maybe_unused)
401
{
402
	workload_exec_errno = info->si_value.sival_int;
403 404
}

405
static int perf_stat_synthesize_config(struct perf_stat_config *config,
406
				       struct perf_tool *tool,
407
				       bool attrs)
408 409 410
{
	int err;

411
	if (attrs) {
412
		err = perf_event__synthesize_attrs(tool, evsel_list,
413 414 415 416 417 418 419
						   process_synthesized_event);
		if (err < 0) {
			pr_err("Couldn't synthesize attrs.\n");
			return err;
		}
	}

420
	err = perf_event__synthesize_extra_attr(tool,
421 422
						evsel_list,
						process_synthesized_event,
423
						attrs);
424

425
	err = perf_event__synthesize_thread_map2(tool, evsel_list->threads,
426 427 428 429 430 431 432
						process_synthesized_event,
						NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize thread map.\n");
		return err;
	}

433
	err = perf_event__synthesize_cpu_map(tool, evsel_list->cpus,
434 435 436 437 438 439
					     process_synthesized_event, NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize thread map.\n");
		return err;
	}

440
	err = perf_event__synthesize_stat_config(tool, config,
441 442 443 444 445 446 447 448 449
						 process_synthesized_event, NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize config.\n");
		return err;
	}

	return 0;
}

450 451 452 453 454
static bool perf_evsel__should_store_id(struct perf_evsel *counter)
{
	return STAT_RECORD || counter->attr.read_format & PERF_FORMAT_ID;
}

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
static struct perf_evsel *perf_evsel__reset_weak_group(struct perf_evsel *evsel)
{
	struct perf_evsel *c2, *leader;
	bool is_open = true;

	leader = evsel->leader;
	pr_debug("Weak group for %s/%d failed\n",
			leader->name, leader->nr_members);

	/*
	 * for_each_group_member doesn't work here because it doesn't
	 * include the first entry.
	 */
	evlist__for_each_entry(evsel_list, c2) {
		if (c2 == evsel)
			is_open = false;
		if (c2->leader == leader) {
			if (is_open)
				perf_evsel__close(c2);
			c2->leader = c2;
			c2->nr_members = 0;
		}
	}
	return leader;
}

481
static int __run_perf_stat(int argc, const char **argv, int run_idx)
482
{
483
	int interval = stat_config.interval;
484
	int times = stat_config.times;
485
	int timeout = stat_config.timeout;
486
	char msg[BUFSIZ];
487
	unsigned long long t0, t1;
488
	struct perf_evsel *counter;
489
	struct timespec ts;
490
	size_t l;
491
	int status = 0;
492
	const bool forks = (argc > 0);
493
	bool is_pipe = STAT_RECORD ? perf_stat.data.is_pipe : false;
494
	struct perf_evsel_config_term *err_term;
495

496
	if (interval) {
497 498
		ts.tv_sec  = interval / USEC_PER_MSEC;
		ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC;
499 500 501
	} else if (timeout) {
		ts.tv_sec  = timeout / USEC_PER_MSEC;
		ts.tv_nsec = (timeout % USEC_PER_MSEC) * NSEC_PER_MSEC;
502 503 504 505 506
	} else {
		ts.tv_sec  = 1;
		ts.tv_nsec = 0;
	}

507
	if (forks) {
508
		if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe,
509
						  workload_exec_failed_signal) < 0) {
510 511
			perror("failed to prepare workload");
			return -1;
512
		}
513
		child_pid = evsel_list->workload.pid;
514 515
	}

516
	if (group)
517
		perf_evlist__set_leader(evsel_list);
518

519
	evlist__for_each_entry(evsel_list, counter) {
520
try_again:
521
		if (create_perf_stat_counter(counter, &stat_config, &target) < 0) {
522 523

			/* Weak group failed. Reset the group. */
524
			if ((errno == EINVAL || errno == EBADF) &&
525 526 527 528 529 530
			    counter->leader != counter &&
			    counter->weak_group) {
				counter = perf_evsel__reset_weak_group(counter);
				goto try_again;
			}

531 532 533 534
			/*
			 * PPC returns ENXIO for HW counters until 2.6.37
			 * (behavior changed with commit b0a873e).
			 */
535
			if (errno == EINVAL || errno == ENOSYS ||
536 537
			    errno == ENOENT || errno == EOPNOTSUPP ||
			    errno == ENXIO) {
538
				if (verbose > 0)
539
					ui__warning("%s event is not supported by the kernel.\n",
540
						    perf_evsel__name(counter));
541
				counter->supported = false;
542 543 544 545

				if ((counter->leader != counter) ||
				    !(counter->leader->nr_members > 1))
					continue;
546
			} else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
547
                                if (verbose > 0)
548 549
                                        ui__warning("%s\n", msg);
                                goto try_again;
550 551 552 553 554 555 556 557 558 559 560 561 562
			} else if (target__has_per_thread(&target) &&
				   evsel_list->threads &&
				   evsel_list->threads->err_thread != -1) {
				/*
				 * For global --per-thread case, skip current
				 * error thread.
				 */
				if (!thread_map__remove(evsel_list->threads,
							evsel_list->threads->err_thread)) {
					evsel_list->threads->err_thread = -1;
					goto try_again;
				}
			}
563

564 565 566 567
			perf_evsel__open_strerror(counter, &target,
						  errno, msg, sizeof(msg));
			ui__error("%s\n", msg);

568 569
			if (child_pid != -1)
				kill(child_pid, SIGTERM);
570

571 572
			return -1;
		}
573
		counter->supported = true;
574 575 576 577

		l = strlen(counter->unit);
		if (l > unit_width)
			unit_width = l;
578

579
		if (perf_evsel__should_store_id(counter) &&
580
		    perf_evsel__store_ids(counter, evsel_list))
581
			return -1;
582
	}
583

584
	if (perf_evlist__apply_filters(evsel_list, &counter)) {
585
		pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
586
			counter->filter, perf_evsel__name(counter), errno,
587
			str_error_r(errno, msg, sizeof(msg)));
588 589 590
		return -1;
	}

591
	if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) {
592
		pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
593 594 595 596 597
		      err_term->val.drv_cfg, perf_evsel__name(counter), errno,
		      str_error_r(errno, msg, sizeof(msg)));
		return -1;
	}

598
	if (STAT_RECORD) {
599
		int err, fd = perf_data__fd(&perf_stat.data);
600

601
		if (is_pipe) {
602
			err = perf_header__write_pipe(perf_data__fd(&perf_stat.data));
603 604 605 606 607
		} else {
			err = perf_session__write_header(perf_stat.session, evsel_list,
							 fd, false);
		}

608 609
		if (err < 0)
			return err;
610

611
		err = perf_stat_synthesize_config(&stat_config, NULL, is_pipe);
612 613
		if (err < 0)
			return err;
614 615
	}

616 617 618 619
	/*
	 * Enable counters and exec the command:
	 */
	t0 = rdclock();
620
	clock_gettime(CLOCK_MONOTONIC, &ref_time);
621

622
	if (forks) {
623
		perf_evlist__start_workload(evsel_list);
624
		enable_counters();
625

626
		if (interval || timeout) {
627 628
			while (!waitpid(child_pid, &status, WNOHANG)) {
				nanosleep(&ts, NULL);
629 630
				if (timeout)
					break;
631
				process_interval();
632 633
				if (interval_count && !(--times))
					break;
634 635
			}
		}
636
		wait4(child_pid, &status, 0, &ru_data);
637

638
		if (workload_exec_errno) {
639
			const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
640
			pr_err("Workload failed: %s\n", emsg);
641
			return -1;
642
		}
643

644 645
		if (WIFSIGNALED(status))
			psignal(WTERMSIG(status), argv[0]);
646
	} else {
647
		enable_counters();
648 649
		while (!done) {
			nanosleep(&ts, NULL);
650 651
			if (timeout)
				break;
652
			if (interval) {
653
				process_interval();
654 655 656
				if (interval_count && !(--times))
					break;
			}
657
		}
658
	}
659

660 661
	disable_counters();

662 663
	t1 = rdclock();

664 665 666
	if (walltime_run_table)
		walltime_run[run_idx] = t1 - t0;

667
	update_stats(&walltime_nsecs_stats, t1 - t0);
668

669 670 671 672 673 674 675 676
	/*
	 * Closing a group leader splits the group, and as we only disable
	 * group leaders, results in remaining events becoming enabled. To
	 * avoid arbitrary skew, we must read all counters before closing any
	 * group leaders.
	 */
	read_counters();
	perf_evlist__close(evsel_list);
677

678 679 680
	return WEXITSTATUS(status);
}

681
static int run_perf_stat(int argc, const char **argv, int run_idx)
682 683 684 685 686 687 688 689 690 691 692 693
{
	int ret;

	if (pre_cmd) {
		ret = system(pre_cmd);
		if (ret)
			return ret;
	}

	if (sync_run)
		sync();

694
	ret = __run_perf_stat(argc, argv, run_idx);
695 696 697 698 699 700 701 702 703 704 705 706
	if (ret)
		return ret;

	if (post_cmd) {
		ret = system(post_cmd);
		if (ret)
			return ret;
	}

	return ret;
}

707 708 709
static void print_running(u64 run, u64 ena)
{
	if (csv_output) {
710
		fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f",
711 712 713 714 715
					csv_sep,
					run,
					csv_sep,
					ena ? 100.0 * run / ena : 100.0);
	} else if (run != ena) {
716
		fprintf(stat_config.output, "  (%.2f%%)", 100.0 * run / ena);
717 718 719
	}
}

720 721
static void print_noise_pct(double total, double avg)
{
722
	double pct = rel_stddev_stats(total, avg);
723

724
	if (csv_output)
725
		fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct);
726
	else if (pct)
727
		fprintf(stat_config.output, "  ( +-%6.2f%% )", pct);
728 729
}

730
static void print_noise(struct perf_evsel *evsel, double avg)
731
{
732
	struct perf_stat_evsel *ps;
733

734 735 736
	if (run_count == 1)
		return;

737
	ps = evsel->stats;
738
	print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
739 740
}

741
static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
Ingo Molnar's avatar
Ingo Molnar committed
742
{
743
	switch (stat_config.aggr_mode) {
744
	case AGGR_CORE:
745
		fprintf(stat_config.output, "S%d-C%*d%s%*d%s",
746 747 748 749 750 751 752 753
			cpu_map__id_to_socket(id),
			csv_output ? 0 : -8,
			cpu_map__id_to_cpu(id),
			csv_sep,
			csv_output ? 0 : 4,
			nr,
			csv_sep);
		break;
754
	case AGGR_SOCKET:
755
		fprintf(stat_config.output, "S%*d%s%*d%s",
756
			csv_output ? 0 : -5,
757
			id,
758 759 760 761
			csv_sep,
			csv_output ? 0 : 4,
			nr,
			csv_sep);
762 763
			break;
	case AGGR_NONE:
764
		fprintf(stat_config.output, "CPU%*d%s",
765
			csv_output ? 0 : -4,
766
			perf_evsel__cpus(evsel)->map[id], csv_sep);
767
		break;
768
	case AGGR_THREAD:
769
		fprintf(stat_config.output, "%*s-%*d%s",
770 771 772 773 774 775
			csv_output ? 0 : 16,
			thread_map__comm(evsel->threads, id),
			csv_output ? 0 : -8,
			thread_map__pid(evsel->threads, id),
			csv_sep);
		break;
776
	case AGGR_GLOBAL:
Jiri Olsa's avatar
Jiri Olsa committed
777
	case AGGR_UNSET:
778 779 780 781 782
	default:
		break;
	}
}

783 784 785
struct outstate {
	FILE *fh;
	bool newline;
786
	const char *prefix;
787
	int  nfields;
788 789
	int  id, nr;
	struct perf_evsel *evsel;
790 791 792 793 794 795 796 797 798 799 800 801 802 803
};

#define METRIC_LEN  35

static void new_line_std(void *ctx)
{
	struct outstate *os = ctx;

	os->newline = true;
}

static void do_new_line_std(struct outstate *os)
{
	fputc('\n', os->fh);
804
	fputs(os->prefix, os->fh);
805
	aggr_printout(os->evsel, os->id, os->nr);
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
	if (stat_config.aggr_mode == AGGR_NONE)
		fprintf(os->fh, "        ");
	fprintf(os->fh, "                                                 ");
}

static void print_metric_std(void *ctx, const char *color, const char *fmt,
			     const char *unit, double val)
{
	struct outstate *os = ctx;
	FILE *out = os->fh;
	int n;
	bool newline = os->newline;

	os->newline = false;

	if (unit == NULL || fmt == NULL) {
		fprintf(out, "%-*s", METRIC_LEN, "");
		return;
	}

	if (newline)
		do_new_line_std(os);

	n = fprintf(out, " # ");
	if (color)
		n += color_fprintf(out, color, fmt, val);
	else
		n += fprintf(out, fmt, val);
	fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
}

837 838 839 840 841 842 843 844
static void new_line_csv(void *ctx)
{
	struct outstate *os = ctx;
	int i;

	fputc('\n', os->fh);
	if (os->prefix)
		fprintf(os->fh, "%s%s", os->prefix, csv_sep);
845
	aggr_printout(os->evsel, os->id, os->nr);
846 847 848 849 850 851 852 853 854 855 856 857 858
	for (i = 0; i < os->nfields; i++)
		fputs(csv_sep, os->fh);
}

static void print_metric_csv(void *ctx,
			     const char *color __maybe_unused,
			     const char *fmt, const char *unit, double val)
{
	struct outstate *os = ctx;
	FILE *out = os->fh;
	char buf[64], *vals, *ends;

	if (unit == NULL || fmt == NULL) {
859
		fprintf(out, "%s%s", csv_sep, csv_sep);
860 861 862
		return;
	}
	snprintf(buf, sizeof(buf), fmt, val);
863
	ends = vals = ltrim(buf);
864 865 866 867 868 869 870 871
	while (isdigit(*ends) || *ends == '.')
		ends++;
	*ends = 0;
	while (isspace(*unit))
		unit++;
	fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit);
}

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
/* Filter out some columns that don't work well in metrics only mode */

static bool valid_only_metric(const char *unit)
{
	if (!unit)
		return false;
	if (strstr(unit, "/sec") ||
	    strstr(unit, "hz") ||
	    strstr(unit, "Hz") ||
	    strstr(unit, "CPUs utilized"))
		return false;
	return true;
}

static const char *fixunit(char *buf, struct perf_evsel *evsel,
			   const char *unit)
{
	if (!strncmp(unit, "of all", 6)) {
		snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
			 unit);
		return buf;
	}
	return unit;
}

static void print_metric_only(void *ctx, const char *color, const char *fmt,
			      const char *unit, double val)
{
	struct outstate *os = ctx;
	FILE *out = os->fh;
902
	char buf[1024], str[1024];
903
	unsigned mlen = metric_only_len;
904 905 906 907 908 909

	if (!valid_only_metric(unit))
		return;
	unit = fixunit(buf, os->evsel, unit);
	if (mlen < strlen(unit))
		mlen = strlen(unit) + 1;
910 911 912 913 914 915

	if (color)
		mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;

	color_snprintf(str, sizeof(str), color ?: "", fmt, val);
	fprintf(out, "%*s ", mlen, str);
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
}

static void print_metric_only_csv(void *ctx, const char *color __maybe_unused,
				  const char *fmt,
				  const char *unit, double val)
{
	struct outstate *os = ctx;
	FILE *out = os->fh;
	char buf[64], *vals, *ends;
	char tbuf[1024];

	if (!valid_only_metric(unit))
		return;
	unit = fixunit(tbuf, os->evsel, unit);
	snprintf(buf, sizeof buf, fmt, val);
931
	ends = vals = ltrim(buf);
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
	while (isdigit(*ends) || *ends == '.')
		ends++;
	*ends = 0;
	fprintf(out, "%s%s", vals, csv_sep);
}

static void new_line_metric(void *ctx __maybe_unused)
{
}

static void print_metric_header(void *ctx, const char *color __maybe_unused,
				const char *fmt __maybe_unused,
				const char *unit, double val __maybe_unused)
{
	struct outstate *os = ctx;
	char tbuf[1024];

	if (!valid_only_metric(unit))
		return;
	unit = fixunit(tbuf, os->evsel, unit);
	if (csv_output)
		fprintf(os->fh, "%s%s", unit, csv_sep);
	else
955
		fprintf(os->fh, "%*s ", metric_only_len, unit);
956 957
}

958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
static int first_shadow_cpu(struct perf_evsel *evsel, int id)
{
	int i;

	if (!aggr_get_id)
		return 0;

	if (stat_config.aggr_mode == AGGR_NONE)
		return id;

	if (stat_config.aggr_mode == AGGR_GLOBAL)
		return 0;

	for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
		int cpu2 = perf_evsel__cpus(evsel)->map[i];

		if (aggr_get_id(evsel_list->cpus, cpu2) == id)
			return cpu2;
	}
	return 0;
}

980 981
static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
{
982
	FILE *output = stat_config.output;
983 984 985 986
	double sc =  evsel->scale;
	const char *fmt;

	if (csv_output) {
987
		fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
988 989
	} else {
		if (big_num)
990
			fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
991
		else
992
			fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
	}

	aggr_printout(evsel, id, nr);

	fprintf(output, fmt, avg, csv_sep);

	if (evsel->unit)
		fprintf(output, "%-*s%s",
			csv_output ? 0 : unit_width,
			evsel->unit, csv_sep);

	fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel));

	if (evsel->cgrp)
		fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
1008
}
1009

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
static bool is_mixed_hw_group(struct perf_evsel *counter)
{
	struct perf_evlist *evlist = counter->evlist;
	u32 pmu_type = counter->attr.type;
	struct perf_evsel *pos;

	if (counter->nr_members < 2)
		return false;

	evlist__for_each_entry(evlist, pos) {
		/* software events can be part of any hardware group */
		if (pos->attr.type == PERF_TYPE_SOFTWARE)
			continue;
		if (pmu_type == PERF_TYPE_SOFTWARE) {
			pmu_type = pos->attr.type;
			continue;
		}
		if (pmu_type != pos->attr.type)
			return true;
	}

	return false;
}

1034
static void printout(int id, int nr, struct perf_evsel *counter, double uval,
1035 1036
		     char *prefix, u64 run, u64 ena, double noise,
		     struct runtime_stat *st)
1037
{
1038
	struct perf_stat_output_ctx out;
1039 1040
	struct outstate os = {
		.fh = stat_config.output,
1041 1042 1043 1044
		.prefix = prefix ? prefix : "",
		.id = id,
		.nr = nr,
		.evsel = counter,
1045
	};
1046 1047
	print_metric_t pm = print_metric_std;
	void (*nl)(void *);
1048

1049 1050 1051 1052 1053 1054 1055 1056
	if (metric_only) {
		nl = new_line_metric;
		if (csv_output)
			pm = print_metric_only_csv;
		else
			pm = print_metric_only;
	} else
		nl = new_line_std;
1057

1058
	if (csv_output && !metric_only) {
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
		static int aggr_fields[] = {
			[AGGR_GLOBAL] = 0,
			[AGGR_THREAD] = 1,
			[AGGR_NONE] = 1,
			[AGGR_SOCKET] = 2,
			[AGGR_CORE] = 2,
		};

		pm = print_metric_csv;
		nl = new_line_csv;
		os.nfields = 3;
		os.nfields += aggr_fields[stat_config.aggr_mode];
		if (counter->cgrp)
			os.nfields++;
	}
1074
	if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
1075 1076 1077 1078
		if (metric_only) {
			pm(&os, NULL, "", "", 0);
			return;
		}
1079 1080 1081 1082 1083 1084 1085
		aggr_printout(counter, id, nr);

		fprintf(stat_config.output, "%*s%s",
			csv_output ? 0 : 18,
			counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
			csv_sep);

1086
		if (counter->supported) {
1087
			print_free_counters_hint = 1;
1088 1089 1090
			if (is_mixed_hw_group(counter))
				print_mixed_hw_group_error = 1;
		}
1091

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
		fprintf(stat_config.output, "%-*s%s",
			csv_output ? 0 : unit_width,
			counter->unit, csv_sep);

		fprintf(stat_config.output, "%*s",
			csv_output ? 0 : -25,
			perf_evsel__name(counter));

		if (counter->cgrp)
			fprintf(stat_config.output, "%s%s",
				csv_sep, counter->cgrp->name);

1104 1105 1106
		if (!csv_output)
			pm(&os, NULL, NULL, "", 0);
		print_noise(counter, noise);
1107
		print_running(run, ena);
1108 1109
		if (csv_output)
			pm(&os, NULL, NULL, "", 0);
1110 1111 1112
		return;
	}

1113
	if (!metric_only)
1114
		abs_printout(id, nr, counter, uval);
1115

1116 1117 1118
	out.print_metric = pm;
	out.new_line = nl;
	out.ctx = &os;
1119
	out.force_header = false;
1120

1121
	if (csv_output && !metric_only) {
1122 1123 1124 1125 1126
		print_noise(counter, noise);
		print_running(run, ena);
	}

	perf_stat__print_shadow_stats(counter, uval,
1127
				first_shadow_cpu(counter, id),
1128
				&out, &metric_events, st);
1129
	if (!csv_output && !metric_only) {
1130 1131 1132
		print_noise(counter, noise);
		print_running(run, ena);
	}
1133 1134
}

1135 1136 1137 1138 1139 1140 1141 1142
static void aggr_update_shadow(void)
{
	int cpu, s2, id, s;
	u64 val;
	struct perf_evsel *counter;

	for (s = 0; s < aggr_map->nr; s++) {
		id = aggr_map->map[s];
1143
		evlist__for_each_entry(evsel_list, counter) {
1144 1145 1146 1147 1148 1149 1150
			val = 0;
			for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
				s2 = aggr_get_id(evsel_list->cpus, cpu);
				if (s2 != id)
					continue;
				val += perf_counts(counter->counts, cpu, 0)->val;
			}
1151
			perf_stat__update_shadow_stats(counter, val,
1152 1153
					first_shadow_cpu(counter, id),
					&rt_stat);
1154 1155 1156 1157
		}
	}
}

1158 1159 1160 1161 1162
static void uniquify_event_name(struct perf_evsel *counter)
{
	char *new_name;
	char *config;

1163 1164
	if (counter->uniquified_name ||
	    !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
					   strlen(counter->pmu_name)))
		return;

	config = strchr(counter->name, '/');
	if (config) {
		if (asprintf(&new_name,
			     "%s%s", counter->pmu_name, config) > 0) {
			free(counter->name);
			counter->name = new_name;
		}
	} else {
		if (asprintf(&new_name,
			     "%s [%s]", counter->name, counter->pmu_name) > 0) {
			free(counter->name);
			counter->name = new_name;
		}
	}
1182 1183

	counter->uniquified_name = true;
1184 1185
}

1186
static void collect_all_aliases(struct perf_evsel *counter,
1187 1188 1189 1190
			    void (*cb)(struct perf_evsel *counter, void *data,
				       bool first),
			    void *data)
{
1191 1192 1193 1194 1195 1196 1197 1198
	struct perf_evsel *alias;

	alias = list_prepare_entry(counter, &(evsel_list->entries), node);
	list_for_each_entry_continue (alias, &evsel_list->entries, node) {
		if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
		    alias->scale != counter->scale ||
		    alias->cgrp != counter->cgrp ||
		    strcmp(alias->unit, counter->unit) ||
1199
		    perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter))
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
			break;
		alias->merged_stat = true;
		cb(alias, data, false);
	}
}

static bool collect_data(struct perf_evsel *counter,
			    void (*cb)(struct perf_evsel *counter, void *data,
				       bool first),
			    void *data)
{
	if (counter->merged_stat)
		return false;
1213
	cb(counter, data, true);
1214 1215 1216
	if (no_merge)
		uniquify_event_name(counter);
	else if (counter->auto_merge_stats)
1217 1218
		collect_all_aliases(counter, cb, data);
	return true;
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
}

struct aggr_data {
	u64 ena, run, val;
	int id;
	int nr;
	int cpu;
};

static void aggr_cb(struct perf_evsel *counter, void *data, bool first)
{
	struct aggr_data *ad = data;
	int cpu, s2;

	for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
		struct perf_counts_values *counts;

		s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
		if (s2 != ad->id)
			continue;
		if (first)
			ad->nr++;
		counts = perf_counts(counter->counts, cpu, 0);
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
		/*
		 * When any result is bad, make them all to give
		 * consistent output in interval mode.
		 */
		if (counts->ena == 0 || counts->run == 0 ||
		    counter->counts->scaled == -1) {
			ad->ena = 0;
			ad->run = 0;
			break;
		}
1252 1253 1254 1255 1256 1257
		ad->val += counts->val;
		ad->ena += counts->ena;
		ad->run += counts->run;
	}
}

1258
static void print_aggr(char *prefix)
1259
{
1260
	FILE *output = stat_config.output;
1261
	struct perf_evsel *counter;
1262
	int s, id, nr;
1263
	double uval;
1264
	u64 ena, run, val;
1265
	bool first;
1266

1267
	if (!(aggr_map || aggr_get_id))
1268 1269
		return;

1270 1271
	aggr_update_shadow();

1272 1273 1274 1275
	/*
	 * With metric_only everything is on a single line.
	 * Without each counter has its own line.
	 */
1276
	for (s = 0; s < aggr_map->nr; s++) {
1277
		struct aggr_data ad;
1278 1279 1280
		if (prefix && metric_only)
			fprintf(output, "%s", prefix);

1281
		ad.id = id = aggr_map->map[s];
1282
		first = true;
1283
		evlist__for_each_entry(evsel_list, counter) {
1284 1285 1286
			if (is_duration_time(counter))
				continue;

1287 1288
			ad.val = ad.ena = ad.run = 0;
			ad.nr = 0;
1289 1290
			if (!collect_data(counter, aggr_cb, &ad))
				continue;
1291 1292 1293 1294
			nr = ad.nr;
			ena = ad.ena;
			run = ad.run;
			val = ad.val;
1295 1296 1297 1298 1299
			if (first && metric_only) {
				first = false;
				aggr_printout(counter, id, nr);
			}
			if (prefix && !metric_only)
1300 1301
				fprintf(output, "%s", prefix);

1302
			uval = val * counter->scale;
1303 1304
			printout(id, nr, counter, uval, prefix, run, ena, 1.0,
				 &rt_stat);
1305 1306
			if (!metric_only)
				fputc('\n', output);
1307
		}
1308 1309
		if (metric_only)
			fputc('\n', output);
1310 1311 1312
	}
}

1313
static int cmp_val(const void *a, const void *b)
1314
{
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
	return ((struct perf_aggr_thread_value *)b)->val -
		((struct perf_aggr_thread_value *)a)->val;
}

static struct perf_aggr_thread_value *sort_aggr_thread(
					struct perf_evsel *counter,
					int nthreads, int ncpus,
					int *ret)
{
	int cpu, thread, i = 0;
1325
	double uval;
1326 1327 1328 1329 1330
	struct perf_aggr_thread_value *buf;

	buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
	if (!buf)
		return NULL;
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340

	for (thread = 0; thread < nthreads; thread++) {
		u64 ena = 0, run = 0, val = 0;

		for (cpu = 0; cpu < ncpus; cpu++) {
			val += perf_counts(counter->counts, cpu, thread)->val;
			ena += perf_counts(counter->counts, cpu, thread)->ena;
			run += perf_counts(counter->counts, cpu, thread)->run;
		}

1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
		uval = val * counter->scale;

		/*
		 * Skip value 0 when enabling --per-thread globally,
		 * otherwise too many 0 output.
		 */
		if (uval == 0.0 && target__has_per_thread(&target))
			continue;

		buf[i].counter = counter;
		buf[i].id = thread;
		buf[i].uval = uval;
		buf[i].val = val;
		buf[i].run = run;
		buf[i].ena = ena;
		i++;
	}

	qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);

	if (ret)
		*ret = i;

	return buf;
}

static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
{
	FILE *output = stat_config.output;
	int nthreads = thread_map__nr(counter->threads);
	int ncpus = cpu_map__nr(counter->cpus);
	int thread, sorted_threads, id;
	struct perf_aggr_thread_value *buf;

	buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads);
	if (!buf) {
		perror("cannot sort aggr thread");
		return;
	}

	for (thread = 0; thread < sorted_threads; thread++) {
1382 1383 1384
		if (prefix)
			fprintf(output, "%s", prefix);

1385
		id = buf[thread].id;
1386
		if (stat_config.stats)
1387 1388 1389
			printout(id, 0, buf[thread].counter, buf[thread].uval,
				 prefix, buf[thread].run, buf[thread].ena, 1.0,
				 &stat_config.stats[id]);
1390
		else
1391 1392 1393
			printout(id, 0, buf[thread].counter, buf[thread].uval,
				 prefix, buf[thread].run, buf[thread].ena, 1.0,
				 &rt_stat);
1394 1395
		fputc('\n', output);
	}
1396 1397

	free(buf);
1398 1399
}

1400 1401 1402 1403 1404 1405 1406 1407
struct caggr_data {
	double avg, avg_enabled, avg_running;
};

static void counter_aggr_cb(struct perf_evsel *counter, void *data,
			    bool first __maybe_unused)
{
	struct caggr_data *cd = data;
1408
	struct perf_stat_evsel *ps = counter->stats;
1409 1410 1411 1412 1413 1414

	cd->avg += avg_stats(&ps->res_stats[0]);
	cd->avg_enabled += avg_stats(&ps->res_stats[1]);
	cd->avg_running += avg_stats(&ps->res_stats[2]);
}

1415 1416
/*
 * Print out the results of a single counter:
1417
 * aggregated counts in system-wide mode
1418
 */
1419
static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
1420
{
1421
	FILE *output = stat_config.output;
1422
	double uval;
1423
	struct caggr_data cd = { .avg = 0.0 };
1424

1425 1426
	if (!collect_data(counter, counter_aggr_cb, &cd))
		return;
1427

1428
	if (prefix && !metric_only)
1429 1430
		fprintf(output, "%s", prefix);

1431
	uval = cd.avg * counter->scale;
1432 1433
	printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
		 cd.avg, &rt_stat);
1434 1435
	if (!metric_only)
		fprintf(output, "\n");
1436 1437
}

1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
static void counter_cb(struct perf_evsel *counter, void *data,
		       bool first __maybe_unused)
{
	struct aggr_data *ad = data;

	ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
	ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
	ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
}

1448 1449 1450 1451
/*
 * Print out the results of a single counter:
 * does not use aggregated count in system-wide
 */
1452
static void print_counter(struct perf_evsel *counter, char *prefix)
1453
{
1454
	FILE *output = stat_config.output;
1455
	u64 ena, run, val;
1456
	double uval;
1457 1458
	int cpu;

1459
	for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
1460 1461
		struct aggr_data ad = { .cpu = cpu };

1462 1463
		if (!collect_data(counter, counter_cb, &ad))
			return;
1464 1465 1466
		val = ad.val;
		ena = ad.ena;
		run = ad.run;
1467 1468 1469 1470

		if (prefix)
			fprintf(output, "%s", prefix);

1471
		uval = val * counter->scale;
1472 1473
		printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
			 &rt_stat);
1474

1475
		fputc('\n', output);
1476 1477 1478
	}
}

1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
static void print_no_aggr_metric(char *prefix)
{
	int cpu;
	int nrcpus = 0;
	struct perf_evsel *counter;
	u64 ena, run, val;
	double uval;

	nrcpus = evsel_list->cpus->nr;
	for (cpu = 0; cpu < nrcpus; cpu++) {
		bool first = true;

		if (prefix)
			fputs(prefix, stat_config.output);
1493
		evlist__for_each_entry(evsel_list, counter) {
1494 1495
			if (is_duration_time(counter))
				continue;
1496 1497 1498 1499 1500 1501 1502 1503 1504
			if (first) {
				aggr_printout(counter, cpu, 0);
				first = false;
			}
			val = perf_counts(counter->counts, cpu, 0)->val;
			ena = perf_counts(counter->counts, cpu, 0)->ena;
			run = perf_counts(counter->counts, cpu, 0)->run;

			uval = val * counter->scale;
1505 1506
			printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
				 &rt_stat);
1507 1508 1509 1510 1511
		}
		fputc('\n', stat_config.output);
	}
}

1512 1513 1514
static int aggr_header_lens[] = {
	[AGGR_CORE] = 18,
	[AGGR_SOCKET] = 12,
1515
	[AGGR_NONE] = 6,
1516 1517 1518 1519
	[AGGR_THREAD] = 24,
	[AGGR_GLOBAL] = 0,
};

1520 1521 1522 1523 1524 1525 1526 1527
static const char *aggr_header_csv[] = {
	[AGGR_CORE] 	= 	"core,cpus,",
	[AGGR_SOCKET] 	= 	"socket,cpus",
	[AGGR_NONE] 	= 	"cpu,",
	[AGGR_THREAD] 	= 	"comm-pid,",
	[AGGR_GLOBAL] 	=	""
};

1528
static void print_metric_headers(const char *prefix, bool no_indent)
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
{
	struct perf_stat_output_ctx out;
	struct perf_evsel *counter;
	struct outstate os = {
		.fh = stat_config.output
	};

	if (prefix)
		fprintf(stat_config.output, "%s", prefix);

1539
	if (!csv_output && !no_indent)
1540 1541
		fprintf(stat_config.output, "%*s",
			aggr_header_lens[stat_config.aggr_mode], "");
1542 1543 1544 1545 1546 1547
	if (csv_output) {
		if (stat_config.interval)
			fputs("time,", stat_config.output);
		fputs(aggr_header_csv[stat_config.aggr_mode],
			stat_config.output);
	}
1548 1549

	/* Print metrics headers only */
1550
	evlist__for_each_entry(evsel_list, counter) {
1551 1552
		if (is_duration_time(counter))
			continue;
1553 1554 1555 1556
		os.evsel = counter;
		out.ctx = &os;
		out.print_metric = print_metric_header;
		out.new_line = new_line_metric;
1557
		out.force_header = true;
1558 1559 1560
		os.evsel = counter;
		perf_stat__print_shadow_stats(counter, 0,
					      0,
1561
					      &out,
1562 1563
					      &metric_events,
					      &rt_stat);
1564 1565 1566 1567
	}
	fputc('\n', stat_config.output);
}

1568 1569
static void print_interval(char *prefix, struct timespec *ts)
{
1570
	FILE *output = stat_config.output;
1571 1572
	static int num_print_interval;

1573 1574 1575
	if (interval_clear)
		puts(CONSOLE_CLEAR);

1576 1577
	sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);

1578
	if ((num_print_interval == 0 && !csv_output) || interval_clear) {
1579
		switch (stat_config.aggr_mode) {
1580
		case AGGR_SOCKET:
1581 1582 1583
			fprintf(output, "#           time socket cpus");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
1584 1585
			break;
		case AGGR_CORE:
1586 1587 1588
			fprintf(output, "#           time core         cpus");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
1589 1590
			break;
		case AGGR_NONE:
1591
			fprintf(output, "#           time CPU    ");
1592 1593
			if (!metric_only)
				fprintf(output, "                counts %*s events\n", unit_width, "unit");
1594
			break;
1595
		case AGGR_THREAD:
1596 1597 1598
			fprintf(output, "#           time             comm-pid");
			if (!metric_only)
				fprintf(output, "                  counts %*s events\n", unit_width, "unit");
1599
			break;
1600 1601
		case AGGR_GLOBAL:
		default:
1602 1603 1604
			fprintf(output, "#           time");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
Jiri Olsa's avatar
Jiri Olsa committed
1605 1606
		case AGGR_UNSET:
			break;
1607 1608 1609
		}
	}

1610
	if ((num_print_interval == 0 || interval_clear) && metric_only)
1611
		print_metric_headers(" ", true);
1612 1613 1614 1615 1616
	if (++num_print_interval == 25)
		num_print_interval = 0;
}

static void print_header(int argc, const char **argv)
1617
{
1618
	FILE *output = stat_config.output;
1619
	int i;
1620

1621 1622
	fflush(stdout);

1623
	if (!csv_output) {
1624 1625
		fprintf(output, "\n");
		fprintf(output, " Performance counter stats for ");
1626 1627 1628 1629
		if (target.system_wide)
			fprintf(output, "\'system wide");
		else if (target.cpu_list)
			fprintf(output, "\'CPU(s) %s", target.cpu_list);
1630
		else if (!target__has_task(&target)) {
1631 1632
			fprintf(output, "\'%s", argv ? argv[0] : "pipe");
			for (i = 1; argv && (i < argc); i++)
1633
				fprintf(output, " %s", argv[i]);
1634 1635
		} else if (target.pid)
			fprintf(output, "process id \'%s", target.pid);
1636
		else
1637
			fprintf(output, "thread id \'%s", target.tid);
1638

1639
		fprintf(output, "\'");
1640
		if (run_count > 1)
1641 1642
			fprintf(output, " (%d runs)", run_count);
		fprintf(output, ":\n\n");
1643
	}
1644 1645
}

1646 1647 1648 1649 1650 1651 1652 1653
static int get_precision(double num)
{
	if (num > 1)
		return 0;

	return lround(ceil(-log10(num)));
}

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
static void print_table(FILE *output, int precision, double avg)
{
	char tmp[64];
	int idx, indent = 0;

	scnprintf(tmp, 64, " %17.*f", precision, avg);
	while (tmp[indent] == ' ')
		indent++;

	fprintf(output, "%*s# Table of individual measurements:\n", indent, "");

	for (idx = 0; idx < run_count; idx++) {
		double run = (double) walltime_run[idx] / NSEC_PER_SEC;
1667
		int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
1668

1669
		fprintf(output, " %17.*f (%+.*f) ",
1670
			precision, run, precision, run - avg);
1671 1672 1673 1674 1675

		for (h = 0; h < n; h++)
			fprintf(output, "#");

		fprintf(output, "\n");
1676 1677 1678 1679 1680
	}

	fprintf(output, "\n%*s# Final result:\n", indent, "");
}

1681 1682 1683 1684 1685
static double timeval2double(struct timeval *t)
{
	return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
}

1686 1687
static void print_footer(void)
{
1688
	double avg = avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
1689
	FILE *output = stat_config.output;
1690
	int n;
1691

1692 1693
	if (!null_run)
		fprintf(output, "\n");
1694 1695 1696

	if (run_count == 1) {
		fprintf(output, " %17.9f seconds time elapsed", avg);
1697 1698 1699 1700 1701 1702 1703 1704 1705

		if (ru_display) {
			double ru_utime = timeval2double(&ru_data.ru_utime);
			double ru_stime = timeval2double(&ru_data.ru_stime);

			fprintf(output, "\n\n");
			fprintf(output, " %17.9f seconds user\n", ru_utime);
			fprintf(output, " %17.9f seconds sys\n", ru_stime);
		}
1706 1707 1708 1709 1710 1711 1712 1713
	} else {
		double sd = stddev_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
		/*
		 * Display at most 2 more significant
		 * digits than the stddev inaccuracy.
		 */
		int precision = get_precision(sd) + 2;

1714 1715 1716
		if (walltime_run_table)
			print_table(output, precision, avg);

1717 1718 1719 1720
		fprintf(output, " %17.*f +- %.*f seconds time elapsed",
			precision, avg, precision, sd);

		print_noise_pct(sd, avg);
1721 1722
	}
	fprintf(output, "\n\n");
1723

1724 1725 1726
	if (print_free_counters_hint &&
	    sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
	    n > 0)
1727 1728 1729 1730 1731
		fprintf(output,
"Some events weren't counted. Try disabling the NMI watchdog:\n"
"	echo 0 > /proc/sys/kernel/nmi_watchdog\n"
"	perf stat ...\n"
"	echo 1 > /proc/sys/kernel/nmi_watchdog\n");
1732 1733 1734 1735 1736

	if (print_mixed_hw_group_error)
		fprintf(output,
			"The events in group usually have to be from "
			"the same PMU. Try reorganizing the group.\n");
1737 1738 1739 1740
}

static void print_counters(struct timespec *ts, int argc, const char **argv)
{
1741
	int interval = stat_config.interval;
1742 1743 1744
	struct perf_evsel *counter;
	char buf[64], *prefix = NULL;

1745
	/* Do not print anything if we record to the pipe. */
1746
	if (STAT_RECORD && perf_stat.data.is_pipe)
1747 1748
		return;

1749 1750 1751 1752
	if (interval)
		print_interval(prefix = buf, ts);
	else
		print_header(argc, argv);
1753

1754 1755 1756
	if (metric_only) {
		static int num_print_iv;

1757 1758
		if (num_print_iv == 0 && !interval)
			print_metric_headers(prefix, false);
1759 1760 1761 1762 1763 1764
		if (num_print_iv++ == 25)
			num_print_iv = 0;
		if (stat_config.aggr_mode == AGGR_GLOBAL && prefix)
			fprintf(stat_config.output, "%s", prefix);
	}

1765
	switch (stat_config.aggr_mode) {
1766
	case AGGR_CORE:
1767
	case AGGR_SOCKET:
1768
		print_aggr(prefix);
1769
		break;
1770
	case AGGR_THREAD:
1771 1772 1773
		evlist__for_each_entry(evsel_list, counter) {
			if (is_duration_time(counter))
				continue;
1774
			print_aggr_thread(counter, prefix);
1775
		}
1776
		break;
1777
	case AGGR_GLOBAL:
1778 1779 1780
		evlist__for_each_entry(evsel_list, counter) {
			if (is_duration_time(counter))
				continue;
1781
			print_counter_aggr(counter, prefix);
1782
		}
1783 1784
		if (metric_only)
			fputc('\n', stat_config.output);
1785 1786
		break;
	case AGGR_NONE:
1787 1788 1789
		if (metric_only)
			print_no_aggr_metric(prefix);
		else {
1790 1791 1792
			evlist__for_each_entry(evsel_list, counter) {
				if (is_duration_time(counter))
					continue;
1793
				print_counter(counter, prefix);
1794
			}
1795
		}
1796
		break;
Jiri Olsa's avatar
Jiri Olsa committed
1797
	case AGGR_UNSET:
1798 1799
	default:
		break;
1800
	}
1801

1802 1803 1804
	if (!interval && !csv_output)
		print_footer();

1805
	fflush(stat_config.output);
1806 1807
}

1808 1809
static volatile int signr = -1;

1810
static void skip_signal(int signo)
1811
{
1812
	if ((child_pid == -1) || stat_config.interval)
1813 1814
		done = 1;

1815
	signr = signo;
1816 1817 1818 1819 1820 1821 1822
	/*
	 * render child_pid harmless
	 * won't send SIGTERM to a random
	 * process in case of race condition
	 * and fast PID recycling
	 */
	child_pid = -1;
1823 1824 1825 1826
}

static void sig_atexit(void)
{
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
	sigset_t set, oset;

	/*
	 * avoid race condition with SIGCHLD handler
	 * in skip_signal() which is modifying child_pid
	 * goal is to avoid send SIGTERM to a random
	 * process
	 */
	sigemptyset(&set);
	sigaddset(&set, SIGCHLD);
	sigprocmask(SIG_BLOCK, &set, &oset);

1839 1840 1841
	if (child_pid != -1)
		kill(child_pid, SIGTERM);

1842 1843
	sigprocmask(SIG_SETMASK, &oset, NULL);

1844 1845 1846 1847 1848
	if (signr == -1)
		return;

	signal(signr, SIG_DFL);
	kill(getpid(), signr);
1849 1850
}

1851 1852
static int stat__set_big_num(const struct option *opt __maybe_unused,
			     const char *s __maybe_unused, int unset)
1853 1854 1855 1856 1857
{
	big_num_opt = unset ? 0 : 1;
	return 0;
}

1858 1859 1860 1861 1862 1863 1864 1865
static int enable_metric_only(const struct option *opt __maybe_unused,
			      const char *s __maybe_unused, int unset)
{
	force_metric_only = true;
	metric_only = !unset;
	return 0;
}

1866 1867 1868 1869 1870 1871 1872
static int parse_metric_groups(const struct option *opt,
			       const char *str,
			       int unset __maybe_unused)
{
	return metricgroup__parse_groups(opt, str, &metric_events);
}

1873 1874 1875 1876 1877 1878 1879 1880
static const struct option stat_options[] = {
	OPT_BOOLEAN('T', "transaction", &transaction_run,
		    "hardware transaction statistics"),
	OPT_CALLBACK('e', "event", &evsel_list, "event",
		     "event selector. use 'perf list' to list available events",
		     parse_events_option),
	OPT_CALLBACK(0, "filter", &evsel_list, "filter",
		     "event filter", parse_filter),
1881
	OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit,
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
		    "child tasks do not inherit counters"),
	OPT_STRING('p', "pid", &target.pid, "pid",
		   "stat events on existing process id"),
	OPT_STRING('t', "tid", &target.tid, "tid",
		   "stat events on existing thread id"),
	OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
		    "system-wide collection from all CPUs"),
	OPT_BOOLEAN('g', "group", &group,
		    "put the counters into a counter group"),
	OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"),
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show counter open errors, etc)"),
	OPT_INTEGER('r', "repeat", &run_count,
		    "repeat command and print average + stddev (max: 100, forever: 0)"),
1896 1897
	OPT_BOOLEAN(0, "table", &walltime_run_table,
		    "display details about each run (only with -r option)"),
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
	OPT_BOOLEAN('n', "null", &null_run,
		    "null run - dont start any counters"),
	OPT_INCR('d', "detailed", &detailed_run,
		    "detailed run - start a lot of events"),
	OPT_BOOLEAN('S', "sync", &sync_run,
		    "call sync() before starting a run"),
	OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
			   "print large numbers with thousands\' separators",
			   stat__set_big_num),
	OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
		    "list of cpus to monitor in system-wide"),
	OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
		    "disable CPU count aggregation", AGGR_NONE),
1911
	OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"),
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
	OPT_STRING('x', "field-separator", &csv_sep, "separator",
		   "print counts with custom separator"),
	OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
		     "monitor event in cgroup name only", parse_cgroups),
	OPT_STRING('o', "output", &output_name, "file", "output file name"),
	OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
	OPT_INTEGER(0, "log-fd", &output_fd,
		    "log output to fd, instead of stderr"),
	OPT_STRING(0, "pre", &pre_cmd, "command",
			"command to run prior to the measured command"),
	OPT_STRING(0, "post", &post_cmd, "command",
			"command to run after to the measured command"),
	OPT_UINTEGER('I', "interval-print", &stat_config.interval,
1925 1926
		    "print counts at regular interval in ms "
		    "(overhead is possible for values <= 100ms)"),
1927 1928
	OPT_INTEGER(0, "interval-count", &stat_config.times,
		    "print counts for fixed number of times"),
1929 1930
	OPT_BOOLEAN(0, "interval-clear", &interval_clear,
		    "clear screen in between new interval"),
1931 1932
	OPT_UINTEGER(0, "timeout", &stat_config.timeout,
		    "stop workload and print counts after a timeout period in ms (>= 10ms)"),
1933 1934 1935 1936 1937 1938
	OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode,
		     "aggregate counts per processor socket", AGGR_SOCKET),
	OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode,
		     "aggregate counts per physical processor core", AGGR_CORE),
	OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
		     "aggregate counts per thread", AGGR_THREAD),
1939
	OPT_UINTEGER('D', "delay", &stat_config.initial_delay,
1940
		     "ms to wait before starting measurement after program start"),
1941 1942 1943 1944
	OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL,
			"Only print computed metrics. No raw values", enable_metric_only),
	OPT_BOOLEAN(0, "topdown", &topdown_run,
			"measure topdown level 1 statistics"),
1945 1946
	OPT_BOOLEAN(0, "smi-cost", &smi_cost,
			"measure SMI cost"),
1947 1948 1949
	OPT_CALLBACK('M', "metrics", &evsel_list, "metric/metric group list",
		     "monitor specified metrics or metric groups (separated by ,)",
		     parse_metric_groups),
1950 1951 1952
	OPT_END()
};

1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
static int perf_stat__get_socket(struct cpu_map *map, int cpu)
{
	return cpu_map__get_socket(map, cpu, NULL);
}

static int perf_stat__get_core(struct cpu_map *map, int cpu)
{
	return cpu_map__get_core(map, cpu, NULL);
}

1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
static int cpu_map__get_max(struct cpu_map *map)
{
	int i, max = -1;

	for (i = 0; i < map->nr; i++) {
		if (map->map[i] > max)
			max = map->map[i];
	}

	return max;
}

static struct cpu_map *cpus_aggr_map;

static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx)
{
	int cpu;

	if (idx >= map->nr)
		return -1;

	cpu = map->map[idx];

	if (cpus_aggr_map->map[cpu] == -1)
		cpus_aggr_map->map[cpu] = get_id(map, idx);

	return cpus_aggr_map->map[cpu];
}

static int perf_stat__get_socket_cached(struct cpu_map *map, int idx)
{
	return perf_stat__get_aggr(perf_stat__get_socket, map, idx);
}

static int perf_stat__get_core_cached(struct cpu_map *map, int idx)
{
	return perf_stat__get_aggr(perf_stat__get_core, map, idx);
}

2002 2003
static int perf_stat_init_aggr_mode(void)
{
2004 2005
	int nr;

2006
	switch (stat_config.aggr_mode) {
2007 2008 2009 2010 2011
	case AGGR_SOCKET:
		if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
			perror("cannot build socket map");
			return -1;
		}
2012
		aggr_get_id = perf_stat__get_socket_cached;
2013
		break;
2014 2015 2016 2017 2018
	case AGGR_CORE:
		if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
			perror("cannot build core map");
			return -1;
		}
2019
		aggr_get_id = perf_stat__get_core_cached;
2020
		break;
2021 2022
	case AGGR_NONE:
	case AGGR_GLOBAL:
2023
	case AGGR_THREAD:
Jiri Olsa's avatar
Jiri Olsa committed
2024
	case AGGR_UNSET:
2025 2026 2027
	default:
		break;
	}
2028 2029 2030 2031 2032 2033 2034 2035 2036

	/*
	 * The evsel_list->cpus is the base we operate on,
	 * taking the highest cpu number to be the size of
	 * the aggregation translate cpumap.
	 */
	nr = cpu_map__get_max(evsel_list->cpus);
	cpus_aggr_map = cpu_map__empty_new(nr + 1);
	return cpus_aggr_map ? 0 : -ENOMEM;
2037 2038
}

2039 2040 2041 2042 2043 2044 2045 2046
static void perf_stat__exit_aggr_mode(void)
{
	cpu_map__put(aggr_map);
	cpu_map__put(cpus_aggr_map);
	aggr_map = NULL;
	cpus_aggr_map = NULL;
}

2047 2048 2049 2050 2051 2052 2053 2054 2055
static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx)
{
	int cpu;

	if (idx > map->nr)
		return -1;

	cpu = map->map[idx];

2056
	if (cpu >= env->nr_cpus_avail)
2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
		return -1;

	return cpu;
}

static int perf_env__get_socket(struct cpu_map *map, int idx, void *data)
{
	struct perf_env *env = data;
	int cpu = perf_env__get_cpu(env, map, idx);

	return cpu == -1 ? -1 : env->cpu[cpu].socket_id;
}

static int perf_env__get_core(struct cpu_map *map, int idx, void *data)
{
	struct perf_env *env = data;
	int core = -1, cpu = perf_env__get_cpu(env, map, idx);

	if (cpu != -1) {
		int socket_id = env->cpu[cpu].socket_id;

		/*
		 * Encode socket in upper 16 bits
		 * core_id is relative to socket, and
		 * we need a global id. So we combine
		 * socket + core id.
		 */
		core = (socket_id << 16) | (env->cpu[cpu].core_id & 0xffff);
	}

	return core;
}

static int perf_env__build_socket_map(struct perf_env *env, struct cpu_map *cpus,
				      struct cpu_map **sockp)
{
	return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env);
}

static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus,
				    struct cpu_map **corep)
{
	return cpu_map__build_map(cpus, corep, perf_env__get_core, env);
}

static int perf_stat__get_socket_file(struct cpu_map *map, int idx)
{
	return perf_env__get_socket(map, idx, &perf_stat.session->header.env);
}

static int perf_stat__get_core_file(struct cpu_map *map, int idx)
{
	return perf_env__get_core(map, idx, &perf_stat.session->header.env);
}

static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
{
	struct perf_env *env = &st->session->header.env;

	switch (stat_config.aggr_mode) {
	case AGGR_SOCKET:
		if (perf_env__build_socket_map(env, evsel_list->cpus, &aggr_map)) {
			perror("cannot build socket map");
			return -1;
		}
		aggr_get_id = perf_stat__get_socket_file;
		break;
	case AGGR_CORE:
		if (perf_env__build_core_map(env, evsel_list->cpus, &aggr_map)) {
			perror("cannot build core map");
			return -1;
		}
		aggr_get_id = perf_stat__get_core_file;
		break;
	case AGGR_NONE:
	case AGGR_GLOBAL:
	case AGGR_THREAD:
	case AGGR_UNSET:
	default:
		break;
	}

	return 0;
}

2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
static int topdown_filter_events(const char **attr, char **str, bool use_group)
{
	int off = 0;
	int i;
	int len = 0;
	char *s;

	for (i = 0; attr[i]; i++) {
		if (pmu_have_event("cpu", attr[i])) {
			len += strlen(attr[i]) + 1;
			attr[i - off] = attr[i];
		} else
			off++;
	}
	attr[i - off] = NULL;

	*str = malloc(len + 1 + 2);
	if (!*str)
		return -1;
	s = *str;
	if (i - off == 0) {
		*s = 0;
		return 0;
	}
	if (use_group)
		*s++ = '{';
	for (i = 0; attr[i]; i++) {
		strcpy(s, attr[i]);
		s += strlen(s);
		*s++ = ',';
	}
	if (use_group) {
		s[-1] = '}';
		*s = 0;
	} else
		s[-1] = 0;
	return 0;
}

__weak bool arch_topdown_check_group(bool *warn)
{
	*warn = false;
	return false;
}

__weak void arch_topdown_group_warn(void)
{
}

2191 2192 2193 2194 2195 2196
/*
 * Add default attributes, if there were no attributes specified or
 * if -d/--detailed, -d -d or -d -d -d is used:
 */
static int add_default_attributes(void)
{
2197
	int err;
2198
	struct perf_event_attr default_attrs0[] = {
2199 2200 2201 2202 2203 2204 2205

  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK		},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES	},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS		},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS		},

  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES		},
2206 2207
};
	struct perf_event_attr frontend_attrs[] = {
2208
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND	},
2209 2210
};
	struct perf_event_attr backend_attrs[] = {
2211
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND	},
2212 2213
};
	struct perf_event_attr default_attrs1[] = {
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS		},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS	},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES		},

};

/*
 * Detailed stats (-d), covering the L1 and last level data caches:
 */
	struct perf_event_attr detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_LL			<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_LL			<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
};

/*
 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
 */
	struct perf_event_attr very_detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

};

/*
 * Very, very detailed stats (-d -d -d), adding prefetch events:
 */
	struct perf_event_attr very_very_detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
};
2310
	struct parse_events_error errinfo;
2311

2312 2313 2314 2315
	/* Set attrs if no event is selected and !null_run: */
	if (null_run)
		return 0;

2316
	if (transaction_run) {
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
		/* Handle -T as -M transaction. Once platform specific metrics
		 * support has been added to the json files, all archictures
		 * will use this approach. To determine transaction support
		 * on an architecture test for such a metric name.
		 */
		if (metricgroup__has_metric("transaction")) {
			struct option opt = { .value = &evsel_list };

			return metricgroup__parse_groups(&opt, "transaction",
							 &metric_events);
		}

2329 2330
		if (pmu_have_event("cpu", "cycles-ct") &&
		    pmu_have_event("cpu", "el-start"))
2331 2332
			err = parse_events(evsel_list, transaction_attrs,
					   &errinfo);
2333
		else
2334 2335 2336
			err = parse_events(evsel_list,
					   transaction_limited_attrs,
					   &errinfo);
2337
		if (err) {
2338
			fprintf(stderr, "Cannot set up transaction events\n");
2339
			parse_events_print_error(&errinfo, transaction_attrs);
2340 2341 2342 2343 2344
			return -1;
		}
		return 0;
	}

2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
	if (smi_cost) {
		int smi;

		if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) {
			fprintf(stderr, "freeze_on_smi is not supported.\n");
			return -1;
		}

		if (!smi) {
			if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) {
				fprintf(stderr, "Failed to set freeze_on_smi.\n");
				return -1;
			}
			smi_reset = true;
		}

		if (pmu_have_event("msr", "aperf") &&
		    pmu_have_event("msr", "smi")) {
			if (!force_metric_only)
				metric_only = true;
2365
			err = parse_events(evsel_list, smi_cost_attrs, &errinfo);
2366 2367 2368
		} else {
			fprintf(stderr, "To measure SMI cost, it needs "
				"msr/aperf/, msr/smi/ and cpu/cycles/ support\n");
2369
			parse_events_print_error(&errinfo, smi_cost_attrs);
2370 2371 2372 2373 2374 2375 2376 2377 2378
			return -1;
		}
		if (err) {
			fprintf(stderr, "Cannot set up SMI cost events\n");
			return -1;
		}
		return 0;
	}

2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
	if (topdown_run) {
		char *str = NULL;
		bool warn = false;

		if (stat_config.aggr_mode != AGGR_GLOBAL &&
		    stat_config.aggr_mode != AGGR_CORE) {
			pr_err("top down event configuration requires --per-core mode\n");
			return -1;
		}
		stat_config.aggr_mode = AGGR_CORE;
		if (nr_cgroups || !target__has_cpu(&target)) {
			pr_err("top down event configuration requires system-wide mode (-a)\n");
			return -1;
		}

		if (!force_metric_only)
			metric_only = true;
		if (topdown_filter_events(topdown_attrs, &str,
				arch_topdown_check_group(&warn)) < 0) {
			pr_err("Out of memory\n");
			return -1;
		}
		if (topdown_attrs[0] && str) {
			if (warn)
				arch_topdown_group_warn();
2404
			err = parse_events(evsel_list, str, &errinfo);
2405 2406 2407 2408 2409
			if (err) {
				fprintf(stderr,
					"Cannot set up top down events %s: %d\n",
					str, err);
				free(str);
2410
				parse_events_print_error(&errinfo, str);
2411 2412 2413 2414 2415 2416 2417 2418 2419
				return -1;
			}
		} else {
			fprintf(stderr, "System does not support topdown\n");
			return -1;
		}
		free(str);
	}

2420
	if (!evsel_list->nr_entries) {
2421 2422 2423
		if (target__has_cpu(&target))
			default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;

2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
		if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0)
			return -1;
		if (pmu_have_event("cpu", "stalled-cycles-frontend")) {
			if (perf_evlist__add_default_attrs(evsel_list,
						frontend_attrs) < 0)
				return -1;
		}
		if (pmu_have_event("cpu", "stalled-cycles-backend")) {
			if (perf_evlist__add_default_attrs(evsel_list,
						backend_attrs) < 0)
				return -1;
		}
		if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0)
2437
			return -1;
2438 2439 2440 2441 2442 2443 2444 2445
	}

	/* Detailed events get appended to the event list: */

	if (detailed_run <  1)
		return 0;

	/* Append detailed run extra attributes: */
2446
	if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
2447
		return -1;
2448 2449 2450 2451 2452

	if (detailed_run < 2)
		return 0;

	/* Append very detailed run extra attributes: */
2453
	if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
2454
		return -1;
2455 2456 2457 2458 2459

	if (detailed_run < 3)
		return 0;

	/* Append very, very detailed run extra attributes: */
2460
	return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
2461 2462
}

2463
static const char * const stat_record_usage[] = {
2464 2465 2466 2467
	"perf stat record [<options>]",
	NULL,
};

2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480
static void init_features(struct perf_session *session)
{
	int feat;

	for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
		perf_header__set_feat(&session->header, feat);

	perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
	perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
	perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
	perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
}

2481 2482 2483
static int __cmd_record(int argc, const char **argv)
{
	struct perf_session *session;
2484
	struct perf_data *data = &perf_stat.data;
2485

2486
	argc = parse_options(argc, argv, stat_options, stat_record_usage,
2487 2488 2489
			     PARSE_OPT_STOP_AT_NON_OPTION);

	if (output_name)
2490
		data->file.path = output_name;
2491

2492 2493 2494 2495 2496
	if (run_count != 1 || forever) {
		pr_err("Cannot use -r option with perf stat record.\n");
		return -1;
	}

2497
	session = perf_session__new(data, false, NULL);
2498 2499 2500 2501 2502
	if (session == NULL) {
		pr_err("Perf session creation failed.\n");
		return -1;
	}

2503 2504
	init_features(session);

2505 2506 2507 2508 2509 2510
	session->evlist   = evsel_list;
	perf_stat.session = session;
	perf_stat.record  = true;
	return argc;
}

2511 2512 2513 2514
static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
				    union perf_event *event,
				    struct perf_session *session)
{
2515
	struct stat_round_event *stat_round = &event->stat_round;
2516 2517 2518 2519 2520
	struct perf_evsel *counter;
	struct timespec tsh, *ts = NULL;
	const char **argv = session->header.env.cmdline_argv;
	int argc = session->header.env.nr_cmdline;

2521
	evlist__for_each_entry(evsel_list, counter)
2522 2523
		perf_stat_process_counter(&stat_config, counter);

2524 2525
	if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL)
		update_stats(&walltime_nsecs_stats, stat_round->time);
2526

2527
	if (stat_config.interval && stat_round->time) {
2528 2529
		tsh.tv_sec  = stat_round->time / NSEC_PER_SEC;
		tsh.tv_nsec = stat_round->time % NSEC_PER_SEC;
2530 2531 2532 2533 2534 2535 2536
		ts = &tsh;
	}

	print_counters(ts, argc, argv);
	return 0;
}

2537
static
2538
int process_stat_config_event(struct perf_tool *tool,
2539 2540 2541
			      union perf_event *event,
			      struct perf_session *session __maybe_unused)
{
2542 2543
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);

2544
	perf_event__read_stat_config(&stat_config, &event->stat_config);
2545

2546 2547 2548 2549 2550 2551 2552 2553 2554
	if (cpu_map__empty(st->cpus)) {
		if (st->aggr_mode != AGGR_UNSET)
			pr_warning("warning: processing task data, aggregation mode not set\n");
		return 0;
	}

	if (st->aggr_mode != AGGR_UNSET)
		stat_config.aggr_mode = st->aggr_mode;

2555
	if (perf_stat.data.is_pipe)
2556 2557 2558 2559
		perf_stat_init_aggr_mode();
	else
		perf_stat_init_aggr_mode_file(st);

2560 2561 2562
	return 0;
}

2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
static int set_maps(struct perf_stat *st)
{
	if (!st->cpus || !st->threads)
		return 0;

	if (WARN_ONCE(st->maps_allocated, "stats double allocation\n"))
		return -EINVAL;

	perf_evlist__set_maps(evsel_list, st->cpus, st->threads);

	if (perf_evlist__alloc_stats(evsel_list, true))
		return -ENOMEM;

	st->maps_allocated = true;
	return 0;
}

static
2581
int process_thread_map_event(struct perf_tool *tool,
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599
			     union perf_event *event,
			     struct perf_session *session __maybe_unused)
{
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);

	if (st->threads) {
		pr_warning("Extra thread map event, ignoring.\n");
		return 0;
	}

	st->threads = thread_map__new_event(&event->thread_map);
	if (!st->threads)
		return -ENOMEM;

	return set_maps(st);
}

static
2600
int process_cpu_map_event(struct perf_tool *tool,
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
			  union perf_event *event,
			  struct perf_session *session __maybe_unused)
{
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);
	struct cpu_map *cpus;

	if (st->cpus) {
		pr_warning("Extra cpu map event, ignoring.\n");
		return 0;
	}

	cpus = cpu_map__new_data(&event->cpu_map.data);
	if (!cpus)
		return -ENOMEM;

	st->cpus = cpus;
	return set_maps(st);
}

2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648
static int runtime_stat_new(struct perf_stat_config *config, int nthreads)
{
	int i;

	config->stats = calloc(nthreads, sizeof(struct runtime_stat));
	if (!config->stats)
		return -1;

	config->stats_num = nthreads;

	for (i = 0; i < nthreads; i++)
		runtime_stat__init(&config->stats[i]);

	return 0;
}

static void runtime_stat_delete(struct perf_stat_config *config)
{
	int i;

	if (!config->stats)
		return;

	for (i = 0; i < config->stats_num; i++)
		runtime_stat__exit(&config->stats[i]);

	free(config->stats);
}

2649
static const char * const stat_report_usage[] = {
2650 2651 2652 2653 2654 2655 2656
	"perf stat report [<options>]",
	NULL,
};

static struct perf_stat perf_stat = {
	.tool = {
		.attr		= perf_event__process_attr,
2657
		.event_update	= perf_event__process_event_update,
2658 2659
		.thread_map	= process_thread_map_event,
		.cpu_map	= process_cpu_map_event,
2660
		.stat_config	= process_stat_config_event,
2661 2662
		.stat		= perf_event__process_stat_event,
		.stat_round	= process_stat_round_event,
2663
	},
2664
	.aggr_mode = AGGR_UNSET,
2665 2666 2667 2668 2669 2670 2671
};

static int __cmd_report(int argc, const char **argv)
{
	struct perf_session *session;
	const struct option options[] = {
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
2672 2673 2674 2675 2676 2677
	OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode,
		     "aggregate counts per processor socket", AGGR_SOCKET),
	OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode,
		     "aggregate counts per physical processor core", AGGR_CORE),
	OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode,
		     "disable CPU count aggregation", AGGR_NONE),
2678 2679 2680 2681 2682
	OPT_END()
	};
	struct stat st;
	int ret;

2683
	argc = parse_options(argc, argv, options, stat_report_usage, 0);
2684 2685 2686 2687 2688 2689 2690 2691

	if (!input_name || !strlen(input_name)) {
		if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
			input_name = "-";
		else
			input_name = "perf.data";
	}

2692 2693
	perf_stat.data.file.path = input_name;
	perf_stat.data.mode      = PERF_DATA_MODE_READ;
2694

2695
	session = perf_session__new(&perf_stat.data, false, &perf_stat.tool);
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
	if (session == NULL)
		return -1;

	perf_stat.session  = session;
	stat_config.output = stderr;
	evsel_list         = session->evlist;

	ret = perf_session__process_events(session);
	if (ret)
		return ret;

	perf_session__delete(session);
	return 0;
}

2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
static void setup_system_wide(int forks)
{
	/*
	 * Make system wide (-a) the default target if
	 * no target was specified and one of following
	 * conditions is met:
	 *
	 *   - there's no workload specified
	 *   - there is workload specified but all requested
	 *     events are system wide events
	 */
	if (!target__none(&target))
		return;

	if (!forks)
		target.system_wide = true;
	else {
		struct perf_evsel *counter;

		evlist__for_each_entry(evsel_list, counter) {
			if (!counter->system_wide)
				return;
		}

		if (evsel_list->nr_entries)
			target.system_wide = true;
	}
}

2740
int cmd_stat(int argc, const char **argv)
2741
{
2742 2743 2744 2745
	const char * const stat_usage[] = {
		"perf stat [<options>] [<command>]",
		NULL
	};
2746
	int status = -EINVAL, run_idx;
2747
	const char *mode;
2748
	FILE *output = stderr;
2749
	unsigned int interval, timeout;
2750
	const char * const stat_subcommands[] = { "record", "report" };
2751

2752 2753
	setlocale(LC_ALL, "");

2754
	evsel_list = perf_evlist__new();
2755 2756 2757
	if (evsel_list == NULL)
		return -ENOMEM;

2758
	parse_events__shrink_config_terms();
2759 2760 2761
	argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
					(const char **) stat_usage,
					PARSE_OPT_STOP_AT_NON_OPTION);
2762
	perf_stat__collect_metric_expr(evsel_list);
2763
	perf_stat__init_shadow_stats();
2764

2765 2766 2767 2768 2769 2770 2771
	if (csv_sep) {
		csv_output = true;
		if (!strcmp(csv_sep, "\\t"))
			csv_sep = "\t";
	} else
		csv_sep = DEFAULT_SEPARATOR;

2772 2773 2774 2775
	if (argc && !strncmp(argv[0], "rec", 3)) {
		argc = __cmd_record(argc, argv);
		if (argc < 0)
			return -1;
2776 2777
	} else if (argc && !strncmp(argv[0], "rep", 3))
		return __cmd_report(argc, argv);
2778

2779
	interval = stat_config.interval;
2780
	timeout = stat_config.timeout;
2781

2782 2783 2784 2785
	/*
	 * For record command the -o is already taken care of.
	 */
	if (!STAT_RECORD && output_name && strcmp(output_name, "-"))
2786 2787
		output = NULL;

2788 2789
	if (output_name && output_fd) {
		fprintf(stderr, "cannot use both --output and --log-fd\n");
2790 2791
		parse_options_usage(stat_usage, stat_options, "o", 1);
		parse_options_usage(NULL, stat_options, "log-fd", 0);
2792
		goto out;
2793
	}
2794

2795 2796 2797 2798 2799 2800 2801 2802 2803 2804
	if (metric_only && stat_config.aggr_mode == AGGR_THREAD) {
		fprintf(stderr, "--metric-only is not supported with --per-thread\n");
		goto out;
	}

	if (metric_only && run_count > 1) {
		fprintf(stderr, "--metric-only is not supported with -r\n");
		goto out;
	}

2805 2806 2807 2808 2809 2810 2811
	if (walltime_run_table && run_count <= 1) {
		fprintf(stderr, "--table is only supported with -r\n");
		parse_options_usage(stat_usage, stat_options, "r", 1);
		parse_options_usage(NULL, stat_options, "table", 0);
		goto out;
	}

2812 2813
	if (output_fd < 0) {
		fprintf(stderr, "argument to --log-fd must be a > 0\n");
2814
		parse_options_usage(stat_usage, stat_options, "log-fd", 0);
2815
		goto out;
2816 2817
	}

2818 2819 2820 2821 2822 2823 2824
	if (!output) {
		struct timespec tm;
		mode = append_file ? "a" : "w";

		output = fopen(output_name, mode);
		if (!output) {
			perror("failed to create output file");
2825
			return -1;
2826 2827 2828
		}
		clock_gettime(CLOCK_REALTIME, &tm);
		fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
2829
	} else if (output_fd > 0) {
2830 2831 2832 2833 2834 2835
		mode = append_file ? "a" : "w";
		output = fdopen(output_fd, mode);
		if (!output) {
			perror("Failed opening logfd");
			return -errno;
		}
2836 2837
	}

2838 2839
	stat_config.output = output;

2840 2841 2842 2843
	/*
	 * let the spreadsheet do the pretty-printing
	 */
	if (csv_output) {
2844
		/* User explicitly passed -B? */
2845 2846
		if (big_num_opt == 1) {
			fprintf(stderr, "-B option not supported with -x\n");
2847 2848
			parse_options_usage(stat_usage, stat_options, "B", 1);
			parse_options_usage(NULL, stat_options, "x", 1);
2849
			goto out;
2850 2851 2852 2853 2854
		} else /* Nope, so disable big number formatting */
			big_num = false;
	} else if (big_num_opt == 0) /* User passed --no-big-num */
		big_num = false;

2855
	setup_system_wide(argc);
2856

2857 2858 2859 2860 2861 2862 2863
	/*
	 * Display user/system times only for single
	 * run and when there's specified tracee.
	 */
	if ((run_count == 1) && target__none(&target))
		ru_display = true;

2864
	if (run_count < 0) {
2865
		pr_err("Run count must be a positive number\n");
2866
		parse_options_usage(stat_usage, stat_options, "r", 1);
2867
		goto out;
2868 2869 2870 2871
	} else if (run_count == 0) {
		forever = true;
		run_count = 1;
	}
2872

2873 2874 2875 2876 2877 2878 2879 2880
	if (walltime_run_table) {
		walltime_run = zalloc(run_count * sizeof(walltime_run[0]));
		if (!walltime_run) {
			pr_err("failed to setup -r option");
			goto out;
		}
	}

2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
	if ((stat_config.aggr_mode == AGGR_THREAD) &&
		!target__has_task(&target)) {
		if (!target.system_wide || target.cpu_list) {
			fprintf(stderr, "The --per-thread option is only "
				"available when monitoring via -p -t -a "
				"options or only --per-thread.\n");
			parse_options_usage(NULL, stat_options, "p", 1);
			parse_options_usage(NULL, stat_options, "t", 1);
			goto out;
		}
2891 2892 2893 2894 2895 2896
	}

	/*
	 * no_aggr, cgroup are for system-wide only
	 * --per-thread is aggregated per thread, we dont mix it with cpu mode
	 */
2897 2898
	if (((stat_config.aggr_mode != AGGR_GLOBAL &&
	      stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) &&
2899
	    !target__has_cpu(&target)) {
2900 2901 2902
		fprintf(stderr, "both cgroup and no-aggregation "
			"modes only available in system-wide mode\n");

2903 2904 2905
		parse_options_usage(stat_usage, stat_options, "G", 1);
		parse_options_usage(NULL, stat_options, "A", 1);
		parse_options_usage(NULL, stat_options, "a", 1);
2906
		goto out;
2907 2908
	}

2909 2910
	if (add_default_attributes())
		goto out;
2911

2912
	target__validate(&target);
2913

2914 2915 2916
	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
		target.per_thread = true;

2917
	if (perf_evlist__create_maps(evsel_list, &target) < 0) {
2918
		if (target__has_task(&target)) {
2919
			pr_err("Problems finding threads of monitor\n");
2920 2921
			parse_options_usage(stat_usage, stat_options, "p", 1);
			parse_options_usage(NULL, stat_options, "t", 1);
2922
		} else if (target__has_cpu(&target)) {
2923
			perror("failed to parse CPUs map");
2924 2925
			parse_options_usage(stat_usage, stat_options, "C", 1);
			parse_options_usage(NULL, stat_options, "a", 1);
2926 2927
		}
		goto out;
2928
	}
2929 2930 2931 2932 2933

	/*
	 * Initialize thread_map with comm names,
	 * so we could print it out on output.
	 */
2934
	if (stat_config.aggr_mode == AGGR_THREAD) {
2935
		thread_map__read_comms(evsel_list->threads);
2936 2937 2938 2939 2940 2941 2942
		if (target.system_wide) {
			if (runtime_stat_new(&stat_config,
				thread_map__nr(evsel_list->threads))) {
				goto out;
			}
		}
	}
2943

2944 2945 2946 2947 2948 2949 2950 2951 2952
	if (stat_config.times && interval)
		interval_count = true;
	else if (stat_config.times && !interval) {
		pr_err("interval-count option should be used together with "
				"interval-print.\n");
		parse_options_usage(stat_usage, stat_options, "interval-count", 0);
		parse_options_usage(stat_usage, stat_options, "I", 1);
		goto out;
	}
2953

2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970
	if (timeout && timeout < 100) {
		if (timeout < 10) {
			pr_err("timeout must be >= 10ms.\n");
			parse_options_usage(stat_usage, stat_options, "timeout", 0);
			goto out;
		} else
			pr_warning("timeout < 100ms. "
				   "The overhead percentage could be high in some cases. "
				   "Please proceed with caution.\n");
	}
	if (timeout && interval) {
		pr_err("timeout option is not supported with interval-print.\n");
		parse_options_usage(stat_usage, stat_options, "timeout", 0);
		parse_options_usage(stat_usage, stat_options, "I", 1);
		goto out;
	}

2971
	if (perf_evlist__alloc_stats(evsel_list, interval))
2972
		goto out;
2973

2974
	if (perf_stat_init_aggr_mode())
2975
		goto out;
2976

2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
	/*
	 * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
	 * while avoiding that older tools show confusing messages.
	 *
	 * However for pipe sessions we need to keep it zero,
	 * because script's perf_evsel__check_attr is triggered
	 * by attr->sample_type != 0, and we can't run it on
	 * stat sessions.
	 */
	stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe);

Ingo Molnar's avatar
Ingo Molnar committed
2988 2989 2990 2991 2992 2993
	/*
	 * We dont want to block the signals - that would cause
	 * child tasks to inherit that and Ctrl-C would not work.
	 * What we want is for Ctrl-C to work in the exec()-ed
	 * task, but being ignored by perf stat itself:
	 */
2994
	atexit(sig_atexit);
2995 2996
	if (!forever)
		signal(SIGINT,  skip_signal);
2997
	signal(SIGCHLD, skip_signal);
Ingo Molnar's avatar
Ingo Molnar committed
2998 2999 3000
	signal(SIGALRM, skip_signal);
	signal(SIGABRT, skip_signal);

3001
	status = 0;
3002
	for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
3003
		if (run_count != 1 && verbose > 0)
3004 3005
			fprintf(output, "[ perf stat: executing run #%d ... ]\n",
				run_idx + 1);
3006

3007
		status = run_perf_stat(argc, argv, run_idx);
3008
		if (forever && status != -1) {
3009
			print_counters(NULL, argc, argv);
3010
			perf_stat__reset_stats();
3011
		}
3012 3013
	}

3014
	if (!forever && status != -1 && !interval)
3015
		print_counters(NULL, argc, argv);
3016

3017 3018 3019 3020 3021 3022 3023 3024
	if (STAT_RECORD) {
		/*
		 * We synthesize the kernel mmap record just so that older tools
		 * don't emit warnings about not being able to resolve symbols
		 * due to /proc/sys/kernel/kptr_restrict settings and instear provide
		 * a saner message about no samples being in the perf.data file.
		 *
		 * This also serves to suppress a warning about f_header.data.size == 0
3025 3026 3027 3028
		 * in header.c at the moment 'perf stat record' gets introduced, which
		 * is not really needed once we start adding the stat specific PERF_RECORD_
		 * records, but the need to suppress the kptr_restrict messages in older
		 * tools remain  -acme
3029
		 */
3030
		int fd = perf_data__fd(&perf_stat.data);
3031 3032 3033 3034 3035 3036 3037 3038
		int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat,
							     process_synthesized_event,
							     &perf_stat.session->machines.host);
		if (err) {
			pr_warning("Couldn't synthesize the kernel mmap record, harmless, "
				   "older tools may produce warnings about this file\n.");
		}

3039 3040 3041 3042 3043
		if (!interval) {
			if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL))
				pr_err("failed to write stat round event\n");
		}

3044
		if (!perf_stat.data.is_pipe) {
3045 3046 3047
			perf_stat.session->header.data_size += perf_stat.bytes_written;
			perf_session__write_header(perf_stat.session, evsel_list, fd, true);
		}
3048 3049 3050 3051

		perf_session__delete(perf_stat.session);
	}

3052
	perf_stat__exit_aggr_mode();
3053
	perf_evlist__free_stats(evsel_list);
3054
out:
3055 3056
	free(walltime_run);

3057 3058 3059
	if (smi_cost && smi_reset)
		sysfs__write_int(FREEZE_ON_SMI_PATH, 0);

3060
	perf_evlist__delete(evsel_list);
3061 3062 3063

	runtime_stat_delete(&stat_config);

3064
	return status;
3065
}