perf tools: Introduce event selectors (69aad6f1) · Commits · e / devices / android_kernel_xiaomi_markw

tools/perf/Makefile

+4 −0

Original line number	Diff line number	Diff line
		@@ -396,6 +396,7 @@ LIB_H += util/build-id.h
		LIB_H += util/debug.h
		LIB_H += util/debugfs.h
		LIB_H += util/event.h
		LIB_H += util/evsel.h
		LIB_H += util/exec_cmd.h
		LIB_H += util/types.h
		LIB_H += util/levenshtein.h
		@@ -404,6 +405,7 @@ LIB_H += util/parse-options.h
		LIB_H += util/parse-events.h
		LIB_H += util/quote.h
		LIB_H += util/util.h
		LIB_H += util/xyarray.h
		LIB_H += util/header.h
		LIB_H += util/help.h
		LIB_H += util/session.h
		@@ -433,6 +435,7 @@ LIB_OBJS += $(OUTPUT)util/ctype.o
		LIB_OBJS += $(OUTPUT)util/debugfs.o
		LIB_OBJS += $(OUTPUT)util/environment.o
		LIB_OBJS += $(OUTPUT)util/event.o
		LIB_OBJS += $(OUTPUT)util/evsel.o
		LIB_OBJS += $(OUTPUT)util/exec_cmd.o
		LIB_OBJS += $(OUTPUT)util/help.o
		LIB_OBJS += $(OUTPUT)util/levenshtein.o
		@@ -470,6 +473,7 @@ LIB_OBJS += $(OUTPUT)util/sort.o
		LIB_OBJS += $(OUTPUT)util/hist.o
		LIB_OBJS += $(OUTPUT)util/probe-event.o
		LIB_OBJS += $(OUTPUT)util/util.o
		LIB_OBJS += $(OUTPUT)util/xyarray.o
		LIB_OBJS += $(OUTPUT)util/cpumap.o

		BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o

tools/perf/builtin-record.c

+54 −59

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include "util/header.h"
		#include "util/event.h"
		#include "util/evsel.h"
		#include "util/debug.h"
		#include "util/session.h"
		#include "util/symbol.h"
		@@ -27,13 +28,13 @@
		#include <sched.h>
		#include <sys/mman.h>

		#define FD(e, x, y) ((int )xyarray__entry(e->fd, x, y))

		enum write_mode_t {
		WRITE_FORCE,
		WRITE_APPEND
		};

		static int *fd[MAX_NR_CPUS][MAX_COUNTERS];

		static u64 user_interval = ULLONG_MAX;
		static u64 default_interval = 0;
		static u64 sample_type;
		@@ -81,7 +82,6 @@ static struct perf_session *session;
		static const char *cpu_list;

		struct mmap_data {
		int counter;
		void *base;
		unsigned int mask;
		unsigned int prev;
		@@ -229,12 +229,12 @@ static struct perf_header_attr get_header_attr(struct perf_event_attr a, int n
		return h_attr;
		}

		static void create_counter(int counter, int cpu)
		static void create_counter(struct perf_evsel *evsel, int cpu)
		{
		char *filter = filters[counter];
		struct perf_event_attr *attr = attrs + counter;
		char *filter = evsel->filter;
		struct perf_event_attr *attr = &evsel->attr;
		struct perf_header_attr *h_attr;
		int track = !counter; /* only the first counter needs these */
		int track = !evsel->idx; /* only the first counter needs these */
		int thread_index;
		int ret;
		struct {
		@@ -320,10 +320,9 @@ retry_sample_id:

		for (thread_index = 0; thread_index < thread_num; thread_index++) {
		try_again:
		fd[nr_cpu][counter][thread_index] = sys_perf_event_open(attr,
		all_tids[thread_index], cpu, group_fd, 0);
		FD(evsel, nr_cpu, thread_index) = sys_perf_event_open(attr, all_tids[thread_index], cpu, group_fd, 0);

		if (fd[nr_cpu][counter][thread_index] < 0) {
		if (FD(evsel, nr_cpu, thread_index) < 0) {
		int err = errno;

		if (err == EPERM \|\| err == EACCES)
		@@ -360,7 +359,7 @@ try_again:
		}
		printf("\n");
		error("sys_perf_event_open() syscall returned with %d (%s). /bin/dmesg may provide additional information.\n",
		fd[nr_cpu][counter][thread_index], strerror(err));
		FD(evsel, nr_cpu, thread_index), strerror(err));

		#if defined(__i386__) \|\| defined(__x86_64__)
		if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
		@@ -374,7 +373,7 @@ try_again:
		exit(-1);
		}

		h_attr = get_header_attr(attr, counter);
		h_attr = get_header_attr(attr, evsel->idx);
		if (h_attr == NULL)
		die("nomem\n");

		@@ -385,7 +384,7 @@ try_again:
		}
		}

		if (read(fd[nr_cpu][counter][thread_index], &read_data, sizeof(read_data)) == -1) {
		if (read(FD(evsel, nr_cpu, thread_index), &read_data, sizeof(read_data)) == -1) {
		perror("Unable to read perf file descriptor");
		exit(-1);
		}
		@@ -395,42 +394,43 @@ try_again:
		exit(-1);
		}

		assert(fd[nr_cpu][counter][thread_index] >= 0);
		fcntl(fd[nr_cpu][counter][thread_index], F_SETFL, O_NONBLOCK);
		assert(FD(evsel, nr_cpu, thread_index) >= 0);
		fcntl(FD(evsel, nr_cpu, thread_index), F_SETFL, O_NONBLOCK);

		/*
		* First counter acts as the group leader:
		*/
		if (group && group_fd == -1)
		group_fd = fd[nr_cpu][counter][thread_index];
		group_fd = FD(evsel, nr_cpu, thread_index);

		if (counter \|\| thread_index) {
		ret = ioctl(fd[nr_cpu][counter][thread_index],
		if (evsel->idx \|\| thread_index) {
		struct perf_evsel *first;
		first = list_entry(evsel_list.next, struct perf_evsel, node);
		ret = ioctl(FD(evsel, nr_cpu, thread_index),
		PERF_EVENT_IOC_SET_OUTPUT,
		fd[nr_cpu][0][0]);
		FD(first, nr_cpu, 0));
		if (ret) {
		error("failed to set output: %d (%s)\n", errno,
		strerror(errno));
		exit(-1);
		}
		} else {
		mmap_array[nr_cpu].counter = counter;
		mmap_array[nr_cpu].prev = 0;
		mmap_array[nr_cpu].mask = mmap_pages*page_size - 1;
		mmap_array[nr_cpu].base = mmap(NULL, (mmap_pages+1)*page_size,
		PROT_READ\|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter][thread_index], 0);
		PROT_READ \| PROT_WRITE, MAP_SHARED, FD(evsel, nr_cpu, thread_index), 0);
		if (mmap_array[nr_cpu].base == MAP_FAILED) {
		error("failed to mmap with %d (%s)\n", errno, strerror(errno));
		exit(-1);
		}

		event_array[nr_poll].fd = fd[nr_cpu][counter][thread_index];
		event_array[nr_poll].fd = FD(evsel, nr_cpu, thread_index);
		event_array[nr_poll].events = POLLIN;
		nr_poll++;
		}

		if (filter != NULL) {
		ret = ioctl(fd[nr_cpu][counter][thread_index],
		ret = ioctl(FD(evsel, nr_cpu, thread_index),
		PERF_EVENT_IOC_SET_FILTER, filter);
		if (ret) {
		error("failed to set filter with %d (%s)\n", errno,
		@@ -446,11 +446,12 @@ try_again:

		static void open_counters(int cpu)
		{
		int counter;
		struct perf_evsel *pos;

		group_fd = -1;
		for (counter = 0; counter < nr_counters; counter++)
		create_counter(counter, cpu);

		list_for_each_entry(pos, &evsel_list, node)
		create_counter(pos, cpu);

		nr_cpu++;
		}
		@@ -537,7 +538,7 @@ static void mmap_read_all(void)

		static int __cmd_record(int argc, const char **argv)
		{
		int i, counter;
		int i;
		struct stat st;
		int flags;
		int err;
		@@ -604,7 +605,7 @@ static int __cmd_record(int argc, const char **argv)
		goto out_delete_session;
		}

		if (have_tracepoints(attrs, nr_counters))
		if (have_tracepoints(&evsel_list))
		perf_header__set_feat(&session->header, HEADER_TRACE_INFO);

		/*
		@@ -666,12 +667,6 @@ static int __cmd_record(int argc, const char **argv)
		close(child_ready_pipe[0]);
		}

		nr_cpus = read_cpu_map(cpu_list);
		if (nr_cpus < 1) {
		perror("failed to collect number of CPUs");
		return -1;
		}

		if (!system_wide && no_inherit && !cpu_list) {
		open_counters(-1);
		} else {
		@@ -711,7 +706,7 @@ static int __cmd_record(int argc, const char **argv)
		return err;
		}

		if (have_tracepoints(attrs, nr_counters)) {
		if (have_tracepoints(&evsel_list)) {
		/*
		* FIXME err <= 0 here actually means that
		* there were no tracepoints so its not really
		@@ -720,8 +715,7 @@ static int __cmd_record(int argc, const char **argv)
		* return this more properly and also
		* propagate errors that now are calling die()
		*/
		err = event__synthesize_tracing_data(output, attrs,
		nr_counters,
		err = event__synthesize_tracing_data(output, &evsel_list,
		process_synthesized_event,
		session);
		if (err <= 0) {
		@@ -795,13 +789,13 @@ static int __cmd_record(int argc, const char **argv)

		if (done) {
		for (i = 0; i < nr_cpu; i++) {
		for (counter = 0;
		counter < nr_counters;
		counter++) {
		struct perf_evsel *pos;

		list_for_each_entry(pos, &evsel_list, node) {
		for (thread = 0;
		thread < thread_num;
		thread++)
		ioctl(fd[i][counter][thread],
		ioctl(FD(pos, i, thread),
		PERF_EVENT_IOC_DISABLE);
		}
		}
		@@ -887,7 +881,8 @@ const struct option record_options[] = {

		int cmd_record(int argc, const char *argv, const char prefix __used)
		{
		int i, j, err = -ENOMEM;
		int err = -ENOMEM;
		struct perf_evsel *pos;

		argc = parse_options(argc, argv, record_options, record_usage,
		PARSE_OPT_STOP_AT_NON_OPTION);
		@@ -910,10 +905,9 @@ int cmd_record(int argc, const char *argv, const char prefix __used)
		if (no_buildid_cache \|\| no_buildid)
		disable_buildid_cache();

		if (!nr_counters) {
		nr_counters = 1;
		attrs[0].type = PERF_TYPE_HARDWARE;
		attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
		if (list_empty(&evsel_list) && perf_evsel_list__create_default() < 0) {
		pr_err("Not enough memory for event selector list\n");
		goto out_symbol_exit;
		}

		if (target_pid != -1) {
		@@ -933,12 +927,15 @@ int cmd_record(int argc, const char *argv, const char prefix __used)
		thread_num = 1;
		}

		for (i = 0; i < MAX_NR_CPUS; i++) {
		for (j = 0; j < MAX_COUNTERS; j++) {
		fd[i][j] = malloc(sizeof(int)*thread_num);
		if (!fd[i][j])
		goto out_free_fd;
		nr_cpus = read_cpu_map(cpu_list);
		if (nr_cpus < 1) {
		perror("failed to collect number of CPUs");
		return -1;
		}

		list_for_each_entry(pos, &evsel_list, node) {
		if (perf_evsel__alloc_fd(pos, nr_cpus, thread_num) < 0)
		goto out_free_fd;
		}
		event_array = malloc(
		sizeof(struct pollfd)MAX_NR_CPUSMAX_COUNTERS*thread_num);
		@@ -968,10 +965,8 @@ int cmd_record(int argc, const char *argv, const char prefix __used)
		out_free_event_array:
		free(event_array);
		out_free_fd:
		for (i = 0; i < MAX_NR_CPUS; i++) {
		for (j = 0; j < MAX_COUNTERS; j++)
		free(fd[i][j]);
		}
		list_for_each_entry(pos, &evsel_list, node)
		perf_evsel__free_fd(pos);
		free(all_tids);
		all_tids = NULL;
		out_symbol_exit:

tools/perf/builtin-stat.c

+107 −68

Original line number	Diff line number	Diff line
		@@ -43,6 +43,7 @@
		#include "util/parse-options.h"
		#include "util/parse-events.h"
		#include "util/event.h"
		#include "util/evsel.h"
		#include "util/debug.h"
		#include "util/header.h"
		#include "util/cpumap.h"
		@@ -52,6 +53,8 @@
		#include <math.h>
		#include <locale.h>

		#define FD(e, x, y) ((int )xyarray__entry(e->fd, x, y))

		#define DEFAULT_SEPARATOR " "

		static struct perf_event_attr default_attrs[] = {
		@@ -90,16 +93,11 @@ static const char *cpu_list;
		static const char *csv_sep = NULL;
		static bool csv_output = false;


		static int *fd[MAX_NR_CPUS][MAX_COUNTERS];

		static int event_scaled[MAX_COUNTERS];

		static struct {
		struct cpu_counts {
		u64 val;
		u64 ena;
		u64 run;
		} cpu_counts[MAX_NR_CPUS][MAX_COUNTERS];
		};

		static volatile int done = 0;

		@@ -108,6 +106,26 @@ struct stats
		double n, mean, M2;
		};

		struct perf_stat {
		struct stats res_stats[3];
		int scaled;
		struct cpu_counts cpu_counts[];
		};

		static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel, int ncpus)
		{
		size_t priv_size = (sizeof(struct perf_stat) +
		(ncpus * sizeof(struct cpu_counts)));
		evsel->priv = zalloc(priv_size);
		return evsel->priv == NULL ? -ENOMEM : 0;
		}

		static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
		{
		free(evsel->priv);
		evsel->priv = NULL;
		}

		static void update_stats(struct stats *stats, u64 val)
		{
		double delta;
		@@ -147,22 +165,21 @@ static double stddev_stats(struct stats *stats)
		return sqrt(variance_mean);
		}

		struct stats event_res_stats[MAX_COUNTERS][3];
		struct stats runtime_nsecs_stats[MAX_NR_CPUS];
		struct stats runtime_cycles_stats[MAX_NR_CPUS];
		struct stats runtime_branches_stats[MAX_NR_CPUS];
		struct stats walltime_nsecs_stats;

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

		#define ERR_PERF_OPEN \
		"counter %d, sys_perf_event_open() syscall returned with %d (%s). /bin/dmesg may provide additional information."

		static int create_perf_stat_counter(int counter, bool *perm_err)
		static int create_perf_stat_counter(struct perf_evsel evsel, bool perm_err)
		{
		struct perf_event_attr *attr = attrs + counter;
		struct perf_event_attr *attr = &evsel->attr;
		int thread;
		int ncreated = 0;

		@@ -174,13 +191,13 @@ static int create_perf_stat_counter(int counter, bool *perm_err)
		int cpu;

		for (cpu = 0; cpu < nr_cpus; cpu++) {
		fd[cpu][counter][0] = sys_perf_event_open(attr,
		FD(evsel, cpu, 0) = sys_perf_event_open(attr,
		-1, cpumap[cpu], -1, 0);
		if (fd[cpu][counter][0] < 0) {
		if (FD(evsel, cpu, 0) < 0) {
		if (errno == EPERM \|\| errno == EACCES)
		*perm_err = true;
		error(ERR_PERF_OPEN, counter,
		fd[cpu][counter][0], strerror(errno));
		error(ERR_PERF_OPEN, evsel->idx,
		FD(evsel, cpu, 0), strerror(errno));
		} else {
		++ncreated;
		}
		@@ -192,13 +209,13 @@ static int create_perf_stat_counter(int counter, bool *perm_err)
		attr->enable_on_exec = 1;
		}
		for (thread = 0; thread < thread_num; thread++) {
		fd[0][counter][thread] = sys_perf_event_open(attr,
		FD(evsel, 0, thread) = sys_perf_event_open(attr,
		all_tids[thread], -1, -1, 0);
		if (fd[0][counter][thread] < 0) {
		if (FD(evsel, 0, thread) < 0) {
		if (errno == EPERM \|\| errno == EACCES)
		*perm_err = true;
		error(ERR_PERF_OPEN, counter,
		fd[0][counter][thread],
		error(ERR_PERF_OPEN, evsel->idx,
		FD(evsel, 0, thread),
		strerror(errno));
		} else {
		++ncreated;
		@@ -212,7 +229,7 @@ static int create_perf_stat_counter(int counter, bool *perm_err)
		/*
		* Does the counter have nsecs as a unit?
		*/
		static inline int nsec_counter(int counter)
		static inline int nsec_counter(struct perf_evsel *counter)
		{
		if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) \|\|
		MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
		@@ -225,8 +242,9 @@ static inline int nsec_counter(int counter)
		* Read out the results of a single counter:
		* aggregate counts across CPUs in system-wide mode
		*/
		static void read_counter_aggr(int counter)
		static void read_counter_aggr(struct perf_evsel *counter)
		{
		struct perf_stat *ps = counter->priv;
		u64 count[3], single_count[3];
		int cpu;
		size_t res, nv;
		@@ -238,15 +256,15 @@ static void read_counter_aggr(int counter)
		nv = scale ? 3 : 1;
		for (cpu = 0; cpu < nr_cpus; cpu++) {
		for (thread = 0; thread < thread_num; thread++) {
		if (fd[cpu][counter][thread] < 0)
		if (FD(counter, cpu, thread) < 0)
		continue;

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

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

		count[0] += single_count[0];
		if (scale) {
		@@ -259,20 +277,20 @@ static void read_counter_aggr(int counter)
		scaled = 0;
		if (scale) {
		if (count[2] == 0) {
		event_scaled[counter] = -1;
		ps->scaled = -1;
		count[0] = 0;
		return;
		}

		if (count[2] < count[1]) {
		event_scaled[counter] = 1;
		ps->scaled = 1;
		count[0] = (unsigned long long)
		((double)count[0] * count[1] / count[2] + 0.5);
		}
		}

		for (i = 0; i < 3; i++)
		update_stats(&event_res_stats[counter][i], count[i]);
		update_stats(&ps->res_stats[i], count[i]);

		if (verbose) {
		fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
		@@ -294,8 +312,9 @@ static void read_counter_aggr(int counter)
		* Read out the results of a single counter:
		* do not aggregate counts across CPUs in system-wide mode
		*/
		static void read_counter(int counter)
		static void read_counter(struct perf_evsel *counter)
		{
		struct cpu_counts *cpu_counts = counter->priv;
		u64 count[3];
		int cpu;
		size_t res, nv;
		@@ -306,15 +325,15 @@ static void read_counter(int counter)

		for (cpu = 0; cpu < nr_cpus; cpu++) {

		if (fd[cpu][counter][0] < 0)
		if (FD(counter, cpu, 0) < 0)
		continue;

		res = read(fd[cpu][counter][0], count, nv * sizeof(u64));
		res = read(FD(counter, cpu, 0), count, nv * sizeof(u64));

		assert(res == nv * sizeof(u64));

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

		if (scale) {
		if (count[2] == 0) {
		@@ -324,9 +343,9 @@ static void read_counter(int counter)
		((double)count[0] * count[1] / count[2] + 0.5);
		}
		}
		cpu_counts[cpu][counter].val = count[0]; /* scaled count */
		cpu_counts[cpu][counter].ena = count[1];
		cpu_counts[cpu][counter].run = count[2];
		cpu_counts[cpu].val = count[0]; /* scaled count */
		cpu_counts[cpu].ena = count[1];
		cpu_counts[cpu].run = count[2];

		if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
		update_stats(&runtime_nsecs_stats[cpu], count[0]);
		@@ -340,8 +359,9 @@ static void read_counter(int counter)
		static int run_perf_stat(int argc __used, const char **argv)
		{
		unsigned long long t0, t1;
		struct perf_evsel *counter;
		int status = 0;
		int counter, ncreated = 0;
		int ncreated = 0;
		int child_ready_pipe[2], go_pipe[2];
		bool perm_err = false;
		const bool forks = (argc > 0);
		@@ -401,7 +421,7 @@ static int run_perf_stat(int argc __used, const char **argv)
		close(child_ready_pipe[0]);
		}

		for (counter = 0; counter < nr_counters; counter++)
		list_for_each_entry(counter, &evsel_list, node)
		ncreated += create_perf_stat_counter(counter, &perm_err);

		if (ncreated < nr_counters) {
		@@ -433,25 +453,28 @@ static int run_perf_stat(int argc __used, const char **argv)
		update_stats(&walltime_nsecs_stats, t1 - t0);

		if (no_aggr) {
		for (counter = 0; counter < nr_counters; counter++)
		list_for_each_entry(counter, &evsel_list, node)
		read_counter(counter);
		} else {
		for (counter = 0; counter < nr_counters; counter++)
		list_for_each_entry(counter, &evsel_list, node)
		read_counter_aggr(counter);
		}
		return WEXITSTATUS(status);
		}

		static void print_noise(int counter, double avg)
		static void print_noise(struct perf_evsel *evsel, double avg)
		{
		struct perf_stat *ps;

		if (run_count == 1)
		return;

		ps = evsel->priv;
		fprintf(stderr, " ( +- %7.3f%% )",
		100 * stddev_stats(&event_res_stats[counter][0]) / avg);
		100 * stddev_stats(&ps->res_stats[0]) / avg);
		}

		static void nsec_printout(int cpu, int counter, double avg)
		static void nsec_printout(int cpu, struct perf_evsel *counter, double avg)
		{
		double msecs = avg / 1e6;
		char cpustr[16] = { '\0', };
		@@ -473,7 +496,7 @@ static void nsec_printout(int cpu, int counter, double avg)
		}
		}

		static void abs_printout(int cpu, int counter, double avg)
		static void abs_printout(int cpu, struct perf_evsel *counter, double avg)
		{
		double total, ratio = 0.0;
		char cpustr[16] = { '\0', };
		@@ -528,10 +551,11 @@ static void abs_printout(int cpu, int counter, double avg)
		* Print out the results of a single counter:
		* aggregated counts in system-wide mode
		*/
		static void print_counter_aggr(int counter)
		static void print_counter_aggr(struct perf_evsel *counter)
		{
		double avg = avg_stats(&event_res_stats[counter][0]);
		int scaled = event_scaled[counter];
		struct perf_stat *ps = counter->priv;
		double avg = avg_stats(&ps->res_stats[0]);
		int scaled = ps->scaled;

		if (scaled == -1) {
		fprintf(stderr, "%*s%s%-24s\n",
		@@ -555,8 +579,8 @@ static void print_counter_aggr(int counter)
		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]);
		avg_enabled = avg_stats(&ps->res_stats[1]);
		avg_running = avg_stats(&ps->res_stats[2]);

		fprintf(stderr, " (scaled from %.2f%%)",
		100 * avg_running / avg_enabled);
		@@ -569,15 +593,16 @@ static void print_counter_aggr(int counter)
		* Print out the results of a single counter:
		* does not use aggregated count in system-wide
		*/
		static void print_counter(int counter)
		static void print_counter(struct perf_evsel *counter)
		{
		struct perf_stat *ps = counter->priv;
		u64 ena, run, val;
		int cpu;

		for (cpu = 0; cpu < nr_cpus; cpu++) {
		val = cpu_counts[cpu][counter].val;
		ena = cpu_counts[cpu][counter].ena;
		run = cpu_counts[cpu][counter].run;
		val = ps->cpu_counts[cpu].val;
		ena = ps->cpu_counts[cpu].ena;
		run = ps->cpu_counts[cpu].run;
		if (run == 0 \|\| ena == 0) {
		fprintf(stderr, "CPU%d%s%s%s%-24s",
		csv_output ? 0 : -4,
		@@ -609,7 +634,8 @@ static void print_counter(int counter)

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

		fflush(stdout);

		@@ -632,10 +658,10 @@ static void print_stat(int argc, const char **argv)
		}

		if (no_aggr) {
		for (counter = 0; counter < nr_counters; counter++)
		list_for_each_entry(counter, &evsel_list, node)
		print_counter(counter);
		} else {
		for (counter = 0; counter < nr_counters; counter++)
		list_for_each_entry(counter, &evsel_list, node)
		print_counter_aggr(counter);
		}

		@@ -720,8 +746,8 @@ static const struct option options[] = {

		int cmd_stat(int argc, const char *argv, const char prefix __used)
		{
		int status;
		int i,j;
		struct perf_evsel *pos;
		int status = -ENOMEM;

		setlocale(LC_ALL, "");

		@@ -757,8 +783,18 @@ int cmd_stat(int argc, const char *argv, const char prefix __used)

		/* 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));
		size_t c;

		nr_counters = ARRAY_SIZE(default_attrs);

		for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
		pos = perf_evsel__new(default_attrs[c].type,
		default_attrs[c].config,
		nr_counters);
		if (pos == NULL)
		goto out;
		list_add(&pos->node, &evsel_list);
		}
		}

		if (system_wide)
		@@ -786,12 +822,10 @@ int cmd_stat(int argc, const char *argv, const char prefix __used)
		thread_num = 1;
		}

		for (i = 0; i < MAX_NR_CPUS; i++) {
		for (j = 0; j < MAX_COUNTERS; j++) {
		fd[i][j] = malloc(sizeof(int)*thread_num);
		if (!fd[i][j])
		return -ENOMEM;
		}
		list_for_each_entry(pos, &evsel_list, node) {
		if (perf_evsel__alloc_stat_priv(pos, nr_cpus) < 0 \|\|
		perf_evsel__alloc_fd(pos, nr_cpus, thread_num) < 0)
		goto out_free_fd;
		}

		/*
		@@ -814,6 +848,11 @@ int cmd_stat(int argc, const char *argv, const char prefix __used)

		if (status != -1)
		print_stat(argc, argv);

		out_free_fd:
		list_for_each_entry(pos, &evsel_list, node) {
		perf_evsel__free_fd(pos);
		perf_evsel__free_stat_priv(pos);
		}
		out:
		return status;
		}

tools/perf/builtin-top.c

+104 −72

File changed.

Preview size limit exceeded, changes collapsed.

tools/perf/util/evsel.c

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		#include "evsel.h"
		#include "util.h"

		struct perf_evsel *perf_evsel__new(u32 type, u64 config, int idx)
		{
		struct perf_evsel evsel = zalloc(sizeof(evsel));

		if (evsel != NULL) {
		evsel->idx = idx;
		evsel->attr.type = type;
		evsel->attr.config = config;
		INIT_LIST_HEAD(&evsel->node);
		}

		return evsel;
		}

		int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
		{
		evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
		return evsel->fd != NULL ? 0 : -ENOMEM;
		}

		void perf_evsel__free_fd(struct perf_evsel *evsel)
		{
		xyarray__delete(evsel->fd);
		evsel->fd = NULL;
		}

		void perf_evsel__delete(struct perf_evsel *evsel)
		{
		assert(list_empty(&evsel->node));
		xyarray__delete(evsel->fd);
		free(evsel);
		}