Commit 5dc8f73e authored by Dave Martin's avatar Dave Martin Committed by James Morse
Browse files

arm_mpam: resctrl: Add kunit test for control format conversions 



resctrl specifies the format of the control schemes, and these don't match
the hardware.

Some of the conversions are a bit hairy - add some kunit tests.

Tested-by: default avatarGavin Shan <gshan@redhat.com>
Tested-by: default avatarShaopeng Tan <tan.shaopeng@jp.fujitsu.com>
Tested-by: default avatarPeter Newman <peternewman@google.com>
Tested-by: default avatarZeng Heng <zengheng4@huawei.com>
Tested-by: default avatarPunit Agrawal <punit.agrawal@oss.qualcomm.com>
Tested-by: default avatarJesse Chick <jessechick@os.amperecomputing.com>
Reviewed-by: default avatarZeng Heng <zengheng4@huawei.com>
Reviewed-by: default avatarShaopeng Tan <tan.shaopeng@jp.fujitsu.com>
Reviewed-by: default avatarJonathan Cameron <jonathan.cameron@huawei.com>
Reviewed-by: default avatarGavin Shan <gshan@redhat.com>
Signed-off-by: default avatarDave Martin <Dave.Martin@arm.com>
[morse: squashed enough of Dave's fixes in here that it's his patch now!]
Signed-off-by: default avatarBen Horgan <ben.horgan@arm.com>
Signed-off-by: default avatarJames Morse <james.morse@arm.com>
parent 36528c76

drivers/resctrl/mpam_resctrl.c

+4 −0
Original line number Diff line number Diff line
@@ -1092,3 +1092,7 @@ static int __init __cacheinfo_ready(void) 
	return 0;

}

device_initcall_sync(__cacheinfo_ready);



#ifdef CONFIG_MPAM_KUNIT_TEST

#include "test_mpam_resctrl.c"

#endif

drivers/resctrl/test_mpam_resctrl.c

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

// Copyright (C) 2025 Arm Ltd.

/* This file is intended to be included into mpam_resctrl.c */



#include <kunit/test.h>

#include <linux/array_size.h>

#include <linux/bits.h>

#include <linux/math.h>

#include <linux/sprintf.h>



struct percent_value_case {

	u8	pc;

	u8	width;

	u16	value;

};



/*

 * Mysterious inscriptions taken from the union of ARM DDI 0598D.b,

 * "Arm Architecture Reference Manual Supplement - Memory System

 * Resource Partitioning and Monitoring (MPAM), for A-profile

 * architecture", Section 9.8, "About the fixed-point fractional

 * format" (exact percentage entries only) and ARM IHI0099B.a

 * "MPAM system component specification", Section 9.3,

 * "The fixed-point fractional format":

 */

static const struct percent_value_case percent_value_cases[] = {

	/* Architectural cases: */

	{   1,  8,    1 },	{   1, 12,  0x27 },	{   1, 16,  0x28e },

	{  25,  8, 0x3f },	{  25, 12, 0x3ff },	{  25, 16, 0x3fff },

	{  33,  8, 0x53 },	{  33, 12, 0x546 },	{  33, 16, 0x5479 },

	{  35,  8, 0x58 },	{  35, 12, 0x598 },	{  35, 16, 0x5998 },

	{  45,  8, 0x72 },	{  45, 12, 0x732 },	{  45, 16, 0x7332 },

	{  50,  8, 0x7f },	{  50, 12, 0x7ff },	{  50, 16, 0x7fff },

	{  52,  8, 0x84 },	{  52, 12, 0x850 },	{  52, 16, 0x851d },

	{  55,  8, 0x8b },	{  55, 12, 0x8cb },	{  55, 16, 0x8ccb },

	{  58,  8, 0x93 },	{  58, 12, 0x946 },	{  58, 16, 0x9479 },

	{  75,  8, 0xbf },	{  75, 12, 0xbff },	{  75, 16, 0xbfff },

	{  80,  8, 0xcb },	{  80, 12, 0xccb },	{  80, 16, 0xcccb },

	{  88,  8, 0xe0 },	{  88, 12, 0xe13 },	{  88, 16, 0xe146 },

	{  95,  8, 0xf2 },	{  95, 12, 0xf32 },	{  95, 16, 0xf332 },

	{ 100,  8, 0xff },	{ 100, 12, 0xfff },	{ 100, 16, 0xffff },

};



static void test_percent_value_desc(const struct percent_value_case *param,

				    char *desc)

{

	snprintf(desc, KUNIT_PARAM_DESC_SIZE,

		 "pc=%d, width=%d, value=0x%.*x\n",

		 param->pc, param->width,

		 DIV_ROUND_UP(param->width, 4), param->value);

}



KUNIT_ARRAY_PARAM(test_percent_value, percent_value_cases,

		  test_percent_value_desc);



struct percent_value_test_info {

	u32 pc;			/* result of value-to-percent conversion */

	u32 value;		/* result of percent-to-value conversion */

	u32 max_value;		/* maximum raw value allowed by test params */

	unsigned int shift;	/* promotes raw testcase value to 16 bits */

};



/*

 * Convert a reference percentage to a fixed-point MAX value and

 * vice-versa, based on param (not test->param_value!)

 */

static void __prepare_percent_value_test(struct kunit *test,

					 struct percent_value_test_info *res,

					 const struct percent_value_case *param)

{

	struct mpam_props fake_props = { };



	/* Reject bogus test parameters that would break the tests: */

	KUNIT_ASSERT_GE(test, param->width, 1);

	KUNIT_ASSERT_LE(test, param->width, 16);

	KUNIT_ASSERT_LT(test, param->value, 1 << param->width);



	mpam_set_feature(mpam_feat_mbw_max, &fake_props);

	fake_props.bwa_wd = param->width;



	res->shift = 16 - param->width;

	res->max_value = GENMASK_U32(param->width - 1, 0);

	res->value = percent_to_mbw_max(param->pc, &fake_props);

	res->pc = mbw_max_to_percent(param->value << res->shift, &fake_props);

}



static void test_get_mba_granularity(struct kunit *test)

{

	int ret;

	struct mpam_props fake_props = { };



	/* Use MBW_MAX */

	mpam_set_feature(mpam_feat_mbw_max, &fake_props);



	fake_props.bwa_wd = 0;

	KUNIT_EXPECT_FALSE(test, mba_class_use_mbw_max(&fake_props));



	fake_props.bwa_wd = 1;

	KUNIT_EXPECT_TRUE(test, mba_class_use_mbw_max(&fake_props));



	/* Architectural maximum: */

	fake_props.bwa_wd = 16;

	KUNIT_EXPECT_TRUE(test, mba_class_use_mbw_max(&fake_props));



	/* No usable control... */

	fake_props.bwa_wd = 0;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 0);



	fake_props.bwa_wd = 1;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 50);	/* DIV_ROUND_UP(100, 1 << 1)% = 50% */



	fake_props.bwa_wd = 2;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 25);	/* DIV_ROUND_UP(100, 1 << 2)% = 25% */



	fake_props.bwa_wd = 3;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 13);	/* DIV_ROUND_UP(100, 1 << 3)% = 13% */



	fake_props.bwa_wd = 6;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 2);	/* DIV_ROUND_UP(100, 1 << 6)% = 2% */



	fake_props.bwa_wd = 7;

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 1);	/* DIV_ROUND_UP(100, 1 << 7)% = 1% */



	/* Granularity saturates at 1% */

	fake_props.bwa_wd = 16; /* architectural maximum */

	ret = get_mba_granularity(&fake_props);

	KUNIT_EXPECT_EQ(test, ret, 1);	/* DIV_ROUND_UP(100, 1 << 16)% = 1% */

}



static void test_mbw_max_to_percent(struct kunit *test)

{

	const struct percent_value_case *param = test->param_value;

	struct percent_value_test_info res;



	/*

	 * Since the reference values in percent_value_cases[] all

	 * correspond to exact percentages, round-to-nearest will

	 * always give the exact percentage back when the MPAM max

	 * value has precision of 0.5% or finer.  (Always true for the

	 * reference data, since they all specify 8 bits or more of

	 * precision.

	 *

	 * So, keep it simple and demand an exact match:

	 */

	__prepare_percent_value_test(test, &res, param);

	KUNIT_EXPECT_EQ(test, res.pc, param->pc);

}



static void test_percent_to_mbw_max(struct kunit *test)

{

	const struct percent_value_case *param = test->param_value;

	struct percent_value_test_info res;



	__prepare_percent_value_test(test, &res, param);



	KUNIT_EXPECT_GE(test, res.value, param->value << res.shift);

	KUNIT_EXPECT_LE(test, res.value, (param->value + 1) << res.shift);

	KUNIT_EXPECT_LE(test, res.value, res.max_value << res.shift);



	/* No flexibility allowed for 0% and 100%! */



	if (param->pc == 0)

		KUNIT_EXPECT_EQ(test, res.value, 0);



	if (param->pc == 100)

		KUNIT_EXPECT_EQ(test, res.value, res.max_value << res.shift);

}



static const void *test_all_bwa_wd_gen_params(struct kunit *test, const void *prev,

					      char *desc)

{

	uintptr_t param = (uintptr_t)prev;



	if (param > 15)

		return NULL;



	param++;



	snprintf(desc, KUNIT_PARAM_DESC_SIZE, "wd=%u\n", (unsigned int)param);



	return (void *)param;

}



static unsigned int test_get_bwa_wd(struct kunit *test)

{

	uintptr_t param = (uintptr_t)test->param_value;



	KUNIT_ASSERT_GE(test, param, 1);

	KUNIT_ASSERT_LE(test, param, 16);



	return param;

}



static void test_mbw_max_to_percent_limits(struct kunit *test)

{

	struct mpam_props fake_props = {0};

	u32 max_value;



	mpam_set_feature(mpam_feat_mbw_max, &fake_props);

	fake_props.bwa_wd = test_get_bwa_wd(test);

	max_value = GENMASK(15, 16 - fake_props.bwa_wd);



	KUNIT_EXPECT_EQ(test, mbw_max_to_percent(max_value, &fake_props),

			MAX_MBA_BW);

	KUNIT_EXPECT_EQ(test, mbw_max_to_percent(0, &fake_props),

			get_mba_min(&fake_props));



	/*

	 * Rounding policy dependent 0% sanity-check:

	 * With round-to-nearest, the minimum mbw_max value really

	 * should map to 0% if there are at least 200 steps.

	 * (100 steps may be enough for some other rounding policies.)

	 */

	if (fake_props.bwa_wd >= 8)

		KUNIT_EXPECT_EQ(test, mbw_max_to_percent(0, &fake_props), 0);



	if (fake_props.bwa_wd < 8 &&

	    mbw_max_to_percent(0, &fake_props) == 0)

		kunit_warn(test, "wd=%d: Testsuite/driver Rounding policy mismatch?",

			   fake_props.bwa_wd);

}



/*

 * Check that converting a percentage to mbw_max and back again (or, as

 * appropriate, vice-versa) always restores the original value:

 */

static void test_percent_max_roundtrip_stability(struct kunit *test)

{

	struct mpam_props fake_props = {0};

	unsigned int shift;

	u32 pc, max, pc2, max2;



	mpam_set_feature(mpam_feat_mbw_max, &fake_props);

	fake_props.bwa_wd = test_get_bwa_wd(test);

	shift = 16 - fake_props.bwa_wd;



	/*

	 * Converting a valid value from the coarser scale to the finer

	 * scale and back again must yield the original value:

	 */

	if (fake_props.bwa_wd >= 7) {

		/* More than 100 steps: only test exact pc values: */

		for (pc = get_mba_min(&fake_props); pc <= MAX_MBA_BW; pc++) {

			max = percent_to_mbw_max(pc, &fake_props);

			pc2 = mbw_max_to_percent(max, &fake_props);

			KUNIT_EXPECT_EQ(test, pc2, pc);

		}

	} else {

		/* Fewer than 100 steps: only test exact mbw_max values: */

		for (max = 0; max < 1 << 16; max += 1 << shift) {

			pc = mbw_max_to_percent(max, &fake_props);

			max2 = percent_to_mbw_max(pc, &fake_props);

			KUNIT_EXPECT_EQ(test, max2, max);

		}

	}

}



static void test_percent_to_max_rounding(struct kunit *test)

{

	const struct percent_value_case *param = test->param_value;

	unsigned int num_rounded_up = 0, total = 0;

	struct percent_value_test_info res;



	for (param = percent_value_cases, total = 0;

	     param < &percent_value_cases[ARRAY_SIZE(percent_value_cases)];

	     param++, total++) {

		__prepare_percent_value_test(test, &res, param);

		if (res.value > param->value << res.shift)

			num_rounded_up++;

	}



	/*

	 * The MPAM driver applies a round-to-nearest policy, whereas a

	 * round-down policy seems to have been applied in the

	 * reference table from which the test vectors were selected.

	 *

	 * For a large and well-distributed suite of test vectors,

	 * about half should be rounded up and half down compared with

	 * the reference table.  The actual test vectors are few in

	 * number and probably not very well distributed however, so

	 * tolerate a round-up rate of between 1/4 and 3/4 before

	 * crying foul:

	 */



	kunit_info(test, "Round-up rate: %u%% (%u/%u)\n",

		   DIV_ROUND_CLOSEST(num_rounded_up * 100, total),

		   num_rounded_up, total);



	KUNIT_EXPECT_GE(test, 4 * num_rounded_up, 1 * total);

	KUNIT_EXPECT_LE(test, 4 * num_rounded_up, 3 * total);

}



static struct kunit_case mpam_resctrl_test_cases[] = {

	KUNIT_CASE(test_get_mba_granularity),

	KUNIT_CASE_PARAM(test_mbw_max_to_percent, test_percent_value_gen_params),

	KUNIT_CASE_PARAM(test_percent_to_mbw_max, test_percent_value_gen_params),

	KUNIT_CASE_PARAM(test_mbw_max_to_percent_limits, test_all_bwa_wd_gen_params),

	KUNIT_CASE(test_percent_to_max_rounding),

	KUNIT_CASE_PARAM(test_percent_max_roundtrip_stability,

			 test_all_bwa_wd_gen_params),

	{}

};



static struct kunit_suite mpam_resctrl_test_suite = {

	.name = "mpam_resctrl_test_suite",

	.test_cases = mpam_resctrl_test_cases,

};



kunit_test_suites(&mpam_resctrl_test_suite);