[mirror_ubuntu-bionic-kernel.git] / tools / perf / builtin-stat.c

/*
 * builtin-stat.c
 *
 * Builtin stat command: Give a precise performance counters summary
 * overview about any workload, CPU or specific PID.
 *
 * Sample output:

   $ perf stat ~/hackbench 10
   Time: 0.104

    Performance counter stats for '/home/mingo/hackbench':

       1255.538611  task clock ticks     #      10.143 CPU utilization factor
             54011  context switches     #       0.043 M/sec
               385  CPU migrations       #       0.000 M/sec
             17755  pagefaults           #       0.014 M/sec
        3808323185  CPU cycles           #    3033.219 M/sec
        1575111190  instructions         #    1254.530 M/sec
          17367895  cache references     #      13.833 M/sec
           7674421  cache misses         #       6.112 M/sec

    Wall-clock time elapsed:   123.786620 msecs

 *
 * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
 *
 * 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>
 *   Jaswinder Singh Rajput <jaswinder@kernel.org>
 *
 * Released under the GPL v2. (and only v2, not any later version)
 */

#include "perf.h"
#include "builtin.h"
#include "util/util.h"
#include "util/parse-options.h"
#include "util/parse-events.h"
#include "util/event.h"
#include "util/debug.h"

#include <sys/prctl.h>
#include <math.h>

static struct perf_counter_attr default_attrs[] = {

  { .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	},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS	},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES	},

};

#define MAX_RUN			100

static int			system_wide			=  0;
static unsigned int		nr_cpus				=  0;
static int			run_idx				=  0;

static int			run_count			=  1;
static int			inherit				=  1;
static int			scale				=  1;
static int			target_pid			= -1;
static int			null_run			=  0;

static int			fd[MAX_NR_CPUS][MAX_COUNTERS];

static u64			runtime_nsecs[MAX_RUN];
static u64			walltime_nsecs[MAX_RUN];
static u64			runtime_cycles[MAX_RUN];

static u64			event_res[MAX_RUN][MAX_COUNTERS][3];
static u64			event_scaled[MAX_RUN][MAX_COUNTERS];

struct stats
{
	double sum;
	double sum_sq;
};

static double avg_stats(struct stats *stats)
{
	return stats->sum / run_count;
}

/*
 * stddev = sqrt(1/N (\Sum n_i^2) - avg(n)^2)
 */
static double stddev_stats(struct stats *stats)
{
	double avg = stats->sum / run_count;

	return sqrt(stats->sum_sq/run_count - avg*avg);
}

struct stats			event_res_stats[MAX_COUNTERS][3];
struct stats			event_scaled_stats[MAX_COUNTERS];
struct stats			runtime_nsecs_stats;
struct stats			walltime_nsecs_stats;
struct stats			runtime_cycles_stats;

#define MATCH_EVENT(t, c, counter)			\
	(attrs[counter].type == PERF_TYPE_##t &&	\
	 attrs[counter].config == PERF_COUNT_##c)

#define ERR_PERF_OPEN \
"Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"

static void create_perf_stat_counter(int counter, int pid)
{
	struct perf_counter_attr *attr = attrs + counter;

	if (scale)
		attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
				    PERF_FORMAT_TOTAL_TIME_RUNNING;

	if (system_wide) {
		unsigned int cpu;

		for (cpu = 0; cpu < nr_cpus; cpu++) {
			fd[cpu][counter] = sys_perf_counter_open(attr, -1, cpu, -1, 0);
			if (fd[cpu][counter] < 0 && verbose)
				fprintf(stderr, ERR_PERF_OPEN, counter,
					fd[cpu][counter], strerror(errno));
		}
	} else {
		attr->inherit	     = inherit;
		attr->disabled	     = 1;
		attr->enable_on_exec = 1;

		fd[0][counter] = sys_perf_counter_open(attr, pid, -1, -1, 0);
		if (fd[0][counter] < 0 && verbose)
			fprintf(stderr, ERR_PERF_OPEN, counter,
				fd[0][counter], strerror(errno));
	}
}

/*
 * Does the counter have nsecs as a unit?
 */
static inline int nsec_counter(int counter)
{
	if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
	    MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
		return 1;

	return 0;
}

/*
 * Read out the results of a single counter:
 */
static void read_counter(int counter)
{
	u64 *count, single_count[3];
	unsigned int cpu;
	size_t res, nv;
	int scaled;

	count = event_res[run_idx][counter];

	count[0] = count[1] = count[2] = 0;

	nv = scale ? 3 : 1;
	for (cpu = 0; cpu < nr_cpus; cpu++) {
		if (fd[cpu][counter] < 0)
			continue;

		res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
		assert(res == nv * sizeof(u64));

		close(fd[cpu][counter]);
		fd[cpu][counter] = -1;

		count[0] += single_count[0];
		if (scale) {
			count[1] += single_count[1];
			count[2] += single_count[2];
		}
	}

	scaled = 0;
	if (scale) {
		if (count[2] == 0) {
			event_scaled[run_idx][counter] = -1;
			count[0] = 0;
			return;
		}

		if (count[2] < count[1]) {
			event_scaled[run_idx][counter] = 1;
			count[0] = (unsigned long long)
				((double)count[0] * count[1] / count[2] + 0.5);
		}
	}
	/*
	 * Save the full runtime - to allow normalization during printout:
	 */
	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
		runtime_nsecs[run_idx] = count[0];
	if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
		runtime_cycles[run_idx] = count[0];
}

static int run_perf_stat(int argc __used, const char **argv)
{
	unsigned long long t0, t1;
	int status = 0;
	int counter;
	int pid;
	int child_ready_pipe[2], go_pipe[2];
	char buf;

	if (!system_wide)
		nr_cpus = 1;

	if (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0) {
		perror("failed to create pipes");
		exit(1);
	}

	if ((pid = fork()) < 0)
		perror("failed to fork");

	if (!pid) {
		close(child_ready_pipe[0]);
		close(go_pipe[1]);
		fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);

		/*
		 * Do a dummy execvp to get the PLT entry resolved,
		 * so we avoid the resolver overhead on the real
		 * execvp call.
		 */
		execvp("", (char **)argv);

		/*
		 * Tell the parent we're ready to go
		 */
		close(child_ready_pipe[1]);

		/*
		 * Wait until the parent tells us to go.
		 */
		if (read(go_pipe[0], &buf, 1) == -1)
			perror("unable to read pipe");

		execvp(argv[0], (char **)argv);

		perror(argv[0]);
		exit(-1);
	}

	/*
	 * Wait for the child to be ready to exec.
	 */
	close(child_ready_pipe[1]);
	close(go_pipe[0]);
	if (read(child_ready_pipe[0], &buf, 1) == -1)
		perror("unable to read pipe");
	close(child_ready_pipe[0]);

	for (counter = 0; counter < nr_counters; counter++)
		create_perf_stat_counter(counter, pid);

	/*
	 * Enable counters and exec the command:
	 */
	t0 = rdclock();

	close(go_pipe[1]);
	wait(&status);

	t1 = rdclock();

	walltime_nsecs[run_idx] = t1 - t0;

	for (counter = 0; counter < nr_counters; counter++)
		read_counter(counter);

	return WEXITSTATUS(status);
}

static void print_noise(double avg, double stddev)
{
	if (run_count > 1)
		fprintf(stderr, "   ( +- %7.3f%% )", 100*stddev / avg);
}

static void nsec_printout(int counter, double avg, double stddev)
{
	double msecs = avg / 1e6;

	fprintf(stderr, " %14.6f  %-24s", msecs, event_name(counter));

	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
		fprintf(stderr, " # %10.3f CPUs ",
				avg / avg_stats(&walltime_nsecs_stats));
	}
	print_noise(avg, stddev);
}

static void abs_printout(int counter, double avg, double stddev)
{
	fprintf(stderr, " %14.0f  %-24s", avg, event_name(counter));

	if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
		fprintf(stderr, " # %10.3f IPC  ",
				avg / avg_stats(&runtime_cycles_stats));
	} else {
		fprintf(stderr, " # %10.3f M/sec",
				1000.0 * avg / avg_stats(&runtime_nsecs_stats));
	}
	print_noise(avg, stddev);
}

/*
 * Print out the results of a single counter:
 */
static void print_counter(int counter)
{
	double avg, stddev;
	int scaled;

	avg    = avg_stats(&event_res_stats[counter][0]);
	stddev = stddev_stats(&event_res_stats[counter][0]);
	scaled = avg_stats(&event_scaled_stats[counter]);

	if (scaled == -1) {
		fprintf(stderr, " %14s  %-24s\n",
			"<not counted>", event_name(counter));
		return;
	}

	if (nsec_counter(counter))
		nsec_printout(counter, avg, stddev);
	else
		abs_printout(counter, avg, stddev);

	if (scaled) {
		double avg_enabled, avg_running;

		avg_enabled = avg_stats(&event_res_stats[counter][1]);
		avg_running = avg_stats(&event_res_stats[counter][2]);

		fprintf(stderr, "  (scaled from %.2f%%)",
				100 * avg_running / avg_enabled);
	}

	fprintf(stderr, "\n");
}

static void update_stats(const char *name, int idx, struct stats *stats, u64 *val)
{
	double sq = *val;

	stats->sum += *val;
	stats->sum_sq += sq * sq;

	if (verbose > 1)
		fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val);
}

/*
 * Calculate the averages and noises:
 */
static void calc_avg(void)
{
	int i, j;

	if (verbose > 1)
		fprintf(stderr, "\n");

	for (i = 0; i < run_count; i++) {
		update_stats("runtime", 0, &runtime_nsecs_stats, runtime_nsecs + i);
		update_stats("walltime", 0, &walltime_nsecs_stats, walltime_nsecs + i);
		update_stats("runtime_cycles", 0, &runtime_cycles_stats, runtime_cycles + i);

		for (j = 0; j < nr_counters; j++) {
			update_stats("counter/0", j,
				event_res_stats[j]+0, event_res[i][j]+0);
			update_stats("counter/1", j,
				event_res_stats[j]+1, event_res[i][j]+1);
			update_stats("counter/2", j,
				event_res_stats[j]+2, event_res[i][j]+2);
			if (event_scaled[i][j] != (u64)-1)
				update_stats("scaled", j,
					event_scaled_stats + j, event_scaled[i]+j);
		}
	}
}

static void print_stat(int argc, const char **argv)
{
	int i, counter;

	calc_avg();

	fflush(stdout);

	fprintf(stderr, "\n");
	fprintf(stderr, " Performance counter stats for \'%s", argv[0]);

	for (i = 1; i < argc; i++)
		fprintf(stderr, " %s", argv[i]);

	fprintf(stderr, "\'");
	if (run_count > 1)
		fprintf(stderr, " (%d runs)", run_count);
	fprintf(stderr, ":\n\n");

	for (counter = 0; counter < nr_counters; counter++)
		print_counter(counter);

	fprintf(stderr, "\n");
	fprintf(stderr, " %14.9f  seconds time elapsed",
			avg_stats(&walltime_nsecs_stats)/1e9);
	if (run_count > 1) {
		fprintf(stderr, "   ( +- %7.3f%% )",
				100*stddev_stats(&walltime_nsecs_stats) /
				avg_stats(&walltime_nsecs_stats));
	}
	fprintf(stderr, "\n\n");
}

static volatile int signr = -1;

static void skip_signal(int signo)
{
	signr = signo;
}

static void sig_atexit(void)
{
	if (signr == -1)
		return;

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

static const char * const stat_usage[] = {
	"perf stat [<options>] <command>",
	NULL
};

static const struct option options[] = {
	OPT_CALLBACK('e', "event", NULL, "event",
		     "event selector. use 'perf list' to list available events",
		     parse_events),
	OPT_BOOLEAN('i', "inherit", &inherit,
		    "child tasks inherit counters"),
	OPT_INTEGER('p', "pid", &target_pid,
		    "stat events on existing pid"),
	OPT_BOOLEAN('a', "all-cpus", &system_wide,
		    "system-wide collection from all CPUs"),
	OPT_BOOLEAN('c', "scale", &scale,
		    "scale/normalize counters"),
	OPT_BOOLEAN('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)"),
	OPT_BOOLEAN('n', "null", &null_run,
		    "null run - dont start any counters"),
	OPT_END()
};

int cmd_stat(int argc, const char **argv, const char *prefix __used)
{
	int status;

	argc = parse_options(argc, argv, options, stat_usage,
		PARSE_OPT_STOP_AT_NON_OPTION);
	if (!argc)
		usage_with_options(stat_usage, options);
	if (run_count <= 0 || run_count > MAX_RUN)
		usage_with_options(stat_usage, options);

	/* Set attrs and nr_counters if no event is selected and !null_run */
	if (!null_run && !nr_counters) {
		memcpy(attrs, default_attrs, sizeof(default_attrs));
		nr_counters = ARRAY_SIZE(default_attrs);
	}

	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	assert(nr_cpus <= MAX_NR_CPUS);
	assert((int)nr_cpus >= 0);

	/*
	 * 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:
	 */
	atexit(sig_atexit);
	signal(SIGINT,  skip_signal);
	signal(SIGALRM, skip_signal);
	signal(SIGABRT, skip_signal);

	status = 0;
	for (run_idx = 0; run_idx < run_count; run_idx++) {
		if (run_count != 1 && verbose)
			fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
		status = run_perf_stat(argc, argv);
	}

	print_stat(argc, argv);

	return status;
}
Commit	Line	Data
ddcacfa0	1	/*
bf9e1876 IM	2	* builtin-stat.c
	3	*
	4	* Builtin stat command: Give a precise performance counters summary
	5	* overview about any workload, CPU or specific PID.
	6	*
	7	* Sample output:
ddcacfa0	8
bf9e1876 IM	9	$ perf stat ~/hackbench 10
bf9e1876 IM	10	Time: 0.104
ddcacfa0	11
bf9e1876	12	Performance counter stats for '/home/mingo/hackbench':
ddcacfa0	13
bf9e1876 IM	14	1255.538611 task clock ticks # 10.143 CPU utilization factor
	15	54011 context switches # 0.043 M/sec
	16	385 CPU migrations # 0.000 M/sec
	17	17755 pagefaults # 0.014 M/sec
	18	3808323185 CPU cycles # 3033.219 M/sec
	19	1575111190 instructions # 1254.530 M/sec
	20	17367895 cache references # 13.833 M/sec
	21	7674421 cache misses # 6.112 M/sec
ddcacfa0	22
bf9e1876	23	Wall-clock time elapsed: 123.786620 msecs
ddcacfa0	24
5242519b IM	25	*
	26	* Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
	27	*
	28	* Improvements and fixes by:
	29	*
	30	* Arjan van de Ven <arjan@linux.intel.com>
	31	* Yanmin Zhang <yanmin.zhang@intel.com>
	32	* Wu Fengguang <fengguang.wu@intel.com>
	33	* Mike Galbraith <efault@gmx.de>
	34	* Paul Mackerras <paulus@samba.org>
6e750a8f	35	* Jaswinder Singh Rajput <jaswinder@kernel.org>
5242519b IM	36	*
5242519b IM	37	* Released under the GPL v2. (and only v2, not any later version)
ddcacfa0 IM	38	*/
ddcacfa0 IM	39
1a482f38	40	#include "perf.h"
16f762a2	41	#include "builtin.h"
148be2c1	42	#include "util/util.h"
5242519b IM	43	#include "util/parse-options.h"
5242519b IM	44	#include "util/parse-events.h"
8f28827a FW	45	#include "util/event.h"
8f28827a FW	46	#include "util/debug.h"
ddcacfa0	47
ddcacfa0	48	#include <sys/prctl.h>
42202dd5	49	#include <math.h>
16c8a109	50
c3043569	51	static struct perf_counter_attr default_attrs[] = {
ddcacfa0	52
f4dbfa8f PZ	53	{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK },
	54	{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES},
	55	{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS },
	56	{ .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS },
	57
	58	{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES },
	59	{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS },
	60	{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES},
	61	{ .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES },
	62
ddcacfa0	63	};
5242519b	64
3d632595 JSR	65	#define MAX_RUN 100
3d632595 JSR	66
a21ca2ca	67	static int system_wide = 0;
f37a291c	68	static unsigned int nr_cpus = 0;
3d632595	69	static int run_idx = 0;
ddcacfa0	70
3d632595 JSR	71	static int run_count = 1;
3d632595 JSR	72	static int inherit = 1;
66cf7829	73	static int scale = 1;
3d632595	74	static int target_pid = -1;
0cfb7a13	75	static int null_run = 0;
ddcacfa0	76
3d632595	77	static int fd[MAX_NR_CPUS][MAX_COUNTERS];
42202dd5	78
9cffa8d5 PM	79	static u64 runtime_nsecs[MAX_RUN];
	80	static u64 walltime_nsecs[MAX_RUN];
	81	static u64 runtime_cycles[MAX_RUN];
42202dd5	82
3d632595 JSR	83	static u64 event_res[MAX_RUN][MAX_COUNTERS][3];
	84	static u64 event_scaled[MAX_RUN][MAX_COUNTERS];
	85
506d4bc8 PZ	86	struct stats
	87	{
	88	double sum;
	89	double sum_sq;
	90	};
42202dd5	91
506d4bc8 PZ	92	static double avg_stats(struct stats *stats)
	93	{
	94	return stats->sum / run_count;
	95	}
42202dd5	96
506d4bc8 PZ	97	/*
	98	* stddev = sqrt(1/N (\Sum n_i^2) - avg(n)^2)
	99	*/
	100	static double stddev_stats(struct stats *stats)
	101	{
	102	double avg = stats->sum / run_count;
42202dd5	103
506d4bc8 PZ	104	return sqrt(stats->sum_sq/run_count - avg*avg);
506d4bc8 PZ	105	}
42202dd5	106
506d4bc8 PZ	107	struct stats event_res_stats[MAX_COUNTERS][3];
	108	struct stats event_scaled_stats[MAX_COUNTERS];
	109	struct stats runtime_nsecs_stats;
	110	struct stats walltime_nsecs_stats;
	111	struct stats runtime_cycles_stats;
be1ac0d8	112
b9ebdcc0 JSR	113	#define MATCH_EVENT(t, c, counter) \
	114	(attrs[counter].type == PERF_TYPE_##t && \
	115	attrs[counter].config == PERF_COUNT_##c)
	116
cca03c0a JSR	117	#define ERR_PERF_OPEN \
	118	"Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"
	119
051ae7f7	120	static void create_perf_stat_counter(int counter, int pid)
ddcacfa0	121	{
a21ca2ca	122	struct perf_counter_attr *attr = attrs + counter;
16c8a109	123
ddcacfa0	124	if (scale)
a21ca2ca IM	125	attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED \|
a21ca2ca IM	126	PERF_FORMAT_TOTAL_TIME_RUNNING;
ddcacfa0 IM	127
ddcacfa0 IM	128	if (system_wide) {
f37a291c IM	129	unsigned int cpu;
f37a291c IM	130
cca03c0a	131	for (cpu = 0; cpu < nr_cpus; cpu++) {
a21ca2ca	132	fd[cpu][counter] = sys_perf_counter_open(attr, -1, cpu, -1, 0);
cca03c0a JSR	133	if (fd[cpu][counter] < 0 && verbose)
	134	fprintf(stderr, ERR_PERF_OPEN, counter,
	135	fd[cpu][counter], strerror(errno));
ddcacfa0 IM	136	}
ddcacfa0 IM	137	} else {
57e7986e PM	138	attr->inherit = inherit;
	139	attr->disabled = 1;
	140	attr->enable_on_exec = 1;
ddcacfa0	141
051ae7f7	142	fd[0][counter] = sys_perf_counter_open(attr, pid, -1, -1, 0);
cca03c0a JSR	143	if (fd[0][counter] < 0 && verbose)
	144	fprintf(stderr, ERR_PERF_OPEN, counter,
	145	fd[0][counter], strerror(errno));
ddcacfa0 IM	146	}
	147	}
	148
c04f5e5d IM	149	/*
	150	* Does the counter have nsecs as a unit?
	151	*/
	152	static inline int nsec_counter(int counter)
	153	{
b9ebdcc0 JSR	154	if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) \|\|
b9ebdcc0 JSR	155	MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
c04f5e5d IM	156	return 1;
	157
	158	return 0;
	159	}
	160
	161	/*
2996f5dd	162	* Read out the results of a single counter:
c04f5e5d	163	*/
2996f5dd	164	static void read_counter(int counter)
c04f5e5d	165	{
9cffa8d5	166	u64 *count, single_count[3];
f37a291c IM	167	unsigned int cpu;
f37a291c IM	168	size_t res, nv;
c04f5e5d IM	169	int scaled;
c04f5e5d IM	170
42202dd5	171	count = event_res[run_idx][counter];
2996f5dd	172
c04f5e5d	173	count[0] = count[1] = count[2] = 0;
2996f5dd	174
c04f5e5d	175	nv = scale ? 3 : 1;
cca03c0a	176	for (cpu = 0; cpu < nr_cpus; cpu++) {
743ee1f8 IM	177	if (fd[cpu][counter] < 0)
	178	continue;
	179
9cffa8d5 PM	180	res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
9cffa8d5 PM	181	assert(res == nv * sizeof(u64));
f37a291c	182
42202dd5 IM	183	close(fd[cpu][counter]);
42202dd5 IM	184	fd[cpu][counter] = -1;
c04f5e5d IM	185
	186	count[0] += single_count[0];
	187	if (scale) {
	188	count[1] += single_count[1];
	189	count[2] += single_count[2];
	190	}
	191	}
	192
	193	scaled = 0;
	194	if (scale) {
	195	if (count[2] == 0) {
42202dd5	196	event_scaled[run_idx][counter] = -1;
2996f5dd	197	count[0] = 0;
c04f5e5d IM	198	return;
c04f5e5d IM	199	}
2996f5dd	200
c04f5e5d	201	if (count[2] < count[1]) {
42202dd5	202	event_scaled[run_idx][counter] = 1;
c04f5e5d IM	203	count[0] = (unsigned long long)
	204	((double)count[0] * count[1] / count[2] + 0.5);
	205	}
	206	}
be1ac0d8 IM	207	/*
	208	* Save the full runtime - to allow normalization during printout:
	209	*/
b9ebdcc0	210	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
42202dd5	211	runtime_nsecs[run_idx] = count[0];
b9ebdcc0	212	if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
42202dd5	213	runtime_cycles[run_idx] = count[0];
2996f5dd IM	214	}
2996f5dd IM	215
f37a291c	216	static int run_perf_stat(int argc __used, const char **argv)
42202dd5 IM	217	{
	218	unsigned long long t0, t1;
	219	int status = 0;
	220	int counter;
	221	int pid;
051ae7f7 PM	222	int child_ready_pipe[2], go_pipe[2];
051ae7f7 PM	223	char buf;
42202dd5 IM	224
	225	if (!system_wide)
	226	nr_cpus = 1;
	227
051ae7f7 PM	228	if (pipe(child_ready_pipe) < 0 \|\| pipe(go_pipe) < 0) {
	229	perror("failed to create pipes");
	230	exit(1);
	231	}
	232
	233	if ((pid = fork()) < 0)
	234	perror("failed to fork");
	235
	236	if (!pid) {
	237	close(child_ready_pipe[0]);
	238	close(go_pipe[1]);
	239	fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
	240
	241	/*
	242	* Do a dummy execvp to get the PLT entry resolved,
	243	* so we avoid the resolver overhead on the real
	244	* execvp call.
	245	*/
	246	execvp("", (char **)argv);
	247
	248	/*
	249	* Tell the parent we're ready to go
	250	*/
	251	close(child_ready_pipe[1]);
	252
	253	/*
	254	* Wait until the parent tells us to go.
	255	*/
a92bef0f FW	256	if (read(go_pipe[0], &buf, 1) == -1)
a92bef0f FW	257	perror("unable to read pipe");
051ae7f7 PM	258
	259	execvp(argv[0], (char **)argv);
	260
	261	perror(argv[0]);
	262	exit(-1);
	263	}
	264
	265	/*
	266	* Wait for the child to be ready to exec.
	267	*/
	268	close(child_ready_pipe[1]);
	269	close(go_pipe[0]);
a92bef0f FW	270	if (read(child_ready_pipe[0], &buf, 1) == -1)
a92bef0f FW	271	perror("unable to read pipe");
051ae7f7 PM	272	close(child_ready_pipe[0]);
051ae7f7 PM	273
42202dd5	274	for (counter = 0; counter < nr_counters; counter++)
051ae7f7	275	create_perf_stat_counter(counter, pid);
42202dd5 IM	276
	277	/*
	278	* Enable counters and exec the command:
	279	*/
	280	t0 = rdclock();
42202dd5	281
051ae7f7	282	close(go_pipe[1]);
42202dd5 IM	283	wait(&status);
42202dd5 IM	284
42202dd5 IM	285	t1 = rdclock();
	286
	287	walltime_nsecs[run_idx] = t1 - t0;
	288
	289	for (counter = 0; counter < nr_counters; counter++)
	290	read_counter(counter);
	291
	292	return WEXITSTATUS(status);
	293	}
	294
506d4bc8	295	static void print_noise(double avg, double stddev)
42202dd5 IM	296	{
42202dd5 IM	297	if (run_count > 1)
506d4bc8	298	fprintf(stderr, " ( +- %7.3f%% )", 100*stddev / avg);
42202dd5 IM	299	}
42202dd5 IM	300
506d4bc8	301	static void nsec_printout(int counter, double avg, double stddev)
44175b6f	302	{
506d4bc8	303	double msecs = avg / 1e6;
44175b6f	304
6e750a8f	305	fprintf(stderr, " %14.6f %-24s", msecs, event_name(counter));
44175b6f	306
b9ebdcc0	307	if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
506d4bc8 PZ	308	fprintf(stderr, " # %10.3f CPUs ",
506d4bc8 PZ	309	avg / avg_stats(&walltime_nsecs_stats));
44175b6f	310	}
506d4bc8	311	print_noise(avg, stddev);
44175b6f IM	312	}
44175b6f IM	313
506d4bc8	314	static void abs_printout(int counter, double avg, double stddev)
44175b6f	315	{
506d4bc8	316	fprintf(stderr, " %14.0f %-24s", avg, event_name(counter));
44175b6f	317
506d4bc8	318	if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
42202dd5	319	fprintf(stderr, " # %10.3f IPC ",
506d4bc8	320	avg / avg_stats(&runtime_cycles_stats));
42202dd5	321	} else {
506d4bc8 PZ	322	fprintf(stderr, " # %10.3f M/sec",
506d4bc8 PZ	323	1000.0 * avg / avg_stats(&runtime_nsecs_stats));
44175b6f	324	}
506d4bc8	325	print_noise(avg, stddev);
44175b6f IM	326	}
44175b6f IM	327
2996f5dd IM	328	/*
	329	* Print out the results of a single counter:
	330	*/
	331	static void print_counter(int counter)
	332	{
506d4bc8	333	double avg, stddev;
2996f5dd IM	334	int scaled;
2996f5dd IM	335
506d4bc8 PZ	336	avg = avg_stats(&event_res_stats[counter][0]);
	337	stddev = stddev_stats(&event_res_stats[counter][0]);
	338	scaled = avg_stats(&event_scaled_stats[counter]);
2996f5dd IM	339
2996f5dd IM	340	if (scaled == -1) {
6e750a8f	341	fprintf(stderr, " %14s %-24s\n",
2996f5dd IM	342	"<not counted>", event_name(counter));
	343	return;
	344	}
c04f5e5d	345
44175b6f	346	if (nsec_counter(counter))
506d4bc8	347	nsec_printout(counter, avg, stddev);
44175b6f	348	else
506d4bc8 PZ	349	abs_printout(counter, avg, stddev);
	350
	351	if (scaled) {
	352	double avg_enabled, avg_running;
	353
	354	avg_enabled = avg_stats(&event_res_stats[counter][1]);
	355	avg_running = avg_stats(&event_res_stats[counter][2]);
d7c29318	356
210ad39f	357	fprintf(stderr, " (scaled from %.2f%%)",
506d4bc8 PZ	358	100 * avg_running / avg_enabled);
506d4bc8 PZ	359	}
44175b6f	360
c04f5e5d IM	361	fprintf(stderr, "\n");
	362	}
	363
506d4bc8	364	static void update_stats(const char name, int idx, struct stats stats, u64 *val)
ddcacfa0	365	{
506d4bc8	366	double sq = *val;
ddcacfa0	367
506d4bc8 PZ	368	stats->sum += *val;
506d4bc8 PZ	369	stats->sum_sq += sq * sq;
ef281a19 IM	370
	371	if (verbose > 1)
	372	fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val);
	373	}
506d4bc8	374
42202dd5 IM	375	/*
	376	* Calculate the averages and noises:
	377	*/
	378	static void calc_avg(void)
	379	{
	380	int i, j;
	381
ef281a19 IM	382	if (verbose > 1)
	383	fprintf(stderr, "\n");
	384
42202dd5	385	for (i = 0; i < run_count; i++) {
506d4bc8 PZ	386	update_stats("runtime", 0, &runtime_nsecs_stats, runtime_nsecs + i);
	387	update_stats("walltime", 0, &walltime_nsecs_stats, walltime_nsecs + i);
	388	update_stats("runtime_cycles", 0, &runtime_cycles_stats, runtime_cycles + i);
42202dd5 IM	389
42202dd5 IM	390	for (j = 0; j < nr_counters; j++) {
506d4bc8 PZ	391	update_stats("counter/0", j,
	392	event_res_stats[j]+0, event_res[i][j]+0);
	393	update_stats("counter/1", j,
	394	event_res_stats[j]+1, event_res[i][j]+1);
	395	update_stats("counter/2", j,
	396	event_res_stats[j]+2, event_res[i][j]+2);
f37a291c	397	if (event_scaled[i][j] != (u64)-1)
506d4bc8 PZ	398	update_stats("scaled", j,
506d4bc8 PZ	399	event_scaled_stats + j, event_scaled[i]+j);
42202dd5 IM	400	}
42202dd5 IM	401	}
42202dd5 IM	402	}
	403
	404	static void print_stat(int argc, const char **argv)
	405	{
	406	int i, counter;
	407
	408	calc_avg();
ddcacfa0 IM	409
	410	fflush(stdout);
	411
	412	fprintf(stderr, "\n");
44db76c8 IM	413	fprintf(stderr, " Performance counter stats for \'%s", argv[0]);
	414
	415	for (i = 1; i < argc; i++)
	416	fprintf(stderr, " %s", argv[i]);
	417
42202dd5 IM	418	fprintf(stderr, "\'");
	419	if (run_count > 1)
	420	fprintf(stderr, " (%d runs)", run_count);
	421	fprintf(stderr, ":\n\n");
2996f5dd	422
c04f5e5d IM	423	for (counter = 0; counter < nr_counters; counter++)
c04f5e5d IM	424	print_counter(counter);
ddcacfa0	425
ddcacfa0	426	fprintf(stderr, "\n");
566747e6	427	fprintf(stderr, " %14.9f seconds time elapsed",
506d4bc8	428	avg_stats(&walltime_nsecs_stats)/1e9);
566747e6 IM	429	if (run_count > 1) {
566747e6 IM	430	fprintf(stderr, " ( +- %7.3f%% )",
506d4bc8 PZ	431	100*stddev_stats(&walltime_nsecs_stats) /
506d4bc8 PZ	432	avg_stats(&walltime_nsecs_stats));
566747e6 IM	433	}
566747e6 IM	434	fprintf(stderr, "\n\n");
ddcacfa0 IM	435	}
ddcacfa0 IM	436
f7b7c26e PZ	437	static volatile int signr = -1;
f7b7c26e PZ	438
5242519b	439	static void skip_signal(int signo)
ddcacfa0	440	{
f7b7c26e PZ	441	signr = signo;
	442	}
	443
	444	static void sig_atexit(void)
	445	{
	446	if (signr == -1)
	447	return;
	448
	449	signal(signr, SIG_DFL);
	450	kill(getpid(), signr);
5242519b IM	451	}
	452
	453	static const char * const stat_usage[] = {
	454	"perf stat [<options>] <command>",
	455	NULL
	456	};
	457
5242519b IM	458	static const struct option options[] = {
5242519b IM	459	OPT_CALLBACK('e', "event", NULL, "event",
86847b62 TG	460	"event selector. use 'perf list' to list available events",
86847b62 TG	461	parse_events),
5242519b IM	462	OPT_BOOLEAN('i', "inherit", &inherit,
	463	"child tasks inherit counters"),
	464	OPT_INTEGER('p', "pid", &target_pid,
	465	"stat events on existing pid"),
	466	OPT_BOOLEAN('a', "all-cpus", &system_wide,
3d632595	467	"system-wide collection from all CPUs"),
b26bc5a7	468	OPT_BOOLEAN('c', "scale", &scale,
3d632595	469	"scale/normalize counters"),
743ee1f8 IM	470	OPT_BOOLEAN('v', "verbose", &verbose,
743ee1f8 IM	471	"be more verbose (show counter open errors, etc)"),
42202dd5 IM	472	OPT_INTEGER('r', "repeat", &run_count,
42202dd5 IM	473	"repeat command and print average + stddev (max: 100)"),
0cfb7a13 IM	474	OPT_BOOLEAN('n', "null", &null_run,
0cfb7a13 IM	475	"null run - dont start any counters"),
5242519b IM	476	OPT_END()
	477	};
	478
f37a291c	479	int cmd_stat(int argc, const char *argv, const char prefix __used)
5242519b	480	{
42202dd5 IM	481	int status;
42202dd5 IM	482
a0541234 AB	483	argc = parse_options(argc, argv, options, stat_usage,
a0541234 AB	484	PARSE_OPT_STOP_AT_NON_OPTION);
5242519b IM	485	if (!argc)
5242519b IM	486	usage_with_options(stat_usage, options);
42202dd5 IM	487	if (run_count <= 0 \|\| run_count > MAX_RUN)
42202dd5 IM	488	usage_with_options(stat_usage, options);
ddcacfa0	489
c3043569 JSR	490	/* Set attrs and nr_counters if no event is selected and !null_run */
	491	if (!null_run && !nr_counters) {
	492	memcpy(attrs, default_attrs, sizeof(default_attrs));
	493	nr_counters = ARRAY_SIZE(default_attrs);
	494	}
ddcacfa0	495
ddcacfa0 IM	496	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
ddcacfa0 IM	497	assert(nr_cpus <= MAX_NR_CPUS);
f37a291c	498	assert((int)nr_cpus >= 0);
ddcacfa0	499
58d7e993 IM	500	/*
	501	* We dont want to block the signals - that would cause
	502	* child tasks to inherit that and Ctrl-C would not work.
	503	* What we want is for Ctrl-C to work in the exec()-ed
	504	* task, but being ignored by perf stat itself:
	505	*/
f7b7c26e	506	atexit(sig_atexit);
58d7e993 IM	507	signal(SIGINT, skip_signal);
	508	signal(SIGALRM, skip_signal);
	509	signal(SIGABRT, skip_signal);
	510
42202dd5 IM	511	status = 0;
	512	for (run_idx = 0; run_idx < run_count; run_idx++) {
	513	if (run_count != 1 && verbose)
3d632595	514	fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
42202dd5 IM	515	status = run_perf_stat(argc, argv);
	516	}
	517
	518	print_stat(argc, argv);
	519
	520	return status;
ddcacfa0	521	}