perf stat: Avoid wildcarding PMUs for default events

Without a PMU perf matches an event against any PMU with the
event. Unfortunately some PMU drivers advertise a "cycles" event which
is typically just a core event. To make perf's behavior consistent,
just look up default events with their designated PMU types.

Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: James Clark <james.clark@linaro.org>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 4314012846ba346799f2df010d01747f5978ea0c..3c3188a57016f8b71951360126e5f063dfad9d1f 100644 (file)
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -1853,6 +1853,38 @@ static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
        return 0;
 }
 
+/* Add given software event to evlist without wildcarding. */
+static int parse_software_event(struct evlist *evlist, const char *event,
+                               struct parse_events_error *err)
+{
+       char buf[256];
+
+       snprintf(buf, sizeof(buf), "software/%s,name=%s/", event, event);
+       return parse_events(evlist, buf, err);
+}
+
+/* Add legacy hardware/hardware-cache event to evlist for all core PMUs without wildcarding. */
+static int parse_hardware_event(struct evlist *evlist, const char *event,
+                               struct parse_events_error *err)
+{
+       char buf[256];
+       struct perf_pmu *pmu = NULL;
+
+       while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
+               int ret;
+
+               if (perf_pmus__num_core_pmus() == 1)
+                       snprintf(buf, sizeof(buf), "%s/%s,name=%s/", pmu->name, event, event);
+               else
+                       snprintf(buf, sizeof(buf), "%s/%s/", pmu->name, event);
+
+               ret = parse_events(evlist, buf, err);
+               if (ret)
+                       return ret;
+       }
+       return 0;
+}
+
 /*
  * Add default events, if there were no attributes specified or
  * if -d/--detailed, -d -d or -d -d -d is used:
@@ -1976,26 +2008,31 @@ static int add_default_events(void)
 
        if (!evlist->core.nr_entries && !evsel_list->core.nr_entries) {
                /* No events so add defaults. */
-               if (target__has_cpu(&target))
-                       ret = parse_events(evlist, "cpu-clock", &err);
-               else
-                       ret = parse_events(evlist, "task-clock", &err);
-               if (ret)
-                       goto out;
-
-               ret = parse_events(evlist,
-                               "context-switches,"
-                               "cpu-migrations,"
-                               "page-faults,"
-                               "instructions,"
-                               "cycles,"
-                               "stalled-cycles-frontend,"
-                               "stalled-cycles-backend,"
-                               "branches,"
-                               "branch-misses",
-                               &err);
-               if (ret)
-                       goto out;
+               const char *sw_events[] = {
+                       target__has_cpu(&target) ? "cpu-clock" : "task-clock",
+                       "context-switches",
+                       "cpu-migrations",
+                       "page-faults",
+               };
+               const char *hw_events[] = {
+                       "instructions",
+                       "cycles",
+                       "stalled-cycles-frontend",
+                       "stalled-cycles-backend",
+                       "branches",
+                       "branch-misses",
+               };
+
+               for (size_t i = 0; i < ARRAY_SIZE(sw_events); i++) {
+                       ret = parse_software_event(evlist, sw_events[i], &err);
+                       if (ret)
+                               goto out;
+               }
+               for (size_t i = 0; i < ARRAY_SIZE(hw_events); i++) {
+                       ret = parse_hardware_event(evlist, hw_events[i], &err);
+                       if (ret)
+                               goto out;
+               }
 
                /*
                 * Add TopdownL1 metrics if they exist. To minimize
@@ -2037,35 +2074,53 @@ static int add_default_events(void)
                 * Detailed stats (-d), covering the L1 and last level data
                 * caches:
                 */
-               ret = parse_events(evlist,
-                               "L1-dcache-loads,"
-                               "L1-dcache-load-misses,"
-                               "LLC-loads,"
-                               "LLC-load-misses",
-                               &err);
+               const char *hw_events[] = {
+                       "L1-dcache-loads",
+                       "L1-dcache-load-misses",
+                       "LLC-loads",
+                       "LLC-load-misses",
+               };
+
+               for (size_t i = 0; i < ARRAY_SIZE(hw_events); i++) {
+                       ret = parse_hardware_event(evlist, hw_events[i], &err);
+                       if (ret)
+                               goto out;
+               }
        }
        if (!ret && detailed_run >=  2) {
                /*
                 * Very detailed stats (-d -d), covering the instruction cache
                 * and the TLB caches:
                 */
-               ret = parse_events(evlist,
-                               "L1-icache-loads,"
-                               "L1-icache-load-misses,"
-                               "dTLB-loads,"
-                               "dTLB-load-misses,"
-                               "iTLB-loads,"
-                               "iTLB-load-misses",
-                               &err);
+               const char *hw_events[] = {
+                       "L1-icache-loads",
+                       "L1-icache-load-misses",
+                       "dTLB-loads",
+                       "dTLB-load-misses",
+                       "iTLB-loads",
+                       "iTLB-load-misses",
+               };
+
+               for (size_t i = 0; i < ARRAY_SIZE(hw_events); i++) {
+                       ret = parse_hardware_event(evlist, hw_events[i], &err);
+                       if (ret)
+                               goto out;
+               }
        }
        if (!ret && detailed_run >=  3) {
                /*
                 * Very, very detailed stats (-d -d -d), adding prefetch events:
                 */
-               ret = parse_events(evlist,
-                               "L1-dcache-prefetches,"
-                               "L1-dcache-prefetch-misses",
-                               &err);
+               const char *hw_events[] = {
+                       "L1-dcache-prefetches",
+                       "L1-dcache-prefetch-misses",
+               };
+
+               for (size_t i = 0; i < ARRAY_SIZE(hw_events); i++) {
+                       ret = parse_hardware_event(evlist, hw_events[i], &err);
+                       if (ret)
+                               goto out;
+               }
        }
 out:
        if (!ret) {
@@ -2074,7 +2129,7 @@ out:
                         * Make at least one event non-skippable so fatal errors are visible.
                         * 'cycles' always used to be default and non-skippable, so use that.
                         */
-                       if (strcmp("cycles", evsel__name(evsel)))
+                       if (!evsel__match(evsel, HARDWARE, HW_CPU_CYCLES))
                                evsel->skippable = true;
                }
        }