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

perf parse-events: Support hardware events as terms 



An event like "cpu/instructions/" typically parses due to there being
a sysfs event called instructions. On hybrid recursive parsing means
that the hardware event is encoded in the attribute, with the PMU
being placed in the high bits of the config:

'''
$ perf stat -vv -e 'cpu_core/cycles/' true
...
------------------------------------------------------------
perf_event_attr:
  size                             136
  config                           0x400000000
  sample_type                      IDENTIFIER
  read_format                      TOTAL_TIME_ENABLED|TOTAL_TIME_RUNNING
  disabled                         1
  inherit                          1
  enable_on_exec                   1
  exclude_guest                    1
------------------------------------------------------------
'''

Make this behavior the default by adding a new term type and token for
hardware events. The token gathers both the numeric config and the
parsed name, so that if the token appears like "cycles/name=cycles/"
then the token can be handled like a name. The numeric value isn't
sufficient to distinguish say "cpu-cycles" from "cycles".

Extend the parse-events test so that all current non-PMU hardware
parsing tests, also test with the PMU cpu - more than half the change.

Signed-off-by: default avatarIan Rogers <irogers@google.com>
Tested-by: default avatarKan Liang <kan.liang@linux.intel.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ahmad Yasin <ahmad.yasin@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Athira Rajeev <atrajeev@linux.vnet.ibm.com>
Cc: Caleb Biggers <caleb.biggers@intel.com>
Cc: Edward Baker <edward.baker@intel.com>
Cc: Florian Fischer <florian.fischer@muhq.space>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Kajol Jain <kjain@linux.ibm.com>
Cc: Kang Minchul <tegongkang@gmail.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Perry Taylor <perry.taylor@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Rob Herring <robh@kernel.org>
Cc: Samantha Alt <samantha.alt@intel.com>
Cc: Stephane Eranian <eranian@google.com>
Cc: Sumanth Korikkar <sumanthk@linux.ibm.com>
Cc: Suzuki Poulouse <suzuki.poulose@arm.com>
Cc: Thomas Richter <tmricht@linux.ibm.com>
Cc: Tiezhu Yang <yangtiezhu@loongson.cn>
Cc: Weilin Wang <weilin.wang@intel.com>
Cc: Xing Zhengjun <zhengjun.xing@linux.intel.com>
Cc: Yang Jihong <yangjihong1@huawei.com>
Link: https://lore.kernel.org/r/20230502223851.2234828-34-irogers@google.com


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

tools/perf/tests/parse-events.c

+126 −0
Original line number Diff line number Diff line
@@ -1926,6 +1926,132 @@ static const struct evlist_test test__events_pmu[] = { 
		.check = test__checkevent_config_cache,

		/* 8 */

	},

	{

		.name  = "cpu/instructions/",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_symbolic_name,

		/* 9 */

	},

	{

		.name  = "cpu/cycles,period=100000,config2/",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_symbolic_name_config,

		/* 0 */

	},

	{

		.name  = "cpu/instructions/h",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_symbolic_name_modifier,

		/* 1 */

	},

	{

		.name  = "cpu/instructions/G",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_exclude_host_modifier,

		/* 2 */

	},

	{

		.name  = "cpu/instructions/H",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_exclude_guest_modifier,

		/* 3 */

	},

	{

		.name  = "{cpu/instructions/k,cpu/cycles/upp}",

		.valid = test__pmu_cpu_valid,

		.check = test__group1,

		/* 4 */

	},

	{

		.name  = "{cpu/cycles/u,cpu/instructions/kp}:p",

		.valid = test__pmu_cpu_valid,

		.check = test__group4,

		/* 5 */

	},

	{

		.name  = "{cpu/cycles/,cpu/cache-misses/G}:H",

		.valid = test__pmu_cpu_valid,

		.check = test__group_gh1,

		/* 6 */

	},

	{

		.name  = "{cpu/cycles/,cpu/cache-misses/H}:G",

		.valid = test__pmu_cpu_valid,

		.check = test__group_gh2,

		/* 7 */

	},

	{

		.name  = "{cpu/cycles/G,cpu/cache-misses/H}:u",

		.valid = test__pmu_cpu_valid,

		.check = test__group_gh3,

		/* 8 */

	},

	{

		.name  = "{cpu/cycles/G,cpu/cache-misses/H}:uG",

		.valid = test__pmu_cpu_valid,

		.check = test__group_gh4,

		/* 9 */

	},

	{

		.name  = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:S",

		.valid = test__pmu_cpu_valid,

		.check = test__leader_sample1,

		/* 0 */

	},

	{

		.name  = "{cpu/instructions/,cpu/branch-misses/}:Su",

		.valid = test__pmu_cpu_valid,

		.check = test__leader_sample2,

		/* 1 */

	},

	{

		.name  = "cpu/instructions/uDp",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_pinned_modifier,

		/* 2 */

	},

	{

		.name  = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:D",

		.valid = test__pmu_cpu_valid,

		.check = test__pinned_group,

		/* 3 */

	},

	{

		.name  = "cpu/instructions/I",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_exclude_idle_modifier,

		/* 4 */

	},

	{

		.name  = "cpu/instructions/kIG",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_exclude_idle_modifier_1,

		/* 5 */

	},

	{

		.name  = "cpu/cycles/u",

		.valid = test__pmu_cpu_valid,

		.check = test__sym_event_slash,

		/* 6 */

	},

	{

		.name  = "cpu/cycles/k",

		.valid = test__pmu_cpu_valid,

		.check = test__sym_event_dc,

		/* 7 */

	},

	{

		.name  = "cpu/instructions/uep",

		.valid = test__pmu_cpu_valid,

		.check = test__checkevent_exclusive_modifier,

		/* 8 */

	},

	{

		.name  = "{cpu/cycles/,cpu/cache-misses/,cpu/branch-misses/}:e",

		.valid = test__pmu_cpu_valid,

		.check = test__exclusive_group,

		/* 9 */

	},

};



struct terms_test {

tools/perf/util/parse-events.c

+12 −25
Original line number Diff line number Diff line
@@ -1052,6 +1052,7 @@ static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = { 
	[PARSE_EVENTS__TERM_TYPE_METRIC_ID]		= "metric-id",

	[PARSE_EVENTS__TERM_TYPE_RAW]                   = "raw",

	[PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE]          = "legacy-cache",

	[PARSE_EVENTS__TERM_TYPE_HARDWARE]              = "hardware",

};



static bool config_term_shrinked;
@@ -1239,6 +1240,17 @@ static int config_term_pmu(struct perf_event_attr *attr, 
		} else

			term->type_term = PARSE_EVENTS__TERM_TYPE_USER;

	}

	if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) {

		const struct perf_pmu *pmu = perf_pmu__find_by_type(attr->type);



		if (!pmu) {

			pr_debug("Failed to find PMU for type %d", attr->type);

			return -EINVAL;

		}

		attr->type = PERF_TYPE_HARDWARE;

		attr->config = ((__u64)pmu->type << PERF_PMU_TYPE_SHIFT) | term->val.num;

		return 0;

	}

	if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||

	    term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) {

		/*
@@ -2569,31 +2581,6 @@ int parse_events_term__str(struct parse_events_term **term, 
	return new_term(term, &temp, str, 0);

}



int parse_events_term__sym_hw(struct parse_events_term **term,

			      char *config, unsigned idx)

{

	struct event_symbol *sym;

	char *str;

	struct parse_events_term temp = {

		.type_val  = PARSE_EVENTS__TERM_TYPE_STR,

		.type_term = PARSE_EVENTS__TERM_TYPE_USER,

		.config    = config,

	};



	if (!temp.config) {

		temp.config = strdup("event");

		if (!temp.config)

			return -ENOMEM;

	}

	BUG_ON(idx >= PERF_COUNT_HW_MAX);

	sym = &event_symbols_hw[idx];



	str = strdup(sym->symbol);

	if (!str)

		return -ENOMEM;

	return new_term(term, &temp, str, 0);

}



int parse_events_term__clone(struct parse_events_term **new,

			     struct parse_events_term *term)

{

tools/perf/util/parse-events.h

+1 −2
Original line number Diff line number Diff line
@@ -79,6 +79,7 @@ enum { 
	PARSE_EVENTS__TERM_TYPE_METRIC_ID,

	PARSE_EVENTS__TERM_TYPE_RAW,

	PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE,

	PARSE_EVENTS__TERM_TYPE_HARDWARE,

	__PARSE_EVENTS__TERM_TYPE_NR,

};
@@ -147,8 +148,6 @@ int parse_events_term__num(struct parse_events_term **term, 
int parse_events_term__str(struct parse_events_term **term,

			   int type_term, char *config, char *str,

			   void *loc_term, void *loc_val);

int parse_events_term__sym_hw(struct parse_events_term **term,

			      char *config, unsigned idx);

int parse_events_term__clone(struct parse_events_term **new,

			     struct parse_events_term *term);

void parse_events_term__delete(struct parse_events_term *term);

tools/perf/util/parse-events.l

+20 −0
Original line number Diff line number Diff line
@@ -149,6 +149,16 @@ static int term(yyscan_t scanner, int type) 
	return PE_TERM;

}



static int hw_term(yyscan_t scanner, int config)

{

	YYSTYPE *yylval = parse_events_get_lval(scanner);

	char *text = parse_events_get_text(scanner);



	yylval->hardware_term.str = strdup(text);

	yylval->hardware_term.num = PERF_TYPE_HARDWARE + config;

	return PE_TERM_HW;

}



#define YY_USER_ACTION					\

do {							\

	yylloc->last_column  = yylloc->first_column;	\
@@ -269,6 +279,16 @@ percore { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_PERCORE); } 
aux-output		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT); }

aux-sample-size		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE); }

metric-id		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_METRIC_ID); }

cpu-cycles|cycles				{ return hw_term(yyscanner, PERF_COUNT_HW_CPU_CYCLES); }

stalled-cycles-frontend|idle-cycles-frontend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }

stalled-cycles-backend|idle-cycles-backend	{ return hw_term(yyscanner, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }

instructions					{ return hw_term(yyscanner, PERF_COUNT_HW_INSTRUCTIONS); }

cache-references				{ return hw_term(yyscanner, PERF_COUNT_HW_CACHE_REFERENCES); }

cache-misses					{ return hw_term(yyscanner, PERF_COUNT_HW_CACHE_MISSES); }

branch-instructions|branches			{ return hw_term(yyscanner, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }

branch-misses					{ return hw_term(yyscanner, PERF_COUNT_HW_BRANCH_MISSES); }

bus-cycles					{ return hw_term(yyscanner, PERF_COUNT_HW_BUS_CYCLES); }

ref-cycles					{ return hw_term(yyscanner, PERF_COUNT_HW_REF_CPU_CYCLES); }

r{num_raw_hex}		{ return str(yyscanner, PE_RAW); }

r0x{num_raw_hex}	{ return str(yyscanner, PE_RAW); }

,			{ return ','; }

tools/perf/util/parse-events.y

+28 −6
Original line number Diff line number Diff line
@@ -65,6 +65,7 @@ static void free_list_evsel(struct list_head* list_evsel) 
%token PE_KERNEL_PMU_EVENT PE_PMU_EVENT_FAKE

%token PE_ARRAY_ALL PE_ARRAY_RANGE

%token PE_DRV_CFG_TERM

%token PE_TERM_HW

%type <num> PE_VALUE

%type <num> PE_VALUE_SYM_HW

%type <num> PE_VALUE_SYM_SW
@@ -112,6 +113,8 @@ static void free_list_evsel(struct list_head* list_evsel) 
%type <array> array_term

%type <array> array_terms

%destructor { free ($$.ranges); } <array>

%type <hardware_term> PE_TERM_HW

%destructor { free ($$.str); } <hardware_term>



%union

{
@@ -125,6 +128,10 @@ static void free_list_evsel(struct list_head* list_evsel) 
		char *event;

	} tracepoint_name;

	struct parse_events_array array;

	struct hardware_term {

		char *str;

		u64 num;

	} hardware_term;

}

%%
@@ -770,13 +777,14 @@ name_or_raw '=' PE_VALUE 
	$$ = term;

}

|

name_or_raw '=' PE_VALUE_SYM_HW

name_or_raw '=' PE_TERM_HW

{

	struct parse_events_term *term;

	int config = $3 & 255;



	if (parse_events_term__sym_hw(&term, $1, config)) {

	if (parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,

					$1, $3.str, &@1, &@3)) {

		free($1);

		free($3.str);

		YYABORT;

	}

	$$ = term;
@@ -806,12 +814,15 @@ PE_NAME 
	$$ = term;

}

|

PE_VALUE_SYM_HW

PE_TERM_HW

{

	struct parse_events_term *term;

	int config = $1 & 255;



	ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));

	if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_HARDWARE,

				   $1.str, $1.num & 255, false, &@1, NULL)) {

		free($1.str);

		YYABORT;

	}

	$$ = term;

}

|
@@ -826,6 +837,17 @@ PE_TERM '=' PE_NAME 
	$$ = term;

}

|

PE_TERM '=' PE_TERM_HW

{

	struct parse_events_term *term;



	if (parse_events_term__str(&term, (int)$1, NULL, $3.str, &@1, &@3)) {

		free($3.str);

		YYABORT;

	}

	$$ = term;

}

|

PE_TERM '=' PE_VALUE

{

	struct parse_events_term *term;