Commit 660842e4 authored by Ian Rogers's avatar Ian Rogers Committed by Arnaldo Carvalho de Melo
Browse files

perf pmu-events: Don't assume pmu_event is an array 



The current code assumes that a struct pmu_event can be iterated over
forward until a NULL pmu_event is encountered.

This makes it difficult to refactor pmu_event.

Add a loop function taking a callback function that's passed the struct
pmu_event.

This way the pmu_event is only needed for one element and not an entire
array.

Switch existing code iterating over the pmu_event arrays to use the new
loop function pmu_events_table_for_each_event.

Signed-off-by: default avatarIan Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.garry@huawei.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mike Leach <mike.leach@linaro.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Stephane Eranian <eranian@google.com>
Cc: Will Deacon <will@kernel.org>
Cc: Xing Zhengjun <zhengjun.xing@linux.intel.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: https://lore.kernel.org/r/20220812230949.683239-11-irogers@google.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 7ae5c03a

tools/perf/pmu-events/empty-pmu-events.c

+20 −14
Original line number Diff line number Diff line
@@ -247,6 +247,20 @@ static const struct pmu_sys_events pmu_sys_event_tables[] = { 
	},

};



int pmu_events_table_for_each_event(const struct pmu_event *table, pmu_event_iter_fn fn,

				    void *data)

{

	for (const struct pmu_event *pe = &table[0];

	     pe->name || pe->metric_group || pe->metric_name;

	     pe++) {

		int ret = fn(pe, table, data);



		if (ret)

			return ret;

	}

	return 0;

}



const struct pmu_event *perf_pmu__find_table(struct perf_pmu *pmu)

{

	const struct pmu_event *table = NULL;
@@ -291,15 +305,11 @@ int pmu_for_each_core_event(pmu_event_iter_fn fn, void *data) 
	for (const struct pmu_events_map *tables = &pmu_events_map[0];

	     tables->table;

	     tables++) {

		for (const struct pmu_event *pe = &tables->table[0];

		     pe->name || pe->metric_group || pe->metric_name;

		     pe++) {

			int ret = fn(pe, &tables->table[0], data);

		int ret = pmu_events_table_for_each_event(tables->table, fn, data);



		if (ret)

			return ret;

	}

	}

	return 0;

}
@@ -319,14 +329,10 @@ int pmu_for_each_sys_event(pmu_event_iter_fn fn, void *data) 
	for (const struct pmu_sys_events *tables = &pmu_sys_event_tables[0];

	     tables->name;

	     tables++) {

		for (const struct pmu_event *pe = &tables->table[0];

		     pe->name || pe->metric_group || pe->metric_name;

		     pe++) {

			int ret = fn(pe, &tables->table[0], data);

		int ret = pmu_events_table_for_each_event(tables->table, fn, data);



		if (ret)

			return ret;

	}

	}

	return 0;

}

tools/perf/pmu-events/jevents.py

+20 −14
Original line number Diff line number Diff line
@@ -410,6 +410,20 @@ static const struct pmu_sys_events pmu_sys_event_tables[] = { 
\t},

};



int pmu_events_table_for_each_event(const struct pmu_event *table, pmu_event_iter_fn fn,

                                    void *data)

{

        for (const struct pmu_event *pe = &table[0];

             pe->name || pe->metric_group || pe->metric_name;

             pe++) {

                int ret = fn(pe, table, data);



                if (ret)

                        return ret;

        }

        return 0;

}



const struct pmu_event *perf_pmu__find_table(struct perf_pmu *pmu)

{

        const struct pmu_event *table = NULL;
@@ -453,15 +467,11 @@ int pmu_for_each_core_event(pmu_event_iter_fn fn, void *data) 
        for (const struct pmu_events_map *tables = &pmu_events_map[0];

             tables->table;

             tables++) {

                for (const struct pmu_event *pe = &tables->table[0];

                     pe->name || pe->metric_group || pe->metric_name;

                     pe++) {

                        int ret = fn(pe, &tables->table[0], data);

                int ret = pmu_events_table_for_each_event(tables->table, fn, data);



                if (ret)

                        return ret;

        }

        }

        return 0;

}
@@ -481,15 +491,11 @@ int pmu_for_each_sys_event(pmu_event_iter_fn fn, void *data) 
        for (const struct pmu_sys_events *tables = &pmu_sys_event_tables[0];

             tables->name;

             tables++) {

                for (const struct pmu_event *pe = &tables->table[0];

                     pe->name || pe->metric_group || pe->metric_name;

                     pe++) {

                        int ret = fn(pe, &tables->table[0], data);

                int ret = pmu_events_table_for_each_event(tables->table, fn, data);



                if (ret)

                        return ret;

        }

        }

        return 0;

}

""")

tools/perf/pmu-events/pmu-events.h

+3 −0
Original line number Diff line number Diff line
@@ -34,6 +34,9 @@ typedef int (*pmu_event_iter_fn)(const struct pmu_event *pe, 
				 const struct pmu_event *table,

				 void *data);



int pmu_events_table_for_each_event(const struct pmu_event *table, pmu_event_iter_fn fn,

				    void *data);



const struct pmu_event *perf_pmu__find_table(struct perf_pmu *pmu);

const struct pmu_event *find_core_events_table(const char *arch, const char *cpuid);

int pmu_for_each_core_event(pmu_event_iter_fn fn, void *data);

tools/perf/tests/pmu-events.c

+78 −58
Original line number Diff line number Diff line
@@ -423,27 +423,18 @@ static int compare_alias_to_test_event(struct perf_pmu_alias *alias, 
	return 0;

}



/* Verify generated events from pmu-events.c are as expected */

static int test__pmu_event_table(struct test_suite *test __maybe_unused,

				 int subtest __maybe_unused)

static int test__pmu_event_table_core_callback(const struct pmu_event *pe,

					       const struct pmu_event *table __maybe_unused,

					       void *data)

{

	const struct pmu_event *sys_event_tables = find_sys_events_table("pme_test_soc_sys");

	const struct pmu_event *table = find_core_events_table("testarch", "testcpu");

	int map_events = 0, expected_events;



	/* ignore 3x sentinels */

	expected_events = ARRAY_SIZE(core_events) +

			  ARRAY_SIZE(uncore_events) +

			  ARRAY_SIZE(sys_events) - 3;



	if (!table || !sys_event_tables)

		return -1;



	for (; table->name; table++) {

	int *map_events = data;

	struct perf_pmu_test_event const **test_event_table;

	bool found = false;



		if (table->pmu)

	if (!pe->name)

		return 0;



	if (pe->pmu)

		test_event_table = &uncore_events[0];

	else

		test_event_table = &core_events[0];
@@ -452,25 +443,28 @@ static int test__pmu_event_table(struct test_suite *test __maybe_unused, 
		struct perf_pmu_test_event const *test_event = *test_event_table;

		struct pmu_event const *event = &test_event->event;



			if (strcmp(table->name, event->name))

		if (strcmp(pe->name, event->name))

			continue;

		found = true;

			map_events++;

		(*map_events)++;



			if (compare_pmu_events(table, event))

		if (compare_pmu_events(pe, event))

			return -1;



			pr_debug("testing event table %s: pass\n", table->name);

		pr_debug("testing event table %s: pass\n", pe->name);

	}



	if (!found) {

			pr_err("testing event table: could not find event %s\n",

			       table->name);

		pr_err("testing event table: could not find event %s\n", pe->name);

		return -1;

	}

	return 0;

}



	for (table = sys_event_tables; table->name; table++) {

static int test__pmu_event_table_sys_callback(const struct pmu_event *pe,

					      const struct pmu_event *table __maybe_unused,

					      void *data)

{

	int *map_events = data;

	struct perf_pmu_test_event const **test_event_table;

	bool found = false;
@@ -480,27 +474,53 @@ static int test__pmu_event_table(struct test_suite *test __maybe_unused, 
		struct perf_pmu_test_event const *test_event = *test_event_table;

		struct pmu_event const *event = &test_event->event;



			if (strcmp(table->name, event->name))

		if (strcmp(pe->name, event->name))

			continue;

		found = true;

			map_events++;

		(*map_events)++;



			if (compare_pmu_events(table, event))

				return -1;

		if (compare_pmu_events(pe, event))

			return TEST_FAIL;



			pr_debug("testing sys event table %s: pass\n", table->name);

		pr_debug("testing sys event table %s: pass\n", pe->name);

	}

	if (!found) {

			pr_debug("testing event table: could not find event %s\n",

				   table->name);

			return -1;

		pr_debug("testing sys event table: could not find event %s\n", pe->name);

		return TEST_FAIL;

	}

	return TEST_OK;

}



/* Verify generated events from pmu-events.c are as expected */

static int test__pmu_event_table(struct test_suite *test __maybe_unused,

				 int subtest __maybe_unused)

{

	const struct pmu_event *sys_event_table = find_sys_events_table("pme_test_soc_sys");

	const struct pmu_event *table = find_core_events_table("testarch", "testcpu");

	int map_events = 0, expected_events, err;



	/* ignore 3x sentinels */

	expected_events = ARRAY_SIZE(core_events) +

			  ARRAY_SIZE(uncore_events) +

			  ARRAY_SIZE(sys_events) - 3;



	if (!table || !sys_event_table)

		return -1;



	err = pmu_events_table_for_each_event(table, test__pmu_event_table_core_callback,

					      &map_events);

	if (err)

		return err;



	err = pmu_events_table_for_each_event(sys_event_table, test__pmu_event_table_sys_callback,

					      &map_events);

	if (err)

		return err;



	if (map_events != expected_events) {

		pr_err("testing event table: found %d, but expected %d\n",

		       map_events, expected_events);

		return -1;

		return TEST_FAIL;

	}



	return 0;

tools/perf/util/metricgroup.c

+125 −56
Original line number Diff line number Diff line
@@ -538,12 +538,40 @@ static int metricgroup__print_sys_event_iter(const struct pmu_event *pe, 
				     d->details, d->groups, d->metriclist);

}



struct metricgroup_print_data {

	const char *pmu_name;

	struct strlist *metriclist;

	char *filter;

	struct rblist *groups;

	bool metricgroups;

	bool raw;

	bool details;

};



static int metricgroup__print_callback(const struct pmu_event *pe,

				       const struct pmu_event *table __maybe_unused,

				       void *vdata)

{

	struct metricgroup_print_data *data = vdata;



	if (!pe->metric_expr)

		return 0;



	if (data->pmu_name && perf_pmu__is_hybrid(pe->pmu) && strcmp(data->pmu_name, pe->pmu))

		return 0;



	return metricgroup__print_pmu_event(pe, data->metricgroups, data->filter,

					    data->raw, data->details, data->groups,

					    data->metriclist);

}



void metricgroup__print(bool metrics, bool metricgroups, char *filter,

			bool raw, bool details, const char *pmu_name)

{

	struct rblist groups;

	struct rb_node *node, *next;

	struct strlist *metriclist = NULL;

	const struct pmu_event *table;



	if (!metricgroups) {

		metriclist = strlist__new(NULL, NULL);
@@ -555,22 +583,22 @@ void metricgroup__print(bool metrics, bool metricgroups, char *filter, 
	groups.node_new = mep_new;

	groups.node_cmp = mep_cmp;

	groups.node_delete = mep_delete;

	for (const struct pmu_event *pe = pmu_events_table__find(); pe; pe++) {

	table = pmu_events_table__find();

	if (table) {

		struct metricgroup_print_data data = {

			.pmu_name = pmu_name,

			.metriclist = metriclist,

			.metricgroups = metricgroups,

			.filter = filter,

			.raw = raw,

			.details = details,

			.groups = &groups,

		};



		if (!pe->name && !pe->metric_group && !pe->metric_name)

			break;

		if (!pe->metric_expr)

			continue;

		if (pmu_name && perf_pmu__is_hybrid(pe->pmu) &&

		    strcmp(pmu_name, pe->pmu)) {

			continue;

		}

		if (metricgroup__print_pmu_event(pe, metricgroups, filter,

						 raw, details, &groups,

						 metriclist) < 0)

			return;

		pmu_events_table_for_each_event(table,

						metricgroup__print_callback,

						&data);

	}



	{

		struct metricgroup_iter_data data = {

			.fn = metricgroup__print_sys_event_iter,
@@ -1043,30 +1071,35 @@ static int __add_metric(struct list_head *metric_list, 
	return ret;

}



#define table_for_each_event(__pe, __idx, __table)					\

	if (__table)								\

		for (__idx = 0, __pe = &__table[__idx];				\

		     __pe->name || __pe->metric_group || __pe->metric_name;	\

		     __pe = &__table[++__idx])

struct metricgroup__find_metric_data {

	const char *metric;

	const struct pmu_event *pe;

};



static int metricgroup__find_metric_callback(const struct pmu_event *pe,

					     const struct pmu_event *table  __maybe_unused,

					     void *vdata)

{

	struct metricgroup__find_metric_data *data = vdata;



	if (!match_metric(pe->metric_name, data->metric))

		return 0;



#define table_for_each_metric(__pe, __idx, __table, __metric)		\

	table_for_each_event(__pe, __idx, __table)				\

		if (__pe->metric_expr &&				\

		    (match_metric(__pe->metric_group, __metric) ||	\

		     match_metric(__pe->metric_name, __metric)))

	data->pe = pe;

	return -1;

}



const struct pmu_event *metricgroup__find_metric(const char *metric,

						 const struct pmu_event *table)

{

	const struct pmu_event *pe;

	int i;

	struct metricgroup__find_metric_data data = {

		.metric = metric,

		.pe = NULL,

	};



	table_for_each_event(pe, i, table) {

		if (match_metric(pe->metric_name, metric))

			return pe;

	}

	pmu_events_table_for_each_event(table, metricgroup__find_metric_callback, &data);



	return NULL;

	return data.pe;

}



static int add_metric(struct list_head *metric_list,
@@ -1151,6 +1184,33 @@ static int metric_list_cmp(void *priv __maybe_unused, const struct list_head *l, 
	return right_count - left_count;

}



struct metricgroup__add_metric_data {

	struct list_head *list;

	const char *metric_name;

	const char *modifier;

	bool metric_no_group;

	bool has_match;

};



static int metricgroup__add_metric_callback(const struct pmu_event *pe,

					    const struct pmu_event *table,

					    void *vdata)

{

	struct metricgroup__add_metric_data *data = vdata;

	int ret = 0;



	if (pe->metric_expr &&

		(match_metric(pe->metric_group, data->metric_name) ||

		 match_metric(pe->metric_name, data->metric_name))) {



		data->has_match = true;

		ret = add_metric(data->list, pe, data->modifier, data->metric_no_group,

				 /*root_metric=*/NULL,

				 /*visited_metrics=*/NULL, table);

	}

	return ret;

}



/**

 * metricgroup__add_metric - Find and add a metric, or a metric group.

 * @metric_name: The name of the metric or metric group. For example, "IPC"
@@ -1169,24 +1229,29 @@ static int metricgroup__add_metric(const char *metric_name, const char *modifier 
				   struct list_head *metric_list,

				   const struct pmu_event *table)

{

	const struct pmu_event *pe;

	LIST_HEAD(list);

	int i, ret;

	int ret;

	bool has_match = false;



	{

		struct metricgroup__add_metric_data data = {

			.list = &list,

			.metric_name = metric_name,

			.modifier = modifier,

			.metric_no_group = metric_no_group,

			.has_match = false,

		};

		/*

	 * Iterate over all metrics seeing if metric matches either the name or

	 * group. When it does add the metric to the list.

		 * Iterate over all metrics seeing if metric matches either the

		 * name or group. When it does add the metric to the list.

		 */

	table_for_each_metric(pe, i, table, metric_name) {

		has_match = true;

		ret = add_metric(&list, pe, modifier, metric_no_group,

				 /*root_metric=*/NULL,

				 /*visited_metrics=*/NULL, table);

		ret = pmu_events_table_for_each_event(table, metricgroup__add_metric_callback,

						      &data);

		if (ret)

			goto out;

	}



		has_match = data.has_match;

	}

	{

		struct metricgroup_iter_data data = {

			.fn = metricgroup__add_metric_sys_event_iter,
@@ -1602,26 +1667,30 @@ int metricgroup__parse_groups_test(struct evlist *evlist, 
			    metric_no_merge, &perf_pmu__fake, metric_events, table);

}



static int metricgroup__has_metric_callback(const struct pmu_event *pe,

					    const struct pmu_event *table __maybe_unused,

					    void *vdata)

{

	const char *metric = vdata;



	if (!pe->metric_expr)

		return 0;



	if (match_metric(pe->metric_name, metric))

		return 1;



	return 0;

}



bool metricgroup__has_metric(const char *metric)

{

	const struct pmu_event *table = pmu_events_table__find();

	const struct pmu_event *pe;

	int i;



	if (!table)

		return false;



	for (i = 0; ; i++) {

		pe = &table[i];



		if (!pe->name && !pe->metric_group && !pe->metric_name)

			break;

		if (!pe->metric_expr)

			continue;

		if (match_metric(pe->metric_name, metric))

			return true;

	}

	return false;

	return pmu_events_table_for_each_event(table, metricgroup__has_metric_callback,

					       (void *)metric) ? true : false;

}



int metricgroup__copy_metric_events(struct evlist *evlist, struct cgroup *cgrp,