1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * fill_buf benchmark
4 *
5 * Copyright (C) 2018 Intel Corporation
6 *
7 * Authors:
8 * Sai Praneeth Prakhya <sai.praneeth.prakhya@intel.com>,
9 * Fenghua Yu <fenghua.yu@intel.com>
10 */
11 #include <stdio.h>
12 #include <unistd.h>
13 #include <stdlib.h>
14 #include <sys/types.h>
15 #include <sys/wait.h>
16 #include <inttypes.h>
17 #include <malloc.h>
18 #include <string.h>
19
20 #include "resctrl.h"
21
22 #define CL_SIZE (64)
23 #define PAGE_SIZE (4 * 1024)
24 #define MB (1024 * 1024)
25
26 static unsigned char *startptr;
27
sb(void)28 static void sb(void)
29 {
30 #if defined(__i386) || defined(__x86_64)
31 asm volatile("sfence\n\t"
32 : : : "memory");
33 #endif
34 }
35
ctrl_handler(int signo)36 static void ctrl_handler(int signo)
37 {
38 free(startptr);
39 printf("\nEnding\n");
40 sb();
41 exit(EXIT_SUCCESS);
42 }
43
cl_flush(void * p)44 static void cl_flush(void *p)
45 {
46 #if defined(__i386) || defined(__x86_64)
47 asm volatile("clflush (%0)\n\t"
48 : : "r"(p) : "memory");
49 #endif
50 }
51
mem_flush(void * p,size_t s)52 static void mem_flush(void *p, size_t s)
53 {
54 char *cp = (char *)p;
55 size_t i = 0;
56
57 s = s / CL_SIZE; /* mem size in cache llines */
58
59 for (i = 0; i < s; i++)
60 cl_flush(&cp[i * CL_SIZE]);
61
62 sb();
63 }
64
malloc_and_init_memory(size_t s)65 static void *malloc_and_init_memory(size_t s)
66 {
67 uint64_t *p64;
68 size_t s64;
69
70 void *p = memalign(PAGE_SIZE, s);
71
72 p64 = (uint64_t *)p;
73 s64 = s / sizeof(uint64_t);
74
75 while (s64 > 0) {
76 *p64 = (uint64_t)rand();
77 p64 += (CL_SIZE / sizeof(uint64_t));
78 s64 -= (CL_SIZE / sizeof(uint64_t));
79 }
80
81 return p;
82 }
83
fill_one_span_read(unsigned char * start_ptr,unsigned char * end_ptr)84 static int fill_one_span_read(unsigned char *start_ptr, unsigned char *end_ptr)
85 {
86 unsigned char sum, *p;
87
88 sum = 0;
89 p = start_ptr;
90 while (p < end_ptr) {
91 sum += *p;
92 p += (CL_SIZE / 2);
93 }
94
95 return sum;
96 }
97
98 static
fill_one_span_write(unsigned char * start_ptr,unsigned char * end_ptr)99 void fill_one_span_write(unsigned char *start_ptr, unsigned char *end_ptr)
100 {
101 unsigned char *p;
102
103 p = start_ptr;
104 while (p < end_ptr) {
105 *p = '1';
106 p += (CL_SIZE / 2);
107 }
108 }
109
fill_cache_read(unsigned char * start_ptr,unsigned char * end_ptr,char * resctrl_val)110 static int fill_cache_read(unsigned char *start_ptr, unsigned char *end_ptr,
111 char *resctrl_val)
112 {
113 int ret = 0;
114 FILE *fp;
115
116 while (1) {
117 ret = fill_one_span_read(start_ptr, end_ptr);
118 if (!strcmp(resctrl_val, "cat"))
119 break;
120 }
121
122 /* Consume read result so that reading memory is not optimized out. */
123 fp = fopen("/dev/null", "w");
124 if (!fp)
125 perror("Unable to write to /dev/null");
126 fprintf(fp, "Sum: %d ", ret);
127 fclose(fp);
128
129 return 0;
130 }
131
fill_cache_write(unsigned char * start_ptr,unsigned char * end_ptr,char * resctrl_val)132 static int fill_cache_write(unsigned char *start_ptr, unsigned char *end_ptr,
133 char *resctrl_val)
134 {
135 while (1) {
136 fill_one_span_write(start_ptr, end_ptr);
137 if (!strcmp(resctrl_val, "cat"))
138 break;
139 }
140
141 return 0;
142 }
143
144 static int
fill_cache(unsigned long long buf_size,int malloc_and_init,int memflush,int op,char * resctrl_val)145 fill_cache(unsigned long long buf_size, int malloc_and_init, int memflush,
146 int op, char *resctrl_val)
147 {
148 unsigned char *start_ptr, *end_ptr;
149 unsigned long long i;
150 int ret;
151
152 if (malloc_and_init)
153 start_ptr = malloc_and_init_memory(buf_size);
154 else
155 start_ptr = malloc(buf_size);
156
157 if (!start_ptr)
158 return -1;
159
160 startptr = start_ptr;
161 end_ptr = start_ptr + buf_size;
162
163 /*
164 * It's better to touch the memory once to avoid any compiler
165 * optimizations
166 */
167 if (!malloc_and_init) {
168 for (i = 0; i < buf_size; i++)
169 *start_ptr++ = (unsigned char)rand();
170 }
171
172 start_ptr = startptr;
173
174 /* Flush the memory before using to avoid "cache hot pages" effect */
175 if (memflush)
176 mem_flush(start_ptr, buf_size);
177
178 if (op == 0)
179 ret = fill_cache_read(start_ptr, end_ptr, resctrl_val);
180 else
181 ret = fill_cache_write(start_ptr, end_ptr, resctrl_val);
182
183 if (ret) {
184 printf("\n Error in fill cache read/write...\n");
185 return -1;
186 }
187
188 free(startptr);
189
190 return 0;
191 }
192
run_fill_buf(unsigned long span,int malloc_and_init_memory,int memflush,int op,char * resctrl_val)193 int run_fill_buf(unsigned long span, int malloc_and_init_memory,
194 int memflush, int op, char *resctrl_val)
195 {
196 unsigned long long cache_size = span;
197 int ret;
198
199 /* set up ctrl-c handler */
200 if (signal(SIGINT, ctrl_handler) == SIG_ERR)
201 printf("Failed to catch SIGINT!\n");
202 if (signal(SIGHUP, ctrl_handler) == SIG_ERR)
203 printf("Failed to catch SIGHUP!\n");
204
205 ret = fill_cache(cache_size, malloc_and_init_memory, memflush, op,
206 resctrl_val);
207 if (ret) {
208 printf("\n Error in fill cache\n");
209 return -1;
210 }
211
212 return 0;
213 }
214
