tools/perf/arch/x86/tests/topdown.c | 166 +++++++++++++++++++++- tools/perf/tests/Build | 1 + tools/perf/tests/builtin-test.c | 1 + tools/perf/tests/tests.h | 1 + tools/perf/tests/uncore-event-sorting.c | 178 ++++++++++++++++++++++++ 5 files changed, 346 insertions(+), 1 deletion(-) create mode 100644 tools/perf/tests/uncore-event-sorting.c
A patch thread changing event sorting highlighted a lack of testing
for the more complicated uncore and x86 perf metric event sorting:
https://lore.kernel.org/linux-perf-users/CAP-5=fWRgDo7UnJAD4C--d=mVPRhOEWZVyU7nVM1YEp3jncAgg@mail.gmail.com/
v7: - Prevent double-free of m.event1 and dangling pointer access upon
PMU scanning loop termination or early continue in the uncore
event sorting test by utilizing standard perf zfree() helpers
(reported by Sashiko).
- Document Intel Hybrid CPU architectural invariants in the x86
topdown test to clarify why instructions correctly leads a group
of 2 on E-cores (cpu_atom) where slots is unsupported and
filtered out (reported by Sashiko).
v6: - Ensure robust error initialization and resource cleanup in both
uncore and topdown tests by initializing evlist to NULL and
parse_events_error at function entry, preventing uninitialized
stack access or resource leaks on early return paths (reported
by Sashiko).
- Prevent double evaluation and duplicate debug logging upon test
assertion failure in the x86 topdown test by caching test_sort()
return values into local variables (reported by Sashiko).
v5: - Strengthen uncore event sorting test assertions to require at
least 4 total events (>= 2 groups of 2 events) instead of > 0
events, guaranteeing that multi-PMU wildcard expansion is
genuinely exercised across multiple sibling PMUs (reported by Sashiko).
- Fix memory leaks on assertion failure across both uncore and
topdown test suites by replacing standard TEST_ASSERT macros
with local CHECK macros that correctly branch to out_err cleanup
handlers (reported by Sashiko).
- Fix test_sort() in the x86 topdown test to correctly return TEST_FAIL (-1)
instead of parse_events() internal error codes (e.g., -EINVAL) when event
parsing fails (reported by Namhyung).
v4: Fix malformed event group string formatting in the uncore event
sorting test when running on AMD systems (where sysfs event
aliases lack JSON descriptions - reported by Namhyung). Added a
helper to strip redundant PMU prefixes and trailing slashes to
ensure parse_events() receives valid syntax across all
architectures.
v3: Address sashiko nits on using evsel__name and ensuring slots is injected.
https://lore.kernel.org/linux-perf-users/20260331185419.4085479-1-irogers@google.com/
v2: Address indentation and other nits from Namhyung. Add Zide Chen's
tested-by tags.
https://lore.kernel.org/lkml/20260331165207.4016392-1-irogers@google.com/
v1: https://lore.kernel.org/lkml/20260325183045.1229502-1-irogers@google.com/
Ian Rogers (2):
perf tests: Add test for uncore event sorting
perf arch x86 tests: Add test for topdown event sorting
tools/perf/arch/x86/tests/topdown.c | 166 +++++++++++++++++++++-
tools/perf/tests/Build | 1 +
tools/perf/tests/builtin-test.c | 1 +
tools/perf/tests/tests.h | 1 +
tools/perf/tests/uncore-event-sorting.c | 178 ++++++++++++++++++++++++
5 files changed, 346 insertions(+), 1 deletion(-)
create mode 100644 tools/perf/tests/uncore-event-sorting.c
--
2.54.0.563.g4f69b47b94-goog
A patch thread changing event sorting highlighted a lack of testing
for the more complicated uncore and x86 perf metric event sorting:
https://lore.kernel.org/linux-perf-users/CAP-5=fWRgDo7UnJAD4C--d=mVPRhOEWZVyU7nVM1YEp3jncAgg@mail.gmail.com/
v8: Simplify event_cb in the uncore event sorting test by removing the
unreachable dead-code else block (reported by Sashiko).
v7: - Prevent double-free of m.event1 and dangling pointer access upon
PMU scanning loop termination or early continue in the uncore
event sorting test by utilizing standard perf zfree() helpers
(reported by Sashiko).
- Document Intel Hybrid CPU architectural invariants in the x86
topdown test to clarify why instructions correctly leads a group
of 2 on E-cores (cpu_atom) where slots is unsupported and
filtered out (reported by Sashiko).
v6: - Ensure robust error initialization and resource cleanup in both
uncore and topdown tests by initializing evlist to NULL and
parse_events_error at function entry, preventing uninitialized
stack access or resource leaks on early return paths (reported
by Sashiko).
- Prevent double evaluation and duplicate debug logging upon test
assertion failure in the x86 topdown test by caching test_sort()
return values into local variables (reported by Sashiko).
v5: - Strengthen uncore event sorting test assertions to require at
least 4 total events (>= 2 groups of 2 events) instead of > 0
events, guaranteeing that multi-PMU wildcard expansion is
genuinely exercised across multiple sibling PMUs (reported by Sashiko).
- Fix memory leaks on assertion failure across both uncore and
topdown test suites by replacing standard TEST_ASSERT macros
with local CHECK macros that correctly branch to out_err cleanup
handlers (reported by Sashiko).
- Fix test_sort() in the x86 topdown test to correctly return TEST_FAIL (-1)
instead of parse_events() internal error codes (e.g., -EINVAL) when event
parsing fails (reported by Namhyung).
v4: Fix malformed event group string formatting in the uncore event
sorting test when running on AMD systems (where sysfs event
aliases lack JSON descriptions - reported by Namhyung). Added a
helper to strip redundant PMU prefixes and trailing slashes to
ensure parse_events() receives valid syntax across all
architectures.
v3: Address sashiko nits on using evsel__name and ensuring slots is injected.
https://lore.kernel.org/linux-perf-users/20260331185419.4085479-1-irogers@google.com/
v2: Address indentation and other nits from Namhyung. Add Zide Chen's
tested-by tags.
https://lore.kernel.org/lkml/20260331165207.4016392-1-irogers@google.com/
v1: https://lore.kernel.org/lkml/20260325183045.1229502-1-irogers@google.com/
Ian Rogers (2):
perf tests: Add test for uncore event sorting
perf arch x86 tests: Add test for topdown event sorting
tools/perf/arch/x86/tests/topdown.c | 166 +++++++++++++++++++++-
tools/perf/tests/Build | 1 +
tools/perf/tests/builtin-test.c | 1 +
tools/perf/tests/tests.h | 1 +
tools/perf/tests/uncore-event-sorting.c | 176 ++++++++++++++++++++++++
5 files changed, 344 insertions(+), 1 deletion(-)
create mode 100644 tools/perf/tests/uncore-event-sorting.c
--
2.54.0.563.g4f69b47b94-goog
On Sun, May 17, 2026 at 11:29 PM Ian Rogers <irogers@google.com> wrote: > > A patch thread changing event sorting highlighted a lack of testing > for the more complicated uncore and x86 perf metric event sorting: > https://lore.kernel.org/linux-perf-users/CAP-5=fWRgDo7UnJAD4C--d=mVPRhOEWZVyU7nVM1YEp3jncAgg@mail.gmail.com/ Purely test changes with green analysis from Sashiko: https://sashiko.dev/#/patchset/20260518062904.2591616-1-irogers%40google.com It would be nice to get help landing this. Thanks, Ian > v8: Simplify event_cb in the uncore event sorting test by removing the > unreachable dead-code else block (reported by Sashiko). > > v7: - Prevent double-free of m.event1 and dangling pointer access upon > PMU scanning loop termination or early continue in the uncore > event sorting test by utilizing standard perf zfree() helpers > (reported by Sashiko). > - Document Intel Hybrid CPU architectural invariants in the x86 > topdown test to clarify why instructions correctly leads a group > of 2 on E-cores (cpu_atom) where slots is unsupported and > filtered out (reported by Sashiko). > > v6: - Ensure robust error initialization and resource cleanup in both > uncore and topdown tests by initializing evlist to NULL and > parse_events_error at function entry, preventing uninitialized > stack access or resource leaks on early return paths (reported > by Sashiko). > - Prevent double evaluation and duplicate debug logging upon test > assertion failure in the x86 topdown test by caching test_sort() > return values into local variables (reported by Sashiko). > > v5: - Strengthen uncore event sorting test assertions to require at > least 4 total events (>= 2 groups of 2 events) instead of > 0 > events, guaranteeing that multi-PMU wildcard expansion is > genuinely exercised across multiple sibling PMUs (reported by Sashiko). > - Fix memory leaks on assertion failure across both uncore and > topdown test suites by replacing standard TEST_ASSERT macros > with local CHECK macros that correctly branch to out_err cleanup > handlers (reported by Sashiko). > - Fix test_sort() in the x86 topdown test to correctly return TEST_FAIL (-1) > instead of parse_events() internal error codes (e.g., -EINVAL) when event > parsing fails (reported by Namhyung). > > v4: Fix malformed event group string formatting in the uncore event > sorting test when running on AMD systems (where sysfs event > aliases lack JSON descriptions - reported by Namhyung). Added a > helper to strip redundant PMU prefixes and trailing slashes to > ensure parse_events() receives valid syntax across all > architectures. > > v3: Address sashiko nits on using evsel__name and ensuring slots is injected. > https://lore.kernel.org/linux-perf-users/20260331185419.4085479-1-irogers@google.com/ > > v2: Address indentation and other nits from Namhyung. Add Zide Chen's > tested-by tags. > https://lore.kernel.org/lkml/20260331165207.4016392-1-irogers@google.com/ > > v1: https://lore.kernel.org/lkml/20260325183045.1229502-1-irogers@google.com/ > > Ian Rogers (2): > perf tests: Add test for uncore event sorting > perf arch x86 tests: Add test for topdown event sorting > > tools/perf/arch/x86/tests/topdown.c | 166 +++++++++++++++++++++- > tools/perf/tests/Build | 1 + > tools/perf/tests/builtin-test.c | 1 + > tools/perf/tests/tests.h | 1 + > tools/perf/tests/uncore-event-sorting.c | 176 ++++++++++++++++++++++++ > 5 files changed, 344 insertions(+), 1 deletion(-) > create mode 100644 tools/perf/tests/uncore-event-sorting.c > > -- > 2.54.0.563.g4f69b47b94-goog >
On Wed, May 20, 2026 at 08:31:31AM -0700, Ian Rogers wrote:
> On Sun, May 17, 2026 at 11:29 PM Ian Rogers <irogers@google.com> wrote:
> >
> > A patch thread changing event sorting highlighted a lack of testing
> > for the more complicated uncore and x86 perf metric event sorting:
> > https://lore.kernel.org/linux-perf-users/CAP-5=fWRgDo7UnJAD4C--d=mVPRhOEWZVyU7nVM1YEp3jncAgg@mail.gmail.com/
>
> Purely test changes with green analysis from Sashiko:
> https://sashiko.dev/#/patchset/20260518062904.2591616-1-irogers%40google.com
> It would be nice to get help landing this.
On my AMD machine, it looks good now.
$ sudo tools/perf/perf test -v sorting
6: Uncore event sorting : Ok
76.2: topdown sorting : Ok
Tested-by: Namhyung Kim <namhyung@kernel.org>
Thanks,
Namhyung
Add a test for uncore event sorting matching multiple PMUs. Uncore
PMUs may have a common prefix, like the PMUs uncore_imc_free_running_0
and uncore_imc_free_running_1 have a prefix of
uncore_imc_free_running. Parsing an event group like
"{data_read,data_write}" for those PMUs should result with two groups
"{uncore_imc_free_running_0/data_read/,uncore_imc_free_running_0/data_write/},
{uncore_imc_free_running_1/data_read/,uncore_imc_free_running_1/data_write/}"
which means the evsels need resorting as when initially parsed the
evsels are ordered with mixed PMUs:
"{uncore_imc_free_running_0/data_read/,uncore_imc_free_running_1/data_read/,
uncore_imc_free_running_0/data_write/,uncore_imc_free_running_1/data_write/}".
Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: Zide Chen <zide.chen@intel.com>
---
tools/perf/tests/Build | 1 +
tools/perf/tests/builtin-test.c | 1 +
tools/perf/tests/tests.h | 1 +
tools/perf/tests/uncore-event-sorting.c | 176 ++++++++++++++++++++++++
4 files changed, 179 insertions(+)
create mode 100644 tools/perf/tests/uncore-event-sorting.c
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index c2a67ce45941..66944a4f4968 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -3,6 +3,7 @@
perf-test-y += builtin-test.o
perf-test-y += tests-scripts.o
perf-test-y += parse-events.o
+perf-test-y += uncore-event-sorting.o
perf-test-y += dso-data.o
perf-test-y += vmlinux-kallsyms.o
perf-test-y += openat-syscall.o
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 06507066213b..f2c135891477 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -71,6 +71,7 @@ static struct test_suite *generic_tests[] = {
&suite__basic_mmap,
&suite__mem,
&suite__parse_events,
+ &suite__uncore_event_sorting,
&suite__expr,
&suite__PERF_RECORD,
&suite__pmu,
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index f5f1238d1f7f..ee00518bf36f 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -177,6 +177,7 @@ DECLARE_SUITE(sigtrap);
DECLARE_SUITE(event_groups);
DECLARE_SUITE(symbols);
DECLARE_SUITE(util);
+DECLARE_SUITE(uncore_event_sorting);
DECLARE_SUITE(subcmd_help);
DECLARE_SUITE(kallsyms_split);
diff --git a/tools/perf/tests/uncore-event-sorting.c b/tools/perf/tests/uncore-event-sorting.c
new file mode 100644
index 000000000000..7d2fc304e21f
--- /dev/null
+++ b/tools/perf/tests/uncore-event-sorting.c
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
+#include <string.h>
+
+#include "debug.h"
+#include "evlist.h"
+#include "parse-events.h"
+#include "pmu.h"
+#include "pmus.h"
+#include "tests.h"
+
+struct match_state {
+ char *event1;
+ char *event2;
+};
+
+static char *clean_event_name(struct pmu_event_info *info)
+{
+ const char *name = info->name;
+ const char *pmu_name = info->pmu->name;
+ size_t pmu_len = strlen(pmu_name);
+ char *res;
+ size_t len;
+
+ if (!strncmp(name, pmu_name, pmu_len) && name[pmu_len] == '/')
+ name += pmu_len + 1;
+
+ res = strdup(name);
+ if (!res)
+ return NULL;
+
+ len = strlen(res);
+ if (len > 0 && res[len - 1] == '/')
+ res[len - 1] = '\0';
+
+ return res;
+}
+
+static int event_cb(void *state, struct pmu_event_info *info)
+{
+ struct match_state *m = state;
+ char *clean_name;
+
+ if (m->event1 && m->event2)
+ return 1;
+
+ clean_name = clean_event_name(info);
+ if (!clean_name)
+ return 0;
+
+ if (!m->event1) {
+ m->event1 = clean_name;
+ } else {
+ if (strcmp(m->event1, clean_name)) {
+ m->event2 = clean_name;
+ return 1;
+ }
+ free(clean_name);
+ }
+ return 0;
+}
+
+#define CHECK_COND(cond, text) \
+do { \
+ if (!(cond)) { \
+ pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
+ ret = TEST_FAIL; \
+ goto out_err; \
+ } \
+} while (0)
+
+#define CHECK_EQUAL(val, expected, text) \
+do { \
+ if ((val) != (expected)) { \
+ pr_debug("FAILED %s:%d %s (%d != %d)\n", \
+ __FILE__, __LINE__, text, (val), (expected)); \
+ ret = TEST_FAIL; \
+ goto out_err; \
+ } \
+} while (0)
+
+static int test__uncore_event_sorting(struct test_suite *test __maybe_unused,
+ int subtest __maybe_unused)
+{
+ struct evlist *evlist = NULL;
+ struct parse_events_error err;
+ struct evsel *evsel;
+ struct perf_pmu *pmu = NULL;
+ char *pmu_prefix = NULL;
+ struct match_state m = { NULL, NULL };
+ char buf[1024];
+ int ret;
+
+ parse_events_error__init(&err);
+
+ while ((pmu = perf_pmus__scan(pmu)) != NULL) {
+ size_t len;
+ struct perf_pmu *sibling;
+
+ if (pmu->is_core)
+ continue;
+
+ len = pmu_name_len_no_suffix(pmu->name);
+ if (len == strlen(pmu->name))
+ continue;
+
+ sibling = pmu;
+ while ((sibling = perf_pmus__scan(sibling)) != NULL) {
+ if (sibling->is_core)
+ continue;
+ if (pmu_name_len_no_suffix(sibling->name) == len &&
+ !strncmp(pmu->name, sibling->name, len))
+ break;
+ }
+
+ if (!sibling)
+ continue;
+
+ m.event1 = m.event2 = NULL;
+ perf_pmu__for_each_event(pmu, false, &m, event_cb);
+
+ if (m.event1 && m.event2) {
+ pmu_prefix = strndup(pmu->name, len);
+ break;
+ }
+ zfree(&m.event1);
+ }
+
+ if (!pmu_prefix) {
+ pr_debug("No suitable uncore PMU found\n");
+ ret = TEST_SKIP;
+ goto out_err;
+ }
+
+ evlist = evlist__new();
+ if (!evlist) {
+ ret = TEST_FAIL;
+ goto out_err;
+ }
+
+ snprintf(buf, sizeof(buf), "{%s/%s/,%s/%s/}", pmu_prefix, m.event1, pmu_prefix, m.event2);
+ pr_debug("Parsing: %s\n", buf);
+
+ ret = parse_events(evlist, buf, &err);
+ if (ret) {
+ pr_debug("parse_events failed\n");
+ ret = TEST_FAIL;
+ goto out_err;
+ }
+
+ CHECK_COND(evlist->core.nr_entries >= 4, "Number of events is >= 4");
+ CHECK_EQUAL(evlist->core.nr_entries % 2, 0, "Number of events is a multiple of 2");
+
+ evlist__for_each_entry(evlist, evsel) {
+ struct evsel *next;
+
+ if (!evsel__is_group_leader(evsel))
+ continue;
+
+ next = evsel__next(evsel);
+ CHECK_EQUAL(evsel->core.nr_members, 2, "Group size is 2");
+ CHECK_COND(evsel->pmu == next->pmu, "PMU match");
+ CHECK_COND(strstr(evsel__name(evsel), m.event1) != NULL, "First event name");
+ CHECK_COND(strstr(evsel__name(next), m.event2) != NULL, "Second event name");
+ }
+ ret = TEST_OK;
+
+out_err:
+ evlist__delete(evlist);
+ parse_events_error__exit(&err);
+ zfree(&pmu_prefix);
+ zfree(&m.event1);
+ zfree(&m.event2);
+ return ret;
+}
+
+DEFINE_SUITE("Uncore event sorting", uncore_event_sorting);
--
2.54.0.563.g4f69b47b94-googAdd a test to capture the comment in
tools/perf/arch/x86/util/evlist.c. Test that slots and
topdown-retiring get appropriately sorted with respect to instructions
when they're all specified together. When the PMU requires topdown
event grouping (indicated by the pressence of the slots event) metric
events should be after slots, which should be the group leader.
Add a related test that when the slots event isn't given it is
injected into the appropriate group.
Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: Zide Chen <zide.chen@intel.com>
---
tools/perf/arch/x86/tests/topdown.c | 166 +++++++++++++++++++++++++++-
1 file changed, 165 insertions(+), 1 deletion(-)
diff --git a/tools/perf/arch/x86/tests/topdown.c b/tools/perf/arch/x86/tests/topdown.c
index 3ee4e5e71be3..221f2c4bbb61 100644
--- a/tools/perf/arch/x86/tests/topdown.c
+++ b/tools/perf/arch/x86/tests/topdown.c
@@ -75,4 +75,168 @@ static int test__x86_topdown(struct test_suite *test __maybe_unused, int subtest
return ret;
}
-DEFINE_SUITE("x86 topdown", x86_topdown);
+#define CHECK_COND(cond, text) \
+do { \
+ if (!(cond)) { \
+ pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
+ ret = TEST_FAIL; \
+ goto out_err; \
+ } \
+} while (0)
+
+#define CHECK_EQUAL(val, expected, text) \
+do { \
+ if ((val) != (expected)) { \
+ pr_debug("FAILED %s:%d %s (%d != %d)\n", \
+ __FILE__, __LINE__, text, (val), (expected)); \
+ ret = TEST_FAIL; \
+ goto out_err; \
+ } \
+} while (0)
+
+static int test_sort(const char *str, int expected_slots_group_size,
+ int expected_instructions_group_size)
+{
+ struct evlist *evlist = NULL;
+ struct parse_events_error err;
+ struct evsel *evsel;
+ int ret = TEST_FAIL;
+ bool slots_seen = false;
+
+ parse_events_error__init(&err);
+
+ evlist = evlist__new();
+ if (!evlist)
+ goto out_err;
+
+ if (parse_events(evlist, str, &err)) {
+ pr_debug("parse_events failed for %s\n", str);
+ goto out_err;
+ }
+
+ evlist__for_each_entry(evlist, evsel) {
+ if (!evsel__is_group_leader(evsel))
+ continue;
+
+ if (strstr(evsel__name(evsel), "slots")) {
+ /*
+ * Slots as a leader means the PMU is for a perf metric
+ * group as the slots event isn't present when not.
+ */
+ slots_seen = true;
+ CHECK_EQUAL(evsel->core.nr_members, expected_slots_group_size,
+ "slots group size");
+ if (expected_slots_group_size == 3) {
+ struct evsel *next = evsel__next(evsel);
+ struct evsel *next2 = evsel__next(next);
+
+ CHECK_COND(strstr(evsel__name(next), "instructions") != NULL,
+ "slots second event is instructions");
+ CHECK_COND(strstr(evsel__name(next2), "topdown-retiring") != NULL,
+ "slots third event is topdown-retiring");
+ } else if (expected_slots_group_size == 2) {
+ struct evsel *next = evsel__next(evsel);
+
+ CHECK_COND(strstr(evsel__name(next), "topdown-retiring") != NULL,
+ "slots second event is topdown-retiring");
+ }
+ } else if (strstr(evsel__name(evsel), "instructions")) {
+ CHECK_EQUAL(evsel->core.nr_members, expected_instructions_group_size,
+ "instructions group size");
+ if (expected_instructions_group_size == 2) {
+ /*
+ * On Intel hybrid CPUs (e.g., Alder Lake/
+ * Raptor Lake), E-cores (cpu_atom) do not
+ * support/enforce the slots event. When
+ * parsing event groups containing slots
+ * across all PMUs, slots is automatically
+ * filtered out from cpu_atom, leaving
+ * {cpu_atom/instructions/,
+ * cpu_atom/topdown-retiring/}. On cpu_atom,
+ * instructions correctly leads this group of
+ * 2 without slots reordering.
+ */
+ struct evsel *next = evsel__next(evsel);
+
+ CHECK_COND(strstr(evsel__name(next), "topdown-retiring") != NULL,
+ "instructions second event is topdown-retiring");
+ }
+ } else if (strstr(evsel__name(evsel), "topdown-retiring")) {
+ /*
+ * A perf metric event where the PMU doesn't require
+ * slots as a leader.
+ */
+ CHECK_EQUAL(evsel->core.nr_members, 1, "topdown-retiring group size");
+ } else if (strstr(evsel__name(evsel), "cycles")) {
+ CHECK_EQUAL(evsel->core.nr_members, 1, "cycles group size");
+ }
+ }
+ CHECK_COND(slots_seen, "slots seen");
+ ret = TEST_OK;
+out_err:
+ evlist__delete(evlist);
+ parse_events_error__exit(&err);
+ return ret;
+}
+
+static int test__x86_topdown_sorting(struct test_suite *test __maybe_unused,
+ int subtest __maybe_unused)
+{
+ int ret;
+
+ if (!topdown_sys_has_perf_metrics())
+ return TEST_OK;
+
+ ret = test_sort("{instructions,topdown-retiring,slots}", 3, 2);
+ TEST_ASSERT_EQUAL("all events in a group", ret, TEST_OK);
+ ret = test_sort("instructions,topdown-retiring,slots", 2, 1);
+ TEST_ASSERT_EQUAL("all events not in a group", ret, TEST_OK);
+ ret = test_sort("{instructions,slots},topdown-retiring", 2, 1);
+ TEST_ASSERT_EQUAL("slots event in a group but topdown metrics events outside the group",
+ ret, TEST_OK);
+ ret = test_sort("{instructions,slots},{topdown-retiring}", 2, 1);
+ TEST_ASSERT_EQUAL("slots event and topdown metrics events in two groups",
+ ret, TEST_OK);
+ ret = test_sort("{instructions,slots},cycles,topdown-retiring", 2, 1);
+ TEST_ASSERT_EQUAL("slots event and metrics event are not in a group and not adjacent",
+ ret, TEST_OK);
+
+ return TEST_OK;
+}
+
+static int test__x86_topdown_slots_injection(struct test_suite *test __maybe_unused,
+ int subtest __maybe_unused)
+{
+ int ret;
+
+ if (!topdown_sys_has_perf_metrics())
+ return TEST_OK;
+
+ ret = test_sort("{instructions,topdown-retiring}", 3, 2);
+ TEST_ASSERT_EQUAL("all events in a group", ret, TEST_OK);
+ ret = test_sort("instructions,topdown-retiring", 2, 1);
+ TEST_ASSERT_EQUAL("all events not in a group", ret, TEST_OK);
+ ret = test_sort("{instructions},topdown-retiring", 2, 1);
+ TEST_ASSERT_EQUAL("event in a group but topdown metrics events outside the group",
+ ret, TEST_OK);
+ ret = test_sort("{instructions},{topdown-retiring}", 2, 1);
+ TEST_ASSERT_EQUAL("event and topdown metrics events in two groups",
+ ret, TEST_OK);
+ ret = test_sort("{instructions},cycles,topdown-retiring", 2, 1);
+ TEST_ASSERT_EQUAL("event and metrics event are not in a group and not adjacent",
+ ret, TEST_OK);
+
+ return TEST_OK;
+}
+
+static struct test_case x86_topdown_tests[] = {
+ TEST_CASE("topdown events", x86_topdown),
+ TEST_CASE("topdown sorting", x86_topdown_sorting),
+ TEST_CASE("topdown slots injection", x86_topdown_slots_injection),
+ { .name = NULL, }
+};
+
+struct test_suite suite__x86_topdown = {
+ .desc = "x86 topdown",
+ .test_cases = x86_topdown_tests,
+};
--
2.54.0.563.g4f69b47b94-goog© 2016 - 2026 Red Hat, Inc.