google-benchmark 1.9.2 and other cleanups

NOTICE.txt

@@ -216,13 +216,3 @@ In addition, certain files include the notices provided below.
 // shall not be used in advertising or otherwise to promote the sale,
 // use or other dealings in these Data Files or Software without prior
 // written authorization of the copyright holder.
-
-----------------------
-
-/*  Written in 2018 by David Blackman and Sebastiano Vigna ([email protected])
-
-To the extent possible under law, the author has dedicated all copyright
-and related and neighboring rights to this software to the public domain
-worldwide. This software is distributed without any warranty.
-
-See <http://creativecommons.org/publicdomain/zero/1.0/>. */

benchmarks/CMakeLists.txt

@@ -46,23 +46,15 @@ set_property(CACHE STL_BENCHMARK_MSVC_RUNTIME_LIBRARY
 )
 set(CMAKE_MSVC_RUNTIME_LIBRARY "${STL_BENCHMARK_MSVC_RUNTIME_LIBRARY}")
 
-set(STL_BENCHMARK_ITERATOR_DEBUG_LEVEL
-    default
-    CACHE STRING "What level of iterator debugging to use."
-)
-set_property(CACHE STL_BENCHMARK_ITERATOR_DEBUG_LEVEL
-    PROPERTY STRINGS
-    "default;0;1;2"
-)
-
-if(NOT STL_BENCHMARK_ITERATOR_DEBUG_LEVEL STREQUAL "default")
-    add_compile_definitions("_ITERATOR_DEBUG_LEVEL=${STL_BENCHMARK_ITERATOR_DEBUG_LEVEL}")
-endif()
-
-set(CMAKE_BUILD_TYPE RelWithDebInfo)
+# Building the benchmarks as Release optimizes them with `/O2 /Ob2`.
+# Compiling with `/Zi` and linking with `/DEBUG` below makes profiling possible.
+# (RelWithDebInfo would use `/O2 /Ob1 /Zi`.) See GH-4496.
+set(CMAKE_BUILD_TYPE Release)
 
 # /utf-8 affects <format>.
-add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:/diagnostics:caret;/W4;/WX;/w14265;/w15038;/w15262;/utf-8;/Zc:preprocessor>")
+add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:/Zi;/nologo;/diagnostics:caret;/W4;/WX;/w14265;/w15038;/w15262;/utf-8;/Zc:preprocessor>")
+
+add_link_options("/DEBUG")
 
 if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/google-benchmark/.git")
     message(FATAL_ERROR "google-benchmark is not checked out; make sure to run\n    git submodule update --init benchmarks/google-benchmark")
@@ -72,15 +64,13 @@ set(BENCHMARK_ENABLE_DOXYGEN OFF)
 set(BENCHMARK_ENABLE_INSTALL OFF)
 set(BENCHMARK_ENABLE_TESTING OFF)
 
-set(HAVE_GNU_POSIX_REGEX OFF)
-set(HAVE_POSIX_REGEX OFF)
-
 add_subdirectory(google-benchmark EXCLUDE_FROM_ALL)
 
 set(benchmark_headers
+    "inc/lorem.hpp"
+    "inc/skewed_allocator.hpp"
     "inc/udt.hpp"
     "inc/utility.hpp"
-    "inc/xoshiro.hpp"
 )
 
 function(add_benchmark name)
@@ -130,7 +120,6 @@ add_benchmark(std_copy src/std_copy.cpp)
 add_benchmark(sv_equal src/sv_equal.cpp)
 add_benchmark(swap_ranges src/swap_ranges.cpp)
 add_benchmark(unique src/unique.cpp)
-
-add_benchmark(vector_bool_copy src/std/containers/sequences/vector.bool/copy/test.cpp)
-add_benchmark(vector_bool_copy_n src/std/containers/sequences/vector.bool/copy_n/test.cpp)
-add_benchmark(vector_bool_move src/std/containers/sequences/vector.bool/move/test.cpp)
+add_benchmark(vector_bool_copy src/vector_bool_copy.cpp)
+add_benchmark(vector_bool_copy_n src/vector_bool_copy_n.cpp)
+add_benchmark(vector_bool_move src/vector_bool_move.cpp)

benchmarks/inc/utility.hpp

@@ -5,17 +5,12 @@
 
 #include <algorithm>
 #include <cstddef>
-#include <cstdint>
 #include <random>
 #include <vector>
 
-#include <xoshiro.hpp>
-
 template <class Contained>
 std::vector<Contained> random_vector(size_t n) {
-    std::random_device rd;
-    std::uniform_int_distribution<std::uint64_t> id64;
-    xoshiro256ss prng{id64(rd), id64(rd), id64(rd), id64(rd)};
+    std::mt19937_64 prng;
 
     std::vector<Contained> res(n);
 
@@ -25,7 +20,7 @@ std::vector<Contained> random_vector(size_t n) {
 // but is insufficient for aggregate<Data> or non_trivial<Data>.
 #pragma warning(push)
 #pragma warning(disable : 4244) // warning C4244: conversion from 'uint64_t' to 'Data', possible loss of data
-    std::generate(res.begin(), res.end(), [&prng] { return static_cast<Contained>(prng.next()); });
+    std::generate(res.begin(), res.end(), [&prng] { return static_cast<Contained>(prng()); });
 #pragma warning(pop)
 
     return res;

benchmarks/src/bitset_from_string.cpp

@@ -12,89 +12,86 @@
 
 using namespace std;
 
-namespace {
-    template <size_t N, class charT, size_t Min_length>
-    auto random_digits_init() {
-        mt19937_64 rnd{};
-        uniform_int_distribution<> dis('0', '1');
+template <size_t N, class charT, size_t Min_length>
+auto random_digits_init() {
+    mt19937_64 rnd{};
+    uniform_int_distribution<> dis('0', '1');
 
-        constexpr size_t number_of_bitsets = (Min_length + N - 1) / N;
-        static_assert(number_of_bitsets != 0);
+    constexpr size_t number_of_bitsets = (Min_length + N - 1) / N;
+    static_assert(number_of_bitsets != 0);
 
-        constexpr size_t actual_size = number_of_bitsets * (N + 1); // +1 for \0
+    constexpr size_t actual_size = number_of_bitsets * (N + 1); // +1 for \0
 
-        array<charT, actual_size> result;
+    array<charT, actual_size> result;
 
-        for (size_t i = 0; i < actual_size; ++i) {
-            if (i % (N + 1) == N) {
-                result[i] = charT{'\0'}; // write null terminators
-            } else {
-                result[i] = static_cast<charT>(dis(rnd)); // fill random digits
-            }
+    for (size_t i = 0; i < actual_size; ++i) {
+        if (i % (N + 1) == N) {
+            result[i] = charT{'\0'}; // write null terminators
+        } else {
+            result[i] = static_cast<charT>(dis(rnd)); // fill random digits
         }
-
-        return result;
     }
 
-    enum class length_type : bool { char_count, null_term };
-
-    template <size_t N, class charT>
-    const auto random_digits = random_digits_init<N, charT, 2048>();
-
-    template <length_type Length, size_t N, class charT>
-    void bitset_from_string(benchmark::State& state) {
-        const auto& digit_array = random_digits<N, charT>;
-        for (auto _ : state) {
-            benchmark::DoNotOptimize(digit_array);
-            const auto arr_data = digit_array.data();
-            const auto arr_size = digit_array.size();
-            for (size_t pos = 0; pos != arr_size; pos += N + 1) {
-                if constexpr (Length == length_type::char_count) {
-                    bitset<N> bs(arr_data + pos, N);
-                    benchmark::DoNotOptimize(bs);
-                } else {
-                    bitset<N> bs(arr_data + pos);
-                    benchmark::DoNotOptimize(bs);
-                }
+    return result;
+}
+
+enum class length_type : bool { char_count, null_term };
+
+template <size_t N, class charT>
+const auto random_digits = random_digits_init<N, charT, 2048>();
+
+template <length_type Length, size_t N, class charT>
+void bitset_from_string(benchmark::State& state) {
+    const auto& digit_array = random_digits<N, charT>;
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(digit_array);
+        const auto arr_data = digit_array.data();
+        const auto arr_size = digit_array.size();
+        for (size_t pos = 0; pos != arr_size; pos += N + 1) {
+            if constexpr (Length == length_type::char_count) {
+                bitset<N> bs(arr_data + pos, N);
+                benchmark::DoNotOptimize(bs);
+            } else {
+                bitset<N> bs(arr_data + pos);
+                benchmark::DoNotOptimize(bs);
             }
         }
     }
-
-    template <class charT, size_t Length>
-    basic_string<charT> random_digits_contiguous_string_init() {
-        mt19937_64 rnd{};
-        uniform_int_distribution<> dis('0', '1');
-
-        basic_string<charT> result;
-
-        result.resize_and_overwrite(Length, [&](charT* ptr, size_t) {
-            generate_n(ptr, Length, [&] { return static_cast<charT>(dis(rnd)); });
-            return Length;
-        });
-
-        return result;
-    }
-
-    template <class charT, size_t Length>
-    const auto random_digits_contiguous_string = random_digits_contiguous_string_init<charT, Length>();
-
-    template <size_t N, class charT>
-    void bitset_from_stream(benchmark::State& state) {
-        constexpr size_t string_length = 2048;
-        constexpr size_t count         = string_length / N;
-        basic_istringstream<charT> stream(random_digits_contiguous_string<charT, string_length>);
-        bitset<N> bs;
-        for (auto _ : state) {
-            benchmark::DoNotOptimize(stream);
-            for (size_t i = 0; i != count; ++i) {
-                stream >> bs;
-            }
-            benchmark::DoNotOptimize(bs);
-            stream.seekg(0);
+}
+
+template <class charT, size_t Length>
+basic_string<charT> random_digits_contiguous_string_init() {
+    mt19937_64 rnd{};
+    uniform_int_distribution<> dis('0', '1');
+
+    basic_string<charT> result;
+
+    result.resize_and_overwrite(Length, [&](charT* ptr, size_t) {
+        generate_n(ptr, Length, [&] { return static_cast<charT>(dis(rnd)); });
+        return Length;
+    });
+
+    return result;
+}
+
+template <class charT, size_t Length>
+const auto random_digits_contiguous_string = random_digits_contiguous_string_init<charT, Length>();
+
+template <size_t N, class charT>
+void bitset_from_stream(benchmark::State& state) {
+    constexpr size_t string_length = 2048;
+    constexpr size_t count         = string_length / N;
+    basic_istringstream<charT> stream(random_digits_contiguous_string<charT, string_length>);
+    bitset<N> bs;
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(stream);
+        for (size_t i = 0; i != count; ++i) {
+            stream >> bs;
         }
+        benchmark::DoNotOptimize(bs);
+        stream.seekg(0);
     }
-
-} // namespace
+}
 
 BENCHMARK(bitset_from_string<length_type::char_count, 15, char>);
 BENCHMARK(bitset_from_string<length_type::char_count, 16, char>);

benchmarks/src/bitset_to_string.cpp

@@ -12,45 +12,43 @@
 
 using namespace std;
 
-namespace {
-    template <size_t Elems>
-    auto random_bits_init() {
-        mt19937_64 rnd{};
-        array<uint64_t, Elems> arr;
-        for (auto& d : arr) {
-            d = rnd();
-        }
-        return arr;
+template <size_t Elems>
+auto random_bits_init() {
+    mt19937_64 rnd{};
+    array<uint64_t, Elems> arr;
+    for (auto& d : arr) {
+        d = rnd();
     }
+    return arr;
+}
 
-    template <size_t Elems = 32>
-    const auto random_bits = random_bits_init<Elems>();
+template <size_t Elems = 32>
+const auto random_bits = random_bits_init<Elems>();
 
-    template <size_t N, class charT>
-    void BM_bitset_to_string(benchmark::State& state) {
-        static_assert(N <= 64);
+template <size_t N, class charT>
+void BM_bitset_to_string(benchmark::State& state) {
+    static_assert(N <= 64);
 
-        for (auto _ : state) {
-            for (const auto& bits : random_bits<>) {
-                benchmark::DoNotOptimize(bits);
-                bitset<N> bs{bits};
-                benchmark::DoNotOptimize(bs.to_string<charT>());
-            }
+    for (auto _ : state) {
+        for (const auto& bits : random_bits<>) {
+            benchmark::DoNotOptimize(bits);
+            bitset<N> bs{bits};
+            benchmark::DoNotOptimize(bs.to_string<charT>());
         }
     }
+}
 
-    template <size_t N, class charT>
-    void BM_bitset_to_string_large_single(benchmark::State& state) {
-        static_assert(N % 64 == 0 && N >= 64);
-        const auto& bitset_data = random_bits<N / 64>;
+template <size_t N, class charT>
+void BM_bitset_to_string_large_single(benchmark::State& state) {
+    static_assert(N % 64 == 0 && N >= 64);
+    const auto& bitset_data = random_bits<N / 64>;
 
-        const auto large_bitset = bit_cast<bitset<N>>(bitset_data);
-        for (auto _ : state) {
-            benchmark::DoNotOptimize(large_bitset);
-            benchmark::DoNotOptimize(large_bitset.to_string<charT>());
-        }
+    const auto large_bitset = bit_cast<bitset<N>>(bitset_data);
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(large_bitset);
+        benchmark::DoNotOptimize(large_bitset.to_string<charT>());
     }
-} // namespace
+}
 
 BENCHMARK(BM_bitset_to_string<15, char>);
 BENCHMARK(BM_bitset_to_string<64, char>);