selftests/resctrl: Add resctrl selftest
Subsystems (2)
v9 cover selftests/resctrl: Add resctrl selftest
With more and more resctrl features are being added by Intel, AMD and ARM, a test tool is becoming more and more useful to validate that both hardware and software functionalities work as expected.
We introduce resctrl selftest to cover resctrl features on X86, AMD and ARM architectures. It first implements MBM (Memory Bandwidth Monitoring), MBA (Memory Bandwidth Allocation), L3 CAT (Cache Allocation Technology), and CQM (Cache QoS Monitoring) tests. We will enhance the selftest tool to include more functionality tests in the future.
The tool has been tested on Intel RDT, AMD QoS and ARM MPAM and is in tools/testing/selftests/resctrl in order to have generic test code base for all architectures.
The selftest tool we are introducing here provides a convenient tool which does automatic resctrl testing, is easily available in kernel tree, and covers Intel RDT, AMD QoS and ARM MPAM.
There is an existing resctrl test suite 'intel_cmt_cat'. But its major purpose is to test Intel RDT hardware via writing and reading MSR registers. It does access resctrl file system; but the functionalities are very limited. And it doesn't support automatic test and a lot of manual verifications are involved.
Changelog:
v9:
- Per Boris suggestion, add Co-developed-by in each patch to make it clear who contributed to the patch set.
v8:
Update code per comments from Andre Przywara from ARM:
- Change Makefile and remove inline assembly code to build and test the tool on ARM
- Change the output to TAP format because the format is both readable by human and other test tools.
- Detect resctrl feature from /proc/cpuinfo instead of dmesg to support generic detection on all architectures.
- Fix a few coding issues.
v7:
- Fix a few warnings when compiling patches separately, pointed by Babu
v6:
- Fix a benchmark reading optimized out issue in newer GCC.
- Fix a few coding style issues.
- Re-arrange code among patches to make cleaner code. No change in patches structure.
v5:
- Based the v4 patches submitted by Fenghua Yu and added changes to support AMD.
- Changed the function name get_sock_num to get_resource_id. Intel uses socket number for schemata and AMD uses l3 index id. To generalize, changed the function name to get_resource_id.
- Added the code to detect vendor.
- Disabled the few tests for AMD where the test results are not clear. Also AMD does not have IMC.
- Fixed few compile issues.
- Some cleanup to make each patch independent.
- Tested the patches on AMD system. Fenghua, Need your help to test on Intel box. Please feel free to change and resubmit if something broken.
v4:
- address comments from Balu and Randy
- Add CAT and CQM tests
v3:
- Change code based on comments from Babu Moger
- Remove some unnessary code and use pipe to communicate b/w processes
v2:
- Change code based on comments from Babu Moger
- Clean up other places.
Babu Moger (3):
selftests/resctrl: Add vendor detection mechanism selftests/resctrl: Use cache index3 id for AMD schemata masks selftests/resctrl: Disable MBA and MBM tests for AMD
Fenghua Yu (6):
selftests/resctrl: Add README for resctrl tests selftests/resctrl: Add MBM test
selftests/resctrl: Add MBA test
selftests/resctrl: Add Cache QoS Monitoring (CQM) selftest selftests/resctrl: Add Cache Allocation Technology (CAT) selftest selftests/resctrl: Add the test in MAINTAINERS
Sai Praneeth Prakhya (4):
selftests/resctrl: Add basic resctrl file system operations and data selftests/resctrl: Read memory bandwidth from perf IMC counter and
from resctrl file system
selftests/resctrl: Add callback to start a benchmark selftests/resctrl: Add built in benchmark
MAINTAINERS | 1 + tools/testing/selftests/resctrl/Makefile | 17 + tools/testing/selftests/resctrl/README | 53 ++ tools/testing/selftests/resctrl/cache.c | 272 +++++++ tools/testing/selftests/resctrl/cat_test.c | 250 ++++++ tools/testing/selftests/resctrl/cqm_test.c | 176 +++++ tools/testing/selftests/resctrl/fill_buf.c | 213 +++++ tools/testing/selftests/resctrl/mba_test.c | 171 ++++ tools/testing/selftests/resctrl/mbm_test.c | 145 ++++ tools/testing/selftests/resctrl/resctrl.h | 107 +++ .../testing/selftests/resctrl/resctrl_tests.c | 202 +++++ tools/testing/selftests/resctrl/resctrl_val.c | 744 ++++++++++++++++++ tools/testing/selftests/resctrl/resctrlfs.c | 722 +++++++++++++++++ 13 files changed, 3073 insertions(+) create mode 100644 tools/testing/selftests/resctrl/Makefile create mode 100644 tools/testing/selftests/resctrl/README create mode 100644 tools/testing/selftests/resctrl/cache.c create mode 100644 tools/testing/selftests/resctrl/cat_test.c create mode 100644 tools/testing/selftests/resctrl/cqm_test.c create mode 100644 tools/testing/selftests/resctrl/fill_buf.c create mode 100644 tools/testing/selftests/resctrl/mba_test.c create mode 100644 tools/testing/selftests/resctrl/mbm_test.c create mode 100644 tools/testing/selftests/resctrl/resctrl.h create mode 100644 tools/testing/selftests/resctrl/resctrl_tests.c create mode 100644 tools/testing/selftests/resctrl/resctrl_val.c create mode 100644 tools/testing/selftests/resctrl/resctrlfs.c
Signature · 1 line
2.19.1
PATCH v9 1/13 selftests/resctrl: Add README for resctrl tests
resctrl tests will be implemented. README is added for the tool first.
--- tools/testing/selftests/resctrl/README | 53 ++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 tools/testing/selftests/resctrl/README
tools/testing/selftests/resctrl/README new file +53 -0
@@ -0,0 +1,53 @@ +resctrl_tests - resctrl file system test suit + +Authors: + Fenghua Yu <[email protected]> + Sai Praneeth Prakhya <[email protected]>, + +resctrl_tests tests various resctrl functionalities and interfaces including +both software and hardware. + +Currently it supports Memory Bandwidth Monitoring test and Memory Bandwidth +Allocation test on Intel RDT hardware. More tests will be added in the future. +And the test suit can be extended to cover AMD QoS and ARM MPAM hardware +as well. + +BUILD +----- + +Run "make" to build executable file "resctrl_tests". + +RUN +--- + +To use resctrl_tests, root or sudoer privileges are required. This is because +the test needs to mount resctrl file system and change contents in the file +system. + +Executing the test without any parameter will run all supported tests: + + sudo ./resctrl_tests + +OVERVIEW OF EXECUTION +--------------------- + +A test case has four stages: + + - setup: mount resctrl file system, create group, setup schemata, move test + process pids to tasks, start benchmark. + - execute: let benchmark run + - verify: get resctrl data and verify the data with another source, e.g. + perf event. + - teardown: umount resctrl and clear temporary files. + +ARGUMENTS +--------- + +Parameter '-h' shows usage information. + +usage: resctrl_tests [-h] [-b "benchmark_cmd [options]"] [-t test list] [-n no_of_bits] + -b benchmark_cmd [options]: run specified benchmark for MBM, MBA and CQM default benchmark is builtin fill_buf + -t test list: run tests specified in the test list, e.g. -t mbm, mba, cqm, cat + -n no_of_bits: run cache tests using specified no of bits in cache bit mask + -p cpu_no: specify CPU number to run the test. 1 is default + -h: help
Signature · 1 line
2.19.1
PATCH v9 2/13 selftests/resctrl: Add basic resctrl file system operations and data
In reply to Fenghua YuFrom: Sai Praneeth Prakhya <[email protected]>
The basic resctrl file system operations and data are added for future usage by resctrl selftest tool.
--- tools/testing/selftests/resctrl/Makefile | 12 + tools/testing/selftests/resctrl/resctrl.h | 50 +++ tools/testing/selftests/resctrl/resctrlfs.c | 462 ++++++++++++++++++++ 3 files changed, 524 insertions(+) create mode 100644 tools/testing/selftests/resctrl/Makefile create mode 100644 tools/testing/selftests/resctrl/resctrl.h create mode 100644 tools/testing/selftests/resctrl/resctrlfs.c
tools/testing/selftests/resctrl/Makefile new file +12 -0
@@ -0,0 +1,12 @@ +CC = $(CROSS_COMPILE)gcc +CFLAGS = -g -Wall +SRCS=$(wildcard *.c) +OBJS=$(SRCS:.c=.o) + +$(OBJS): $(SRCS) + $(CC) $(CFLAGS) -c $(SRCS) + +.PHONY: clean + +clean: + $(RM) $(OBJS)
tools/testing/selftests/resctrl/resctrl.h new file +50 -0
50 lines not on this page · raw message
tools/testing/selftests/resctrl/resctrlfs.c new file +462 -0
462 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH v9 3/13 selftests/resctrl: Read memory bandwidth from perf IMC counter and from resctrl file system
In reply to Fenghua YuFrom: Sai Praneeth Prakhya <[email protected]>
Total memory bandwidth can be monitored from perf IMC counter and from resctrl file system. Later the two will be compared to verify the total memory bandwidth read from resctrl is correct.
--- tools/testing/selftests/resctrl/resctrl_val.c | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 tools/testing/selftests/resctrl/resctrl_val.c
tools/testing/selftests/resctrl/resctrl_val.c new file +117 -0
@@ -0,0 +1,117 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Memory bandwidth monitoring and allocation library +* +* Copyright (C) 2018 Intel Corporation +* +* Authors: +* Sai Praneeth Prakhya <[email protected]>, +* Fenghua Yu <[email protected]> +*/ +#include "resctrl.h" + +#define UNCORE_IMC "uncore_imc" +#define READ_FILE_NAME "events/cas_count_read" +#define WRITE_FILE_NAME "events/cas_count_write" +#define DYN_PMU_PATH "/sys/bus/event_source/devices" +#define SCALE 0.00006103515625 +#define MAX_IMCS 20 +#define MAX_TOKENS 5 +#define READ 0 +#define WRITE 1 +#define CON_MON_MBM_LOCAL_BYTES_PATH \ + "%s/%s/mon_groups/%s/mon_data/mon_L3_%02d/mbm_local_bytes" + +#define CON_MBM_LOCAL_BYTES_PATH \ + "%s/%s/mon_data/mon_L3_%02d/mbm_local_bytes" + +#define MON_MBM_LOCAL_BYTES_PATH \ + "%s/mon_groups/%s/mon_data/mon_L3_%02d/mbm_local_bytes" + +#define MBM_LOCAL_BYTES_PATH \ + "%s/mon_data/mon_L3_%02d/mbm_local_bytes" + +struct membw_read_format { +__u64 value;/* The value of the event */ +__u64 time_enabled;/* if PERF_FORMAT_TOTAL_TIME_ENABLED */ +__u64 time_running;/* if PERF_FORMAT_TOTAL_TIME_RUNNING */ +__u64 id;/* if PERF_FORMAT_ID */ +}; + +struct imc_counter_config { +__u32 type; +__u64 event; +__u64 umask; +struct perf_event_attr pe; +struct membw_read_format return_value; +int fd; +}; + +static struct imc_counter_config imc_counters_config[MAX_IMCS ][2 ]; + +void membw_initialize_perf_event_attr (int i,int j) +{ +memset (&imc_counters_config[i][j].pe,0 , +sizeof (struct perf_event_attr )); + imc_counters_config[i][j].pe.type = imc_counters_config[i][j].type; + imc_counters_config[i][j].pe.size =sizeof (struct perf_event_attr ); + imc_counters_config[i][j].pe.disabled =1 ; + imc_counters_config[i][j].pe.inherit =1 ; + imc_counters_config[i][j].pe.exclude_guest =0 ; + imc_counters_config[i][j].pe.config = + imc_counters_config[i][j].umask <<8 | + imc_counters_config[i][j].event; + imc_counters_config[i][j].pe.sample_type =PERF_SAMPLE_IDENTIFIER ; + imc_counters_config[i][j].pe.read_format = +PERF_FORMAT_TOTAL_TIME_ENABLED |PERF_FORMAT_TOTAL_TIME_RUNNING ; +} + +void membw_ioctl_perf_event_ioc_reset_enable (int i,int j) +{ +ioctl (imc_counters_config[i][j].fd,PERF_EVENT_IOC_RESET ,0 ); +ioctl (imc_counters_config[i][j].fd,PERF_EVENT_IOC_ENABLE ,0 ); +} + +void membw_ioctl_perf_event_ioc_disable (int i,int j) +{ +ioctl (imc_counters_config[i][j].fd,PERF_EVENT_IOC_DISABLE ,0 ); +} + +/* +* get_event_and_umask: Parse config into event and umask +* @cas_count_cfg: Config +* @count: iMC number +* @op: Operation (read/write) +*/ +void get_event_and_umask (char *cas_count_cfg,int count,bool op) +{ +char *token[MAX_TOKENS ]; +int i =0 ; + +strcat (cas_count_cfg,"," ); + token[0 ] =strtok (cas_count_cfg,"=," ); + +for (i =1 ; i <MAX_TOKENS ; i++) + token[i] =strtok (NULL ,"=," ); + +for (i =0 ; i <MAX_TOKENS ; i++) { +if (!token[i]) +break ; +if (strcmp (token[i],"event" ) ==0 ) { +if (op ==READ ) + imc_counters_config[count][READ ].event = +strtol (token[i +1 ],NULL ,16 ); +else + imc_counters_config[count][WRITE ].event = +strtol (token[i +1 ],NULL ,16 ); + } +if (strcmp (token[i],"umask" ) ==0 ) { +if (op ==READ ) + imc_counters_config[count][READ ].umask = +strtol (token[i +1 ],NULL ,16 ); +else + imc_counters_config[count][WRITE ].umask = +strtol (token[i +1 ],NULL ,16 ); + } + } +}
Signature · 1 line
2.19.1
PATCH v9 4/13 selftests/resctrl: Add callback to start a benchmark
In reply to Fenghua YuFrom: Sai Praneeth Prakhya <[email protected]>
The callback starts a child process and puts the child pid in created resctrl group with specified memory bandwidth in schemata. The child starts running benchmark.
--- tools/testing/selftests/resctrl/resctrl.h | 29 + tools/testing/selftests/resctrl/resctrl_val.c | 574 ++++++++++++++++++ 2 files changed, 603 insertions(+)
tools/testing/selftests/resctrl/resctrl.h +29 -0
@@ -3,6 +3,8 @@#ifndef RESCTRL_H #define RESCTRL_H #include <stdio.h> +#include <stdarg.h> +#include <math.h> #include <errno.h> #include <sched.h> #include <stdlib.h>
@@ -19,6 +21,7 @@#include <asm/unistd.h> #include <linux/perf_event.h> +#define MB (1024 * 1024)#define RESCTRL_PATH "/sys/fs/resctrl"#define PHYS_ID_PATH "/sys/devices/system/cpu/cpu"
@@ -29,10 +32,35 @@exit (EXIT_FAILURE ); \ }while (0 ) +/* +* resctrl_val_param: resctrl test parameters +* @resctrl_val: Resctrl feature (Eg: mbm, mba.. etc) +* @ctrlgrp: Name of the control monitor group (con_mon grp) +* @mongrp: Name of the monitor group (mon grp) +* @cpu_no: CPU number to which the benchmark would be binded +* @span: Memory bytes accessed in each benchmark iteration +* @mum_resctrlfs: Should the resctrl FS be remounted? +* @filename: Name of file to which the o/p should be written +* @bw_report: Bandwidth report type (reads vs writes) +* @setup: Call back function to setup test environment +*/ +struct resctrl_val_param { +char *resctrl_val; +char ctrlgrp[64 ]; +char mongrp[64 ]; +int cpu_no; +unsigned long span; +int mum_resctrlfs; +char filename[64 ]; +char *bw_report; +int (*setup)(int num, ...); +}; +pid_t bm_pid, ppid;int remount_resctrlfs (bool mum_resctrlfs);int get_resource_id (int cpu_no,int *resource_id); +int umount_resctrlfs (void );int validate_bw_report_request (char *bw_report);bool validate_resctrl_feature_request (char *resctrl_val);char *fgrep (FILE *inf,const char *str);
@@ -46,5 +74,6 @@ int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu, int group_fd, unsigned long flags);int run_fill_buf (unsigned long span,int malloc_and_init_memory,int memflush,int op,char *resctrl_va); +int resctrl_val (char **benchmark_cmd,struct resctrl_val_param *param);#endif /* RESCTRL_H */
tools/testing/selftests/resctrl/resctrl_val.c +574 -0
583 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH v9 5/13 selftests/resctrl: Add built in benchmark
In reply to Fenghua YuFrom: Sai Praneeth Prakhya <[email protected]>
Built-in benchmark fill_buf generates stressful memory bandwidth and cache traffic.
Later it will be used as a default benchmark by various resctrl tests such as MBA (Memory Bandwidth Allocation) and MBM (Memory Bandwidth Monitoring) tests.
--- tools/testing/selftests/resctrl/fill_buf.c | 207 +++++++++++++++++++++ 1 file changed, 207 insertions(+) create mode 100644 tools/testing/selftests/resctrl/fill_buf.c
tools/testing/selftests/resctrl/fill_buf.c new file +207 -0
@@ -0,0 +1,207 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* fill_buf benchmark +* +* Copyright (C) 2018 Intel Corporation +* +* Authors: +* Sai Praneeth Prakhya <[email protected]>, +* Fenghua Yu <[email protected]> +*/ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <inttypes.h> +#include <malloc.h> +#include <string.h> + +#include "resctrl.h" + +#define CL_SIZE (64) +#define PAGE_SIZE (4 * 1024) +#define MB (1024 * 1024) + +static unsigned char *startptr; + +static void sb (void ) +{ +#if defined(__i386) || defined(__x86_64) + asmvolatile ("sfence\n\t" + : : :"memory" ); +#endif +} + +static void ctrl_handler (int signo) +{ +free (startptr); +printf ("\nEnding\n" ); +sb (); +exit (EXIT_SUCCESS ); +} + +static void cl_flush (void *p) +{ +#if defined(__i386) || defined(__x86_64) + asmvolatile ("clflush (%0)\n\t" + : :"r" (p) :"memory" ); +#endif +} + +static void mem_flush (void *p,size_t s) +{ +char *cp = (char *)p; +size_t i =0 ; + + s = s /CL_SIZE ;/* mem size in cache llines */ + +for (i =0 ; i < s; i++) +cl_flush (&cp[i *CL_SIZE ]); + +sb (); +} + +static void *malloc_and_init_memory (size_t s) +{ +uint64_t *p64; +size_t s64; + +void *p =memalign (PAGE_SIZE , s); + + p64 = (uint64_t *)p; + s64 = s /sizeof (uint64_t ); + +while (s64 >0 ) { + *p64 = (uint64_t )rand (); + p64 += (CL_SIZE /sizeof (uint64_t )); + s64 -= (CL_SIZE /sizeof (uint64_t )); + } + +return p; +} + +static int fill_one_span_read (unsigned char *start_ptr,unsigned char *end_ptr) +{ +unsigned char sum, *p; + + sum =0 ; + p = start_ptr; +while (p < end_ptr) { + sum += *p; + p += (CL_SIZE /2 ); + } + +return sum; +} + +static +void fill_one_span_write (unsigned char *start_ptr,unsigned char *end_ptr) +{ +unsigned char *p; + + p = start_ptr; +while (p < end_ptr) { + *p ='1' ; + p += (CL_SIZE /2 ); + } +} + +static int fill_cache_read (unsigned char *start_ptr,unsigned char *end_ptr, +char *resctrl_val) +{ +int ret =0 ; +FILE *fp; + +while (1 ) + ret =fill_one_span_read (start_ptr, end_ptr); + +/* Consume read result so that reading memory is not optimized out. */ + fp =fopen ("/dev/null" ,"w" ); +if (!fp) +perror ("Unable to write to /dev/null" ); +fprintf (fp,"Sum: %d " , ret); +fclose (fp); + +return 0 ; +} + +static int fill_cache_write (unsigned char *start_ptr,unsigned char *end_ptr, +char *resctrl_val) +{ +while (1 ) +fill_one_span_write (start_ptr, end_ptr); + +return 0 ; +} + +static int +fill_cache (unsigned long long buf_size,int malloc_and_init,int memflush, +int op,char *resctrl_val) +{ +unsigned char *start_ptr, *end_ptr; +unsigned long long i; +int ret; + +if (malloc_and_init) + start_ptr =malloc_and_init_memory (buf_size); +else + start_ptr =malloc (buf_size); + +if (!start_ptr) +return -1 ; + + startptr = start_ptr; + end_ptr = start_ptr + buf_size; + +/* +* It's better to touch the memory once to avoid any compiler +* optimizations +*/ +if (!malloc_and_init) { +for (i =0 ; i < buf_size; i++) + *start_ptr++ = (unsigned char )rand (); + } + + start_ptr = startptr; + +/* Flush the memory before using to avoid "cache hot pages" effect */ +if (memflush) +mem_flush (start_ptr, buf_size); + +if (op ==0 ) + ret =fill_cache_read (start_ptr, end_ptr, resctrl_val); +else + ret =fill_cache_write (start_ptr, end_ptr, resctrl_val); + +if (ret) { +printf ("\n Errror in fill cache read/write...\n" ); +return -1 ; + } + +free (startptr); + +return 0 ; +} + +int run_fill_buf (unsigned long span,int malloc_and_init_memory, +int memflush,int op,char *resctrl_val) +{ +unsigned long long cache_size = span; +int ret; + +/* set up ctrl-c handler */ +if (signal (SIGINT , ctrl_handler) ==SIG_ERR ) +printf ("Failed to catch SIGINT!\n" ); +if (signal (SIGHUP , ctrl_handler) ==SIG_ERR ) +printf ("Failed to catch SIGHUP!\n" ); + + ret =fill_cache (cache_size, malloc_and_init_memory, memflush, op, + resctrl_val); +if (ret) { +printf ("\n Errror in fill cache\n" ); +return -1 ; + } + +return 0 ; +}
Signature · 1 line
2.19.1
PATCH v9 6/13 selftests/resctrl: Add MBM test
In reply to Fenghua YuMBM (Memory Bandwidth Monitoring) test is the first implemented selftest. It starts a stressful memory bandwidth benchmark and assigns the bandwidth pid in a resctrl monitoring group. Read and compare perf IMC counter and MBM total bytes for the benchmark. The numbers should be close enough to pass the test.
Default benchmark is built-in fill_buf. But users can specify their own benchmark by option "-b".
We can add memory bandwidth monitoring for multiple processes in the future.
--- tools/testing/selftests/resctrl/Makefile | 7 +- tools/testing/selftests/resctrl/mbm_test.c | 145 ++++++++++++++++++ tools/testing/selftests/resctrl/resctrl.h | 6 + .../testing/selftests/resctrl/resctrl_tests.c | 132 ++++++++++++++++ tools/testing/selftests/resctrl/resctrl_val.c | 2 + tools/testing/selftests/resctrl/resctrlfs.c | 77 ++++++++++ 6 files changed, 368 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/resctrl/mbm_test.c create mode 100644 tools/testing/selftests/resctrl/resctrl_tests.c
tools/testing/selftests/resctrl/Makefile +6 -1
@@ -3,10 +3,15 @@ CFLAGS = -g -Wall SRCS=$(wildcard *.c) OBJS=$(SRCS:.c=.o) +all: resctrl_tests + $(OBJS): $(SRCS) $(CC) $(CFLAGS) -c $(SRCS) +resctrl_tests: $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ + .PHONY: clean clean: - $(RM) $(OBJS) + $(RM) $(OBJS) resctrl_tests
tools/testing/selftests/resctrl/mbm_test.c new file +145 -0
145 lines not on this page · raw message
tools/testing/selftests/resctrl/resctrl.h +6 -0
@@ -57,7 +57,10 @@ struct resctrl_val_param { };pid_t bm_pid, ppid; +int tests_run; +bool check_resctrlfs_support (void ); +int filter_dmesg (void );int remount_resctrlfs (bool mum_resctrlfs);int get_resource_id (int cpu_no,int *resource_id);int umount_resctrlfs (void );
@@ -75,5 +78,8 @@ int perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu,int run_fill_buf (unsigned long span,int malloc_and_init_memory,int memflush,int op,char *resctrl_va);int resctrl_val (char **benchmark_cmd,struct resctrl_val_param *param); +int mbm_bw_change (int span,int cpu_no,char *bw_report,char **benchmark_cmd); +void tests_cleanup (void ); +void mbm_test_cleanup (void );#endif /* RESCTRL_H */
tools/testing/selftests/resctrl/resctrl_tests.c new file +132 -0
132 lines not on this page · raw message
tools/testing/selftests/resctrl/resctrl_val.c +2 -0
@@ -435,6 +435,8 @@ pid_t bm_pid, ppid;static void ctrlc_handler (int signum,siginfo_t *info,void *ptr) {kill (bm_pid,SIGKILL ); +umount_resctrlfs (); +tests_cleanup ();printf ("Ending\n\n" );exit (EXIT_SUCCESS );
tools/testing/selftests/resctrl/resctrlfs.c +77 -0
89 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH v9 7/13 selftests/resctrl: Add MBA test
In reply to Fenghua YuMBA (Memory Bandwidth Allocation) test starts a stressful memory bandwidth benchmark and allocates memory bandwidth from 100% down to 10% for the benchmark process. For each allocation, compare perf IMC counter and mbm total bytes from resctrl. The difference between the two values should be within a threshold to pass the test.
Default benchmark is built-in fill_buf. But users can specify their own benchmark by option "-b".
We can add memory bandwidth allocation for multiple processes in the future.
--- tools/testing/selftests/resctrl/mba_test.c | 171 ++++++++++++++++++ tools/testing/selftests/resctrl/resctrl.h | 2 + .../testing/selftests/resctrl/resctrl_tests.c | 16 +- 3 files changed, 188 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/resctrl/mba_test.c
tools/testing/selftests/resctrl/mba_test.c new file +171 -0
@@ -0,0 +1,171 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Memory Bandwidth Allocation (MBA) test +* +* Copyright (C) 2018 Intel Corporation +* +* Authors: +* Sai Praneeth Prakhya <[email protected]>, +* Fenghua Yu <[email protected]> +*/ +#include "resctrl.h" + +#define RESULT_FILE_NAME "result_mba" +#define NUM_OF_RUNS 5 +#define MAX_DIFF 300 +#define ALLOCATION_MAX 100 +#define ALLOCATION_MIN 10 +#define ALLOCATION_STEP 10 + +/* +* Change schemata percentage from 100 to 10%. Write schemata to specified +* con_mon grp, mon_grp in resctrl FS. +* For each allocation, run 5 times in order to get average values. +*/ +static int mba_setup (int num, ...) +{ +static int runs_per_allocation, allocation =100 ; +struct resctrl_val_param *p; +char allocation_str[64 ]; +va_list param; + +va_start (param, num); + p = va_arg(param, struct resctrl_val_param *); +va_end (param); + +if (runs_per_allocation >=NUM_OF_RUNS ) + runs_per_allocation =0 ; + +/* Only set up schemata once every NUM_OF_RUNS of allocations */ +if (runs_per_allocation++ !=0 ) +return 0 ; + +if (allocation <ALLOCATION_MIN || allocation >ALLOCATION_MAX ) +return -1 ; + +sprintf (allocation_str,"%d" , allocation); + +write_schemata (p->ctrlgrp, allocation_str, p->cpu_no, p->resctrl_val); + allocation -=ALLOCATION_STEP ; + +return 0 ; +} + +static void show_mba_info (unsigned long *bw_imc,unsigned long *bw_resc) +{ +int allocation, runs; +bool failed = false; + +printf ("# Results are displayed in (MB)\n" ); +/* Memory bandwidth from 100% down to 10% */ +for (allocation =0 ; allocation <ALLOCATION_MAX /ALLOCATION_STEP ; + allocation++) { +unsigned long avg_bw_imc, avg_bw_resc; +unsigned long sum_bw_imc =0 , sum_bw_resc =0 ; +unsigned long avg_diff; + +/* +* The first run is discarded due to inaccurate value from +* phase transition. +*/ +for (runs =NUM_OF_RUNS * allocation +1 ; + runs <NUM_OF_RUNS * allocation +NUM_OF_RUNS ; runs++) { + sum_bw_imc += bw_imc[runs]; + sum_bw_resc += bw_resc[runs]; + } + + avg_bw_imc = sum_bw_imc / (NUM_OF_RUNS -1 ); + avg_bw_resc = sum_bw_resc / (NUM_OF_RUNS -1 ); + avg_diff =labs ((long )(avg_bw_resc - avg_bw_imc)); + +printf ("%sok MBA schemata percentage %u smaller than %d %%\n" , + avg_diff >MAX_DIFF ?"not " :"" , +ALLOCATION_MAX -ALLOCATION_STEP * allocation, +MAX_DIFF ); + tests_run++; +printf ("# avg_diff: %lu\n" , avg_diff); +printf ("# avg_bw_imc: %lu\n" , avg_bw_imc); +printf ("# avg_bw_resc: %lu\n" , avg_bw_resc); +if (avg_diff >MAX_DIFF ) + failed = true; + } + +printf ("%sok schemata change using MBA%s\n" , failed ?"not " :"" , + failed ?" # at least one test failed" :"" ); + tests_run++; +} + +static int check_results (void ) +{ +char *token_array[8 ], output[] =RESULT_FILE_NAME , temp[512 ]; +unsigned long bw_imc[1024 ], bw_resc[1024 ]; +int runs; +FILE *fp; + + fp =fopen (output,"r" ); +if (!fp) { +perror (output); + +return errno; + } + + runs =0 ; +while (fgets (temp,sizeof (temp), fp)) { +char *token =strtok (temp,":\t" ); +int fields =0 ; + +while (token) { + token_array[fields++] = token; + token =strtok (NULL ,":\t" ); + } + +/* Field 3 is perf imc value */ + bw_imc[runs] =strtoul (token_array[3 ],NULL ,0 ); +/* Field 5 is resctrl value */ + bw_resc[runs] =strtoul (token_array[5 ],NULL ,0 ); + runs++; + } + +fclose (fp); + +show_mba_info (bw_imc, bw_resc); + +return 0 ; +} + +void mba_test_cleanup (void ) +{ +remove (RESULT_FILE_NAME ); +} + +int mba_schemata_change (int cpu_no,char *bw_report,char **benchmark_cmd) +{ +struct resctrl_val_param param = { + .resctrl_val ="mba" , + .ctrlgrp ="c1" , + .mongrp ="m1" , + .cpu_no = cpu_no, + .mum_resctrlfs =1 , + .filename =RESULT_FILE_NAME , + .bw_report = bw_report, + .setup = mba_setup + }; +int ret; + +remove (RESULT_FILE_NAME ); + +if (!validate_resctrl_feature_request ("mba" )) +return -1 ; + + ret =resctrl_val (benchmark_cmd, ¶m); +if (ret) +return ret; + + ret =check_results (); +if (ret) +return ret; + +mba_test_cleanup (); + +return 0 ; +}
tools/testing/selftests/resctrl/resctrl.h +2 -0
@@ -81,5 +81,7 @@ int resctrl_val(char **benchmark_cmd, struct resctrl_val_param *param);int mbm_bw_change (int span,int cpu_no,char *bw_report,char **benchmark_cmd);void tests_cleanup (void );void mbm_test_cleanup (void ); +int mba_schemata_change (int cpu_no,char *bw_report,char **benchmark_cmd); +void mba_test_cleanup (void );#endif /* RESCTRL_H */
tools/testing/selftests/resctrl/resctrl_tests.c +15 -1
@@ -26,6 +26,7 @@ static void cmd_help(void)void tests_cleanup (void ) {mbm_test_cleanup (); +mba_test_cleanup (); }int main (int argc,char **argv)
@@ -33,7 +34,7 @@ int main(int argc, char **argv)int res, c, cpu_no =1 , span =250 , argc_new = argc, i, ben_ind;char *benchmark_cmd[BENCHMARK_ARGS ], bw_report[64 ], bm_type[64 ];char benchmark_cmd_area[BENCHMARK_ARGS ][BENCHMARK_ARG_SIZE ]; -bool has_ben = false, mbm_test = true; +bool has_ben = false, mbm_test = true, mba_test = true;int ben_count;for (i =0 ; i < argc; i++) {
@@ -54,9 +55,12 @@ int main(int argc, char **argv) token =strtok (optarg,"," ); mbm_test = false; + mba_test = false;while (token) {if (!strcmp (token,"mbm" )) { mbm_test = true; + }else if (!strcmp (token,"mba" )) { + mba_test = true; }else {printf ("invalid argument\n" );
@@ -126,6 +130,16 @@ int main(int argc, char **argv) tests_run++; } +if (mba_test) { +printf ("# Starting MBA Schemata change ...\n" ); +if (!has_ben) +sprintf (benchmark_cmd[1 ],"%d" , span); + res =mba_schemata_change (cpu_no, bw_report, benchmark_cmd); +printf ("%sok MBA: schemata change\n" , res ?"not " :"" ); +mba_test_cleanup (); + tests_run++; + } +printf ("1..%d\n" , tests_run);return 0 ;
Signature · 1 line
2.19.1
PATCH v9 8/13 selftests/resctrl: Add Cache QoS Monitoring (CQM) selftest
In reply to Fenghua YuCache QoS Monitoring (CQM) selftest starts stressful cache benchmark with specified size of memory to access the cache. Last Level cache occupancy reported by CQM should be close to the size of the memory.
--- tools/testing/selftests/resctrl/cache.c | 99 +++++++++ tools/testing/selftests/resctrl/cqm_test.c | 176 ++++++++++++++++ tools/testing/selftests/resctrl/resctrl.h | 16 ++ .../testing/selftests/resctrl/resctrl_tests.c | 31 ++- tools/testing/selftests/resctrl/resctrl_val.c | 63 +++++- tools/testing/selftests/resctrl/resctrlfs.c | 193 +++++++++++++++++- 6 files changed, 558 insertions(+), 20 deletions(-) create mode 100644 tools/testing/selftests/resctrl/cache.c create mode 100644 tools/testing/selftests/resctrl/cqm_test.c
tools/testing/selftests/resctrl/cache.c new file +99 -0
@@ -0,0 +1,99 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <stdint.h> +#include "resctrl.h" + +struct read_format { +__u64 nr;/* The number of events */ +struct { +__u64 value;/* The value of the event */ + } values[2 ]; +}; + +char llc_occup_path[1024 ]; + +/* +* Get LLC Occupancy as reported by RESCTRL FS +* For CQM, +* 1. If con_mon grp and mon grp given, then read from mon grp in +* con_mon grp +* 2. If only con_mon grp given, then read from con_mon grp +* 3. If both not given, then read from root con_mon grp +* For CAT, +* 1. If con_mon grp given, then read from it +* 2. If con_mon grp not given, then read from root con_mon grp +* +* Return: =0 on success. <0 on failure. +*/ +static int get_llc_occu_resctrl (unsigned long *llc_occupancy) +{ +FILE *fp; + + fp =fopen (llc_occup_path,"r" ); +if (!fp) { +perror ("Failed to open results file" ); + +return errno; + } +if (fscanf (fp,"%lu" , llc_occupancy) <=0 ) { +perror ("Could not get llc occupancy" ); +fclose (fp); + +return -1 ; + } +fclose (fp); + +return 0 ; +} + +/* +* print_results_cache: the cache results are stored in a file +* @filename: file that stores the results +* @bm_pid: child pid that runs benchmark +* @llc_value: perf miss value / +* llc occupancy value reported by resctrl FS +* +* Return: 0 on success. non-zero on failure. +*/ +static int print_results_cache (char *filename,int bm_pid, +unsigned long llc_value) +{ +FILE *fp; + +if (strcmp (filename,"stdio" ) ==0 ||strcmp (filename,"stderr" ) ==0 ) { +printf ("Pid: %d \t LLC_value: %lu\n" , bm_pid, + llc_value); + }else { + fp =fopen (filename,"a" ); +if (!fp) { +perror ("Cannot open results file" ); + +return errno; + } +fprintf (fp,"Pid: %d \t llc_value: %lu\n" , bm_pid, llc_value); +fclose (fp); + } + +return 0 ; +} + +int measure_cache_vals (struct resctrl_val_param *param,int bm_pid) +{ +unsigned long llc_occu_resc =0 , llc_value =0 ; +int ret; + +/* +* Measure llc occupancy from resctrl. +*/ +if (!strcmp (param->resctrl_val,"cqm" )) { + ret =get_llc_occu_resctrl (&llc_occu_resc); +if (ret <0 ) +return ret; + llc_value = llc_occu_resc; + } + ret =print_results_cache (param->filename, bm_pid, llc_value); +if (ret) +return ret; + +return 0 ; +}
tools/testing/selftests/resctrl/cqm_test.c new file +176 -0
176 lines not on this page · raw message
tools/testing/selftests/resctrl/resctrl.h +16 -0
@@ -18,12 +18,16 @@#include <sys/mount.h> #include <sys/types.h> #include <sys/wait.h> +#include <sys/select.h> +#include <sys/time.h> +#include <sys/eventfd.h> #include <asm/unistd.h> #include <linux/perf_event.h> #define MB (1024 * 1024)#define RESCTRL_PATH "/sys/fs/resctrl"#define PHYS_ID_PATH "/sys/devices/system/cpu/cpu" +#define CBM_MASK_PATH "/sys/fs/resctrl/info"#define PARENT_EXIT (err_msg) \ do { \
@@ -53,12 +57,16 @@ struct resctrl_val_param {int mum_resctrlfs;char filename[64 ];char *bw_report; +unsigned long mask; +int num_of_runs;int (*setup)(int num, ...); };pid_t bm_pid, ppid;int tests_run; +char llc_occup_path[1024 ]; +bool check_resctrlfs_support (void );int filter_dmesg (void );int remount_resctrlfs (bool mum_resctrlfs);
@@ -83,5 +91,13 @@ void tests_cleanup(void);void mbm_test_cleanup (void );int mba_schemata_change (int cpu_no,char *bw_report,char **benchmark_cmd);void mba_test_cleanup (void ); +int get_cbm_mask (char *cache_type); +int get_cache_size (int cpu_no,char *cache_type,unsigned long *cache_size); +void ctrlc_handler (int signum,siginfo_t *info,void *ptr); +int cqm_resctrl_val (int cpu_no,int n,char **benchmark_cmd); +unsigned int count_bits (unsigned long n); +void cqm_test_cleanup (void ); +int get_core_sibling (int cpu_no); +int measure_cache_vals (struct resctrl_val_param *param,int bm_pid);#endif /* RESCTRL_H */
tools/testing/selftests/resctrl/resctrl_tests.c +25 -6
@@ -15,11 +15,13 @@static void cmd_help (void ) { -printf ("usage: resctrl_tests [-h] [-b \"benchmark_cmd [options]\"] [-t test list]\n" ); -printf ("\t-b benchmark_cmd [options]: run specified benchmark\n" ); +printf ("usage: resctrl_tests [-h] [-b \"benchmark_cmd [options]\"] [-t test list] [-n no_of_bits]\n" ); +printf ("\t-b benchmark_cmd [options]: run specified benchmark for MBM, MBA and CQM" );printf ("\t default benchmark is builtin fill_buf\n" );printf ("\t-t test list: run tests specified in the test list, " ); -printf ("e.g. -t mbm,mba\n" ); +printf ("e.g. -t mbm, mba, cqm\n" ); +printf ("\t-n no_of_bits: run cache tests using specified no of bits in cache bit mask\n" ); +printf ("\t-p cpu_no: specify CPU number to run the test. 1 is default\n" );printf ("\t-h: help\n" ); }
@@ -27,15 +29,16 @@ void tests_cleanup(void) {mbm_test_cleanup ();mba_test_cleanup (); +cqm_test_cleanup (); }int main (int argc,char **argv) { -int res, c, cpu_no =1 , span =250 , argc_new = argc, i, ben_ind; +bool has_ben = false, mbm_test = true, mba_test = true, cqm_test = true; +int res, c, cpu_no =1 , span =250 , argc_new = argc, i, no_of_bits =5 ;char *benchmark_cmd[BENCHMARK_ARGS ], bw_report[64 ], bm_type[64 ];char benchmark_cmd_area[BENCHMARK_ARGS ][BENCHMARK_ARG_SIZE ]; -bool has_ben = false, mbm_test = true, mba_test = true; -int ben_count; +int ben_ind, ben_count;for (i =0 ; i < argc; i++) {if (strcmp (argv[i],"-b" ) ==0 ) {
@@ -56,11 +59,14 @@ int main(int argc, char **argv) mbm_test = false; mba_test = false; + cqm_test = false;while (token) {if (!strcmp (token,"mbm" )) { mbm_test = true; }else if (!strcmp (token,"mba" )) { mba_test = true; + }else if (!strcmp (token,"cqm" )) { + cqm_test = true; }else {printf ("invalid argument\n" );
@@ -72,6 +78,9 @@ int main(int argc, char **argv)case 'p' : cpu_no =atoi (optarg);break ; +case 'n' : + no_of_bits =atoi (optarg); +break ;case 'h' :cmd_help ();
@@ -140,6 +149,16 @@ int main(int argc, char **argv) tests_run++; } +if (cqm_test) { +printf ("# Starting CQM test ...\n" ); +if (!has_ben) +sprintf (benchmark_cmd[5 ],"%s" ,"cqm" ); + res =cqm_resctrl_val (cpu_no, no_of_bits, benchmark_cmd); +printf ("%sok CQM: test\n" , res ?"not " :"" ); +cqm_test_cleanup (); + tests_run++; + } +printf ("1..%d\n" , tests_run);return 0 ;
tools/testing/selftests/resctrl/resctrl_val.c +57 -6
104 lines not on this page · raw message
tools/testing/selftests/resctrl/resctrlfs.c +185 -8
246 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH v9 9/13 selftests/resctrl: Add Cache Allocation Technology (CAT) selftest
In reply to Fenghua YuCache Allocation Technology (CAT) selftest allocates a portion of last level cache and starts a benchmark to read each cache line in this portion of cache. Measure the cache misses in perf and the misses should be equal to the number of cache lines in this portion of cache.
We don't use CQM to calculate cache usage because some CAT enabled platforms don't have CQM.
--- tools/testing/selftests/resctrl/cache.c | 175 +++++++++++- tools/testing/selftests/resctrl/cat_test.c | 250 ++++++++++++++++++ tools/testing/selftests/resctrl/fill_buf.c | 10 +- tools/testing/selftests/resctrl/resctrl.h | 3 + .../testing/selftests/resctrl/resctrl_tests.c | 15 +- tools/testing/selftests/resctrl/resctrlfs.c | 3 +- 6 files changed, 451 insertions(+), 5 deletions(-) create mode 100644 tools/testing/selftests/resctrl/cat_test.c
tools/testing/selftests/resctrl/cache.c +174 -1
@@ -10,8 +10,105 @@ struct read_format { } values[2 ]; }; +static struct perf_event_attr pea_llc_miss; +static struct read_format rf_cqm; +static int fd_lm;char llc_occup_path[1024 ]; +static void initialize_perf_event_attr (void ) +{ + pea_llc_miss.type =PERF_TYPE_HARDWARE ; + pea_llc_miss.size =sizeof (struct perf_event_attr ); + pea_llc_miss.read_format =PERF_FORMAT_GROUP ; + pea_llc_miss.exclude_kernel =1 ; + pea_llc_miss.exclude_hv =1 ; + pea_llc_miss.exclude_idle =1 ; + pea_llc_miss.exclude_callchain_kernel =1 ; + pea_llc_miss.inherit =1 ; + pea_llc_miss.exclude_guest =1 ; + pea_llc_miss.disabled =1 ; +} + +static void ioctl_perf_event_ioc_reset_enable (void ) +{ +ioctl (fd_lm,PERF_EVENT_IOC_RESET ,0 ); +ioctl (fd_lm,PERF_EVENT_IOC_ENABLE ,0 ); +} + +static int perf_event_open_llc_miss (pid_t pid,int cpu_no) +{ + fd_lm =perf_event_open (&pea_llc_miss, pid, cpu_no,-1 , +PERF_FLAG_FD_CLOEXEC ); +if (fd_lm ==-1 ) { +perror ("Error opening leader" ); +ctrlc_handler (0 ,NULL ,NULL ); +return -1 ; + } + +return 0 ; +} + +static int initialize_llc_perf (void ) +{ +memset (&pea_llc_miss,0 ,sizeof (struct perf_event_attr )); +memset (&rf_cqm,0 ,sizeof (struct read_format )); + +/* Initialize perf_event_attr structures for HW_CACHE_MISSES */ +initialize_perf_event_attr (); + + pea_llc_miss.config =PERF_COUNT_HW_CACHE_MISSES ; + + rf_cqm.nr =1 ; + +return 0 ; +} + +static int reset_enable_llc_perf (pid_t pid,int cpu_no) +{ +int ret =0 ; + + ret =perf_event_open_llc_miss (pid, cpu_no); +if (ret <0 ) +return ret; + +/* Start counters to log values */ +ioctl_perf_event_ioc_reset_enable (); + +return 0 ; +} + +/* +* get_llc_perf: llc cache miss through perf events +* @cpu_no: CPU number that the benchmark PID is binded to +* +* Perf events like HW_CACHE_MISSES could be used to validate number of +* cache lines allocated. +* +* Return: =0 on success. <0 on failure. +*/ +static int get_llc_perf (unsigned long *llc_perf_miss) +{ +__u64 total_misses; + +/* Stop counters after one span to get miss rate */ + +ioctl (fd_lm,PERF_EVENT_IOC_DISABLE ,0 ); + +if (read (fd_lm, &rf_cqm,sizeof (struct read_format )) ==-1 ) { +perror ("Could not get llc misses through perf" ); + +return -1 ; + } + + total_misses = rf_cqm.values[0 ].value; + +close (fd_lm); + + *llc_perf_miss = total_misses; + +return 0 ; +} +/* * Get LLC Occupancy as reported by RESCTRL FS * For CQM,
@@ -79,9 +176,19 @@ static int print_results_cache(char *filename, int bm_pid,int measure_cache_vals (struct resctrl_val_param *param,int bm_pid) { -unsigned long llc_occu_resc =0 , llc_value =0 ; +unsigned long llc_perf_miss =0 , llc_occu_resc =0 , llc_value =0 ;int ret; +/* +* Measure cache miss from perf. +*/ +if (!strcmp (param->resctrl_val,"cat" )) { + ret =get_llc_perf (&llc_perf_miss); +if (ret <0 ) +return ret; + llc_value = llc_perf_miss; + } +/* * Measure llc occupancy from resctrl. */
@@ -97,3 +204,69 @@ int measure_cache_vals(struct resctrl_val_param *param, int bm_pid)return 0 ; } + +/* +* cache_val: execute benchmark and measure LLC occupancy resctrl +* and perf cache miss for the benchmark +* @param: parameters passed to cache_val() +* +* Return: 0 on success. non-zero on failure. +*/ +int cat_val (struct resctrl_val_param *param) +{ +int malloc_and_init_memory =1 , memflush =1 , operation =0 , ret =0 ; +char *resctrl_val = param->resctrl_val; +pid_t bm_pid; + +if (strcmp (param->filename,"" ) ==0 ) +sprintf (param->filename,"stdio" ); + + bm_pid =getpid (); + +/* Taskset benchmark to specified cpu */ + ret =taskset_benchmark (bm_pid, param->cpu_no); +if (ret) +return ret; + +/* Write benchmark to specified con_mon grp, mon_grp in resctrl FS*/ + ret =write_bm_pid_to_resctrl (bm_pid, param->ctrlgrp, param->mongrp, + resctrl_val); +if (ret) +return ret; + +if ((strcmp (resctrl_val,"cat" ) ==0 )) { + ret =initialize_llc_perf (); +if (ret) +return ret; + } + +/* Test runs until the callback setup() tells the test to stop. */ +while (1 ) { +if (strcmp (resctrl_val,"cat" ) ==0 ) { + ret = param->setup (1 , param); +if (ret) { + ret =0 ; +break ; + } + ret =reset_enable_llc_perf (bm_pid, param->cpu_no); +if (ret) +break ; + +if (run_fill_buf (param->span, malloc_and_init_memory, + memflush, operation, resctrl_val)) { +fprintf (stderr,"Error-running fill buffer\n" ); + ret =-1 ; +break ; + } + +sleep (1 ); + ret =measure_cache_vals (param, bm_pid); +if (ret) +break ; + }else { +break ; + } + } + +return ret; +}
tools/testing/selftests/resctrl/cat_test.c new file +250 -0
250 lines not on this page · raw message
tools/testing/selftests/resctrl/fill_buf.c +8 -2
@@ -113,8 +113,11 @@ static int fill_cache_read(unsigned char *start_ptr, unsigned char *end_ptr,int ret =0 ;FILE *fp; -while (1 ) +while (1 ) { ret =fill_one_span_read (start_ptr, end_ptr); +if (!strcmp (resctrl_val,"cat" )) +break ; + }/* Consume read result so that reading memory is not optimized out. */ fp =fopen ("/dev/null" ,"w" );
@@ -129,8 +132,11 @@ static int fill_cache_read(unsigned char *start_ptr, unsigned char *end_ptr,static int fill_cache_write (unsigned char *start_ptr,unsigned char *end_ptr,char *resctrl_val) { -while (1 ) +while (1 ) {fill_one_span_write (start_ptr, end_ptr); +if (!strcmp (resctrl_val,"cat" )) +break ; + }return 0 ; }
tools/testing/selftests/resctrl/resctrl.h +3 -0
@@ -94,6 +94,9 @@ void mba_test_cleanup(void);int get_cbm_mask (char *cache_type);int get_cache_size (int cpu_no,char *cache_type,unsigned long *cache_size);void ctrlc_handler (int signum,siginfo_t *info,void *ptr); +int cat_val (struct resctrl_val_param *param); +void cat_test_cleanup (void ); +int cat_perf_miss_val (int cpu_no,int no_of_bits,char *cache_type);int cqm_resctrl_val (int cpu_no,int n,char **benchmark_cmd);unsigned int count_bits (unsigned long n);void cqm_test_cleanup (void );
tools/testing/selftests/resctrl/resctrl_tests.c +14 -1
@@ -19,7 +19,7 @@ static void cmd_help(void)printf ("\t-b benchmark_cmd [options]: run specified benchmark for MBM, MBA and CQM" );printf ("\t default benchmark is builtin fill_buf\n" );printf ("\t-t test list: run tests specified in the test list, " ); -printf ("e.g. -t mbm, mba, cqm\n" ); +printf ("e.g. -t mbm, mba, cqm, cat\n" );printf ("\t-n no_of_bits: run cache tests using specified no of bits in cache bit mask\n" );printf ("\t-p cpu_no: specify CPU number to run the test. 1 is default\n" );printf ("\t-h: help\n" );
@@ -30,6 +30,7 @@ void tests_cleanup(void)mbm_test_cleanup ();mba_test_cleanup ();cqm_test_cleanup (); +cat_test_cleanup (); }int main (int argc,char **argv)
@@ -39,6 +40,7 @@ int main(int argc, char **argv)char *benchmark_cmd[BENCHMARK_ARGS ], bw_report[64 ], bm_type[64 ];char benchmark_cmd_area[BENCHMARK_ARGS ][BENCHMARK_ARG_SIZE ];int ben_ind, ben_count; +bool cat_test = true;for (i =0 ; i < argc; i++) {if (strcmp (argv[i],"-b" ) ==0 ) {
@@ -60,6 +62,7 @@ int main(int argc, char **argv) mbm_test = false; mba_test = false; cqm_test = false; + cat_test = false;while (token) {if (!strcmp (token,"mbm" )) { mbm_test = true;
@@ -67,6 +70,8 @@ int main(int argc, char **argv) mba_test = true; }else if (!strcmp (token,"cqm" )) { cqm_test = true; + }else if (!strcmp (token,"cat" )) { + cat_test = true; }else {printf ("invalid argument\n" );
@@ -159,6 +164,14 @@ int main(int argc, char **argv) tests_run++; } +if (cat_test) { +printf ("# Starting CAT test ...\n" ); + res =cat_perf_miss_val (cpu_no, no_of_bits,"L3" ); +printf ("%sok CAT: test\n" , res ?"not " :"" ); + tests_run++; +cat_test_cleanup (); + } +printf ("1..%d\n" , tests_run);return 0 ;
tools/testing/selftests/resctrl/resctrlfs.c +2 -1
@@ -501,6 +501,7 @@ int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val)FILE *fp;if ((strcmp (resctrl_val,"mba" ) !=0 ) && + (strcmp (resctrl_val,"cat" ) !=0 ) && (strcmp (resctrl_val,"cqm" ) !=0 ))return -ENOENT ;
@@ -522,7 +523,7 @@ int write_schemata(char *ctrlgrp, char *schemata, int cpu_no, char *resctrl_val)else sprintf (controlgroup,"%s/schemata" ,RESCTRL_PATH ); -if (!strcmp (resctrl_val,"cqm" )) +if (!strcmp (resctrl_val,"cat" ) || !strcmp (resctrl_val,"cqm" ))sprintf (schema,"%s%d%c%s" ,"L3:" , resource_id,'=' , schemata);if (strcmp (resctrl_val,"mba" ) ==0 )sprintf (schema,"%s%d%c%s" ,"MB:" , resource_id,'=' , schemata);
Signature · 1 line
2.19.1
PATCH v9 10/13 selftests/resctrl: Add vendor detection mechanism
In reply to Fenghua YuFrom: Babu Moger <[email protected]>
RESCTRL feature is supported both on Intel and AMD now. Some features are implemented differently. Add vendor detection mechanism. Use the vendor check where there are differences.
--- tools/testing/selftests/resctrl/resctrl.h | 1 + .../testing/selftests/resctrl/resctrl_tests.c | 24 +++++++++++++++++++ 2 files changed, 25 insertions(+)
tools/testing/selftests/resctrl/resctrl.h +1 -0
@@ -66,6 +66,7 @@ pid_t bm_pid, ppid;int tests_run;char llc_occup_path[1024 ]; +bool is_amd;bool check_resctrlfs_support (void );int filter_dmesg (void );
tools/testing/selftests/resctrl/resctrl_tests.c +24 -0
@@ -13,6 +13,27 @@#define BENCHMARK_ARGS 64#define BENCHMARK_ARG_SIZE 64 +bool is_amd; + +void detect_amd (void ) +{ +FILE *inf =fopen ("/proc/cpuinfo" ,"r" ); +char *res; + +if (!inf) +return ; + + res =fgrep (inf,"vendor_id" ); + +if (res) { +char *s =strchr (res,':' ); + + is_amd = s && !strcmp (s,": AuthenticAMD\n" ); +free (res); + } +fclose (inf); +} +static void cmd_help (void ) {printf ("usage: resctrl_tests [-h] [-b \"benchmark_cmd [options]\"] [-t test list] [-n no_of_bits]\n" );
@@ -107,6 +128,9 @@ int main(int argc, char **argv)if (geteuid () !=0 )printf ("# WARNING: not running as root, tests may fail.\n" ); +/* Detect AMD vendor */ +detect_amd (); +if (has_ben) {/* Extract benchmark command from command line. */ for (i = ben_ind; i < argc; i++) {
Signature · 1 line
2.19.1
PATCH v9 11/13 selftests/resctrl: Use cache index3 id for AMD schemata masks
In reply to Fenghua YuFrom: Babu Moger <[email protected]>
AMD uses the cache l3 boundary for schemata masks. Update it accordigly.
--- tools/testing/selftests/resctrl/resctrlfs.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
tools/testing/selftests/resctrl/resctrlfs.c +7 -2
@@ -113,8 +113,13 @@ int get_resource_id(int cpu_no, int *resource_id)char phys_pkg_path[1024 ];FILE *fp; -sprintf (phys_pkg_path,"%s%d/topology/physical_package_id" , -PHYS_ID_PATH , cpu_no); +if (is_amd) +sprintf (phys_pkg_path,"%s%d/cache/index3/id" , +PHYS_ID_PATH , cpu_no); +else +sprintf (phys_pkg_path,"%s%d/topology/physical_package_id" , +PHYS_ID_PATH , cpu_no); + fp =fopen (phys_pkg_path,"r" );if (!fp) {perror ("Failed to open physical_package_id" );
Signature · 1 line
2.19.1
PATCH v9 12/13 selftests/resctrl: Disable MBA and MBM tests for AMD
In reply to Fenghua YuFrom: Babu Moger <[email protected]>
For now, disable MBA and MBM tests for AMD. Deciding test pass/fail is not clear right now. We can enable when we have some clarity.
--- tools/testing/selftests/resctrl/cat_test.c | 4 ++-- tools/testing/selftests/resctrl/resctrl_tests.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-)
tools/testing/selftests/resctrl/cat_test.c +2 -2
@@ -64,8 +64,8 @@ static void show_cache_info(unsigned long sum_llc_perf_miss, int no_of_bits, allocated_cache_lines *100 ;printf ("%sok CAT: cache miss rate within %d%%\n" , -abs ((int )diff_percent) >MAX_DIFF_PERCENT ?"not " :"" , -MAX_DIFF_PERCENT ); + !is_amd &&abs ((int )diff_percent) >MAX_DIFF_PERCENT ? +"not " :"" ,MAX_DIFF_PERCENT ); tests_run++;printf ("# Percent diff=%d\n" ,abs ((int )diff_percent));printf ("# Number of bits: %d\n" , no_of_bits);
tools/testing/selftests/resctrl/resctrl_tests.c +2 -2
@@ -158,7 +158,7 @@ int main(int argc, char **argv)check_resctrlfs_support ();filter_dmesg (); -if (mbm_test) { +if (!is_amd && mbm_test) {printf ("# Starting MBM BW change ...\n" );if (!has_ben)sprintf (benchmark_cmd[5 ],"%s" ,"mba" );
@@ -168,7 +168,7 @@ int main(int argc, char **argv) tests_run++; } -if (mba_test) { +if (!is_amd && mba_test) {printf ("# Starting MBA Schemata change ...\n" );if (!has_ben)sprintf (benchmark_cmd[1 ],"%d" , span);
Signature · 1 line
2.19.1
PATCH v9 13/13 selftests/resctrl: Add the test in MAINTAINERS
In reply to Fenghua YuThe resctrl selftest will be maintained by RDT maintainers.
--- MAINTAINERS | 1 + 1 file changed, 1 insertion(+)
MAINTAINERS +1 -0
@@ -13833,6 +13833,7 @@ S: Supported F: arch/x86/kernel/cpu/resctrl/ F: arch/x86/include/asm/resctrl_sched.h F: Documentation/x86/resctrl* +F: tools/testing/selftests/resctrl/ READ-COPY UPDATE (RCU) M: "Paul E. McKenney" <[email protected]>
Signature · 1 line
2.19.1
Babu Moger
reviewerFenghua,
Thanks for the patches. I did a quick test. I am seeing some failures with this series. I need to debug to figure out what is going on. Hopefully I will be able to spend sometime this week or next week. I will be out for few days this week and also next week. Here is the failure..
# ./resctrl_tests -t cat TAP version 13 ok kernel supports resctrl filesystem ok resctrl mountpoint "/sys/fs/resctrl" exists # resctrl filesystem is mounted # dmesg: [ 6.558645] resctrl: L3 allocation detected # dmesg: [ 6.558646] resctrl: L3DATA allocation detected # dmesg: [ 6.558646] resctrl: L3CODE allocation detected # dmesg: [ 6.558647] resctrl: MB allocation detected # dmesg: [ 6.558647] resctrl: L3 monitoring detected # Starting CAT test ... ok mounting resctrl to "/sys/fs/resctrl" cache size :16777216 ok writing benchmark parameters to resctrl FS ok writing benchmark parameters to resctrl FS ok Write schema "L3:0=7ff" to resctrl FS ok Write schema "L3:15=f800" to resctrl FS Error opening leader: No such file or directory Killed
Quoted 122 lines · Fenghua Yu
With more and more resctrl features are being added by Intel, AMD and ARM, a test tool is becoming more and more useful to validate that both hardware and software functionalities work as expected.
We introduce resctrl selftest to cover resctrl features on X86, AMD and ARM architectures. It first implements MBM (Memory Bandwidth Monitoring), MBA (Memory Bandwidth Allocation), L3 CAT (Cache Allocation Technology), and CQM (Cache QoS Monitoring) tests. We will enhance the selftest tool to include more functionality tests in the future.
The tool has been tested on Intel RDT, AMD QoS and ARM MPAM and is in
tools/testing/selftests/resctrlin order to have generic test code base for all architectures.The selftest tool we are introducing here provides a convenient tool which does automatic resctrl testing, is easily available in kernel tree, and covers Intel RDT, AMD QoS and ARM MPAM.
There is an existing resctrl test suite '
intel_cmt_cat'. But its major purpose is to test Intel RDT hardware via writing and reading MSR registers. It does access resctrl file system; but the functionalities are very limited. And it doesn't support automatic test and a lot of manual verifications are involved.Changelog:
v9:
- Per Boris suggestion, add Co-developed-by in each patch to make it clear who contributed to the patch set.v8:
Update code per comments from Andre Przywara from ARM:
- ChangeMakefileand remove inline assembly code to build and test the tool on ARM
- Change the output to TAP format because the format is both readable by human and other test tools.
- Detect resctrl feature from/proc/cpuinfoinstead of dmesg to support generic detection on all architectures.
- Fix a few coding issues.v7:
- Fix a few warnings when compiling patches separately, pointed by Babuv6:
- Fix a benchmark reading optimized out issue in newer GCC.
- Fix a few coding style issues.
- Re-arrange code among patches to make cleaner code. No change in patches structure.v5:
- Based the v4 patches submitted by Fenghua Yu and added changes to support AMD.
- Changed the function nameget_sock_numtoget_resource_id. Intel uses socket number for schemata and AMD uses l3 index id. To generalize, changed the function name toget_resource_id.
- Added the code to detect vendor.
- Disabled the few tests for AMD where the test results are not clear. Also AMD does not have IMC.
- Fixed few compile issues.
- Some cleanup to make each patch independent.
- Tested the patches on AMD system. Fenghua, Need your help to test on Intel box. Please feel free to change and resubmit if something broken.v4:
- address comments from Balu and Randy
- Add CAT and CQM testsv3:
- Change code based on comments from Babu Moger
- Remove some unnessary code and use pipe to communicate b/w processesv2:
- Change code based on comments from Babu Moger
- Clean up other places.Babu Moger (3):
selftests/resctrl: Add vendor detection mechanism selftests/resctrl: Use cache index3 id for AMD schemata masks selftests/resctrl: Disable MBA and MBM tests for AMDFenghua Yu (6):
selftests/resctrl: Add README for resctrl tests selftests/resctrl: Add MBM test
selftests/resctrl: Add MBA test
selftests/resctrl: Add Cache QoS Monitoring (CQM) selftest selftests/resctrl: Add Cache Allocation Technology (CAT) selftest selftests/resctrl: Add the test inMAINTAINERSSai Praneeth Prakhya (4):
selftests/resctrl: Add basic resctrl file system operations and data selftests/resctrl: Read memory bandwidth from perf IMC counter and
from resctrl file system
selftests/resctrl: Add callback to start a benchmark selftests/resctrl: Add built in benchmarkMAINTAINERS | 1 + tools/testing/selftests/resctrl/Makefile | 17 + tools/testing/selftests/resctrl/README | 53 ++ tools/testing/selftests/resctrl/cache.c | 272 +++++++ tools/testing/selftests/resctrl/cat_test.c | 250 ++++++ tools/testing/selftests/resctrl/cqm_test.c | 176 +++++ tools/testing/selftests/resctrl/fill_buf.c | 213 +++++ tools/testing/selftests/resctrl/mba_test.c | 171 ++++ tools/testing/selftests/resctrl/mbm_test.c | 145 ++++ tools/testing/selftests/resctrl/resctrl.h | 107 +++ .../testing/selftests/resctrl/resctrl_tests.c | 202 +++++ tools/testing/selftests/resctrl/resctrl_val.c | 744 ++++++++++++++++++ tools/testing/selftests/resctrl/resctrlfs.c | 722 +++++++++++++++++ 13 files changed, 3073 insertions(+) create mode 100644 tools/testing/selftests/resctrl/Makefile create mode 100644 tools/testing/selftests/resctrl/README create mode 100644 tools/testing/selftests/resctrl/cache.c create mode 100644 tools/testing/selftests/resctrl/cat_test.c create mode 100644 tools/testing/selftests/resctrl/cqm_test.c create mode 100644 tools/testing/selftests/resctrl/fill_buf.c create mode 100644 tools/testing/selftests/resctrl/mba_test.c create mode 100644 tools/testing/selftests/resctrl/mbm_test.c create mode 100644 tools/testing/selftests/resctrl/resctrl.h create mode 100644 tools/testing/selftests/resctrl/resctrl_tests.c create mode 100644 tools/testing/selftests/resctrl/resctrl_val.c create mode 100644 tools/testing/selftests/resctrl/resctrlfs.c
Moger, Babu
reviewer[AMD Official Use Only - Internal Distribution Only]
Hi Fenghua,
Quoted 13 lines
-----Original Message-----
From: Moger, Babu <[email protected]>
Sent: Tuesday, December 17, 2019 12:24 PM
To: Fenghua Yu <[email protected]>; Thomas Gleixner <[email protected]>; Ingo Molnar <[email protected]>; Borislav Petkov <[email protected]>; H Peter Anvin <[email protected]>; Tony Luck <[email protected]>; Reinette Chatre <[email protected]>; James Morse <[email protected]>; Ravi V Shankar <[email protected]>; Sai Praneeth Prakhya <[email protected]>
Cc: linux-kernel <[email protected]>; x86 <[email protected]>
Subject: Re: [PATCH v9 00/13] selftests/resctrl: Add resctrl selftest
Quoted 5 lines
Fenghua,
Thanks for the patches. I did a quick test. I am seeing some failures with this series. I need to debug to figure out what is going on. Hopefully I will be able to spend sometime this week or next week. I will be out for few days this week and also next week. Here is the failure..
The problem has been root caused and fixed with this following patch.
https://lore.kernel.org/lkml/[email protected]/
After this patch everything works as expected. Patches look good to me. Thanks.
Quoted 149 lines
# ./resctrl_tests -t cat TAP version 13 ok kernel supports resctrl filesystem ok resctrl mountpoint "/sys/fs/resctrl" exists # resctrl filesystem is mounted # dmesg: [ 6.558645] resctrl: L3 allocation detected # dmesg: [ 6.558646] resctrl: L3DATA allocation detected # dmesg: [ 6.558646] resctrl: L3CODE allocation detected # dmesg: [ 6.558647] resctrl: MB allocation detected # dmesg: [ 6.558647] resctrl: L3 monitoring detected # Starting CAT test ... ok mounting resctrl to "/sys/fs/resctrl" cache size :16777216 ok writing benchmark parameters to resctrl FS ok writing benchmark parameters to resctrl FS ok Write schema "L3:0=7ff" to resctrl FS ok Write schema "L3:15=f800" to resctrl FS Error opening leader: No such file or directory KilledQuoted 7 lines · Fenghua Yu
With more and more resctrl features are being added by Intel, AMD and ARM, a test tool is becoming more and more useful to validate that both hardware and software functionalities work as expected.
We introduce resctrl selftest to cover resctrl features on X86, AMD and ARM architectures. It first implements MBM (Memory Bandwidth Monitoring), MBA (Memory Bandwidth Allocation), L3 CAT (Cache
Allocation
Quoted 32 lines
Technology), and CQM (Cache QoS Monitoring) tests. We will enhance the selftest tool to include more functionality tests in the future.
The tool has been tested on Intel RDT, AMD QoS and ARM MPAM and is in
tools/testing/selftests/resctrlin order to have generic test code base for all architectures.The selftest tool we are introducing here provides a convenient tool which does automatic resctrl testing, is easily available in kernel tree, and covers Intel RDT, AMD QoS and ARM MPAM.
There is an existing resctrl test suite '
intel_cmt_cat'. But its major purpose is to test Intel RDT hardware via writing and reading MSR registers. It does access resctrl file system; but the functionalities are very limited. And it doesn't support automatic test and a lot of manual verifications are involved.Changelog:
v9:
- Per Boris suggestion, add Co-developed-by in each patch to make it clear who contributed to the patch set.v8:
Update code per comments from Andre Przywara from ARM:
- ChangeMakefileand remove inline assembly code to build and test the tool on ARM
- Change the output to TAP format because the format is both readable by human and other test tools.
- Detect resctrl feature from/proc/cpuinfoinstead of dmesg to support generic detection on all architectures.
- Fix a few coding issues.Quoted 7 lines
v7:
- Fix a few warnings when compiling patches separately, pointed by Babuv6:
- Fix a benchmark reading optimized out issue in newer GCC.
- Fix a few coding style issues.
- Re-arrange code among patches to make cleaner code. No change inpatches
Quoted 4 lines
structure.
v5:
- Based the v4 patches submitted by Fenghua Yu and added changes tosupport
Quoted 13 lines
AMD.
- Changed the function nameget_sock_numtoget_resource_id. Intel uses socket number for schemata and AMD uses l3 index id. To generalize, changed the function name toget_resource_id.
- Added the code to detect vendor.
- Disabled the few tests for AMD where the test results are not clear. Also AMD does not have IMC.
- Fixed few compile issues.
- Some cleanup to make each patch independent.
- Tested the patches on AMD system. Fenghua, Need your help to test on Intel box. Please feel free to change and resubmit if something broken.Quoted 7 lines
v4:
- address comments from Balu and Randy
- Add CAT and CQM testsv3:
- Change code based on comments from Babu Moger
- Remove some unnessary code and use pipe to communicate b/wprocesses
Quoted 52 lines
v2:
- Change code based on comments from Babu Moger
- Clean up other places.Babu Moger (3):
selftests/resctrl: Add vendor detection mechanism selftests/resctrl: Use cache index3 id for AMD schemata masks selftests/resctrl: Disable MBA and MBM tests for AMDFenghua Yu (6):
selftests/resctrl: Add README for resctrl tests selftests/resctrl: Add MBM test
selftests/resctrl: Add MBA test
selftests/resctrl: Add Cache QoS Monitoring (CQM) selftest selftests/resctrl: Add Cache Allocation Technology (CAT) selftest selftests/resctrl: Add the test inMAINTAINERSSai Praneeth Prakhya (4):
selftests/resctrl: Add basic resctrl file system operations and data selftests/resctrl: Read memory bandwidth from perf IMC counter and
from resctrl file system
selftests/resctrl: Add callback to start a benchmark selftests/resctrl: Add built in benchmarkMAINTAINERS | 1 + tools/testing/selftests/resctrl/Makefile | 17 + tools/testing/selftests/resctrl/README | 53 ++ tools/testing/selftests/resctrl/cache.c | 272 +++++++ tools/testing/selftests/resctrl/cat_test.c | 250 ++++++ tools/testing/selftests/resctrl/cqm_test.c | 176 +++++ tools/testing/selftests/resctrl/fill_buf.c | 213 +++++ tools/testing/selftests/resctrl/mba_test.c | 171 ++++ tools/testing/selftests/resctrl/mbm_test.c | 145 ++++ tools/testing/selftests/resctrl/resctrl.h | 107 +++ .../testing/selftests/resctrl/resctrl_tests.c | 202 +++++ tools/testing/selftests/resctrl/resctrl_val.c | 744 ++++++++++++++++++ tools/testing/selftests/resctrl/resctrlfs.c | 722 +++++++++++++++++ 13 files changed, 3073 insertions(+) create mode 100644 tools/testing/selftests/resctrl/Makefile create mode 100644 tools/testing/selftests/resctrl/README create mode 100644 tools/testing/selftests/resctrl/cache.c create mode 100644 tools/testing/selftests/resctrl/cat_test.c create mode 100644 tools/testing/selftests/resctrl/cqm_test.c create mode 100644 tools/testing/selftests/resctrl/fill_buf.c create mode 100644 tools/testing/selftests/resctrl/mba_test.c create mode 100644 tools/testing/selftests/resctrl/mbm_test.c create mode 100644 tools/testing/selftests/resctrl/resctrl.h create mode 100644 tools/testing/selftests/resctrl/resctrl_tests.c create mode 100644 tools/testing/selftests/resctrl/resctrl_val.c create mode 100644 tools/testing/selftests/resctrl/resctrlfs.c
Quoted 23 lines · Babu
[AMD Official Use Only - Internal Distribution Only]
Hi Fenghua,
Quoted 13 lines
-----Original Message-----
From: Moger, Babu <[email protected]>
Sent: Tuesday, December 17, 2019 12:24 PM
To: Fenghua Yu <[email protected]>; Thomas Gleixner <[email protected]>; Ingo Molnar <[email protected]>; Borislav Petkov <[email protected]>; H Peter Anvin <[email protected]>; Tony Luck <[email protected]>; Reinette Chatre <[email protected]>; James Morse <[email protected]>; Ravi V Shankar <[email protected]>; Sai Praneeth Prakhya <[email protected]>
Cc: linux-kernel <[email protected]>; x86 <[email protected]>
Subject: Re: [PATCH v9 00/13] selftests/resctrl: Add resctrl selftestQuoted 5 lines
Fenghua,
Thanks for the patches. I did a quick test. I am seeing some failures with this series. I need to debug to figure out what is going on. Hopefully I will be able to spend sometime this week or next week. I will be out for few days this week and also next week. Here is the failure..
Quoted 3 lines
The problem has been root caused and fixed with this following patch.
https://lore.kernel.org/lkml/[email protected]/
After this patch everything works as expected. Patches look good to me. Thanks.
Hi, Babu,
Thank you very much for finding and fixing the issue!
Glad to know this resctrl selftest tool actually finds one issue although it's not really a resctrl issue.
Hi, Boris, Thomas, Ingo, et al,
Any comment on this patch set?
Thanks.
-Fenghua
Quoted 4 lines · Fenghua Yu
Hi, Boris, Thomas, Ingo, et al,
Any comment on this patch set?
No objections from my side, but you forgot to CC the relevant maintainer/mailinglist for tools/testing/selftests/. CC'ed now.
Thanks,
tglx
Quoted 8 lines · Thomas Gleixner
Quoted 4 lines · Fenghua Yu
Hi, Boris, Thomas, Ingo, et al,
Any comment on this patch set?
No objections from my side, but you forgot to CC the relevant maintainer/mailinglist for
tools/testing/selftests/. CC'ed now.
Thank you for your comments, Thomas!
Hi, Shuah,
Do you want me to resend the v9 resctrl selftest patches to you and linux-kselftest?
This repository has the v9 patches:git://github.com/fyu1/linux resctrl_selftest
Thanks.
-Fenghua