// SPDX-License-Identifier: GPL-2.0/* * fill_buf benchmark * * Copyright (C) 2018 Intel Corporation * * Authors: *    Sai Praneeth Prakhya <sai.praneeth.prakhya@intel.com>, *    Fenghua Yu <fenghua.yu@intel.com> */#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)	asm volatile("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)	asm volatile("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;} staticvoid 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);		if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)))			break;	} 	/* 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);		if (!strncmp(resctrl_val, CAT_STR, sizeof(CAT_STR)))			break;	} 	return 0;} static intfill_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 Error 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 Error in fill cache\n");		return -1;	} 	return 0;}