4 * Simple memcpy() and memset() benchmarks
6 * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
11 #include "../util/util.h"
12 #include <subcmd/parse-options.h>
13 #include "../util/header.h"
14 #include "../util/cloexec.h"
16 #include "mem-memcpy-arch.h"
17 #include "mem-memset-arch.h"
24 #include <linux/time64.h>
28 static const char *size_str
= "1MB";
29 static const char *function_str
= "all";
30 static int nr_loops
= 1;
31 static bool use_cycles
;
34 static const struct option options
[] = {
35 OPT_STRING('s', "size", &size_str
, "1MB",
36 "Specify the size of the memory buffers. "
37 "Available units: B, KB, MB, GB and TB (case insensitive)"),
39 OPT_STRING('f', "function", &function_str
, "all",
40 "Specify the function to run, \"all\" runs all available functions, \"help\" lists them"),
42 OPT_INTEGER('l', "nr_loops", &nr_loops
,
43 "Specify the number of loops to run. (default: 1)"),
45 OPT_BOOLEAN('c', "cycles", &use_cycles
,
46 "Use a cycles event instead of gettimeofday() to measure performance"),
51 typedef void *(*memcpy_t
)(void *, const void *, size_t);
52 typedef void *(*memset_t
)(void *, int, size_t);
63 static struct perf_event_attr cycle_attr
= {
64 .type
= PERF_TYPE_HARDWARE
,
65 .config
= PERF_COUNT_HW_CPU_CYCLES
68 static int init_cycles(void)
70 cycles_fd
= sys_perf_event_open(&cycle_attr
, getpid(), -1, -1, perf_event_open_cloexec_flag());
72 if (cycles_fd
< 0 && errno
== ENOSYS
) {
73 pr_debug("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
80 static u64
get_cycles(void)
85 ret
= read(cycles_fd
, &clk
, sizeof(u64
));
86 BUG_ON(ret
!= sizeof(u64
));
91 static double timeval2double(struct timeval
*ts
)
93 return (double)ts
->tv_sec
+ (double)ts
->tv_usec
/ (double)USEC_PER_SEC
;
96 #define print_bps(x) do { \
98 printf(" %14lf bytes/sec\n", x); \
100 printf(" %14lfd KB/sec\n", x / K); \
101 else if (x < K * K * K) \
102 printf(" %14lf MB/sec\n", x / K / K); \
104 printf(" %14lf GB/sec\n", x / K / K / K); \
107 struct bench_mem_info
{
108 const struct function
*functions
;
109 u64 (*do_cycles
)(const struct function
*r
, size_t size
, void *src
, void *dst
);
110 double (*do_gettimeofday
)(const struct function
*r
, size_t size
, void *src
, void *dst
);
111 const char *const *usage
;
115 static void __bench_mem_function(struct bench_mem_info
*info
, int r_idx
, size_t size
, double size_total
)
117 const struct function
*r
= &info
->functions
[r_idx
];
118 double result_bps
= 0.0;
119 u64 result_cycles
= 0;
120 void *src
= NULL
, *dst
= zalloc(size
);
122 printf("# function '%s' (%s)\n", r
->name
, r
->desc
);
125 goto out_alloc_failed
;
127 if (info
->alloc_src
) {
130 goto out_alloc_failed
;
133 if (bench_format
== BENCH_FORMAT_DEFAULT
)
134 printf("# Copying %s bytes ...\n\n", size_str
);
137 result_cycles
= info
->do_cycles(r
, size
, src
, dst
);
139 result_bps
= info
->do_gettimeofday(r
, size
, src
, dst
);
142 switch (bench_format
) {
143 case BENCH_FORMAT_DEFAULT
:
145 printf(" %14lf cycles/byte\n", (double)result_cycles
/size_total
);
147 print_bps(result_bps
);
151 case BENCH_FORMAT_SIMPLE
:
153 printf("%lf\n", (double)result_cycles
/size_total
);
155 printf("%lf\n", result_bps
);
169 printf("# Memory allocation failed - maybe size (%s) is too large?\n", size_str
);
173 static int bench_mem_common(int argc
, const char **argv
, struct bench_mem_info
*info
)
179 argc
= parse_options(argc
, argv
, options
, info
->usage
, 0);
184 fprintf(stderr
, "Failed to open cycles counter\n");
189 size
= (size_t)perf_atoll((char *)size_str
);
190 size_total
= (double)size
* nr_loops
;
192 if ((s64
)size
<= 0) {
193 fprintf(stderr
, "Invalid size:%s\n", size_str
);
197 if (!strncmp(function_str
, "all", 3)) {
198 for (i
= 0; info
->functions
[i
].name
; i
++)
199 __bench_mem_function(info
, i
, size
, size_total
);
203 for (i
= 0; info
->functions
[i
].name
; i
++) {
204 if (!strcmp(info
->functions
[i
].name
, function_str
))
207 if (!info
->functions
[i
].name
) {
208 if (strcmp(function_str
, "help") && strcmp(function_str
, "h"))
209 printf("Unknown function: %s\n", function_str
);
210 printf("Available functions:\n");
211 for (i
= 0; info
->functions
[i
].name
; i
++) {
212 printf("\t%s ... %s\n",
213 info
->functions
[i
].name
, info
->functions
[i
].desc
);
218 __bench_mem_function(info
, i
, size
, size_total
);
223 static u64
do_memcpy_cycles(const struct function
*r
, size_t size
, void *src
, void *dst
)
225 u64 cycle_start
= 0ULL, cycle_end
= 0ULL;
226 memcpy_t fn
= r
->fn
.memcpy
;
229 /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
230 memset(src
, 0, size
);
233 * We prefault the freshly allocated memory range here,
234 * to not measure page fault overhead:
238 cycle_start
= get_cycles();
239 for (i
= 0; i
< nr_loops
; ++i
)
241 cycle_end
= get_cycles();
243 return cycle_end
- cycle_start
;
246 static double do_memcpy_gettimeofday(const struct function
*r
, size_t size
, void *src
, void *dst
)
248 struct timeval tv_start
, tv_end
, tv_diff
;
249 memcpy_t fn
= r
->fn
.memcpy
;
253 * We prefault the freshly allocated memory range here,
254 * to not measure page fault overhead:
258 BUG_ON(gettimeofday(&tv_start
, NULL
));
259 for (i
= 0; i
< nr_loops
; ++i
)
261 BUG_ON(gettimeofday(&tv_end
, NULL
));
263 timersub(&tv_end
, &tv_start
, &tv_diff
);
265 return (double)(((double)size
* nr_loops
) / timeval2double(&tv_diff
));
268 struct function memcpy_functions
[] = {
270 .desc
= "Default memcpy() provided by glibc",
271 .fn
.memcpy
= memcpy
},
273 #ifdef HAVE_ARCH_X86_64_SUPPORT
274 # define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
275 # include "mem-memcpy-x86-64-asm-def.h"
282 static const char * const bench_mem_memcpy_usage
[] = {
283 "perf bench mem memcpy <options>",
287 int bench_mem_memcpy(int argc
, const char **argv
)
289 struct bench_mem_info info
= {
290 .functions
= memcpy_functions
,
291 .do_cycles
= do_memcpy_cycles
,
292 .do_gettimeofday
= do_memcpy_gettimeofday
,
293 .usage
= bench_mem_memcpy_usage
,
297 return bench_mem_common(argc
, argv
, &info
);
300 static u64
do_memset_cycles(const struct function
*r
, size_t size
, void *src __maybe_unused
, void *dst
)
302 u64 cycle_start
= 0ULL, cycle_end
= 0ULL;
303 memset_t fn
= r
->fn
.memset
;
307 * We prefault the freshly allocated memory range here,
308 * to not measure page fault overhead:
312 cycle_start
= get_cycles();
313 for (i
= 0; i
< nr_loops
; ++i
)
315 cycle_end
= get_cycles();
317 return cycle_end
- cycle_start
;
320 static double do_memset_gettimeofday(const struct function
*r
, size_t size
, void *src __maybe_unused
, void *dst
)
322 struct timeval tv_start
, tv_end
, tv_diff
;
323 memset_t fn
= r
->fn
.memset
;
327 * We prefault the freshly allocated memory range here,
328 * to not measure page fault overhead:
332 BUG_ON(gettimeofday(&tv_start
, NULL
));
333 for (i
= 0; i
< nr_loops
; ++i
)
335 BUG_ON(gettimeofday(&tv_end
, NULL
));
337 timersub(&tv_end
, &tv_start
, &tv_diff
);
339 return (double)(((double)size
* nr_loops
) / timeval2double(&tv_diff
));
342 static const char * const bench_mem_memset_usage
[] = {
343 "perf bench mem memset <options>",
347 static const struct function memset_functions
[] = {
349 .desc
= "Default memset() provided by glibc",
350 .fn
.memset
= memset
},
352 #ifdef HAVE_ARCH_X86_64_SUPPORT
353 # define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
354 # include "mem-memset-x86-64-asm-def.h"
361 int bench_mem_memset(int argc
, const char **argv
)
363 struct bench_mem_info info
= {
364 .functions
= memset_functions
,
365 .do_cycles
= do_memset_cycles
,
366 .do_gettimeofday
= do_memset_gettimeofday
,
367 .usage
= bench_mem_memset_usage
,
370 return bench_mem_common(argc
, argv
, &info
);