Skip to contentSkip to conversation

perf stat: Ensure group is defined on top of the same cpu mask

PATCH In review Jiri Olsa 5 participants 17 messages May 31, 2020 – Jun 2, 2020 perf events

lore
Share & tools
lore

Jiri Olsa

author reviewer
#0 lore raw

PATCH 1/1 perf stat: Ensure group is defined on top of the same cpu mask

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 51 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
tools/perf/builtin-stat.c +51 -0
index b2b79aa161dd..512a41363d07 100644
@@ -190,6 +190,55 @@ static struct perf_stat_config stat_config = {
 	.big_num		= true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+	if (!a->core.cpus && !b->core.cpus)
+		return true;
+
+	if (!a->core.cpus || !b->core.cpus)
+		return false;
+
+	if (a->core.cpus->nr != b->core.cpus->nr)
+		return false;
+
+	for (int i = 0; i < a->core.cpus->nr; i++) {
+		if (a->core.cpus->map[i] != b->core.cpus->map[i])
+			return false;
+	}
+
+	return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+	struct evsel *evsel, *pos, *leader;
+	char buf[1024];
+
+	evlist__for_each_entry(evlist, evsel) {
+		leader = evsel->leader;
+
+		/* Check that leader matches cpus with each member. */
+		if (leader == evsel)
+			continue;
+		if (cpus_map_matched(leader, evsel))
+			continue;
+
+		/*
+		 * If there's mismatch display dismantle the
+		 * group and warn user.
+		 */
+		WARN_ONCE(1, "WARNING: group events cpu maps do not match, disabling group:\n");
+		evsel__group_desc(leader, buf, sizeof(buf));
+		pr_warning("  %s\n", buf);
+
+		for_each_group_evsel(pos, leader) {
+			pos->leader = pos;
+			pos->core.nr_members = 0;
+		}
+		evsel->leader->core.nr_members = 0;
+	}
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 				 struct timespec *b)
 {
@@ -1962,6 +2011,8 @@ int cmd_stat(int argc, const char **argv)
 	} else if (argc && !strncmp(argv[0], "rep", 3))
 		return __cmd_report(argc, argv);
 
+	evlist__check_cpu_maps(evsel_list);
+
 	interval = stat_config.interval;
 	timeout = stat_config.timeout;
 
Signature · 1 line
2.25.4
reviewer
#1 lore raw
Quoted 13 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Quoted 7 lines

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

This is really cool! I wonder if there is a better wording for 'event cpu maps' ? It may be useful to list what the cpu maps are for the events as a diagnostic aid.

Thanks,
Ian

Quoted 80 lines
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 51 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
tools/perf/builtin-stat.c +51 -1
index b2b79aa161dd..512a41363d07 100644
@@ -190,6 +190,55 @@ static struct perf_stat_config stat_config = {
        .big_num                = true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+       if (!a->core.cpus && !b->core.cpus)
+               return true;
+
+       if (!a->core.cpus || !b->core.cpus)
+               return false;
+
+       if (a->core.cpus->nr != b->core.cpus->nr)
+               return false;
+
+       for (int i = 0; i < a->core.cpus->nr; i++) {
+               if (a->core.cpus->map[i] != b->core.cpus->map[i])
+                       return false;
+       }
+
+       return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+       struct evsel *evsel, *pos, *leader;
+       char buf[1024];
+
+       evlist__for_each_entry(evlist, evsel) {
+               leader = evsel->leader;
+
+               /* Check that leader matches cpus with each member. */
+               if (leader == evsel)
+                       continue;
+               if (cpus_map_matched(leader, evsel))
+                       continue;
+
+               /*
+                * If there's mismatch display dismantle the
+                * group and warn user.
+                */
+               WARN_ONCE(1, "WARNING: group events cpu maps do not match, disabling group:\n");
+               evsel__group_desc(leader, buf, sizeof(buf));
+               pr_warning("  %s\n", buf);
+
+               for_each_group_evsel(pos, leader) {
+                       pos->leader = pos;
+                       pos->core.nr_members = 0;
+               }
+               evsel->leader->core.nr_members = 0;
+       }
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                 struct timespec *b)
 {
@@ -1962,6 +2011,8 @@ int cmd_stat(int argc, const char **argv)
        } else if (argc && !strncmp(argv[0], "rep", 3))
                return __cmd_report(argc, argv);
 
+       evlist__check_cpu_maps(evsel_list);
+
        interval = stat_config.interval;
        timeout = stat_config.timeout;
 
--

2.25.4

#2 lore raw
Quoted 17 lines · Ian Rogers
Quoted 16 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

Quoted 8 lines
Quoted 4 lines
  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

This is really cool! I wonder if there is a better wording for 'event cpu maps' ? It may be useful to list what the cpu maps are for the events as a diagnostic aid.

right, we could display that for -v option

jirka

#3 lore raw
In reply to Ian Rogers
Quoted 17 lines · Ian Rogers
Quoted 16 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

Quoted 8 lines
Quoted 4 lines
  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

This is really cool! I wonder if there is a better wording for 'event cpu maps' ? It may be useful to list what the cpu maps are for the events as a diagnostic aid.

right, something like this in verbose mode?
it display cpu maps of events that did not match

[root@krava perf]# ./perf stat -e '{cycles,power/energy-cores/}' -v
WARNING: group events cpu maps do not match, disabling group:
anon group { cycles, power/energy-cores/ }

     cycles: 0-7
     power/energy-cores/: 0

jirka

Quoted 85 lines

Thanks,
Ian

Quoted 80 lines
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 51 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
tools/perf/builtin-stat.c +51 -1
index b2b79aa161dd..512a41363d07 100644
@@ -190,6 +190,55 @@ static struct perf_stat_config stat_config = {
        .big_num                = true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+       if (!a->core.cpus && !b->core.cpus)
+               return true;
+
+       if (!a->core.cpus || !b->core.cpus)
+               return false;
+
+       if (a->core.cpus->nr != b->core.cpus->nr)
+               return false;
+
+       for (int i = 0; i < a->core.cpus->nr; i++) {
+               if (a->core.cpus->map[i] != b->core.cpus->map[i])
+                       return false;
+       }
+
+       return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+       struct evsel *evsel, *pos, *leader;
+       char buf[1024];
+
+       evlist__for_each_entry(evlist, evsel) {
+               leader = evsel->leader;
+
+               /* Check that leader matches cpus with each member. */
+               if (leader == evsel)
+                       continue;
+               if (cpus_map_matched(leader, evsel))
+                       continue;
+
+               /*
+                * If there's mismatch display dismantle the
+                * group and warn user.
+                */
+               WARN_ONCE(1, "WARNING: group events cpu maps do not match, disabling group:\n");
+               evsel__group_desc(leader, buf, sizeof(buf));
+               pr_warning("  %s\n", buf);
+
+               for_each_group_evsel(pos, leader) {
+                       pos->leader = pos;
+                       pos->core.nr_members = 0;
+               }
+               evsel->leader->core.nr_members = 0;
+       }
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                 struct timespec *b)
 {
@@ -1962,6 +2011,8 @@ int cmd_stat(int argc, const char **argv)
        } else if (argc && !strncmp(argv[0], "rep", 3))
                return __cmd_report(argc, argv);
 
+       evlist__check_cpu_maps(evsel_list);
+
        interval = stat_config.interval;
        timeout = stat_config.timeout;
 
--

2.25.4

#4 lore raw

PATCH v2 1/1 perf stat: Ensure group is defined on top of the same cpu mask

In reply to Ian Rogers

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 58 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

v2 changes:
- display mixed events maps in verbose mode

tools/perf/builtin-stat.c +58 -0
index b2b79aa161dd..dda60b9dbc63 100644
@@ -190,6 +190,62 @@ static struct perf_stat_config stat_config = {
 	.big_num		= true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+	if (!a->core.cpus && !b->core.cpus)
+		return true;
+
+	if (!a->core.cpus || !b->core.cpus)
+		return false;
+
+	if (a->core.cpus->nr != b->core.cpus->nr)
+		return false;
+
+	for (int i = 0; i < a->core.cpus->nr; i++) {
+		if (a->core.cpus->map[i] != b->core.cpus->map[i])
+			return false;
+	}
+
+	return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+	struct evsel *evsel, *pos, *leader;
+	char buf[1024];
+
+	evlist__for_each_entry(evlist, evsel) {
+		leader = evsel->leader;
+
+		/* Check that leader matches cpus with each member. */
+		if (leader == evsel)
+			continue;
+		if (cpus_map_matched(leader, evsel))
+			continue;
+
+		/*
+		 * If there's mismatch display dismantle the
+		 * group and warn user.
+		 */
+		WARN_ONCE(1, "WARNING: group events cpu maps do not match, disabling group:\n");
+		evsel__group_desc(leader, buf, sizeof(buf));
+		pr_warning("  %s\n", buf);
+
+		if (verbose) {
+			cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", leader->name, buf);
+			cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", evsel->name, buf);
+		}
+
+		for_each_group_evsel(pos, leader) {
+			pos->leader = pos;
+			pos->core.nr_members = 0;
+		}
+		evsel->leader->core.nr_members = 0;
+	}
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 				 struct timespec *b)
 {
@@ -2113,6 +2169,8 @@ int cmd_stat(int argc, const char **argv)
 		goto out;
 	}
 
+	evlist__check_cpu_maps(evsel_list);
+
 	/*
 	 * Initialize thread_map with comm names,
 	 * so we could print it out on output.
Signature · 1 line
2.25.4
reviewer
#5 lore raw
Quoted 23 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

Quoted 8 lines
  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

Thanks,
Ian

Quoted 90 lines
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 58 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

v2 changes:
- display mixed events maps in verbose mode

tools/perf/builtin-stat.c +58 -1
index b2b79aa161dd..dda60b9dbc63 100644
@@ -190,6 +190,62 @@ static struct perf_stat_config stat_config = {
        .big_num                = true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+       if (!a->core.cpus && !b->core.cpus)
+               return true;
+
+       if (!a->core.cpus || !b->core.cpus)
+               return false;
+
+       if (a->core.cpus->nr != b->core.cpus->nr)
+               return false;
+
+       for (int i = 0; i < a->core.cpus->nr; i++) {
+               if (a->core.cpus->map[i] != b->core.cpus->map[i])
+                       return false;
+       }
+
+       return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+       struct evsel *evsel, *pos, *leader;
+       char buf[1024];
+
+       evlist__for_each_entry(evlist, evsel) {
+               leader = evsel->leader;
+
+               /* Check that leader matches cpus with each member. */
+               if (leader == evsel)
+                       continue;
+               if (cpus_map_matched(leader, evsel))
+                       continue;
+
+               /*
+                * If there's mismatch display dismantle the
+                * group and warn user.
+                */
+               WARN_ONCE(1, "WARNING: group events cpu maps do not match, disabling group:\n");
+               evsel__group_desc(leader, buf, sizeof(buf));
+               pr_warning("  %s\n", buf);
+
+               if (verbose) {
+                       cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
+                       pr_warning("     %s: %s\n", leader->name, buf);
+                       cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
+                       pr_warning("     %s: %s\n", evsel->name, buf);
+               }
+
+               for_each_group_evsel(pos, leader) {
+                       pos->leader = pos;
+                       pos->core.nr_members = 0;
+               }
+               evsel->leader->core.nr_members = 0;
+       }
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                 struct timespec *b)
 {
@@ -2113,6 +2169,8 @@ int cmd_stat(int argc, const char **argv)
                goto out;
        }
 
+       evlist__check_cpu_maps(evsel_list);
+
        /*
         * Initialize thread_map with comm names,
         * so we could print it out on output.
--

2.25.4

maintainer
#6 lore raw
Quoted 34 lines · Ian Rogers
Quoted 23 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

Quoted 8 lines
  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Quoted 2 lines

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

Allowed cpus?

Thanks
Namhyung

#7 lore raw
Quoted 35 lines · Namhyung Kim
Quoted 34 lines · Ian Rogers
Quoted 31 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Quoted 2 lines
Quoted 2 lines

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

ok

Quoted 2 lines

Allowed cpus?

hum, what you mean?

jirka

Quoted 4 lines

Thanks
Namhyung

maintainer
#8 lore raw

Hi Jiri,

Quoted 37 lines · Jiri Olsa
Quoted 35 lines · Namhyung Kim
Quoted 34 lines · Ian Rogers
Quoted 31 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Quoted 5 lines
Quoted 3 lines
Quoted 2 lines

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

Allowed cpus?

hum, what you mean?

I mean that we can use 'allowed cpus' rather then 'cpu map' in the message. Something like this?

allowed cpus for events in a group do not match, disabling group:

Thanks
Namhyung

#9 lore raw
Quoted 42 lines · Namhyung Kim

Hi Jiri,

Quoted 39 lines · Jiri Olsa
Quoted 37 lines · Namhyung Kim
Quoted 36 lines · Ian Rogers
Quoted 23 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

Quoted 8 lines
  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

Allowed cpus?

hum, what you mean?

I mean that we can use 'allowed cpus' rather then 'cpu map' in the message. Something like this?

allowed cpus for events in a group do not match, disabling group:

hm, I like more the one Ian suggested.. anyway, leaving this to Arnaldo, he can change that before committing ;-)

thanks,
jirka

#10 lore raw

Em Tue, Jun 02, 2020 at 02:10:17PM +0200, Jiri Olsa escreveu:

Quoted 47 lines · Namhyung Kim
Quoted 46 lines

Hi Jiri,

Quoted 42 lines · Jiri Olsa
Quoted 35 lines · Namhyung Kim
Quoted 34 lines · Ian Rogers
Quoted 31 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Quoted 3 lines
Quoted 2 lines

This is great! A nit, would 'grouped events cpus do not match' read better? I think the cpu map is more of an internal naming convention.

Allowed cpus?

hum, what you mean?

Quoted 7 lines
Quoted 4 lines

I mean that we can use 'allowed cpus' rather then 'cpu map' in the message. Something like this?

allowed cpus for events in a group do not match, disabling group:

hm, I like more the one Ian suggested.. anyway, leaving this to Arnaldo, he can change that before committing ;-)

I think its ok as-is, Ian, can I have your acked-by?

- Arnaldo

#11 lore raw

PATCH v3 1/1 perf stat: Ensure group is defined on top of the same cpu mask

In reply to Ian Rogers

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

v3 changes:
- reword the warning with Ian's suggestion

tools/perf/builtin-stat.c +55 -0
index b2b79aa161dd..9be020e0098a 100644
@@ -190,6 +190,59 @@ static struct perf_stat_config stat_config = {
 	.big_num		= true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+	if (!a->core.cpus && !b->core.cpus)
+		return true;
+
+	if (!a->core.cpus || !b->core.cpus)
+		return false;
+
+	if (a->core.cpus->nr != b->core.cpus->nr)
+		return false;
+
+	for (int i = 0; i < a->core.cpus->nr; i++) {
+		if (a->core.cpus->map[i] != b->core.cpus->map[i])
+			return false;
+	}
+
+	return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+	struct evsel *evsel, *pos, *leader;
+	char buf[1024];
+
+	evlist__for_each_entry(evlist, evsel) {
+		leader = evsel->leader;
+
+		/* Check that leader matches cpus with each member. */
+		if (leader == evsel)
+			continue;
+		if (cpus_map_matched(leader, evsel))
+			continue;
+
+		/* If there's mismatch disable the group and warn user. */
+		WARN_ONCE(1, "WARNING: grouped events cpus do not match, disabling group:\n");
+		evsel__group_desc(leader, buf, sizeof(buf));
+		pr_warning("  %s\n", buf);
+
+		if (verbose) {
+			cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", leader->name, buf);
+			cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", evsel->name, buf);
+		}
+
+		for_each_group_evsel(pos, leader) {
+			pos->leader = pos;
+			pos->core.nr_members = 0;
+		}
+		evsel->leader->core.nr_members = 0;
+	}
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 				 struct timespec *b)
 {
@@ -2113,6 +2166,8 @@ int cmd_stat(int argc, const char **argv)
 		goto out;
 	}
 
+	evlist__check_cpu_maps(evsel_list);
+
 	/*
 	 * Initialize thread_map with comm names,
 	 * so we could print it out on output.
Signature · 1 line
2.25.4
#12 lore raw

Em Tue, Jun 02, 2020 at 12:17:36PM +0200, Jiri Olsa escreveu:

Quoted 12 lines

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Quoted 7 lines

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

So it doesn't disable the 'group', it disables the 'grouping' of those events, right? I.e. reading the WARNING, I thought that it would count nothing, since it lists both groups as being disabled, but when I tested I noticed that:

[root@seventh ~]# perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
WARNING: grouped events cpus do not match, disabling group:

    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

^C
Performance counter stats for 'system wide':

12.62 Joules power/energy-cores/
106,920,637 cycles
80,228,899 instructions # 0.75 insn per cycle
12.62 Joules power/energy-cores/

14.514476987 seconds time elapsed

[root@seventh ~]#

I.e. it counted the events, ungrouped, or am I missing something?

If I do:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/
12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

2.001272492 seconds time elapsed

[root@seventh ~]#

It works, grouped. One observation, shouldn't we somehow show in the output that the first two were indeed grouped, ditto for the second two?

Also, this needs improvement:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' sleep 2 Error:
The sys_perf_event_open() syscall returned with 22 (Invalid argument) for event (power/energy-cores/). /bin/dmesg | grep -i perf may provide additional information.

[root@seventh ~]#

Probably stating that the power/ events can only be done on a system wide mode or per-cpu?

I'm applying the patch now, with the above observations as committer notes, we can improve this in follow on patch,

- Arnaldo

Quoted 98 lines

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")
---
 tools/perf/builtin-stat.c | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

v3 changes:
- reword the warning with Ian's suggestion

tools/perf/builtin-stat.c +55 -0
index b2b79aa161dd..9be020e0098a 100644
@@ -190,6 +190,59 @@ static struct perf_stat_config stat_config = {
 	.big_num		= true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+	if (!a->core.cpus && !b->core.cpus)
+		return true;
+
+	if (!a->core.cpus || !b->core.cpus)
+		return false;
+
+	if (a->core.cpus->nr != b->core.cpus->nr)
+		return false;
+
+	for (int i = 0; i < a->core.cpus->nr; i++) {
+		if (a->core.cpus->map[i] != b->core.cpus->map[i])
+			return false;
+	}
+
+	return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+	struct evsel *evsel, *pos, *leader;
+	char buf[1024];
+
+	evlist__for_each_entry(evlist, evsel) {
+		leader = evsel->leader;
+
+		/* Check that leader matches cpus with each member. */
+		if (leader == evsel)
+			continue;
+		if (cpus_map_matched(leader, evsel))
+			continue;
+
+		/* If there's mismatch disable the group and warn user. */
+		WARN_ONCE(1, "WARNING: grouped events cpus do not match, disabling group:\n");
+		evsel__group_desc(leader, buf, sizeof(buf));
+		pr_warning("  %s\n", buf);
+
+		if (verbose) {
+			cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", leader->name, buf);
+			cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
+			pr_warning("     %s: %s\n", evsel->name, buf);
+		}
+
+		for_each_group_evsel(pos, leader) {
+			pos->leader = pos;
+			pos->core.nr_members = 0;
+		}
+		evsel->leader->core.nr_members = 0;
+	}
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
 				 struct timespec *b)
 {
@@ -2113,6 +2166,8 @@ int cmd_stat(int argc, const char **argv)
 		goto out;
 	}
 
+	evlist__check_cpu_maps(evsel_list);
+
 	/*
 	 * Initialize thread_map with comm names,
 	 * so we could print it out on output.
Signature · 1 line
2.25.4
Signature · 1 line
- Arnaldo
#13 lore raw
Quoted 38 lines · Arnaldo Carvalho de Melo

Em Tue, Jun 02, 2020 at 12:17:36PM +0200, Jiri Olsa escreveu:

Quoted 12 lines

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Quoted 7 lines

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

So it doesn't disable the 'group', it disables the 'grouping' of those events, right? I.e. reading the WARNING, I thought that it would count nothing, since it lists both groups as being disabled, but when I tested I noticed that:

[root@seventh ~]# perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
WARNING: grouped events cpus do not match, disabling group:

    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

^C
Performance counter stats for 'system wide':

12.62 Joules power/energy-cores/
106,920,637 cycles
80,228,899 instructions # 0.75 insn per cycle
12.62 Joules power/energy-cores/

Quoted 6 lines

14.514476987 seconds time elapsed

[root@seventh ~]#

I.e. it counted the events, ungrouped, or am I missing something?

right, it disables 'grouping', events are scheduled/counted individualy

this way we will not hit the issue when looking for group_fd FD and there's not any, because of different cpu maps

Quoted 12 lines

If I do:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/
12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

Quoted 6 lines

2.001272492 seconds time elapsed

[root@seventh ~]#

It works, grouped. One observation, shouldn't we somehow show in the output that the first two were indeed grouped, ditto for the second two?

yea, we don't display groups in output.. also there's no number for the group, it's still separate events numbers in output grouping is only used when creating events

Quoted 7 lines

Also, this needs improvement:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' sleep 2 Error:
The sys_perf_event_open() syscall returned with 22 (Invalid argument) for event (power/energy-cores/). /bin/dmesg | grep -i perf may provide additional information.

yes, power events don't work with events without cpu being defined, which is what we do for 'workload' session.. we should either check for that and display some sensible error for power events

or perhaps check if we could monitor like perf record does with creating events for task and every cpu in the system

thanks,
jirka

#14 lore raw

Em Tue, Jun 02, 2020 at 04:05:08PM +0200, Jiri Olsa escreveu:

Quoted 39 lines · Arnaldo Carvalho de Melo
Quoted 38 lines

Em Tue, Jun 02, 2020 at 12:17:36PM +0200, Jiri Olsa escreveu:

Quoted 12 lines

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Quoted 7 lines

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

So it doesn't disable the 'group', it disables the 'grouping' of those events, right? I.e. reading the WARNING, I thought that it would count nothing, since it lists both groups as being disabled, but when I tested I noticed that:

[root@seventh ~]# perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
WARNING: grouped events cpus do not match, disabling group:

    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

^C
Performance counter stats for 'system wide':

12.62 Joules power/energy-cores/
106,920,637 cycles
80,228,899 instructions # 0.75 insn per cycle
12.62 Joules power/energy-cores/

Quoted 8 lines
Quoted 6 lines
        14.514476987 seconds time elapsed

[root@seventh ~]#

I.e. it counted the events, ungrouped, or am I missing something?

right, it disables 'grouping', events are scheduled/counted individualy

Ok, I applied this already, we can fix this in the next cycle.

Quoted 16 lines

this way we will not hit the issue when looking for group_fd FD and there's not any, because of different cpu maps

Quoted 12 lines

If I do:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/
12,191,658 instructions # 0.67 insn per cycles/
18,275,233 cycles

2.001272492 seconds time elapsed

Quoted 8 lines
Quoted 4 lines

[root@seventh ~]#

It works, grouped. One observation, shouldn't we somehow show in the output that the first two were indeed grouped, ditto for the second two?

yea, we don't display groups in output.. also there's no number for the group, it's still separate events numbers in output grouping is only used when creating events

perhaps if we just add a blank line to separate groups? I.e. the above would be:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/

12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

2.001272492 seconds time elapsed

[root@seventh ~]#

Humm, in the presence of at least one group, any ungrouped events would have to be also separated, i.e.:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},instructions,cycles' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/

12,191,658 instructions # 0.67 insn per cycle

18,275,233 cycles

2.001272492 seconds time elapsed

[root@seventh ~]#

wdyt?

Quoted 7 lines
Quoted 6 lines

Also, this needs improvement:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' sleep 2 Error:
The sys_perf_event_open() syscall returned with 22 (Invalid argument) for event (power/energy-cores/). /bin/dmesg | grep -i perf may provide additional information.

Quoted 6 lines

yes, power events don't work with events without cpu being defined, which is what we do for 'workload' session.. we should either check for that and display some sensible error for power events

or perhaps check if we could monitor like perf record does with creating events for task and every cpu in the system

- Arnaldo

#15 lore raw

On Tue, Jun 02, 2020 at 12:03:52PM -0300, Arnaldo Carvalho de Melo wrote:

SNIP

Quoted 36 lines
Quoted 1 line

right, it disables 'grouping', events are scheduled/counted individualy

Ok, I applied this already, we can fix this in the next cycle.

Quoted 16 lines

this way we will not hit the issue when looking for group_fd FD and there's not any, because of different cpu maps

Quoted 12 lines

If I do:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/
12,191,658 instructions # 0.67 insn per cycles/
18,275,233 cycles

2.001272492 seconds time elapsed

Quoted 8 lines
Quoted 4 lines

[root@seventh ~]#

It works, grouped. One observation, shouldn't we somehow show in the output that the first two were indeed grouped, ditto for the second two?

yea, we don't display groups in output.. also there's no number for the group, it's still separate events numbers in output grouping is only used when creating events

perhaps if we just add a blank line to separate groups? I.e. the above would be:

[root@seventh ~]# perf stat -e '{power/energy-cores/,power/energy-ram/},{instructions,cycles}' -a sleep 2

Performance counter stats for 'system wide':

Quoted 7 lines

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/

12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

2.001272492 seconds time elapsed

maybe it could be separated by new line and we could put note in the comment:

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/ # groupped

12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

2.001272492 seconds time elapsed

for events that already have defined comment, it'd be on the next line, like:

Performance counter stats for 'system wide':

1.73 Joules power/energy-cores/
0.92 Joules power/energy-ram/ # XXXXX
# groupped

12,191,658 instructions # 0.67 insn per cycle
18,275,233 cycles

2.001272492 seconds time elapsed

jirka

reviewer Acked-by on v3 1/1
#16 lore raw
In reply to Jiri Olsa
Quoted 32 lines · Jiri Olsa

Jin Yao reported the issue (and posted first versions of this change) with groups being defined over events with different cpu mask.

This causes assert aborts in get_group_fd, like:

  # perf stat -M "C2_Pkg_Residency" -a -- sleep 1
  perf: util/evsel.c:1464: get_group_fd: Assertion `!(fd == -1)' failed.
  Aborted

All the events in the group have to be defined over the same cpus so the group_fd can be found for every leader/member pair.

Adding check to ensure this condition is met and removing the group (with warning) if we detect mixed cpus, like:

  $ sudo perf stat -e '{power/energy-cores/,cycles},{instructions,power/energy-cores/}'
  WARNING: event cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
    anon group { instructions, power/energy-cores/ }

Ian asked also for cpu maps details, it's displayed in verbose mode:

  $ sudo perf stat -e '{cycles,power/energy-cores/}' -v
  WARNING: group events cpu maps do not match, disabling group:
    anon group { power/energy-cores/, cycles }
       power/energy-cores/: 0
       cycles: 0-7
    anon group { instructions, power/energy-cores/ }
       instructions: 0-7
       power/energy-cores/: 0
Quoted 4 lines
Fixes 6a4bb04caacc8 ("perf tools: Enable grouping logic for parsed events")

Thanks!
Ian

Quoted 83 lines
---
 tools/perf/builtin-stat.c | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

v3 changes:
- reword the warning with Ian's suggestion

tools/perf/builtin-stat.c +55 -1
index b2b79aa161dd..9be020e0098a 100644
@@ -190,6 +190,59 @@ static struct perf_stat_config stat_config = {
        .big_num                = true,
 };
 
+static bool cpus_map_matched(struct evsel *a, struct evsel *b)
+{
+       if (!a->core.cpus && !b->core.cpus)
+               return true;
+
+       if (!a->core.cpus || !b->core.cpus)
+               return false;
+
+       if (a->core.cpus->nr != b->core.cpus->nr)
+               return false;
+
+       for (int i = 0; i < a->core.cpus->nr; i++) {
+               if (a->core.cpus->map[i] != b->core.cpus->map[i])
+                       return false;
+       }
+
+       return true;
+}
+
+static void evlist__check_cpu_maps(struct evlist *evlist)
+{
+       struct evsel *evsel, *pos, *leader;
+       char buf[1024];
+
+       evlist__for_each_entry(evlist, evsel) {
+               leader = evsel->leader;
+
+               /* Check that leader matches cpus with each member. */
+               if (leader == evsel)
+                       continue;
+               if (cpus_map_matched(leader, evsel))
+                       continue;
+
+               /* If there's mismatch disable the group and warn user. */
+               WARN_ONCE(1, "WARNING: grouped events cpus do not match, disabling group:\n");
+               evsel__group_desc(leader, buf, sizeof(buf));
+               pr_warning("  %s\n", buf);
+
+               if (verbose) {
+                       cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
+                       pr_warning("     %s: %s\n", leader->name, buf);
+                       cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
+                       pr_warning("     %s: %s\n", evsel->name, buf);
+               }
+
+               for_each_group_evsel(pos, leader) {
+                       pos->leader = pos;
+                       pos->core.nr_members = 0;
+               }
+               evsel->leader->core.nr_members = 0;
+       }
+}
+
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                 struct timespec *b)
 {
@@ -2113,6 +2166,8 @@ int cmd_stat(int argc, const char **argv)
                goto out;
        }
 
+       evlist__check_cpu_maps(evsel_list);
+
        /*
         * Initialize thread_map with comm names,
         * so we could print it out on output.
--

2.25.4