* [PATCH 01/14] perf/bench: Improve the 'perf bench mem memcpy' code readability
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:43 ` [tip:perf/core] perf bench: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem' Ingo Molnar
` (13 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Linus Torvalds, Andrew Morton,
Thomas Gleixner
- improve the readability of initializations
- fix unnecessary double negations
- fix ugly line breaks
- fix other small details
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-memcpy.c | 101 ++++++++++++++++++++++++++++----------------------------------
1 file changed, 45 insertions(+), 56 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index d3dfb7936dcd..27606ff5c4f9 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -1,7 +1,7 @@
/*
* mem-memcpy.c
*
- * memcpy: Simple memory copy in various ways
+ * Simple memcpy() and memset() benchmarks
*
* Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
*/
@@ -61,20 +61,17 @@ struct routine {
};
struct routine memcpy_routines[] = {
- { .name = "default",
- .desc = "Default memcpy() provided by glibc",
- .fn.memcpy = memcpy },
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-
-#define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
-#include "mem-memcpy-x86-64-asm-def.h"
-#undef MEMCPY_FN
+ { .name = "default",
+ .desc = "Default memcpy() provided by glibc",
+ .fn.memcpy = memcpy },
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
+# include "mem-memcpy-x86-64-asm-def.h"
+# undef MEMCPY_FN
#endif
- { NULL,
- NULL,
- {NULL} }
+ { NULL, }
};
static const char * const bench_mem_memcpy_usage[] = {
@@ -89,8 +86,7 @@ static struct perf_event_attr cycle_attr = {
static void init_cycle(void)
{
- cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1,
- perf_event_open_cloexec_flag());
+ cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
if (cycle_fd < 0 && errno == ENOSYS)
die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
@@ -111,12 +107,9 @@ static u64 get_cycle(void)
static double timeval2double(struct timeval *ts)
{
- return (double)ts->tv_sec +
- (double)ts->tv_usec / (double)1000000;
+ return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
}
-#define pf (no_prefault ? 0 : 1)
-
#define print_bps(x) do { \
if (x < K) \
printf(" %14lf B/Sec", x); \
@@ -140,6 +133,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
const struct routine *r = &info->routines[r_idx];
double result_bps[2];
u64 result_cycle[2];
+ int prefault = no_prefault ? 0 : 1;
result_cycle[0] = result_cycle[1] = 0ULL;
result_bps[0] = result_bps[1] = 0.0;
@@ -149,8 +143,8 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (!only_prefault && !no_prefault) {
- /* show both of results */
+ if (!only_prefault && prefault) {
+ /* Show both results: */
if (use_cycle) {
result_cycle[0] = info->do_cycle(r, len, false);
result_cycle[1] = info->do_cycle(r, len, true);
@@ -160,14 +154,14 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
} else {
if (use_cycle)
- result_cycle[pf] = info->do_cycle(r, len, only_prefault);
+ result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
else
- result_bps[pf] = info->do_gettimeofday(r, len, only_prefault);
+ result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (!only_prefault && !no_prefault) {
+ if (!only_prefault && prefault) {
if (use_cycle) {
printf(" %14lf Cycle/Byte\n",
(double)result_cycle[0]
@@ -184,16 +178,16 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
} else {
if (use_cycle) {
printf(" %14lf Cycle/Byte",
- (double)result_cycle[pf]
+ (double)result_cycle[prefault]
/ totallen);
} else
- print_bps(result_bps[pf]);
+ print_bps(result_bps[prefault]);
printf("%s\n", only_prefault ? " (with prefault)" : "");
}
break;
case BENCH_FORMAT_SIMPLE:
- if (!only_prefault && !no_prefault) {
+ if (!only_prefault && prefault) {
if (use_cycle) {
printf("%lf %lf\n",
(double)result_cycle[0] / totallen,
@@ -204,14 +198,14 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
} else {
if (use_cycle) {
- printf("%lf\n", (double)result_cycle[pf]
+ printf("%lf\n", (double)result_cycle[prefault]
/ totallen);
} else
- printf("%lf\n", result_bps[pf]);
+ printf("%lf\n", result_bps[prefault]);
}
break;
default:
- /* reaching this means there's some disaster: */
+ /* Reaching this means there's some disaster: */
die("unknown format: %d\n", bench_format);
break;
}
@@ -225,8 +219,7 @@ static int bench_mem_common(int argc, const char **argv,
size_t len;
double totallen;
- argc = parse_options(argc, argv, options,
- info->usage, 0);
+ argc = parse_options(argc, argv, options, info->usage, 0);
if (no_prefault && only_prefault) {
fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
@@ -244,7 +237,7 @@ static int bench_mem_common(int argc, const char **argv,
return 1;
}
- /* same to without specifying either of prefault and no-prefault */
+ /* Same as without specifying either of prefault and no-prefault: */
if (only_prefault && no_prefault)
only_prefault = no_prefault = false;
@@ -282,7 +275,8 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
*src = zalloc(length);
if (!*src)
die("memory allocation failed - maybe length is too large?\n");
- /* Make sure to always replace the zero pages even if MMAP_THRESH is crossed */
+
+ /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
memset(*src, 0, length);
}
@@ -308,8 +302,7 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len,
- bool prefault)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -337,10 +330,10 @@ int bench_mem_memcpy(int argc, const char **argv,
const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memcpy_routines,
- .do_cycle = do_memcpy_cycle,
- .do_gettimeofday = do_memcpy_gettimeofday,
- .usage = bench_mem_memcpy_usage,
+ .routines = memcpy_routines,
+ .do_cycle = do_memcpy_cycle,
+ .do_gettimeofday = do_memcpy_gettimeofday,
+ .usage = bench_mem_memcpy_usage,
};
return bench_mem_common(argc, argv, prefix, &info);
@@ -404,30 +397,26 @@ static const char * const bench_mem_memset_usage[] = {
};
static const struct routine memset_routines[] = {
- { .name ="default",
- .desc = "Default memset() provided by glibc",
- .fn.memset = memset },
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-
-#define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
-#include "mem-memset-x86-64-asm-def.h"
-#undef MEMSET_FN
+ { .name = "default",
+ .desc = "Default memset() provided by glibc",
+ .fn.memset = memset },
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
+# include "mem-memset-x86-64-asm-def.h"
+# undef MEMSET_FN
#endif
- { .name = NULL,
- .desc = NULL,
- .fn.memset = NULL }
+ { NULL, }
};
-int bench_mem_memset(int argc, const char **argv,
- const char *prefix __maybe_unused)
+int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memset_routines,
- .do_cycle = do_memset_cycle,
- .do_gettimeofday = do_memset_gettimeofday,
- .usage = bench_mem_memset_usage,
+ .routines = memset_routines,
+ .do_cycle = do_memset_cycle,
+ .do_gettimeofday = do_memset_gettimeofday,
+ .usage = bench_mem_memset_usage,
};
return bench_mem_common(argc, argv, prefix, &info);
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench: Improve the 'perf bench mem memcpy' code readability
2015-10-19 8:04 ` [PATCH 01/14] perf/bench: Improve the 'perf bench mem memcpy' code readability Ingo Molnar
@ 2015-10-20 7:43 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:43 UTC (permalink / raw)
To: linux-tip-commits
Cc: jolsa, hpa, akpm, mingo, acme, linux-kernel, peterz, dsahern,
namhyung, torvalds, tglx
Commit-ID: 13839ec495a31844d66d487f740c07771c60a0d0
Gitweb: http://git.kernel.org/tip/13839ec495a31844d66d487f740c07771c60a0d0
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:17 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 15:05:00 -0300
perf bench: Improve the 'perf bench mem memcpy' code readability
- improve the readability of initializations
- fix unnecessary double negations
- fix ugly line breaks
- fix other small details
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-2-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-memcpy.c | 101 +++++++++++++++++++-----------------------
1 file changed, 45 insertions(+), 56 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index d3dfb79..27606ff 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -1,7 +1,7 @@
/*
* mem-memcpy.c
*
- * memcpy: Simple memory copy in various ways
+ * Simple memcpy() and memset() benchmarks
*
* Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
*/
@@ -61,20 +61,17 @@ struct routine {
};
struct routine memcpy_routines[] = {
- { .name = "default",
- .desc = "Default memcpy() provided by glibc",
- .fn.memcpy = memcpy },
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-
-#define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
-#include "mem-memcpy-x86-64-asm-def.h"
-#undef MEMCPY_FN
+ { .name = "default",
+ .desc = "Default memcpy() provided by glibc",
+ .fn.memcpy = memcpy },
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
+# include "mem-memcpy-x86-64-asm-def.h"
+# undef MEMCPY_FN
#endif
- { NULL,
- NULL,
- {NULL} }
+ { NULL, }
};
static const char * const bench_mem_memcpy_usage[] = {
@@ -89,8 +86,7 @@ static struct perf_event_attr cycle_attr = {
static void init_cycle(void)
{
- cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1,
- perf_event_open_cloexec_flag());
+ cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
if (cycle_fd < 0 && errno == ENOSYS)
die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
@@ -111,12 +107,9 @@ static u64 get_cycle(void)
static double timeval2double(struct timeval *ts)
{
- return (double)ts->tv_sec +
- (double)ts->tv_usec / (double)1000000;
+ return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
}
-#define pf (no_prefault ? 0 : 1)
-
#define print_bps(x) do { \
if (x < K) \
printf(" %14lf B/Sec", x); \
@@ -140,6 +133,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
const struct routine *r = &info->routines[r_idx];
double result_bps[2];
u64 result_cycle[2];
+ int prefault = no_prefault ? 0 : 1;
result_cycle[0] = result_cycle[1] = 0ULL;
result_bps[0] = result_bps[1] = 0.0;
@@ -149,8 +143,8 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (!only_prefault && !no_prefault) {
- /* show both of results */
+ if (!only_prefault && prefault) {
+ /* Show both results: */
if (use_cycle) {
result_cycle[0] = info->do_cycle(r, len, false);
result_cycle[1] = info->do_cycle(r, len, true);
@@ -160,14 +154,14 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
} else {
if (use_cycle)
- result_cycle[pf] = info->do_cycle(r, len, only_prefault);
+ result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
else
- result_bps[pf] = info->do_gettimeofday(r, len, only_prefault);
+ result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (!only_prefault && !no_prefault) {
+ if (!only_prefault && prefault) {
if (use_cycle) {
printf(" %14lf Cycle/Byte\n",
(double)result_cycle[0]
@@ -184,16 +178,16 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
} else {
if (use_cycle) {
printf(" %14lf Cycle/Byte",
- (double)result_cycle[pf]
+ (double)result_cycle[prefault]
/ totallen);
} else
- print_bps(result_bps[pf]);
+ print_bps(result_bps[prefault]);
printf("%s\n", only_prefault ? " (with prefault)" : "");
}
break;
case BENCH_FORMAT_SIMPLE:
- if (!only_prefault && !no_prefault) {
+ if (!only_prefault && prefault) {
if (use_cycle) {
printf("%lf %lf\n",
(double)result_cycle[0] / totallen,
@@ -204,14 +198,14 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
} else {
if (use_cycle) {
- printf("%lf\n", (double)result_cycle[pf]
+ printf("%lf\n", (double)result_cycle[prefault]
/ totallen);
} else
- printf("%lf\n", result_bps[pf]);
+ printf("%lf\n", result_bps[prefault]);
}
break;
default:
- /* reaching this means there's some disaster: */
+ /* Reaching this means there's some disaster: */
die("unknown format: %d\n", bench_format);
break;
}
@@ -225,8 +219,7 @@ static int bench_mem_common(int argc, const char **argv,
size_t len;
double totallen;
- argc = parse_options(argc, argv, options,
- info->usage, 0);
+ argc = parse_options(argc, argv, options, info->usage, 0);
if (no_prefault && only_prefault) {
fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
@@ -244,7 +237,7 @@ static int bench_mem_common(int argc, const char **argv,
return 1;
}
- /* same to without specifying either of prefault and no-prefault */
+ /* Same as without specifying either of prefault and no-prefault: */
if (only_prefault && no_prefault)
only_prefault = no_prefault = false;
@@ -282,7 +275,8 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
*src = zalloc(length);
if (!*src)
die("memory allocation failed - maybe length is too large?\n");
- /* Make sure to always replace the zero pages even if MMAP_THRESH is crossed */
+
+ /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
memset(*src, 0, length);
}
@@ -308,8 +302,7 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len,
- bool prefault)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -337,10 +330,10 @@ int bench_mem_memcpy(int argc, const char **argv,
const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memcpy_routines,
- .do_cycle = do_memcpy_cycle,
- .do_gettimeofday = do_memcpy_gettimeofday,
- .usage = bench_mem_memcpy_usage,
+ .routines = memcpy_routines,
+ .do_cycle = do_memcpy_cycle,
+ .do_gettimeofday = do_memcpy_gettimeofday,
+ .usage = bench_mem_memcpy_usage,
};
return bench_mem_common(argc, argv, prefix, &info);
@@ -404,30 +397,26 @@ static const char * const bench_mem_memset_usage[] = {
};
static const struct routine memset_routines[] = {
- { .name ="default",
- .desc = "Default memset() provided by glibc",
- .fn.memset = memset },
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-
-#define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
-#include "mem-memset-x86-64-asm-def.h"
-#undef MEMSET_FN
+ { .name = "default",
+ .desc = "Default memset() provided by glibc",
+ .fn.memset = memset },
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
+# include "mem-memset-x86-64-asm-def.h"
+# undef MEMSET_FN
#endif
- { .name = NULL,
- .desc = NULL,
- .fn.memset = NULL }
+ { NULL, }
};
-int bench_mem_memset(int argc, const char **argv,
- const char *prefix __maybe_unused)
+int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memset_routines,
- .do_cycle = do_memset_cycle,
- .do_gettimeofday = do_memset_gettimeofday,
- .usage = bench_mem_memset_usage,
+ .routines = memset_routines,
+ .do_cycle = do_memset_cycle,
+ .do_gettimeofday = do_memset_gettimeofday,
+ .usage = bench_mem_memset_usage,
};
return bench_mem_common(argc, argv, prefix, &info);
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
2015-10-19 8:04 ` [PATCH 01/14] perf/bench: Improve the 'perf bench mem memcpy' code readability Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-19 15:21 ` Linus Torvalds
2015-10-20 7:43 ` [tip:perf/core] perf bench: Default to all routines in ' perf " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 03/14] perf/bench: Eliminate unused argument from bench_mem_common() Ingo Molnar
` (12 subsequent siblings)
14 siblings, 2 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So few people know that the --routine option to 'perf bench memcpy/memset' exists,
and would not know that it's capable of testing the kernel's memcpy/memset
implementations.
Furthermore, 'perf bench mem all' will not run all routines:
vega:~> perf bench mem all
# Running mem/memcpy benchmark...
Routine default (Default memcpy() provided by glibc)
# Copying 1MB Bytes ...
894.454383 MB/Sec
3.844734 GB/Sec (with prefault)
# Running mem/memset benchmark...
Routine default (Default memset() provided by glibc)
# Copying 1MB Bytes ...
1.220703 GB/Sec
9.042245 GB/Sec (with prefault)
Because misleadingly the 'all' refers to 'all sub-benchmarks', not 'all sub-benchmarks
and routines'.
Fix all this by making the memcpy/memset routine to default to 'all', which results in
all the benchmarks being run:
triton:~> perf bench mem all
# Running mem/memcpy benchmark...
Routine default (Default memcpy() provided by glibc)
# Copying 1MB Bytes ...
1.448906 GB/Sec
4.957170 GB/Sec (with prefault)
Routine x86-64-unrolled (unrolled memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.614153 GB/Sec
4.379204 GB/Sec (with prefault)
Routine x86-64-movsq (movsq-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.570036 GB/Sec
4.264465 GB/Sec (with prefault)
Routine x86-64-movsb (movsb-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.788576 GB/Sec
6.554111 GB/Sec (with prefault)
# Running mem/memset benchmark...
Routine default (Default memset() provided by glibc)
# Copying 1MB Bytes ...
2.082223 GB/Sec
9.126752 GB/Sec (with prefault)
Routine x86-64-unrolled (unrolled memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
5.710892 GB/Sec
8.346688 GB/Sec (with prefault)
Routine x86-64-stosq (movsq-based memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
9.765625 GB/Sec
12.520032 GB/Sec (with prefault)
Routine x86-64-stosb (movsb-based memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
9.668936 GB/Sec
12.682630 GB/Sec (with prefault)
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-memcpy.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 27606ff5c4f9..263f84171ae5 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *length_str = "1MB";
-static const char *routine = "default";
+static const char *routine = "all";
static int iterations = 1;
static bool use_cycle;
static int cycle_fd;
@@ -35,7 +35,7 @@ static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
"Specify length of memory to copy. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
- OPT_STRING('r', "routine", &routine, "default",
+ OPT_STRING('r', "routine", &routine, "all",
"Specify routine to copy, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem'
2015-10-19 8:04 ` [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem' Ingo Molnar
@ 2015-10-19 15:21 ` Linus Torvalds
2015-10-19 17:47 ` Ingo Molnar
2015-10-20 7:43 ` [tip:perf/core] perf bench: Default to all routines in ' perf " tip-bot for Ingo Molnar
1 sibling, 1 reply; 44+ messages in thread
From: Linus Torvalds @ 2015-10-19 15:21 UTC (permalink / raw)
To: Ingo Molnar
Cc: Linux Kernel Mailing List, Peter Zijlstra,
Arnaldo Carvalho de Melo, Namhyung Kim, David Ahern, Jiri Olsa,
Hitoshi Mitake, Thomas Gleixner
On Mon, Oct 19, 2015 at 1:04 AM, Ingo Molnar <mingo@kernel.org> wrote:
>
> triton:~> perf bench mem all
> # Running mem/memcpy benchmark...
> Routine default (Default memcpy() provided by glibc)
> 4.957170 GB/Sec (with prefault)
> Routine x86-64-unrolled (unrolled memcpy() in arch/x86/lib/memcpy_64.S)
> 4.379204 GB/Sec (with prefault)
> Routine x86-64-movsq (movsq-based memcpy() in arch/x86/lib/memcpy_64.S)
> 4.264465 GB/Sec (with prefault)
> Routine x86-64-movsb (movsb-based memcpy() in arch/x86/lib/memcpy_64.S)
> 6.554111 GB/Sec (with prefault)
Is this skylake? And why are the numbers so low? Even on my laptop
(Haswell), I get ~21GB/s (when setting cpufreq to performance).
It's interesting that 'movsb' for you is so much better. It's been
promising before, and it *should* be able to do better than manual
copying, but it's not been that noticeable on the machines I've
tested. But I haven't ued Skylake or Broadwell yet.
cpufreq might be making a difference too. Maybe it's just ramping up
the CPU? Or is that really repeatable?
Linus
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem'
2015-10-19 15:21 ` Linus Torvalds
@ 2015-10-19 17:47 ` Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 17:47 UTC (permalink / raw)
To: Linus Torvalds
Cc: Linux Kernel Mailing List, Peter Zijlstra,
Arnaldo Carvalho de Melo, Namhyung Kim, David Ahern, Jiri Olsa,
Hitoshi Mitake, Thomas Gleixner
* Linus Torvalds <torvalds@linux-foundation.org> wrote:
> On Mon, Oct 19, 2015 at 1:04 AM, Ingo Molnar <mingo@kernel.org> wrote:
> >
> > triton:~> perf bench mem all
> > # Running mem/memcpy benchmark...
> > Routine default (Default memcpy() provided by glibc)
> > 4.957170 GB/Sec (with prefault)
> > Routine x86-64-unrolled (unrolled memcpy() in arch/x86/lib/memcpy_64.S)
> > 4.379204 GB/Sec (with prefault)
> > Routine x86-64-movsq (movsq-based memcpy() in arch/x86/lib/memcpy_64.S)
> > 4.264465 GB/Sec (with prefault)
> > Routine x86-64-movsb (movsb-based memcpy() in arch/x86/lib/memcpy_64.S)
> > 6.554111 GB/Sec (with prefault)
>
> Is this skylake? And why are the numbers so low? Even on my laptop
> (Haswell), I get ~21GB/s (when setting cpufreq to performance).
No, this was on my desktop, which is a water cooled IvyBridge running at 3.6GHz:
processor : 11
vendor_id : GenuineIntel
cpu family : 6
model : 62
model name : Intel(R) Core(TM) i7-4960X CPU @ 3.60GHz
stepping : 4
microcode : 0x416
cpu MHz : 1303.031
cache size : 15360 KB
and I didn't really think about the validity of the numbers when I made the
changelog, as I rarely benchmark on this box, due to it having various desktop
loads running all the time.
AAs you noticed the results are highly variable with default settings:
triton:~/tip> taskset 1 perf stat --null --repeat 10 perf bench mem memcpy -f x86-64-movsb 2>&1 | grep GB
5.580357 GB/sec
5.580357 GB/sec
16.551907 GB/sec
16.551907 GB/sec
15.258789 GB/sec
16.837284 GB/sec
16.837284 GB/sec
16.837284 GB/sec
16.551907 GB/sec
16.837284 GB/sec
They get more reliable with '-l 10000' (10,000 loops instead of the default 1):
triton:~/tip> taskset 1 perf stat --null --repeat 10 perf bench mem memcpy -f x86-64-movsb -l 10000 2>&1 | grep GB
15.483591 GB/sec
16.975429 GB/sec
17.088396 GB/sec
20.920407 GB/sec
21.346655 GB/sec
21.322372 GB/sec
21.338306 GB/sec
21.342130 GB/sec
21.339984 GB/sec
21.373145 GB/sec
that's purely cached. Also note how after a few seconds it gets faster, due to
cpufreq as you suspected.
So once I fix the frequency of all cores to the max, I get much more reliable
results:
triton:~/tip> taskset 1 perf stat --null --repeat 10 perf bench mem memcpy -f x86-64-movsb -l 10000 2>&1 | grep -E 'GB|elaps'
21.356879 GB/sec
21.378526 GB/sec
21.351976 GB/sec
21.375203 GB/sec
21.369824 GB/sec
21.353236 GB/sec
21.283708 GB/sec
21.380679 GB/sec
21.347915 GB/sec
21.378572 GB/sec
0.459286278 seconds time elapsed ( +- 0.04% )
I'll add a debug check to 'perf bench' to warn about systems that have variable
cpufreq running - this is too easy a mistake to make :-/
So with the benchmark stabilized, I get the following results:
triton:~/tip> taskset 1 perf bench mem memcpy -f all -l 10000
# Running 'mem/memcpy' benchmark:
# function 'default' (Default memcpy() provided by glibc)
# Copying 1MB bytes ...
18.356783 GB/sec
# function 'x86-64-unrolled' (unrolled memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB bytes ...
16.294889 GB/sec
# function 'x86-64-movsq' (movsq-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB bytes ...
15.760032 GB/sec
# function 'x86-64-movsb' (movsb-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB bytes ...
21.145818 GB/sec
which matches your observations:
> It's interesting that 'movsb' for you is so much better. It's been
> promising before, and it *should* be able to do better than manual
> copying, but it's not been that noticeable on the machines I've
> tested. But I haven't ued Skylake or Broadwell yet.
>
> cpufreq might be making a difference too. Maybe it's just ramping up
> the CPU? Or is that really repeatable?
So modulo the cpufreq multiplier it seems repeatable on this IB system - will try
it on SkyLake as well.
Before relying on it I also wanted to implement the following 'perf bench'
improvements:
- make it more representative of kernel usage by benchmarking a list of
characteristic lengths, not just the single stupid 1MB buffer. At smaller
buffer sizes I'd expect MOVSB to have even more of a fundamental advantage (due
to having all the differentiation in hardware) - but we don't know the
latencies of those cases, some of which are in microcode I suspect.
- measure aligned/unaligned buffer address and length effects as well
- measure cache-cold numbers as well. This is pretty hard but not impossible.
With that we could start validating our fundamental memory op routines in
user-space.
Thanks,
Ingo
^ permalink raw reply [flat|nested] 44+ messages in thread
* [tip:perf/core] perf bench: Default to all routines in ' perf bench mem'
2015-10-19 8:04 ` [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem' Ingo Molnar
2015-10-19 15:21 ` Linus Torvalds
@ 2015-10-20 7:43 ` tip-bot for Ingo Molnar
1 sibling, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:43 UTC (permalink / raw)
To: linux-tip-commits
Cc: hpa, tglx, mitake, peterz, torvalds, linux-kernel, mingo, jolsa,
acme, namhyung, dsahern
Commit-ID: 276197415685e2a91ce367562800cf0f8fbe482c
Gitweb: http://git.kernel.org/tip/276197415685e2a91ce367562800cf0f8fbe482c
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:18 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 15:05:34 -0300
perf bench: Default to all routines in 'perf bench mem'
So few people know that the --routine option to 'perf bench memcpy/memset'
exists, and would not know that it's capable of testing the kernel's
memcpy/memset implementations.
Furthermore, 'perf bench mem all' will not run all routines:
vega:~> perf bench mem all
# Running mem/memcpy benchmark...
Routine default (Default memcpy() provided by glibc)
# Copying 1MB Bytes ...
894.454383 MB/Sec
3.844734 GB/Sec (with prefault)
# Running mem/memset benchmark...
Routine default (Default memset() provided by glibc)
# Copying 1MB Bytes ...
1.220703 GB/Sec
9.042245 GB/Sec (with prefault)
Because misleadingly the 'all' refers to 'all sub-benchmarks', not 'all
sub-benchmarks and routines'.
Fix all this by making the memcpy/memset routine to default to 'all',
which results in all the benchmarks being run:
triton:~> perf bench mem all
# Running mem/memcpy benchmark...
Routine default (Default memcpy() provided by glibc)
# Copying 1MB Bytes ...
1.448906 GB/Sec
4.957170 GB/Sec (with prefault)
Routine x86-64-unrolled (unrolled memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.614153 GB/Sec
4.379204 GB/Sec (with prefault)
Routine x86-64-movsq (movsq-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.570036 GB/Sec
4.264465 GB/Sec (with prefault)
Routine x86-64-movsb (movsb-based memcpy() in arch/x86/lib/memcpy_64.S)
# Copying 1MB Bytes ...
1.788576 GB/Sec
6.554111 GB/Sec (with prefault)
# Running mem/memset benchmark...
Routine default (Default memset() provided by glibc)
# Copying 1MB Bytes ...
2.082223 GB/Sec
9.126752 GB/Sec (with prefault)
Routine x86-64-unrolled (unrolled memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
5.710892 GB/Sec
8.346688 GB/Sec (with prefault)
Routine x86-64-stosq (movsq-based memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
9.765625 GB/Sec
12.520032 GB/Sec (with prefault)
Routine x86-64-stosb (movsb-based memset() in arch/x86/lib/memset_64.S)
# Copying 1MB Bytes ...
9.668936 GB/Sec
12.682630 GB/Sec (with prefault)
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-3-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-memcpy.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 27606ff..263f841 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *length_str = "1MB";
-static const char *routine = "default";
+static const char *routine = "all";
static int iterations = 1;
static bool use_cycle;
static int cycle_fd;
@@ -35,7 +35,7 @@ static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
"Specify length of memory to copy. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
- OPT_STRING('r', "routine", &routine, "default",
+ OPT_STRING('r', "routine", &routine, "all",
"Specify routine to copy, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 03/14] perf/bench: Eliminate unused argument from bench_mem_common()
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
2015-10-19 8:04 ` [PATCH 01/14] perf/bench: Improve the 'perf bench mem memcpy' code readability Ingo Molnar
2015-10-19 8:04 ` [PATCH 02/14] perf/bench: Default to all routines in 'perf bench mem' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:44 ` [tip:perf/core] perf bench: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c' Ingo Molnar
` (11 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-memcpy.c | 11 ++++-------
1 file changed, 4 insertions(+), 7 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 263f84171ae5..7acb9b83382c 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -211,9 +211,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
}
-static int bench_mem_common(int argc, const char **argv,
- const char *prefix __maybe_unused,
- struct bench_mem_info *info)
+static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
{
int i;
size_t len;
@@ -326,8 +324,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
-int bench_mem_memcpy(int argc, const char **argv,
- const char *prefix __maybe_unused)
+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
.routines = memcpy_routines,
@@ -336,7 +333,7 @@ int bench_mem_memcpy(int argc, const char **argv,
.usage = bench_mem_memcpy_usage,
};
- return bench_mem_common(argc, argv, prefix, &info);
+ return bench_mem_common(argc, argv, &info);
}
static void memset_alloc_mem(void **dst, size_t length)
@@ -419,5 +416,5 @@ int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unu
.usage = bench_mem_memset_usage,
};
- return bench_mem_common(argc, argv, prefix, &info);
+ return bench_mem_common(argc, argv, &info);
}
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench: Eliminate unused argument from bench_mem_common()
2015-10-19 8:04 ` [PATCH 03/14] perf/bench: Eliminate unused argument from bench_mem_common() Ingo Molnar
@ 2015-10-20 7:44 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:44 UTC (permalink / raw)
To: linux-tip-commits
Cc: hpa, linux-kernel, dsahern, jolsa, tglx, mitake, acme, mingo,
namhyung, torvalds, peterz
Commit-ID: 2946f59ac31d703738c00c684613d289e8d001ea
Gitweb: http://git.kernel.org/tip/2946f59ac31d703738c00c684613d289e8d001ea
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:19 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 15:29:08 -0300
perf bench: Eliminate unused argument from bench_mem_common()
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-4-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-memcpy.c | 11 ++++-------
1 file changed, 4 insertions(+), 7 deletions(-)
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 263f841..7acb9b8 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -211,9 +211,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
}
}
-static int bench_mem_common(int argc, const char **argv,
- const char *prefix __maybe_unused,
- struct bench_mem_info *info)
+static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
{
int i;
size_t len;
@@ -326,8 +324,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
-int bench_mem_memcpy(int argc, const char **argv,
- const char *prefix __maybe_unused)
+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
.routines = memcpy_routines,
@@ -336,7 +333,7 @@ int bench_mem_memcpy(int argc, const char **argv,
.usage = bench_mem_memcpy_usage,
};
- return bench_mem_common(argc, argv, prefix, &info);
+ return bench_mem_common(argc, argv, &info);
}
static void memset_alloc_mem(void **dst, size_t length)
@@ -419,5 +416,5 @@ int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unu
.usage = bench_mem_memset_usage,
};
- return bench_mem_common(argc, argv, prefix, &info);
+ return bench_mem_common(argc, argv, &info);
}
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (2 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 03/14] perf/bench: Eliminate unused argument from bench_mem_common() Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-19 18:35 ` Arnaldo Carvalho de Melo
2015-10-20 7:44 ` [tip:perf/core] perf bench: Rename 'mem-memcpy.c' => ' mem-functions.c' tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 05/14] perf/bench: Remove the prefaulting complication from 'perf bench mem mem*' Ingo Molnar
` (10 subsequent siblings)
14 siblings, 2 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So mem-memcpy.c started out as a simple memcpy() benchmark, then
it grew memset() functionality and now I plan to add string copy
benchmarks as well.
This makes the file name a misnomer: rename it to the more generic
mem-functions.c name.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/Build | 2 +-
tools/perf/bench/mem-functions.c | 420 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 421 insertions(+), 1 deletion(-)
diff --git a/tools/perf/bench/Build b/tools/perf/bench/Build
index 573e28896038..60bf11943047 100644
--- a/tools/perf/bench/Build
+++ b/tools/perf/bench/Build
@@ -1,6 +1,6 @@
perf-y += sched-messaging.o
perf-y += sched-pipe.o
-perf-y += mem-memcpy.o
+perf-y += mem-functions.o
perf-y += futex-hash.o
perf-y += futex-wake.o
perf-y += futex-wake-parallel.o
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
new file mode 100644
index 000000000000..8f91c2e6b459
--- /dev/null
+++ b/tools/perf/bench/mem-functions.c
@@ -0,0 +1,420 @@
+/*
+ * mem-functions.c
+ *
+ * Simple memcpy() and memset() benchmarks.
+ *
+ * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
+ */
+
+#include "../perf.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+#include "../util/header.h"
+#include "../util/cloexec.h"
+#include "bench.h"
+#include "mem-memcpy-arch.h"
+#include "mem-memset-arch.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#define K 1024
+
+static const char *length_str = "1MB";
+static const char *routine = "all";
+static int iterations = 1;
+static bool use_cycle;
+static int cycle_fd;
+static bool only_prefault;
+static bool no_prefault;
+
+static const struct option options[] = {
+ OPT_STRING('l', "length", &length_str, "1MB",
+ "Specify length of memory to copy. "
+ "Available units: B, KB, MB, GB and TB (upper and lower)"),
+ OPT_STRING('r', "routine", &routine, "all",
+ "Specify routine to copy, \"all\" runs all available routines"),
+ OPT_INTEGER('i', "iterations", &iterations,
+ "repeat memcpy() invocation this number of times"),
+ OPT_BOOLEAN('c', "cycle", &use_cycle,
+ "Use cycles event instead of gettimeofday() for measuring"),
+ OPT_BOOLEAN('o', "only-prefault", &only_prefault,
+ "Show only the result with page faults before memcpy()"),
+ OPT_BOOLEAN('n', "no-prefault", &no_prefault,
+ "Show only the result without page faults before memcpy()"),
+ OPT_END()
+};
+
+typedef void *(*memcpy_t)(void *, const void *, size_t);
+typedef void *(*memset_t)(void *, int, size_t);
+
+struct routine {
+ const char *name;
+ const char *desc;
+ union {
+ memcpy_t memcpy;
+ memset_t memset;
+ } fn;
+};
+
+struct routine memcpy_routines[] = {
+ { .name = "default",
+ .desc = "Default memcpy() provided by glibc",
+ .fn.memcpy = memcpy },
+
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
+# include "mem-memcpy-x86-64-asm-def.h"
+# undef MEMCPY_FN
+#endif
+
+ { NULL, }
+};
+
+static const char * const bench_mem_memcpy_usage[] = {
+ "perf bench mem memcpy <options>",
+ NULL
+};
+
+static struct perf_event_attr cycle_attr = {
+ .type = PERF_TYPE_HARDWARE,
+ .config = PERF_COUNT_HW_CPU_CYCLES
+};
+
+static void init_cycle(void)
+{
+ cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
+
+ if (cycle_fd < 0 && errno == ENOSYS)
+ die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
+ else
+ BUG_ON(cycle_fd < 0);
+}
+
+static u64 get_cycle(void)
+{
+ int ret;
+ u64 clk;
+
+ ret = read(cycle_fd, &clk, sizeof(u64));
+ BUG_ON(ret != sizeof(u64));
+
+ return clk;
+}
+
+static double timeval2double(struct timeval *ts)
+{
+ return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
+}
+
+#define print_bps(x) do { \
+ if (x < K) \
+ printf(" %14lf B/Sec", x); \
+ else if (x < K * K) \
+ printf(" %14lfd KB/Sec", x / K); \
+ else if (x < K * K * K) \
+ printf(" %14lf MB/Sec", x / K / K); \
+ else \
+ printf(" %14lf GB/Sec", x / K / K / K); \
+ } while (0)
+
+struct bench_mem_info {
+ const struct routine *routines;
+ u64 (*do_cycle)(const struct routine *r, size_t len, bool prefault);
+ double (*do_gettimeofday)(const struct routine *r, size_t len, bool prefault);
+ const char *const *usage;
+};
+
+static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
+{
+ const struct routine *r = &info->routines[r_idx];
+ double result_bps[2];
+ u64 result_cycle[2];
+ int prefault = no_prefault ? 0 : 1;
+
+ result_cycle[0] = result_cycle[1] = 0ULL;
+ result_bps[0] = result_bps[1] = 0.0;
+
+ printf("Routine %s (%s)\n", r->name, r->desc);
+
+ if (bench_format == BENCH_FORMAT_DEFAULT)
+ printf("# Copying %s Bytes ...\n\n", length_str);
+
+ if (!only_prefault && prefault) {
+ /* Show both results: */
+ if (use_cycle) {
+ result_cycle[0] = info->do_cycle(r, len, false);
+ result_cycle[1] = info->do_cycle(r, len, true);
+ } else {
+ result_bps[0] = info->do_gettimeofday(r, len, false);
+ result_bps[1] = info->do_gettimeofday(r, len, true);
+ }
+ } else {
+ if (use_cycle)
+ result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
+ else
+ result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
+ }
+
+ switch (bench_format) {
+ case BENCH_FORMAT_DEFAULT:
+ if (!only_prefault && prefault) {
+ if (use_cycle) {
+ printf(" %14lf Cycle/Byte\n",
+ (double)result_cycle[0]
+ / totallen);
+ printf(" %14lf Cycle/Byte (with prefault)\n",
+ (double)result_cycle[1]
+ / totallen);
+ } else {
+ print_bps(result_bps[0]);
+ printf("\n");
+ print_bps(result_bps[1]);
+ printf(" (with prefault)\n");
+ }
+ } else {
+ if (use_cycle) {
+ printf(" %14lf Cycle/Byte",
+ (double)result_cycle[prefault]
+ / totallen);
+ } else
+ print_bps(result_bps[prefault]);
+
+ printf("%s\n", only_prefault ? " (with prefault)" : "");
+ }
+ break;
+ case BENCH_FORMAT_SIMPLE:
+ if (!only_prefault && prefault) {
+ if (use_cycle) {
+ printf("%lf %lf\n",
+ (double)result_cycle[0] / totallen,
+ (double)result_cycle[1] / totallen);
+ } else {
+ printf("%lf %lf\n",
+ result_bps[0], result_bps[1]);
+ }
+ } else {
+ if (use_cycle) {
+ printf("%lf\n", (double)result_cycle[prefault]
+ / totallen);
+ } else
+ printf("%lf\n", result_bps[prefault]);
+ }
+ break;
+ default:
+ /* Reaching this means there's some disaster: */
+ die("unknown format: %d\n", bench_format);
+ break;
+ }
+}
+
+static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
+{
+ int i;
+ size_t len;
+ double totallen;
+
+ argc = parse_options(argc, argv, options, info->usage, 0);
+
+ if (no_prefault && only_prefault) {
+ fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
+ return 1;
+ }
+
+ if (use_cycle)
+ init_cycle();
+
+ len = (size_t)perf_atoll((char *)length_str);
+ totallen = (double)len * iterations;
+
+ if ((s64)len <= 0) {
+ fprintf(stderr, "Invalid length:%s\n", length_str);
+ return 1;
+ }
+
+ /* Same as without specifying either of prefault and no-prefault: */
+ if (only_prefault && no_prefault)
+ only_prefault = no_prefault = false;
+
+ if (!strncmp(routine, "all", 3)) {
+ for (i = 0; info->routines[i].name; i++)
+ __bench_mem_routine(info, i, len, totallen);
+ return 0;
+ }
+
+ for (i = 0; info->routines[i].name; i++) {
+ if (!strcmp(info->routines[i].name, routine))
+ break;
+ }
+ if (!info->routines[i].name) {
+ printf("Unknown routine:%s\n", routine);
+ printf("Available routines...\n");
+ for (i = 0; info->routines[i].name; i++) {
+ printf("\t%s ... %s\n",
+ info->routines[i].name, info->routines[i].desc);
+ }
+ return 1;
+ }
+
+ __bench_mem_routine(info, i, len, totallen);
+
+ return 0;
+}
+
+static void memcpy_alloc_mem(void **dst, void **src, size_t length)
+{
+ *dst = zalloc(length);
+ if (!*dst)
+ die("memory allocation failed - maybe length is too large?\n");
+
+ *src = zalloc(length);
+ if (!*src)
+ die("memory allocation failed - maybe length is too large?\n");
+
+ /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
+ memset(*src, 0, length);
+}
+
+static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
+{
+ u64 cycle_start = 0ULL, cycle_end = 0ULL;
+ void *src = NULL, *dst = NULL;
+ memcpy_t fn = r->fn.memcpy;
+ int i;
+
+ memcpy_alloc_mem(&dst, &src, len);
+
+ if (prefault)
+ fn(dst, src, len);
+
+ cycle_start = get_cycle();
+ for (i = 0; i < iterations; ++i)
+ fn(dst, src, len);
+ cycle_end = get_cycle();
+
+ free(src);
+ free(dst);
+ return cycle_end - cycle_start;
+}
+
+static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
+{
+ struct timeval tv_start, tv_end, tv_diff;
+ memcpy_t fn = r->fn.memcpy;
+ void *src = NULL, *dst = NULL;
+ int i;
+
+ memcpy_alloc_mem(&dst, &src, len);
+
+ if (prefault)
+ fn(dst, src, len);
+
+ BUG_ON(gettimeofday(&tv_start, NULL));
+ for (i = 0; i < iterations; ++i)
+ fn(dst, src, len);
+ BUG_ON(gettimeofday(&tv_end, NULL));
+
+ timersub(&tv_end, &tv_start, &tv_diff);
+
+ free(src);
+ free(dst);
+ return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+}
+
+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
+{
+ struct bench_mem_info info = {
+ .routines = memcpy_routines,
+ .do_cycle = do_memcpy_cycle,
+ .do_gettimeofday = do_memcpy_gettimeofday,
+ .usage = bench_mem_memcpy_usage,
+ };
+
+ return bench_mem_common(argc, argv, &info);
+}
+
+static void memset_alloc_mem(void **dst, size_t length)
+{
+ *dst = zalloc(length);
+ if (!*dst)
+ die("memory allocation failed - maybe length is too large?\n");
+}
+
+static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
+{
+ u64 cycle_start = 0ULL, cycle_end = 0ULL;
+ memset_t fn = r->fn.memset;
+ void *dst = NULL;
+ int i;
+
+ memset_alloc_mem(&dst, len);
+
+ if (prefault)
+ fn(dst, -1, len);
+
+ cycle_start = get_cycle();
+ for (i = 0; i < iterations; ++i)
+ fn(dst, i, len);
+ cycle_end = get_cycle();
+
+ free(dst);
+ return cycle_end - cycle_start;
+}
+
+static double do_memset_gettimeofday(const struct routine *r, size_t len,
+ bool prefault)
+{
+ struct timeval tv_start, tv_end, tv_diff;
+ memset_t fn = r->fn.memset;
+ void *dst = NULL;
+ int i;
+
+ memset_alloc_mem(&dst, len);
+
+ if (prefault)
+ fn(dst, -1, len);
+
+ BUG_ON(gettimeofday(&tv_start, NULL));
+ for (i = 0; i < iterations; ++i)
+ fn(dst, i, len);
+ BUG_ON(gettimeofday(&tv_end, NULL));
+
+ timersub(&tv_end, &tv_start, &tv_diff);
+
+ free(dst);
+ return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+}
+
+static const char * const bench_mem_memset_usage[] = {
+ "perf bench mem memset <options>",
+ NULL
+};
+
+static const struct routine memset_routines[] = {
+ { .name = "default",
+ .desc = "Default memset() provided by glibc",
+ .fn.memset = memset },
+
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
+# include "mem-memset-x86-64-asm-def.h"
+# undef MEMSET_FN
+#endif
+
+ { NULL, }
+};
+
+int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
+{
+ struct bench_mem_info info = {
+ .routines = memset_routines,
+ .do_cycle = do_memset_cycle,
+ .do_gettimeofday = do_memset_gettimeofday,
+ .usage = bench_mem_memset_usage,
+ };
+
+ return bench_mem_common(argc, argv, &info);
+}
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c'
2015-10-19 8:04 ` [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c' Ingo Molnar
@ 2015-10-19 18:35 ` Arnaldo Carvalho de Melo
2015-10-19 18:37 ` Arnaldo Carvalho de Melo
2015-10-20 7:44 ` [tip:perf/core] perf bench: Rename 'mem-memcpy.c' => ' mem-functions.c' tip-bot for Ingo Molnar
1 sibling, 1 reply; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 18:35 UTC (permalink / raw)
To: Ingo Molnar
Cc: linux-kernel, Peter Zijlstra, Namhyung Kim, David Ahern,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 10:04:20AM +0200, Ingo Molnar escreveu:
> So mem-memcpy.c started out as a simple memcpy() benchmark, then
> it grew memset() functionality and now I plan to add string copy
> benchmarks as well.
>
> This makes the file name a misnomer: rename it to the more generic
> mem-functions.c name.
>
> Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
> Cc: David Ahern <dsahern@gmail.com>
> Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
> Cc: Jiri Olsa <jolsa@redhat.com>
> Cc: Linus Torvalds <torvalds@linux-foundation.org>
> Cc: Namhyung Kim <namhyung@kernel.org>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Thomas Gleixner <tglx@linutronix.de>
> Cc: linux-kernel@vger.kernel.org
> Signed-off-by: Ingo Molnar <mingo@kernel.org>
> ---
> tools/perf/bench/Build | 2 +-
> tools/perf/bench/mem-functions.c | 420 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Oops, this is not renaming anything, right? And it also introducs
__unused usage, which breaks the build.
Lemme try to do it...
- Arnaldo
> 2 files changed, 421 insertions(+), 1 deletion(-)
>
> diff --git a/tools/perf/bench/Build b/tools/perf/bench/Build
> index 573e28896038..60bf11943047 100644
> --- a/tools/perf/bench/Build
> +++ b/tools/perf/bench/Build
> @@ -1,6 +1,6 @@
> perf-y += sched-messaging.o
> perf-y += sched-pipe.o
> -perf-y += mem-memcpy.o
> +perf-y += mem-functions.o
> perf-y += futex-hash.o
> perf-y += futex-wake.o
> perf-y += futex-wake-parallel.o
> diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
> new file mode 100644
> index 000000000000..8f91c2e6b459
> --- /dev/null
> +++ b/tools/perf/bench/mem-functions.c
> @@ -0,0 +1,420 @@
> +/*
> + * mem-functions.c
> + *
> + * Simple memcpy() and memset() benchmarks.
> + *
> + * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
> + */
> +
> +#include "../perf.h"
> +#include "../util/util.h"
> +#include "../util/parse-options.h"
> +#include "../util/header.h"
> +#include "../util/cloexec.h"
> +#include "bench.h"
> +#include "mem-memcpy-arch.h"
> +#include "mem-memset-arch.h"
> +
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/time.h>
> +#include <errno.h>
> +
> +#define K 1024
> +
> +static const char *length_str = "1MB";
> +static const char *routine = "all";
> +static int iterations = 1;
> +static bool use_cycle;
> +static int cycle_fd;
> +static bool only_prefault;
> +static bool no_prefault;
> +
> +static const struct option options[] = {
> + OPT_STRING('l', "length", &length_str, "1MB",
> + "Specify length of memory to copy. "
> + "Available units: B, KB, MB, GB and TB (upper and lower)"),
> + OPT_STRING('r', "routine", &routine, "all",
> + "Specify routine to copy, \"all\" runs all available routines"),
> + OPT_INTEGER('i', "iterations", &iterations,
> + "repeat memcpy() invocation this number of times"),
> + OPT_BOOLEAN('c', "cycle", &use_cycle,
> + "Use cycles event instead of gettimeofday() for measuring"),
> + OPT_BOOLEAN('o', "only-prefault", &only_prefault,
> + "Show only the result with page faults before memcpy()"),
> + OPT_BOOLEAN('n', "no-prefault", &no_prefault,
> + "Show only the result without page faults before memcpy()"),
> + OPT_END()
> +};
> +
> +typedef void *(*memcpy_t)(void *, const void *, size_t);
> +typedef void *(*memset_t)(void *, int, size_t);
> +
> +struct routine {
> + const char *name;
> + const char *desc;
> + union {
> + memcpy_t memcpy;
> + memset_t memset;
> + } fn;
> +};
> +
> +struct routine memcpy_routines[] = {
> + { .name = "default",
> + .desc = "Default memcpy() provided by glibc",
> + .fn.memcpy = memcpy },
> +
> +#ifdef HAVE_ARCH_X86_64_SUPPORT
> +# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
> +# include "mem-memcpy-x86-64-asm-def.h"
> +# undef MEMCPY_FN
> +#endif
> +
> + { NULL, }
> +};
> +
> +static const char * const bench_mem_memcpy_usage[] = {
> + "perf bench mem memcpy <options>",
> + NULL
> +};
> +
> +static struct perf_event_attr cycle_attr = {
> + .type = PERF_TYPE_HARDWARE,
> + .config = PERF_COUNT_HW_CPU_CYCLES
> +};
> +
> +static void init_cycle(void)
> +{
> + cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
> +
> + if (cycle_fd < 0 && errno == ENOSYS)
> + die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
> + else
> + BUG_ON(cycle_fd < 0);
> +}
> +
> +static u64 get_cycle(void)
> +{
> + int ret;
> + u64 clk;
> +
> + ret = read(cycle_fd, &clk, sizeof(u64));
> + BUG_ON(ret != sizeof(u64));
> +
> + return clk;
> +}
> +
> +static double timeval2double(struct timeval *ts)
> +{
> + return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
> +}
> +
> +#define print_bps(x) do { \
> + if (x < K) \
> + printf(" %14lf B/Sec", x); \
> + else if (x < K * K) \
> + printf(" %14lfd KB/Sec", x / K); \
> + else if (x < K * K * K) \
> + printf(" %14lf MB/Sec", x / K / K); \
> + else \
> + printf(" %14lf GB/Sec", x / K / K / K); \
> + } while (0)
> +
> +struct bench_mem_info {
> + const struct routine *routines;
> + u64 (*do_cycle)(const struct routine *r, size_t len, bool prefault);
> + double (*do_gettimeofday)(const struct routine *r, size_t len, bool prefault);
> + const char *const *usage;
> +};
> +
> +static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
> +{
> + const struct routine *r = &info->routines[r_idx];
> + double result_bps[2];
> + u64 result_cycle[2];
> + int prefault = no_prefault ? 0 : 1;
> +
> + result_cycle[0] = result_cycle[1] = 0ULL;
> + result_bps[0] = result_bps[1] = 0.0;
> +
> + printf("Routine %s (%s)\n", r->name, r->desc);
> +
> + if (bench_format == BENCH_FORMAT_DEFAULT)
> + printf("# Copying %s Bytes ...\n\n", length_str);
> +
> + if (!only_prefault && prefault) {
> + /* Show both results: */
> + if (use_cycle) {
> + result_cycle[0] = info->do_cycle(r, len, false);
> + result_cycle[1] = info->do_cycle(r, len, true);
> + } else {
> + result_bps[0] = info->do_gettimeofday(r, len, false);
> + result_bps[1] = info->do_gettimeofday(r, len, true);
> + }
> + } else {
> + if (use_cycle)
> + result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
> + else
> + result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
> + }
> +
> + switch (bench_format) {
> + case BENCH_FORMAT_DEFAULT:
> + if (!only_prefault && prefault) {
> + if (use_cycle) {
> + printf(" %14lf Cycle/Byte\n",
> + (double)result_cycle[0]
> + / totallen);
> + printf(" %14lf Cycle/Byte (with prefault)\n",
> + (double)result_cycle[1]
> + / totallen);
> + } else {
> + print_bps(result_bps[0]);
> + printf("\n");
> + print_bps(result_bps[1]);
> + printf(" (with prefault)\n");
> + }
> + } else {
> + if (use_cycle) {
> + printf(" %14lf Cycle/Byte",
> + (double)result_cycle[prefault]
> + / totallen);
> + } else
> + print_bps(result_bps[prefault]);
> +
> + printf("%s\n", only_prefault ? " (with prefault)" : "");
> + }
> + break;
> + case BENCH_FORMAT_SIMPLE:
> + if (!only_prefault && prefault) {
> + if (use_cycle) {
> + printf("%lf %lf\n",
> + (double)result_cycle[0] / totallen,
> + (double)result_cycle[1] / totallen);
> + } else {
> + printf("%lf %lf\n",
> + result_bps[0], result_bps[1]);
> + }
> + } else {
> + if (use_cycle) {
> + printf("%lf\n", (double)result_cycle[prefault]
> + / totallen);
> + } else
> + printf("%lf\n", result_bps[prefault]);
> + }
> + break;
> + default:
> + /* Reaching this means there's some disaster: */
> + die("unknown format: %d\n", bench_format);
> + break;
> + }
> +}
> +
> +static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
> +{
> + int i;
> + size_t len;
> + double totallen;
> +
> + argc = parse_options(argc, argv, options, info->usage, 0);
> +
> + if (no_prefault && only_prefault) {
> + fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
> + return 1;
> + }
> +
> + if (use_cycle)
> + init_cycle();
> +
> + len = (size_t)perf_atoll((char *)length_str);
> + totallen = (double)len * iterations;
> +
> + if ((s64)len <= 0) {
> + fprintf(stderr, "Invalid length:%s\n", length_str);
> + return 1;
> + }
> +
> + /* Same as without specifying either of prefault and no-prefault: */
> + if (only_prefault && no_prefault)
> + only_prefault = no_prefault = false;
> +
> + if (!strncmp(routine, "all", 3)) {
> + for (i = 0; info->routines[i].name; i++)
> + __bench_mem_routine(info, i, len, totallen);
> + return 0;
> + }
> +
> + for (i = 0; info->routines[i].name; i++) {
> + if (!strcmp(info->routines[i].name, routine))
> + break;
> + }
> + if (!info->routines[i].name) {
> + printf("Unknown routine:%s\n", routine);
> + printf("Available routines...\n");
> + for (i = 0; info->routines[i].name; i++) {
> + printf("\t%s ... %s\n",
> + info->routines[i].name, info->routines[i].desc);
> + }
> + return 1;
> + }
> +
> + __bench_mem_routine(info, i, len, totallen);
> +
> + return 0;
> +}
> +
> +static void memcpy_alloc_mem(void **dst, void **src, size_t length)
> +{
> + *dst = zalloc(length);
> + if (!*dst)
> + die("memory allocation failed - maybe length is too large?\n");
> +
> + *src = zalloc(length);
> + if (!*src)
> + die("memory allocation failed - maybe length is too large?\n");
> +
> + /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
> + memset(*src, 0, length);
> +}
> +
> +static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
> +{
> + u64 cycle_start = 0ULL, cycle_end = 0ULL;
> + void *src = NULL, *dst = NULL;
> + memcpy_t fn = r->fn.memcpy;
> + int i;
> +
> + memcpy_alloc_mem(&dst, &src, len);
> +
> + if (prefault)
> + fn(dst, src, len);
> +
> + cycle_start = get_cycle();
> + for (i = 0; i < iterations; ++i)
> + fn(dst, src, len);
> + cycle_end = get_cycle();
> +
> + free(src);
> + free(dst);
> + return cycle_end - cycle_start;
> +}
> +
> +static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
> +{
> + struct timeval tv_start, tv_end, tv_diff;
> + memcpy_t fn = r->fn.memcpy;
> + void *src = NULL, *dst = NULL;
> + int i;
> +
> + memcpy_alloc_mem(&dst, &src, len);
> +
> + if (prefault)
> + fn(dst, src, len);
> +
> + BUG_ON(gettimeofday(&tv_start, NULL));
> + for (i = 0; i < iterations; ++i)
> + fn(dst, src, len);
> + BUG_ON(gettimeofday(&tv_end, NULL));
> +
> + timersub(&tv_end, &tv_start, &tv_diff);
> +
> + free(src);
> + free(dst);
> + return (double)(((double)len * iterations) / timeval2double(&tv_diff));
> +}
> +
> +int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
> +{
> + struct bench_mem_info info = {
> + .routines = memcpy_routines,
> + .do_cycle = do_memcpy_cycle,
> + .do_gettimeofday = do_memcpy_gettimeofday,
> + .usage = bench_mem_memcpy_usage,
> + };
> +
> + return bench_mem_common(argc, argv, &info);
> +}
> +
> +static void memset_alloc_mem(void **dst, size_t length)
> +{
> + *dst = zalloc(length);
> + if (!*dst)
> + die("memory allocation failed - maybe length is too large?\n");
> +}
> +
> +static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
> +{
> + u64 cycle_start = 0ULL, cycle_end = 0ULL;
> + memset_t fn = r->fn.memset;
> + void *dst = NULL;
> + int i;
> +
> + memset_alloc_mem(&dst, len);
> +
> + if (prefault)
> + fn(dst, -1, len);
> +
> + cycle_start = get_cycle();
> + for (i = 0; i < iterations; ++i)
> + fn(dst, i, len);
> + cycle_end = get_cycle();
> +
> + free(dst);
> + return cycle_end - cycle_start;
> +}
> +
> +static double do_memset_gettimeofday(const struct routine *r, size_t len,
> + bool prefault)
> +{
> + struct timeval tv_start, tv_end, tv_diff;
> + memset_t fn = r->fn.memset;
> + void *dst = NULL;
> + int i;
> +
> + memset_alloc_mem(&dst, len);
> +
> + if (prefault)
> + fn(dst, -1, len);
> +
> + BUG_ON(gettimeofday(&tv_start, NULL));
> + for (i = 0; i < iterations; ++i)
> + fn(dst, i, len);
> + BUG_ON(gettimeofday(&tv_end, NULL));
> +
> + timersub(&tv_end, &tv_start, &tv_diff);
> +
> + free(dst);
> + return (double)(((double)len * iterations) / timeval2double(&tv_diff));
> +}
> +
> +static const char * const bench_mem_memset_usage[] = {
> + "perf bench mem memset <options>",
> + NULL
> +};
> +
> +static const struct routine memset_routines[] = {
> + { .name = "default",
> + .desc = "Default memset() provided by glibc",
> + .fn.memset = memset },
> +
> +#ifdef HAVE_ARCH_X86_64_SUPPORT
> +# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
> +# include "mem-memset-x86-64-asm-def.h"
> +# undef MEMSET_FN
> +#endif
> +
> + { NULL, }
> +};
> +
> +int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
> +{
> + struct bench_mem_info info = {
> + .routines = memset_routines,
> + .do_cycle = do_memset_cycle,
> + .do_gettimeofday = do_memset_gettimeofday,
> + .usage = bench_mem_memset_usage,
> + };
> +
> + return bench_mem_common(argc, argv, &info);
> +}
> --
> 2.1.4
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c'
2015-10-19 18:35 ` Arnaldo Carvalho de Melo
@ 2015-10-19 18:37 ` Arnaldo Carvalho de Melo
0 siblings, 0 replies; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 18:37 UTC (permalink / raw)
To: Ingo Molnar
Cc: linux-kernel, Peter Zijlstra, Namhyung Kim, David Ahern,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner, acme
Em Mon, Oct 19, 2015 at 04:35:20PM -0200, Arnaldo Carvalho de Melo escreveu:
> Em Mon, Oct 19, 2015 at 10:04:20AM +0200, Ingo Molnar escreveu:
> > So mem-memcpy.c started out as a simple memcpy() benchmark, then
> > it grew memset() functionality and now I plan to add string copy
> > benchmarks as well.
> >
> > This makes the file name a misnomer: rename it to the more generic
> > mem-functions.c name.
> >
> > Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
> > Cc: David Ahern <dsahern@gmail.com>
> > Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
> > Cc: Jiri Olsa <jolsa@redhat.com>
> > Cc: Linus Torvalds <torvalds@linux-foundation.org>
> > Cc: Namhyung Kim <namhyung@kernel.org>
> > Cc: Peter Zijlstra <peterz@infradead.org>
> > Cc: Thomas Gleixner <tglx@linutronix.de>
> > Cc: linux-kernel@vger.kernel.org
> > Signed-off-by: Ingo Molnar <mingo@kernel.org>
> > ---
> > tools/perf/bench/Build | 2 +-
> > tools/perf/bench/mem-functions.c | 420 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>
> Oops, this is not renaming anything, right? And it also introducs
> __unused usage, which breaks the build.
>
> Lemme try to do it...
Just after applying this patch, I tried a diff and figure this, fixing
it by just renaming it.
$ diff -u tools/perf/bench/mem-memcpy.c tools/perf/bench/mem-functions.c
--- tools/perf/bench/mem-memcpy.c 2015-10-19 15:29:08.761643798 -0300
+++ tools/perf/bench/mem-functions.c 2015-10-19 15:35:34.986776289 -0300
@@ -1,7 +1,7 @@
/*
- * mem-memcpy.c
+ * mem-functions.c
*
- * Simple memcpy() and memset() benchmarks
+ * Simple memcpy() and memset() benchmarks.
*
* Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
*/
@@ -324,7 +324,7 @@
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
-int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
{
struct bench_mem_info info = {
.routines = memcpy_routines,
@@ -407,7 +407,7 @@
{ NULL, }
};
-int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
{
struct bench_mem_info info = {
.routines = memset_routines,
^ permalink raw reply [flat|nested] 44+ messages in thread
* [tip:perf/core] perf bench: Rename 'mem-memcpy.c' => ' mem-functions.c'
2015-10-19 8:04 ` [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c' Ingo Molnar
2015-10-19 18:35 ` Arnaldo Carvalho de Melo
@ 2015-10-20 7:44 ` tip-bot for Ingo Molnar
1 sibling, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:44 UTC (permalink / raw)
To: linux-tip-commits
Cc: mitake, mingo, peterz, dsahern, torvalds, jolsa, hpa, tglx,
namhyung, linux-kernel, acme
Commit-ID: 9b2fa7f3e7799a335fd839906ab4d45b7d595dc4
Gitweb: http://git.kernel.org/tip/9b2fa7f3e7799a335fd839906ab4d45b7d595dc4
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:20 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 15:39:39 -0300
perf bench: Rename 'mem-memcpy.c' => 'mem-functions.c'
So mem-memcpy.c started out as a simple memcpy() benchmark, then it grew
memset() functionality and now I plan to add string copy benchmarks as
well.
This makes the file name a misnomer: rename it to the more generic
mem-functions.c name.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-5-git-send-email-mingo@kernel.org
[ The "rename" was introducing __unused, wasn't removing the old file,
and didn't update tools/perf/bench/Build, fix it ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/Build | 2 +-
tools/perf/bench/{mem-memcpy.c => mem-functions.c} | 0
2 files changed, 1 insertion(+), 1 deletion(-)
diff --git a/tools/perf/bench/Build b/tools/perf/bench/Build
index 573e288..60bf119 100644
--- a/tools/perf/bench/Build
+++ b/tools/perf/bench/Build
@@ -1,6 +1,6 @@
perf-y += sched-messaging.o
perf-y += sched-pipe.o
-perf-y += mem-memcpy.o
+perf-y += mem-functions.o
perf-y += futex-hash.o
perf-y += futex-wake.o
perf-y += futex-wake-parallel.o
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-functions.c
similarity index 100%
rename from tools/perf/bench/mem-memcpy.c
rename to tools/perf/bench/mem-functions.c
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 05/14] perf/bench: Remove the prefaulting complication from 'perf bench mem mem*'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (3 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 04/14] perf/bench: Rename 'mem-memcpy.c' => 'mem-functions.c' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:44 ` [tip:perf/core] perf bench: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h' Ingo Molnar
` (9 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So 'perf bench mem memcpy/memset' has elaborate code to measure
memcpy()/memset() performance both with freshly allocated buffers
(which includes initial page fault overhead) and with preallocated
buffers.
But the thing is, the resulting bandwidth results are mostly
meaningless, because page faults dominate so much of the cost.
It might make sense to measure cache cold vs. cache hot performance,
but the code does not do this.
So remove this complication, and always prefault the ranges before
using them.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 146 ++++++++++++++++++++---------------------------------------
1 file changed, 50 insertions(+), 96 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 8f91c2e6b459..33de5d57a163 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -28,8 +28,6 @@ static const char *routine = "all";
static int iterations = 1;
static bool use_cycle;
static int cycle_fd;
-static bool only_prefault;
-static bool no_prefault;
static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
@@ -41,10 +39,6 @@ static const struct option options[] = {
"repeat memcpy() invocation this number of times"),
OPT_BOOLEAN('c', "cycle", &use_cycle,
"Use cycles event instead of gettimeofday() for measuring"),
- OPT_BOOLEAN('o', "only-prefault", &only_prefault,
- "Show only the result with page faults before memcpy()"),
- OPT_BOOLEAN('n', "no-prefault", &no_prefault,
- "Show only the result without page faults before memcpy()"),
OPT_END()
};
@@ -110,103 +104,60 @@ static double timeval2double(struct timeval *ts)
return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
}
-#define print_bps(x) do { \
- if (x < K) \
- printf(" %14lf B/Sec", x); \
- else if (x < K * K) \
- printf(" %14lfd KB/Sec", x / K); \
- else if (x < K * K * K) \
- printf(" %14lf MB/Sec", x / K / K); \
- else \
- printf(" %14lf GB/Sec", x / K / K / K); \
+#define print_bps(x) do { \
+ if (x < K) \
+ printf(" %14lf B/Sec\n", x); \
+ else if (x < K * K) \
+ printf(" %14lfd KB/Sec\n", x / K); \
+ else if (x < K * K * K) \
+ printf(" %14lf MB/Sec\n", x / K / K); \
+ else \
+ printf(" %14lf GB/Sec\n", x / K / K / K); \
} while (0)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycle)(const struct routine *r, size_t len, bool prefault);
- double (*do_gettimeofday)(const struct routine *r, size_t len, bool prefault);
+ u64 (*do_cycle)(const struct routine *r, size_t len);
+ double (*do_gettimeofday)(const struct routine *r, size_t len);
const char *const *usage;
};
static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
{
const struct routine *r = &info->routines[r_idx];
- double result_bps[2];
- u64 result_cycle[2];
- int prefault = no_prefault ? 0 : 1;
-
- result_cycle[0] = result_cycle[1] = 0ULL;
- result_bps[0] = result_bps[1] = 0.0;
+ double result_bps = 0.0;
+ u64 result_cycle = 0;
printf("Routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (!only_prefault && prefault) {
- /* Show both results: */
- if (use_cycle) {
- result_cycle[0] = info->do_cycle(r, len, false);
- result_cycle[1] = info->do_cycle(r, len, true);
- } else {
- result_bps[0] = info->do_gettimeofday(r, len, false);
- result_bps[1] = info->do_gettimeofday(r, len, true);
- }
+ if (use_cycle) {
+ result_cycle = info->do_cycle(r, len);
} else {
- if (use_cycle)
- result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
- else
- result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
+ result_bps = info->do_gettimeofday(r, len);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte\n",
- (double)result_cycle[0]
- / totallen);
- printf(" %14lf Cycle/Byte (with prefault)\n",
- (double)result_cycle[1]
- / totallen);
- } else {
- print_bps(result_bps[0]);
- printf("\n");
- print_bps(result_bps[1]);
- printf(" (with prefault)\n");
- }
+ if (use_cycle) {
+ printf(" %14lf Cycle/Byte\n", (double)result_cycle/totallen);
} else {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte",
- (double)result_cycle[prefault]
- / totallen);
- } else
- print_bps(result_bps[prefault]);
-
- printf("%s\n", only_prefault ? " (with prefault)" : "");
+ print_bps(result_bps);
}
break;
+
case BENCH_FORMAT_SIMPLE:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf("%lf %lf\n",
- (double)result_cycle[0] / totallen,
- (double)result_cycle[1] / totallen);
- } else {
- printf("%lf %lf\n",
- result_bps[0], result_bps[1]);
- }
+ if (use_cycle) {
+ printf("%lf\n", (double)result_cycle/totallen);
} else {
- if (use_cycle) {
- printf("%lf\n", (double)result_cycle[prefault]
- / totallen);
- } else
- printf("%lf\n", result_bps[prefault]);
+ printf("%lf\n", result_bps);
}
break;
+
default:
- /* Reaching this means there's some disaster: */
- die("unknown format: %d\n", bench_format);
+ BUG_ON(1);
break;
}
}
@@ -219,11 +170,6 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
argc = parse_options(argc, argv, options, info->usage, 0);
- if (no_prefault && only_prefault) {
- fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
- return 1;
- }
-
if (use_cycle)
init_cycle();
@@ -235,10 +181,6 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- /* Same as without specifying either of prefault and no-prefault: */
- if (only_prefault && no_prefault)
- only_prefault = no_prefault = false;
-
if (!strncmp(routine, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
__bench_mem_routine(info, i, len, totallen);
@@ -278,7 +220,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
memset(*src, 0, length);
}
-static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
+static u64 do_memcpy_cycle(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -287,8 +229,11 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
memcpy_alloc_mem(&dst, &src, len);
- if (prefault)
- fn(dst, src, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, src, len);
cycle_start = get_cycle();
for (i = 0; i < iterations; ++i)
@@ -300,7 +245,7 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -309,8 +254,11 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
memcpy_alloc_mem(&dst, &src, len);
- if (prefault)
- fn(dst, src, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, src, len);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
@@ -321,6 +269,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
free(src);
free(dst);
+
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
@@ -343,7 +292,7 @@ static void memset_alloc_mem(void **dst, size_t length)
die("memory allocation failed - maybe length is too large?\n");
}
-static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
+static u64 do_memset_cycle(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -352,8 +301,11 @@ static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
memset_alloc_mem(&dst, len);
- if (prefault)
- fn(dst, -1, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, -1, len);
cycle_start = get_cycle();
for (i = 0; i < iterations; ++i)
@@ -364,8 +316,7 @@ static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t len,
- bool prefault)
+static double do_memset_gettimeofday(const struct routine *r, size_t len)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
@@ -374,8 +325,11 @@ static double do_memset_gettimeofday(const struct routine *r, size_t len,
memset_alloc_mem(&dst, len);
- if (prefault)
- fn(dst, -1, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, -1, len);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench: Remove the prefaulting complication from 'perf bench mem mem*'
2015-10-19 8:04 ` [PATCH 05/14] perf/bench: Remove the prefaulting complication from 'perf bench mem mem*' Ingo Molnar
@ 2015-10-20 7:44 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:44 UTC (permalink / raw)
To: linux-tip-commits
Cc: hpa, tglx, torvalds, acme, jolsa, namhyung, linux-kernel, mingo,
mitake, peterz, dsahern
Commit-ID: 6db175c7333e22ee818373cbea067e3eaa0236f7
Gitweb: http://git.kernel.org/tip/6db175c7333e22ee818373cbea067e3eaa0236f7
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:21 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:03:31 -0300
perf bench: Remove the prefaulting complication from 'perf bench mem mem*'
So 'perf bench mem memcpy/memset' has elaborate code to measure
memcpy()/memset() performance both with freshly allocated buffers (which
includes initial page fault overhead) and with preallocated buffers.
But the thing is, the resulting bandwidth results are mostly
meaningless, because page faults dominate so much of the cost.
It might make sense to measure cache cold vs. cache hot performance, but
the code does not do this.
So remove this complication, and always prefault the ranges before using
them.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-6-git-send-email-mingo@kernel.org
[ Remove --no-prefault, --only-prefault from docs, noticed by David Ahern ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/Documentation/perf-bench.txt | 16 ----
tools/perf/bench/mem-functions.c | 146 +++++++++++---------------------
2 files changed, 50 insertions(+), 112 deletions(-)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index ab632d9..9cb60ab 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -157,14 +157,6 @@ Repeat memcpy invocation this number of times.
--cycle::
Use perf's cpu-cycles event instead of gettimeofday syscall.
--o::
---only-prefault::
-Show only the result with page faults before memcpy.
-
--n::
---no-prefault::
-Show only the result without page faults before memcpy.
-
*memset*::
Suite for evaluating performance of simple memory set in various ways.
@@ -189,14 +181,6 @@ Repeat memset invocation this number of times.
--cycle::
Use perf's cpu-cycles event instead of gettimeofday syscall.
--o::
---only-prefault::
-Show only the result with page faults before memset.
-
--n::
---no-prefault::
-Show only the result without page faults before memset.
-
SUITES FOR 'numa'
~~~~~~~~~~~~~~~~~
*mem*::
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 7acb9b8..9c18a4b 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -28,8 +28,6 @@ static const char *routine = "all";
static int iterations = 1;
static bool use_cycle;
static int cycle_fd;
-static bool only_prefault;
-static bool no_prefault;
static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
@@ -41,10 +39,6 @@ static const struct option options[] = {
"repeat memcpy() invocation this number of times"),
OPT_BOOLEAN('c', "cycle", &use_cycle,
"Use cycles event instead of gettimeofday() for measuring"),
- OPT_BOOLEAN('o', "only-prefault", &only_prefault,
- "Show only the result with page faults before memcpy()"),
- OPT_BOOLEAN('n', "no-prefault", &no_prefault,
- "Show only the result without page faults before memcpy()"),
OPT_END()
};
@@ -110,103 +104,60 @@ static double timeval2double(struct timeval *ts)
return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
}
-#define print_bps(x) do { \
- if (x < K) \
- printf(" %14lf B/Sec", x); \
- else if (x < K * K) \
- printf(" %14lfd KB/Sec", x / K); \
- else if (x < K * K * K) \
- printf(" %14lf MB/Sec", x / K / K); \
- else \
- printf(" %14lf GB/Sec", x / K / K / K); \
+#define print_bps(x) do { \
+ if (x < K) \
+ printf(" %14lf B/Sec\n", x); \
+ else if (x < K * K) \
+ printf(" %14lfd KB/Sec\n", x / K); \
+ else if (x < K * K * K) \
+ printf(" %14lf MB/Sec\n", x / K / K); \
+ else \
+ printf(" %14lf GB/Sec\n", x / K / K / K); \
} while (0)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycle)(const struct routine *r, size_t len, bool prefault);
- double (*do_gettimeofday)(const struct routine *r, size_t len, bool prefault);
+ u64 (*do_cycle)(const struct routine *r, size_t len);
+ double (*do_gettimeofday)(const struct routine *r, size_t len);
const char *const *usage;
};
static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
{
const struct routine *r = &info->routines[r_idx];
- double result_bps[2];
- u64 result_cycle[2];
- int prefault = no_prefault ? 0 : 1;
-
- result_cycle[0] = result_cycle[1] = 0ULL;
- result_bps[0] = result_bps[1] = 0.0;
+ double result_bps = 0.0;
+ u64 result_cycle = 0;
printf("Routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (!only_prefault && prefault) {
- /* Show both results: */
- if (use_cycle) {
- result_cycle[0] = info->do_cycle(r, len, false);
- result_cycle[1] = info->do_cycle(r, len, true);
- } else {
- result_bps[0] = info->do_gettimeofday(r, len, false);
- result_bps[1] = info->do_gettimeofday(r, len, true);
- }
+ if (use_cycle) {
+ result_cycle = info->do_cycle(r, len);
} else {
- if (use_cycle)
- result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
- else
- result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
+ result_bps = info->do_gettimeofday(r, len);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte\n",
- (double)result_cycle[0]
- / totallen);
- printf(" %14lf Cycle/Byte (with prefault)\n",
- (double)result_cycle[1]
- / totallen);
- } else {
- print_bps(result_bps[0]);
- printf("\n");
- print_bps(result_bps[1]);
- printf(" (with prefault)\n");
- }
+ if (use_cycle) {
+ printf(" %14lf Cycle/Byte\n", (double)result_cycle/totallen);
} else {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte",
- (double)result_cycle[prefault]
- / totallen);
- } else
- print_bps(result_bps[prefault]);
-
- printf("%s\n", only_prefault ? " (with prefault)" : "");
+ print_bps(result_bps);
}
break;
+
case BENCH_FORMAT_SIMPLE:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf("%lf %lf\n",
- (double)result_cycle[0] / totallen,
- (double)result_cycle[1] / totallen);
- } else {
- printf("%lf %lf\n",
- result_bps[0], result_bps[1]);
- }
+ if (use_cycle) {
+ printf("%lf\n", (double)result_cycle/totallen);
} else {
- if (use_cycle) {
- printf("%lf\n", (double)result_cycle[prefault]
- / totallen);
- } else
- printf("%lf\n", result_bps[prefault]);
+ printf("%lf\n", result_bps);
}
break;
+
default:
- /* Reaching this means there's some disaster: */
- die("unknown format: %d\n", bench_format);
+ BUG_ON(1);
break;
}
}
@@ -219,11 +170,6 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
argc = parse_options(argc, argv, options, info->usage, 0);
- if (no_prefault && only_prefault) {
- fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
- return 1;
- }
-
if (use_cycle)
init_cycle();
@@ -235,10 +181,6 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- /* Same as without specifying either of prefault and no-prefault: */
- if (only_prefault && no_prefault)
- only_prefault = no_prefault = false;
-
if (!strncmp(routine, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
__bench_mem_routine(info, i, len, totallen);
@@ -278,7 +220,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
memset(*src, 0, length);
}
-static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
+static u64 do_memcpy_cycle(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -287,8 +229,11 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
memcpy_alloc_mem(&dst, &src, len);
- if (prefault)
- fn(dst, src, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, src, len);
cycle_start = get_cycle();
for (i = 0; i < iterations; ++i)
@@ -300,7 +245,7 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -309,8 +254,11 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
memcpy_alloc_mem(&dst, &src, len);
- if (prefault)
- fn(dst, src, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, src, len);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
@@ -321,6 +269,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool p
free(src);
free(dst);
+
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
@@ -343,7 +292,7 @@ static void memset_alloc_mem(void **dst, size_t length)
die("memory allocation failed - maybe length is too large?\n");
}
-static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
+static u64 do_memset_cycle(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -352,8 +301,11 @@ static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
memset_alloc_mem(&dst, len);
- if (prefault)
- fn(dst, -1, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, -1, len);
cycle_start = get_cycle();
for (i = 0; i < iterations; ++i)
@@ -364,8 +316,7 @@ static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t len,
- bool prefault)
+static double do_memset_gettimeofday(const struct routine *r, size_t len)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
@@ -374,8 +325,11 @@ static double do_memset_gettimeofday(const struct routine *r, size_t len,
memset_alloc_mem(&dst, len);
- if (prefault)
- fn(dst, -1, len);
+ /*
+ * We prefault the freshly allocated memory range here,
+ * to not measure page fault overhead:
+ */
+ fn(dst, -1, len);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (4 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 05/14] perf/bench: Remove the prefaulting complication from 'perf bench mem mem*' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-19 13:28 ` David Ahern
2015-10-20 7:45 ` [tip:perf/core] perf bench: List output formatting options on ' perf " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 07/14] perf/bench/mem: Change 'cycle' to 'cycles' Ingo Molnar
` (8 subsequent siblings)
14 siblings, 2 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So 'perf bench -h' is not very helpful when printing the help line
about the output formatting options:
-f, --format <default>
Specify format style
There are two output format styles, 'default' and 'simple', so improve
the help text to:
-f, --format <default|simple>
Specify the output formatting style
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 4 +-
tools/perf/bench/mem-memcpy.c | 420 -----------------------------------------------------------
tools/perf/builtin-bench.c | 2 +-
3 files changed, 3 insertions(+), 423 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 33de5d57a163..d822ee0c6003 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -273,7 +273,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
return (double)(((double)len * iterations) / timeval2double(&tv_diff));
}
-int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
.routines = memcpy_routines,
@@ -361,7 +361,7 @@ static const struct routine memset_routines[] = {
{ NULL, }
};
-int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
+int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
.routines = memset_routines,
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
deleted file mode 100644
index 7acb9b83382c..000000000000
--- a/tools/perf/bench/mem-memcpy.c
+++ /dev/null
@@ -1,420 +0,0 @@
-/*
- * mem-memcpy.c
- *
- * Simple memcpy() and memset() benchmarks
- *
- * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
- */
-
-#include "../perf.h"
-#include "../util/util.h"
-#include "../util/parse-options.h"
-#include "../util/header.h"
-#include "../util/cloexec.h"
-#include "bench.h"
-#include "mem-memcpy-arch.h"
-#include "mem-memset-arch.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <errno.h>
-
-#define K 1024
-
-static const char *length_str = "1MB";
-static const char *routine = "all";
-static int iterations = 1;
-static bool use_cycle;
-static int cycle_fd;
-static bool only_prefault;
-static bool no_prefault;
-
-static const struct option options[] = {
- OPT_STRING('l', "length", &length_str, "1MB",
- "Specify length of memory to copy. "
- "Available units: B, KB, MB, GB and TB (upper and lower)"),
- OPT_STRING('r', "routine", &routine, "all",
- "Specify routine to copy, \"all\" runs all available routines"),
- OPT_INTEGER('i', "iterations", &iterations,
- "repeat memcpy() invocation this number of times"),
- OPT_BOOLEAN('c', "cycle", &use_cycle,
- "Use cycles event instead of gettimeofday() for measuring"),
- OPT_BOOLEAN('o', "only-prefault", &only_prefault,
- "Show only the result with page faults before memcpy()"),
- OPT_BOOLEAN('n', "no-prefault", &no_prefault,
- "Show only the result without page faults before memcpy()"),
- OPT_END()
-};
-
-typedef void *(*memcpy_t)(void *, const void *, size_t);
-typedef void *(*memset_t)(void *, int, size_t);
-
-struct routine {
- const char *name;
- const char *desc;
- union {
- memcpy_t memcpy;
- memset_t memset;
- } fn;
-};
-
-struct routine memcpy_routines[] = {
- { .name = "default",
- .desc = "Default memcpy() provided by glibc",
- .fn.memcpy = memcpy },
-
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
-# include "mem-memcpy-x86-64-asm-def.h"
-# undef MEMCPY_FN
-#endif
-
- { NULL, }
-};
-
-static const char * const bench_mem_memcpy_usage[] = {
- "perf bench mem memcpy <options>",
- NULL
-};
-
-static struct perf_event_attr cycle_attr = {
- .type = PERF_TYPE_HARDWARE,
- .config = PERF_COUNT_HW_CPU_CYCLES
-};
-
-static void init_cycle(void)
-{
- cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
-
- if (cycle_fd < 0 && errno == ENOSYS)
- die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
- else
- BUG_ON(cycle_fd < 0);
-}
-
-static u64 get_cycle(void)
-{
- int ret;
- u64 clk;
-
- ret = read(cycle_fd, &clk, sizeof(u64));
- BUG_ON(ret != sizeof(u64));
-
- return clk;
-}
-
-static double timeval2double(struct timeval *ts)
-{
- return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
-}
-
-#define print_bps(x) do { \
- if (x < K) \
- printf(" %14lf B/Sec", x); \
- else if (x < K * K) \
- printf(" %14lfd KB/Sec", x / K); \
- else if (x < K * K * K) \
- printf(" %14lf MB/Sec", x / K / K); \
- else \
- printf(" %14lf GB/Sec", x / K / K / K); \
- } while (0)
-
-struct bench_mem_info {
- const struct routine *routines;
- u64 (*do_cycle)(const struct routine *r, size_t len, bool prefault);
- double (*do_gettimeofday)(const struct routine *r, size_t len, bool prefault);
- const char *const *usage;
-};
-
-static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
-{
- const struct routine *r = &info->routines[r_idx];
- double result_bps[2];
- u64 result_cycle[2];
- int prefault = no_prefault ? 0 : 1;
-
- result_cycle[0] = result_cycle[1] = 0ULL;
- result_bps[0] = result_bps[1] = 0.0;
-
- printf("Routine %s (%s)\n", r->name, r->desc);
-
- if (bench_format == BENCH_FORMAT_DEFAULT)
- printf("# Copying %s Bytes ...\n\n", length_str);
-
- if (!only_prefault && prefault) {
- /* Show both results: */
- if (use_cycle) {
- result_cycle[0] = info->do_cycle(r, len, false);
- result_cycle[1] = info->do_cycle(r, len, true);
- } else {
- result_bps[0] = info->do_gettimeofday(r, len, false);
- result_bps[1] = info->do_gettimeofday(r, len, true);
- }
- } else {
- if (use_cycle)
- result_cycle[prefault] = info->do_cycle(r, len, only_prefault);
- else
- result_bps[prefault] = info->do_gettimeofday(r, len, only_prefault);
- }
-
- switch (bench_format) {
- case BENCH_FORMAT_DEFAULT:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte\n",
- (double)result_cycle[0]
- / totallen);
- printf(" %14lf Cycle/Byte (with prefault)\n",
- (double)result_cycle[1]
- / totallen);
- } else {
- print_bps(result_bps[0]);
- printf("\n");
- print_bps(result_bps[1]);
- printf(" (with prefault)\n");
- }
- } else {
- if (use_cycle) {
- printf(" %14lf Cycle/Byte",
- (double)result_cycle[prefault]
- / totallen);
- } else
- print_bps(result_bps[prefault]);
-
- printf("%s\n", only_prefault ? " (with prefault)" : "");
- }
- break;
- case BENCH_FORMAT_SIMPLE:
- if (!only_prefault && prefault) {
- if (use_cycle) {
- printf("%lf %lf\n",
- (double)result_cycle[0] / totallen,
- (double)result_cycle[1] / totallen);
- } else {
- printf("%lf %lf\n",
- result_bps[0], result_bps[1]);
- }
- } else {
- if (use_cycle) {
- printf("%lf\n", (double)result_cycle[prefault]
- / totallen);
- } else
- printf("%lf\n", result_bps[prefault]);
- }
- break;
- default:
- /* Reaching this means there's some disaster: */
- die("unknown format: %d\n", bench_format);
- break;
- }
-}
-
-static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
-{
- int i;
- size_t len;
- double totallen;
-
- argc = parse_options(argc, argv, options, info->usage, 0);
-
- if (no_prefault && only_prefault) {
- fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
- return 1;
- }
-
- if (use_cycle)
- init_cycle();
-
- len = (size_t)perf_atoll((char *)length_str);
- totallen = (double)len * iterations;
-
- if ((s64)len <= 0) {
- fprintf(stderr, "Invalid length:%s\n", length_str);
- return 1;
- }
-
- /* Same as without specifying either of prefault and no-prefault: */
- if (only_prefault && no_prefault)
- only_prefault = no_prefault = false;
-
- if (!strncmp(routine, "all", 3)) {
- for (i = 0; info->routines[i].name; i++)
- __bench_mem_routine(info, i, len, totallen);
- return 0;
- }
-
- for (i = 0; info->routines[i].name; i++) {
- if (!strcmp(info->routines[i].name, routine))
- break;
- }
- if (!info->routines[i].name) {
- printf("Unknown routine:%s\n", routine);
- printf("Available routines...\n");
- for (i = 0; info->routines[i].name; i++) {
- printf("\t%s ... %s\n",
- info->routines[i].name, info->routines[i].desc);
- }
- return 1;
- }
-
- __bench_mem_routine(info, i, len, totallen);
-
- return 0;
-}
-
-static void memcpy_alloc_mem(void **dst, void **src, size_t length)
-{
- *dst = zalloc(length);
- if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
-
- *src = zalloc(length);
- if (!*src)
- die("memory allocation failed - maybe length is too large?\n");
-
- /* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
- memset(*src, 0, length);
-}
-
-static u64 do_memcpy_cycle(const struct routine *r, size_t len, bool prefault)
-{
- u64 cycle_start = 0ULL, cycle_end = 0ULL;
- void *src = NULL, *dst = NULL;
- memcpy_t fn = r->fn.memcpy;
- int i;
-
- memcpy_alloc_mem(&dst, &src, len);
-
- if (prefault)
- fn(dst, src, len);
-
- cycle_start = get_cycle();
- for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
- cycle_end = get_cycle();
-
- free(src);
- free(dst);
- return cycle_end - cycle_start;
-}
-
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len, bool prefault)
-{
- struct timeval tv_start, tv_end, tv_diff;
- memcpy_t fn = r->fn.memcpy;
- void *src = NULL, *dst = NULL;
- int i;
-
- memcpy_alloc_mem(&dst, &src, len);
-
- if (prefault)
- fn(dst, src, len);
-
- BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
- BUG_ON(gettimeofday(&tv_end, NULL));
-
- timersub(&tv_end, &tv_start, &tv_diff);
-
- free(src);
- free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
-}
-
-int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
-{
- struct bench_mem_info info = {
- .routines = memcpy_routines,
- .do_cycle = do_memcpy_cycle,
- .do_gettimeofday = do_memcpy_gettimeofday,
- .usage = bench_mem_memcpy_usage,
- };
-
- return bench_mem_common(argc, argv, &info);
-}
-
-static void memset_alloc_mem(void **dst, size_t length)
-{
- *dst = zalloc(length);
- if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
-}
-
-static u64 do_memset_cycle(const struct routine *r, size_t len, bool prefault)
-{
- u64 cycle_start = 0ULL, cycle_end = 0ULL;
- memset_t fn = r->fn.memset;
- void *dst = NULL;
- int i;
-
- memset_alloc_mem(&dst, len);
-
- if (prefault)
- fn(dst, -1, len);
-
- cycle_start = get_cycle();
- for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
- cycle_end = get_cycle();
-
- free(dst);
- return cycle_end - cycle_start;
-}
-
-static double do_memset_gettimeofday(const struct routine *r, size_t len,
- bool prefault)
-{
- struct timeval tv_start, tv_end, tv_diff;
- memset_t fn = r->fn.memset;
- void *dst = NULL;
- int i;
-
- memset_alloc_mem(&dst, len);
-
- if (prefault)
- fn(dst, -1, len);
-
- BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
- BUG_ON(gettimeofday(&tv_end, NULL));
-
- timersub(&tv_end, &tv_start, &tv_diff);
-
- free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
-}
-
-static const char * const bench_mem_memset_usage[] = {
- "perf bench mem memset <options>",
- NULL
-};
-
-static const struct routine memset_routines[] = {
- { .name = "default",
- .desc = "Default memset() provided by glibc",
- .fn.memset = memset },
-
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-# define MEMSET_FN(_fn, _name, _desc) { .name = _name, .desc = _desc, .fn.memset = _fn },
-# include "mem-memset-x86-64-asm-def.h"
-# undef MEMSET_FN
-#endif
-
- { NULL, }
-};
-
-int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
-{
- struct bench_mem_info info = {
- .routines = memset_routines,
- .do_cycle = do_memset_cycle,
- .do_gettimeofday = do_memset_gettimeofday,
- .usage = bench_mem_memset_usage,
- };
-
- return bench_mem_common(argc, argv, &info);
-}
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index f67934d46d40..1b585213ba5a 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -110,7 +110,7 @@ int bench_format = BENCH_FORMAT_DEFAULT;
unsigned int bench_repeat = 10; /* default number of times to repeat the run */
static const struct option bench_options[] = {
- OPT_STRING('f', "format", &bench_format_str, "default", "Specify format style"),
+ OPT_STRING('f', "format", &bench_format_str, "default|simple", "Specify the output formatting style"),
OPT_UINTEGER('r', "repeat", &bench_repeat, "Specify amount of times to repeat the run"),
OPT_END()
};
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h'
2015-10-19 8:04 ` [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h' Ingo Molnar
@ 2015-10-19 13:28 ` David Ahern
2015-10-19 18:51 ` Arnaldo Carvalho de Melo
2015-10-20 7:45 ` [tip:perf/core] perf bench: List output formatting options on ' perf " tip-bot for Ingo Molnar
1 sibling, 1 reply; 44+ messages in thread
From: David Ahern @ 2015-10-19 13:28 UTC (permalink / raw)
To: Ingo Molnar, linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim, Jiri Olsa,
Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
On 10/19/15 2:04 AM, Ingo Molnar wrote:
> diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
> index 33de5d57a163..d822ee0c6003 100644
> --- a/tools/perf/bench/mem-functions.c
> +++ b/tools/perf/bench/mem-functions.c
> @@ -273,7 +273,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
> return (double)(((double)len * iterations) / timeval2double(&tv_diff));
> }
>
> -int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
> +int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
> {
> struct bench_mem_info info = {
> .routines = memcpy_routines,
> @@ -361,7 +361,7 @@ static const struct routine memset_routines[] = {
> { NULL, }
> };
>
> -int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
> +int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
> {
> struct bench_mem_info info = {
> .routines = memset_routines,
> diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
> deleted file mode 100644
> index 7acb9b83382c..000000000000
> --- a/tools/perf/bench/mem-memcpy.c
> +++ /dev/null
All of this seems like leftovers from previous patches.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h'
2015-10-19 13:28 ` David Ahern
@ 2015-10-19 18:51 ` Arnaldo Carvalho de Melo
0 siblings, 0 replies; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 18:51 UTC (permalink / raw)
To: David Ahern
Cc: Ingo Molnar, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 07:28:56AM -0600, David Ahern escreveu:
> On 10/19/15 2:04 AM, Ingo Molnar wrote:
> >diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
> >index 33de5d57a163..d822ee0c6003 100644
> >--- a/tools/perf/bench/mem-functions.c
> >+++ b/tools/perf/bench/mem-functions.c
> >@@ -273,7 +273,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
> > return (double)(((double)len * iterations) / timeval2double(&tv_diff));
> > }
> >
> >-int bench_mem_memcpy(int argc, const char **argv, const char *prefix __unused)
> >+int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
> > {
> > struct bench_mem_info info = {
> > .routines = memcpy_routines,
> >@@ -361,7 +361,7 @@ static const struct routine memset_routines[] = {
> > { NULL, }
> > };
> >
> >-int bench_mem_memset(int argc, const char **argv, const char *prefix __unused)
> >+int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
> > {
> > struct bench_mem_info info = {
> > .routines = memset_routines,
> >diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
> >deleted file mode 100644
> >index 7acb9b83382c..000000000000
> >--- a/tools/perf/bench/mem-memcpy.c
> >+++ /dev/null
>
> All of this seems like leftovers from previous patches.
Right, I fixed this one at the rename point, 4/5 IIRc
^ permalink raw reply [flat|nested] 44+ messages in thread
* [tip:perf/core] perf bench: List output formatting options on ' perf bench -h'
2015-10-19 8:04 ` [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h' Ingo Molnar
2015-10-19 13:28 ` David Ahern
@ 2015-10-20 7:45 ` tip-bot for Ingo Molnar
1 sibling, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:45 UTC (permalink / raw)
To: linux-tip-commits
Cc: dsahern, mingo, linux-kernel, torvalds, namhyung, mitake, acme,
tglx, peterz, hpa, jolsa
Commit-ID: 7a46a8fd13bd60584687f417cd35935965f29ae2
Gitweb: http://git.kernel.org/tip/7a46a8fd13bd60584687f417cd35935965f29ae2
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:22 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:03:53 -0300
perf bench: List output formatting options on 'perf bench -h'
So 'perf bench -h' is not very helpful when printing the help line
about the output formatting options:
-f, --format <default>
Specify format style
There are two output format styles, 'default' and 'simple', so improve
the help text to:
-f, --format <default|simple>
Specify the output formatting style
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-7-git-send-email-mingo@kernel.org
[ Removed leftovers from the mem-functions.c rename ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/builtin-bench.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index f67934d..1b58521 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -110,7 +110,7 @@ int bench_format = BENCH_FORMAT_DEFAULT;
unsigned int bench_repeat = 10; /* default number of times to repeat the run */
static const struct option bench_options[] = {
- OPT_STRING('f', "format", &bench_format_str, "default", "Specify format style"),
+ OPT_STRING('f', "format", &bench_format_str, "default|simple", "Specify the output formatting style"),
OPT_UINTEGER('r', "repeat", &bench_repeat, "Specify amount of times to repeat the run"),
OPT_END()
};
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 07/14] perf/bench/mem: Change 'cycle' to 'cycles'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (5 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 06/14] perf/bench: List output formatting options on 'perf bench -h' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:45 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str' Ingo Molnar
` (7 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So 'perf bench mem memset/memcpy' has a CPU cycles measurement method,
but calls it 'cycle' (singular) throughout the code, which makes it
harder to read.
Rename all related functions, variables and options to a plural 'cycles'
nomenclature.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 56 ++++++++++++++++++++++++++++----------------------------
1 file changed, 28 insertions(+), 28 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index d822ee0c6003..150414de1497 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -26,8 +26,8 @@
static const char *length_str = "1MB";
static const char *routine = "all";
static int iterations = 1;
-static bool use_cycle;
-static int cycle_fd;
+static bool use_cycles;
+static int cycles_fd;
static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
@@ -37,8 +37,8 @@ static const struct option options[] = {
"Specify routine to copy, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
- OPT_BOOLEAN('c', "cycle", &use_cycle,
- "Use cycles event instead of gettimeofday() for measuring"),
+ OPT_BOOLEAN('c', "cycles", &use_cycles,
+ "Use a cycles event instead of gettimeofday() to measure performance"),
OPT_END()
};
@@ -78,22 +78,22 @@ static struct perf_event_attr cycle_attr = {
.config = PERF_COUNT_HW_CPU_CYCLES
};
-static void init_cycle(void)
+static void init_cycles(void)
{
- cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
+ cycles_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
- if (cycle_fd < 0 && errno == ENOSYS)
+ if (cycles_fd < 0 && errno == ENOSYS)
die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
else
- BUG_ON(cycle_fd < 0);
+ BUG_ON(cycles_fd < 0);
}
-static u64 get_cycle(void)
+static u64 get_cycles(void)
{
int ret;
u64 clk;
- ret = read(cycle_fd, &clk, sizeof(u64));
+ ret = read(cycles_fd, &clk, sizeof(u64));
BUG_ON(ret != sizeof(u64));
return clk;
@@ -117,7 +117,7 @@ static double timeval2double(struct timeval *ts)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycle)(const struct routine *r, size_t len);
+ u64 (*do_cycles)(const struct routine *r, size_t len);
double (*do_gettimeofday)(const struct routine *r, size_t len);
const char *const *usage;
};
@@ -126,31 +126,31 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
{
const struct routine *r = &info->routines[r_idx];
double result_bps = 0.0;
- u64 result_cycle = 0;
+ u64 result_cycles = 0;
printf("Routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (use_cycle) {
- result_cycle = info->do_cycle(r, len);
+ if (use_cycles) {
+ result_cycles = info->do_cycles(r, len);
} else {
result_bps = info->do_gettimeofday(r, len);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (use_cycle) {
- printf(" %14lf Cycle/Byte\n", (double)result_cycle/totallen);
+ if (use_cycles) {
+ printf(" %14lf cycles/Byte\n", (double)result_cycles/totallen);
} else {
print_bps(result_bps);
}
break;
case BENCH_FORMAT_SIMPLE:
- if (use_cycle) {
- printf("%lf\n", (double)result_cycle/totallen);
+ if (use_cycles) {
+ printf("%lf\n", (double)result_cycles/totallen);
} else {
printf("%lf\n", result_bps);
}
@@ -170,8 +170,8 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
argc = parse_options(argc, argv, options, info->usage, 0);
- if (use_cycle)
- init_cycle();
+ if (use_cycles)
+ init_cycles();
len = (size_t)perf_atoll((char *)length_str);
totallen = (double)len * iterations;
@@ -220,7 +220,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
memset(*src, 0, length);
}
-static u64 do_memcpy_cycle(const struct routine *r, size_t len)
+static u64 do_memcpy_cycles(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -235,10 +235,10 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len)
*/
fn(dst, src, len);
- cycle_start = get_cycle();
+ cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
fn(dst, src, len);
- cycle_end = get_cycle();
+ cycle_end = get_cycles();
free(src);
free(dst);
@@ -277,7 +277,7 @@ int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unu
{
struct bench_mem_info info = {
.routines = memcpy_routines,
- .do_cycle = do_memcpy_cycle,
+ .do_cycles = do_memcpy_cycles,
.do_gettimeofday = do_memcpy_gettimeofday,
.usage = bench_mem_memcpy_usage,
};
@@ -292,7 +292,7 @@ static void memset_alloc_mem(void **dst, size_t length)
die("memory allocation failed - maybe length is too large?\n");
}
-static u64 do_memset_cycle(const struct routine *r, size_t len)
+static u64 do_memset_cycles(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -307,10 +307,10 @@ static u64 do_memset_cycle(const struct routine *r, size_t len)
*/
fn(dst, -1, len);
- cycle_start = get_cycle();
+ cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
fn(dst, i, len);
- cycle_end = get_cycle();
+ cycle_end = get_cycles();
free(dst);
return cycle_end - cycle_start;
@@ -365,7 +365,7 @@ int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unu
{
struct bench_mem_info info = {
.routines = memset_routines,
- .do_cycle = do_memset_cycle,
+ .do_cycles = do_memset_cycles,
.do_gettimeofday = do_memset_gettimeofday,
.usage = bench_mem_memset_usage,
};
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench mem: Change 'cycle' to 'cycles'
2015-10-19 8:04 ` [PATCH 07/14] perf/bench/mem: Change 'cycle' to 'cycles' Ingo Molnar
@ 2015-10-20 7:45 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:45 UTC (permalink / raw)
To: linux-tip-commits
Cc: mingo, acme, linux-kernel, mitake, jolsa, torvalds, tglx,
namhyung, hpa, dsahern, peterz
Commit-ID: b14f2d357675bd7fb4e5a705ac7320a9638ecab5
Gitweb: http://git.kernel.org/tip/b14f2d357675bd7fb4e5a705ac7320a9638ecab5
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:23 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:05:01 -0300
perf bench mem: Change 'cycle' to 'cycles'
So 'perf bench mem memset/memcpy' has a CPU cycles measurement method,
but calls it 'cycle' (singular) throughout the code, which makes it
harder to read.
Rename all related functions, variables and options to a plural 'cycles'
nomenclature.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-8-git-send-email-mingo@kernel.org
[ s/--cycle/--cycles/g in perf-bench man page ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/Documentation/perf-bench.txt | 4 +--
tools/perf/bench/mem-functions.c | 56 ++++++++++++++++-----------------
2 files changed, 30 insertions(+), 30 deletions(-)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index 9cb60ab..17135ef 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -154,7 +154,7 @@ On x86-64, x86-64-unrolled, x86-64-movsq and x86-64-movsb are supported.
Repeat memcpy invocation this number of times.
-c::
---cycle::
+--cycles::
Use perf's cpu-cycles event instead of gettimeofday syscall.
*memset*::
@@ -178,7 +178,7 @@ On x86-64, x86-64-unrolled, x86-64-stosq and x86-64-stosb are supported.
Repeat memset invocation this number of times.
-c::
---cycle::
+--cycles::
Use perf's cpu-cycles event instead of gettimeofday syscall.
SUITES FOR 'numa'
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 9c18a4b..6fe8667 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -26,8 +26,8 @@
static const char *length_str = "1MB";
static const char *routine = "all";
static int iterations = 1;
-static bool use_cycle;
-static int cycle_fd;
+static bool use_cycles;
+static int cycles_fd;
static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
@@ -37,8 +37,8 @@ static const struct option options[] = {
"Specify routine to copy, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
- OPT_BOOLEAN('c', "cycle", &use_cycle,
- "Use cycles event instead of gettimeofday() for measuring"),
+ OPT_BOOLEAN('c', "cycles", &use_cycles,
+ "Use a cycles event instead of gettimeofday() to measure performance"),
OPT_END()
};
@@ -78,22 +78,22 @@ static struct perf_event_attr cycle_attr = {
.config = PERF_COUNT_HW_CPU_CYCLES
};
-static void init_cycle(void)
+static void init_cycles(void)
{
- cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
+ cycles_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, perf_event_open_cloexec_flag());
- if (cycle_fd < 0 && errno == ENOSYS)
+ if (cycles_fd < 0 && errno == ENOSYS)
die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
else
- BUG_ON(cycle_fd < 0);
+ BUG_ON(cycles_fd < 0);
}
-static u64 get_cycle(void)
+static u64 get_cycles(void)
{
int ret;
u64 clk;
- ret = read(cycle_fd, &clk, sizeof(u64));
+ ret = read(cycles_fd, &clk, sizeof(u64));
BUG_ON(ret != sizeof(u64));
return clk;
@@ -117,7 +117,7 @@ static double timeval2double(struct timeval *ts)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycle)(const struct routine *r, size_t len);
+ u64 (*do_cycles)(const struct routine *r, size_t len);
double (*do_gettimeofday)(const struct routine *r, size_t len);
const char *const *usage;
};
@@ -126,31 +126,31 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
{
const struct routine *r = &info->routines[r_idx];
double result_bps = 0.0;
- u64 result_cycle = 0;
+ u64 result_cycles = 0;
printf("Routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
- if (use_cycle) {
- result_cycle = info->do_cycle(r, len);
+ if (use_cycles) {
+ result_cycles = info->do_cycles(r, len);
} else {
result_bps = info->do_gettimeofday(r, len);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
- if (use_cycle) {
- printf(" %14lf Cycle/Byte\n", (double)result_cycle/totallen);
+ if (use_cycles) {
+ printf(" %14lf cycles/Byte\n", (double)result_cycles/totallen);
} else {
print_bps(result_bps);
}
break;
case BENCH_FORMAT_SIMPLE:
- if (use_cycle) {
- printf("%lf\n", (double)result_cycle/totallen);
+ if (use_cycles) {
+ printf("%lf\n", (double)result_cycles/totallen);
} else {
printf("%lf\n", result_bps);
}
@@ -170,8 +170,8 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
argc = parse_options(argc, argv, options, info->usage, 0);
- if (use_cycle)
- init_cycle();
+ if (use_cycles)
+ init_cycles();
len = (size_t)perf_atoll((char *)length_str);
totallen = (double)len * iterations;
@@ -220,7 +220,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t length)
memset(*src, 0, length);
}
-static u64 do_memcpy_cycle(const struct routine *r, size_t len)
+static u64 do_memcpy_cycles(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -235,10 +235,10 @@ static u64 do_memcpy_cycle(const struct routine *r, size_t len)
*/
fn(dst, src, len);
- cycle_start = get_cycle();
+ cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
fn(dst, src, len);
- cycle_end = get_cycle();
+ cycle_end = get_cycles();
free(src);
free(dst);
@@ -277,7 +277,7 @@ int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unu
{
struct bench_mem_info info = {
.routines = memcpy_routines,
- .do_cycle = do_memcpy_cycle,
+ .do_cycles = do_memcpy_cycles,
.do_gettimeofday = do_memcpy_gettimeofday,
.usage = bench_mem_memcpy_usage,
};
@@ -292,7 +292,7 @@ static void memset_alloc_mem(void **dst, size_t length)
die("memory allocation failed - maybe length is too large?\n");
}
-static u64 do_memset_cycle(const struct routine *r, size_t len)
+static u64 do_memset_cycles(const struct routine *r, size_t len)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -307,10 +307,10 @@ static u64 do_memset_cycle(const struct routine *r, size_t len)
*/
fn(dst, -1, len);
- cycle_start = get_cycle();
+ cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
fn(dst, i, len);
- cycle_end = get_cycle();
+ cycle_end = get_cycles();
free(dst);
return cycle_end - cycle_start;
@@ -365,7 +365,7 @@ int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unu
{
struct bench_mem_info info = {
.routines = memset_routines,
- .do_cycle = do_memset_cycle,
+ .do_cycles = do_memset_cycles,
.do_gettimeofday = do_memset_gettimeofday,
.usage = bench_mem_memset_usage,
};
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (6 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 07/14] perf/bench/mem: Change 'cycle' to 'cycles' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-19 13:34 ` David Ahern
2015-10-20 7:45 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 09/14] perf/bench/mem: Fix 'length' vs. 'size' naming confusion Ingo Molnar
` (6 subsequent siblings)
14 siblings, 2 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So bench/mem-functions.c has a 'routine' name for the routines
parameter string, but a 'length_str' name for the length parameter string.
We also have another entity named 'routine': 'struct routine'.
This is inconsistent and confusing: rename 'routine' to 'routine_str'.
Also fix typos in the --routine help text.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 150414de1497..fc2afd1bfb4e 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *length_str = "1MB";
-static const char *routine = "all";
+static const char *routine_str = "all";
static int iterations = 1;
static bool use_cycles;
static int cycles_fd;
@@ -33,8 +33,8 @@ static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
"Specify length of memory to copy. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
- OPT_STRING('r', "routine", &routine, "all",
- "Specify routine to copy, \"all\" runs all available routines"),
+ OPT_STRING('r', "routine", &routine_str, "all",
+ "Specify the routine to run, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
OPT_BOOLEAN('c', "cycles", &use_cycles,
@@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
double result_bps = 0.0;
u64 result_cycles = 0;
- printf("Routine %s (%s)\n", r->name, r->desc);
+ printf("routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s Bytes ...\n\n", length_str);
@@ -181,18 +181,18 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- if (!strncmp(routine, "all", 3)) {
+ if (!strncmp(routine_str, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
__bench_mem_routine(info, i, len, totallen);
return 0;
}
for (i = 0; info->routines[i].name; i++) {
- if (!strcmp(info->routines[i].name, routine))
+ if (!strcmp(info->routines[i].name, routine_str))
break;
}
if (!info->routines[i].name) {
- printf("Unknown routine:%s\n", routine);
+ printf("Unknown routine: %s\n", routine_str);
printf("Available routines...\n");
for (i = 0; info->routines[i].name; i++) {
printf("\t%s ... %s\n",
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 8:04 ` [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str' Ingo Molnar
@ 2015-10-19 13:34 ` David Ahern
2015-10-19 18:54 ` Arnaldo Carvalho de Melo
2015-10-20 7:45 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
1 sibling, 1 reply; 44+ messages in thread
From: David Ahern @ 2015-10-19 13:34 UTC (permalink / raw)
To: Ingo Molnar, linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim, Jiri Olsa,
Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
On 10/19/15 2:04 AM, Ingo Molnar wrote:
> @@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
> double result_bps = 0.0;
> u64 result_cycles = 0;
>
> - printf("Routine %s (%s)\n", r->name, r->desc);
> + printf("routine %s (%s)\n", r->name, r->desc);
>
> if (bench_format == BENCH_FORMAT_DEFAULT)
> printf("# Copying %s Bytes ...\n\n", length_str);
Seems like 'R' is more appropriate here.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 13:34 ` David Ahern
@ 2015-10-19 18:54 ` Arnaldo Carvalho de Melo
2015-10-19 18:56 ` Arnaldo Carvalho de Melo
0 siblings, 1 reply; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 18:54 UTC (permalink / raw)
To: David Ahern
Cc: Ingo Molnar, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> On 10/19/15 2:04 AM, Ingo Molnar wrote:
> >@@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
> > double result_bps = 0.0;
> > u64 result_cycles = 0;
> >
> >- printf("Routine %s (%s)\n", r->name, r->desc);
> >+ printf("routine %s (%s)\n", r->name, r->desc);
> >
> > if (bench_format == BENCH_FORMAT_DEFAULT)
> > printf("# Copying %s Bytes ...\n\n", length_str);
>
> Seems like 'R' is more appropriate here.
Right, changed it.
- Arnaldo
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 18:54 ` Arnaldo Carvalho de Melo
@ 2015-10-19 18:56 ` Arnaldo Carvalho de Melo
2015-10-19 19:09 ` Ingo Molnar
0 siblings, 1 reply; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 18:56 UTC (permalink / raw)
To: David Ahern
Cc: Ingo Molnar, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 04:54:47PM -0200, Arnaldo Carvalho de Melo escreveu:
> Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> > On 10/19/15 2:04 AM, Ingo Molnar wrote:
> > >@@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
> > > double result_bps = 0.0;
> > > u64 result_cycles = 0;
> > >
> > >- printf("Routine %s (%s)\n", r->name, r->desc);
> > >+ printf("routine %s (%s)\n", r->name, r->desc);
> > >
> > > if (bench_format == BENCH_FORMAT_DEFAULT)
> > > printf("# Copying %s Bytes ...\n\n", length_str);
> >
> > Seems like 'R' is more appropriate here.
>
> Right, changed it.
And then, he does that on a later patch, duh.
- Arnaldo
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 18:56 ` Arnaldo Carvalho de Melo
@ 2015-10-19 19:09 ` Ingo Molnar
2015-10-19 19:20 ` Arnaldo Carvalho de Melo
0 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 19:09 UTC (permalink / raw)
To: Arnaldo Carvalho de Melo
Cc: David Ahern, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
* Arnaldo Carvalho de Melo <acme@redhat.com> wrote:
> Em Mon, Oct 19, 2015 at 04:54:47PM -0200, Arnaldo Carvalho de Melo escreveu:
> > Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> > > On 10/19/15 2:04 AM, Ingo Molnar wrote:
> > > >@@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
> > > > double result_bps = 0.0;
> > > > u64 result_cycles = 0;
> > > >
> > > >- printf("Routine %s (%s)\n", r->name, r->desc);
> > > >+ printf("routine %s (%s)\n", r->name, r->desc);
> > > >
> > > > if (bench_format == BENCH_FORMAT_DEFAULT)
> > > > printf("# Copying %s Bytes ...\n\n", length_str);
> > >
> > > Seems like 'R' is more appropriate here.
> >
> > Right, changed it.
>
> And then, he does that on a later patch, duh.
Yeah, indeed - I messed that up: tried to introduce __unused but noticed during
development and testing on other distros that '__unused' is way too crowded a
namespace (various fields in random headers are named like that), so after a bit
of a fight with those headers I changed it back to __maybe_unused ... but the
original change slipped into the series.
Do you want me to resend the series to fix this and the other problems David and
you noticed?
Thanks,
Ingo
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 19:09 ` Ingo Molnar
@ 2015-10-19 19:20 ` Arnaldo Carvalho de Melo
2015-10-19 19:21 ` Arnaldo Carvalho de Melo
0 siblings, 1 reply; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 19:20 UTC (permalink / raw)
To: Ingo Molnar
Cc: David Ahern, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 09:09:32PM +0200, Ingo Molnar escreveu:
>
> * Arnaldo Carvalho de Melo <acme@redhat.com> wrote:
>
> > Em Mon, Oct 19, 2015 at 04:54:47PM -0200, Arnaldo Carvalho de Melo escreveu:
> > > Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> > > > On 10/19/15 2:04 AM, Ingo Molnar wrote:
> > > > >@@ -128,7 +128,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
> > > > > double result_bps = 0.0;
> > > > > u64 result_cycles = 0;
> > > > >
> > > > >- printf("Routine %s (%s)\n", r->name, r->desc);
> > > > >+ printf("routine %s (%s)\n", r->name, r->desc);
> > > > >
> > > > > if (bench_format == BENCH_FORMAT_DEFAULT)
> > > > > printf("# Copying %s Bytes ...\n\n", length_str);
> > > >
> > > > Seems like 'R' is more appropriate here.
> > >
> > > Right, changed it.
> >
> > And then, he does that on a later patch, duh.
>
> Yeah, indeed - I messed that up: tried to introduce __unused but noticed during
> development and testing on other distros that '__unused' is way too crowded a
> namespace (various fields in random headers are named like that), so after a bit
> of a fight with those headers I changed it back to __maybe_unused ... but the
> original change slipped into the series.
>
> Do you want me to resend the series to fix this and the other problems David and
> you noticed?
No problem, I fixed it all already :-)
- Arnaldo
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 19:20 ` Arnaldo Carvalho de Melo
@ 2015-10-19 19:21 ` Arnaldo Carvalho de Melo
2015-10-20 7:36 ` Ingo Molnar
0 siblings, 1 reply; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 19:21 UTC (permalink / raw)
To: Ingo Molnar
Cc: David Ahern, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
Em Mon, Oct 19, 2015 at 05:20:03PM -0200, Arnaldo Carvalho de Melo escreveu:
> Em Mon, Oct 19, 2015 at 09:09:32PM +0200, Ingo Molnar escreveu:
> > * Arnaldo Carvalho de Melo <acme@redhat.com> wrote:
> > > Em Mon, Oct 19, 2015 at 04:54:47PM -0200, Arnaldo Carvalho de Melo escreveu:
> > > > Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> > > > > Seems like 'R' is more appropriate here.
> > > > Right, changed it.
> > > And then, he does that on a later patch, duh.
> > Yeah, indeed - I messed that up: tried to introduce __unused but noticed during
> > development and testing on other distros that '__unused' is way too crowded a
> > namespace (various fields in random headers are named like that), so after a bit
> > of a fight with those headers I changed it back to __maybe_unused ... but the
> > original change slipped into the series.
> >
> > Do you want me to resend the series to fix this and the other problems David and
> > you noticed?
>
> No problem, I fixed it all already :-)
Please check my perf/core branch.
- Arnaldo
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str'
2015-10-19 19:21 ` Arnaldo Carvalho de Melo
@ 2015-10-20 7:36 ` Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: Ingo Molnar @ 2015-10-20 7:36 UTC (permalink / raw)
To: Arnaldo Carvalho de Melo
Cc: David Ahern, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa, Hitoshi Mitake, Linus Torvalds, Thomas Gleixner
* Arnaldo Carvalho de Melo <acme@redhat.com> wrote:
> Em Mon, Oct 19, 2015 at 05:20:03PM -0200, Arnaldo Carvalho de Melo escreveu:
> > Em Mon, Oct 19, 2015 at 09:09:32PM +0200, Ingo Molnar escreveu:
> > > * Arnaldo Carvalho de Melo <acme@redhat.com> wrote:
> > > > Em Mon, Oct 19, 2015 at 04:54:47PM -0200, Arnaldo Carvalho de Melo escreveu:
> > > > > Em Mon, Oct 19, 2015 at 07:34:46AM -0600, David Ahern escreveu:
> > > > > > Seems like 'R' is more appropriate here.
>
> > > > > Right, changed it.
>
> > > > And then, he does that on a later patch, duh.
>
> > > Yeah, indeed - I messed that up: tried to introduce __unused but noticed during
> > > development and testing on other distros that '__unused' is way too crowded a
> > > namespace (various fields in random headers are named like that), so after a bit
> > > of a fight with those headers I changed it back to __maybe_unused ... but the
> > > original change slipped into the series.
> > >
> > > Do you want me to resend the series to fix this and the other problems David and
> > > you noticed?
> >
> > No problem, I fixed it all already :-)
>
> Please check my perf/core branch.
Looks good - thanks Arnaldo!
Ingo
^ permalink raw reply [flat|nested] 44+ messages in thread
* [tip:perf/core] perf bench mem: Rename 'routine' to 'routine_str'
2015-10-19 8:04 ` [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str' Ingo Molnar
2015-10-19 13:34 ` David Ahern
@ 2015-10-20 7:45 ` tip-bot for Ingo Molnar
1 sibling, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:45 UTC (permalink / raw)
To: linux-tip-commits
Cc: dsahern, acme, jolsa, hpa, namhyung, torvalds, mingo,
linux-kernel, tglx, peterz, mitake
Commit-ID: e815e327604af880bdcf38cdd711dfa78627ab2a
Gitweb: http://git.kernel.org/tip/e815e327604af880bdcf38cdd711dfa78627ab2a
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:24 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:05:27 -0300
perf bench mem: Rename 'routine' to 'routine_str'
So bench/mem-functions.c has a 'routine' name for the routines parameter
string, but a 'length_str' name for the length parameter string.
We also have another entity named 'routine': 'struct routine'.
This is inconsistent and confusing: rename 'routine' to 'routine_str'.
Also fix typos in the --routine help text.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-9-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-functions.c | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 6fe8667..a76e57f 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *length_str = "1MB";
-static const char *routine = "all";
+static const char *routine_str = "all";
static int iterations = 1;
static bool use_cycles;
static int cycles_fd;
@@ -33,8 +33,8 @@ static const struct option options[] = {
OPT_STRING('l', "length", &length_str, "1MB",
"Specify length of memory to copy. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
- OPT_STRING('r', "routine", &routine, "all",
- "Specify routine to copy, \"all\" runs all available routines"),
+ OPT_STRING('r', "routine", &routine_str, "all",
+ "Specify the routine to run, \"all\" runs all available routines"),
OPT_INTEGER('i', "iterations", &iterations,
"repeat memcpy() invocation this number of times"),
OPT_BOOLEAN('c', "cycles", &use_cycles,
@@ -181,18 +181,18 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- if (!strncmp(routine, "all", 3)) {
+ if (!strncmp(routine_str, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
__bench_mem_routine(info, i, len, totallen);
return 0;
}
for (i = 0; info->routines[i].name; i++) {
- if (!strcmp(info->routines[i].name, routine))
+ if (!strcmp(info->routines[i].name, routine_str))
break;
}
if (!info->routines[i].name) {
- printf("Unknown routine:%s\n", routine);
+ printf("Unknown routine: %s\n", routine_str);
printf("Available routines...\n");
for (i = 0; info->routines[i].name; i++) {
printf("\t%s ... %s\n",
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 09/14] perf/bench/mem: Fix 'length' vs. 'size' naming confusion
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (7 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 08/14] perf/bench/mem: Rename 'routine' to 'routine_str' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:46 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 10/14] perf/bench/mem: Improve user visible strings Ingo Molnar
` (5 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So 'perf bench mem memcpy/memset' consistently uses 'len' and 'length'
for buffer sizes - while it's really a memory buffer size. (strings
have length.)
Rename all affected variables.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 92 ++++++++++++++++++++++++++++++------------------------------
1 file changed, 46 insertions(+), 46 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index fc2afd1bfb4e..0cd9020b8601 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -23,15 +23,15 @@
#define K 1024
-static const char *length_str = "1MB";
+static const char *size_str = "1MB";
static const char *routine_str = "all";
static int iterations = 1;
static bool use_cycles;
static int cycles_fd;
static const struct option options[] = {
- OPT_STRING('l', "length", &length_str, "1MB",
- "Specify length of memory to copy. "
+ OPT_STRING('l', "size", &size_str, "1MB",
+ "Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
OPT_STRING('r', "routine", &routine_str, "all",
"Specify the routine to run, \"all\" runs all available routines"),
@@ -117,12 +117,12 @@ static double timeval2double(struct timeval *ts)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycles)(const struct routine *r, size_t len);
- double (*do_gettimeofday)(const struct routine *r, size_t len);
+ u64 (*do_cycles)(const struct routine *r, size_t size);
+ double (*do_gettimeofday)(const struct routine *r, size_t size);
const char *const *usage;
};
-static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
+static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
{
const struct routine *r = &info->routines[r_idx];
double result_bps = 0.0;
@@ -131,18 +131,18 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
printf("routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
- printf("# Copying %s Bytes ...\n\n", length_str);
+ printf("# Copying %s Bytes ...\n\n", size_str);
if (use_cycles) {
- result_cycles = info->do_cycles(r, len);
+ result_cycles = info->do_cycles(r, size);
} else {
- result_bps = info->do_gettimeofday(r, len);
+ result_bps = info->do_gettimeofday(r, size);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
if (use_cycles) {
- printf(" %14lf cycles/Byte\n", (double)result_cycles/totallen);
+ printf(" %14lf cycles/Byte\n", (double)result_cycles/size_total);
} else {
print_bps(result_bps);
}
@@ -150,7 +150,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
case BENCH_FORMAT_SIMPLE:
if (use_cycles) {
- printf("%lf\n", (double)result_cycles/totallen);
+ printf("%lf\n", (double)result_cycles/size_total);
} else {
printf("%lf\n", result_bps);
}
@@ -165,25 +165,25 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
{
int i;
- size_t len;
- double totallen;
+ size_t size;
+ double size_total;
argc = parse_options(argc, argv, options, info->usage, 0);
if (use_cycles)
init_cycles();
- len = (size_t)perf_atoll((char *)length_str);
- totallen = (double)len * iterations;
+ size = (size_t)perf_atoll((char *)size_str);
+ size_total = (double)size * iterations;
- if ((s64)len <= 0) {
- fprintf(stderr, "Invalid length:%s\n", length_str);
+ if ((s64)size <= 0) {
+ fprintf(stderr, "Invalid size:%s\n", size_str);
return 1;
}
if (!strncmp(routine_str, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
- __bench_mem_routine(info, i, len, totallen);
+ __bench_mem_routine(info, i, size, size_total);
return 0;
}
@@ -201,43 +201,43 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- __bench_mem_routine(info, i, len, totallen);
+ __bench_mem_routine(info, i, size, size_total);
return 0;
}
-static void memcpy_alloc_mem(void **dst, void **src, size_t length)
+static void memcpy_alloc_mem(void **dst, void **src, size_t size)
{
- *dst = zalloc(length);
+ *dst = zalloc(size);
if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
- *src = zalloc(length);
+ *src = zalloc(size);
if (!*src)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
/* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
- memset(*src, 0, length);
+ memset(*src, 0, size);
}
-static u64 do_memcpy_cycles(const struct routine *r, size_t len)
+static u64 do_memcpy_cycles(const struct routine *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
memcpy_t fn = r->fn.memcpy;
int i;
- memcpy_alloc_mem(&dst, &src, len);
+ memcpy_alloc_mem(&dst, &src, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, src, len);
+ fn(dst, src, size);
cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
+ fn(dst, src, size);
cycle_end = get_cycles();
free(src);
@@ -245,24 +245,24 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t len)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
void *src = NULL, *dst = NULL;
int i;
- memcpy_alloc_mem(&dst, &src, len);
+ memcpy_alloc_mem(&dst, &src, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, src, len);
+ fn(dst, src, size);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
+ fn(dst, src, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
@@ -270,7 +270,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
free(src);
free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
@@ -285,61 +285,61 @@ int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unu
return bench_mem_common(argc, argv, &info);
}
-static void memset_alloc_mem(void **dst, size_t length)
+static void memset_alloc_mem(void **dst, size_t size)
{
- *dst = zalloc(length);
+ *dst = zalloc(size);
if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
}
-static u64 do_memset_cycles(const struct routine *r, size_t len)
+static u64 do_memset_cycles(const struct routine *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
void *dst = NULL;
int i;
- memset_alloc_mem(&dst, len);
+ memset_alloc_mem(&dst, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, -1, len);
+ fn(dst, -1, size);
cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
+ fn(dst, i, size);
cycle_end = get_cycles();
free(dst);
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t len)
+static double do_memset_gettimeofday(const struct routine *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
void *dst = NULL;
int i;
- memset_alloc_mem(&dst, len);
+ memset_alloc_mem(&dst, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, -1, len);
+ fn(dst, -1, size);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
+ fn(dst, i, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
static const char * const bench_mem_memset_usage[] = {
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench mem: Fix 'length' vs. 'size' naming confusion
2015-10-19 8:04 ` [PATCH 09/14] perf/bench/mem: Fix 'length' vs. 'size' naming confusion Ingo Molnar
@ 2015-10-20 7:46 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:46 UTC (permalink / raw)
To: linux-tip-commits
Cc: hpa, namhyung, linux-kernel, dsahern, acme, torvalds, jolsa,
mingo, tglx, mitake, peterz
Commit-ID: a69b4f741340a52d0976636a45c9976a883f03a0
Gitweb: http://git.kernel.org/tip/a69b4f741340a52d0976636a45c9976a883f03a0
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:25 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:07:11 -0300
perf bench mem: Fix 'length' vs. 'size' naming confusion
So 'perf bench mem memcpy/memset' consistently uses 'len' and 'length'
for buffer sizes - while it's really a memory buffer size. (strings have
length.)
Rename all affected variables.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-10-git-send-email-mingo@kernel.org
[ Update perf-bench man page ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/Documentation/perf-bench.txt | 8 +--
tools/perf/bench/mem-functions.c | 92 ++++++++++++++++-----------------
2 files changed, 50 insertions(+), 50 deletions(-)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index 17135ef..bbd27d8 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -139,8 +139,8 @@ Suite for evaluating performance of simple memory copy in various ways.
Options of *memcpy*
^^^^^^^^^^^^^^^^^^^
-l::
---length::
-Specify length of memory to copy (default: 1MB).
+--size::
+Specify size of memory to copy (default: 1MB).
Available units are B, KB, MB, GB and TB (case insensitive).
-r::
@@ -163,8 +163,8 @@ Suite for evaluating performance of simple memory set in various ways.
Options of *memset*
^^^^^^^^^^^^^^^^^^^
-l::
---length::
-Specify length of memory to set (default: 1MB).
+--size::
+Specify size of memory to set (default: 1MB).
Available units are B, KB, MB, GB and TB (case insensitive).
-r::
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index a76e57f..1605249 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -23,15 +23,15 @@
#define K 1024
-static const char *length_str = "1MB";
+static const char *size_str = "1MB";
static const char *routine_str = "all";
static int iterations = 1;
static bool use_cycles;
static int cycles_fd;
static const struct option options[] = {
- OPT_STRING('l', "length", &length_str, "1MB",
- "Specify length of memory to copy. "
+ OPT_STRING('l', "size", &size_str, "1MB",
+ "Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (upper and lower)"),
OPT_STRING('r', "routine", &routine_str, "all",
"Specify the routine to run, \"all\" runs all available routines"),
@@ -117,12 +117,12 @@ static double timeval2double(struct timeval *ts)
struct bench_mem_info {
const struct routine *routines;
- u64 (*do_cycles)(const struct routine *r, size_t len);
- double (*do_gettimeofday)(const struct routine *r, size_t len);
+ u64 (*do_cycles)(const struct routine *r, size_t size);
+ double (*do_gettimeofday)(const struct routine *r, size_t size);
const char *const *usage;
};
-static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
+static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
{
const struct routine *r = &info->routines[r_idx];
double result_bps = 0.0;
@@ -131,18 +131,18 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
printf("Routine %s (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
- printf("# Copying %s Bytes ...\n\n", length_str);
+ printf("# Copying %s Bytes ...\n\n", size_str);
if (use_cycles) {
- result_cycles = info->do_cycles(r, len);
+ result_cycles = info->do_cycles(r, size);
} else {
- result_bps = info->do_gettimeofday(r, len);
+ result_bps = info->do_gettimeofday(r, size);
}
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
if (use_cycles) {
- printf(" %14lf cycles/Byte\n", (double)result_cycles/totallen);
+ printf(" %14lf cycles/Byte\n", (double)result_cycles/size_total);
} else {
print_bps(result_bps);
}
@@ -150,7 +150,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
case BENCH_FORMAT_SIMPLE:
if (use_cycles) {
- printf("%lf\n", (double)result_cycles/totallen);
+ printf("%lf\n", (double)result_cycles/size_total);
} else {
printf("%lf\n", result_bps);
}
@@ -165,25 +165,25 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t l
static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *info)
{
int i;
- size_t len;
- double totallen;
+ size_t size;
+ double size_total;
argc = parse_options(argc, argv, options, info->usage, 0);
if (use_cycles)
init_cycles();
- len = (size_t)perf_atoll((char *)length_str);
- totallen = (double)len * iterations;
+ size = (size_t)perf_atoll((char *)size_str);
+ size_total = (double)size * iterations;
- if ((s64)len <= 0) {
- fprintf(stderr, "Invalid length:%s\n", length_str);
+ if ((s64)size <= 0) {
+ fprintf(stderr, "Invalid size:%s\n", size_str);
return 1;
}
if (!strncmp(routine_str, "all", 3)) {
for (i = 0; info->routines[i].name; i++)
- __bench_mem_routine(info, i, len, totallen);
+ __bench_mem_routine(info, i, size, size_total);
return 0;
}
@@ -201,43 +201,43 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- __bench_mem_routine(info, i, len, totallen);
+ __bench_mem_routine(info, i, size, size_total);
return 0;
}
-static void memcpy_alloc_mem(void **dst, void **src, size_t length)
+static void memcpy_alloc_mem(void **dst, void **src, size_t size)
{
- *dst = zalloc(length);
+ *dst = zalloc(size);
if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
- *src = zalloc(length);
+ *src = zalloc(size);
if (!*src)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
/* Make sure to always prefault zero pages even if MMAP_THRESH is crossed: */
- memset(*src, 0, length);
+ memset(*src, 0, size);
}
-static u64 do_memcpy_cycles(const struct routine *r, size_t len)
+static u64 do_memcpy_cycles(const struct routine *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
memcpy_t fn = r->fn.memcpy;
int i;
- memcpy_alloc_mem(&dst, &src, len);
+ memcpy_alloc_mem(&dst, &src, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, src, len);
+ fn(dst, src, size);
cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
+ fn(dst, src, size);
cycle_end = get_cycles();
free(src);
@@ -245,24 +245,24 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t len)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
+static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
void *src = NULL, *dst = NULL;
int i;
- memcpy_alloc_mem(&dst, &src, len);
+ memcpy_alloc_mem(&dst, &src, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, src, len);
+ fn(dst, src, size);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
- fn(dst, src, len);
+ fn(dst, src, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
@@ -270,7 +270,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t len)
free(src);
free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
@@ -285,61 +285,61 @@ int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unu
return bench_mem_common(argc, argv, &info);
}
-static void memset_alloc_mem(void **dst, size_t length)
+static void memset_alloc_mem(void **dst, size_t size)
{
- *dst = zalloc(length);
+ *dst = zalloc(size);
if (!*dst)
- die("memory allocation failed - maybe length is too large?\n");
+ die("memory allocation failed - maybe size is too large?\n");
}
-static u64 do_memset_cycles(const struct routine *r, size_t len)
+static u64 do_memset_cycles(const struct routine *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
void *dst = NULL;
int i;
- memset_alloc_mem(&dst, len);
+ memset_alloc_mem(&dst, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, -1, len);
+ fn(dst, -1, size);
cycle_start = get_cycles();
for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
+ fn(dst, i, size);
cycle_end = get_cycles();
free(dst);
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t len)
+static double do_memset_gettimeofday(const struct routine *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
void *dst = NULL;
int i;
- memset_alloc_mem(&dst, len);
+ memset_alloc_mem(&dst, size);
/*
* We prefault the freshly allocated memory range here,
* to not measure page fault overhead:
*/
- fn(dst, -1, len);
+ fn(dst, -1, size);
BUG_ON(gettimeofday(&tv_start, NULL));
for (i = 0; i < iterations; ++i)
- fn(dst, i, len);
+ fn(dst, i, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
free(dst);
- return (double)(((double)len * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
static const char * const bench_mem_memset_usage[] = {
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 10/14] perf/bench/mem: Improve user visible strings
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (8 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 09/14] perf/bench/mem: Fix 'length' vs. 'size' naming confusion Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:46 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 11/14] perf/bench/mem: Reorganize the code a bit Ingo Molnar
` (4 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
- fix various typos in user visible output strings
- make the output consistent (wrt. capitalization and spelling)
- offer the list of routines to benchmark on '-r help'.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 29 +++++++++++++++++------------
tools/perf/builtin-bench.c | 6 +++---
2 files changed, 20 insertions(+), 15 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 0cd9020b8601..34faeccdce34 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -32,13 +32,17 @@ static int cycles_fd;
static const struct option options[] = {
OPT_STRING('l', "size", &size_str, "1MB",
"Specify the size of the memory buffers. "
- "Available units: B, KB, MB, GB and TB (upper and lower)"),
+ "Available units: B, KB, MB, GB and TB (case insensitive)"),
+
OPT_STRING('r', "routine", &routine_str, "all",
- "Specify the routine to run, \"all\" runs all available routines"),
+ "Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
+
OPT_INTEGER('i', "iterations", &iterations,
- "repeat memcpy() invocation this number of times"),
+ "Repeat the function this number of times"),
+
OPT_BOOLEAN('c', "cycles", &use_cycles,
"Use a cycles event instead of gettimeofday() to measure performance"),
+
OPT_END()
};
@@ -106,13 +110,13 @@ static double timeval2double(struct timeval *ts)
#define print_bps(x) do { \
if (x < K) \
- printf(" %14lf B/Sec\n", x); \
+ printf(" %14lf bytes/sec\n", x); \
else if (x < K * K) \
- printf(" %14lfd KB/Sec\n", x / K); \
+ printf(" %14lfd KB/sec\n", x / K); \
else if (x < K * K * K) \
- printf(" %14lf MB/Sec\n", x / K / K); \
+ printf(" %14lf MB/sec\n", x / K / K); \
else \
- printf(" %14lf GB/Sec\n", x / K / K / K); \
+ printf(" %14lf GB/sec\n", x / K / K / K); \
} while (0)
struct bench_mem_info {
@@ -128,10 +132,10 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t s
double result_bps = 0.0;
u64 result_cycles = 0;
- printf("routine %s (%s)\n", r->name, r->desc);
+ printf("# Routine '%s' (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
- printf("# Copying %s Bytes ...\n\n", size_str);
+ printf("# Copying %s bytes ...\n\n", size_str);
if (use_cycles) {
result_cycles = info->do_cycles(r, size);
@@ -142,7 +146,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t s
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
if (use_cycles) {
- printf(" %14lf cycles/Byte\n", (double)result_cycles/size_total);
+ printf(" %14lf cycles/byte\n", (double)result_cycles/size_total);
} else {
print_bps(result_bps);
}
@@ -192,8 +196,9 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
break;
}
if (!info->routines[i].name) {
- printf("Unknown routine: %s\n", routine_str);
- printf("Available routines...\n");
+ if (strcmp(routine_str, "help") && strcmp(routine_str, "h"))
+ printf("Unknown routine: %s\n", routine_str);
+ printf("Available routines:\n");
for (i = 0; info->routines[i].name; i++) {
printf("\t%s ... %s\n",
info->routines[i].name, info->routines[i].desc);
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index 1b585213ba5a..a8fc948c8ace 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -49,9 +49,9 @@ static struct bench sched_benchmarks[] = {
};
static struct bench mem_benchmarks[] = {
- { "memcpy", "Benchmark for memcpy()", bench_mem_memcpy },
- { "memset", "Benchmark for memset() tests", bench_mem_memset },
- { "all", "Test all memory benchmarks", NULL },
+ { "memcpy", "Benchmark for memcpy() functions", bench_mem_memcpy },
+ { "memset", "Benchmark for memset() functions", bench_mem_memset },
+ { "all", "Test all memory access benchmarks", NULL },
{ NULL, NULL, NULL }
};
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench mem: Improve user visible strings
2015-10-19 8:04 ` [PATCH 10/14] perf/bench/mem: Improve user visible strings Ingo Molnar
@ 2015-10-20 7:46 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:46 UTC (permalink / raw)
To: linux-tip-commits
Cc: mingo, peterz, jolsa, hpa, mitake, acme, namhyung, dsahern, tglx,
linux-kernel, torvalds
Commit-ID: 13b1fdce8d46027f346c0533a4323b58e2b5bad8
Gitweb: http://git.kernel.org/tip/13b1fdce8d46027f346c0533a4323b58e2b5bad8
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:26 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:07:18 -0300
perf bench mem: Improve user visible strings
- fix various typos in user visible output strings
- make the output consistent (wrt. capitalization and spelling)
- offer the list of routines to benchmark on '-r help'.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-11-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-functions.c | 29 +++++++++++++++++------------
tools/perf/builtin-bench.c | 6 +++---
2 files changed, 20 insertions(+), 15 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 1605249..318da34 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -32,13 +32,17 @@ static int cycles_fd;
static const struct option options[] = {
OPT_STRING('l', "size", &size_str, "1MB",
"Specify the size of the memory buffers. "
- "Available units: B, KB, MB, GB and TB (upper and lower)"),
+ "Available units: B, KB, MB, GB and TB (case insensitive)"),
+
OPT_STRING('r', "routine", &routine_str, "all",
- "Specify the routine to run, \"all\" runs all available routines"),
+ "Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
+
OPT_INTEGER('i', "iterations", &iterations,
- "repeat memcpy() invocation this number of times"),
+ "Repeat the function this number of times"),
+
OPT_BOOLEAN('c', "cycles", &use_cycles,
"Use a cycles event instead of gettimeofday() to measure performance"),
+
OPT_END()
};
@@ -106,13 +110,13 @@ static double timeval2double(struct timeval *ts)
#define print_bps(x) do { \
if (x < K) \
- printf(" %14lf B/Sec\n", x); \
+ printf(" %14lf bytes/sec\n", x); \
else if (x < K * K) \
- printf(" %14lfd KB/Sec\n", x / K); \
+ printf(" %14lfd KB/sec\n", x / K); \
else if (x < K * K * K) \
- printf(" %14lf MB/Sec\n", x / K / K); \
+ printf(" %14lf MB/sec\n", x / K / K); \
else \
- printf(" %14lf GB/Sec\n", x / K / K / K); \
+ printf(" %14lf GB/sec\n", x / K / K / K); \
} while (0)
struct bench_mem_info {
@@ -128,10 +132,10 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t s
double result_bps = 0.0;
u64 result_cycles = 0;
- printf("Routine %s (%s)\n", r->name, r->desc);
+ printf("# Routine '%s' (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
- printf("# Copying %s Bytes ...\n\n", size_str);
+ printf("# Copying %s bytes ...\n\n", size_str);
if (use_cycles) {
result_cycles = info->do_cycles(r, size);
@@ -142,7 +146,7 @@ static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t s
switch (bench_format) {
case BENCH_FORMAT_DEFAULT:
if (use_cycles) {
- printf(" %14lf cycles/Byte\n", (double)result_cycles/size_total);
+ printf(" %14lf cycles/byte\n", (double)result_cycles/size_total);
} else {
print_bps(result_bps);
}
@@ -192,8 +196,9 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
break;
}
if (!info->routines[i].name) {
- printf("Unknown routine: %s\n", routine_str);
- printf("Available routines...\n");
+ if (strcmp(routine_str, "help") && strcmp(routine_str, "h"))
+ printf("Unknown routine: %s\n", routine_str);
+ printf("Available routines:\n");
for (i = 0; info->routines[i].name; i++) {
printf("\t%s ... %s\n",
info->routines[i].name, info->routines[i].desc);
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index 1b58521..a8fc948 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -49,9 +49,9 @@ static struct bench sched_benchmarks[] = {
};
static struct bench mem_benchmarks[] = {
- { "memcpy", "Benchmark for memcpy()", bench_mem_memcpy },
- { "memset", "Benchmark for memset() tests", bench_mem_memset },
- { "all", "Test all memory benchmarks", NULL },
+ { "memcpy", "Benchmark for memcpy() functions", bench_mem_memcpy },
+ { "memset", "Benchmark for memset() functions", bench_mem_memset },
+ { "all", "Test all memory access benchmarks", NULL },
{ NULL, NULL, NULL }
};
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 11/14] perf/bench/mem: Reorganize the code a bit
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (9 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 10/14] perf/bench/mem: Improve user visible strings Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:46 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 12/14] perf/bench: Harmonize all the -l/--nr_loops options Ingo Molnar
` (3 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
Reorder functions a bit, so that we synchronize the layout of the
memcpy() and memset() portions of the code.
This improves the code, especially after we'll add an strlcpy()
variant as well.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 38 +++++++++++++++++++-------------------
1 file changed, 19 insertions(+), 19 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 34faeccdce34..f701b5b56079 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -58,25 +58,6 @@ struct routine {
} fn;
};
-struct routine memcpy_routines[] = {
- { .name = "default",
- .desc = "Default memcpy() provided by glibc",
- .fn.memcpy = memcpy },
-
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
-# include "mem-memcpy-x86-64-asm-def.h"
-# undef MEMCPY_FN
-#endif
-
- { NULL, }
-};
-
-static const char * const bench_mem_memcpy_usage[] = {
- "perf bench mem memcpy <options>",
- NULL
-};
-
static struct perf_event_attr cycle_attr = {
.type = PERF_TYPE_HARDWARE,
.config = PERF_COUNT_HW_CPU_CYCLES
@@ -278,6 +259,25 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
+struct routine memcpy_routines[] = {
+ { .name = "default",
+ .desc = "Default memcpy() provided by glibc",
+ .fn.memcpy = memcpy },
+
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
+# include "mem-memcpy-x86-64-asm-def.h"
+# undef MEMCPY_FN
+#endif
+
+ { NULL, }
+};
+
+static const char * const bench_mem_memcpy_usage[] = {
+ "perf bench mem memcpy <options>",
+ NULL
+};
+
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench mem: Reorganize the code a bit
2015-10-19 8:04 ` [PATCH 11/14] perf/bench/mem: Reorganize the code a bit Ingo Molnar
@ 2015-10-20 7:46 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:46 UTC (permalink / raw)
To: linux-tip-commits
Cc: tglx, torvalds, hpa, peterz, linux-kernel, jolsa, mingo, namhyung,
dsahern, acme, mitake
Commit-ID: 5dd93304a5d386c73c0a59117752acdca67f857d
Gitweb: http://git.kernel.org/tip/5dd93304a5d386c73c0a59117752acdca67f857d
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:27 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:07:19 -0300
perf bench mem: Reorganize the code a bit
Reorder functions a bit, so that we synchronize the layout of the
memcpy() and memset() portions of the code.
This improves the code, especially after we'll add an strlcpy() variant
as well.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-12-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/bench/mem-functions.c | 38 +++++++++++++++++++-------------------
1 file changed, 19 insertions(+), 19 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 318da34..8d980d4 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -58,25 +58,6 @@ struct routine {
} fn;
};
-struct routine memcpy_routines[] = {
- { .name = "default",
- .desc = "Default memcpy() provided by glibc",
- .fn.memcpy = memcpy },
-
-#ifdef HAVE_ARCH_X86_64_SUPPORT
-# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
-# include "mem-memcpy-x86-64-asm-def.h"
-# undef MEMCPY_FN
-#endif
-
- { NULL, }
-};
-
-static const char * const bench_mem_memcpy_usage[] = {
- "perf bench mem memcpy <options>",
- NULL
-};
-
static struct perf_event_attr cycle_attr = {
.type = PERF_TYPE_HARDWARE,
.config = PERF_COUNT_HW_CPU_CYCLES
@@ -278,6 +259,25 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
return (double)(((double)size * iterations) / timeval2double(&tv_diff));
}
+struct routine memcpy_routines[] = {
+ { .name = "default",
+ .desc = "Default memcpy() provided by glibc",
+ .fn.memcpy = memcpy },
+
+#ifdef HAVE_ARCH_X86_64_SUPPORT
+# define MEMCPY_FN(_fn, _name, _desc) {.name = _name, .desc = _desc, .fn.memcpy = _fn},
+# include "mem-memcpy-x86-64-asm-def.h"
+# undef MEMCPY_FN
+#endif
+
+ { NULL, }
+};
+
+static const char * const bench_mem_memcpy_usage[] = {
+ "perf bench mem memcpy <options>",
+ NULL
+};
+
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 12/14] perf/bench: Harmonize all the -l/--nr_loops options
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (10 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 11/14] perf/bench/mem: Reorganize the code a bit Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:47 ` [tip:perf/core] perf bench: Harmonize all the -l/ --nr_loops options tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 13/14] perf/bench/mem: Rename 'routine' to 'function' Ingo Molnar
` (2 subsequent siblings)
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
We have three benchmarking subsystems that specify some sort of
'number of loops' parameter - but all of them do it inconsistently:
numa: -l/--nr_loops
sched messaging: -l/--loops
mem memset/memcpy: -i/--iterations
Harmonize them to -l/--nr_loops by picking the numa variant - which
is also the most likely one to have existing scripting which we don't
want to break.
Plus improve the parameter help texts to indicate the default value
for the nr_loops variable to keep users from guessing ...
Also propagate the naming to internal variables.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 22 +++++++++++-----------
tools/perf/bench/numa.c | 4 ++--
tools/perf/bench/sched-messaging.c | 10 +++++-----
3 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index f701b5b56079..65e7297de4b1 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -25,20 +25,20 @@
static const char *size_str = "1MB";
static const char *routine_str = "all";
-static int iterations = 1;
+static int nr_loops = 1;
static bool use_cycles;
static int cycles_fd;
static const struct option options[] = {
- OPT_STRING('l', "size", &size_str, "1MB",
+ OPT_STRING('s', "size", &size_str, "1MB",
"Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (case insensitive)"),
OPT_STRING('r', "routine", &routine_str, "all",
"Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
- OPT_INTEGER('i', "iterations", &iterations,
- "Repeat the function this number of times"),
+ OPT_INTEGER('l', "nr_loops", &nr_loops,
+ "Specify the number of loops to run. (default: 1)"),
OPT_BOOLEAN('c', "cycles", &use_cycles,
"Use a cycles event instead of gettimeofday() to measure performance"),
@@ -159,7 +159,7 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
init_cycles();
size = (size_t)perf_atoll((char *)size_str);
- size_total = (double)size * iterations;
+ size_total = (double)size * nr_loops;
if ((s64)size <= 0) {
fprintf(stderr, "Invalid size:%s\n", size_str);
@@ -222,7 +222,7 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t size)
fn(dst, src, size);
cycle_start = get_cycles();
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, src, size);
cycle_end = get_cycles();
@@ -247,7 +247,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
fn(dst, src, size);
BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, src, size);
BUG_ON(gettimeofday(&tv_end, NULL));
@@ -256,7 +256,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
free(src);
free(dst);
- return (double)(((double)size * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
struct routine memcpy_routines[] = {
@@ -313,7 +313,7 @@ static u64 do_memset_cycles(const struct routine *r, size_t size)
fn(dst, -1, size);
cycle_start = get_cycles();
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, i, size);
cycle_end = get_cycles();
@@ -337,14 +337,14 @@ static double do_memset_gettimeofday(const struct routine *r, size_t size)
fn(dst, -1, size);
BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, i, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
free(dst);
- return (double)(((double)size * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
static const char * const bench_mem_memset_usage[] = {
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 870b7e665a20..492df2752a2d 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -164,8 +164,8 @@ static const struct option options[] = {
OPT_STRING('L', "mb_proc_locked", &p0.mb_proc_locked_str,"MB", "process serialized/locked memory access (MBs), <= process_memory"),
OPT_STRING('T', "mb_thread" , &p0.mb_thread_str, "MB", "thread memory (MBs)"),
- OPT_UINTEGER('l', "nr_loops" , &p0.nr_loops, "max number of loops to run"),
- OPT_UINTEGER('s', "nr_secs" , &p0.nr_secs, "max number of seconds to run"),
+ OPT_UINTEGER('l', "nr_loops" , &p0.nr_loops, "max number of loops to run (default: unlimited)"),
+ OPT_UINTEGER('s', "nr_secs" , &p0.nr_secs, "max number of seconds to run (default: 5 secs)"),
OPT_UINTEGER('u', "usleep" , &p0.sleep_usecs, "usecs to sleep per loop iteration"),
OPT_BOOLEAN('R', "data_reads" , &p0.data_reads, "access the data via writes (can be mixed with -W)"),
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index d7f281c2828d..d4ff1b539cfd 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -33,7 +33,7 @@
#define DATASIZE 100
static bool use_pipes = false;
-static unsigned int loops = 100;
+static unsigned int nr_loops = 100;
static bool thread_mode = false;
static unsigned int num_groups = 10;
@@ -79,7 +79,7 @@ static void ready(int ready_out, int wakefd)
err(EXIT_FAILURE, "poll");
}
-/* Sender sprays loops messages down each file descriptor */
+/* Sender sprays nr_loops messages down each file descriptor */
static void *sender(struct sender_context *ctx)
{
char data[DATASIZE];
@@ -88,7 +88,7 @@ static void *sender(struct sender_context *ctx)
ready(ctx->ready_out, ctx->wakefd);
/* Now pump to every receiver. */
- for (i = 0; i < loops; i++) {
+ for (i = 0; i < nr_loops; i++) {
for (j = 0; j < ctx->num_fds; j++) {
int ret, done = 0;
@@ -213,7 +213,7 @@ static unsigned int group(pthread_t *pth,
/* Create the pipe between client and server */
fdpair(fds);
- ctx->num_packets = num_fds * loops;
+ ctx->num_packets = num_fds * nr_loops;
ctx->in_fds[0] = fds[0];
ctx->in_fds[1] = fds[1];
ctx->ready_out = ready_out;
@@ -250,7 +250,7 @@ static const struct option options[] = {
OPT_BOOLEAN('t', "thread", &thread_mode,
"Be multi thread instead of multi process"),
OPT_UINTEGER('g', "group", &num_groups, "Specify number of groups"),
- OPT_UINTEGER('l', "loop", &loops, "Specify number of loops"),
+ OPT_UINTEGER('l', "nr_loops", &nr_loops, "Specify the number of loops to run (default: 100)"),
OPT_END()
};
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench: Harmonize all the -l/ --nr_loops options
2015-10-19 8:04 ` [PATCH 12/14] perf/bench: Harmonize all the -l/--nr_loops options Ingo Molnar
@ 2015-10-20 7:47 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:47 UTC (permalink / raw)
To: linux-tip-commits
Cc: mingo, hpa, namhyung, dsahern, torvalds, mitake, linux-kernel,
acme, tglx, jolsa, peterz
Commit-ID: b0d22e52e3d2c2b151dfaa0f6e01bafa5475344f
Gitweb: http://git.kernel.org/tip/b0d22e52e3d2c2b151dfaa0f6e01bafa5475344f
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:28 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:10:05 -0300
perf bench: Harmonize all the -l/--nr_loops options
We have three benchmarking subsystems that specify some sort of 'number
of loops' parameter - but all of them do it inconsistently:
numa: -l/--nr_loops
sched messaging: -l/--loops
mem memset/memcpy: -i/--iterations
Harmonize them to -l/--nr_loops by picking the numa variant - which is
also the most likely one to have existing scripting which we don't want
to break.
Plus improve the parameter help texts to indicate the default value for
the nr_loops variable to keep users from guessing ...
Also propagate the naming to internal variables.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-13-git-send-email-mingo@kernel.org
[ Let the harmonisation reach the perf-bench man page as well ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/Documentation/perf-bench.txt | 10 +++++-----
tools/perf/bench/mem-functions.c | 22 +++++++++++-----------
tools/perf/bench/numa.c | 4 ++--
tools/perf/bench/sched-messaging.c | 10 +++++-----
4 files changed, 23 insertions(+), 23 deletions(-)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index bbd27d8..ddfb3e1 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -82,7 +82,7 @@ Be multi thread instead of multi process
Specify number of groups
-l::
---loop=::
+--nr_loops=::
Specify number of loops
Example of *messaging*
@@ -149,8 +149,8 @@ Specify routine to copy (default: default).
Available routines are depend on the architecture.
On x86-64, x86-64-unrolled, x86-64-movsq and x86-64-movsb are supported.
--i::
---iterations::
+-l::
+--nr_loops::
Repeat memcpy invocation this number of times.
-c::
@@ -173,8 +173,8 @@ Specify routine to set (default: default).
Available routines are depend on the architecture.
On x86-64, x86-64-unrolled, x86-64-stosq and x86-64-stosb are supported.
--i::
---iterations::
+-l::
+--nr_loops::
Repeat memset invocation this number of times.
-c::
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 8d980d4..c5dfabd 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -25,20 +25,20 @@
static const char *size_str = "1MB";
static const char *routine_str = "all";
-static int iterations = 1;
+static int nr_loops = 1;
static bool use_cycles;
static int cycles_fd;
static const struct option options[] = {
- OPT_STRING('l', "size", &size_str, "1MB",
+ OPT_STRING('s', "size", &size_str, "1MB",
"Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (case insensitive)"),
OPT_STRING('r', "routine", &routine_str, "all",
"Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
- OPT_INTEGER('i', "iterations", &iterations,
- "Repeat the function this number of times"),
+ OPT_INTEGER('l', "nr_loops", &nr_loops,
+ "Specify the number of loops to run. (default: 1)"),
OPT_BOOLEAN('c', "cycles", &use_cycles,
"Use a cycles event instead of gettimeofday() to measure performance"),
@@ -159,7 +159,7 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
init_cycles();
size = (size_t)perf_atoll((char *)size_str);
- size_total = (double)size * iterations;
+ size_total = (double)size * nr_loops;
if ((s64)size <= 0) {
fprintf(stderr, "Invalid size:%s\n", size_str);
@@ -222,7 +222,7 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t size)
fn(dst, src, size);
cycle_start = get_cycles();
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, src, size);
cycle_end = get_cycles();
@@ -247,7 +247,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
fn(dst, src, size);
BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, src, size);
BUG_ON(gettimeofday(&tv_end, NULL));
@@ -256,7 +256,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
free(src);
free(dst);
- return (double)(((double)size * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
struct routine memcpy_routines[] = {
@@ -313,7 +313,7 @@ static u64 do_memset_cycles(const struct routine *r, size_t size)
fn(dst, -1, size);
cycle_start = get_cycles();
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, i, size);
cycle_end = get_cycles();
@@ -337,14 +337,14 @@ static double do_memset_gettimeofday(const struct routine *r, size_t size)
fn(dst, -1, size);
BUG_ON(gettimeofday(&tv_start, NULL));
- for (i = 0; i < iterations; ++i)
+ for (i = 0; i < nr_loops; ++i)
fn(dst, i, size);
BUG_ON(gettimeofday(&tv_end, NULL));
timersub(&tv_end, &tv_start, &tv_diff);
free(dst);
- return (double)(((double)size * iterations) / timeval2double(&tv_diff));
+ return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
static const char * const bench_mem_memset_usage[] = {
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 870b7e6..492df27 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -164,8 +164,8 @@ static const struct option options[] = {
OPT_STRING('L', "mb_proc_locked", &p0.mb_proc_locked_str,"MB", "process serialized/locked memory access (MBs), <= process_memory"),
OPT_STRING('T', "mb_thread" , &p0.mb_thread_str, "MB", "thread memory (MBs)"),
- OPT_UINTEGER('l', "nr_loops" , &p0.nr_loops, "max number of loops to run"),
- OPT_UINTEGER('s', "nr_secs" , &p0.nr_secs, "max number of seconds to run"),
+ OPT_UINTEGER('l', "nr_loops" , &p0.nr_loops, "max number of loops to run (default: unlimited)"),
+ OPT_UINTEGER('s', "nr_secs" , &p0.nr_secs, "max number of seconds to run (default: 5 secs)"),
OPT_UINTEGER('u', "usleep" , &p0.sleep_usecs, "usecs to sleep per loop iteration"),
OPT_BOOLEAN('R', "data_reads" , &p0.data_reads, "access the data via writes (can be mixed with -W)"),
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index d7f281c..d4ff1b5 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -33,7 +33,7 @@
#define DATASIZE 100
static bool use_pipes = false;
-static unsigned int loops = 100;
+static unsigned int nr_loops = 100;
static bool thread_mode = false;
static unsigned int num_groups = 10;
@@ -79,7 +79,7 @@ static void ready(int ready_out, int wakefd)
err(EXIT_FAILURE, "poll");
}
-/* Sender sprays loops messages down each file descriptor */
+/* Sender sprays nr_loops messages down each file descriptor */
static void *sender(struct sender_context *ctx)
{
char data[DATASIZE];
@@ -88,7 +88,7 @@ static void *sender(struct sender_context *ctx)
ready(ctx->ready_out, ctx->wakefd);
/* Now pump to every receiver. */
- for (i = 0; i < loops; i++) {
+ for (i = 0; i < nr_loops; i++) {
for (j = 0; j < ctx->num_fds; j++) {
int ret, done = 0;
@@ -213,7 +213,7 @@ static unsigned int group(pthread_t *pth,
/* Create the pipe between client and server */
fdpair(fds);
- ctx->num_packets = num_fds * loops;
+ ctx->num_packets = num_fds * nr_loops;
ctx->in_fds[0] = fds[0];
ctx->in_fds[1] = fds[1];
ctx->ready_out = ready_out;
@@ -250,7 +250,7 @@ static const struct option options[] = {
OPT_BOOLEAN('t', "thread", &thread_mode,
"Be multi thread instead of multi process"),
OPT_UINTEGER('g', "group", &num_groups, "Specify number of groups"),
- OPT_UINTEGER('l', "loop", &loops, "Specify number of loops"),
+ OPT_UINTEGER('l', "nr_loops", &nr_loops, "Specify the number of loops to run (default: 100)"),
OPT_END()
};
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 13/14] perf/bench/mem: Rename 'routine' to 'function'
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (11 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 12/14] perf/bench: Harmonize all the -l/--nr_loops options Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:47 ` [tip:perf/core] perf bench mem: " tip-bot for Ingo Molnar
2015-10-19 8:04 ` [PATCH 14/14] perf/bench: Run benchmarks, don't test them Ingo Molnar
2015-10-19 13:40 ` [PATCH 00/14] perf bench: Misc improvements David Ahern
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So right now there's a somewhat inconsistent mess of the benchmarking
code and options sometimes calling benchmarked functions 'functions',
sometimes calling them 'routines'.
Name them 'functions' consistently.
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/bench/mem-functions.c | 60 ++++++++++++++++++++++++++++++------------------------------
1 file changed, 30 insertions(+), 30 deletions(-)
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 65e7297de4b1..d8fc59092b39 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *size_str = "1MB";
-static const char *routine_str = "all";
+static const char *function_str = "all";
static int nr_loops = 1;
static bool use_cycles;
static int cycles_fd;
@@ -34,8 +34,8 @@ static const struct option options[] = {
"Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (case insensitive)"),
- OPT_STRING('r', "routine", &routine_str, "all",
- "Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
+ OPT_STRING('f', "function", &function_str, "all",
+ "Specify the function to run, \"all\" runs all available functions, \"help\" lists them"),
OPT_INTEGER('l', "nr_loops", &nr_loops,
"Specify the number of loops to run. (default: 1)"),
@@ -49,7 +49,7 @@ static const struct option options[] = {
typedef void *(*memcpy_t)(void *, const void *, size_t);
typedef void *(*memset_t)(void *, int, size_t);
-struct routine {
+struct function {
const char *name;
const char *desc;
union {
@@ -101,19 +101,19 @@ static double timeval2double(struct timeval *ts)
} while (0)
struct bench_mem_info {
- const struct routine *routines;
- u64 (*do_cycles)(const struct routine *r, size_t size);
- double (*do_gettimeofday)(const struct routine *r, size_t size);
+ const struct function *functions;
+ u64 (*do_cycles)(const struct function *r, size_t size);
+ double (*do_gettimeofday)(const struct function *r, size_t size);
const char *const *usage;
};
-static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
+static void __bench_mem_function(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
{
- const struct routine *r = &info->routines[r_idx];
+ const struct function *r = &info->functions[r_idx];
double result_bps = 0.0;
u64 result_cycles = 0;
- printf("# Routine '%s' (%s)\n", r->name, r->desc);
+ printf("# function '%s' (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s bytes ...\n\n", size_str);
@@ -166,28 +166,28 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- if (!strncmp(routine_str, "all", 3)) {
- for (i = 0; info->routines[i].name; i++)
- __bench_mem_routine(info, i, size, size_total);
+ if (!strncmp(function_str, "all", 3)) {
+ for (i = 0; info->functions[i].name; i++)
+ __bench_mem_function(info, i, size, size_total);
return 0;
}
- for (i = 0; info->routines[i].name; i++) {
- if (!strcmp(info->routines[i].name, routine_str))
+ for (i = 0; info->functions[i].name; i++) {
+ if (!strcmp(info->functions[i].name, function_str))
break;
}
- if (!info->routines[i].name) {
- if (strcmp(routine_str, "help") && strcmp(routine_str, "h"))
- printf("Unknown routine: %s\n", routine_str);
- printf("Available routines:\n");
- for (i = 0; info->routines[i].name; i++) {
+ if (!info->functions[i].name) {
+ if (strcmp(function_str, "help") && strcmp(function_str, "h"))
+ printf("Unknown function: %s\n", function_str);
+ printf("Available functions:\n");
+ for (i = 0; info->functions[i].name; i++) {
printf("\t%s ... %s\n",
- info->routines[i].name, info->routines[i].desc);
+ info->functions[i].name, info->functions[i].desc);
}
return 1;
}
- __bench_mem_routine(info, i, size, size_total);
+ __bench_mem_function(info, i, size, size_total);
return 0;
}
@@ -206,7 +206,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t size)
memset(*src, 0, size);
}
-static u64 do_memcpy_cycles(const struct routine *r, size_t size)
+static u64 do_memcpy_cycles(const struct function *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -231,7 +231,7 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t size)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
+static double do_memcpy_gettimeofday(const struct function *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -259,7 +259,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
-struct routine memcpy_routines[] = {
+struct function memcpy_functions[] = {
{ .name = "default",
.desc = "Default memcpy() provided by glibc",
.fn.memcpy = memcpy },
@@ -281,7 +281,7 @@ static const char * const bench_mem_memcpy_usage[] = {
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memcpy_routines,
+ .functions = memcpy_functions,
.do_cycles = do_memcpy_cycles,
.do_gettimeofday = do_memcpy_gettimeofday,
.usage = bench_mem_memcpy_usage,
@@ -297,7 +297,7 @@ static void memset_alloc_mem(void **dst, size_t size)
die("memory allocation failed - maybe size is too large?\n");
}
-static u64 do_memset_cycles(const struct routine *r, size_t size)
+static u64 do_memset_cycles(const struct function *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -321,7 +321,7 @@ static u64 do_memset_cycles(const struct routine *r, size_t size)
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t size)
+static double do_memset_gettimeofday(const struct function *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
@@ -352,7 +352,7 @@ static const char * const bench_mem_memset_usage[] = {
NULL
};
-static const struct routine memset_routines[] = {
+static const struct function memset_functions[] = {
{ .name = "default",
.desc = "Default memset() provided by glibc",
.fn.memset = memset },
@@ -369,7 +369,7 @@ static const struct routine memset_routines[] = {
int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memset_routines,
+ .functions = memset_functions,
.do_cycles = do_memset_cycles,
.do_gettimeofday = do_memset_gettimeofday,
.usage = bench_mem_memset_usage,
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench mem: Rename 'routine' to 'function'
2015-10-19 8:04 ` [PATCH 13/14] perf/bench/mem: Rename 'routine' to 'function' Ingo Molnar
@ 2015-10-20 7:47 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:47 UTC (permalink / raw)
To: linux-tip-commits
Cc: mingo, jolsa, mitake, acme, namhyung, dsahern, tglx, hpa, peterz,
linux-kernel, torvalds
Commit-ID: 2f211c84ad40469c15226e899b720624fbd28e20
Gitweb: http://git.kernel.org/tip/2f211c84ad40469c15226e899b720624fbd28e20
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:29 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:10:25 -0300
perf bench mem: Rename 'routine' to 'function'
So right now there's a somewhat inconsistent mess of the benchmarking
code and options sometimes calling benchmarked functions 'functions',
sometimes calling them 'routines'.
Name them 'functions' consistently.
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-14-git-send-email-mingo@kernel.org
[ Updated perf-bench man page, pointed out by David Ahern ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/Documentation/perf-bench.txt | 16 ++++-----
tools/perf/bench/mem-functions.c | 60 ++++++++++++++++-----------------
2 files changed, 38 insertions(+), 38 deletions(-)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index ddfb3e1..34750fc 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -143,10 +143,10 @@ Options of *memcpy*
Specify size of memory to copy (default: 1MB).
Available units are B, KB, MB, GB and TB (case insensitive).
--r::
---routine::
-Specify routine to copy (default: default).
-Available routines are depend on the architecture.
+-f::
+--function::
+Specify function to copy (default: default).
+Available functions are depend on the architecture.
On x86-64, x86-64-unrolled, x86-64-movsq and x86-64-movsb are supported.
-l::
@@ -167,10 +167,10 @@ Options of *memset*
Specify size of memory to set (default: 1MB).
Available units are B, KB, MB, GB and TB (case insensitive).
--r::
---routine::
-Specify routine to set (default: default).
-Available routines are depend on the architecture.
+-f::
+--function::
+Specify function to set (default: default).
+Available functions are depend on the architecture.
On x86-64, x86-64-unrolled, x86-64-stosq and x86-64-stosb are supported.
-l::
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index c5dfabd..d1de9c4 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -24,7 +24,7 @@
#define K 1024
static const char *size_str = "1MB";
-static const char *routine_str = "all";
+static const char *function_str = "all";
static int nr_loops = 1;
static bool use_cycles;
static int cycles_fd;
@@ -34,8 +34,8 @@ static const struct option options[] = {
"Specify the size of the memory buffers. "
"Available units: B, KB, MB, GB and TB (case insensitive)"),
- OPT_STRING('r', "routine", &routine_str, "all",
- "Specify the routine to run, \"all\" runs all available routines, \"help\" lists them"),
+ OPT_STRING('f', "function", &function_str, "all",
+ "Specify the function to run, \"all\" runs all available functions, \"help\" lists them"),
OPT_INTEGER('l', "nr_loops", &nr_loops,
"Specify the number of loops to run. (default: 1)"),
@@ -49,7 +49,7 @@ static const struct option options[] = {
typedef void *(*memcpy_t)(void *, const void *, size_t);
typedef void *(*memset_t)(void *, int, size_t);
-struct routine {
+struct function {
const char *name;
const char *desc;
union {
@@ -101,19 +101,19 @@ static double timeval2double(struct timeval *ts)
} while (0)
struct bench_mem_info {
- const struct routine *routines;
- u64 (*do_cycles)(const struct routine *r, size_t size);
- double (*do_gettimeofday)(const struct routine *r, size_t size);
+ const struct function *functions;
+ u64 (*do_cycles)(const struct function *r, size_t size);
+ double (*do_gettimeofday)(const struct function *r, size_t size);
const char *const *usage;
};
-static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
+static void __bench_mem_function(struct bench_mem_info *info, int r_idx, size_t size, double size_total)
{
- const struct routine *r = &info->routines[r_idx];
+ const struct function *r = &info->functions[r_idx];
double result_bps = 0.0;
u64 result_cycles = 0;
- printf("# Routine '%s' (%s)\n", r->name, r->desc);
+ printf("# function '%s' (%s)\n", r->name, r->desc);
if (bench_format == BENCH_FORMAT_DEFAULT)
printf("# Copying %s bytes ...\n\n", size_str);
@@ -166,28 +166,28 @@ static int bench_mem_common(int argc, const char **argv, struct bench_mem_info *
return 1;
}
- if (!strncmp(routine_str, "all", 3)) {
- for (i = 0; info->routines[i].name; i++)
- __bench_mem_routine(info, i, size, size_total);
+ if (!strncmp(function_str, "all", 3)) {
+ for (i = 0; info->functions[i].name; i++)
+ __bench_mem_function(info, i, size, size_total);
return 0;
}
- for (i = 0; info->routines[i].name; i++) {
- if (!strcmp(info->routines[i].name, routine_str))
+ for (i = 0; info->functions[i].name; i++) {
+ if (!strcmp(info->functions[i].name, function_str))
break;
}
- if (!info->routines[i].name) {
- if (strcmp(routine_str, "help") && strcmp(routine_str, "h"))
- printf("Unknown routine: %s\n", routine_str);
- printf("Available routines:\n");
- for (i = 0; info->routines[i].name; i++) {
+ if (!info->functions[i].name) {
+ if (strcmp(function_str, "help") && strcmp(function_str, "h"))
+ printf("Unknown function: %s\n", function_str);
+ printf("Available functions:\n");
+ for (i = 0; info->functions[i].name; i++) {
printf("\t%s ... %s\n",
- info->routines[i].name, info->routines[i].desc);
+ info->functions[i].name, info->functions[i].desc);
}
return 1;
}
- __bench_mem_routine(info, i, size, size_total);
+ __bench_mem_function(info, i, size, size_total);
return 0;
}
@@ -206,7 +206,7 @@ static void memcpy_alloc_mem(void **dst, void **src, size_t size)
memset(*src, 0, size);
}
-static u64 do_memcpy_cycles(const struct routine *r, size_t size)
+static u64 do_memcpy_cycles(const struct function *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
void *src = NULL, *dst = NULL;
@@ -231,7 +231,7 @@ static u64 do_memcpy_cycles(const struct routine *r, size_t size)
return cycle_end - cycle_start;
}
-static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
+static double do_memcpy_gettimeofday(const struct function *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memcpy_t fn = r->fn.memcpy;
@@ -259,7 +259,7 @@ static double do_memcpy_gettimeofday(const struct routine *r, size_t size)
return (double)(((double)size * nr_loops) / timeval2double(&tv_diff));
}
-struct routine memcpy_routines[] = {
+struct function memcpy_functions[] = {
{ .name = "default",
.desc = "Default memcpy() provided by glibc",
.fn.memcpy = memcpy },
@@ -281,7 +281,7 @@ static const char * const bench_mem_memcpy_usage[] = {
int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memcpy_routines,
+ .functions = memcpy_functions,
.do_cycles = do_memcpy_cycles,
.do_gettimeofday = do_memcpy_gettimeofday,
.usage = bench_mem_memcpy_usage,
@@ -297,7 +297,7 @@ static void memset_alloc_mem(void **dst, size_t size)
die("memory allocation failed - maybe size is too large?\n");
}
-static u64 do_memset_cycles(const struct routine *r, size_t size)
+static u64 do_memset_cycles(const struct function *r, size_t size)
{
u64 cycle_start = 0ULL, cycle_end = 0ULL;
memset_t fn = r->fn.memset;
@@ -321,7 +321,7 @@ static u64 do_memset_cycles(const struct routine *r, size_t size)
return cycle_end - cycle_start;
}
-static double do_memset_gettimeofday(const struct routine *r, size_t size)
+static double do_memset_gettimeofday(const struct function *r, size_t size)
{
struct timeval tv_start, tv_end, tv_diff;
memset_t fn = r->fn.memset;
@@ -352,7 +352,7 @@ static const char * const bench_mem_memset_usage[] = {
NULL
};
-static const struct routine memset_routines[] = {
+static const struct function memset_functions[] = {
{ .name = "default",
.desc = "Default memset() provided by glibc",
.fn.memset = memset },
@@ -369,7 +369,7 @@ static const struct routine memset_routines[] = {
int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
{
struct bench_mem_info info = {
- .routines = memset_routines,
+ .functions = memset_functions,
.do_cycles = do_memset_cycles,
.do_gettimeofday = do_memset_gettimeofday,
.usage = bench_mem_memset_usage,
^ permalink raw reply related [flat|nested] 44+ messages in thread
* [PATCH 14/14] perf/bench: Run benchmarks, don't test them
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (12 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 13/14] perf/bench/mem: Rename 'routine' to 'function' Ingo Molnar
@ 2015-10-19 8:04 ` Ingo Molnar
2015-10-20 7:47 ` [tip:perf/core] perf bench: " tip-bot for Ingo Molnar
2015-10-19 13:40 ` [PATCH 00/14] perf bench: Misc improvements David Ahern
14 siblings, 1 reply; 44+ messages in thread
From: Ingo Molnar @ 2015-10-19 8:04 UTC (permalink / raw)
To: linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim,
David Ahern, Jiri Olsa, Hitoshi Mitake, Linus Torvalds,
Thomas Gleixner
So right now we output this text:
memcpy: Benchmark for memcpy() functions
memset: Benchmark for memset() functions
all: Test all memory access benchmarks
But the right verb to use with benchmarks is to 'run' them,
not 'test' them.
So change this (and all similar texts) to:
memcpy: Benchmark for memcpy() functions
memset: Benchmark for memset() functions
all: Run all memory access benchmarks
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
tools/perf/builtin-bench.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index a8fc948c8ace..b17aed36ca16 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -36,7 +36,7 @@ struct bench {
#ifdef HAVE_LIBNUMA_SUPPORT
static struct bench numa_benchmarks[] = {
{ "mem", "Benchmark for NUMA workloads", bench_numa },
- { "all", "Test all NUMA benchmarks", NULL },
+ { "all", "Run all NUMA benchmarks", NULL },
{ NULL, NULL, NULL }
};
#endif
@@ -44,14 +44,14 @@ static struct bench numa_benchmarks[] = {
static struct bench sched_benchmarks[] = {
{ "messaging", "Benchmark for scheduling and IPC", bench_sched_messaging },
{ "pipe", "Benchmark for pipe() between two processes", bench_sched_pipe },
- { "all", "Test all scheduler benchmarks", NULL },
+ { "all", "Run all scheduler benchmarks", NULL },
{ NULL, NULL, NULL }
};
static struct bench mem_benchmarks[] = {
{ "memcpy", "Benchmark for memcpy() functions", bench_mem_memcpy },
{ "memset", "Benchmark for memset() functions", bench_mem_memset },
- { "all", "Test all memory access benchmarks", NULL },
+ { "all", "Run all memory access benchmarks", NULL },
{ NULL, NULL, NULL }
};
@@ -62,7 +62,7 @@ static struct bench futex_benchmarks[] = {
{ "requeue", "Benchmark for futex requeue calls", bench_futex_requeue },
/* pi-futexes */
{ "lock-pi", "Benchmark for futex lock_pi calls", bench_futex_lock_pi },
- { "all", "Test all futex benchmarks", NULL },
+ { "all", "Run all futex benchmarks", NULL },
{ NULL, NULL, NULL }
};
--
2.1.4
^ permalink raw reply related [flat|nested] 44+ messages in thread* [tip:perf/core] perf bench: Run benchmarks, don't test them
2015-10-19 8:04 ` [PATCH 14/14] perf/bench: Run benchmarks, don't test them Ingo Molnar
@ 2015-10-20 7:47 ` tip-bot for Ingo Molnar
0 siblings, 0 replies; 44+ messages in thread
From: tip-bot for Ingo Molnar @ 2015-10-20 7:47 UTC (permalink / raw)
To: linux-tip-commits
Cc: namhyung, linux-kernel, peterz, mingo, tglx, torvalds, dsahern,
hpa, mitake, jolsa, acme
Commit-ID: aa254af25c40d6d1cdc3f354db29eaf3e85a5ede
Gitweb: http://git.kernel.org/tip/aa254af25c40d6d1cdc3f354db29eaf3e85a5ede
Author: Ingo Molnar <mingo@kernel.org>
AuthorDate: Mon, 19 Oct 2015 10:04:30 +0200
Committer: Arnaldo Carvalho de Melo <acme@redhat.com>
CommitDate: Mon, 19 Oct 2015 16:10:25 -0300
perf bench: Run benchmarks, don't test them
So right now we output this text:
memcpy: Benchmark for memcpy() functions
memset: Benchmark for memset() functions
all: Test all memory access benchmarks
But the right verb to use with benchmarks is to 'run' them, not 'test'
them.
So change this (and all similar texts) to:
memcpy: Benchmark for memcpy() functions
memset: Benchmark for memset() functions
all: Run all memory access benchmarks
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Cc: David Ahern <dsahern@gmail.com>
Cc: Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/1445241870-24854-15-git-send-email-mingo@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/builtin-bench.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index a8fc948..b17aed3 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -36,7 +36,7 @@ struct bench {
#ifdef HAVE_LIBNUMA_SUPPORT
static struct bench numa_benchmarks[] = {
{ "mem", "Benchmark for NUMA workloads", bench_numa },
- { "all", "Test all NUMA benchmarks", NULL },
+ { "all", "Run all NUMA benchmarks", NULL },
{ NULL, NULL, NULL }
};
#endif
@@ -44,14 +44,14 @@ static struct bench numa_benchmarks[] = {
static struct bench sched_benchmarks[] = {
{ "messaging", "Benchmark for scheduling and IPC", bench_sched_messaging },
{ "pipe", "Benchmark for pipe() between two processes", bench_sched_pipe },
- { "all", "Test all scheduler benchmarks", NULL },
+ { "all", "Run all scheduler benchmarks", NULL },
{ NULL, NULL, NULL }
};
static struct bench mem_benchmarks[] = {
{ "memcpy", "Benchmark for memcpy() functions", bench_mem_memcpy },
{ "memset", "Benchmark for memset() functions", bench_mem_memset },
- { "all", "Test all memory access benchmarks", NULL },
+ { "all", "Run all memory access benchmarks", NULL },
{ NULL, NULL, NULL }
};
@@ -62,7 +62,7 @@ static struct bench futex_benchmarks[] = {
{ "requeue", "Benchmark for futex requeue calls", bench_futex_requeue },
/* pi-futexes */
{ "lock-pi", "Benchmark for futex lock_pi calls", bench_futex_lock_pi },
- { "all", "Test all futex benchmarks", NULL },
+ { "all", "Run all futex benchmarks", NULL },
{ NULL, NULL, NULL }
};
^ permalink raw reply related [flat|nested] 44+ messages in thread
* Re: [PATCH 00/14] perf bench: Misc improvements
2015-10-19 8:04 [PATCH 00/14] perf bench: Misc improvements Ingo Molnar
` (13 preceding siblings ...)
2015-10-19 8:04 ` [PATCH 14/14] perf/bench: Run benchmarks, don't test them Ingo Molnar
@ 2015-10-19 13:40 ` David Ahern
2015-10-19 19:01 ` Arnaldo Carvalho de Melo
14 siblings, 1 reply; 44+ messages in thread
From: David Ahern @ 2015-10-19 13:40 UTC (permalink / raw)
To: Ingo Molnar, linux-kernel
Cc: Peter Zijlstra, Arnaldo Carvalho de Melo, Namhyung Kim, Jiri Olsa
On 10/19/15 2:04 AM, Ingo Molnar wrote:
> tools/perf/bench/Build | 2 +-
> tools/perf/bench/mem-functions.c | 379 +++++++++++++++++++++++++++++++++++++++++++++++++
> tools/perf/bench/mem-memcpy.c | 434 ---------------------------------------------------------
> tools/perf/bench/numa.c | 4 +-
> tools/perf/bench/sched-messaging.c | 10 +-
> tools/perf/builtin-bench.c | 14 +-
> 6 files changed, 394 insertions(+), 449 deletions(-)
> create mode 100644 tools/perf/bench/mem-functions.c
> delete mode 100644 tools/perf/bench/mem-memcpy.c
>
tools/perf/Documentation needs updating for the user visible options.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH 00/14] perf bench: Misc improvements
2015-10-19 13:40 ` [PATCH 00/14] perf bench: Misc improvements David Ahern
@ 2015-10-19 19:01 ` Arnaldo Carvalho de Melo
0 siblings, 0 replies; 44+ messages in thread
From: Arnaldo Carvalho de Melo @ 2015-10-19 19:01 UTC (permalink / raw)
To: David Ahern
Cc: Ingo Molnar, linux-kernel, Peter Zijlstra, Namhyung Kim,
Jiri Olsa
Em Mon, Oct 19, 2015 at 07:40:36AM -0600, David Ahern escreveu:
> On 10/19/15 2:04 AM, Ingo Molnar wrote:
>
> > tools/perf/bench/Build | 2 +-
> > tools/perf/bench/mem-functions.c | 379 +++++++++++++++++++++++++++++++++++++++++++++++++
> > tools/perf/bench/mem-memcpy.c | 434 ---------------------------------------------------------
> > tools/perf/bench/numa.c | 4 +-
> > tools/perf/bench/sched-messaging.c | 10 +-
> > tools/perf/builtin-bench.c | 14 +-
> > 6 files changed, 394 insertions(+), 449 deletions(-)
> > create mode 100644 tools/perf/bench/mem-functions.c
> > delete mode 100644 tools/perf/bench/mem-memcpy.c
> >
>
> tools/perf/Documentation needs updating for the user visible options.
perf bench mem: Rename 'routine' to 'function'
changes -r to -f, fixed. Looking at the others...
^ permalink raw reply [flat|nested] 44+ messages in thread