diff options
Diffstat (limited to 'benchtests')
| -rw-r--r-- | benchtests/Makefile | 8 | ||||
| -rw-r--r-- | benchtests/bench-skeleton.c | 35 | ||||
| -rw-r--r-- | benchtests/bench-timing.h | 72 |
3 files changed, 93 insertions, 22 deletions
diff --git a/benchtests/Makefile b/benchtests/Makefile index 19e1be6f4b..861839013b 100644 --- a/benchtests/Makefile +++ b/benchtests/Makefile @@ -86,13 +86,19 @@ endif CPPFLAGS-nonlib = -DDURATION=$(BENCH_DURATION) +# Use clock_gettime to measure performance of functions. The default is to use +# HP_TIMING if it is available. +ifdef USE_CLOCK_GETTIME +CPPFLAGS-nonlib += -DUSE_CLOCK_GETTIME +endif + # This makes sure CPPFLAGS-nonlib and CFLAGS-nonlib are passed # for all these modules. cpp-srcs-left := $(binaries-bench:=.c) lib := nonlib include $(patsubst %,$(..)cppflags-iterator.mk,$(cpp-srcs-left)) -bench-deps := bench-skeleton.c Makefile +bench-deps := bench-skeleton.c bench-timing.h Makefile run-bench = $(test-wrapper-env) \ GCONV_PATH=$(common-objpfx)iconvdata LC_ALL=C \ diff --git a/benchtests/bench-skeleton.c b/benchtests/bench-skeleton.c index 404900bd64..4e3a50704d 100644 --- a/benchtests/bench-skeleton.c +++ b/benchtests/bench-skeleton.c @@ -21,6 +21,7 @@ #include <stdio.h> #include <time.h> #include <inttypes.h> +#include "bench-timing.h" volatile unsigned int dontoptimize = 0; @@ -45,21 +46,16 @@ int main (int argc, char **argv) { unsigned long i, k; - struct timespec start, end, runtime; + struct timespec runtime; + timing_t start, end; startup(); memset (&runtime, 0, sizeof (runtime)); - memset (&start, 0, sizeof (start)); - memset (&end, 0, sizeof (end)); - clock_getres (CLOCK_PROCESS_CPUTIME_ID, &start); + unsigned long iters; - /* Measure 1000 times the resolution of the clock. So for a 1ns resolution - clock, we measure 1000 iterations of the function call at a time. - Measurements close to the minimum clock resolution won't make much sense, - but it's better than having nothing at all. */ - unsigned long iters = 1000 * start.tv_nsec; + TIMING_INIT (iters); for (int v = 0; v < NUM_VARIANTS; v++) { @@ -68,19 +64,18 @@ main (int argc, char **argv) runtime.tv_sec += DURATION; double d_total_i = 0; - uint64_t total = 0, max = 0, min = 0x7fffffffffffffff; + timing_t total = 0, max = 0, min = 0x7fffffffffffffff; while (1) { for (i = 0; i < NUM_SAMPLES (v); i++) { - clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &start); + uint64_t cur; + TIMING_NOW (start); for (k = 0; k < iters; k++) BENCH_FUNC (v, i); - clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &end); + TIMING_NOW (end); - uint64_t cur = (end.tv_nsec - start.tv_nsec - + ((end.tv_sec - start.tv_sec) - * (uint64_t) 1000000000)); + TIMING_DIFF (cur, start, end); if (cur > max) max = cur; @@ -88,7 +83,7 @@ main (int argc, char **argv) if (cur < min) min = cur; - total += cur; + TIMING_ACCUM (total, cur); d_total_i += iters; } @@ -104,13 +99,11 @@ main (int argc, char **argv) double d_iters; done: - d_total_s = total * 1e-9; + d_total_s = total; d_iters = iters; - printf ("%s: ITERS:%g: TOTAL:%gs, MAX:%gns, MIN:%gns, %g iter/s\n", - VARIANT (v), - d_total_i, d_total_s, max / d_iters, min / d_iters, - d_total_i / d_total_s); + TIMING_PRINT_STATS (VARIANT (v), d_total_s, d_iters, d_total_i, max, + min); } return 0; diff --git a/benchtests/bench-timing.h b/benchtests/bench-timing.h new file mode 100644 index 0000000000..264d4b8bab --- /dev/null +++ b/benchtests/bench-timing.h @@ -0,0 +1,72 @@ +/* Define timing macros. + Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#include <hp-timing.h> +#include <stdint.h> + +#if HP_TIMING_AVAIL && !defined USE_CLOCK_GETTIME +# define GL(x) _##x +# define GLRO(x) _##x +hp_timing_t _dl_hp_timing_overhead; +typedef hp_timing_t timing_t; + +# define TIMING_INIT(iters) \ +({ \ + HP_TIMING_DIFF_INIT(); \ + (iters) = 1000; \ +}) + +# define TIMING_NOW(var) HP_TIMING_NOW (var) +# define TIMING_DIFF(diff, start, end) HP_TIMING_DIFF ((diff), (start), (end)) +# define TIMING_ACCUM(sum, diff) HP_TIMING_ACCUM_NT ((sum), (diff)) + +# define TIMING_PRINT_STATS(func, d_total_s, d_iters, d_total_i, max, min) \ + printf ("%s: ITERS:%g: TOTAL:%gMcy, MAX:%gcy, MIN:%gcy, %g calls/Mcy\n", \ + (func), (d_total_i), (d_total_s) * 1e-6, (max) / (d_iters), \ + (min) / (d_iters), 1e6 * (d_total_i) / (d_total_s)); + +#else +typedef uint64_t timing_t; + +/* Measure 1000 times the resolution of the clock. So for a 1ns + resolution clock, we measure 1000 iterations of the function call at a + time. Measurements close to the minimum clock resolution won't make + much sense, but it's better than having nothing at all. */ +# define TIMING_INIT(iters) \ +({ \ + struct timespec start; \ + clock_getres (CLOCK_PROCESS_CPUTIME_ID, &start); \ + (iters) = 1000 * start.tv_nsec; \ +}) + +# define TIMING_NOW(var) \ +({ \ + struct timespec tv; \ + clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &tv); \ + (var) = (uint64_t) (tv.tv_nsec + (uint64_t) 1000000000 * tv.tv_sec); \ +}) + +# define TIMING_DIFF(diff, start, end) (diff) = (end) - (start) +# define TIMING_ACCUM(sum, diff) (sum) += (diff) + +# define TIMING_PRINT_STATS(func, d_total_s, d_iters, d_total_i, max, min) \ + printf ("%s: ITERS:%g: TOTAL:%gs, MAX:%gns, MIN:%gns, %g iter/s\n", \ + (func), (d_total_i), (d_total_s) * 1e-9, (max) / (d_iters), \ + (min) / (d_iters), 1e9 * (d_total_i) / (d_total_s)) + +#endif |