Commit ae4aa00a authored by Ian Rogers's avatar Ian Rogers Committed by Arnaldo Carvalho de Melo
Browse files

perf test: Move x86 hybrid tests to arch/x86 



The tests use x86 hybrid specific PMUs.

Signed-off-by: default avatarIan Rogers <irogers@google.com>
Tested-by: default avatarKan Liang <kan.liang@linux.intel.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ahmad Yasin <ahmad.yasin@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Athira Rajeev <atrajeev@linux.vnet.ibm.com>
Cc: Caleb Biggers <caleb.biggers@intel.com>
Cc: Edward Baker <edward.baker@intel.com>
Cc: Florian Fischer <florian.fischer@muhq.space>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Kajol Jain <kjain@linux.ibm.com>
Cc: Kang Minchul <tegongkang@gmail.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Perry Taylor <perry.taylor@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Rob Herring <robh@kernel.org>
Cc: Samantha Alt <samantha.alt@intel.com>
Cc: Stephane Eranian <eranian@google.com>
Cc: Sumanth Korikkar <sumanthk@linux.ibm.com>
Cc: Suzuki Poulouse <suzuki.poulose@arm.com>
Cc: Thomas Richter <tmricht@linux.ibm.com>
Cc: Tiezhu Yang <yangtiezhu@loongson.cn>
Cc: Weilin Wang <weilin.wang@intel.com>
Cc: Xing Zhengjun <zhengjun.xing@linux.intel.com>
Cc: Yang Jihong <yangjihong1@huawei.com>
Link: https://lore.kernel.org/r/20230502223851.2234828-21-irogers@google.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 70c90e4a

tools/perf/arch/x86/include/arch-tests.h

+1 −0
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ int test__intel_pt_pkt_decoder(struct test_suite *test, int subtest); 
int test__intel_pt_hybrid_compat(struct test_suite *test, int subtest);

int test__bp_modify(struct test_suite *test, int subtest);

int test__x86_sample_parsing(struct test_suite *test, int subtest);

int test__hybrid(struct test_suite *test, int subtest);



extern struct test_suite *arch_tests[];

tools/perf/arch/x86/tests/Build

+1 −0
Original line number Diff line number Diff line
@@ -3,5 +3,6 @@ perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o 


perf-y += arch-tests.o

perf-y += sample-parsing.o

perf-y += hybrid.o

perf-$(CONFIG_AUXTRACE) += insn-x86.o intel-pt-test.o

perf-$(CONFIG_X86_64) += bp-modify.o

tools/perf/arch/x86/tests/arch-tests.c

+10 −0
Original line number Diff line number Diff line
@@ -22,6 +22,15 @@ struct test_suite suite__intel_pt = { 
DEFINE_SUITE("x86 bp modify", bp_modify);

#endif

DEFINE_SUITE("x86 Sample parsing", x86_sample_parsing);

static struct test_case hybrid_tests[] = {

	TEST_CASE_REASON("x86 hybrid event parsing", hybrid, "not hybrid"),

	{ .name = NULL, }

};



struct test_suite suite__hybrid = {

	.desc = "x86 hybrid",

	.test_cases = hybrid_tests,

};



struct test_suite *arch_tests[] = {

#ifdef HAVE_DWARF_UNWIND_SUPPORT
@@ -35,5 +44,6 @@ struct test_suite *arch_tests[] = { 
	&suite__bp_modify,

#endif

	&suite__x86_sample_parsing,

	&suite__hybrid,

	NULL,

};

tools/perf/arch/x86/tests/hybrid.c

0 → 100644
+277 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include "arch-tests.h"

#include "debug.h"

#include "evlist.h"

#include "evsel.h"

#include "pmu-hybrid.h"

#include "tests/tests.h"



static bool test_config(const struct evsel *evsel, __u64 expected_config)

{

	return (evsel->core.attr.config & PERF_HW_EVENT_MASK) == expected_config;

}



static int test__hybrid_hw_event_with_pmu(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	return TEST_OK;

}



static int test__hybrid_hw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0xc0));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_sw_hw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_hw_sw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_group_modifier1(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);

	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0xc0));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);

	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);

	return TEST_OK;

}



static int test__hybrid_raw1(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	if (!perf_pmu__hybrid_mounted("cpu_atom")) {

		TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

		TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

		TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

		return TEST_OK;

	}



	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));



	/* The type of second event is randome value */

	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

	return TEST_OK;

}



static int test__hybrid_raw2(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

	return TEST_OK;

}



static int test__hybrid_cache_event(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", 0x2 == (evsel->core.attr.config & 0xffffffff));

	return TEST_OK;

}



static int test__checkevent_pmu(struct evlist *evlist)

{



	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config",    10 == evsel->core.attr.config);

	TEST_ASSERT_VAL("wrong config1",    1 == evsel->core.attr.config1);

	TEST_ASSERT_VAL("wrong config2",    3 == evsel->core.attr.config2);

	TEST_ASSERT_VAL("wrong config3",    0 == evsel->core.attr.config3);

	/*

	 * The period value gets configured within evlist__config,

	 * while this test executes only parse events method.

	 */

	TEST_ASSERT_VAL("wrong period",     0 == evsel->core.attr.sample_period);



	return TEST_OK;

}



struct evlist_test {

	const char *name;

	bool (*valid)(void);

	int (*check)(struct evlist *evlist);

};



static const struct evlist_test test__hybrid_events[] = {

	{

		.name  = "cpu_core/cpu-cycles/",

		.check = test__hybrid_hw_event_with_pmu,

		/* 0 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/,cpu_core/instructions/}",

		.check = test__hybrid_hw_group_event,

		/* 1 */

	},

	{

		.name  = "{cpu-clock,cpu_core/cpu-cycles/}",

		.check = test__hybrid_sw_hw_group_event,

		/* 2 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/,cpu-clock}",

		.check = test__hybrid_hw_sw_group_event,

		/* 3 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}",

		.check = test__hybrid_group_modifier1,

		/* 4 */

	},

	{

		.name  = "r1a",

		.check = test__hybrid_raw1,

		/* 5 */

	},

	{

		.name  = "cpu_core/r1a/",

		.check = test__hybrid_raw2,

		/* 6 */

	},

	{

		.name  = "cpu_core/config=10,config1,config2=3,period=1000/u",

		.check = test__checkevent_pmu,

		/* 7 */

	},

	{

		.name  = "cpu_core/LLC-loads/",

		.check = test__hybrid_cache_event,

		/* 8 */

	},

};



static int test_event(const struct evlist_test *e)

{

	struct parse_events_error err;

	struct evlist *evlist;

	int ret;



	if (e->valid && !e->valid()) {

		pr_debug("... SKIP\n");

		return TEST_OK;

	}



	evlist = evlist__new();

	if (evlist == NULL) {

		pr_err("Failed allocation");

		return TEST_FAIL;

	}

	parse_events_error__init(&err);

	ret = parse_events(evlist, e->name, &err);

	if (ret) {

		pr_debug("failed to parse event '%s', err %d, str '%s'\n",

			 e->name, ret, err.str);

		parse_events_error__print(&err, e->name);

		ret = TEST_FAIL;

		if (strstr(err.str, "can't access trace events"))

			ret = TEST_SKIP;

	} else {

		ret = e->check(evlist);

	}

	parse_events_error__exit(&err);

	evlist__delete(evlist);



	return ret;

}



static int combine_test_results(int existing, int latest)

{

	if (existing == TEST_FAIL)

		return TEST_FAIL;

	if (existing == TEST_SKIP)

		return latest == TEST_OK ? TEST_SKIP : latest;

	return latest;

}



static int test_events(const struct evlist_test *events, int cnt)

{

	int ret = TEST_OK;



	for (int i = 0; i < cnt; i++) {

		const struct evlist_test *e = &events[i];

		int test_ret;



		pr_debug("running test %d '%s'\n", i, e->name);

		test_ret = test_event(e);

		if (test_ret != TEST_OK) {

			pr_debug("Event test failure: test %d '%s'", i, e->name);

			ret = combine_test_results(ret, test_ret);

		}

	}



	return ret;

}



int test__hybrid(struct test_suite *test __maybe_unused, int subtest __maybe_unused)

{

	if (!perf_pmu__has_hybrid())

		return TEST_SKIP;



	return test_events(test__hybrid_events, ARRAY_SIZE(test__hybrid_events));

}

tools/perf/tests/parse-events.c

+0 −181
Original line number Diff line number Diff line
@@ -6,7 +6,6 @@ 
#include "tests.h"

#include "debug.h"

#include "pmu.h"

#include "pmu-hybrid.h"

#include "pmus.h"

#include <dirent.h>

#include <errno.h>
@@ -1523,127 +1522,6 @@ static int test__all_tracepoints(struct evlist *evlist) 
}

#endif /* HAVE_LIBTRACEVENT */



static int test__hybrid_hw_event_with_pmu(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	return TEST_OK;

}



static int test__hybrid_hw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0xc0));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_sw_hw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_hw_sw_group_event(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	return TEST_OK;

}



static int test__hybrid_group_modifier1(struct evlist *evlist)

{

	struct evsel *evsel, *leader;



	evsel = leader = evlist__first(evlist);

	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x3c));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	TEST_ASSERT_VAL("wrong exclude_user", evsel->core.attr.exclude_user);

	TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->core.attr.exclude_kernel);



	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0xc0));

	TEST_ASSERT_VAL("wrong leader", evsel__has_leader(evsel, leader));

	TEST_ASSERT_VAL("wrong exclude_user", !evsel->core.attr.exclude_user);

	TEST_ASSERT_VAL("wrong exclude_kernel", evsel->core.attr.exclude_kernel);

	return TEST_OK;

}



static int test__hybrid_raw1(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	if (!perf_pmu__hybrid_mounted("cpu_atom")) {

		TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

		TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

		TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

		return TEST_OK;

	}



	TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));



	/* The type of second event is randome value */

	evsel = evsel__next(evsel);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

	return TEST_OK;

}



static int test__hybrid_raw2(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", test_config(evsel, 0x1a));

	return TEST_OK;

}



static int test__hybrid_cache_event(struct evlist *evlist)

{

	struct evsel *evsel = evlist__first(evlist);



	TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->core.nr_entries);

	TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->core.attr.type);

	TEST_ASSERT_VAL("wrong config", 0x2 == (evsel->core.attr.config & 0xffffffff));

	return TEST_OK;

}



struct evlist_test {

	const char *name;

	bool (*valid)(void);
@@ -2011,54 +1889,6 @@ static const struct terms_test test__terms[] = { 
	},

};



static const struct evlist_test test__hybrid_events[] = {

	{

		.name  = "cpu_core/cpu-cycles/",

		.check = test__hybrid_hw_event_with_pmu,

		/* 0 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/,cpu_core/instructions/}",

		.check = test__hybrid_hw_group_event,

		/* 1 */

	},

	{

		.name  = "{cpu-clock,cpu_core/cpu-cycles/}",

		.check = test__hybrid_sw_hw_group_event,

		/* 2 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/,cpu-clock}",

		.check = test__hybrid_hw_sw_group_event,

		/* 3 */

	},

	{

		.name  = "{cpu_core/cpu-cycles/k,cpu_core/instructions/u}",

		.check = test__hybrid_group_modifier1,

		/* 4 */

	},

	{

		.name  = "r1a",

		.check = test__hybrid_raw1,

		/* 5 */

	},

	{

		.name  = "cpu_core/r1a/",

		.check = test__hybrid_raw2,

		/* 6 */

	},

	{

		.name  = "cpu_core/config=10,config1,config2=3,period=1000/u",

		.check = test__checkevent_pmu,

		/* 7 */

	},

	{

		.name  = "cpu_core/LLC-loads/",

		.check = test__hybrid_cache_event,

		/* 8 */

	},

};



static int test_event(const struct evlist_test *e)

{

	struct parse_events_error err;
@@ -2337,14 +2167,6 @@ static bool test_alias(char **event, char **alias) 
	return false;

}



static int test__hybrid(struct test_suite *test __maybe_unused, int subtest __maybe_unused)

{

	if (!perf_pmu__has_hybrid())

		return TEST_SKIP;



	return test_events(test__hybrid_events, ARRAY_SIZE(test__hybrid_events));

}



static int test__checkevent_pmu_events_alias(struct evlist *evlist)

{

	struct evsel *evsel1 = evlist__first(evlist);
@@ -2408,9 +2230,6 @@ static struct test_case tests__parse_events[] = { 
	TEST_CASE_REASON("Test event parsing",

			 events2,

			 "permissions"),

	TEST_CASE_REASON("Test parsing of \"hybrid\" CPU events",

			 hybrid,

			"not hybrid"),

	TEST_CASE_REASON("Parsing of all PMU events from sysfs",

			 pmu_events,

			 "permissions"),