Skip to contentSkip to conversation

selftests/resctrl: Run the MBA test on arm64 MPAM via the NVIDIA SCF PMU

PATCH In review Richard Cheng 2 participants 8 messages Jul 22 – Aug 18

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover selftests/resctrl: Run the MBA test on arm64 MPAM via the NVIDIA SCF PMU

The resctrl MBA selftest is currently Intel-only: the test is vendor-gated to GenuineIntel and its reference bandwidth measurement is hard-wired to the Intel iMC uncore PMU. MPAM on arm64 exposes the same MB resource through resctrl, and NVIDIA Grace/Vera systems provide an uncore PMU (the SoC coherency fabric, SCF) that can serve as the same kind of independent reference that the iMC provides on x86.

Patches 1-2 decouple the test machinery from the iMC with no functional change and no NVIDIA code: a mechanical rename, then a small backend abstraction (detect()/setup_counters()) with the iMC as the only backend. Patch 3 teaches the framework the MPAM memory bandwidth monitoring layout (NUMA-node-keyed MB domains, MB_MON's mbm_total_bytes, ABMC counter assignment). Patch 4 switches the MBA test from vendor gating to feature detection. Patch 5 adds the NVIDIA SCF PMU as a reference bandwidth backend, making the MBA test runnable on arm64.

The series builds after each patch, and mid-series behavior is sane:
on arm64 the MBA test skips cleanly until patch 5, after which it runs and passes. x86 behavior is preserved throughout - the iMC stays the default backend and the mbm_local_bytes comparison path is unchanged.

This series applies on top of the 26.04_linux-nvidia.glue.others.cpu_less.hardlimit branch of

https://github.com/fyu1/NV-Kernels.fenghuay.baseos

The base-commit recorded below is the current tip of that branch.

Validated on a two-socket VR-NVL72 (Vera) system: the SCF-measured bandwidth and resctrl mbm_total_bytes agree within 3-4% across all MBA schemata levels (10%..100%), against the test's 8% threshold.

Richard Cheng (5):
selftests/resctrl: Make memory bandwidth measurement vendor-neutral selftests/resctrl: Abstract reference bandwidth counters behind a
backend
selftests/resctrl: Support the MPAM memory bandwidth monitoring layout selftests/resctrl: Gate the MBA test on features, not CPU vendor selftests/resctrl: Add NVIDIA SCF reference bandwidth backend

 tools/testing/selftests/resctrl/mba_test.c    |  38 +-
 tools/testing/selftests/resctrl/mbm_test.c    |  23 +-
 tools/testing/selftests/resctrl/resctrl.h     |   6 +-
 tools/testing/selftests/resctrl/resctrl_val.c | 530 ++++++++++++++----
 tools/testing/selftests/resctrl/resctrlfs.c   |  45 +-
 5 files changed, 519 insertions(+), 123 deletions(-)

base-commit: 475f355d0408698d9f632ba3b9a5dfb1f91e928b

Signature · 1 line
2.43.0
#1 lore raw

PATCH 1/5 selftests/resctrl: Make memory bandwidth measurement vendor-neutral

The MBA and MBM tests validate resctrl's bandwidth accounting against an independent reference: the Intel iMC uncore PMU read through perf. Most of the machinery involved (counter bookkeeping, the one second measurement window, multiplexing correction, result logging and the comparison with the resctrl value) is not iMC-specific, yet it is all named after the iMC.

Rename the shared machinery and the result labels to vendor-neutral names in preparation for supporting reference memory bandwidth PMUs on other architectures:

  - struct imc_counter_config         -> struct mem_bw_counter
  - imc_counters_config[], imcs       -> bw_counters[], nr_bw_counters
  - MAX_IMCS                          -> MAX_BW_COUNTERS
  - initialize_read_mem_bw_imc()      -> initialize_mem_bw_ref()
  - perf_open/close_imc_read_mem_bw() -> perf_open/close_mem_bw_counters()
  - do_imc_read_mem_bw_test()         -> do_mem_bw_test()
  - get_read_mem_bw_imc()             -> get_mem_bw_ref()
  - "Mem_BW_iMC" result file label    -> "Mem_BW_ref"
  - bw_imc / avg_bw_imc               -> bw_ref / avg_bw_ref

check_results() parses result lines by field position, not by label, so the label change has no effect on parsing.

While touching it, reflow the result-file fprintf() so the previously overlong line (101 columns since before this change) fits within the 100 column limit, keeping the format string unsplit.

Functions whose logic is genuinely iMC-specific (num_of_imcs(), read_from_imc_dir()) keep their names.

No functional change intended.

---
 tools/testing/selftests/resctrl/mba_test.c    |  26 +--
 tools/testing/selftests/resctrl/mbm_test.c    |  22 +--
 tools/testing/selftests/resctrl/resctrl.h     |   4 +-
 tools/testing/selftests/resctrl/resctrl_val.c | 178 +++++++++---------
 4 files changed, 114 insertions(+), 116 deletions(-)
tools/testing/selftests/resctrl/mba_test.c +13 -13
index c7e9adc0368f..468ba8accc18 100644
@@ -21,7 +21,7 @@ static int mba_init(const struct resctrl_val_param *param, int domain_id)
 {
 	int ret;
 
-	ret = initialize_read_mem_bw_imc();
+	ret = initialize_mem_bw_ref();
 	if (ret)
 		return ret;
 
@@ -71,7 +71,7 @@ static int mba_measure(const struct user_params *uparams,
 	return measure_read_mem_bw(uparams, param, bm_pid);
 }
 
-static bool show_mba_info(unsigned long *bw_imc, unsigned long *bw_resc)
+static bool show_mba_info(unsigned long *bw_ref, unsigned long *bw_resc)
 {
 	unsigned int allocation;
 	bool ret = false;
@@ -81,27 +81,27 @@ static bool show_mba_info(unsigned long *bw_imc, unsigned long *bw_resc)
 	/* Memory bandwidth from 100% down to 10% */
 	for (allocation = 0; allocation < ALLOCATION_MAX / ALLOCATION_STEP;
 	     allocation++) {
-		unsigned long sum_bw_imc = 0, sum_bw_resc = 0;
-		long avg_bw_imc, avg_bw_resc;
+		unsigned long sum_bw_ref = 0, sum_bw_resc = 0;
+		long avg_bw_ref, avg_bw_resc;
 		int avg_diff_per;
 		float avg_diff;
 
 		for (runs = NUM_OF_RUNS * allocation;
 		     runs < NUM_OF_RUNS * allocation + NUM_OF_RUNS ; runs++) {
-			sum_bw_imc += bw_imc[runs];
+			sum_bw_ref += bw_ref[runs];
 			sum_bw_resc += bw_resc[runs];
 		}
 
-		avg_bw_imc = sum_bw_imc / NUM_OF_RUNS;
+		avg_bw_ref = sum_bw_ref / NUM_OF_RUNS;
 		avg_bw_resc = sum_bw_resc / NUM_OF_RUNS;
-		if (avg_bw_imc < THROTTLE_THRESHOLD || avg_bw_resc < THROTTLE_THRESHOLD) {
+		if (avg_bw_ref < THROTTLE_THRESHOLD || avg_bw_resc < THROTTLE_THRESHOLD) {
 			ksft_print_msg("Bandwidth below threshold (%d MiB). Dropping results from MBA schemata %u.\n",
 				       THROTTLE_THRESHOLD,
 				       ALLOCATION_MIN + ALLOCATION_STEP * allocation);
 			continue;
 		}
 
-		avg_diff = (float)labs(avg_bw_resc - avg_bw_imc) / avg_bw_imc;
+		avg_diff = (float)labs(avg_bw_resc - avg_bw_ref) / avg_bw_ref;
 		avg_diff_per = (int)(avg_diff * 100);
 
 		ksft_print_msg("%s Check MBA diff within %d%% for schemata %u\n",
@@ -111,7 +111,7 @@ static bool show_mba_info(unsigned long *bw_imc, unsigned long *bw_resc)
 			       ALLOCATION_MIN + ALLOCATION_STEP * allocation);
 
 		ksft_print_msg("avg_diff_per: %d%%\n", avg_diff_per);
-		ksft_print_msg("avg_bw_imc: %lu\n", avg_bw_imc);
+		ksft_print_msg("avg_bw_ref: %lu\n", avg_bw_ref);
 		ksft_print_msg("avg_bw_resc: %lu\n", avg_bw_resc);
 		if (avg_diff_per > MAX_DIFF_PERCENT)
 			ret = true;
@@ -128,7 +128,7 @@ static bool show_mba_info(unsigned long *bw_imc, unsigned long *bw_resc)
 static int check_results(void)
 {
 	unsigned long bw_resc[NUM_OF_RUNS * ALLOCATION_MAX / ALLOCATION_STEP];
-	unsigned long bw_imc[NUM_OF_RUNS * ALLOCATION_MAX / ALLOCATION_STEP];
+	unsigned long bw_ref[NUM_OF_RUNS * ALLOCATION_MAX / ALLOCATION_STEP];
 	char *token_array[8], output[] = RESULT_FILE_NAME, temp[512];
 	int runs;
 	FILE *fp;
@@ -150,8 +150,8 @@ static int check_results(void)
 			token = strtok(NULL, ":\t");
 		}
 
-		/* Field 3 is perf imc value */
-		bw_imc[runs] = strtoul(token_array[3], NULL, 0);
+		/* Field 3 is the reference PMU value */
+		bw_ref[runs] = strtoul(token_array[3], NULL, 0);
 		/* Field 5 is resctrl value */
 		bw_resc[runs] = strtoul(token_array[5], NULL, 0);
 		runs++;
@@ -159,7 +159,7 @@ static int check_results(void)
 
 	fclose(fp);
 
-	return show_mba_info(bw_imc, bw_resc);
+	return show_mba_info(bw_ref, bw_resc);
 }
 
 static void mba_test_cleanup(void)
tools/testing/selftests/resctrl/mbm_test.c +11 -11
index 84d8bc250539..001a87608835 100644
@@ -15,21 +15,21 @@
 #define NUM_OF_RUNS		5
 
 static int
-show_bw_info(unsigned long *bw_imc, unsigned long *bw_resc, size_t span)
+show_bw_info(unsigned long *bw_ref, unsigned long *bw_resc, size_t span)
 {
-	unsigned long sum_bw_imc = 0, sum_bw_resc = 0;
-	long avg_bw_imc = 0, avg_bw_resc = 0;
+	unsigned long sum_bw_ref = 0, sum_bw_resc = 0;
+	long avg_bw_ref = 0, avg_bw_resc = 0;
 	int runs, ret, avg_diff_per;
 	float avg_diff = 0;
 
 	for (runs = 0; runs < NUM_OF_RUNS; runs++) {
-		sum_bw_imc += bw_imc[runs];
+		sum_bw_ref += bw_ref[runs];
 		sum_bw_resc += bw_resc[runs];
 	}
 
-	avg_bw_imc = sum_bw_imc / NUM_OF_RUNS;
+	avg_bw_ref = sum_bw_ref / NUM_OF_RUNS;
 	avg_bw_resc = sum_bw_resc / NUM_OF_RUNS;
-	avg_diff = (float)labs(avg_bw_resc - avg_bw_imc) / avg_bw_imc;
+	avg_diff = (float)labs(avg_bw_resc - avg_bw_ref) / avg_bw_ref;
 	avg_diff_per = (int)(avg_diff * 100);
 
 	ret = avg_diff_per > MAX_DIFF_PERCENT;
@@ -38,7 +38,7 @@ show_bw_info(unsigned long *bw_imc, unsigned long *bw_resc, size_t span)
 	ksft_print_msg("avg_diff_per: %d%%\n", avg_diff_per);
 	if (span)
 		ksft_print_msg("Span (MB): %zu\n", span / MB);
-	ksft_print_msg("avg_bw_imc: %lu\n", avg_bw_imc);
+	ksft_print_msg("avg_bw_ref: %lu\n", avg_bw_ref);
 	ksft_print_msg("avg_bw_resc: %lu\n", avg_bw_resc);
 
 	return ret;
@@ -46,7 +46,7 @@ show_bw_info(unsigned long *bw_imc, unsigned long *bw_resc, size_t span)
 
 static int check_results(size_t span)
 {
-	unsigned long bw_imc[NUM_OF_RUNS], bw_resc[NUM_OF_RUNS];
+	unsigned long bw_ref[NUM_OF_RUNS], bw_resc[NUM_OF_RUNS];
 	char temp[1024], *token_array[8];
 	char output[] = RESULT_FILE_NAME;
 	int runs, ret;
@@ -72,11 +72,11 @@ static int check_results(size_t span)
 		}
 
 		bw_resc[runs] = strtoul(token_array[5], NULL, 0);
-		bw_imc[runs] = strtoul(token_array[3], NULL, 0);
+		bw_ref[runs] = strtoul(token_array[3], NULL, 0);
 		runs++;
 	}
 
-	ret = show_bw_info(bw_imc, bw_resc, span);
+	ret = show_bw_info(bw_ref, bw_resc, span);
 
 	fclose(fp);
 
@@ -87,7 +87,7 @@ static int mbm_init(const struct resctrl_val_param *param, int domain_id)
 {
 	int ret;
 
-	ret = initialize_read_mem_bw_imc();
+	ret = initialize_mem_bw_ref();
 	if (ret)
 		return ret;
 
tools/testing/selftests/resctrl/resctrl.h +2 -2
index afe635b6e48d..0de72327a085 100644
@@ -49,7 +49,7 @@
 
 /*
  * Memory bandwidth (in MiB) below which the bandwidth comparisons
- * between iMC and resctrl are considered unreliable. For example RAS
+ * between the reference PMU and resctrl are considered unreliable. For example RAS
  * features or memory performance features that generate memory traffic
  * may drive accesses that are counted differently by performance counters
  * and MBM respectively, for instance generating "overhead" traffic which
@@ -187,7 +187,7 @@ unsigned char *alloc_buffer(size_t buf_size, bool memflush);
 void mem_flush(unsigned char *buf, size_t buf_size);
 void fill_cache_read(unsigned char *buf, size_t buf_size, bool once);
 ssize_t get_fill_buf_size(int cpu_no, const char *cache_type);
-int initialize_read_mem_bw_imc(void);
+int initialize_mem_bw_ref(void);
 int measure_read_mem_bw(const struct user_params *uparams,
 			struct resctrl_val_param *param, pid_t bm_pid);
 void initialize_mem_bw_resctrl(const struct resctrl_val_param *param,
tools/testing/selftests/resctrl/resctrl_val.c +88 -90

360 lines not on this page · raw message

Signature · 1 line
2.43.0
#2 lore raw

PATCH 2/5 selftests/resctrl: Abstract reference bandwidth counters behind a backend

In reply to Richard Cheng

The reference bandwidth measurement is hard-wired to the Intel iMC:
discovery, event configuration and perf open all assume the iMC PMU sysfs layout. Other architectures expose equivalent uncore PMUs that could serve as the same kind of independent reference.

Introduce struct mem_bw_backend with two operations, detect() (is this backend's PMU present?) and setup_counters() (populate bw_counters[] for measuring the benchmark CPU), plus a backend table currently containing only the iMC. Shared code selects a backend at init time and no longer contains any PMU-specific knowledge.

Counter configuration moves from test init time to perf open time via setup_counters(), because a backend may need the benchmark CPU to pick per-socket PMU instances. Each counter now carries the CPU to open it on. The added per-measurement discovery cost is a handful of sysfs reads, negligible against the one second measurement window.

Add mem_bw_ref_available() so feature checks can verify that a reference PMU exists: the MBA test is now skipped instead of failing at init on machines without iMC counters (e.g. virtual machines). Add mem_bw_ref_cleanup() to reset the backend selection between tests.

---
 tools/testing/selftests/resctrl/mba_test.c    |   4 +-
 tools/testing/selftests/resctrl/mbm_test.c    |   1 +
 tools/testing/selftests/resctrl/resctrl.h     |   2 +
 tools/testing/selftests/resctrl/resctrl_val.c | 145 ++++++++++++++++--
 4 files changed, 141 insertions(+), 11 deletions(-)
tools/testing/selftests/resctrl/mba_test.c +3 -1
index 468ba8accc18..8b891d3e6650 100644
@@ -164,6 +164,7 @@ static int check_results(void)
 
 static void mba_test_cleanup(void)
 {
+	mem_bw_ref_cleanup();
 	remove(RESULT_FILE_NAME);
 }
 
@@ -210,7 +211,8 @@ static int mba_run_test(const struct resctrl_test *test, const struct user_param
 static bool mba_feature_check(const struct resctrl_test *test)
 {
 	return test_resource_feature_check(test) &&
-	       resctrl_mon_feature_exists("L3_MON", "mbm_local_bytes");
+	       resctrl_mon_feature_exists("L3_MON", "mbm_local_bytes") &&
+	       mem_bw_ref_available();
 }
 
 struct resctrl_test mba_test = {
tools/testing/selftests/resctrl/mbm_test.c +1 -0
index 001a87608835..873acf6aa648 100644
@@ -123,6 +123,7 @@ static int mbm_measure(const struct user_params *uparams,
 
 static void mbm_test_cleanup(void)
 {
+	mem_bw_ref_cleanup();
 	remove(RESULT_FILE_NAME);
 }
 
tools/testing/selftests/resctrl/resctrl.h +2 -0
index 0de72327a085..2bd19c22a344 100644
@@ -188,6 +188,8 @@ void mem_flush(unsigned char *buf, size_t buf_size);
 void fill_cache_read(unsigned char *buf, size_t buf_size, bool once);
 ssize_t get_fill_buf_size(int cpu_no, const char *cache_type);
 int initialize_mem_bw_ref(void);
+bool mem_bw_ref_available(void);
+void mem_bw_ref_cleanup(void);
 int measure_read_mem_bw(const struct user_params *uparams,
 			struct resctrl_val_param *param, pid_t bm_pid);
 void initialize_mem_bw_resctrl(const struct resctrl_val_param *param,
tools/testing/selftests/resctrl/resctrl_val.c +135 -10

201 lines not on this page · raw message

Signature · 1 line
2.43.0
#3 lore raw

PATCH 3/5 selftests/resctrl: Support the MPAM memory bandwidth monitoring layout

In reply to Richard Cheng

Arm MPAM systems running resctrl expose memory bandwidth differently from x86:

- MB control/monitor domains are keyed by NUMA node id, which need not match the L3 cache id (on a Grace/Vera system L3 ids are {1,2} while MB domains are {0,1,2,10,...}).
- Monitoring lives in a separate MB_MON resource that provides only mbm_total_bytes; there is no local/total split and no L3_MON bandwidth event.
- In "mbm_event" (ABMC) assignment mode a hardware counter must be explicitly assigned to a group+domain+event before the bandwidth file returns a value (it reads "Unassigned" otherwise), and removing a group does not release its counter, so it must be unassigned explicitly or it leaks.

Teach the test framework this layout:

- get_domain_id() resolves MB domains via the CPU's NUMA node when the MB_MON resource exists. x86 (no MB_MON) is unaffected.
- initialize_mem_bw_resctrl() falls back to mon_MB_<domain>/mbm_total_bytes when mbm_local_bytes is absent, and assigns an ABMC counter when the group's mbm_MB_assignments file is present. Note the assignment parser requires a trailing newline; without it the write fails with EINVAL.
- mem_bw_ref_cleanup() unassigns the counter again.
- The MBA feature check accepts MB_MON's mbm_total_bytes as the monitoring source.

Comparing a reference PMU total (read+write) with mbm_total_bytes is a like-for-like comparison; the iMC path keeps comparing read bandwidth with mbm_local_bytes as before.

No effect yet on any vendor: the MBA test is still gated to Intel.

---
 tools/testing/selftests/resctrl/mba_test.c    |  3 +-
 tools/testing/selftests/resctrl/resctrl_val.c | 69 +++++++++++++++++--
 tools/testing/selftests/resctrl/resctrlfs.c   | 45 +++++++++++-
 3 files changed, 111 insertions(+), 6 deletions(-)
tools/testing/selftests/resctrl/mba_test.c +2 -1
index 8b891d3e6650..6c85107c32ee 100644
@@ -211,7 +211,8 @@ static int mba_run_test(const struct resctrl_test *test, const struct user_param
 static bool mba_feature_check(const struct resctrl_test *test)
 {
 	return test_resource_feature_check(test) &&
-	       resctrl_mon_feature_exists("L3_MON", "mbm_local_bytes") &&
+	       (resctrl_mon_feature_exists("L3_MON", "mbm_local_bytes") ||
+		resctrl_mon_feature_exists("MB_MON", "mbm_total_bytes")) &&
 	       mem_bw_ref_available();
 }
 
tools/testing/selftests/resctrl/resctrl_val.c +65 -4

98 lines not on this page · raw message

tools/testing/selftests/resctrl/resctrlfs.c +44 -1

61 lines not on this page · raw message

Signature · 1 line
2.43.0
#4 lore raw

PATCH 4/5 selftests/resctrl: Gate the MBA test on features, not CPU vendor

In reply to Richard Cheng

The MBA test is skipped on every CPU that does not report "GenuineIntel", although everything the test needs is discoverable at
runtime: an MB resource with a bandwidth monitor in resctrl, and a reference PMU backend to validate against. The vendor gate also can never match on architectures whose /proc/cpuinfo has no vendor_id line at all, such as arm64.

Drop .vendor_specific from the MBA test and rely on the feature check. On systems where any required piece is missing - including architectures for which no reference bandwidth backend exists yet - the test reports SKIP exactly as it did under the vendor gate.

---
 tools/testing/selftests/resctrl/mba_test.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
tools/testing/selftests/resctrl/mba_test.c +6 -1
index 6c85107c32ee..22a887a1b4f8 100644
@@ -208,6 +208,12 @@ static int mba_run_test(const struct resctrl_test *test, const struct user_param
 	return ret;
 }
 
+/*
+ * The MBA test runs wherever resctrl exposes an MB resource, a memory-bandwidth
+ * monitor (x86 local bytes under L3_MON or MPAM total bytes under MB_MON), and
+ * an independent reference-bandwidth PMU exists to
+ * validate against. It is not gated on CPU vendor.
+ */
 static bool mba_feature_check(const struct resctrl_test *test)
 {
 	return test_resource_feature_check(test) &&
@@ -219,7 +225,6 @@ static bool mba_feature_check(const struct resctrl_test *test)
 struct resctrl_test mba_test = {
 	.name = "MBA",
 	.resource = "MB",
-	.vendor_specific = ARCH_INTEL,
 	.feature_check = mba_feature_check,
 	.run_test = mba_run_test,
 	.cleanup = mba_test_cleanup,
Signature · 1 line
2.43.0
#5 lore raw

PATCH 5/5 selftests/resctrl: Add NVIDIA SCF reference bandwidth backend

In reply to Richard Cheng

NVIDIA Grace/Vera systems expose the SoC coherency fabric (SCF) uncore PMU, which counts per-socket DRAM traffic and can serve as the independent reference for the MBA test, in the same role the iMC plays on x86. Together with the MPAM MB/MB_MON support this makes the MBA test runnable on arm64.

Implementation notes, all verified on a two-socket Vera system:

- The arm_cspmu driver registers these PMUs under the generic nvidia_uncore_pmu_<n> name, so instances are identified by the PMIIDR value in the sysfs "identifier" file (product id 0x2cf = SCF) rather than by device name. This also keeps working should a future kernel register the PMU under a dedicated name.
- The driver registers no named events on current silicon, and the documented byte counters (cmem_rd_data, gmem_*) read zero under load, so the backend programs raw events: 0xF1 (LLC refill, i.e. reads) and 0xF3 (LLC writeback, i.e. writes). Each event counts 64-byte cache lines, the same scale as iMC CAS counts, and refill+writeback matches the read+write semantics of MPAM's mbm_total_bytes.
- The SCF PMU is per-socket; the backend selects the instance(s) whose cpumask belongs to the benchmark CPU's package.
- The events are opened system-wide (pid == -1), where inherit must be 0 or perf_event_open() fails on this PMU.

Validated against the MPAM MB resource: SCF and mbm_total_bytes agree within 3-4% across all MBA schemata levels (10%..100%), against the 8% test threshold.

---
 tools/testing/selftests/resctrl/mba_test.c    |   2 +-
 tools/testing/selftests/resctrl/resctrl_val.c | 164 +++++++++++++++++-
 2 files changed, 162 insertions(+), 4 deletions(-)
tools/testing/selftests/resctrl/mba_test.c +1 -1
index 22a887a1b4f8..40352df5303c 100644
@@ -211,7 +211,7 @@ static int mba_run_test(const struct resctrl_test *test, const struct user_param
 /*
  * The MBA test runs wherever resctrl exposes an MB resource, a memory-bandwidth
  * monitor (x86 local bytes under L3_MON or MPAM total bytes under MB_MON), and
- * an independent reference-bandwidth PMU exists to
+ * an independent reference-bandwidth PMU (Intel iMC or NVIDIA SCF) exists to
  * validate against. It is not gated on CPU vendor.
  */
 static bool mba_feature_check(const struct resctrl_test *test)
tools/testing/selftests/resctrl/resctrl_val.c +161 -3

200 lines not on this page · raw message

Signature · 1 line
2.43.0