[vector.bool] Optimize copy / move algorithms

Author: miscco

README.md

@@ -416,28 +416,28 @@ for how _we_ use it.
 To run benchmarks, you'll need to first build the STL, then build the benchmarks:
 
 ```cmd
-cmake -B out\x64 -S . -G Ninja
-cmake --build out\x64
-cmake -B out\benchmark -S benchmarks -G Ninja -DSTL_BINARY_DIR=out\x64
-cmake --build out\benchmark
+cmake -B out\build\x64 -S . -G Ninja
+cmake --build out\build\x64
+cmake -B out\build\benchmark -S benchmarks -G Ninja -DSTL_BINARY_DIR=out\build\x64
+cmake --build out\build\benchmark
 ```
 
 You can then run your benchmark with:
 
 ```cmd
-out\benchmark\benchmark-<benchmark-name> --benchmark_out=<file> --benchmark_out_format=csv
+out\build\benchmark\benchmark-<benchmark-name> --benchmark_out=<file> --benchmark_out_format=csv
 ```
 
 And then you can copy this csv file into Excel, or another spreadsheet program. For example:
 
 ```cmd
-out\bench\benchmarks\benchmark-std_copy --benchmark_out=benchmark-std_copy-results.csv --benchmark_out_format=csv
+out\build\benchmarks\benchmark-std_copy --benchmark_out=benchmark-std_copy-results.csv --benchmark_out_format=csv
 ```
 
 If you want to see all the other flags you can pass, run:
 
 ```cmd
-out\bench\benchmarks\benchmark-<benchmark-name> --help
+out\build\benchmarks\benchmark-<benchmark-name> --help
 ```
 
 # Editing And Testing The Debugger Visualizer

benchmarks/CMakeLists.txt

@@ -108,3 +108,7 @@ endfunction()
 add_benchmark(locale_classic src/locale_classic.cpp)
 add_benchmark(random_integer_generation src/random_integer_generation.cpp)
 add_benchmark(std_copy src/std_copy.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)

benchmarks/src/std/containers/sequences/vector.bool/copy/test.cpp

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <benchmark/benchmark.h>
+//
+#include <algorithm>
+#include <functional>
+#include <random>
+#include <vector>
+
+using namespace std;
+
+inline static vector<bool> createRandomVector(const size_t size) {
+    static random_device rd;
+    static mt19937 gen{random_device{}()};
+    vector<bool> result(size);
+    generate_n(result.begin(), size, [] { return bernoulli_distribution{0.5}(gen); });
+    return result;
+}
+
+static void copy_block_aligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        copy(source.cbegin(), source.cend(), dest.begin());
+    }
+}
+
+static void copy_source_missaligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        copy(source.cbegin() + 1, source.cend(), dest.begin());
+    }
+}
+
+static void copy_dest_missaligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        copy(source.cbegin(), source.cend() - 1, dest.begin() + 1);
+    }
+}
+
+// Special benchmark for matching char alignment
+static void copy_matching_alignment(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        copy(source.cbegin() + 5, source.cend(), dest.begin() + 5);
+    }
+}
+
+// Special benchmarks for single block corner case
+static void copy_both_single_blocks(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy(source.cbegin() + 5, source.cbegin() + 5 + length, dest.begin() + 5);
+    }
+}
+
+static void copy_source_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy(source.cbegin() + 5, source.cbegin() + 5 + length, dest.begin() + 25);
+    }
+}
+
+static void copy_dest_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy(source.cbegin() + 25, source.cbegin() + 25 + length, dest.begin() + 5);
+    }
+}
+
+BENCHMARK(copy_block_aligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_source_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_dest_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_matching_alignment)->RangeMultiplier(64)->Range(64, 64 << 10);
+
+BENCHMARK(copy_both_single_blocks);
+BENCHMARK(copy_source_single_block);
+BENCHMARK(copy_dest_single_block);
+
+BENCHMARK_MAIN();

benchmarks/src/std/containers/sequences/vector.bool/copy_n/test.cpp

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <benchmark/benchmark.h>
+//
+#include <algorithm>
+#include <functional>
+#include <random>
+#include <vector>
+
+using namespace std;
+
+inline static vector<bool> createRandomVector(const size_t size) {
+    static random_device rd;
+    static mt19937 gen{random_device{}()};
+    vector<bool> result(size);
+    generate_n(result.begin(), size, [] { return bernoulli_distribution{0.5}(gen); });
+    return result;
+}
+
+static void copy_n_block_aligned(benchmark::State& state) {
+    const auto size           = state.range(0);
+    const vector<bool> source = createRandomVector(size);
+    vector<bool> dest(size, false);
+
+    for (auto _ : state) {
+        copy_n(source.cbegin(), size, dest.begin());
+    }
+}
+
+static void copy_n_source_missaligned(benchmark::State& state) {
+    const auto size           = state.range(0);
+    const vector<bool> source = createRandomVector(size);
+    vector<bool> dest(size, false);
+
+    for (auto _ : state) {
+        copy_n(source.cbegin() + 1, size - 1, dest.begin());
+    }
+}
+
+static void copy_n_dest_missaligned(benchmark::State& state) {
+    const auto size           = state.range(0);
+    const vector<bool> source = createRandomVector(size);
+    vector<bool> dest(size, false);
+
+    for (auto _ : state) {
+        copy_n(source.cbegin(), size - 1, dest.begin() + 1);
+    }
+}
+
+// Special benchmark for matching char alignment
+static void copy_n_matching_alignment(benchmark::State& state) {
+    const auto size           = state.range(0);
+    const vector<bool> source = createRandomVector(size);
+    vector<bool> dest(size, false);
+
+    for (auto _ : state) {
+        copy_n(source.cbegin() + 5, size - 5, dest.begin() + 5);
+    }
+}
+
+// Special benchmarks for single block corner case
+static void copy_n_both_single_blocks(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy_n(source.cbegin() + 5, length, dest.begin() + 5);
+    }
+}
+
+static void copy_n_source_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy_n(source.cbegin() + 5, length, dest.begin() + 25);
+    }
+}
+
+static void copy_n_dest_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        copy_n(source.cbegin() + 25, length, dest.begin() + 5);
+    }
+}
+
+BENCHMARK(copy_n_block_aligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_n_source_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_n_dest_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(copy_n_matching_alignment)->RangeMultiplier(64)->Range(64, 64 << 10);
+
+BENCHMARK(copy_n_both_single_blocks);
+BENCHMARK(copy_n_source_single_block);
+BENCHMARK(copy_n_dest_single_block);
+
+BENCHMARK_MAIN();

benchmarks/src/std/containers/sequences/vector.bool/move/test.cpp

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <benchmark/benchmark.h>
+//
+#include <algorithm>
+#include <functional>
+#include <random>
+#include <vector>
+
+using namespace std;
+
+inline static vector<bool> createRandomVector(const size_t size) {
+    static random_device rd;
+    static mt19937 gen{random_device{}()};
+    vector<bool> result(size);
+    generate_n(result.begin(), size, [] { return bernoulli_distribution{0.5}(gen); });
+    return result;
+}
+
+static void move_block_aligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        move(source.cbegin(), source.cend(), dest.begin());
+    }
+}
+
+static void move_source_missaligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        move(source.cbegin() + 1, source.cend(), dest.begin());
+    }
+}
+
+static void move_dest_missaligned(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        move(source.cbegin(), source.cend() - 1, dest.begin() + 1);
+    }
+}
+
+// Special benchmark for matching char alignment
+static void move_matching_alignment(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(state.range(0));
+    vector<bool> dest(state.range(0), false);
+
+    for (auto _ : state) {
+        move(source.cbegin() + 5, source.cend(), dest.begin() + 5);
+    }
+}
+
+// Special benchmarks for single block corner case
+static void move_both_single_blocks(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        move(source.cbegin() + 5, source.cbegin() + 5 + length, dest.begin() + 5);
+    }
+}
+
+static void move_source_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        move(source.cbegin() + 5, source.cbegin() + 5 + length, dest.begin() + 25);
+    }
+}
+
+static void move_dest_single_block(benchmark::State& state) {
+    const vector<bool> source = createRandomVector(50);
+    vector<bool> dest(50, false);
+
+    const size_t length = 20;
+    for (auto _ : state) {
+        move(source.cbegin() + 25, source.cbegin() + 25 + length, dest.begin() + 5);
+    }
+}
+
+BENCHMARK(move_block_aligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(move_source_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(move_dest_missaligned)->RangeMultiplier(64)->Range(64, 64 << 10);
+BENCHMARK(move_matching_alignment)->RangeMultiplier(64)->Range(64, 64 << 10);
+
+BENCHMARK(move_both_single_blocks);
+BENCHMARK(move_source_single_block);
+BENCHMARK(move_dest_single_block);
+
+BENCHMARK_MAIN();