11d3f0868SSai Praneeth Prakhya // SPDX-License-Identifier: GPL-2.0
21d3f0868SSai Praneeth Prakhya /*
31d3f0868SSai Praneeth Prakhya * Memory bandwidth monitoring and allocation library
41d3f0868SSai Praneeth Prakhya *
51d3f0868SSai Praneeth Prakhya * Copyright (C) 2018 Intel Corporation
61d3f0868SSai Praneeth Prakhya *
71d3f0868SSai Praneeth Prakhya * Authors:
81d3f0868SSai Praneeth Prakhya * Sai Praneeth Prakhya <sai.praneeth.prakhya@intel.com>,
91d3f0868SSai Praneeth Prakhya * Fenghua Yu <fenghua.yu@intel.com>
101d3f0868SSai Praneeth Prakhya */
111d3f0868SSai Praneeth Prakhya #include "resctrl.h"
121d3f0868SSai Praneeth Prakhya
131d3f0868SSai Praneeth Prakhya #define UNCORE_IMC "uncore_imc"
141d3f0868SSai Praneeth Prakhya #define READ_FILE_NAME "events/cas_count_read"
151d3f0868SSai Praneeth Prakhya #define WRITE_FILE_NAME "events/cas_count_write"
161d3f0868SSai Praneeth Prakhya #define DYN_PMU_PATH "/sys/bus/event_source/devices"
171d3f0868SSai Praneeth Prakhya #define SCALE 0.00006103515625
181d3f0868SSai Praneeth Prakhya #define MAX_IMCS 20
191d3f0868SSai Praneeth Prakhya #define MAX_TOKENS 5
201d3f0868SSai Praneeth Prakhya #define READ 0
211d3f0868SSai Praneeth Prakhya #define WRITE 1
221d3f0868SSai Praneeth Prakhya
231d3f0868SSai Praneeth Prakhya #define CON_MBM_LOCAL_BYTES_PATH \
241d3f0868SSai Praneeth Prakhya "%s/%s/mon_data/mon_L3_%02d/mbm_local_bytes"
251d3f0868SSai Praneeth Prakhya
261d3f0868SSai Praneeth Prakhya struct membw_read_format {
271d3f0868SSai Praneeth Prakhya __u64 value; /* The value of the event */
281d3f0868SSai Praneeth Prakhya __u64 time_enabled; /* if PERF_FORMAT_TOTAL_TIME_ENABLED */
291d3f0868SSai Praneeth Prakhya __u64 time_running; /* if PERF_FORMAT_TOTAL_TIME_RUNNING */
301d3f0868SSai Praneeth Prakhya __u64 id; /* if PERF_FORMAT_ID */
311d3f0868SSai Praneeth Prakhya };
321d3f0868SSai Praneeth Prakhya
331d3f0868SSai Praneeth Prakhya struct imc_counter_config {
341d3f0868SSai Praneeth Prakhya __u32 type;
351d3f0868SSai Praneeth Prakhya __u64 event;
361d3f0868SSai Praneeth Prakhya __u64 umask;
371d3f0868SSai Praneeth Prakhya struct perf_event_attr pe;
381d3f0868SSai Praneeth Prakhya struct membw_read_format return_value;
391d3f0868SSai Praneeth Prakhya int fd;
401d3f0868SSai Praneeth Prakhya };
411d3f0868SSai Praneeth Prakhya
427f4d257eSSai Praneeth Prakhya static char mbm_total_path[1024];
437f4d257eSSai Praneeth Prakhya static int imcs;
441d3f0868SSai Praneeth Prakhya static struct imc_counter_config imc_counters_config[MAX_IMCS][2];
45e6487230SMaciej Wieczor-Retman static const struct resctrl_test *current_test;
461d3f0868SSai Praneeth Prakhya
membw_initialize_perf_event_attr(int i,int j)471d3f0868SSai Praneeth Prakhya void membw_initialize_perf_event_attr(int i, int j)
481d3f0868SSai Praneeth Prakhya {
491d3f0868SSai Praneeth Prakhya memset(&imc_counters_config[i][j].pe, 0,
501d3f0868SSai Praneeth Prakhya sizeof(struct perf_event_attr));
511d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.type = imc_counters_config[i][j].type;
521d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.size = sizeof(struct perf_event_attr);
531d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.disabled = 1;
541d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.inherit = 1;
551d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.exclude_guest = 0;
561d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.config =
571d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].umask << 8 |
581d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].event;
591d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.sample_type = PERF_SAMPLE_IDENTIFIER;
601d3f0868SSai Praneeth Prakhya imc_counters_config[i][j].pe.read_format =
611d3f0868SSai Praneeth Prakhya PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING;
621d3f0868SSai Praneeth Prakhya }
631d3f0868SSai Praneeth Prakhya
membw_ioctl_perf_event_ioc_reset_enable(int i,int j)641d3f0868SSai Praneeth Prakhya void membw_ioctl_perf_event_ioc_reset_enable(int i, int j)
651d3f0868SSai Praneeth Prakhya {
661d3f0868SSai Praneeth Prakhya ioctl(imc_counters_config[i][j].fd, PERF_EVENT_IOC_RESET, 0);
671d3f0868SSai Praneeth Prakhya ioctl(imc_counters_config[i][j].fd, PERF_EVENT_IOC_ENABLE, 0);
681d3f0868SSai Praneeth Prakhya }
691d3f0868SSai Praneeth Prakhya
membw_ioctl_perf_event_ioc_disable(int i,int j)701d3f0868SSai Praneeth Prakhya void membw_ioctl_perf_event_ioc_disable(int i, int j)
711d3f0868SSai Praneeth Prakhya {
721d3f0868SSai Praneeth Prakhya ioctl(imc_counters_config[i][j].fd, PERF_EVENT_IOC_DISABLE, 0);
731d3f0868SSai Praneeth Prakhya }
741d3f0868SSai Praneeth Prakhya
751d3f0868SSai Praneeth Prakhya /*
761d3f0868SSai Praneeth Prakhya * get_event_and_umask: Parse config into event and umask
771d3f0868SSai Praneeth Prakhya * @cas_count_cfg: Config
781d3f0868SSai Praneeth Prakhya * @count: iMC number
791d3f0868SSai Praneeth Prakhya * @op: Operation (read/write)
801d3f0868SSai Praneeth Prakhya */
get_event_and_umask(char * cas_count_cfg,int count,bool op)811d3f0868SSai Praneeth Prakhya void get_event_and_umask(char *cas_count_cfg, int count, bool op)
821d3f0868SSai Praneeth Prakhya {
831d3f0868SSai Praneeth Prakhya char *token[MAX_TOKENS];
841d3f0868SSai Praneeth Prakhya int i = 0;
851d3f0868SSai Praneeth Prakhya
861d3f0868SSai Praneeth Prakhya strcat(cas_count_cfg, ",");
871d3f0868SSai Praneeth Prakhya token[0] = strtok(cas_count_cfg, "=,");
881d3f0868SSai Praneeth Prakhya
891d3f0868SSai Praneeth Prakhya for (i = 1; i < MAX_TOKENS; i++)
901d3f0868SSai Praneeth Prakhya token[i] = strtok(NULL, "=,");
911d3f0868SSai Praneeth Prakhya
921d3f0868SSai Praneeth Prakhya for (i = 0; i < MAX_TOKENS; i++) {
931d3f0868SSai Praneeth Prakhya if (!token[i])
941d3f0868SSai Praneeth Prakhya break;
951d3f0868SSai Praneeth Prakhya if (strcmp(token[i], "event") == 0) {
961d3f0868SSai Praneeth Prakhya if (op == READ)
971d3f0868SSai Praneeth Prakhya imc_counters_config[count][READ].event =
981d3f0868SSai Praneeth Prakhya strtol(token[i + 1], NULL, 16);
991d3f0868SSai Praneeth Prakhya else
1001d3f0868SSai Praneeth Prakhya imc_counters_config[count][WRITE].event =
1011d3f0868SSai Praneeth Prakhya strtol(token[i + 1], NULL, 16);
1021d3f0868SSai Praneeth Prakhya }
1031d3f0868SSai Praneeth Prakhya if (strcmp(token[i], "umask") == 0) {
1041d3f0868SSai Praneeth Prakhya if (op == READ)
1051d3f0868SSai Praneeth Prakhya imc_counters_config[count][READ].umask =
1061d3f0868SSai Praneeth Prakhya strtol(token[i + 1], NULL, 16);
1071d3f0868SSai Praneeth Prakhya else
1081d3f0868SSai Praneeth Prakhya imc_counters_config[count][WRITE].umask =
1091d3f0868SSai Praneeth Prakhya strtol(token[i + 1], NULL, 16);
1101d3f0868SSai Praneeth Prakhya }
1111d3f0868SSai Praneeth Prakhya }
1121d3f0868SSai Praneeth Prakhya }
1137f4d257eSSai Praneeth Prakhya
open_perf_event(int i,int cpu_no,int j)1147f4d257eSSai Praneeth Prakhya static int open_perf_event(int i, int cpu_no, int j)
1157f4d257eSSai Praneeth Prakhya {
1167f4d257eSSai Praneeth Prakhya imc_counters_config[i][j].fd =
1177f4d257eSSai Praneeth Prakhya perf_event_open(&imc_counters_config[i][j].pe, -1, cpu_no, -1,
1187f4d257eSSai Praneeth Prakhya PERF_FLAG_FD_CLOEXEC);
1197f4d257eSSai Praneeth Prakhya
1207f4d257eSSai Praneeth Prakhya if (imc_counters_config[i][j].fd == -1) {
1217f4d257eSSai Praneeth Prakhya fprintf(stderr, "Error opening leader %llx\n",
1227f4d257eSSai Praneeth Prakhya imc_counters_config[i][j].pe.config);
1237f4d257eSSai Praneeth Prakhya
1247f4d257eSSai Praneeth Prakhya return -1;
1257f4d257eSSai Praneeth Prakhya }
1267f4d257eSSai Praneeth Prakhya
1277f4d257eSSai Praneeth Prakhya return 0;
1287f4d257eSSai Praneeth Prakhya }
1297f4d257eSSai Praneeth Prakhya
1307f4d257eSSai Praneeth Prakhya /* Get type and config (read and write) of an iMC counter */
read_from_imc_dir(char * imc_dir,int count)1317f4d257eSSai Praneeth Prakhya static int read_from_imc_dir(char *imc_dir, int count)
1327f4d257eSSai Praneeth Prakhya {
1337f4d257eSSai Praneeth Prakhya char cas_count_cfg[1024], imc_counter_cfg[1024], imc_counter_type[1024];
1347f4d257eSSai Praneeth Prakhya FILE *fp;
1357f4d257eSSai Praneeth Prakhya
1367f4d257eSSai Praneeth Prakhya /* Get type of iMC counter */
1377f4d257eSSai Praneeth Prakhya sprintf(imc_counter_type, "%s%s", imc_dir, "type");
1387f4d257eSSai Praneeth Prakhya fp = fopen(imc_counter_type, "r");
1397f4d257eSSai Praneeth Prakhya if (!fp) {
140cc8ff7f5SIlpo Järvinen ksft_perror("Failed to open iMC counter type file");
1417f4d257eSSai Praneeth Prakhya
1427f4d257eSSai Praneeth Prakhya return -1;
1437f4d257eSSai Praneeth Prakhya }
1447f4d257eSSai Praneeth Prakhya if (fscanf(fp, "%u", &imc_counters_config[count][READ].type) <= 0) {
145cc8ff7f5SIlpo Järvinen ksft_perror("Could not get iMC type");
1467f4d257eSSai Praneeth Prakhya fclose(fp);
1477f4d257eSSai Praneeth Prakhya
1487f4d257eSSai Praneeth Prakhya return -1;
1497f4d257eSSai Praneeth Prakhya }
1507f4d257eSSai Praneeth Prakhya fclose(fp);
1517f4d257eSSai Praneeth Prakhya
1527f4d257eSSai Praneeth Prakhya imc_counters_config[count][WRITE].type =
1537f4d257eSSai Praneeth Prakhya imc_counters_config[count][READ].type;
1547f4d257eSSai Praneeth Prakhya
1557f4d257eSSai Praneeth Prakhya /* Get read config */
1567f4d257eSSai Praneeth Prakhya sprintf(imc_counter_cfg, "%s%s", imc_dir, READ_FILE_NAME);
1577f4d257eSSai Praneeth Prakhya fp = fopen(imc_counter_cfg, "r");
1587f4d257eSSai Praneeth Prakhya if (!fp) {
159cc8ff7f5SIlpo Järvinen ksft_perror("Failed to open iMC config file");
1607f4d257eSSai Praneeth Prakhya
1617f4d257eSSai Praneeth Prakhya return -1;
1627f4d257eSSai Praneeth Prakhya }
1637f4d257eSSai Praneeth Prakhya if (fscanf(fp, "%s", cas_count_cfg) <= 0) {
164cc8ff7f5SIlpo Järvinen ksft_perror("Could not get iMC cas count read");
1657f4d257eSSai Praneeth Prakhya fclose(fp);
1667f4d257eSSai Praneeth Prakhya
1677f4d257eSSai Praneeth Prakhya return -1;
1687f4d257eSSai Praneeth Prakhya }
1697f4d257eSSai Praneeth Prakhya fclose(fp);
1707f4d257eSSai Praneeth Prakhya
1717f4d257eSSai Praneeth Prakhya get_event_and_umask(cas_count_cfg, count, READ);
1727f4d257eSSai Praneeth Prakhya
1737f4d257eSSai Praneeth Prakhya /* Get write config */
1747f4d257eSSai Praneeth Prakhya sprintf(imc_counter_cfg, "%s%s", imc_dir, WRITE_FILE_NAME);
1757f4d257eSSai Praneeth Prakhya fp = fopen(imc_counter_cfg, "r");
1767f4d257eSSai Praneeth Prakhya if (!fp) {
177cc8ff7f5SIlpo Järvinen ksft_perror("Failed to open iMC config file");
1787f4d257eSSai Praneeth Prakhya
1797f4d257eSSai Praneeth Prakhya return -1;
1807f4d257eSSai Praneeth Prakhya }
1817f4d257eSSai Praneeth Prakhya if (fscanf(fp, "%s", cas_count_cfg) <= 0) {
182cc8ff7f5SIlpo Järvinen ksft_perror("Could not get iMC cas count write");
1837f4d257eSSai Praneeth Prakhya fclose(fp);
1847f4d257eSSai Praneeth Prakhya
1857f4d257eSSai Praneeth Prakhya return -1;
1867f4d257eSSai Praneeth Prakhya }
1877f4d257eSSai Praneeth Prakhya fclose(fp);
1887f4d257eSSai Praneeth Prakhya
1897f4d257eSSai Praneeth Prakhya get_event_and_umask(cas_count_cfg, count, WRITE);
1907f4d257eSSai Praneeth Prakhya
1917f4d257eSSai Praneeth Prakhya return 0;
1927f4d257eSSai Praneeth Prakhya }
1937f4d257eSSai Praneeth Prakhya
1947f4d257eSSai Praneeth Prakhya /*
1957f4d257eSSai Praneeth Prakhya * A system can have 'n' number of iMC (Integrated Memory Controller)
1967f4d257eSSai Praneeth Prakhya * counters, get that 'n'. For each iMC counter get it's type and config.
1977f4d257eSSai Praneeth Prakhya * Also, each counter has two configs, one for read and the other for write.
1987f4d257eSSai Praneeth Prakhya * A config again has two parts, event and umask.
1997f4d257eSSai Praneeth Prakhya * Enumerate all these details into an array of structures.
2007f4d257eSSai Praneeth Prakhya *
2017f4d257eSSai Praneeth Prakhya * Return: >= 0 on success. < 0 on failure.
2027f4d257eSSai Praneeth Prakhya */
num_of_imcs(void)2037f4d257eSSai Praneeth Prakhya static int num_of_imcs(void)
2047f4d257eSSai Praneeth Prakhya {
205d81343b5SFenghua Yu char imc_dir[512], *temp;
2067f4d257eSSai Praneeth Prakhya unsigned int count = 0;
2077f4d257eSSai Praneeth Prakhya struct dirent *ep;
2087f4d257eSSai Praneeth Prakhya int ret;
2097f4d257eSSai Praneeth Prakhya DIR *dp;
2107f4d257eSSai Praneeth Prakhya
2117f4d257eSSai Praneeth Prakhya dp = opendir(DYN_PMU_PATH);
2127f4d257eSSai Praneeth Prakhya if (dp) {
2137f4d257eSSai Praneeth Prakhya while ((ep = readdir(dp))) {
214d81343b5SFenghua Yu temp = strstr(ep->d_name, UNCORE_IMC);
215d81343b5SFenghua Yu if (!temp)
216d81343b5SFenghua Yu continue;
217d81343b5SFenghua Yu
218d81343b5SFenghua Yu /*
219d81343b5SFenghua Yu * imc counters are named as "uncore_imc_<n>", hence
220d81343b5SFenghua Yu * increment the pointer to point to <n>. Note that
221d81343b5SFenghua Yu * sizeof(UNCORE_IMC) would count for null character as
222d81343b5SFenghua Yu * well and hence the last underscore character in
223d81343b5SFenghua Yu * uncore_imc'_' need not be counted.
224d81343b5SFenghua Yu */
225d81343b5SFenghua Yu temp = temp + sizeof(UNCORE_IMC);
226d81343b5SFenghua Yu
227d81343b5SFenghua Yu /*
228d81343b5SFenghua Yu * Some directories under "DYN_PMU_PATH" could have
229d81343b5SFenghua Yu * names like "uncore_imc_free_running", hence, check if
230d81343b5SFenghua Yu * first character is a numerical digit or not.
231d81343b5SFenghua Yu */
232d81343b5SFenghua Yu if (temp[0] >= '0' && temp[0] <= '9') {
2337f4d257eSSai Praneeth Prakhya sprintf(imc_dir, "%s/%s/", DYN_PMU_PATH,
2347f4d257eSSai Praneeth Prakhya ep->d_name);
2357f4d257eSSai Praneeth Prakhya ret = read_from_imc_dir(imc_dir, count);
2367f4d257eSSai Praneeth Prakhya if (ret) {
2377f4d257eSSai Praneeth Prakhya closedir(dp);
2387f4d257eSSai Praneeth Prakhya
2397f4d257eSSai Praneeth Prakhya return ret;
2407f4d257eSSai Praneeth Prakhya }
2417f4d257eSSai Praneeth Prakhya count++;
2427f4d257eSSai Praneeth Prakhya }
2437f4d257eSSai Praneeth Prakhya }
2447f4d257eSSai Praneeth Prakhya closedir(dp);
2457f4d257eSSai Praneeth Prakhya if (count == 0) {
246cc8ff7f5SIlpo Järvinen ksft_print_msg("Unable to find iMC counters\n");
2477f4d257eSSai Praneeth Prakhya
2487f4d257eSSai Praneeth Prakhya return -1;
2497f4d257eSSai Praneeth Prakhya }
2507f4d257eSSai Praneeth Prakhya } else {
251cc8ff7f5SIlpo Järvinen ksft_perror("Unable to open PMU directory");
2527f4d257eSSai Praneeth Prakhya
2537f4d257eSSai Praneeth Prakhya return -1;
2547f4d257eSSai Praneeth Prakhya }
2557f4d257eSSai Praneeth Prakhya
2567f4d257eSSai Praneeth Prakhya return count;
2577f4d257eSSai Praneeth Prakhya }
2587f4d257eSSai Praneeth Prakhya
initialize_mem_bw_imc(void)259aef5efa6SIlpo Järvinen int initialize_mem_bw_imc(void)
2607f4d257eSSai Praneeth Prakhya {
2617f4d257eSSai Praneeth Prakhya int imc, j;
2627f4d257eSSai Praneeth Prakhya
2637f4d257eSSai Praneeth Prakhya imcs = num_of_imcs();
2647f4d257eSSai Praneeth Prakhya if (imcs <= 0)
2657f4d257eSSai Praneeth Prakhya return imcs;
2667f4d257eSSai Praneeth Prakhya
2677f4d257eSSai Praneeth Prakhya /* Initialize perf_event_attr structures for all iMC's */
2687f4d257eSSai Praneeth Prakhya for (imc = 0; imc < imcs; imc++) {
2697f4d257eSSai Praneeth Prakhya for (j = 0; j < 2; j++)
2707f4d257eSSai Praneeth Prakhya membw_initialize_perf_event_attr(imc, j);
2717f4d257eSSai Praneeth Prakhya }
2727f4d257eSSai Praneeth Prakhya
2737f4d257eSSai Praneeth Prakhya return 0;
2747f4d257eSSai Praneeth Prakhya }
2757f4d257eSSai Praneeth Prakhya
perf_close_imc_mem_bw(void)276c44000b6SIlpo Järvinen static void perf_close_imc_mem_bw(void)
277c44000b6SIlpo Järvinen {
278c44000b6SIlpo Järvinen int mc;
279c44000b6SIlpo Järvinen
280c44000b6SIlpo Järvinen for (mc = 0; mc < imcs; mc++) {
281c44000b6SIlpo Järvinen if (imc_counters_config[mc][READ].fd != -1)
282c44000b6SIlpo Järvinen close(imc_counters_config[mc][READ].fd);
283c44000b6SIlpo Järvinen if (imc_counters_config[mc][WRITE].fd != -1)
284c44000b6SIlpo Järvinen close(imc_counters_config[mc][WRITE].fd);
285c44000b6SIlpo Järvinen }
286c44000b6SIlpo Järvinen }
287c44000b6SIlpo Järvinen
2887f4d257eSSai Praneeth Prakhya /*
289da50de0aSIlpo Järvinen * perf_open_imc_mem_bw - Open perf fds for IMCs
290da50de0aSIlpo Järvinen * @cpu_no: CPU number that the benchmark PID is bound to
2917f4d257eSSai Praneeth Prakhya *
2921205b688SFenghua Yu * Return: = 0 on success. < 0 on failure.
2937f4d257eSSai Praneeth Prakhya */
perf_open_imc_mem_bw(int cpu_no)294da50de0aSIlpo Järvinen static int perf_open_imc_mem_bw(int cpu_no)
2957f4d257eSSai Praneeth Prakhya {
296c44000b6SIlpo Järvinen int imc, ret;
297c44000b6SIlpo Järvinen
298c44000b6SIlpo Järvinen for (imc = 0; imc < imcs; imc++) {
299c44000b6SIlpo Järvinen imc_counters_config[imc][READ].fd = -1;
300c44000b6SIlpo Järvinen imc_counters_config[imc][WRITE].fd = -1;
301c44000b6SIlpo Järvinen }
3027f4d257eSSai Praneeth Prakhya
3037f4d257eSSai Praneeth Prakhya for (imc = 0; imc < imcs; imc++) {
304c44000b6SIlpo Järvinen ret = open_perf_event(imc, cpu_no, READ);
3057f4d257eSSai Praneeth Prakhya if (ret)
306c44000b6SIlpo Järvinen goto close_fds;
307c44000b6SIlpo Järvinen ret = open_perf_event(imc, cpu_no, WRITE);
308c44000b6SIlpo Järvinen if (ret)
309c44000b6SIlpo Järvinen goto close_fds;
310da50de0aSIlpo Järvinen }
311c44000b6SIlpo Järvinen
312da50de0aSIlpo Järvinen return 0;
313da50de0aSIlpo Järvinen
314da50de0aSIlpo Järvinen close_fds:
315da50de0aSIlpo Järvinen perf_close_imc_mem_bw();
316da50de0aSIlpo Järvinen return -1;
317da50de0aSIlpo Järvinen }
318da50de0aSIlpo Järvinen
319da50de0aSIlpo Järvinen /*
320da50de0aSIlpo Järvinen * do_mem_bw_test - Perform memory bandwidth test
321da50de0aSIlpo Järvinen *
322da50de0aSIlpo Järvinen * Runs memory bandwidth test over one second period. Also, handles starting
323da50de0aSIlpo Järvinen * and stopping of the IMC perf counters around the test.
324da50de0aSIlpo Järvinen */
do_imc_mem_bw_test(void)325da50de0aSIlpo Järvinen static void do_imc_mem_bw_test(void)
326da50de0aSIlpo Järvinen {
327da50de0aSIlpo Järvinen int imc;
328da50de0aSIlpo Järvinen
329da50de0aSIlpo Järvinen for (imc = 0; imc < imcs; imc++) {
330c44000b6SIlpo Järvinen membw_ioctl_perf_event_ioc_reset_enable(imc, READ);
331c44000b6SIlpo Järvinen membw_ioctl_perf_event_ioc_reset_enable(imc, WRITE);
3327f4d257eSSai Praneeth Prakhya }
3337f4d257eSSai Praneeth Prakhya
3347f4d257eSSai Praneeth Prakhya sleep(1);
3357f4d257eSSai Praneeth Prakhya
3367f4d257eSSai Praneeth Prakhya /* Stop counters after a second to get results (both read and write) */
3377f4d257eSSai Praneeth Prakhya for (imc = 0; imc < imcs; imc++) {
338c44000b6SIlpo Järvinen membw_ioctl_perf_event_ioc_disable(imc, READ);
339c44000b6SIlpo Järvinen membw_ioctl_perf_event_ioc_disable(imc, WRITE);
3407f4d257eSSai Praneeth Prakhya }
341da50de0aSIlpo Järvinen }
342da50de0aSIlpo Järvinen
343da50de0aSIlpo Järvinen /*
344da50de0aSIlpo Järvinen * get_mem_bw_imc - Memory bandwidth as reported by iMC counters
345da50de0aSIlpo Järvinen * @bw_report: Bandwidth report type (reads, writes)
346da50de0aSIlpo Järvinen *
3472704b2d1SIlpo Järvinen * Memory bandwidth utilized by a process on a socket can be calculated
3482704b2d1SIlpo Järvinen * using iMC counters. Perf events are used to read these counters.
349da50de0aSIlpo Järvinen *
350da50de0aSIlpo Järvinen * Return: = 0 on success. < 0 on failure.
351da50de0aSIlpo Järvinen */
get_mem_bw_imc(const char * bw_report,float * bw_imc)352fa1116d0SIlpo Järvinen static int get_mem_bw_imc(const char *bw_report, float *bw_imc)
353da50de0aSIlpo Järvinen {
354da50de0aSIlpo Järvinen float reads, writes, of_mul_read, of_mul_write;
355da50de0aSIlpo Järvinen int imc;
356da50de0aSIlpo Järvinen
357da50de0aSIlpo Järvinen /* Start all iMC counters to log values (both read and write) */
358da50de0aSIlpo Järvinen reads = 0, writes = 0, of_mul_read = 1, of_mul_write = 1;
3597f4d257eSSai Praneeth Prakhya
3607f4d257eSSai Praneeth Prakhya /*
3617f4d257eSSai Praneeth Prakhya * Get results which are stored in struct type imc_counter_config
3622704b2d1SIlpo Järvinen * Take overflow into consideration before calculating total bandwidth.
3637f4d257eSSai Praneeth Prakhya */
3647f4d257eSSai Praneeth Prakhya for (imc = 0; imc < imcs; imc++) {
3657f4d257eSSai Praneeth Prakhya struct imc_counter_config *r =
3667f4d257eSSai Praneeth Prakhya &imc_counters_config[imc][READ];
3677f4d257eSSai Praneeth Prakhya struct imc_counter_config *w =
3687f4d257eSSai Praneeth Prakhya &imc_counters_config[imc][WRITE];
3697f4d257eSSai Praneeth Prakhya
3707f4d257eSSai Praneeth Prakhya if (read(r->fd, &r->return_value,
3717f4d257eSSai Praneeth Prakhya sizeof(struct membw_read_format)) == -1) {
3722704b2d1SIlpo Järvinen ksft_perror("Couldn't get read bandwidth through iMC");
373da50de0aSIlpo Järvinen return -1;
3747f4d257eSSai Praneeth Prakhya }
3757f4d257eSSai Praneeth Prakhya
3767f4d257eSSai Praneeth Prakhya if (read(w->fd, &w->return_value,
3777f4d257eSSai Praneeth Prakhya sizeof(struct membw_read_format)) == -1) {
3782704b2d1SIlpo Järvinen ksft_perror("Couldn't get write bandwidth through iMC");
379da50de0aSIlpo Järvinen return -1;
3807f4d257eSSai Praneeth Prakhya }
3817f4d257eSSai Praneeth Prakhya
3827f4d257eSSai Praneeth Prakhya __u64 r_time_enabled = r->return_value.time_enabled;
3837f4d257eSSai Praneeth Prakhya __u64 r_time_running = r->return_value.time_running;
3847f4d257eSSai Praneeth Prakhya
3857f4d257eSSai Praneeth Prakhya if (r_time_enabled != r_time_running)
3867f4d257eSSai Praneeth Prakhya of_mul_read = (float)r_time_enabled /
3877f4d257eSSai Praneeth Prakhya (float)r_time_running;
3887f4d257eSSai Praneeth Prakhya
3897f4d257eSSai Praneeth Prakhya __u64 w_time_enabled = w->return_value.time_enabled;
3907f4d257eSSai Praneeth Prakhya __u64 w_time_running = w->return_value.time_running;
3917f4d257eSSai Praneeth Prakhya
3927f4d257eSSai Praneeth Prakhya if (w_time_enabled != w_time_running)
3937f4d257eSSai Praneeth Prakhya of_mul_write = (float)w_time_enabled /
3947f4d257eSSai Praneeth Prakhya (float)w_time_running;
3957f4d257eSSai Praneeth Prakhya reads += r->return_value.value * of_mul_read * SCALE;
3967f4d257eSSai Praneeth Prakhya writes += w->return_value.value * of_mul_write * SCALE;
3977f4d257eSSai Praneeth Prakhya }
3987f4d257eSSai Praneeth Prakhya
3991205b688SFenghua Yu if (strcmp(bw_report, "reads") == 0) {
4001205b688SFenghua Yu *bw_imc = reads;
4011205b688SFenghua Yu return 0;
4021205b688SFenghua Yu }
4037f4d257eSSai Praneeth Prakhya
4041205b688SFenghua Yu if (strcmp(bw_report, "writes") == 0) {
4051205b688SFenghua Yu *bw_imc = writes;
4061205b688SFenghua Yu return 0;
4071205b688SFenghua Yu }
4087f4d257eSSai Praneeth Prakhya
4091205b688SFenghua Yu *bw_imc = reads + writes;
4101205b688SFenghua Yu return 0;
4117f4d257eSSai Praneeth Prakhya }
4127f4d257eSSai Praneeth Prakhya
4137f4d257eSSai Praneeth Prakhya /*
4147f4d257eSSai Praneeth Prakhya * initialize_mem_bw_resctrl: Appropriately populate "mbm_total_path"
415aef5efa6SIlpo Järvinen * @param: Parameters passed to resctrl_val()
4169224db51SIlpo Järvinen * @domain_id: Domain ID (cache ID; for MB, L3 cache ID)
4177f4d257eSSai Praneeth Prakhya */
initialize_mem_bw_resctrl(const struct resctrl_val_param * param,int domain_id)418aef5efa6SIlpo Järvinen void initialize_mem_bw_resctrl(const struct resctrl_val_param *param,
419aef5efa6SIlpo Järvinen int domain_id)
4207f4d257eSSai Praneeth Prakhya {
421711d27b0SIlpo Järvinen sprintf(mbm_total_path, CON_MBM_LOCAL_BYTES_PATH, RESCTRL_PATH,
422aef5efa6SIlpo Järvinen param->ctrlgrp, domain_id);
4237f4d257eSSai Praneeth Prakhya }
4247f4d257eSSai Praneeth Prakhya
4257f4d257eSSai Praneeth Prakhya /*
426aef5efa6SIlpo Järvinen * Open file to read MBM local bytes from resctrl FS
4277f4d257eSSai Praneeth Prakhya */
open_mem_bw_resctrl(const char * mbm_bw_file)428da50de0aSIlpo Järvinen static FILE *open_mem_bw_resctrl(const char *mbm_bw_file)
4297f4d257eSSai Praneeth Prakhya {
4307f4d257eSSai Praneeth Prakhya FILE *fp;
4317f4d257eSSai Praneeth Prakhya
432da50de0aSIlpo Järvinen fp = fopen(mbm_bw_file, "r");
433da50de0aSIlpo Järvinen if (!fp)
4342704b2d1SIlpo Järvinen ksft_perror("Failed to open total memory bandwidth file");
4357f4d257eSSai Praneeth Prakhya
436da50de0aSIlpo Järvinen return fp;
437da50de0aSIlpo Järvinen }
438da50de0aSIlpo Järvinen
439aef5efa6SIlpo Järvinen /*
440aef5efa6SIlpo Järvinen * Get MBM Local bytes as reported by resctrl FS
441aef5efa6SIlpo Järvinen */
get_mem_bw_resctrl(FILE * fp,unsigned long * mbm_total)442da50de0aSIlpo Järvinen static int get_mem_bw_resctrl(FILE *fp, unsigned long *mbm_total)
443da50de0aSIlpo Järvinen {
444da50de0aSIlpo Järvinen if (fscanf(fp, "%lu\n", mbm_total) <= 0) {
445da50de0aSIlpo Järvinen ksft_perror("Could not get MBM local bytes");
4467f4d257eSSai Praneeth Prakhya return -1;
4477f4d257eSSai Praneeth Prakhya }
4481205b688SFenghua Yu return 0;
4497f4d257eSSai Praneeth Prakhya }
4507f4d257eSSai Praneeth Prakhya
451b0bd742aSIlpo Järvinen static pid_t bm_pid, ppid;
4527f4d257eSSai Praneeth Prakhya
ctrlc_handler(int signum,siginfo_t * info,void * ptr)45378941183SFenghua Yu void ctrlc_handler(int signum, siginfo_t *info, void *ptr)
4547f4d257eSSai Praneeth Prakhya {
4553aff5146SIlpo Järvinen /* Only kill child after bm_pid is set after fork() */
4563aff5146SIlpo Järvinen if (bm_pid)
4577f4d257eSSai Praneeth Prakhya kill(bm_pid, SIGKILL);
458ecdbb911SFenghua Yu umount_resctrlfs();
459e6487230SMaciej Wieczor-Retman if (current_test && current_test->cleanup)
460e6487230SMaciej Wieczor-Retman current_test->cleanup();
461ca2f4214SFenghua Yu ksft_print_msg("Ending\n\n");
4627f4d257eSSai Praneeth Prakhya
4637f4d257eSSai Praneeth Prakhya exit(EXIT_SUCCESS);
4647f4d257eSSai Praneeth Prakhya }
4657f4d257eSSai Praneeth Prakhya
4667f4d257eSSai Praneeth Prakhya /*
46773c55fa5SShaopeng Tan * Register CTRL-C handler for parent, as it has to kill
46873c55fa5SShaopeng Tan * child process before exiting.
46973c55fa5SShaopeng Tan */
signal_handler_register(const struct resctrl_test * test)470e6487230SMaciej Wieczor-Retman int signal_handler_register(const struct resctrl_test *test)
47173c55fa5SShaopeng Tan {
472beb7f471SIlpo Järvinen struct sigaction sigact = {};
47373c55fa5SShaopeng Tan int ret = 0;
47473c55fa5SShaopeng Tan
4753aff5146SIlpo Järvinen bm_pid = 0;
4763aff5146SIlpo Järvinen
477e6487230SMaciej Wieczor-Retman current_test = test;
47873c55fa5SShaopeng Tan sigact.sa_sigaction = ctrlc_handler;
47973c55fa5SShaopeng Tan sigemptyset(&sigact.sa_mask);
48073c55fa5SShaopeng Tan sigact.sa_flags = SA_SIGINFO;
48173c55fa5SShaopeng Tan if (sigaction(SIGINT, &sigact, NULL) ||
48273c55fa5SShaopeng Tan sigaction(SIGTERM, &sigact, NULL) ||
48373c55fa5SShaopeng Tan sigaction(SIGHUP, &sigact, NULL)) {
484cc8ff7f5SIlpo Järvinen ksft_perror("sigaction");
48573c55fa5SShaopeng Tan ret = -1;
48673c55fa5SShaopeng Tan }
48773c55fa5SShaopeng Tan return ret;
48873c55fa5SShaopeng Tan }
48973c55fa5SShaopeng Tan
49073c55fa5SShaopeng Tan /*
49173c55fa5SShaopeng Tan * Reset signal handler to SIG_DFL.
49273c55fa5SShaopeng Tan * Non-Value return because the caller should keep
49373c55fa5SShaopeng Tan * the error code of other path even if sigaction fails.
49473c55fa5SShaopeng Tan */
signal_handler_unregister(void)49573c55fa5SShaopeng Tan void signal_handler_unregister(void)
49673c55fa5SShaopeng Tan {
497beb7f471SIlpo Järvinen struct sigaction sigact = {};
49873c55fa5SShaopeng Tan
499e6487230SMaciej Wieczor-Retman current_test = NULL;
50073c55fa5SShaopeng Tan sigact.sa_handler = SIG_DFL;
50173c55fa5SShaopeng Tan sigemptyset(&sigact.sa_mask);
50273c55fa5SShaopeng Tan if (sigaction(SIGINT, &sigact, NULL) ||
50373c55fa5SShaopeng Tan sigaction(SIGTERM, &sigact, NULL) ||
50473c55fa5SShaopeng Tan sigaction(SIGHUP, &sigact, NULL)) {
505cc8ff7f5SIlpo Järvinen ksft_perror("sigaction");
50673c55fa5SShaopeng Tan }
50773c55fa5SShaopeng Tan }
50873c55fa5SShaopeng Tan
parent_exit(pid_t ppid)509b0bd742aSIlpo Järvinen static void parent_exit(pid_t ppid)
510b0bd742aSIlpo Järvinen {
511b0bd742aSIlpo Järvinen kill(ppid, SIGKILL);
512b0bd742aSIlpo Järvinen umount_resctrlfs();
513b0bd742aSIlpo Järvinen exit(EXIT_FAILURE);
514b0bd742aSIlpo Järvinen }
515b0bd742aSIlpo Järvinen
51673c55fa5SShaopeng Tan /*
5177f4d257eSSai Praneeth Prakhya * print_results_bw: the memory bandwidth results are stored in a file
5187f4d257eSSai Praneeth Prakhya * @filename: file that stores the results
5197f4d257eSSai Praneeth Prakhya * @bm_pid: child pid that runs benchmark
5207f4d257eSSai Praneeth Prakhya * @bw_imc: perf imc counter value
5217f4d257eSSai Praneeth Prakhya * @bw_resc: memory bandwidth value
5227f4d257eSSai Praneeth Prakhya *
523c90fba60SIlpo Järvinen * Return: 0 on success, < 0 on error.
5247f4d257eSSai Praneeth Prakhya */
print_results_bw(char * filename,pid_t bm_pid,float bw_imc,unsigned long bw_resc)5258245a70eSIlpo Järvinen static int print_results_bw(char *filename, pid_t bm_pid, float bw_imc,
5267f4d257eSSai Praneeth Prakhya unsigned long bw_resc)
5277f4d257eSSai Praneeth Prakhya {
5287f4d257eSSai Praneeth Prakhya unsigned long diff = fabs(bw_imc - bw_resc);
5297f4d257eSSai Praneeth Prakhya FILE *fp;
5307f4d257eSSai Praneeth Prakhya
5317f4d257eSSai Praneeth Prakhya if (strcmp(filename, "stdio") == 0 || strcmp(filename, "stderr") == 0) {
5328245a70eSIlpo Järvinen printf("Pid: %d \t Mem_BW_iMC: %f \t ", (int)bm_pid, bw_imc);
5337f4d257eSSai Praneeth Prakhya printf("Mem_BW_resc: %lu \t Difference: %lu\n", bw_resc, diff);
5347f4d257eSSai Praneeth Prakhya } else {
5357f4d257eSSai Praneeth Prakhya fp = fopen(filename, "a");
5367f4d257eSSai Praneeth Prakhya if (!fp) {
537cc8ff7f5SIlpo Järvinen ksft_perror("Cannot open results file");
5387f4d257eSSai Praneeth Prakhya
539c90fba60SIlpo Järvinen return -1;
5407f4d257eSSai Praneeth Prakhya }
5417f4d257eSSai Praneeth Prakhya if (fprintf(fp, "Pid: %d \t Mem_BW_iMC: %f \t Mem_BW_resc: %lu \t Difference: %lu\n",
5428245a70eSIlpo Järvinen (int)bm_pid, bw_imc, bw_resc, diff) <= 0) {
543cc8ff7f5SIlpo Järvinen ksft_print_msg("Could not log results\n");
5447f4d257eSSai Praneeth Prakhya fclose(fp);
5457f4d257eSSai Praneeth Prakhya
546c90fba60SIlpo Järvinen return -1;
5477f4d257eSSai Praneeth Prakhya }
5487f4d257eSSai Praneeth Prakhya fclose(fp);
5497f4d257eSSai Praneeth Prakhya }
5507f4d257eSSai Praneeth Prakhya
5517f4d257eSSai Praneeth Prakhya return 0;
5527f4d257eSSai Praneeth Prakhya }
5537f4d257eSSai Praneeth Prakhya
554da50de0aSIlpo Järvinen /*
555bc074b63SIlpo Järvinen * measure_mem_bw - Measures memory bandwidth numbers while benchmark runs
556bc074b63SIlpo Järvinen * @uparams: User supplied parameters
557bc074b63SIlpo Järvinen * @param: Parameters passed to resctrl_val()
558bc074b63SIlpo Järvinen * @bm_pid: PID that runs the benchmark
559fa1116d0SIlpo Järvinen * @bw_report: Bandwidth report type (reads, writes)
560bc074b63SIlpo Järvinen *
561da50de0aSIlpo Järvinen * Measure memory bandwidth from resctrl and from another source which is
562da50de0aSIlpo Järvinen * perf imc value or could be something else if perf imc event is not
563da50de0aSIlpo Järvinen * available. Compare the two values to validate resctrl value. It takes
564da50de0aSIlpo Järvinen * 1 sec to measure the data.
565da50de0aSIlpo Järvinen */
measure_mem_bw(const struct user_params * uparams,struct resctrl_val_param * param,pid_t bm_pid,const char * bw_report)5660e251816SIlpo Järvinen int measure_mem_bw(const struct user_params *uparams,
567fa1116d0SIlpo Järvinen struct resctrl_val_param *param, pid_t bm_pid,
568fa1116d0SIlpo Järvinen const char *bw_report)
5697f4d257eSSai Praneeth Prakhya {
570da50de0aSIlpo Järvinen unsigned long bw_resc, bw_resc_start, bw_resc_end;
571da50de0aSIlpo Järvinen FILE *mem_bw_fp;
5721205b688SFenghua Yu float bw_imc;
5737f4d257eSSai Praneeth Prakhya int ret;
5747f4d257eSSai Praneeth Prakhya
575fa1116d0SIlpo Järvinen bw_report = get_bw_report_type(bw_report);
576fa1116d0SIlpo Järvinen if (!bw_report)
577fa1116d0SIlpo Järvinen return -1;
578fa1116d0SIlpo Järvinen
579da50de0aSIlpo Järvinen mem_bw_fp = open_mem_bw_resctrl(mbm_total_path);
580da50de0aSIlpo Järvinen if (!mem_bw_fp)
581da50de0aSIlpo Järvinen return -1;
582da50de0aSIlpo Järvinen
583da50de0aSIlpo Järvinen ret = perf_open_imc_mem_bw(uparams->cpu);
5841205b688SFenghua Yu if (ret < 0)
585da50de0aSIlpo Järvinen goto close_fp;
5867f4d257eSSai Praneeth Prakhya
587da50de0aSIlpo Järvinen ret = get_mem_bw_resctrl(mem_bw_fp, &bw_resc_start);
5881205b688SFenghua Yu if (ret < 0)
589da50de0aSIlpo Järvinen goto close_imc;
590da50de0aSIlpo Järvinen
591da50de0aSIlpo Järvinen rewind(mem_bw_fp);
592da50de0aSIlpo Järvinen
593da50de0aSIlpo Järvinen do_imc_mem_bw_test();
594da50de0aSIlpo Järvinen
595da50de0aSIlpo Järvinen ret = get_mem_bw_resctrl(mem_bw_fp, &bw_resc_end);
596da50de0aSIlpo Järvinen if (ret < 0)
597da50de0aSIlpo Järvinen goto close_imc;
598da50de0aSIlpo Järvinen
599fa1116d0SIlpo Järvinen ret = get_mem_bw_imc(bw_report, &bw_imc);
600da50de0aSIlpo Järvinen if (ret < 0)
601da50de0aSIlpo Järvinen goto close_imc;
602da50de0aSIlpo Järvinen
603da50de0aSIlpo Järvinen perf_close_imc_mem_bw();
604da50de0aSIlpo Järvinen fclose(mem_bw_fp);
605da50de0aSIlpo Järvinen
606da50de0aSIlpo Järvinen bw_resc = (bw_resc_end - bw_resc_start) / MB;
607da50de0aSIlpo Järvinen
608da50de0aSIlpo Järvinen return print_results_bw(param->filename, bm_pid, bw_imc, bw_resc);
609da50de0aSIlpo Järvinen
610da50de0aSIlpo Järvinen close_imc:
611da50de0aSIlpo Järvinen perf_close_imc_mem_bw();
612da50de0aSIlpo Järvinen close_fp:
613da50de0aSIlpo Järvinen fclose(mem_bw_fp);
6141205b688SFenghua Yu return ret;
6157f4d257eSSai Praneeth Prakhya }
6167f4d257eSSai Praneeth Prakhya
6177f4d257eSSai Praneeth Prakhya /*
618508934b5SMaciej Wieczor-Retman * run_benchmark - Run a specified benchmark or fill_buf (default benchmark)
619508934b5SMaciej Wieczor-Retman * in specified signal. Direct benchmark stdio to /dev/null.
620508934b5SMaciej Wieczor-Retman * @signum: signal number
621508934b5SMaciej Wieczor-Retman * @info: signal info
622508934b5SMaciej Wieczor-Retman * @ucontext: user context in signal handling
623508934b5SMaciej Wieczor-Retman */
run_benchmark(int signum,siginfo_t * info,void * ucontext)624508934b5SMaciej Wieczor-Retman static void run_benchmark(int signum, siginfo_t *info, void *ucontext)
625508934b5SMaciej Wieczor-Retman {
626508934b5SMaciej Wieczor-Retman int operation, ret, memflush;
627508934b5SMaciej Wieczor-Retman char **benchmark_cmd;
628508934b5SMaciej Wieczor-Retman size_t span;
629508934b5SMaciej Wieczor-Retman bool once;
630508934b5SMaciej Wieczor-Retman FILE *fp;
631508934b5SMaciej Wieczor-Retman
632508934b5SMaciej Wieczor-Retman benchmark_cmd = info->si_ptr;
633508934b5SMaciej Wieczor-Retman
634508934b5SMaciej Wieczor-Retman /*
635508934b5SMaciej Wieczor-Retman * Direct stdio of child to /dev/null, so that only parent writes to
636508934b5SMaciej Wieczor-Retman * stdio (console)
637508934b5SMaciej Wieczor-Retman */
638508934b5SMaciej Wieczor-Retman fp = freopen("/dev/null", "w", stdout);
639cc8ff7f5SIlpo Järvinen if (!fp) {
640cc8ff7f5SIlpo Järvinen ksft_perror("Unable to direct benchmark status to /dev/null");
641b0bd742aSIlpo Järvinen parent_exit(ppid);
642cc8ff7f5SIlpo Järvinen }
643508934b5SMaciej Wieczor-Retman
644508934b5SMaciej Wieczor-Retman if (strcmp(benchmark_cmd[0], "fill_buf") == 0) {
645508934b5SMaciej Wieczor-Retman /* Execute default fill_buf benchmark */
646508934b5SMaciej Wieczor-Retman span = strtoul(benchmark_cmd[1], NULL, 10);
647508934b5SMaciej Wieczor-Retman memflush = atoi(benchmark_cmd[2]);
648508934b5SMaciej Wieczor-Retman operation = atoi(benchmark_cmd[3]);
649cc8ff7f5SIlpo Järvinen if (!strcmp(benchmark_cmd[4], "true")) {
650508934b5SMaciej Wieczor-Retman once = true;
651cc8ff7f5SIlpo Järvinen } else if (!strcmp(benchmark_cmd[4], "false")) {
652508934b5SMaciej Wieczor-Retman once = false;
653cc8ff7f5SIlpo Järvinen } else {
654cc8ff7f5SIlpo Järvinen ksft_print_msg("Invalid once parameter\n");
655b0bd742aSIlpo Järvinen parent_exit(ppid);
656cc8ff7f5SIlpo Järvinen }
657508934b5SMaciej Wieczor-Retman
658508934b5SMaciej Wieczor-Retman if (run_fill_buf(span, memflush, operation, once))
659508934b5SMaciej Wieczor-Retman fprintf(stderr, "Error in running fill buffer\n");
660508934b5SMaciej Wieczor-Retman } else {
661508934b5SMaciej Wieczor-Retman /* Execute specified benchmark */
662508934b5SMaciej Wieczor-Retman ret = execvp(benchmark_cmd[0], benchmark_cmd);
663508934b5SMaciej Wieczor-Retman if (ret)
664cc8ff7f5SIlpo Järvinen ksft_perror("execvp");
665508934b5SMaciej Wieczor-Retman }
666508934b5SMaciej Wieczor-Retman
667508934b5SMaciej Wieczor-Retman fclose(stdout);
668cc8ff7f5SIlpo Järvinen ksft_print_msg("Unable to run specified benchmark\n");
669b0bd742aSIlpo Järvinen parent_exit(ppid);
670508934b5SMaciej Wieczor-Retman }
671508934b5SMaciej Wieczor-Retman
672508934b5SMaciej Wieczor-Retman /*
6737f4d257eSSai Praneeth Prakhya * resctrl_val: execute benchmark and measure memory bandwidth on
6747f4d257eSSai Praneeth Prakhya * the benchmark
675ca160887SIlpo Järvinen * @test: test information structure
67615f29882SIlpo Järvinen * @uparams: user supplied parameters
6777f4d257eSSai Praneeth Prakhya * @benchmark_cmd: benchmark command and its arguments
6787f4d257eSSai Praneeth Prakhya * @param: parameters passed to resctrl_val()
6797f4d257eSSai Praneeth Prakhya *
680c90fba60SIlpo Järvinen * Return: 0 when the test was run, < 0 on error.
6817f4d257eSSai Praneeth Prakhya */
resctrl_val(const struct resctrl_test * test,const struct user_params * uparams,const char * const * benchmark_cmd,struct resctrl_val_param * param)682ca160887SIlpo Järvinen int resctrl_val(const struct resctrl_test *test,
683ca160887SIlpo Järvinen const struct user_params *uparams,
684ca160887SIlpo Järvinen const char * const *benchmark_cmd,
68515f29882SIlpo Järvinen struct resctrl_val_param *param)
6867f4d257eSSai Praneeth Prakhya {
6877f4d257eSSai Praneeth Prakhya struct sigaction sigact;
6887f4d257eSSai Praneeth Prakhya int ret = 0, pipefd[2];
6897f4d257eSSai Praneeth Prakhya char pipe_message = 0;
6907f4d257eSSai Praneeth Prakhya union sigval value;
6919224db51SIlpo Järvinen int domain_id;
6927f4d257eSSai Praneeth Prakhya
6937f4d257eSSai Praneeth Prakhya if (strcmp(param->filename, "") == 0)
6947f4d257eSSai Praneeth Prakhya sprintf(param->filename, "stdio");
6957f4d257eSSai Praneeth Prakhya
6969224db51SIlpo Järvinen ret = get_domain_id(test->resource, uparams->cpu, &domain_id);
6979224db51SIlpo Järvinen if (ret < 0) {
6989224db51SIlpo Järvinen ksft_print_msg("Could not get domain ID\n");
6999224db51SIlpo Järvinen return ret;
7009224db51SIlpo Järvinen }
7019224db51SIlpo Järvinen
7027f4d257eSSai Praneeth Prakhya /*
7037f4d257eSSai Praneeth Prakhya * If benchmark wasn't successfully started by child, then child should
7047f4d257eSSai Praneeth Prakhya * kill parent, so save parent's pid
7057f4d257eSSai Praneeth Prakhya */
7067f4d257eSSai Praneeth Prakhya ppid = getpid();
7077f4d257eSSai Praneeth Prakhya
7087f4d257eSSai Praneeth Prakhya if (pipe(pipefd)) {
709cc8ff7f5SIlpo Järvinen ksft_perror("Unable to create pipe");
7107f4d257eSSai Praneeth Prakhya
7117f4d257eSSai Praneeth Prakhya return -1;
7127f4d257eSSai Praneeth Prakhya }
7137f4d257eSSai Praneeth Prakhya
7147f4d257eSSai Praneeth Prakhya /*
7157f4d257eSSai Praneeth Prakhya * Fork to start benchmark, save child's pid so that it can be killed
7167f4d257eSSai Praneeth Prakhya * when needed
7177f4d257eSSai Praneeth Prakhya */
718a080b6e7SShaopeng Tan fflush(stdout);
7197f4d257eSSai Praneeth Prakhya bm_pid = fork();
7207f4d257eSSai Praneeth Prakhya if (bm_pid == -1) {
721cc8ff7f5SIlpo Järvinen ksft_perror("Unable to fork");
7227f4d257eSSai Praneeth Prakhya
7237f4d257eSSai Praneeth Prakhya return -1;
7247f4d257eSSai Praneeth Prakhya }
7257f4d257eSSai Praneeth Prakhya
7267f4d257eSSai Praneeth Prakhya if (bm_pid == 0) {
7277f4d257eSSai Praneeth Prakhya /*
7287f4d257eSSai Praneeth Prakhya * Mask all signals except SIGUSR1, parent uses SIGUSR1 to
7297f4d257eSSai Praneeth Prakhya * start benchmark
7307f4d257eSSai Praneeth Prakhya */
7317f4d257eSSai Praneeth Prakhya sigfillset(&sigact.sa_mask);
7327f4d257eSSai Praneeth Prakhya sigdelset(&sigact.sa_mask, SIGUSR1);
7337f4d257eSSai Praneeth Prakhya
7347f4d257eSSai Praneeth Prakhya sigact.sa_sigaction = run_benchmark;
7357f4d257eSSai Praneeth Prakhya sigact.sa_flags = SA_SIGINFO;
7367f4d257eSSai Praneeth Prakhya
7377f4d257eSSai Praneeth Prakhya /* Register for "SIGUSR1" signal from parent */
738cc8ff7f5SIlpo Järvinen if (sigaction(SIGUSR1, &sigact, NULL)) {
739cc8ff7f5SIlpo Järvinen ksft_perror("Can't register child for signal");
740b0bd742aSIlpo Järvinen parent_exit(ppid);
741cc8ff7f5SIlpo Järvinen }
7427f4d257eSSai Praneeth Prakhya
7437f4d257eSSai Praneeth Prakhya /* Tell parent that child is ready */
7447f4d257eSSai Praneeth Prakhya close(pipefd[0]);
7457f4d257eSSai Praneeth Prakhya pipe_message = 1;
7467f4d257eSSai Praneeth Prakhya if (write(pipefd[1], &pipe_message, sizeof(pipe_message)) <
7477f4d257eSSai Praneeth Prakhya sizeof(pipe_message)) {
748cc8ff7f5SIlpo Järvinen ksft_perror("Failed signaling parent process");
7497f4d257eSSai Praneeth Prakhya close(pipefd[1]);
7507f4d257eSSai Praneeth Prakhya return -1;
7517f4d257eSSai Praneeth Prakhya }
7527f4d257eSSai Praneeth Prakhya close(pipefd[1]);
7537f4d257eSSai Praneeth Prakhya
7547f4d257eSSai Praneeth Prakhya /* Suspend child until delivery of "SIGUSR1" from parent */
7557f4d257eSSai Praneeth Prakhya sigsuspend(&sigact.sa_mask);
7567f4d257eSSai Praneeth Prakhya
757cc8ff7f5SIlpo Järvinen ksft_perror("Child is done");
758b0bd742aSIlpo Järvinen parent_exit(ppid);
7597f4d257eSSai Praneeth Prakhya }
7607f4d257eSSai Praneeth Prakhya
7618245a70eSIlpo Järvinen ksft_print_msg("Benchmark PID: %d\n", (int)bm_pid);
7627f4d257eSSai Praneeth Prakhya
763e33cb570SIlpo Järvinen /*
764e33cb570SIlpo Järvinen * The cast removes constness but nothing mutates benchmark_cmd within
765e33cb570SIlpo Järvinen * the context of this process. At the receiving process, it becomes
766e33cb570SIlpo Järvinen * argv, which is mutable, on exec() but that's after fork() so it
767e33cb570SIlpo Järvinen * doesn't matter for the process running the tests.
768e33cb570SIlpo Järvinen */
769e33cb570SIlpo Järvinen value.sival_ptr = (void *)benchmark_cmd;
7707f4d257eSSai Praneeth Prakhya
7717f4d257eSSai Praneeth Prakhya /* Taskset benchmark to specified cpu */
77215f29882SIlpo Järvinen ret = taskset_benchmark(bm_pid, uparams->cpu, NULL);
7737f4d257eSSai Praneeth Prakhya if (ret)
7743aff5146SIlpo Järvinen goto out;
7757f4d257eSSai Praneeth Prakhya
7767f4d257eSSai Praneeth Prakhya /* Write benchmark to specified control&monitoring grp in resctrl FS */
777*0d66ddb2SIlpo Järvinen ret = write_bm_pid_to_resctrl(bm_pid, param->ctrlgrp, param->mongrp);
7787f4d257eSSai Praneeth Prakhya if (ret)
7793aff5146SIlpo Järvinen goto out;
7807f4d257eSSai Praneeth Prakhya
781aef5efa6SIlpo Järvinen if (param->init) {
782aef5efa6SIlpo Järvinen ret = param->init(param, domain_id);
7837f4d257eSSai Praneeth Prakhya if (ret)
7843aff5146SIlpo Järvinen goto out;
785aef5efa6SIlpo Järvinen }
7867f4d257eSSai Praneeth Prakhya
7877f4d257eSSai Praneeth Prakhya /* Parent waits for child to be ready. */
7887f4d257eSSai Praneeth Prakhya close(pipefd[1]);
7897f4d257eSSai Praneeth Prakhya while (pipe_message != 1) {
7907f4d257eSSai Praneeth Prakhya if (read(pipefd[0], &pipe_message, sizeof(pipe_message)) <
7917f4d257eSSai Praneeth Prakhya sizeof(pipe_message)) {
792cc8ff7f5SIlpo Järvinen ksft_perror("Failed reading message from child process");
7937f4d257eSSai Praneeth Prakhya close(pipefd[0]);
7943aff5146SIlpo Järvinen goto out;
7957f4d257eSSai Praneeth Prakhya }
7967f4d257eSSai Praneeth Prakhya }
7977f4d257eSSai Praneeth Prakhya close(pipefd[0]);
7987f4d257eSSai Praneeth Prakhya
7997f4d257eSSai Praneeth Prakhya /* Signal child to start benchmark */
8007f4d257eSSai Praneeth Prakhya if (sigqueue(bm_pid, SIGUSR1, value) == -1) {
801cc8ff7f5SIlpo Järvinen ksft_perror("sigqueue SIGUSR1 to child");
802c90fba60SIlpo Järvinen ret = -1;
8033aff5146SIlpo Järvinen goto out;
8047f4d257eSSai Praneeth Prakhya }
8057f4d257eSSai Praneeth Prakhya
8067f4d257eSSai Praneeth Prakhya /* Give benchmark enough time to fully run */
8077f4d257eSSai Praneeth Prakhya sleep(1);
8087f4d257eSSai Praneeth Prakhya
8097f4d257eSSai Praneeth Prakhya /* Test runs until the callback setup() tells the test to stop. */
8107f4d257eSSai Praneeth Prakhya while (1) {
811ca160887SIlpo Järvinen ret = param->setup(test, uparams, param);
812fa10366cSIlpo Järvinen if (ret == END_OF_TESTS) {
8137f4d257eSSai Praneeth Prakhya ret = 0;
8147f4d257eSSai Praneeth Prakhya break;
8157f4d257eSSai Praneeth Prakhya }
816fa10366cSIlpo Järvinen if (ret < 0)
817fa10366cSIlpo Järvinen break;
8187f4d257eSSai Praneeth Prakhya
8190e251816SIlpo Järvinen ret = param->measure(uparams, param, bm_pid);
8207f4d257eSSai Praneeth Prakhya if (ret)
8217f4d257eSSai Praneeth Prakhya break;
8227f4d257eSSai Praneeth Prakhya }
8237f4d257eSSai Praneeth Prakhya
8247f4d257eSSai Praneeth Prakhya out:
8257f4d257eSSai Praneeth Prakhya kill(bm_pid, SIGKILL);
8267f4d257eSSai Praneeth Prakhya
8277f4d257eSSai Praneeth Prakhya return ret;
8287f4d257eSSai Praneeth Prakhya }
829