builtin-stat.c 63.5 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"
J
Jiri Olsa 已提交
64
#include "util/session.h"
J
Jiri Olsa 已提交
65
#include "util/tool.h"
66
#include "util/group.h"
J
Jiri Olsa 已提交
67
#include "asm/bug.h"
68

69
#include <linux/time64.h>
70
#include <api/fs/fs.h>
71
#include <stdlib.h>
72
#include <sys/prctl.h>
73
#include <locale.h>
74
#include <math.h>
75

S
Stephane Eranian 已提交
76
#define DEFAULT_SEPARATOR	" "
77 78
#define CNTR_NOT_SUPPORTED	"<not supported>"
#define CNTR_NOT_COUNTED	"<not counted>"
S
Stephane Eranian 已提交
79

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

82
/* Default events used for perf stat -T */
83 84
static const char *transaction_attrs = {
	"task-clock,"
85 86 87 88 89 90 91 92 93 94 95
	"{"
	"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. */
96 97
static const char * transaction_limited_attrs = {
	"task-clock,"
98 99 100 101 102 103 104 105
	"{"
	"instructions,"
	"cycles,"
	"cpu/cycles-t/,"
	"cpu/tx-start/"
	"}"
};

106 107 108 109 110 111 112 113 114
static const char * topdown_attrs[] = {
	"topdown-total-slots",
	"topdown-slots-retired",
	"topdown-recovery-bubbles",
	"topdown-fetch-bubbles",
	"topdown-slots-issued",
	NULL,
};

115
static struct perf_evlist	*evsel_list;
116

117
static struct target target = {
118 119
	.uid	= UINT_MAX,
};
120

121 122
typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);

123
static int			run_count			=  1;
124
static bool			no_inherit			= false;
125
static volatile pid_t		child_pid			= -1;
126
static bool			null_run			=  false;
127
static int			detailed_run			=  0;
128
static bool			transaction_run;
129
static bool			topdown_run			= false;
130
static bool			big_num				=  true;
S
Stephane Eranian 已提交
131 132 133
static int			big_num_opt			=  -1;
static const char		*csv_sep			= NULL;
static bool			csv_output			= false;
134
static bool			group				= false;
135 136 137
static const char		*pre_cmd			= NULL;
static const char		*post_cmd			= NULL;
static bool			sync_run			= false;
138
static unsigned int		initial_delay			= 0;
139
static unsigned int		unit_width			= 4; /* strlen("unit") */
140
static bool			forever				= false;
141
static bool			metric_only			= false;
142
static bool			force_metric_only		= false;
143
static struct timespec		ref_time;
144
static struct cpu_map		*aggr_map;
145
static aggr_get_id_t		aggr_get_id;
J
Jiri Olsa 已提交
146 147 148
static bool			append_file;
static const char		*output_name;
static int			output_fd;
149

J
Jiri Olsa 已提交
150 151 152 153 154
struct perf_stat {
	bool			 record;
	struct perf_data_file	 file;
	struct perf_session	*session;
	u64			 bytes_written;
J
Jiri Olsa 已提交
155
	struct perf_tool	 tool;
156 157 158
	bool			 maps_allocated;
	struct cpu_map		*cpus;
	struct thread_map	*threads;
159
	enum aggr_mode		 aggr_mode;
J
Jiri Olsa 已提交
160 161 162 163 164
};

static struct perf_stat		perf_stat;
#define STAT_RECORD		perf_stat.record

165 166
static volatile int done = 0;

167 168
static struct perf_stat_config stat_config = {
	.aggr_mode	= AGGR_GLOBAL,
169
	.scale		= true,
170 171
};

172 173 174 175 176
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) {
177
		r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec;
178 179 180 181 182 183
		r->tv_sec--;
	} else {
		r->tv_nsec = a->tv_nsec - b->tv_nsec ;
	}
}

184 185 186
static void perf_stat__reset_stats(void)
{
	perf_evlist__reset_stats(evsel_list);
187
	perf_stat__reset_shadow_stats();
188 189
}

190
static int create_perf_stat_counter(struct perf_evsel *evsel)
191
{
192
	struct perf_event_attr *attr = &evsel->attr;
193

194
	if (stat_config.scale)
195 196
		attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
				    PERF_FORMAT_TOTAL_TIME_RUNNING;
197

198 199
	attr->inherit = !no_inherit;

200 201 202 203 204
	/*
	 * Some events get initialized with sample_(period/type) set,
	 * like tracepoints. Clear it up for counting.
	 */
	attr->sample_period = 0;
205

J
Jiri Olsa 已提交
206 207 208
	/*
	 * But set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
	 * while avoiding that older tools show confusing messages.
209 210 211 212 213
	 *
	 * 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.
J
Jiri Olsa 已提交
214
	 */
215 216
	if (!(STAT_RECORD && perf_stat.file.is_pipe))
		attr->sample_type = PERF_SAMPLE_IDENTIFIER;
217

J
Jiri Olsa 已提交
218 219 220 221 222
	/*
	 * Disabling all counters initially, they will be enabled
	 * either manually by us or by kernel via enable_on_exec
	 * set later.
	 */
223
	if (perf_evsel__is_group_leader(evsel)) {
J
Jiri Olsa 已提交
224 225
		attr->disabled = 1;

226 227 228 229 230
		/*
		 * In case of initial_delay we enable tracee
		 * events manually.
		 */
		if (target__none(&target) && !initial_delay)
231
			attr->enable_on_exec = 1;
232
	}
233

234 235 236
	if (target__has_cpu(&target))
		return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));

237
	return perf_evsel__open_per_thread(evsel, evsel_list->threads);
238 239
}

240 241 242
/*
 * Does the counter have nsecs as a unit?
 */
243
static inline int nsec_counter(struct perf_evsel *evsel)
244
{
245 246
	if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
	    perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
247 248 249 250 251
		return 1;

	return 0;
}

252 253 254 255
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)
J
Jiri Olsa 已提交
256
{
257
	if (perf_data_file__write(&perf_stat.file, event, event->header.size) < 0) {
J
Jiri Olsa 已提交
258 259 260 261
		pr_err("failed to write perf data, error: %m\n");
		return -1;
	}

262
	perf_stat.bytes_written += event->header.size;
J
Jiri Olsa 已提交
263 264 265
	return 0;
}

266
static int write_stat_round_event(u64 tm, u64 type)
267
{
268
	return perf_event__synthesize_stat_round(NULL, tm, type,
269 270 271 272 273 274 275
						 process_synthesized_event,
						 NULL);
}

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

276 277 278 279 280 281 282 283 284 285 286 287
#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);
}

288 289 290 291
/*
 * Read out the results of a single counter:
 * do not aggregate counts across CPUs in system-wide mode
 */
292
static int read_counter(struct perf_evsel *counter)
293
{
294
	int nthreads = thread_map__nr(evsel_list->threads);
295 296 297 298 299 300
	int ncpus, cpu, thread;

	if (target__has_cpu(&target))
		ncpus = perf_evsel__nr_cpus(counter);
	else
		ncpus = 1;
301

302 303 304
	if (!counter->supported)
		return -ENOENT;

305 306 307 308 309
	if (counter->system_wide)
		nthreads = 1;

	for (thread = 0; thread < nthreads; thread++) {
		for (cpu = 0; cpu < ncpus; cpu++) {
310 311 312 313
			struct perf_counts_values *count;

			count = perf_counts(counter->counts, cpu, thread);
			if (perf_evsel__read(counter, cpu, thread, count))
314
				return -1;
315 316 317 318 319 320 321

			if (STAT_RECORD) {
				if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
					pr_err("failed to write stat event\n");
					return -1;
				}
			}
322 323 324 325 326 327 328 329

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

	return 0;
334 335
}

336
static void read_counters(void)
337 338 339
{
	struct perf_evsel *counter;

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

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

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

353
	read_counters();
354

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

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

363
	print_counters(&rs, 0, NULL);
364 365
}

J
Jiri Olsa 已提交
366
static void enable_counters(void)
367
{
J
Jiri Olsa 已提交
368
	if (initial_delay)
369
		usleep(initial_delay * USEC_PER_MSEC);
J
Jiri Olsa 已提交
370 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
	 */
	if (!target__none(&target) || initial_delay)
377
		perf_evlist__enable(evsel_list);
378 379
}

380 381 382 383 384 385 386 387 388 389 390
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);
}

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

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

404 405 406 407 408 409 410 411 412 413
static bool has_unit(struct perf_evsel *counter)
{
	return counter->unit && *counter->unit;
}

static bool has_scale(struct perf_evsel *counter)
{
	return counter->scale != 1;
}

414
static int perf_stat_synthesize_config(bool is_pipe)
415
{
416
	struct perf_evsel *counter;
417 418
	int err;

419 420 421 422 423 424 425 426 427
	if (is_pipe) {
		err = perf_event__synthesize_attrs(NULL, perf_stat.session,
						   process_synthesized_event);
		if (err < 0) {
			pr_err("Couldn't synthesize attrs.\n");
			return err;
		}
	}

428 429 430 431
	/*
	 * Synthesize other events stuff not carried within
	 * attr event - unit, scale, name
	 */
432
	evlist__for_each_entry(evsel_list, counter) {
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
		if (!counter->supported)
			continue;

		/*
		 * Synthesize unit and scale only if it's defined.
		 */
		if (has_unit(counter)) {
			err = perf_event__synthesize_event_update_unit(NULL, counter, process_synthesized_event);
			if (err < 0) {
				pr_err("Couldn't synthesize evsel unit.\n");
				return err;
			}
		}

		if (has_scale(counter)) {
			err = perf_event__synthesize_event_update_scale(NULL, counter, process_synthesized_event);
			if (err < 0) {
				pr_err("Couldn't synthesize evsel scale.\n");
				return err;
			}
		}

		if (counter->own_cpus) {
			err = perf_event__synthesize_event_update_cpus(NULL, counter, process_synthesized_event);
			if (err < 0) {
				pr_err("Couldn't synthesize evsel scale.\n");
				return err;
			}
		}

		/*
		 * Name is needed only for pipe output,
		 * perf.data carries event names.
		 */
		if (is_pipe) {
			err = perf_event__synthesize_event_update_name(NULL, counter, process_synthesized_event);
			if (err < 0) {
				pr_err("Couldn't synthesize evsel name.\n");
				return err;
			}
		}
	}

476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
	err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads,
						process_synthesized_event,
						NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize thread map.\n");
		return err;
	}

	err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus,
					     process_synthesized_event, NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize thread map.\n");
		return err;
	}

	err = perf_event__synthesize_stat_config(NULL, &stat_config,
						 process_synthesized_event, NULL);
	if (err < 0) {
		pr_err("Couldn't synthesize config.\n");
		return err;
	}

	return 0;
}

501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))

static int __store_counter_ids(struct perf_evsel *counter,
			       struct cpu_map *cpus,
			       struct thread_map *threads)
{
	int cpu, thread;

	for (cpu = 0; cpu < cpus->nr; cpu++) {
		for (thread = 0; thread < threads->nr; thread++) {
			int fd = FD(counter, cpu, thread);

			if (perf_evlist__id_add_fd(evsel_list, counter,
						   cpu, thread, fd) < 0)
				return -1;
		}
	}

	return 0;
}

static int store_counter_ids(struct perf_evsel *counter)
{
	struct cpu_map *cpus = counter->cpus;
	struct thread_map *threads = counter->threads;

	if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr))
		return -ENOMEM;

	return __store_counter_ids(counter, cpus, threads);
}

533
static int __run_perf_stat(int argc, const char **argv)
534
{
535
	int interval = stat_config.interval;
536
	char msg[BUFSIZ];
537
	unsigned long long t0, t1;
538
	struct perf_evsel *counter;
539
	struct timespec ts;
540
	size_t l;
541
	int status = 0;
542
	const bool forks = (argc > 0);
543
	bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false;
544
	struct perf_evsel_config_term *err_term;
545

546
	if (interval) {
547 548
		ts.tv_sec  = interval / USEC_PER_MSEC;
		ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC;
549 550 551 552 553
	} else {
		ts.tv_sec  = 1;
		ts.tv_nsec = 0;
	}

554
	if (forks) {
555
		if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe,
556
						  workload_exec_failed_signal) < 0) {
557 558
			perror("failed to prepare workload");
			return -1;
559
		}
560
		child_pid = evsel_list->workload.pid;
561 562
	}

563
	if (group)
564
		perf_evlist__set_leader(evsel_list);
565

566
	evlist__for_each_entry(evsel_list, counter) {
567
try_again:
568
		if (create_perf_stat_counter(counter) < 0) {
569 570 571 572
			/*
			 * PPC returns ENXIO for HW counters until 2.6.37
			 * (behavior changed with commit b0a873e).
			 */
573
			if (errno == EINVAL || errno == ENOSYS ||
574 575
			    errno == ENOENT || errno == EOPNOTSUPP ||
			    errno == ENXIO) {
576 577
				if (verbose)
					ui__warning("%s event is not supported by the kernel.\n",
578
						    perf_evsel__name(counter));
579
				counter->supported = false;
580 581 582 583

				if ((counter->leader != counter) ||
				    !(counter->leader->nr_members > 1))
					continue;
584 585 586 587 588
			} else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
                                if (verbose)
                                        ui__warning("%s\n", msg);
                                goto try_again;
                        }
589

590 591 592 593
			perf_evsel__open_strerror(counter, &target,
						  errno, msg, sizeof(msg));
			ui__error("%s\n", msg);

594 595
			if (child_pid != -1)
				kill(child_pid, SIGTERM);
596

597 598
			return -1;
		}
599
		counter->supported = true;
600 601 602 603

		l = strlen(counter->unit);
		if (l > unit_width)
			unit_width = l;
604 605 606

		if (STAT_RECORD && store_counter_ids(counter))
			return -1;
607
	}
608

609 610 611
	if (perf_evlist__apply_filters(evsel_list, &counter)) {
		error("failed to set filter \"%s\" on event %s with %d (%s)\n",
			counter->filter, perf_evsel__name(counter), errno,
612
			str_error_r(errno, msg, sizeof(msg)));
613 614 615
		return -1;
	}

616 617 618 619 620 621 622
	if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) {
		error("failed to set config \"%s\" on event %s with %d (%s)\n",
		      err_term->val.drv_cfg, perf_evsel__name(counter), errno,
		      str_error_r(errno, msg, sizeof(msg)));
		return -1;
	}

J
Jiri Olsa 已提交
623 624 625
	if (STAT_RECORD) {
		int err, fd = perf_data_file__fd(&perf_stat.file);

626 627 628 629 630 631 632
		if (is_pipe) {
			err = perf_header__write_pipe(perf_data_file__fd(&perf_stat.file));
		} else {
			err = perf_session__write_header(perf_stat.session, evsel_list,
							 fd, false);
		}

J
Jiri Olsa 已提交
633 634
		if (err < 0)
			return err;
635

636
		err = perf_stat_synthesize_config(is_pipe);
637 638
		if (err < 0)
			return err;
J
Jiri Olsa 已提交
639 640
	}

641 642 643 644
	/*
	 * Enable counters and exec the command:
	 */
	t0 = rdclock();
645
	clock_gettime(CLOCK_MONOTONIC, &ref_time);
646

647
	if (forks) {
648
		perf_evlist__start_workload(evsel_list);
J
Jiri Olsa 已提交
649
		enable_counters();
650

651 652 653
		if (interval) {
			while (!waitpid(child_pid, &status, WNOHANG)) {
				nanosleep(&ts, NULL);
654
				process_interval();
655 656
			}
		}
657
		wait(&status);
658

659
		if (workload_exec_errno) {
660
			const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
661
			pr_err("Workload failed: %s\n", emsg);
662
			return -1;
663
		}
664

665 666
		if (WIFSIGNALED(status))
			psignal(WTERMSIG(status), argv[0]);
667
	} else {
J
Jiri Olsa 已提交
668
		enable_counters();
669 670 671
		while (!done) {
			nanosleep(&ts, NULL);
			if (interval)
672
				process_interval();
673
		}
674
	}
675

676 677
	disable_counters();

678 679
	t1 = rdclock();

680
	update_stats(&walltime_nsecs_stats, t1 - t0);
681

682 683 684 685 686 687 688 689
	/*
	 * 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);
690

691 692 693
	return WEXITSTATUS(status);
}

694
static int run_perf_stat(int argc, const char **argv)
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
{
	int ret;

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

	if (sync_run)
		sync();

	ret = __run_perf_stat(argc, argv);
	if (ret)
		return ret;

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

	return ret;
}

720 721 722
static void print_running(u64 run, u64 ena)
{
	if (csv_output) {
723
		fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f",
724 725 726 727 728
					csv_sep,
					run,
					csv_sep,
					ena ? 100.0 * run / ena : 100.0);
	} else if (run != ena) {
729
		fprintf(stat_config.output, "  (%.2f%%)", 100.0 * run / ena);
730 731 732
	}
}

733 734
static void print_noise_pct(double total, double avg)
{
735
	double pct = rel_stddev_stats(total, avg);
736

737
	if (csv_output)
738
		fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct);
739
	else if (pct)
740
		fprintf(stat_config.output, "  ( +-%6.2f%% )", pct);
741 742
}

743
static void print_noise(struct perf_evsel *evsel, double avg)
744
{
745
	struct perf_stat_evsel *ps;
746

747 748 749
	if (run_count == 1)
		return;

750
	ps = evsel->priv;
751
	print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
752 753
}

754
static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
I
Ingo Molnar 已提交
755
{
756
	switch (stat_config.aggr_mode) {
757
	case AGGR_CORE:
758
		fprintf(stat_config.output, "S%d-C%*d%s%*d%s",
759 760 761 762 763 764 765 766
			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;
767
	case AGGR_SOCKET:
768
		fprintf(stat_config.output, "S%*d%s%*d%s",
769
			csv_output ? 0 : -5,
770
			id,
771 772 773 774
			csv_sep,
			csv_output ? 0 : 4,
			nr,
			csv_sep);
775 776
			break;
	case AGGR_NONE:
777
		fprintf(stat_config.output, "CPU%*d%s",
S
Stephane Eranian 已提交
778
			csv_output ? 0 : -4,
779
			perf_evsel__cpus(evsel)->map[id], csv_sep);
780
		break;
781
	case AGGR_THREAD:
782
		fprintf(stat_config.output, "%*s-%*d%s",
783 784 785 786 787 788
			csv_output ? 0 : 16,
			thread_map__comm(evsel->threads, id),
			csv_output ? 0 : -8,
			thread_map__pid(evsel->threads, id),
			csv_sep);
		break;
789
	case AGGR_GLOBAL:
J
Jiri Olsa 已提交
790
	case AGGR_UNSET:
791 792 793 794 795
	default:
		break;
	}
}

796 797 798
struct outstate {
	FILE *fh;
	bool newline;
799
	const char *prefix;
800
	int  nfields;
801 802
	int  id, nr;
	struct perf_evsel *evsel;
803 804 805 806 807 808 809 810 811 812 813 814 815 816
};

#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);
817
	fputs(os->prefix, os->fh);
818
	aggr_printout(os->evsel, os->id, os->nr);
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
	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);
}

850 851 852 853 854 855 856 857
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);
858
	aggr_printout(os->evsel, os->id, os->nr);
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
	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) {
		fprintf(out, "%s%s%s%s", csv_sep, csv_sep, csv_sep, csv_sep);
		return;
	}
	snprintf(buf, sizeof(buf), fmt, val);
	vals = buf;
	while (isspace(*vals))
		vals++;
	ends = vals;
	while (isdigit(*ends) || *ends == '.')
		ends++;
	*ends = 0;
	while (isspace(*unit))
		unit++;
	fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit);
}

888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
#define METRIC_ONLY_LEN 20

/* 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;
	int n;
	char buf[1024];
	unsigned mlen = METRIC_ONLY_LEN;

	if (!valid_only_metric(unit))
		return;
	unit = fixunit(buf, os->evsel, unit);
	if (color)
		n = color_fprintf(out, color, fmt, val);
	else
		n = fprintf(out, fmt, val);
	if (n > METRIC_ONLY_LEN)
		n = METRIC_ONLY_LEN;
	if (mlen < strlen(unit))
		mlen = strlen(unit) + 1;
	fprintf(out, "%*s", mlen - n, "");
}

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);
	vals = buf;
	while (isspace(*vals))
		vals++;
	ends = vals;
	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
		fprintf(os->fh, "%-*s ", METRIC_ONLY_LEN, unit);
}

981
static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
982
{
983
	FILE *output = stat_config.output;
984
	double msecs = avg / NSEC_PER_MSEC;
985
	const char *fmt_v, *fmt_n;
986
	char name[25];
987

988 989 990
	fmt_v = csv_output ? "%.6f%s" : "%18.6f%s";
	fmt_n = csv_output ? "%s" : "%-25s";

991
	aggr_printout(evsel, id, nr);
S
Stephane Eranian 已提交
992

993 994
	scnprintf(name, sizeof(name), "%s%s",
		  perf_evsel__name(evsel), csv_output ? "" : " (msec)");
995 996 997 998 999 1000 1001 1002 1003

	fprintf(output, fmt_v, msecs, csv_sep);

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

	fprintf(output, fmt_n, name);
S
Stephane Eranian 已提交
1004

S
Stephane Eranian 已提交
1005
	if (evsel->cgrp)
1006
		fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
I
Ingo Molnar 已提交
1007 1008
}

1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
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;
}

1031 1032
static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
{
1033
	FILE *output = stat_config.output;
1034 1035 1036 1037
	double sc =  evsel->scale;
	const char *fmt;

	if (csv_output) {
1038
		fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
1039 1040
	} else {
		if (big_num)
1041
			fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
1042
		else
1043
			fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
	}

	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);
1059
}
1060

1061
static void printout(int id, int nr, struct perf_evsel *counter, double uval,
1062
		     char *prefix, u64 run, u64 ena, double noise)
1063
{
1064
	struct perf_stat_output_ctx out;
1065 1066
	struct outstate os = {
		.fh = stat_config.output,
1067 1068 1069 1070
		.prefix = prefix ? prefix : "",
		.id = id,
		.nr = nr,
		.evsel = counter,
1071
	};
1072 1073
	print_metric_t pm = print_metric_std;
	void (*nl)(void *);
1074

1075 1076 1077 1078 1079 1080 1081 1082
	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;
1083

1084
	if (csv_output && !metric_only) {
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
		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++;
	}
1100
	if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
1101 1102 1103 1104
		if (metric_only) {
			pm(&os, NULL, "", "", 0);
			return;
		}
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
		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);

		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);

1124 1125 1126
		if (!csv_output)
			pm(&os, NULL, NULL, "", 0);
		print_noise(counter, noise);
1127
		print_running(run, ena);
1128 1129
		if (csv_output)
			pm(&os, NULL, NULL, "", 0);
1130 1131 1132
		return;
	}

1133 1134 1135
	if (metric_only)
		/* nothing */;
	else if (nsec_counter(counter))
1136 1137 1138
		nsec_printout(id, nr, counter, uval);
	else
		abs_printout(id, nr, counter, uval);
1139

1140 1141 1142 1143
	out.print_metric = pm;
	out.new_line = nl;
	out.ctx = &os;

1144
	if (csv_output && !metric_only) {
1145 1146 1147 1148 1149
		print_noise(counter, noise);
		print_running(run, ena);
	}

	perf_stat__print_shadow_stats(counter, uval,
1150
				first_shadow_cpu(counter, id),
1151
				&out);
1152
	if (!csv_output && !metric_only) {
1153 1154 1155
		print_noise(counter, noise);
		print_running(run, ena);
	}
1156 1157
}

1158 1159 1160 1161 1162 1163 1164 1165
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];
1166
		evlist__for_each_entry(evsel_list, counter) {
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
			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;
			}
			val = val * counter->scale;
			perf_stat__update_shadow_stats(counter, &val,
						       first_shadow_cpu(counter, id));
		}
	}
}

1181
static void print_aggr(char *prefix)
1182
{
1183
	FILE *output = stat_config.output;
1184
	struct perf_evsel *counter;
1185
	int cpu, s, s2, id, nr;
1186
	double uval;
1187
	u64 ena, run, val;
1188
	bool first;
1189

1190
	if (!(aggr_map || aggr_get_id))
1191 1192
		return;

1193 1194
	aggr_update_shadow();

1195 1196 1197 1198
	/*
	 * With metric_only everything is on a single line.
	 * Without each counter has its own line.
	 */
1199
	for (s = 0; s < aggr_map->nr; s++) {
1200 1201 1202
		if (prefix && metric_only)
			fprintf(output, "%s", prefix);

1203
		id = aggr_map->map[s];
1204
		first = true;
1205
		evlist__for_each_entry(evsel_list, counter) {
1206 1207 1208
			val = ena = run = 0;
			nr = 0;
			for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
1209
				s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
1210
				if (s2 != id)
1211
					continue;
1212 1213 1214
				val += perf_counts(counter->counts, cpu, 0)->val;
				ena += perf_counts(counter->counts, cpu, 0)->ena;
				run += perf_counts(counter->counts, cpu, 0)->run;
1215 1216
				nr++;
			}
1217 1218 1219 1220 1221
			if (first && metric_only) {
				first = false;
				aggr_printout(counter, id, nr);
			}
			if (prefix && !metric_only)
1222 1223
				fprintf(output, "%s", prefix);

1224
			uval = val * counter->scale;
1225
			printout(id, nr, counter, uval, prefix, run, ena, 1.0);
1226 1227
			if (!metric_only)
				fputc('\n', output);
1228
		}
1229 1230
		if (metric_only)
			fputc('\n', output);
1231 1232 1233
	}
}

1234 1235
static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
{
1236
	FILE *output = stat_config.output;
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
	int nthreads = thread_map__nr(counter->threads);
	int ncpus = cpu_map__nr(counter->cpus);
	int cpu, thread;
	double uval;

	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;
		}

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

		uval = val * counter->scale;
1255
		printout(thread, 0, counter, uval, prefix, run, ena, 1.0);
1256 1257 1258 1259
		fputc('\n', output);
	}
}

1260 1261
/*
 * Print out the results of a single counter:
1262
 * aggregated counts in system-wide mode
1263
 */
1264
static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
1265
{
1266
	FILE *output = stat_config.output;
1267
	struct perf_stat_evsel *ps = counter->priv;
1268
	double avg = avg_stats(&ps->res_stats[0]);
1269
	double uval;
1270 1271 1272 1273
	double avg_enabled, avg_running;

	avg_enabled = avg_stats(&ps->res_stats[1]);
	avg_running = avg_stats(&ps->res_stats[2]);
1274

1275
	if (prefix && !metric_only)
1276 1277
		fprintf(output, "%s", prefix);

1278
	uval = avg * counter->scale;
1279
	printout(-1, 0, counter, uval, prefix, avg_running, avg_enabled, avg);
1280 1281
	if (!metric_only)
		fprintf(output, "\n");
1282 1283
}

1284 1285 1286 1287
/*
 * Print out the results of a single counter:
 * does not use aggregated count in system-wide
 */
1288
static void print_counter(struct perf_evsel *counter, char *prefix)
1289
{
1290
	FILE *output = stat_config.output;
1291
	u64 ena, run, val;
1292
	double uval;
1293 1294
	int cpu;

Y
Yan, Zheng 已提交
1295
	for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
1296 1297 1298
		val = perf_counts(counter->counts, cpu, 0)->val;
		ena = perf_counts(counter->counts, cpu, 0)->ena;
		run = perf_counts(counter->counts, cpu, 0)->run;
1299 1300 1301 1302

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

1303
		uval = val * counter->scale;
1304
		printout(cpu, 0, counter, uval, prefix, run, ena, 1.0);
1305

1306
		fputc('\n', output);
1307 1308 1309
	}
}

1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
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);
1324
		evlist__for_each_entry(evsel_list, counter) {
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
			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;
			printout(cpu, 0, counter, uval, prefix, run, ena, 1.0);
		}
		fputc('\n', stat_config.output);
	}
}

1340 1341 1342
static int aggr_header_lens[] = {
	[AGGR_CORE] = 18,
	[AGGR_SOCKET] = 12,
1343
	[AGGR_NONE] = 6,
1344 1345 1346 1347
	[AGGR_THREAD] = 24,
	[AGGR_GLOBAL] = 0,
};

1348 1349 1350 1351 1352 1353 1354 1355
static const char *aggr_header_csv[] = {
	[AGGR_CORE] 	= 	"core,cpus,",
	[AGGR_SOCKET] 	= 	"socket,cpus",
	[AGGR_NONE] 	= 	"cpu,",
	[AGGR_THREAD] 	= 	"comm-pid,",
	[AGGR_GLOBAL] 	=	""
};

1356
static void print_metric_headers(const char *prefix, bool no_indent)
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
{
	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);

1367
	if (!csv_output && !no_indent)
1368 1369
		fprintf(stat_config.output, "%*s",
			aggr_header_lens[stat_config.aggr_mode], "");
1370 1371 1372 1373 1374 1375
	if (csv_output) {
		if (stat_config.interval)
			fputs("time,", stat_config.output);
		fputs(aggr_header_csv[stat_config.aggr_mode],
			stat_config.output);
	}
1376 1377

	/* Print metrics headers only */
1378
	evlist__for_each_entry(evsel_list, counter) {
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
		os.evsel = counter;
		out.ctx = &os;
		out.print_metric = print_metric_header;
		out.new_line = new_line_metric;
		os.evsel = counter;
		perf_stat__print_shadow_stats(counter, 0,
					      0,
					      &out);
	}
	fputc('\n', stat_config.output);
}

1391 1392
static void print_interval(char *prefix, struct timespec *ts)
{
1393
	FILE *output = stat_config.output;
1394 1395 1396 1397
	static int num_print_interval;

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

1398
	if (num_print_interval == 0 && !csv_output) {
1399
		switch (stat_config.aggr_mode) {
1400
		case AGGR_SOCKET:
1401 1402 1403
			fprintf(output, "#           time socket cpus");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
1404 1405
			break;
		case AGGR_CORE:
1406 1407 1408
			fprintf(output, "#           time core         cpus");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
1409 1410
			break;
		case AGGR_NONE:
1411 1412 1413
			fprintf(output, "#           time CPU");
			if (!metric_only)
				fprintf(output, "                counts %*s events\n", unit_width, "unit");
1414
			break;
1415
		case AGGR_THREAD:
1416 1417 1418
			fprintf(output, "#           time             comm-pid");
			if (!metric_only)
				fprintf(output, "                  counts %*s events\n", unit_width, "unit");
1419
			break;
1420 1421
		case AGGR_GLOBAL:
		default:
1422 1423 1424
			fprintf(output, "#           time");
			if (!metric_only)
				fprintf(output, "             counts %*s events\n", unit_width, "unit");
J
Jiri Olsa 已提交
1425 1426
		case AGGR_UNSET:
			break;
1427 1428 1429
		}
	}

1430 1431
	if (num_print_interval == 0 && metric_only)
		print_metric_headers(" ", true);
1432 1433 1434 1435 1436
	if (++num_print_interval == 25)
		num_print_interval = 0;
}

static void print_header(int argc, const char **argv)
1437
{
1438
	FILE *output = stat_config.output;
1439
	int i;
1440

1441 1442
	fflush(stdout);

S
Stephane Eranian 已提交
1443
	if (!csv_output) {
1444 1445
		fprintf(output, "\n");
		fprintf(output, " Performance counter stats for ");
1446 1447 1448 1449
		if (target.system_wide)
			fprintf(output, "\'system wide");
		else if (target.cpu_list)
			fprintf(output, "\'CPU(s) %s", target.cpu_list);
1450
		else if (!target__has_task(&target)) {
J
Jiri Olsa 已提交
1451 1452
			fprintf(output, "\'%s", argv ? argv[0] : "pipe");
			for (i = 1; argv && (i < argc); i++)
1453
				fprintf(output, " %s", argv[i]);
1454 1455
		} else if (target.pid)
			fprintf(output, "process id \'%s", target.pid);
S
Stephane Eranian 已提交
1456
		else
1457
			fprintf(output, "thread id \'%s", target.tid);
I
Ingo Molnar 已提交
1458

1459
		fprintf(output, "\'");
S
Stephane Eranian 已提交
1460
		if (run_count > 1)
1461 1462
			fprintf(output, " (%d runs)", run_count);
		fprintf(output, ":\n\n");
S
Stephane Eranian 已提交
1463
	}
1464 1465 1466 1467
}

static void print_footer(void)
{
1468 1469
	FILE *output = stat_config.output;

1470 1471 1472
	if (!null_run)
		fprintf(output, "\n");
	fprintf(output, " %17.9f seconds time elapsed",
1473
			avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC);
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	if (run_count > 1) {
		fprintf(output, "                                        ");
		print_noise_pct(stddev_stats(&walltime_nsecs_stats),
				avg_stats(&walltime_nsecs_stats));
	}
	fprintf(output, "\n\n");
}

static void print_counters(struct timespec *ts, int argc, const char **argv)
{
1484
	int interval = stat_config.interval;
1485 1486 1487
	struct perf_evsel *counter;
	char buf[64], *prefix = NULL;

1488 1489 1490 1491
	/* Do not print anything if we record to the pipe. */
	if (STAT_RECORD && perf_stat.file.is_pipe)
		return;

1492 1493 1494 1495
	if (interval)
		print_interval(prefix = buf, ts);
	else
		print_header(argc, argv);
1496

1497 1498 1499
	if (metric_only) {
		static int num_print_iv;

1500 1501
		if (num_print_iv == 0 && !interval)
			print_metric_headers(prefix, false);
1502 1503 1504 1505 1506 1507
		if (num_print_iv++ == 25)
			num_print_iv = 0;
		if (stat_config.aggr_mode == AGGR_GLOBAL && prefix)
			fprintf(stat_config.output, "%s", prefix);
	}

1508
	switch (stat_config.aggr_mode) {
1509
	case AGGR_CORE:
1510
	case AGGR_SOCKET:
1511
		print_aggr(prefix);
1512
		break;
1513
	case AGGR_THREAD:
1514
		evlist__for_each_entry(evsel_list, counter)
1515 1516
			print_aggr_thread(counter, prefix);
		break;
1517
	case AGGR_GLOBAL:
1518
		evlist__for_each_entry(evsel_list, counter)
1519
			print_counter_aggr(counter, prefix);
1520 1521
		if (metric_only)
			fputc('\n', stat_config.output);
1522 1523
		break;
	case AGGR_NONE:
1524 1525 1526
		if (metric_only)
			print_no_aggr_metric(prefix);
		else {
1527
			evlist__for_each_entry(evsel_list, counter)
1528 1529
				print_counter(counter, prefix);
		}
1530
		break;
J
Jiri Olsa 已提交
1531
	case AGGR_UNSET:
1532 1533
	default:
		break;
1534
	}
1535

1536 1537 1538
	if (!interval && !csv_output)
		print_footer();

1539
	fflush(stat_config.output);
1540 1541
}

1542 1543
static volatile int signr = -1;

1544
static void skip_signal(int signo)
1545
{
1546
	if ((child_pid == -1) || stat_config.interval)
1547 1548
		done = 1;

1549
	signr = signo;
1550 1551 1552 1553 1554 1555 1556
	/*
	 * render child_pid harmless
	 * won't send SIGTERM to a random
	 * process in case of race condition
	 * and fast PID recycling
	 */
	child_pid = -1;
1557 1558 1559 1560
}

static void sig_atexit(void)
{
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
	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);

1573 1574 1575
	if (child_pid != -1)
		kill(child_pid, SIGTERM);

1576 1577
	sigprocmask(SIG_SETMASK, &oset, NULL);

1578 1579 1580 1581 1582
	if (signr == -1)
		return;

	signal(signr, SIG_DFL);
	kill(getpid(), signr);
1583 1584
}

1585 1586
static int stat__set_big_num(const struct option *opt __maybe_unused,
			     const char *s __maybe_unused, int unset)
S
Stephane Eranian 已提交
1587 1588 1589 1590 1591
{
	big_num_opt = unset ? 0 : 1;
	return 0;
}

1592 1593 1594 1595 1596 1597 1598 1599
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;
}

J
Jiri Olsa 已提交
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
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),
	OPT_BOOLEAN('i', "no-inherit", &no_inherit,
		    "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)"),
	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),
	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,
		    "print counts at regular interval in ms (>= 10)"),
	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),
	OPT_UINTEGER('D', "delay", &initial_delay,
		     "ms to wait before starting measurement after program start"),
1658 1659 1660 1661
	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"),
J
Jiri Olsa 已提交
1662 1663 1664
	OPT_END()
};

1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
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);
}

1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
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);
}

1714 1715
static int perf_stat_init_aggr_mode(void)
{
1716 1717
	int nr;

1718
	switch (stat_config.aggr_mode) {
1719 1720 1721 1722 1723
	case AGGR_SOCKET:
		if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
			perror("cannot build socket map");
			return -1;
		}
1724
		aggr_get_id = perf_stat__get_socket_cached;
1725
		break;
1726 1727 1728 1729 1730
	case AGGR_CORE:
		if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
			perror("cannot build core map");
			return -1;
		}
1731
		aggr_get_id = perf_stat__get_core_cached;
1732
		break;
1733 1734
	case AGGR_NONE:
	case AGGR_GLOBAL:
1735
	case AGGR_THREAD:
J
Jiri Olsa 已提交
1736
	case AGGR_UNSET:
1737 1738 1739
	default:
		break;
	}
1740 1741 1742 1743 1744 1745 1746 1747 1748

	/*
	 * 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;
1749 1750
}

1751 1752 1753 1754 1755 1756 1757 1758
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;
}

1759 1760 1761 1762 1763 1764 1765 1766 1767
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];

1768
	if (cpu >= env->nr_cpus_avail)
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853
		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;
}

1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902
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)
{
}

1903 1904 1905 1906 1907 1908
/*
 * 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)
{
1909
	int err;
1910
	struct perf_event_attr default_attrs0[] = {
1911 1912 1913 1914 1915 1916 1917

  { .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		},
1918 1919
};
	struct perf_event_attr frontend_attrs[] = {
1920
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND	},
1921 1922
};
	struct perf_event_attr backend_attrs[] = {
1923
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND	},
1924 1925
};
	struct perf_event_attr default_attrs1[] = {
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 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 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
  { .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)				},
};

2023 2024 2025 2026
	/* Set attrs if no event is selected and !null_run: */
	if (null_run)
		return 0;

2027 2028 2029
	if (transaction_run) {
		if (pmu_have_event("cpu", "cycles-ct") &&
		    pmu_have_event("cpu", "el-start"))
2030
			err = parse_events(evsel_list, transaction_attrs, NULL);
2031
		else
2032 2033
			err = parse_events(evsel_list, transaction_limited_attrs, NULL);
		if (err) {
2034 2035 2036 2037 2038 2039
			fprintf(stderr, "Cannot set up transaction events\n");
			return -1;
		}
		return 0;
	}

2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
	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();
			err = parse_events(evsel_list, str, NULL);
			if (err) {
				fprintf(stderr,
					"Cannot set up top down events %s: %d\n",
					str, err);
				free(str);
				return -1;
			}
		} else {
			fprintf(stderr, "System does not support topdown\n");
			return -1;
		}
		free(str);
	}

2080
	if (!evsel_list->nr_entries) {
2081 2082 2083
		if (target__has_cpu(&target))
			default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;

2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
		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)
2097
			return -1;
2098 2099 2100 2101 2102 2103 2104 2105
	}

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

	if (detailed_run <  1)
		return 0;

	/* Append detailed run extra attributes: */
2106
	if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
2107
		return -1;
2108 2109 2110 2111 2112

	if (detailed_run < 2)
		return 0;

	/* Append very detailed run extra attributes: */
2113
	if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
2114
		return -1;
2115 2116 2117 2118 2119

	if (detailed_run < 3)
		return 0;

	/* Append very, very detailed run extra attributes: */
2120
	return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
2121 2122
}

J
Jiri Olsa 已提交
2123
static const char * const stat_record_usage[] = {
J
Jiri Olsa 已提交
2124 2125 2126 2127
	"perf stat record [<options>]",
	NULL,
};

2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
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);
}

J
Jiri Olsa 已提交
2141 2142 2143 2144 2145
static int __cmd_record(int argc, const char **argv)
{
	struct perf_session *session;
	struct perf_data_file *file = &perf_stat.file;

J
Jiri Olsa 已提交
2146
	argc = parse_options(argc, argv, stat_options, stat_record_usage,
J
Jiri Olsa 已提交
2147 2148 2149 2150 2151
			     PARSE_OPT_STOP_AT_NON_OPTION);

	if (output_name)
		file->path = output_name;

2152 2153 2154 2155 2156
	if (run_count != 1 || forever) {
		pr_err("Cannot use -r option with perf stat record.\n");
		return -1;
	}

J
Jiri Olsa 已提交
2157 2158 2159 2160 2161 2162
	session = perf_session__new(file, false, NULL);
	if (session == NULL) {
		pr_err("Perf session creation failed.\n");
		return -1;
	}

2163 2164
	init_features(session);

J
Jiri Olsa 已提交
2165 2166 2167 2168 2169 2170
	session->evlist   = evsel_list;
	perf_stat.session = session;
	perf_stat.record  = true;
	return argc;
}

2171 2172 2173 2174
static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
				    union perf_event *event,
				    struct perf_session *session)
{
2175
	struct stat_round_event *stat_round = &event->stat_round;
2176 2177 2178 2179 2180
	struct perf_evsel *counter;
	struct timespec tsh, *ts = NULL;
	const char **argv = session->header.env.cmdline_argv;
	int argc = session->header.env.nr_cmdline;

2181
	evlist__for_each_entry(evsel_list, counter)
2182 2183
		perf_stat_process_counter(&stat_config, counter);

2184 2185
	if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL)
		update_stats(&walltime_nsecs_stats, stat_round->time);
2186

2187
	if (stat_config.interval && stat_round->time) {
2188 2189
		tsh.tv_sec  = stat_round->time / NSEC_PER_SEC;
		tsh.tv_nsec = stat_round->time % NSEC_PER_SEC;
2190 2191 2192 2193 2194 2195 2196
		ts = &tsh;
	}

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

2197
static
2198
int process_stat_config_event(struct perf_tool *tool,
2199 2200 2201
			      union perf_event *event,
			      struct perf_session *session __maybe_unused)
{
2202 2203
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);

2204
	perf_event__read_stat_config(&stat_config, &event->stat_config);
2205

2206 2207 2208 2209 2210 2211 2212 2213 2214
	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;

2215 2216 2217 2218 2219
	if (perf_stat.file.is_pipe)
		perf_stat_init_aggr_mode();
	else
		perf_stat_init_aggr_mode_file(st);

2220 2221 2222
	return 0;
}

2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
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
2241
int process_thread_map_event(struct perf_tool *tool,
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
			     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
2260
int process_cpu_map_event(struct perf_tool *tool,
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
			  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);
}

J
Jiri Olsa 已提交
2280
static const char * const stat_report_usage[] = {
J
Jiri Olsa 已提交
2281 2282 2283 2284 2285 2286 2287
	"perf stat report [<options>]",
	NULL,
};

static struct perf_stat perf_stat = {
	.tool = {
		.attr		= perf_event__process_attr,
2288
		.event_update	= perf_event__process_event_update,
2289 2290
		.thread_map	= process_thread_map_event,
		.cpu_map	= process_cpu_map_event,
2291
		.stat_config	= process_stat_config_event,
2292 2293
		.stat		= perf_event__process_stat_event,
		.stat_round	= process_stat_round_event,
J
Jiri Olsa 已提交
2294
	},
2295
	.aggr_mode = AGGR_UNSET,
J
Jiri Olsa 已提交
2296 2297 2298 2299 2300 2301 2302
};

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"),
2303 2304 2305 2306 2307 2308
	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),
J
Jiri Olsa 已提交
2309 2310 2311 2312 2313
	OPT_END()
	};
	struct stat st;
	int ret;

J
Jiri Olsa 已提交
2314
	argc = parse_options(argc, argv, options, stat_report_usage, 0);
J
Jiri Olsa 已提交
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341

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

	perf_stat.file.path = input_name;
	perf_stat.file.mode = PERF_DATA_MODE_READ;

	session = perf_session__new(&perf_stat.file, false, &perf_stat.tool);
	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;
}

2342
int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
2343
{
2344 2345 2346 2347
	const char * const stat_usage[] = {
		"perf stat [<options>] [<command>]",
		NULL
	};
2348
	int status = -EINVAL, run_idx;
2349
	const char *mode;
2350
	FILE *output = stderr;
2351
	unsigned int interval;
J
Jiri Olsa 已提交
2352
	const char * const stat_subcommands[] = { "record", "report" };
2353

2354 2355
	setlocale(LC_ALL, "");

2356
	evsel_list = perf_evlist__new();
2357 2358 2359
	if (evsel_list == NULL)
		return -ENOMEM;

2360
	parse_events__shrink_config_terms();
J
Jiri Olsa 已提交
2361 2362 2363
	argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
					(const char **) stat_usage,
					PARSE_OPT_STOP_AT_NON_OPTION);
2364
	perf_stat__init_shadow_stats();
J
Jiri Olsa 已提交
2365

2366 2367 2368 2369 2370 2371 2372
	if (csv_sep) {
		csv_output = true;
		if (!strcmp(csv_sep, "\\t"))
			csv_sep = "\t";
	} else
		csv_sep = DEFAULT_SEPARATOR;

J
Jiri Olsa 已提交
2373 2374 2375 2376
	if (argc && !strncmp(argv[0], "rec", 3)) {
		argc = __cmd_record(argc, argv);
		if (argc < 0)
			return -1;
J
Jiri Olsa 已提交
2377 2378
	} else if (argc && !strncmp(argv[0], "rep", 3))
		return __cmd_report(argc, argv);
S
Stephane Eranian 已提交
2379

2380 2381
	interval = stat_config.interval;

J
Jiri Olsa 已提交
2382 2383 2384 2385
	/*
	 * For record command the -o is already taken care of.
	 */
	if (!STAT_RECORD && output_name && strcmp(output_name, "-"))
2386 2387
		output = NULL;

2388 2389
	if (output_name && output_fd) {
		fprintf(stderr, "cannot use both --output and --log-fd\n");
J
Jiri Olsa 已提交
2390 2391
		parse_options_usage(stat_usage, stat_options, "o", 1);
		parse_options_usage(NULL, stat_options, "log-fd", 0);
2392
		goto out;
2393
	}
2394

2395 2396 2397 2398 2399 2400 2401 2402 2403 2404
	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;
	}

2405 2406
	if (output_fd < 0) {
		fprintf(stderr, "argument to --log-fd must be a > 0\n");
J
Jiri Olsa 已提交
2407
		parse_options_usage(stat_usage, stat_options, "log-fd", 0);
2408
		goto out;
2409 2410
	}

2411 2412 2413 2414 2415 2416 2417
	if (!output) {
		struct timespec tm;
		mode = append_file ? "a" : "w";

		output = fopen(output_name, mode);
		if (!output) {
			perror("failed to create output file");
2418
			return -1;
2419 2420 2421
		}
		clock_gettime(CLOCK_REALTIME, &tm);
		fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
2422
	} else if (output_fd > 0) {
2423 2424 2425 2426 2427 2428
		mode = append_file ? "a" : "w";
		output = fdopen(output_fd, mode);
		if (!output) {
			perror("Failed opening logfd");
			return -errno;
		}
2429 2430
	}

2431 2432
	stat_config.output = output;

S
Stephane Eranian 已提交
2433 2434 2435 2436
	/*
	 * let the spreadsheet do the pretty-printing
	 */
	if (csv_output) {
J
Jim Cromie 已提交
2437
		/* User explicitly passed -B? */
S
Stephane Eranian 已提交
2438 2439
		if (big_num_opt == 1) {
			fprintf(stderr, "-B option not supported with -x\n");
J
Jiri Olsa 已提交
2440 2441
			parse_options_usage(stat_usage, stat_options, "B", 1);
			parse_options_usage(NULL, stat_options, "x", 1);
2442
			goto out;
S
Stephane Eranian 已提交
2443 2444 2445 2446 2447
		} else /* Nope, so disable big number formatting */
			big_num = false;
	} else if (big_num_opt == 0) /* User passed --no-big-num */
		big_num = false;

J
Jiri Olsa 已提交
2448
	/* Make system wide (-a) the default target. */
2449
	if (!argc && target__none(&target))
J
Jiri Olsa 已提交
2450
		target.system_wide = true;
2451

2452
	if (run_count < 0) {
2453
		pr_err("Run count must be a positive number\n");
J
Jiri Olsa 已提交
2454
		parse_options_usage(stat_usage, stat_options, "r", 1);
2455
		goto out;
2456 2457 2458 2459
	} else if (run_count == 0) {
		forever = true;
		run_count = 1;
	}
2460

2461
	if ((stat_config.aggr_mode == AGGR_THREAD) && !target__has_task(&target)) {
2462 2463
		fprintf(stderr, "The --per-thread option is only available "
			"when monitoring via -p -t options.\n");
J
Jiri Olsa 已提交
2464 2465
		parse_options_usage(NULL, stat_options, "p", 1);
		parse_options_usage(NULL, stat_options, "t", 1);
2466 2467 2468 2469 2470 2471 2472
		goto out;
	}

	/*
	 * no_aggr, cgroup are for system-wide only
	 * --per-thread is aggregated per thread, we dont mix it with cpu mode
	 */
2473 2474
	if (((stat_config.aggr_mode != AGGR_GLOBAL &&
	      stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) &&
2475
	    !target__has_cpu(&target)) {
S
Stephane Eranian 已提交
2476 2477 2478
		fprintf(stderr, "both cgroup and no-aggregation "
			"modes only available in system-wide mode\n");

J
Jiri Olsa 已提交
2479 2480 2481
		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);
2482
		goto out;
2483 2484
	}

2485 2486
	if (add_default_attributes())
		goto out;
2487

2488
	target__validate(&target);
2489

2490
	if (perf_evlist__create_maps(evsel_list, &target) < 0) {
2491
		if (target__has_task(&target)) {
2492
			pr_err("Problems finding threads of monitor\n");
J
Jiri Olsa 已提交
2493 2494
			parse_options_usage(stat_usage, stat_options, "p", 1);
			parse_options_usage(NULL, stat_options, "t", 1);
2495
		} else if (target__has_cpu(&target)) {
2496
			perror("failed to parse CPUs map");
J
Jiri Olsa 已提交
2497 2498
			parse_options_usage(stat_usage, stat_options, "C", 1);
			parse_options_usage(NULL, stat_options, "a", 1);
2499 2500
		}
		goto out;
2501
	}
2502 2503 2504 2505 2506

	/*
	 * Initialize thread_map with comm names,
	 * so we could print it out on output.
	 */
2507
	if (stat_config.aggr_mode == AGGR_THREAD)
2508 2509
		thread_map__read_comms(evsel_list->threads);

2510
	if (interval && interval < 100) {
2511 2512
		if (interval < 10) {
			pr_err("print interval must be >= 10ms\n");
J
Jiri Olsa 已提交
2513
			parse_options_usage(stat_usage, stat_options, "I", 1);
2514 2515 2516 2517 2518
			goto out;
		} else
			pr_warning("print interval < 100ms. "
				   "The overhead percentage could be high in some cases. "
				   "Please proceed with caution.\n");
2519
	}
2520

2521
	if (perf_evlist__alloc_stats(evsel_list, interval))
2522
		goto out;
2523

2524
	if (perf_stat_init_aggr_mode())
2525
		goto out;
2526

I
Ingo Molnar 已提交
2527 2528 2529 2530 2531 2532
	/*
	 * 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:
	 */
2533
	atexit(sig_atexit);
2534 2535
	if (!forever)
		signal(SIGINT,  skip_signal);
2536
	signal(SIGCHLD, skip_signal);
I
Ingo Molnar 已提交
2537 2538 2539
	signal(SIGALRM, skip_signal);
	signal(SIGABRT, skip_signal);

2540
	status = 0;
2541
	for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
2542
		if (run_count != 1 && verbose)
2543 2544
			fprintf(output, "[ perf stat: executing run #%d ... ]\n",
				run_idx + 1);
I
Ingo Molnar 已提交
2545

2546
		status = run_perf_stat(argc, argv);
2547
		if (forever && status != -1) {
2548
			print_counters(NULL, argc, argv);
2549
			perf_stat__reset_stats();
2550
		}
2551 2552
	}

2553
	if (!forever && status != -1 && !interval)
2554
		print_counters(NULL, argc, argv);
2555

J
Jiri Olsa 已提交
2556 2557 2558 2559 2560 2561 2562 2563
	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
2564 2565 2566 2567
		 * 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
J
Jiri Olsa 已提交
2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
		 */
		int fd = perf_data_file__fd(&perf_stat.file);
		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.");
		}

2578 2579 2580 2581 2582
		if (!interval) {
			if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL))
				pr_err("failed to write stat round event\n");
		}

2583 2584 2585 2586
		if (!perf_stat.file.is_pipe) {
			perf_stat.session->header.data_size += perf_stat.bytes_written;
			perf_session__write_header(perf_stat.session, evsel_list, fd, true);
		}
J
Jiri Olsa 已提交
2587 2588 2589 2590

		perf_session__delete(perf_stat.session);
	}

2591
	perf_stat__exit_aggr_mode();
2592
	perf_evlist__free_stats(evsel_list);
2593 2594
out:
	perf_evlist__delete(evsel_list);
2595
	return status;
2596
}