perf parse-events: Use wildcard processing to set an event to merge into

The merge stat code fails for uncore events if they are repeated twice,
for example `perf stat -e clockticks,clockticks -I 1000` as the counts
of the second set of uncore events will be merged into the first
counter.

Reimplement the logic to have a first_wildcard_match so that merged
later events correctly merge into the first wildcard event that they
will be aggregated into.

Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: Chun-Tse Shao <ctshao@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: Dr. David Alan Gilbert <linux@treblig.org>
Cc: Howard Chu <howardchu95@gmail.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@linaro.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Levi Yun <yeoreum.yun@arm.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Weilin Wang <weilin.wang@intel.com>
Link: https://lore.kernel.org/r/20250513215401.2315949-3-ctshao@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 34409828f8ec46b71c402151a22f66d4416a5ef0..d55482f094bf95ac7b5c5173c1341baeb0fa9c93 100644 (file)
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -552,11 +552,11 @@ struct evsel *evsel__clone(struct evsel *dest, struct evsel *orig)
 
        evsel->exclude_GH = orig->exclude_GH;
        evsel->sample_read = orig->sample_read;
-       evsel->auto_merge_stats = orig->auto_merge_stats;
        evsel->collect_stat = orig->collect_stat;
        evsel->weak_group = orig->weak_group;
        evsel->use_config_name = orig->use_config_name;
        evsel->pmu = orig->pmu;
+       evsel->first_wildcard_match = orig->first_wildcard_match;
 
        if (evsel__copy_config_terms(evsel, orig) < 0)
                goto out_err;
@@ -3964,11 +3964,6 @@ bool evsel__set_needs_uniquify(struct evsel *counter, const struct perf_stat_con
                return true;
        }
 
-       if (counter->merged_stat) {
-               /* Counter won't be shown. */
-               return false;
-       }
-
        if (counter->use_config_name || counter->is_libpfm_event) {
                /* Original name will be used. */
                return false;
@@ -3997,12 +3992,21 @@ bool evsel__set_needs_uniquify(struct evsel *counter, const struct perf_stat_con
                return true;
        }
 
+       if (counter->first_wildcard_match != NULL) {
+               /*
+                * If stats are merged then only the first_wildcard_match is
+                * displayed, there is no need to uniquify this evsel as the
+                * name won't be shown.
+                */
+               return false;
+       }
+
        /*
         * Do other non-merged events in the evlist have the same name? If so
         * uniquify is necessary.
         */
        evlist__for_each_entry(counter->evlist, evsel) {
-               if (evsel == counter || evsel->merged_stat || evsel->pmu == counter->pmu)
+               if (evsel == counter || evsel->first_wildcard_match || evsel->pmu == counter->pmu)
                        continue;
 
                if (evsel__name_is(counter, evsel__name(evsel))) {

diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index df8d2eea04653004832fba9905603d9b9f300f71..6dbc9690e0c9258c8cff0fc2971bae39077b0ea0 100644 (file)
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -70,6 +70,11 @@ struct evsel {
                const char              *unit;
                struct cgroup           *cgrp;
                const char              *metric_id;
+               /*
+                * This point to the first evsel with the same name, intended to store the
+                * aggregated counts in aggregation mode.
+                */
+               struct evsel            *first_wildcard_match;
                /* parse modifier helper */
                int                     exclude_GH;
                int                     sample_read;
@@ -78,7 +83,6 @@ struct evsel {
                bool                    percore;
                bool                    precise_max;
                bool                    is_libpfm_event;
-               bool                    auto_merge_stats;
                bool                    collect_stat;
                bool                    weak_group;
                bool                    bpf_counter;
@@ -115,7 +119,6 @@ struct evsel {
        bool                    ignore_missing_thread;
        bool                    forced_leader;
        bool                    cmdline_group_boundary;
-       bool                    merged_stat;
        bool                    reset_group;
        bool                    errored;
        bool                    needs_auxtrace_mmap;

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index e4ef8a828ac9f76b6769f3d57c95d9b5c4c0b46c..2380de56a207461dea9b6e75fc42fde0919623a9 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -250,13 +250,34 @@ __add_event(struct list_head *list, int *idx,
            struct perf_event_attr *attr,
            bool init_attr,
            const char *name, const char *metric_id, struct perf_pmu *pmu,
-           struct list_head *config_terms, bool auto_merge_stats,
+           struct list_head *config_terms, struct evsel *first_wildcard_match,
            struct perf_cpu_map *cpu_list, u64 alternate_hw_config)
 {
        struct evsel *evsel;
        bool is_pmu_core;
        struct perf_cpu_map *cpus;
 
+       /*
+        * Ensure the first_wildcard_match's PMU matches that of the new event
+        * being added. Otherwise try to match with another event further down
+        * the evlist.
+        */
+       if (first_wildcard_match) {
+               struct evsel *pos = list_prev_entry(first_wildcard_match, core.node);
+
+               first_wildcard_match = NULL;
+               list_for_each_entry_continue(pos, list, core.node) {
+                       if (perf_pmu__name_no_suffix_match(pos->pmu, pmu->name)) {
+                               first_wildcard_match = pos;
+                               break;
+                       }
+                       if (pos->pmu->is_core && (!pmu || pmu->is_core)) {
+                               first_wildcard_match = pos;
+                               break;
+                       }
+               }
+       }
+
        if (pmu) {
                is_pmu_core = pmu->is_core;
                cpus = perf_cpu_map__get(perf_cpu_map__is_empty(cpu_list) ? pmu->cpus : cpu_list);
@@ -293,9 +314,9 @@ __add_event(struct list_head *list, int *idx,
        evsel->core.own_cpus = perf_cpu_map__get(cpus);
        evsel->core.requires_cpu = pmu ? pmu->is_uncore : false;
        evsel->core.is_pmu_core = is_pmu_core;
-       evsel->auto_merge_stats = auto_merge_stats;
        evsel->pmu = pmu;
        evsel->alternate_hw_config = alternate_hw_config;
+       evsel->first_wildcard_match = first_wildcard_match;
 
        if (name)
                evsel->name = strdup(name);
@@ -318,7 +339,7 @@ struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
 {
        return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name,
                           metric_id, pmu, /*config_terms=*/NULL,
-                          /*auto_merge_stats=*/false, /*cpu_list=*/NULL,
+                          /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL,
                           /*alternate_hw_config=*/PERF_COUNT_HW_MAX);
 }
 
@@ -329,7 +350,7 @@ static int add_event(struct list_head *list, int *idx,
 {
        return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id,
                           /*pmu=*/NULL, config_terms,
-                          /*auto_merge_stats=*/false, /*cpu_list=*/NULL,
+                          /*first_wildcard_match=*/NULL, /*cpu_list=*/NULL,
                           alternate_hw_config) ? 0 : -ENOMEM;
 }
 
@@ -454,7 +475,7 @@ bool parse_events__filter_pmu(const struct parse_events_state *parse_state,
 static int parse_events_add_pmu(struct parse_events_state *parse_state,
                                struct list_head *list, struct perf_pmu *pmu,
                                const struct parse_events_terms *const_parsed_terms,
-                               bool auto_merge_stats, u64 alternate_hw_config);
+                               struct evsel *first_wildcard_match, u64 alternate_hw_config);
 
 int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
                           struct parse_events_state *parse_state,
@@ -466,6 +487,7 @@ int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
        const char *metric_id = get_config_metric_id(parsed_terms);
        struct perf_cpu_map *cpus = get_config_cpu(parsed_terms);
        int ret = 0;
+       struct evsel *first_wildcard_match = NULL;
 
        while ((pmu = perf_pmus__scan(pmu)) != NULL) {
                LIST_HEAD(config_terms);
@@ -481,10 +503,13 @@ int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
                         */
                        ret = parse_events_add_pmu(parse_state, list, pmu,
                                                   parsed_terms,
-                                                  perf_pmu__auto_merge_stats(pmu),
+                                                  first_wildcard_match,
                                                   /*alternate_hw_config=*/PERF_COUNT_HW_MAX);
                        if (ret)
                                goto out_err;
+                       if (first_wildcard_match == NULL)
+                               first_wildcard_match =
+                                       container_of(list->prev, struct evsel, core.node);
                        continue;
                }
 
@@ -515,10 +540,12 @@ int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
                }
 
                if (__add_event(list, idx, &attr, /*init_attr*/true, config_name ?: name,
-                               metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
+                               metric_id, pmu, &config_terms, first_wildcard_match,
                                cpus, /*alternate_hw_config=*/PERF_COUNT_HW_MAX) == NULL)
                        ret = -ENOMEM;
 
+               if (first_wildcard_match == NULL)
+                       first_wildcard_match = container_of(list->prev, struct evsel, core.node);
                free_config_terms(&config_terms);
                if (ret)
                        goto out_err;
@@ -1387,7 +1414,8 @@ int parse_events_add_tracepoint(struct parse_events_state *parse_state,
 static int __parse_events_add_numeric(struct parse_events_state *parse_state,
                                struct list_head *list,
                                struct perf_pmu *pmu, u32 type, u32 extended_type,
-                               u64 config, const struct parse_events_terms *head_config)
+                               u64 config, const struct parse_events_terms *head_config,
+                               struct evsel *first_wildcard_match)
 {
        struct perf_event_attr attr;
        LIST_HEAD(config_terms);
@@ -1416,7 +1444,7 @@ static int __parse_events_add_numeric(struct parse_events_state *parse_state,
        metric_id = get_config_metric_id(head_config);
        cpus = get_config_cpu(head_config);
        ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name,
-                       metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
+                       metric_id, pmu, &config_terms, first_wildcard_match,
                        cpus, /*alternate_hw_config=*/PERF_COUNT_HW_MAX) ? 0 : -ENOMEM;
        perf_cpu_map__put(cpus);
        free_config_terms(&config_terms);
@@ -1434,6 +1462,7 @@ int parse_events_add_numeric(struct parse_events_state *parse_state,
 
        /* Wildcards on numeric values are only supported by core PMUs. */
        if (wildcard && perf_pmus__supports_extended_type()) {
+               struct evsel *first_wildcard_match = NULL;
                while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
                        int ret;
 
@@ -1443,15 +1472,20 @@ int parse_events_add_numeric(struct parse_events_state *parse_state,
 
                        ret = __parse_events_add_numeric(parse_state, list, pmu,
                                                         type, pmu->type,
-                                                        config, head_config);
+                                                        config, head_config,
+                                                        first_wildcard_match);
                        if (ret)
                                return ret;
+                       if (first_wildcard_match == NULL)
+                               first_wildcard_match =
+                                       container_of(list->prev, struct evsel, core.node);
                }
                if (found_supported)
                        return 0;
        }
        return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type),
-                                       type, /*extended_type=*/0, config, head_config);
+                                       type, /*extended_type=*/0, config, head_config,
+                                       /*first_wildcard_match=*/NULL);
 }
 
 static bool config_term_percore(struct list_head *config_terms)
@@ -1469,7 +1503,7 @@ static bool config_term_percore(struct list_head *config_terms)
 static int parse_events_add_pmu(struct parse_events_state *parse_state,
                                struct list_head *list, struct perf_pmu *pmu,
                                const struct parse_events_terms *const_parsed_terms,
-                               bool auto_merge_stats, u64 alternate_hw_config)
+                               struct evsel *first_wildcard_match, u64 alternate_hw_config)
 {
        struct perf_event_attr attr;
        struct perf_pmu_info info;
@@ -1506,7 +1540,7 @@ static int parse_events_add_pmu(struct parse_events_state *parse_state,
                evsel = __add_event(list, &parse_state->idx, &attr,
                                    /*init_attr=*/true, /*name=*/NULL,
                                    /*metric_id=*/NULL, pmu,
-                                   /*config_terms=*/NULL, auto_merge_stats,
+                                   /*config_terms=*/NULL, first_wildcard_match,
                                    /*cpu_list=*/NULL, alternate_hw_config);
                return evsel ? 0 : -ENOMEM;
        }
@@ -1577,7 +1611,7 @@ static int parse_events_add_pmu(struct parse_events_state *parse_state,
        evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true,
                            get_config_name(&parsed_terms),
                            get_config_metric_id(&parsed_terms), pmu,
-                           &config_terms, auto_merge_stats, term_cpu, alternate_hw_config);
+                           &config_terms, first_wildcard_match, term_cpu, alternate_hw_config);
        perf_cpu_map__put(term_cpu);
        if (!evsel) {
                parse_events_terms__exit(&parsed_terms);
@@ -1614,6 +1648,7 @@ int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
        int ok = 0;
        const char *config;
        struct parse_events_terms parsed_terms;
+       struct evsel *first_wildcard_match = NULL;
 
        *listp = NULL;
 
@@ -1646,17 +1681,14 @@ int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
        INIT_LIST_HEAD(list);
 
        while ((pmu = perf_pmus__scan(pmu)) != NULL) {
-               bool auto_merge_stats;
-
                if (parse_events__filter_pmu(parse_state, pmu))
                        continue;
 
                if (!perf_pmu__have_event(pmu, event_name))
                        continue;
 
-               auto_merge_stats = perf_pmu__auto_merge_stats(pmu);
                if (!parse_events_add_pmu(parse_state, list, pmu,
-                                         &parsed_terms, auto_merge_stats, hw_config)) {
+                                         &parsed_terms, first_wildcard_match, hw_config)) {
                        struct strbuf sb;
 
                        strbuf_init(&sb, /*hint=*/ 0);
@@ -1665,11 +1697,13 @@ int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
                        strbuf_release(&sb);
                        ok++;
                }
+               if (first_wildcard_match == NULL)
+                       first_wildcard_match = container_of(list->prev, struct evsel, core.node);
        }
 
        if (parse_state->fake_pmu) {
                if (!parse_events_add_pmu(parse_state, list, perf_pmus__fake_pmu(), &parsed_terms,
-                                         /*auto_merge_stats=*/true, hw_config)) {
+                                        first_wildcard_match, hw_config)) {
                        struct strbuf sb;
 
                        strbuf_init(&sb, /*hint=*/ 0);
@@ -1700,6 +1734,7 @@ int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state
        struct perf_pmu *pmu;
        int ok = 0;
        char *help;
+       struct evsel *first_wildcard_match = NULL;
 
        *listp = malloc(sizeof(**listp));
        if (!*listp)
@@ -1710,14 +1745,14 @@ int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state
        /* Attempt to add to list assuming event_or_pmu is a PMU name. */
        pmu = perf_pmus__find(event_or_pmu);
        if (pmu && !parse_events_add_pmu(parse_state, *listp, pmu, const_parsed_terms,
-                                        /*auto_merge_stats=*/false,
+                                        first_wildcard_match,
                                         /*alternate_hw_config=*/PERF_COUNT_HW_MAX))
                return 0;
 
        if (parse_state->fake_pmu) {
                if (!parse_events_add_pmu(parse_state, *listp, perf_pmus__fake_pmu(),
                                          const_parsed_terms,
-                                         /*auto_merge_stats=*/false,
+                                         first_wildcard_match,
                                          /*alternate_hw_config=*/PERF_COUNT_HW_MAX))
                        return 0;
        }
@@ -1727,15 +1762,16 @@ int parse_events_multi_pmu_add_or_add_pmu(struct parse_events_state *parse_state
        while ((pmu = perf_pmus__scan(pmu)) != NULL) {
                if (!parse_events__filter_pmu(parse_state, pmu) &&
                    perf_pmu__wildcard_match(pmu, event_or_pmu)) {
-                       bool auto_merge_stats = perf_pmu__auto_merge_stats(pmu);
-
                        if (!parse_events_add_pmu(parse_state, *listp, pmu,
                                                  const_parsed_terms,
-                                                 auto_merge_stats,
+                                                 first_wildcard_match,
                                                  /*alternate_hw_config=*/PERF_COUNT_HW_MAX)) {
                                ok++;
                                parse_state->wild_card_pmus = true;
                        }
+                       if (first_wildcard_match == NULL)
+                               first_wildcard_match =
+                                       container_of((*listp)->prev, struct evsel, core.node);
                }
        }
        if (ok)

diff --git a/tools/perf/util/stat-display.c b/tools/perf/util/stat-display.c
index c022afb28514a4ece7c83fa85b6892c5f60a081c..729ad5cd52cb486e3c83761c68a939a841b90584 100644 (file)
--- a/tools/perf/util/stat-display.c
+++ b/tools/perf/util/stat-display.c
@@ -1002,8 +1002,15 @@ static void print_counter_aggrdata(struct perf_stat_config *config,
        os->evsel = counter;
 
        /* Skip already merged uncore/hybrid events */
-       if (counter->merged_stat)
-               return;
+       if (config->aggr_mode != AGGR_NONE) {
+               if (evsel__is_hybrid(counter)) {
+                       if (config->hybrid_merge && counter->first_wildcard_match != NULL)
+                               return;
+               } else {
+                       if (counter->first_wildcard_match != NULL)
+                               return;
+               }
+       }
 
        val = aggr->counts.val;
        ena = aggr->counts.ena;

diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index 1f7abd8754c75b5d5f80b48ab4227ab3f5e04733..355a7d5c8ab88a369487c4168bd2eee16ea1513d 100644 (file)
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -535,35 +535,6 @@ static int evsel__merge_aggr_counters(struct evsel *evsel, struct evsel *alias)
 
        return 0;
 }
-/*
- * Events should have the same name, scale, unit, cgroup but on different core
- * PMUs or on different but matching uncore PMUs.
- */
-static bool evsel__is_alias(struct evsel *evsel_a, struct evsel *evsel_b)
-{
-       if (strcmp(evsel__name(evsel_a), evsel__name(evsel_b)))
-               return false;
-
-       if (evsel_a->scale != evsel_b->scale)
-               return false;
-
-       if (evsel_a->cgrp != evsel_b->cgrp)
-               return false;
-
-       if (strcmp(evsel_a->unit, evsel_b->unit))
-               return false;
-
-       if (evsel__is_clock(evsel_a) != evsel__is_clock(evsel_b))
-               return false;
-
-       if (evsel_a->pmu == evsel_b->pmu || evsel_a->pmu == NULL || evsel_b->pmu == NULL)
-               return false;
-
-       if (evsel_a->pmu->is_core)
-               return evsel_b->pmu->is_core;
-
-       return perf_pmu__name_no_suffix_match(evsel_a->pmu, evsel_b->pmu->name);
-}
 
 static void evsel__merge_aliases(struct evsel *evsel)
 {
@@ -572,10 +543,9 @@ static void evsel__merge_aliases(struct evsel *evsel)
 
        alias = list_prepare_entry(evsel, &(evlist->core.entries), core.node);
        list_for_each_entry_continue(alias, &evlist->core.entries, core.node) {
-               /* Merge the same events on different PMUs. */
-               if (evsel__is_alias(evsel, alias)) {
+               if (alias->first_wildcard_match == evsel) {
+                       /* Merge the same events on different PMUs. */
                        evsel__merge_aggr_counters(evsel, alias);
-                       alias->merged_stat = true;
                }
        }
 }
@@ -588,11 +558,7 @@ static bool evsel__should_merge_hybrid(const struct evsel *evsel,
 
 static void evsel__merge_stats(struct evsel *evsel, struct perf_stat_config *config)
 {
-       /* this evsel is already merged */
-       if (evsel->merged_stat)
-               return;
-
-       if (evsel->auto_merge_stats || evsel__should_merge_hybrid(evsel, config))
+       if (!evsel->pmu || !evsel->pmu->is_core || evsel__should_merge_hybrid(evsel, config))
                evsel__merge_aliases(evsel);
 }