Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316// 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);