4 * Simple memcpy() and memset() benchmarks
6 * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
10 #include "../util/util.h"
11 #include "../util/parse-options.h"
12 #include "../util/header.h"
13 #include "../util/cloexec.h"
15 #include "mem-memcpy-arch.h"
16 #include "mem-memset-arch.h"
26 static const char *size_str = "1MB";
27 static const char *routine_str = "all";
28 static int iterations = 1;
29 static bool use_cycles;
32 static const struct option options[] = {
33 OPT_STRING('l', "size", &size_str, "1MB",
34 "Specify the size of the memory buffers. "
35 "Available units: B, KB, MB, GB and TB (upper and lower)"),
36 OPT_STRING('r', "routine", &routine_str, "all",
37 "Specify the routine to run, \"all\" runs all available routines"),
38 OPT_INTEGER('i', "iterations", &iterations,
39 "repeat memcpy() invocation this number of times"),
40 OPT_BOOLEAN('c', "cycles", &use_cycles,
41 "Use a cycles event instead of gettimeofday() to measure performance"),
45 typedef void *(*memcpy_t)(void *, const void *, size_t);
46 typedef void *(*memset_t)(void *, int, size_t);
57 struct routine memcpy_routines[] = {
59 .desc = "Default memcpy() provided by glibc",
60 .fn.memcpy = memcpy },
62 #ifdef HAVE_ARCH_X86_64_SUPPORT
63 # define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
64 # include "mem-memcpy-x86-64-asm-def.h"
71 static const char * const bench_mem_memcpy_usage[] = {
72 "perf bench mem memcpy <options>",
76 static struct perf_event_attr cycle_attr = {
77 .type = PERF_TYPE_HARDWARE,
78 .config = PERF_COUNT_HW_CPU_CYCLES
81 static void init_cycles(void)
83 cycles_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
85 if (cycles_fd < 0 && errno == ENOSYS)
86 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
88 BUG_ON(cycles_fd < 0);
91 static u64 get_cycles(void)
96 ret = read(cycles_fd, &clk, sizeof(u64));
97 BUG_ON(ret != sizeof(u64));
102 static double timeval2double(struct timeval *ts)
104 return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
107 #define print_bps(x) do { \
109 printf(" %14lf B/Sec\n", x); \
110 else if (x < K * K) \
111 printf(" %14lfd KB/Sec\n", x / K); \
112 else if (x < K * K * K) \
113 printf(" %14lf MB/Sec\n", x / K / K); \
115 printf(" %14lf GB/Sec\n", x / K / K / K); \
118 struct bench_mem_info {
119 const struct routine *routines;
120 u64 (*do_cycles)(const struct routine *r, size_t size);
121 double (*do_gettimeofday)(const struct routine *r, size_t size);
122 const char *const *usage;
125 static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
127 const struct routine *r = &info->routines[r_idx];
128 double result_bps = 0.0;
129 u64 result_cycles = 0;
131 printf("Routine %s (%s)\n", r->name, r->desc);
133 if (bench_format == BENCH_FORMAT_DEFAULT)
134 printf("# Copying %s Bytes ...\n\n", size_str);
137 result_cycles = info->do_cycles(r, size);
139 result_bps = info->do_gettimeofday(r, size);
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);
165 static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
171 argc = parse_options(argc, argv, options, info->usage, 0);
176 size = (size_t)perf_atoll((char *)size_str);
177 size_total = (double)size * iterations;
179 if ((s64)size <= 0) {
180 fprintf(stderr, "Invalid size:%s\n", size_str);
184 if (!strncmp(routine_str, "all", 3)) {
185 for (i = 0; info->routines[i].name; i++)
186 __bench_mem_routine(info, i, size, size_total);
190 for (i = 0; info->routines[i].name; i++) {
191 if (!strcmp(info->routines[i].name, routine_str))
194 if (!info->routines[i].name) {
195 printf("Unknown routine: %s\n", routine_str);
196 printf("Available routines...\n");
197 for (i = 0; info->routines[i].name; i++) {
198 printf("\t%s ... %s\n",
199 info->routines[i].name, info->routines[i].desc);
204 __bench_mem_routine(info, i, size, size_total);
209 static void memcpy_alloc_mem(void **dst, void **src, size_t size)
213 die("memory allocation failed - maybe size is too large?\n");
217 die("memory allocation failed - maybe size is too large?\n");
219 /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
220 memset(*src, 0, size);
223 static u64 do_memcpy_cycles(const struct routine *r, size_t size)
225 u64 cycle_start = 0ULL, cycle_end = 0ULL;
226 void *src = NULL, *dst = NULL;
227 memcpy_t fn = r->fn.memcpy;
230 memcpy_alloc_mem(&dst, &src, 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 < iterations; ++i)
241 cycle_end = get_cycles();
245 return cycle_end - cycle_start;
248 static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
250 struct timeval tv_start, tv_end, tv_diff;
251 memcpy_t fn = r->fn.memcpy;
252 void *src = NULL, *dst = NULL;
255 memcpy_alloc_mem(&dst, &src, size);
258 * We prefault the freshly allocated memory range here,
259 * to not measure page fault overhead:
263 BUG_ON(gettimeofday(&tv_start, NULL));
264 for (i = 0; i < iterations; ++i)
266 BUG_ON(gettimeofday(&tv_end, NULL));
268 timersub(&tv_end, &tv_start, &tv_diff);
273 return (double)(((double)size * iterations) / timeval2double(&tv_diff));
276 int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
278 struct bench_mem_info info = {
279 .routines = memcpy_routines,
280 .do_cycles = do_memcpy_cycles,
281 .do_gettimeofday = do_memcpy_gettimeofday,
282 .usage = bench_mem_memcpy_usage,
285 return bench_mem_common(argc, argv, &info);
288 static void memset_alloc_mem(void **dst, size_t size)
292 die("memory allocation failed - maybe size is too large?\n");
295 static u64 do_memset_cycles(const struct routine *r, size_t size)
297 u64 cycle_start = 0ULL, cycle_end = 0ULL;
298 memset_t fn = r->fn.memset;
302 memset_alloc_mem(&dst, size);
305 * We prefault the freshly allocated memory range here,
306 * to not measure page fault overhead:
310 cycle_start = get_cycles();
311 for (i = 0; i < iterations; ++i)
313 cycle_end = get_cycles();
316 return cycle_end - cycle_start;
319 static double do_memset_gettimeofday(const struct routine *r, size_t size)
321 struct timeval tv_start, tv_end, tv_diff;
322 memset_t fn = r->fn.memset;
326 memset_alloc_mem(&dst, size);
329 * We prefault the freshly allocated memory range here,
330 * to not measure page fault overhead:
334 BUG_ON(gettimeofday(&tv_start, NULL));
335 for (i = 0; i < iterations; ++i)
337 BUG_ON(gettimeofday(&tv_end, NULL));
339 timersub(&tv_end, &tv_start, &tv_diff);
342 return (double)(((double)size * iterations) / timeval2double(&tv_diff));
345 static const char * const bench_mem_memset_usage[] = {
346 "perf bench mem memset <options>",
350 static const struct routine memset_routines[] = {
352 .desc = "Default memset() provided by glibc",
353 .fn.memset = memset },
355 #ifdef HAVE_ARCH_X86_64_SUPPORT
356 # define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
357 # include "mem-memset-x86-64-asm-def.h"
364 int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
366 struct bench_mem_info info = {
367 .routines = memset_routines,
368 .do_cycles = do_memset_cycles,
369 .do_gettimeofday = do_memset_gettimeofday,
370 .usage = bench_mem_memset_usage,
373 return bench_mem_common(argc, argv, &info);