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: Ian Rogers <irogers@google.com>
Tested-by: Kan 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: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 71c77d9d2744a990ff4ac01bea4fb8a4e97a82d0..9ca8e19bda006b0e8a904d134b8673a698e04071 100644 (file)
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -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 {

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index d9d964bbc0e245ca945a7de44cb6845eb80ec587..dea27bc0b376b8531f147acaa73653af907cf7de 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -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)
 {

diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index d4cbda6e946a1ad744aed1d0cb7c9203b5a390a0..7fe80b416143a6ffbb8f9fc9e4e28764a1bbc925 100644 (file)
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -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);

diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index abe0ce681d29369b1b30cf9a036fd3c30fa658bd..6deb70c2598457297cdf63242818d5fa6992ca0b 100644 (file)
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -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 ','; }

diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index c95877cbd6cfbca75329c84935c5f6bda488d34f..819a5123fd7780a784d26f8fd91ffdf6030d9237 100644 (file)
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -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;