Re: [PATCH] Benchtests: Remove broken walk benchmarks

[Noah Goldstein <goldstein.w.n@gmail.com>]

On Mon, Mar 18, 2024 at 10:04 AM Wilco Dijkstra <Wilco.Dijkstra@arm.com> wrote:
>
>
> The walk benchmarks don't measure anything useful - memory is not initialized
> properly so doing a single walk in 32MB just measures reading the 4KB zero
> page for reads and clear_page overhead for writes.  The memset variants don't
> even manage to do a walk in the 32MB region due to using incorrect pointer
> increments...  Neither is it clear why it is walking backwards since this
> won't confuse modern prefetchers.  If you fix the benchmark and print the
> bandwidth, the results are identical for all sizes larger than ~1KB since it
> is just testing memory bandwidth of a single 32MB block.  This case is already
> tested by the large benchmark, so overall it doesn't seem useful to keep these.
>
> OK for commit?
>
> ---
>
> diff --git a/benchtests/Makefile b/benchtests/Makefile
> index 05b8751c55e7eb862efef9d99421fbbf2f4febb2..76fa33535ef1b1cc4fa4f32ed4299ad7fbbcbf11 100644
> --- a/benchtests/Makefile
> +++ b/benchtests/Makefile
> @@ -139,7 +139,6 @@ bench-string := \
>  string-benchset := \
>    bzero \
>    bzero-large \
> -  bzero-walk \
>    memccpy \
>    memchr \
>    memcmp \
> @@ -147,19 +146,15 @@ string-benchset := \
>    memcpy \
>    memcpy-large \
>    memcpy-random \
> -  memcpy-walk \
>    memmem \
>    memmove \
>    memmove-large \
> -  memmove-walk \
>    mempcpy \
>    memrchr \
>    memset \
>    memset-large \
> -  memset-walk \
>    memset-zero \
>    memset-zero-large \
> -  memset-zero-walk \
>    rawmemchr \
>    stpcpy \
>    stpcpy_chk \
> diff --git a/benchtests/bench-bzero-walk.c b/benchtests/bench-bzero-walk.c
> deleted file mode 100644
> index 48df0d77c34f82435d2ffb963067dc8d9a81ff6f..0000000000000000000000000000000000000000
> --- a/benchtests/bench-bzero-walk.c
> +++ /dev/null
> @@ -1,143 +0,0 @@
> -/* Measure memset function throughput with large data sizes.
> -   Copyright (C) 2017-2024 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
> -   <https://www.gnu.org/licenses/>.  */
> -
> -#define TEST_MAIN
> -#ifdef DO_MEMSET
> -# define TEST_NAME "memset"
> -#else
> -# define TEST_NAME "bzero"
> -#endif
> -#define START_SIZE 128
> -#define MIN_PAGE_SIZE (getpagesize () + 32 * 1024 * 1024)
> -#define TIMEOUT (20 * 60)
> -#include "bench-string.h"
> -
> -#include "json-lib.h"
> -
> -#ifdef DO_MEMSET
> -void *generic_memset (void *, int, size_t);
> -
> -typedef void *(*proto_t) (void *, int, size_t);
> -
> -IMPL (memset, 1)
> -IMPL (generic_memset, 0)
> -
> -#else
> -static void
> -memset_zero (void * s, size_t len)
> -{
> -  memset (s, '\0', len);
> -}
> -
> -typedef void (*proto_t) (void *, size_t);
> -
> -IMPL (bzero, 1)
> -IMPL (memset_zero, 0)
> -#endif
> -
> -static void
> -do_one_test (json_ctx_t *json_ctx, impl_t *impl, CHAR *s, CHAR *s_end,
> -            size_t n)
> -{
> -  size_t i, iters = MIN_PAGE_SIZE / n;
> -  timing_t start, stop, cur;
> -
> -  TIMING_NOW (start);
> -  for (i = 0; i < iters && s <= s_end; s_end -= n, i++)
> -#ifdef DO_MEMSET
> -    CALL (impl, s, 0, n);
> -#else
> -    CALL (impl, s, n);
> -#endif
> -  TIMING_NOW (stop);
> -
> -  TIMING_DIFF (cur, start, stop);
> -
> -  /* Get time taken per function call.  */
> -  json_element_double (json_ctx, (double) cur / i);
> -}
> -
> -static void
> -do_test (json_ctx_t *json_ctx, size_t len)
> -{
> -  json_element_object_begin (json_ctx);
> -  json_attr_uint (json_ctx, "length", len);
> -  json_array_begin (json_ctx, "timings");
> -
> -  FOR_EACH_IMPL (impl, 0)
> -    {
> -      do_one_test (json_ctx, impl, (CHAR *) buf1,
> -                  (CHAR *) buf1 + MIN_PAGE_SIZE - len, len);
> -      alloc_bufs ();
> -    }
> -
> -  json_array_end (json_ctx);
> -  json_element_object_end (json_ctx);
> -}
> -
> -int
> -test_main (void)
> -{
> -  json_ctx_t json_ctx;
> -  size_t i;
> -
> -  test_init ();
> -
> -  json_init (&json_ctx, 0, stdout);
> -
> -  json_document_begin (&json_ctx);
> -  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
> -
> -  json_attr_object_begin (&json_ctx, "functions");
> -  json_attr_object_begin (&json_ctx, TEST_NAME);
> -  json_attr_string (&json_ctx, "bench-variant", "walk");
> -
> -  json_array_begin (&json_ctx, "ifuncs");
> -  FOR_EACH_IMPL (impl, 0)
> -    json_element_string (&json_ctx, impl->name);
> -  json_array_end (&json_ctx);
> -
> -  json_array_begin (&json_ctx, "results");
> -  for (i = 1; i <= 64; i++)
> -    do_test (&json_ctx, i);
> -
> -  for (i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, i);
> -      do_test (&json_ctx, i + 1);
> -    }
> -
> -  json_array_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_document_end (&json_ctx);
> -
> -  return ret;
> -}
> -
> -#include <support/test-driver.c>
> -
> -#ifdef DO_MEMSET
> -# define libc_hidden_builtin_def(X)
> -# define libc_hidden_def(X)
> -# define libc_hidden_weak(X)
> -# define weak_alias(X,Y)
> -# undef MEMSET
> -# define MEMSET generic_memset
> -# include <string/memset.c>
> -#endif
> diff --git a/benchtests/bench-memcpy-walk.c b/benchtests/bench-memcpy-walk.c
> deleted file mode 100644
> index 661a40ccd1fe6a669f717319b676f60b39cb56af..0000000000000000000000000000000000000000
> --- a/benchtests/bench-memcpy-walk.c
> +++ /dev/null
> @@ -1,131 +0,0 @@
> -/* Measure memcpy function combined throughput for different alignments.
> -   Copyright (C) 2017-2024 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
> -   <https://www.gnu.org/licenses/>.  */
> -
> -/* This microbenchmark measures the throughput of memcpy for various sizes from
> -   1 byte to 32MiB, doubling every iteration and then misaligning by 0-15
> -   bytes.  The copies are done from source to destination and then back and the
> -   source walks forward across the array and the destination walks backward by
> -   one byte each, thus measuring misaligned accesses as well.  The idea is to
> -   avoid caching effects by copying a different string and far enough from each
> -   other, walking in different directions so that we can measure prefetcher
> -   efficiency (software or hardware) more closely than with a loop copying the
> -   same data over and over, which eventually only gives us L1 cache
> -   performance.  */
> -
> -#ifndef MEMCPY_RESULT
> -# define MEMCPY_RESULT(dst, len) dst
> -# define START_SIZE 128
> -# define MIN_PAGE_SIZE (getpagesize () + 32 * 1024 * 1024)
> -# define TEST_MAIN
> -# define TEST_NAME "memcpy"
> -# define TIMEOUT (20 * 60)
> -# include "bench-string.h"
> -
> -IMPL (memcpy, 1)
> -#endif
> -
> -#include "json-lib.h"
> -
> -typedef char *(*proto_t) (char *, const char *, size_t);
> -
> -static void
> -do_one_test (json_ctx_t *json_ctx, impl_t *impl, char *dst, char *src,
> -            size_t len)
> -{
> -  size_t i = 0;
> -  timing_t start, stop, cur;
> -
> -  char *dst_end = dst + MIN_PAGE_SIZE - len;
> -  char *src_end = src + MIN_PAGE_SIZE - len;
> -
> -  TIMING_NOW (start);
> -  /* Copy the entire buffer backwards, LEN at a time.  */
> -  for (; src_end >= src && dst_end >= dst; src_end -= len, dst_end -= len, i++)
> -    CALL (impl, src_end, dst_end, len);
> -  TIMING_NOW (stop);
> -
> -  TIMING_DIFF (cur, start, stop);
> -
> -  /* Get time taken per function call.  */
> -  json_element_double (json_ctx, (double) cur / i);
> -}
> -
> -static void
> -do_test (json_ctx_t *json_ctx, size_t len, int both_ways)
> -{
> -
> -  char *s1, *s2;
> -  size_t repeats;
> -  s1 = (char *) (buf1);
> -  s2 = (char *) (buf2);
> -
> -  for (repeats = both_ways ? 2 : 1; repeats; --repeats)
> -    {
> -      json_element_object_begin (json_ctx);
> -      json_attr_uint (json_ctx, "length", (double) len);
> -      json_attr_uint (json_ctx, "dst > src", (double) (s2 > s1));
> -      json_array_begin (json_ctx, "timings");
> -
> -      FOR_EACH_IMPL (impl, 0)
> -        do_one_test (json_ctx, impl, s2, s1, len);
> -
> -      json_array_end (json_ctx);
> -      json_element_object_end (json_ctx);
> -
> -      s1 = (char *) (buf2);
> -      s2 = (char *) (buf1);
> -    }
> -}
> -
> -int
> -test_main (void)
> -{
> -  json_ctx_t json_ctx;
> -
> -  test_init ();
> -
> -  json_init (&json_ctx, 0, stdout);
> -
> -  json_document_begin (&json_ctx);
> -  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
> -
> -  json_attr_object_begin (&json_ctx, "functions");
> -  json_attr_object_begin (&json_ctx, "memcpy");
> -  json_attr_string (&json_ctx, "bench-variant", "walk");
> -
> -  json_array_begin (&json_ctx, "ifuncs");
> -  FOR_EACH_IMPL (impl, 0)
> -    json_element_string (&json_ctx, impl->name);
> -  json_array_end (&json_ctx);
> -
> -  json_array_begin (&json_ctx, "results");
> -  for (size_t i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, i, 1);
> -      do_test (&json_ctx, i + 1, 1);
> -    }
> -
> -  json_array_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_document_end (&json_ctx);
> -
> -  return ret;
> -}
> -
> -#include <support/test-driver.c>
> diff --git a/benchtests/bench-memmove-walk.c b/benchtests/bench-memmove-walk.c
> deleted file mode 100644
> index 94b394eb8b22c1d82490002061a4eae469e29dbd..0000000000000000000000000000000000000000
> --- a/benchtests/bench-memmove-walk.c
> +++ /dev/null
> @@ -1,160 +0,0 @@
> -/* Measure memmove function combined throughput for different alignments.
> -   Copyright (C) 2017-2024 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
> -   <https://www.gnu.org/licenses/>.  */
> -
> -/* This microbenchmark measures the throughput of memmove for various sizes from
> -   1 byte to 32MiB, doubling every iteration and then misaligning by 0-15
> -   bytes.  The copies are done from source to destination and then back and the
> -   source walks forward across the array and the destination walks backward by
> -   one byte each, thus measuring misaligned accesses as well.  The idea is to
> -   avoid caching effects by copying a different string and far enough from each
> -   other, walking in different directions so that we can measure prefetcher
> -   efficiency (software or hardware) more closely than with a loop copying the
> -   same data over and over, which eventually only gives us L1 cache
> -   performance.  */
> -
> -#ifndef MEMMOVE_RESULT
> -# define MEMMOVE_RESULT(dst, len) dst
> -# define START_SIZE 128
> -# define MIN_PAGE_SIZE (getpagesize () + 32 * 1024 * 1024)
> -# define TEST_MAIN
> -# define TEST_NAME "memmove"
> -# define TIMEOUT (20 * 60)
> -# include "bench-string.h"
> -
> -#define NO_OVERLAP 0
> -#define PARTIAL_OVERLAP 1
> -#define COMPLETE_OVERLAP 2
> -
> -IMPL (memmove, 1)
> -#endif
> -
> -#include "json-lib.h"
> -
> -typedef char *(*proto_t) (char *, const char *, size_t);
> -
> -static void
> -do_one_test (json_ctx_t *json_ctx, impl_t *impl, char *dst, char *src,
> -            size_t len)
> -{
> -  size_t i = 0;
> -  timing_t start, stop, cur;
> -
> -  char *dst_end = dst + MIN_PAGE_SIZE - len;
> -  char *src_end = src + MIN_PAGE_SIZE - len;
> -
> -  TIMING_NOW (start);
> -  /* Copy the entire buffer backwards, LEN at a time.  */
> -  for (; src_end >= src && dst <= dst_end; dst += len, src_end -= len, i++)
> -    CALL (impl, dst, src_end, len);
> -  TIMING_NOW (stop);
> -
> -  TIMING_DIFF (cur, start, stop);
> -
> -  /* Get time taken per function call.  */
> -  json_element_double (json_ctx, (double) cur / i);
> -}
> -
> -static void
> -do_test (json_ctx_t *json_ctx, size_t len, int overlap, int both_ways)
> -{
> -  char *s1, *s2, *tmp;
> -  size_t repeats;
> -
> -  s1 = (char *) (buf1);
> -  s2 = (char *) (buf2);
> -  if (overlap != NO_OVERLAP)
> -    s2 = s1;
> -  if (overlap == PARTIAL_OVERLAP)
> -    s2 += len / 2;
> -
> -  for (repeats = both_ways ? 2 : 1; repeats; --repeats)
> -    {
> -      json_element_object_begin (json_ctx);
> -      json_attr_uint (json_ctx, "length", (double) len);
> -      json_attr_string(json_ctx, "overlap",
> -                       overlap == NO_OVERLAP        ? "none"
> -                       : overlap == PARTIAL_OVERLAP ? "partial"
> -                                                    : "complete");
> -      json_attr_uint (json_ctx, "dst > src", (double) (s2 > s1));
> -      json_array_begin (json_ctx, "timings");
> -
> -
> -      FOR_EACH_IMPL (impl, 0)
> -        do_one_test (json_ctx, impl, (char *) buf2, (char *) buf1, len);
> -
> -      json_array_end (json_ctx);
> -      json_element_object_end (json_ctx);
> -
> -      tmp = s1;
> -      s1 = s2;
> -      s2 = tmp;
> -    }
> -}
> -
> -int
> -test_main (void)
> -{
> -  json_ctx_t json_ctx;
> -
> -  test_init ();
> -
> -  json_init (&json_ctx, 0, stdout);
> -
> -  json_document_begin (&json_ctx);
> -  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
> -
> -  json_attr_object_begin (&json_ctx, "functions");
> -  json_attr_object_begin (&json_ctx, "memmove");
> -  json_attr_string (&json_ctx, "bench-variant", "walk");
> -
> -  json_array_begin (&json_ctx, "ifuncs");
> -  FOR_EACH_IMPL (impl, 0)
> -    json_element_string (&json_ctx, impl->name);
> -  json_array_end (&json_ctx);
> -
> -  json_array_begin (&json_ctx, "results");
> -  /* Non-overlapping buffers.  */
> -  for (size_t i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, i, NO_OVERLAP, 1);
> -      do_test (&json_ctx, i + 1, NO_OVERLAP, 1);
> -    }
> -
> -  /* Partially-overlapping buffers.  */
> -  for (size_t i = START_SIZE; i <= MIN_PAGE_SIZE / 2; i <<= 1)
> -    {
> -      do_test (&json_ctx, i, PARTIAL_OVERLAP, 1);
> -      do_test (&json_ctx, i + 1, PARTIAL_OVERLAP, 1);
> -    }
> -
> -  /* Complete-overlapping buffers.  */
> -  for (size_t i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, i, COMPLETE_OVERLAP, 0);
> -      do_test (&json_ctx, i + 1, COMPLETE_OVERLAP, 0);
> -    }
> -
> -  json_array_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_document_end (&json_ctx);
> -
> -  return ret;
> -}
> -
> -#include <support/test-driver.c>
> diff --git a/benchtests/bench-memset-walk.c b/benchtests/bench-memset-walk.c
> deleted file mode 100644
> index 7be904a4507db60b5fc46dee03f5a681da960de5..0000000000000000000000000000000000000000
> --- a/benchtests/bench-memset-walk.c
> +++ /dev/null
> @@ -1,122 +0,0 @@
> -/* Measure memset function throughput with large data sizes.
> -   Copyright (C) 2017-2024 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
> -   <https://www.gnu.org/licenses/>.  */
> -
> -#define TEST_MAIN
> -#define TEST_NAME "memset"
> -#define START_SIZE 128
> -#define MIN_PAGE_SIZE (getpagesize () + 32 * 1024 * 1024)
> -#define TIMEOUT (20 * 60)
> -#include "bench-string.h"
> -
> -#include "json-lib.h"
> -
> -void *generic_memset (void *, int, size_t);
> -typedef void *(*proto_t) (void *, int, size_t);
> -
> -IMPL (MEMSET, 1)
> -IMPL (generic_memset, 0)
> -
> -static void
> -do_one_test (json_ctx_t *json_ctx, impl_t *impl, CHAR *s, CHAR *s_end,
> -            int c __attribute ((unused)), size_t n)
> -{
> -  size_t i, iters = MIN_PAGE_SIZE / n;
> -  timing_t start, stop, cur;
> -
> -  TIMING_NOW (start);
> -  for (i = 0; i < iters && s <= s_end; s_end -= n, i++)
> -    CALL (impl, s, c, n);
> -  TIMING_NOW (stop);
> -
> -  TIMING_DIFF (cur, start, stop);
> -
> -  /* Get time taken per function call.  */
> -  json_element_double (json_ctx, (double) cur / i);
> -}
> -
> -static void
> -do_test (json_ctx_t *json_ctx, int c, size_t len)
> -{
> -  json_element_object_begin (json_ctx);
> -  json_attr_uint (json_ctx, "length", len);
> -  json_attr_uint (json_ctx, "char", c);
> -  json_array_begin (json_ctx, "timings");
> -
> -  FOR_EACH_IMPL (impl, 0)
> -    {
> -      do_one_test (json_ctx, impl, (CHAR *) buf1,
> -                  (CHAR *) buf1 + MIN_PAGE_SIZE - len, c, len);
> -      alloc_bufs ();
> -    }
> -
> -  json_array_end (json_ctx);
> -  json_element_object_end (json_ctx);
> -}
> -
> -int
> -test_main (void)
> -{
> -  json_ctx_t json_ctx;
> -  size_t i;
> -
> -  test_init ();
> -
> -  json_init (&json_ctx, 0, stdout);
> -
> -  json_document_begin (&json_ctx);
> -  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
> -
> -  json_attr_object_begin (&json_ctx, "functions");
> -  json_attr_object_begin (&json_ctx, TEST_NAME);
> -  json_attr_string (&json_ctx, "bench-variant", "walk");
> -
> -  json_array_begin (&json_ctx, "ifuncs");
> -  FOR_EACH_IMPL (impl, 0)
> -    json_element_string (&json_ctx, impl->name);
> -  json_array_end (&json_ctx);
> -
> -  json_array_begin (&json_ctx, "results");
> -  for (i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, 65, i);
> -      do_test (&json_ctx, 65, i + 1);
> -    }
> -
> -  for (i = START_SIZE; i <= MIN_PAGE_SIZE; i <<= 1)
> -    {
> -      do_test (&json_ctx, 0, i);
> -      do_test (&json_ctx, 0, i + 1);
> -    }
> -
> -  json_array_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_attr_object_end (&json_ctx);
> -  json_document_end (&json_ctx);
> -
> -  return ret;
> -}
> -
> -#include <support/test-driver.c>
> -
> -#define libc_hidden_builtin_def(X)
> -#define libc_hidden_def(X)
> -#define libc_hidden_weak(X)
> -#define weak_alias(X,Y)
> -#undef MEMSET
> -#define MEMSET generic_memset
> -#include <string/memset.c>
> diff --git a/benchtests/bench-memset-zero-walk.c b/benchtests/bench-memset-zero-walk.c
> deleted file mode 100644
> index 200a17f128f08cf18cddb2b31c331dc9cad3899c..0000000000000000000000000000000000000000
> --- a/benchtests/bench-memset-zero-walk.c
> +++ /dev/null
> @@ -1,20 +0,0 @@
> -/* Measure memset functions for zeroing throughput with large data sizes.
> -   Copyright (C) 2022-2024 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
> -   <https://www.gnu.org/licenses/>.  */
> -
> -#define DO_MEMSET 1
> -#include "bench-bzero-walk.c"
>
+1