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

perf pmu-events: Avoid passing pmu_events_map 



Preparation for hiding pmu_events_map as an implementation detail. While
the map is passed, the table of events is all that is normally wanted.

While modifying the function's types, rename pmu_events_map__find to
pmu_events_table__find to match later encapsulation. Similarly rename
pmu_add_cpu_aliases_map to pmu_add_cpu_aliases_table.

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-7-irogers@google.com


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

tools/perf/arch/arm64/util/pmu.c

+2 −2
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ 
#include "../../../util/cpumap.h"

#include "../../../util/pmu.h"



const struct pmu_events_map *pmu_events_map__find(void)

const struct pmu_event *pmu_events_table__find(void)

{

	struct perf_pmu *pmu = NULL;
@@ -18,7 +18,7 @@ const struct pmu_events_map *pmu_events_map__find(void) 
		if (pmu->cpus->nr != cpu__max_cpu().cpu)

			return NULL;



		return perf_pmu__find_map(pmu);

		return perf_pmu__find_table(pmu);

	}



	return NULL;

tools/perf/tests/expand-cgroup.c

+1 −5
Original line number Diff line number Diff line
@@ -195,16 +195,12 @@ static int expand_metric_events(void) 
			.metric_name	= NULL,

		},

	};

	const struct pmu_events_map ev_map = {

		.cpuid		= "test",

		.table		= pme_test,

	};



	evlist = evlist__new();

	TEST_ASSERT_VAL("failed to get evlist", evlist);



	rblist__init(&metric_events);

	ret = metricgroup__parse_groups_test(evlist, &ev_map, metric_str,

	ret = metricgroup__parse_groups_test(evlist, pme_test, metric_str,

					     false, false, &metric_events);

	if (ret < 0) {

		pr_debug("failed to parse '%s' metric\n", metric_str);

tools/perf/tests/parse-metric.c

+1 −6
Original line number Diff line number Diff line
@@ -79,11 +79,6 @@ static struct pmu_event pme_test[] = { 
}

};



static const struct pmu_events_map map = {

	.cpuid		= "test",

	.table		= pme_test,

};



struct value {

	const char	*event;

	u64		 val;
@@ -166,7 +161,7 @@ static int __compute_metric(const char *name, struct value *vals, 
	runtime_stat__init(&st);



	/* Parse the metric into metric_events list. */

	err = metricgroup__parse_groups_test(evlist, &map, name,

	err = metricgroup__parse_groups_test(evlist, pme_test, name,

					     false, false,

					     &metric_events);

	if (err)

tools/perf/tests/pmu-events.c

+28 −35
Original line number Diff line number Diff line
@@ -272,13 +272,11 @@ static bool is_same(const char *reference, const char *test) 
	return !strcmp(reference, test);

}



static const struct pmu_events_map *__test_pmu_get_events_map(void)

static const struct pmu_event *__test_pmu_get_events_table(void)

{

	const struct pmu_events_map *map;



	for (map = &pmu_events_map[0]; map->cpuid; map++) {

	for (const struct pmu_events_map *map = &pmu_events_map[0]; map->cpuid; map++) {

		if (!strcmp(map->cpuid, "testcpu"))

			return map;

			return map->table;

	}



	pr_err("could not find test events map\n");
@@ -440,8 +438,7 @@ static int test__pmu_event_table(struct test_suite *test __maybe_unused, 
				 int subtest __maybe_unused)

{

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

	const struct pmu_events_map *map = __test_pmu_get_events_map();

	const struct pmu_event *table;

	const struct pmu_event *table = __test_pmu_get_events_table();

	int map_events = 0, expected_events;



	/* ignore 3x sentinels */
@@ -449,10 +446,10 @@ static int test__pmu_event_table(struct test_suite *test __maybe_unused, 
			  ARRAY_SIZE(uncore_events) +

			  ARRAY_SIZE(sys_events) - 3;



	if (!map || !sys_event_tables)

	if (!table || !sys_event_tables)

		return -1;



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

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

		struct perf_pmu_test_event const **test_event_table;

		bool found = false;
@@ -537,10 +534,10 @@ static int __test_core_pmu_event_aliases(char *pmu_name, int *count) 
	struct perf_pmu *pmu;

	LIST_HEAD(aliases);

	int res = 0;

	const struct pmu_events_map *map = __test_pmu_get_events_map();

	const struct pmu_event *table = __test_pmu_get_events_table();

	struct perf_pmu_alias *a, *tmp;



	if (!map)

	if (!table)

		return -1;



	test_event_table = &core_events[0];
@@ -551,7 +548,7 @@ static int __test_core_pmu_event_aliases(char *pmu_name, int *count) 


	pmu->name = pmu_name;



	pmu_add_cpu_aliases_map(&aliases, pmu, map);

	pmu_add_cpu_aliases_table(&aliases, pmu, table);



	for (; *test_event_table; test_event_table++) {

		struct perf_pmu_test_event const *test_event = *test_event_table;
@@ -590,14 +587,14 @@ static int __test_uncore_pmu_event_aliases(struct perf_pmu_test_pmu *test_pmu) 
	struct perf_pmu *pmu = &test_pmu->pmu;

	const char *pmu_name = pmu->name;

	struct perf_pmu_alias *a, *tmp, *alias;

	const struct pmu_events_map *map;

	const struct pmu_event *events_table;

	LIST_HEAD(aliases);

	int res = 0;



	map = __test_pmu_get_events_map();

	if (!map)

	events_table = __test_pmu_get_events_table();

	if (!events_table)

		return -1;

	pmu_add_cpu_aliases_map(&aliases, pmu, map);

	pmu_add_cpu_aliases_table(&aliases, pmu, events_table);

	pmu_add_sys_aliases(&aliases, pmu);



	/* Count how many aliases we generated */
@@ -848,13 +845,9 @@ static int check_parse_fake(const char *id) 
	return ret;

}



static void expr_failure(const char *msg,

			 const struct pmu_events_map *map,

			 const struct pmu_event *pe)

static void expr_failure(const char *msg, const struct pmu_event *pe)

{

	pr_debug("%s for map %s %s\n", msg, map->arch, map->cpuid);

	pr_debug("On metric %s\n", pe->metric_name);

	pr_debug("On expression %s\n", pe->metric_expr);

	pr_debug("%s\nOn metric %s\nOn expression %s\n", msg, pe->metric_name, pe->metric_expr);

}



struct metric {
@@ -864,7 +857,7 @@ struct metric { 


static int resolve_metric_simple(struct expr_parse_ctx *pctx,

				 struct list_head *compound_list,

				 const struct pmu_events_map *map,

				 const struct pmu_event *map,

				 const char *metric_name)

{

	struct hashmap_entry *cur, *cur_tmp;
@@ -925,8 +918,7 @@ static int resolve_metric_simple(struct expr_parse_ctx *pctx, 
static int test__parsing(struct test_suite *test __maybe_unused,

			 int subtest __maybe_unused)

{

	const struct pmu_events_map *cpus_map = pmu_events_map__find();

	const struct pmu_events_map *map;

	const struct pmu_event *cpus_table = pmu_events_table__find();

	const struct pmu_event *pe;

	int i, j, k;

	int ret = 0;
@@ -940,7 +932,8 @@ static int test__parsing(struct test_suite *test __maybe_unused, 
	}

	i = 0;

	for (;;) {

		map = &pmu_events_map[i++];

		const struct pmu_events_map *map = &pmu_events_map[i++];



		if (!map->table)

			break;

		j = 0;
@@ -957,14 +950,14 @@ static int test__parsing(struct test_suite *test __maybe_unused, 
				continue;

			expr__ctx_clear(ctx);

			if (expr__find_ids(pe->metric_expr, NULL, ctx) < 0) {

				expr_failure("Parse find ids failed", map, pe);

				expr_failure("Parse find ids failed", pe);

				ret++;

				continue;

			}



			if (resolve_metric_simple(ctx, &compound_list, map,

			if (resolve_metric_simple(ctx, &compound_list, map->table,

						  pe->metric_name)) {

				expr_failure("Could not resolve metrics", map, pe);

				expr_failure("Could not resolve metrics", pe);

				ret++;

				goto exit; /* Don't tolerate errors due to severity */

			}
@@ -979,7 +972,7 @@ static int test__parsing(struct test_suite *test __maybe_unused, 
				expr__add_id_val(ctx, strdup(cur->key), k++);



			hashmap__for_each_entry(ctx->ids, cur, bkt) {

				if (check_parse_cpu(cur->key, map == cpus_map,

				if (check_parse_cpu(cur->key, map->table == cpus_table,

						   pe))

					ret++;

			}
@@ -999,7 +992,7 @@ static int test__parsing(struct test_suite *test __maybe_unused, 
				hashmap__for_each_entry(ctx->ids, cur, bkt)

					expr__add_id_val(ctx, strdup(cur->key), k--);

				if (expr__parse(&result, ctx, pe->metric_expr)) {

					expr_failure("Parse failed", map, pe);

					expr_failure("Parse failed", pe);

					ret++;

				}

			}
@@ -1088,8 +1081,6 @@ static int metric_parse_fake(const char *str) 
static int test__parsing_fake(struct test_suite *test __maybe_unused,

			      int subtest __maybe_unused)

{

	const struct pmu_events_map *map;

	const struct pmu_event *pe;

	unsigned int i, j;

	int err = 0;
@@ -1101,12 +1092,14 @@ static int test__parsing_fake(struct test_suite *test __maybe_unused, 


	i = 0;

	for (;;) {

		map = &pmu_events_map[i++];

		const struct pmu_events_map *map = &pmu_events_map[i++];



		if (!map->table)

			break;

		j = 0;

		for (;;) {

			pe = &map->table[j++];

			const struct pmu_event *pe = &map->table[j++];



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

				break;

			if (!pe->metric_expr)

tools/perf/util/metricgroup.c

+39 −43
Original line number Diff line number Diff line
@@ -539,9 +539,6 @@ static int metricgroup__print_sys_event_iter(const struct pmu_event *pe, void *d 
void metricgroup__print(bool metrics, bool metricgroups, char *filter,

			bool raw, bool details, const char *pmu_name)

{

	const struct pmu_events_map *map = pmu_events_map__find();

	const struct pmu_event *pe;

	int i;

	struct rblist groups;

	struct rb_node *node, *next;

	struct strlist *metriclist = NULL;
@@ -556,8 +553,7 @@ 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 (i = 0; map; i++) {

		pe = &map->table[i];

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



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

			break;
@@ -850,7 +846,7 @@ struct metricgroup_add_iter_data { 
	bool metric_no_group;

	struct metric *root_metric;

	const struct visited_metric *visited;

	const struct pmu_events_map *map;

	const struct pmu_event *table;

};



static int add_metric(struct list_head *metric_list,
@@ -859,7 +855,7 @@ static int add_metric(struct list_head *metric_list, 
		      bool metric_no_group,

		      struct metric *root_metric,

		      const struct visited_metric *visited,

		      const struct pmu_events_map *map);

		      const struct pmu_event *table);



/**

 * resolve_metric - Locate metrics within the root metric and recursively add
@@ -874,7 +870,7 @@ static int add_metric(struct list_head *metric_list, 
 *               metrics. When adding a root this argument is NULL.

 * @visited: A singly linked list of metric names being added that is used to

 *           detect recursion.

 * @map: The map that is searched for metrics, most commonly the table for the

 * @table: The table that is searched for metrics, most commonly the table for the

 *       architecture perf is running upon.

 */

static int resolve_metric(struct list_head *metric_list,
@@ -882,7 +878,7 @@ static int resolve_metric(struct list_head *metric_list, 
			  bool metric_no_group,

			  struct metric *root_metric,

			  const struct visited_metric *visited,

			  const struct pmu_events_map *map)

			  const struct pmu_event *table)

{

	struct hashmap_entry *cur;

	size_t bkt;
@@ -904,7 +900,7 @@ static int resolve_metric(struct list_head *metric_list, 
	hashmap__for_each_entry(root_metric->pctx->ids, cur, bkt) {

		const struct pmu_event *pe;



		pe = metricgroup__find_metric(cur->key, map);

		pe = metricgroup__find_metric(cur->key, table);

		if (pe) {

			pending = realloc(pending,

					(pending_cnt + 1) * sizeof(struct to_resolve));
@@ -927,7 +923,7 @@ static int resolve_metric(struct list_head *metric_list, 
	 */

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

		ret = add_metric(metric_list, pending[i].pe, modifier, metric_no_group,

				root_metric, visited, map);

				root_metric, visited, table);

		if (ret)

			break;

	}
@@ -950,7 +946,7 @@ static int resolve_metric(struct list_head *metric_list, 
 *               metrics. When adding a root this argument is NULL.

 * @visited: A singly linked list of metric names being added that is used to

 *           detect recursion.

 * @map: The map that is searched for metrics, most commonly the table for the

 * @table: The table that is searched for metrics, most commonly the table for the

 *       architecture perf is running upon.

 */

static int __add_metric(struct list_head *metric_list,
@@ -960,7 +956,7 @@ static int __add_metric(struct list_head *metric_list, 
			int runtime,

			struct metric *root_metric,

			const struct visited_metric *visited,

			const struct pmu_events_map *map)

			const struct pmu_event *table)

{

	const struct visited_metric *vm;

	int ret;
@@ -1032,7 +1028,7 @@ static int __add_metric(struct list_head *metric_list, 
	} else {

		/* Resolve referenced metrics. */

		ret = resolve_metric(metric_list, modifier, metric_no_group, root_metric,

				     &visited_node, map);

				     &visited_node, table);

	}



	if (ret) {
@@ -1045,25 +1041,25 @@ static int __add_metric(struct list_head *metric_list, 
	return ret;

}



#define map_for_each_event(__pe, __idx, __map)					\

	if (__map)								\

		for (__idx = 0, __pe = &__map->table[__idx];			\

#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 = &__map->table[++__idx])

		     __pe = &__table[++__idx])



#define map_for_each_metric(__pe, __idx, __map, __metric)		\

	map_for_each_event(__pe, __idx, __map)				\

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



const struct pmu_event *metricgroup__find_metric(const char *metric,

						 const struct pmu_events_map *map)

						 const struct pmu_event *table)

{

	const struct pmu_event *pe;

	int i;



	map_for_each_event(pe, i, map) {

	table_for_each_event(pe, i, table) {

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

			return pe;

	}
@@ -1077,7 +1073,7 @@ static int add_metric(struct list_head *metric_list, 
		      bool metric_no_group,

		      struct metric *root_metric,

		      const struct visited_metric *visited,

		      const struct pmu_events_map *map)

		      const struct pmu_event *table)

{

	int ret = 0;
@@ -1085,7 +1081,7 @@ static int add_metric(struct list_head *metric_list, 


	if (!strstr(pe->metric_expr, "?")) {

		ret = __add_metric(metric_list, pe, modifier, metric_no_group, 0,

				   root_metric, visited, map);

				   root_metric, visited, table);

	} else {

		int j, count;
@@ -1098,7 +1094,7 @@ static int add_metric(struct list_head *metric_list, 


		for (j = 0; j < count && !ret; j++)

			ret = __add_metric(metric_list, pe, modifier, metric_no_group, j,

					root_metric, visited, map);

					root_metric, visited, table);

	}



	return ret;
@@ -1114,7 +1110,7 @@ static int metricgroup__add_metric_sys_event_iter(const struct pmu_event *pe, 
		return 0;



	ret = add_metric(d->metric_list, pe, d->modifier, d->metric_no_group,

			 d->root_metric, d->visited, d->map);

			 d->root_metric, d->visited, d->table);

	if (ret)

		goto out;
@@ -1162,13 +1158,13 @@ static int metric_list_cmp(void *priv __maybe_unused, const struct list_head *l, 
 *                   global. Grouping is the default but due to multiplexing the

 *                   user may override.

 * @metric_list: The list that the metric or metric group are added to.

 * @map: The map that is searched for metrics, most commonly the table for the

 * @table: The table that is searched for metrics, most commonly the table for the

 *       architecture perf is running upon.

 */

static int metricgroup__add_metric(const char *metric_name, const char *modifier,

				   bool metric_no_group,

				   struct list_head *metric_list,

				   const struct pmu_events_map *map)

				   const struct pmu_event *table)

{

	const struct pmu_event *pe;

	LIST_HEAD(list);
@@ -1179,11 +1175,11 @@ static int metricgroup__add_metric(const char *metric_name, const char *modifier 
	 * Iterate over all metrics seeing if metric matches either the name or

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

	 */

	map_for_each_metric(pe, i, map, metric_name) {

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

				 /*visited_metrics=*/NULL, table);

		if (ret)

			goto out;

	}
@@ -1198,7 +1194,7 @@ static int metricgroup__add_metric(const char *metric_name, const char *modifier 
				.metric_no_group = metric_no_group,

				.has_match = &has_match,

				.ret = &ret,

				.map = map,

				.table = table,

			},

		};
@@ -1227,12 +1223,12 @@ static int metricgroup__add_metric(const char *metric_name, const char *modifier 
 *                   global. Grouping is the default but due to multiplexing the

 *                   user may override.

 * @metric_list: The list that metrics are added to.

 * @map: The map that is searched for metrics, most commonly the table for the

 * @table: The table that is searched for metrics, most commonly the table for the

 *       architecture perf is running upon.

 */

static int metricgroup__add_metric_list(const char *list, bool metric_no_group,

					struct list_head *metric_list,

					const struct pmu_events_map *map)

					const struct pmu_event *table)

{

	char *list_itr, *list_copy, *metric_name, *modifier;

	int ret, count = 0;
@@ -1249,7 +1245,7 @@ static int metricgroup__add_metric_list(const char *list, bool metric_no_group, 


		ret = metricgroup__add_metric(metric_name, modifier,

					      metric_no_group, metric_list,

					      map);

					      table);

		if (ret == -EINVAL)

			pr_err("Cannot find metric or group `%s'\n", metric_name);
@@ -1440,7 +1436,7 @@ static int parse_groups(struct evlist *perf_evlist, const char *str, 
			bool metric_no_merge,

			struct perf_pmu *fake_pmu,

			struct rblist *metric_events_list,

			const struct pmu_events_map *map)

			const struct pmu_event *table)

{

	struct evlist *combined_evlist = NULL;

	LIST_HEAD(metric_list);
@@ -1451,7 +1447,7 @@ static int parse_groups(struct evlist *perf_evlist, const char *str, 
	if (metric_events_list->nr_entries == 0)

		metricgroup__rblist_init(metric_events_list);

	ret = metricgroup__add_metric_list(str, metric_no_group,

					   &metric_list, map);

					   &metric_list, table);

	if (ret)

		goto out;
@@ -1586,34 +1582,34 @@ int metricgroup__parse_groups(const struct option *opt, 
			      struct rblist *metric_events)

{

	struct evlist *perf_evlist = *(struct evlist **)opt->value;

	const struct pmu_events_map *map = pmu_events_map__find();

	const struct pmu_event *table = pmu_events_table__find();



	return parse_groups(perf_evlist, str, metric_no_group,

			    metric_no_merge, NULL, metric_events, map);

			    metric_no_merge, NULL, metric_events, table);

}



int metricgroup__parse_groups_test(struct evlist *evlist,

				   const struct pmu_events_map *map,

				   const struct pmu_event *table,

				   const char *str,

				   bool metric_no_group,

				   bool metric_no_merge,

				   struct rblist *metric_events)

{

	return parse_groups(evlist, str, metric_no_group,

			    metric_no_merge, &perf_pmu__fake, metric_events, map);

			    metric_no_merge, &perf_pmu__fake, metric_events, table);

}



bool metricgroup__has_metric(const char *metric)

{

	const struct pmu_events_map *map = pmu_events_map__find();

	const struct pmu_event *table = pmu_events_table__find();

	const struct pmu_event *pe;

	int i;



	if (!map)

	if (!table)

		return false;



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

		pe = &map->table[i];

		pe = &table[i];



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

			break;