1
2
3
4
5
6
7
8
9#include "debug.h"
10#include "../perf.h"
11#include "../util/util.h"
12#include <subcmd/parse-options.h>
13#include "../util/header.h"
14#include "../util/cloexec.h"
15#include "bench.h"
16#include "mem-memcpy-arch.h"
17#include "mem-memset-arch.h"
18
19#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22#include <sys/time.h>
23#include <errno.h>
24
25#define K 1024
26
27static const char *size_str = "1MB";
28static const char *function_str = "all";
29static int nr_loops = 1;
30static bool use_cycles;
31static int cycles_fd;
32
33static const struct option options[] = {
34 OPT_STRING('s', "size", &size_str, "1MB",
35 "Specify the size of the memory buffers. "
36 "Available units: B, KB, MB, GB and TB (case insensitive)"),
37
38 OPT_STRING('f', "function", &function_str, "all",
39 "Specify the function to run, \"all\" runs all available functions, \"help\" lists them"),
40
41 OPT_INTEGER('l', "nr_loops", &nr_loops,
42 "Specify the number of loops to run. (default: 1)"),
43
44 OPT_BOOLEAN('c', "cycles", &use_cycles,
45 "Use a cycles event instead of gettimeofday() to measure performance"),
46
47 OPT_END()
48};
49
50typedef void *(*memcpy_t)(void *, const void *, size_t);
51typedef void *(*memset_t)(void *, int, size_t);
52
53struct function {
54 const char *name;
55 const char *desc;
56 union {
57 memcpy_t memcpy;
58 memset_t memset;
59 } fn;
60};
61
62static struct perf_event_attr cycle_attr = {
63 .type = PERF_TYPE_HARDWARE,
64 .config = PERF_COUNT_HW_CPU_CYCLES
65};
66
67static int init_cycles(void)
68{
69 cycles_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
70
71 if (cycles_fd < 0 && errno == ENOSYS) {
72 pr_debug("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
73 return -1;
74 }
75
76 return cycles_fd;
77}
78
79static u64 get_cycles(void)
80{
81 int ret;
82 u64 clk;
83
84 ret = read(cycles_fd, &clk, sizeof(u64));
85 BUG_ON(ret != sizeof(u64));
86
87 return clk;
88}
89
90static double timeval2double(struct timeval *ts)
91{
92 return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
93}
94
95#define print_bps(x) do { \
96 if (x < K) \
97 printf(" %14lf bytes/sec\n", x); \
98 else if (x < K * K) \
99 printf(" %14lfd KB/sec\n", x / K); \
100 else if (x < K * K * K) \
101 printf(" %14lf MB/sec\n", x / K / K); \
102 else \
103 printf(" %14lf GB/sec\n", x / K / K / K); \
104 } while (0)
105
106struct bench_mem_info {
107 const struct function *functions;
108 u64 (*do_cycles)(const struct function *r, size_t size);
109 double (*do_gettimeofday)(const struct function *r, size_t size);
110 const char *const *usage;
111};
112
113static void __bench_mem_function(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
114{
115 const struct function *r = &info->functions[r_idx];
116 double result_bps = 0.0;
117 u64 result_cycles = 0;
118
119 printf("# function '%s' (%s)\n", r->name, r->desc);
120
121 if (bench_format == BENCH_FORMAT_DEFAULT)
122 printf("# Copying %s bytes ...\n\n", size_str);
123
124 if (use_cycles) {
125 result_cycles = info->do_cycles(r, size);
126 } else {
127 result_bps = info->do_gettimeofday(r, size);
128 }
129
130 switch (bench_format) {
131 case BENCH_FORMAT_DEFAULT:
132 if (use_cycles) {
133 printf(" %14lf cycles/byte\n", (double)result_cycles/size_total);
134 } else {
135 print_bps(result_bps);
136 }
137 break;
138
139 case BENCH_FORMAT_SIMPLE:
140 if (use_cycles) {
141 printf("%lf\n", (double)result_cycles/size_total);
142 } else {
143 printf("%lf\n", result_bps);
144 }
145 break;
146
147 default:
148 BUG_ON(1);
149 break;
150 }
151}
152
153static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
154{
155 int i;
156 size_t size;
157 double size_total;
158
159 argc = parse_options(argc, argv, options, info->usage, 0);
160
161 if (use_cycles) {
162 i = init_cycles();
163 if (i < 0) {
164 fprintf(stderr, "Failed to open cycles counter\n");
165 return i;
166 }
167 }
168
169 size = (size_t)perf_atoll((char *)size_str);
170 size_total = (double)size * nr_loops;
171
172 if ((s64)size <= 0) {
173 fprintf(stderr, "Invalid size:%s\n", size_str);
174 return 1;
175 }
176
177 if (!strncmp(function_str, "all", 3)) {
178 for (i = 0; info->functions[i].name; i++)
179 __bench_mem_function(info, i, size, size_total);
180 return 0;
181 }
182
183 for (i = 0; info->functions[i].name; i++) {
184 if (!strcmp(info->functions[i].name, function_str))
185 break;
186 }
187 if (!info->functions[i].name) {
188 if (strcmp(function_str, "help") && strcmp(function_str, "h"))
189 printf("Unknown function: %s\n", function_str);
190 printf("Available functions:\n");
191 for (i = 0; info->functions[i].name; i++) {
192 printf("\t%s ... %s\n",
193 info->functions[i].name, info->functions[i].desc);
194 }
195 return 1;
196 }
197
198 __bench_mem_function(info, i, size, size_total);
199
200 return 0;
201}
202
203static void memcpy_alloc_mem(void **dst, void **src, size_t size)
204{
205 *dst = zalloc(size);
206 if (!*dst)
207 die("memory allocation failed - maybe size is too large?\n");
208
209 *src = zalloc(size);
210 if (!*src)
211 die("memory allocation failed - maybe size is too large?\n");
212
213
214 memset(*src, 0, size);
215}
216
217static u64 do_memcpy_cycles(const struct function *r, size_t size)
218{
219 u64 cycle_start = 0ULL, cycle_end = 0ULL;
220 void *src = NULL, *dst = NULL;
221 memcpy_t fn = r->fn.memcpy;
222 int i;
223
224 memcpy_alloc_mem(&dst, &src, size);
225
226
227
228
229
230 fn(dst, src, size);
231
232 cycle_start = get_cycles();
233 for (i = 0; i < nr_loops; ++i)
234 fn(dst, src, size);
235 cycle_end = get_cycles();
236
237 free(src);
238 free(dst);
239 return cycle_end - cycle_start;
240}
241
242static double do_memcpy_gettimeofday(const struct function *r, size_t size)
243{
244 struct timeval tv_start, tv_end, tv_diff;
245 memcpy_t fn = r->fn.memcpy;
246 void *src = NULL, *dst = NULL;
247 int i;
248
249 memcpy_alloc_mem(&dst, &src, size);
250
251
252
253
254
255 fn(dst, src, size);
256
257 BUG_ON(gettimeofday(&tv_start, NULL));
258 for (i = 0; i < nr_loops; ++i)
259 fn(dst, src, size);
260 BUG_ON(gettimeofday(&tv_end, NULL));
261
262 timersub(&tv_end, &tv_start, &tv_diff);
263
264 free(src);
265 free(dst);
266
267 return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
268}
269
270struct function memcpy_functions[] = {
271 { .name = "default",
272 .desc = "Default memcpy() provided by glibc",
273 .fn.memcpy = memcpy },
274
275#ifdef HAVE_ARCH_X86_64_SUPPORT
276# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
277# include "mem-memcpy-x86-64-asm-def.h"
278# undef MEMCPY_FN
279#endif
280
281 { .name = NULL, }
282};
283
284static const char * const bench_mem_memcpy_usage[] = {
285 "perf bench mem memcpy <options>",
286 NULL
287};
288
289int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
290{
291 struct bench_mem_info info = {
292 .functions = memcpy_functions,
293 .do_cycles = do_memcpy_cycles,
294 .do_gettimeofday = do_memcpy_gettimeofday,
295 .usage = bench_mem_memcpy_usage,
296 };
297
298 return bench_mem_common(argc, argv, &info);
299}
300
301static void memset_alloc_mem(void **dst, size_t size)
302{
303 *dst = zalloc(size);
304 if (!*dst)
305 die("memory allocation failed - maybe size is too large?\n");
306}
307
308static u64 do_memset_cycles(const struct function *r, size_t size)
309{
310 u64 cycle_start = 0ULL, cycle_end = 0ULL;
311 memset_t fn = r->fn.memset;
312 void *dst = NULL;
313 int i;
314
315 memset_alloc_mem(&dst, size);
316
317
318
319
320
321 fn(dst, -1, size);
322
323 cycle_start = get_cycles();
324 for (i = 0; i < nr_loops; ++i)
325 fn(dst, i, size);
326 cycle_end = get_cycles();
327
328 free(dst);
329 return cycle_end - cycle_start;
330}
331
332static double do_memset_gettimeofday(const struct function *r, size_t size)
333{
334 struct timeval tv_start, tv_end, tv_diff;
335 memset_t fn = r->fn.memset;
336 void *dst = NULL;
337 int i;
338
339 memset_alloc_mem(&dst, size);
340
341
342
343
344
345 fn(dst, -1, size);
346
347 BUG_ON(gettimeofday(&tv_start, NULL));
348 for (i = 0; i < nr_loops; ++i)
349 fn(dst, i, size);
350 BUG_ON(gettimeofday(&tv_end, NULL));
351
352 timersub(&tv_end, &tv_start, &tv_diff);
353
354 free(dst);
355 return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
356}
357
358static const char * const bench_mem_memset_usage[] = {
359 "perf bench mem memset <options>",
360 NULL
361};
362
363static const struct function memset_functions[] = {
364 { .name = "default",
365 .desc = "Default memset() provided by glibc",
366 .fn.memset = memset },
367
368#ifdef HAVE_ARCH_X86_64_SUPPORT
369# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
370# include "mem-memset-x86-64-asm-def.h"
371# undef MEMSET_FN
372#endif
373
374 { .name = NULL, }
375};
376
377int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
378{
379 struct bench_mem_info info = {
380 .functions = memset_functions,
381 .do_cycles = do_memset_cycles,
382 .do_gettimeofday = do_memset_gettimeofday,
383 .usage = bench_mem_memset_usage,
384 };
385
386 return bench_mem_common(argc, argv, &info);
387}
388
