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 (case insensitive)"),
37 OPT_STRING('r', "routine", &routine_str, "all",
38 "Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
40 OPT_INTEGER('i', "iterations", &iterations,
41 "Repeat the function this number of times"),
43 OPT_BOOLEAN('c', "cycles", &use_cycles,
44 "Use a cycles event instead of gettimeofday() to measure performance"),
49 typedef void *(*memcpy_t)(void *, const void *, size_t);
50 typedef void *(*memset_t)(void *, int, size_t);
61 struct routine memcpy_routines[] = {
63 .desc = "Default memcpy() provided by glibc",
64 .fn.memcpy = memcpy },
66 #ifdef HAVE_ARCH_X86_64_SUPPORT
67 # define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
68 # include "mem-memcpy-x86-64-asm-def.h"
75 static const char * const bench_mem_memcpy_usage[] = {
76 "perf bench mem memcpy <options>",
80 static struct perf_event_attr cycle_attr = {
81 .type = PERF_TYPE_HARDWARE,
82 .config = PERF_COUNT_HW_CPU_CYCLES
85 static void init_cycles(void)
87 cycles_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
89 if (cycles_fd < 0 && errno == ENOSYS)
90 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
92 BUG_ON(cycles_fd < 0);
95 static u64 get_cycles(void)
100 ret = read(cycles_fd, &clk, sizeof(u64));
101 BUG_ON(ret != sizeof(u64));
106 static double timeval2double(struct timeval *ts)
108 return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
111 #define print_bps(x) do { \
113 printf(" %14lf bytes/sec\n", x); \
114 else if (x < K * K) \
115 printf(" %14lfd KB/sec\n", x / K); \
116 else if (x < K * K * K) \
117 printf(" %14lf MB/sec\n", x / K / K); \
119 printf(" %14lf GB/sec\n", x / K / K / K); \
122 struct bench_mem_info {
123 const struct routine *routines;
124 u64 (*do_cycles)(const struct routine *r, size_t size);
125 double (*do_gettimeofday)(const struct routine *r, size_t size);
126 const char *const *usage;
129 static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
131 const struct routine *r = &info->routines[r_idx];
132 double result_bps = 0.0;
133 u64 result_cycles = 0;
135 printf("# Routine '%s' (%s)\n", r->name, r->desc);
137 if (bench_format == BENCH_FORMAT_DEFAULT)
138 printf("# Copying %s bytes ...\n\n", size_str);
141 result_cycles = info->do_cycles(r, size);
143 result_bps = info->do_gettimeofday(r, size);
146 switch (bench_format) {
147 case BENCH_FORMAT_DEFAULT:
149 printf(" %14lf cycles/byte\n", (double)result_cycles/size_total);
151 print_bps(result_bps);
155 case BENCH_FORMAT_SIMPLE:
157 printf("%lf\n", (double)result_cycles/size_total);
159 printf("%lf\n", result_bps);
169 static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
175 argc = parse_options(argc, argv, options, info->usage, 0);
180 size = (size_t)perf_atoll((char *)size_str);
181 size_total = (double)size * iterations;
183 if ((s64)size <= 0) {
184 fprintf(stderr, "Invalid size:%s\n", size_str);
188 if (!strncmp(routine_str, "all", 3)) {
189 for (i = 0; info->routines[i].name; i++)
190 __bench_mem_routine(info, i, size, size_total);
194 for (i = 0; info->routines[i].name; i++) {
195 if (!strcmp(info->routines[i].name, routine_str))
198 if (!info->routines[i].name) {
199 if (strcmp(routine_str, "help") && strcmp(routine_str, "h"))
200 printf("Unknown routine: %s\n", routine_str);
201 printf("Available routines:\n");
202 for (i = 0; info->routines[i].name; i++) {
203 printf("\t%s ... %s\n",
204 info->routines[i].name, info->routines[i].desc);
209 __bench_mem_routine(info, i, size, size_total);
214 static void memcpy_alloc_mem(void **dst, void **src, size_t size)
218 die("memory allocation failed - maybe size is too large?\n");
222 die("memory allocation failed - maybe size is too large?\n");
224 /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
225 memset(*src, 0, size);
228 static u64 do_memcpy_cycles(const struct routine *r, size_t size)
230 u64 cycle_start = 0ULL, cycle_end = 0ULL;
231 void *src = NULL, *dst = NULL;
232 memcpy_t fn = r->fn.memcpy;
235 memcpy_alloc_mem(&dst, &src, size);
238 * We prefault the freshly allocated memory range here,
239 * to not measure page fault overhead:
243 cycle_start = get_cycles();
244 for (i = 0; i < iterations; ++i)
246 cycle_end = get_cycles();
250 return cycle_end - cycle_start;
253 static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
255 struct timeval tv_start, tv_end, tv_diff;
256 memcpy_t fn = r->fn.memcpy;
257 void *src = NULL, *dst = NULL;
260 memcpy_alloc_mem(&dst, &src, size);
263 * We prefault the freshly allocated memory range here,
264 * to not measure page fault overhead:
268 BUG_ON(gettimeofday(&tv_start, NULL));
269 for (i = 0; i < iterations; ++i)
271 BUG_ON(gettimeofday(&tv_end, NULL));
273 timersub(&tv_end, &tv_start, &tv_diff);
278 return (double)(((double)size * iterations) / timeval2double(&tv_diff));
281 int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
283 struct bench_mem_info info = {
284 .routines = memcpy_routines,
285 .do_cycles = do_memcpy_cycles,
286 .do_gettimeofday = do_memcpy_gettimeofday,
287 .usage = bench_mem_memcpy_usage,
290 return bench_mem_common(argc, argv, &info);
293 static void memset_alloc_mem(void **dst, size_t size)
297 die("memory allocation failed - maybe size is too large?\n");
300 static u64 do_memset_cycles(const struct routine *r, size_t size)
302 u64 cycle_start = 0ULL, cycle_end = 0ULL;
303 memset_t fn = r->fn.memset;
307 memset_alloc_mem(&dst, size);
310 * We prefault the freshly allocated memory range here,
311 * to not measure page fault overhead:
315 cycle_start = get_cycles();
316 for (i = 0; i < iterations; ++i)
318 cycle_end = get_cycles();
321 return cycle_end - cycle_start;
324 static double do_memset_gettimeofday(const struct routine *r, size_t size)
326 struct timeval tv_start, tv_end, tv_diff;
327 memset_t fn = r->fn.memset;
331 memset_alloc_mem(&dst, size);
334 * We prefault the freshly allocated memory range here,
335 * to not measure page fault overhead:
339 BUG_ON(gettimeofday(&tv_start, NULL));
340 for (i = 0; i < iterations; ++i)
342 BUG_ON(gettimeofday(&tv_end, NULL));
344 timersub(&tv_end, &tv_start, &tv_diff);
347 return (double)(((double)size * iterations) / timeval2double(&tv_diff));
350 static const char * const bench_mem_memset_usage[] = {
351 "perf bench mem memset <options>",
355 static const struct routine memset_routines[] = {
357 .desc = "Default memset() provided by glibc",
358 .fn.memset = memset },
360 #ifdef HAVE_ARCH_X86_64_SUPPORT
361 # define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
362 # include "mem-memset-x86-64-asm-def.h"
369 int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
371 struct bench_mem_info info = {
372 .routines = memset_routines,
373 .do_cycles = do_memset_cycles,
374 .do_gettimeofday = do_memset_gettimeofday,
375 .usage = bench_mem_memset_usage,
378 return bench_mem_common(argc, argv, &info);