[libcxx-commits] [libcxx] [libc++] Optimize ranges::move{, _backward} for vector<bool>::iterator (PR #121109)
Peng Liu via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Dec 25 07:42:24 PST 2024
https://github.com/winner245 updated https://github.com/llvm/llvm-project/pull/121109
>From aee5865cd7ed31084b92da218e8b40b88e3f0603 Mon Sep 17 00:00:00 2001
From: Peng Liu <winner245 at hotmail.com>
Date: Mon, 23 Dec 2024 15:34:15 -0500
Subject: [PATCH] Optimize ranges::move{,_backward} for vector<bool>::iterator
---
libcxx/include/__algorithm/move.h | 10 ++
libcxx/include/__algorithm/move_backward.h | 10 ++
libcxx/include/__bit_reference | 16 ---
.../test/benchmarks/algorithms/move.bench.cpp | 55 +++++++++
.../algorithms/move_backward.bench.cpp | 55 +++++++++
.../alg.move/move.pass.cpp | 57 +++++++--
.../alg.move/move_backward.pass.cpp | 64 +++++++---
.../alg.move/ranges.move.pass.cpp | 102 +++++++++++-----
.../alg.move/ranges.move_backward.pass.cpp | 113 ++++++++++++------
9 files changed, 372 insertions(+), 110 deletions(-)
create mode 100644 libcxx/test/benchmarks/algorithms/move.bench.cpp
create mode 100644 libcxx/test/benchmarks/algorithms/move_backward.bench.cpp
diff --git a/libcxx/include/__algorithm/move.h b/libcxx/include/__algorithm/move.h
index 005099dcac06e3..dbea92c067ccb4 100644
--- a/libcxx/include/__algorithm/move.h
+++ b/libcxx/include/__algorithm/move.h
@@ -9,11 +9,13 @@
#ifndef _LIBCPP___ALGORITHM_MOVE_H
#define _LIBCPP___ALGORITHM_MOVE_H
+#include <__algorithm/copy.h>
#include <__algorithm/copy_move_common.h>
#include <__algorithm/for_each_segment.h>
#include <__algorithm/iterator_operations.h>
#include <__algorithm/min.h>
#include <__config>
+#include <__fwd/bit_reference.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/segmented_iterator.h>
#include <__type_traits/common_type.h>
@@ -98,6 +100,14 @@ struct __move_impl {
}
}
+ template <class _Cp, bool _IsConst>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
+ operator()(__bit_iterator<_Cp, _IsConst> __first,
+ __bit_iterator<_Cp, _IsConst> __last,
+ __bit_iterator<_Cp, false> __result) {
+ return std::__copy(__first, __last, __result);
+ }
+
// At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
template <class _In, class _Out, __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
diff --git a/libcxx/include/__algorithm/move_backward.h b/libcxx/include/__algorithm/move_backward.h
index 24a8d9b24527a7..14482fee181147 100644
--- a/libcxx/include/__algorithm/move_backward.h
+++ b/libcxx/include/__algorithm/move_backward.h
@@ -9,10 +9,12 @@
#ifndef _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
#define _LIBCPP___ALGORITHM_MOVE_BACKWARD_H
+#include <__algorithm/copy_backward.h>
#include <__algorithm/copy_move_common.h>
#include <__algorithm/iterator_operations.h>
#include <__algorithm/min.h>
#include <__config>
+#include <__fwd/bit_reference.h>
#include <__iterator/iterator_traits.h>
#include <__iterator/segmented_iterator.h>
#include <__type_traits/common_type.h>
@@ -107,6 +109,14 @@ struct __move_backward_impl {
}
}
+ template <class _Cp, bool _IsConst>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
+ operator()(__bit_iterator<_Cp, _IsConst> __first,
+ __bit_iterator<_Cp, _IsConst> __last,
+ __bit_iterator<_Cp, false> __result) {
+ return std::__copy_backward<_ClassicAlgPolicy>(__first, __last, __result);
+ }
+
// At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
template <class _In, class _Out, __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
diff --git a/libcxx/include/__bit_reference b/libcxx/include/__bit_reference
index 9fa24c98d493fd..a86513d81f1820 100644
--- a/libcxx/include/__bit_reference
+++ b/libcxx/include/__bit_reference
@@ -421,22 +421,6 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, f
return std::__copy_backward_unaligned(__first, __last, __result);
}
-// move
-
-template <class _Cp, bool _IsConst>
-inline _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
- return std::copy(__first, __last, __result);
-}
-
-// move_backward
-
-template <class _Cp, bool _IsConst>
-inline _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> move_backward(
- __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
- return std::copy_backward(__first, __last, __result);
-}
-
// swap_ranges
template <class _Cl, class _Cr>
diff --git a/libcxx/test/benchmarks/algorithms/move.bench.cpp b/libcxx/test/benchmarks/algorithms/move.bench.cpp
new file mode 100644
index 00000000000000..8fe42c5964fb88
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/move.bench.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <vector>
+
+static void bm_ranges_move(benchmark::State& state, bool aligned) {
+ auto n = state.range();
+ std::vector<bool> in(n, true);
+ std::vector<bool> out(aligned ? n : n + 8);
+ benchmark::DoNotOptimize(&in);
+ auto dst = aligned ? out.begin() : out.begin() + 4;
+ for (auto _ : state) {
+ benchmark::DoNotOptimize(std::ranges::move(in, dst));
+ benchmark::DoNotOptimize(&out);
+ }
+}
+
+static void bm_move(benchmark::State& state, bool aligned) {
+ auto n = state.range();
+ std::vector<bool> in(n, true);
+ std::vector<bool> out(aligned ? n : n + 8);
+ benchmark::DoNotOptimize(&in);
+ auto beg = in.begin();
+ auto end = in.end();
+ auto dst = aligned ? out.begin() : out.begin() + 4;
+ for (auto _ : state) {
+ benchmark::DoNotOptimize(std::move(beg, end, dst));
+ benchmark::DoNotOptimize(&out);
+ }
+}
+
+static void bm_ranges_move_aligned(benchmark::State& state) { bm_ranges_move(state, true); }
+static void bm_ranges_move_unaligned(benchmark::State& state) { bm_ranges_move(state, false); }
+
+static void bm_move_aligned(benchmark::State& state) { bm_move(state, true); }
+static void bm_move_unaligned(benchmark::State& state) { bm_move(state, false); }
+
+// Test std::ranges::move for vector<bool>::iterator
+BENCHMARK(bm_ranges_move_aligned)->Range(8, 1 << 20);
+BENCHMARK(bm_ranges_move_unaligned)->Range(8, 1 << 20);
+
+// Test std::move for vector<bool>::iterator
+BENCHMARK(bm_move_aligned)->Range(8, 1 << 20);
+BENCHMARK(bm_move_unaligned)->Range(8, 1 << 20);
+
+BENCHMARK_MAIN();
diff --git a/libcxx/test/benchmarks/algorithms/move_backward.bench.cpp b/libcxx/test/benchmarks/algorithms/move_backward.bench.cpp
new file mode 100644
index 00000000000000..c1c420f1d5426d
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/move_backward.bench.cpp
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <vector>
+
+static void bm_ranges_move_backward(benchmark::State& state, bool aligned) {
+ auto n = state.range();
+ std::vector<bool> in(n, true);
+ std::vector<bool> out(aligned ? n : n + 8);
+ benchmark::DoNotOptimize(&in);
+ auto dst = aligned ? out.end() : out.end() - 4;
+ for (auto _ : state) {
+ benchmark::DoNotOptimize(std::ranges::move_backward(in, dst));
+ benchmark::DoNotOptimize(&out);
+ }
+}
+
+static void bm_move_backward(benchmark::State& state, bool aligned) {
+ auto n = state.range();
+ std::vector<bool> in(n, true);
+ std::vector<bool> out(aligned ? n : n + 8);
+ benchmark::DoNotOptimize(&in);
+ auto beg = in.begin();
+ auto end = in.end();
+ auto dst = aligned ? out.end() : out.end() - 4;
+ for (auto _ : state) {
+ benchmark::DoNotOptimize(std::move_backward(beg, end, dst));
+ benchmark::DoNotOptimize(&out);
+ }
+}
+
+static void bm_ranges_move_backward_aligned(benchmark::State& state) { bm_ranges_move_backward(state, true); }
+static void bm_ranges_move_backward_unaligned(benchmark::State& state) { bm_ranges_move_backward(state, false); }
+
+static void bm_move_backward_aligned(benchmark::State& state) { bm_move_backward(state, true); }
+static void bm_move_backward_unaligned(benchmark::State& state) { bm_move_backward(state, false); }
+
+// Test std::ranges::move_backward for vector<bool>::iterator
+BENCHMARK(bm_ranges_move_backward_aligned)->Range(8, 1 << 20);
+BENCHMARK(bm_ranges_move_backward_unaligned)->Range(8, 1 << 20);
+
+// Test std::move_backward for vector<bool>::iterator
+BENCHMARK(bm_move_backward_aligned)->Range(8, 1 << 20);
+BENCHMARK(bm_move_backward_unaligned)->Range(8, 1 << 20);
+
+BENCHMARK_MAIN();
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
index b1ad6873bc5e5a..74ec579a8676f3 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -20,6 +20,7 @@
#include <cassert>
#include <iterator>
#include <memory>
+#include <vector>
#include "MoveOnly.h"
#include "test_iterators.h"
@@ -45,15 +46,15 @@ struct Test {
template <class OutIter>
TEST_CONSTEXPR_CXX20 void operator()() {
const unsigned N = 1000;
- int ia[N] = {};
+ int ia[N] = {};
for (unsigned i = 0; i < N; ++i)
- ia[i] = i;
+ ia[i] = i;
int ib[N] = {0};
- OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
- assert(base(r) == ib+N);
+ OutIter r = std::move(InIter(ia), InIter(ia + N), OutIter(ib));
+ assert(base(r) == ib + N);
for (unsigned i = 0; i < N; ++i)
- assert(ia[i] == ib[i]);
+ assert(ia[i] == ib[i]);
}
};
@@ -73,13 +74,13 @@ struct Test1 {
const unsigned N = 100;
std::unique_ptr<int> ia[N];
for (unsigned i = 0; i < N; ++i)
- ia[i].reset(new int(i));
+ ia[i].reset(new int(i));
std::unique_ptr<int> ib[N];
- OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
- assert(base(r) == ib+N);
+ OutIter r = std::move(InIter(ia), InIter(ia + N), OutIter(ib));
+ assert(base(r) == ib + N);
for (unsigned i = 0; i < N; ++i)
- assert(*ib[i] == static_cast<int>(i));
+ assert(*ib[i] == static_cast<int>(i));
}
};
@@ -92,6 +93,30 @@ struct Test1OutIters {
}
};
+#if TEST_STD_VER >= 23
+template <std::size_t N>
+struct TestBitIter {
+ std::vector<bool> in;
+ TEST_CONSTEXPR_CXX20 TestBitIter() : in(N, false) {
+ for (std::size_t i = 0; i < N; i += 2)
+ in[i] = true;
+ }
+ TEST_CONSTEXPR_CXX20 void operator()() {
+ { // Test move with aligned bytes
+ std::vector<bool> out(N);
+ std::move(in.begin(), in.end(), out.begin());
+ assert(in == out);
+ }
+ { // Test move with unaligned bytes
+ std::vector<bool> out(N + 8);
+ std::move(in.begin(), in.end(), out.begin() + 4);
+ for (std::size_t i = 0; i < N; ++i)
+ assert(out[i + 4] == in[i]);
+ }
+ }
+};
+#endif
+
TEST_CONSTEXPR_CXX20 bool test() {
types::for_each(types::cpp17_input_iterator_list<int*>(), TestOutIters());
if (TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED)
@@ -118,7 +143,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
// When non-trivial
{
MoveOnly from[3] = {1, 2, 3};
- MoveOnly to[3] = {};
+ MoveOnly to[3] = {};
std::move(std::begin(from), std::end(from), std::begin(to));
assert(to[0] == MoveOnly(1));
assert(to[1] == MoveOnly(2));
@@ -127,7 +152,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
// When trivial
{
TrivialMoveOnly from[3] = {1, 2, 3};
- TrivialMoveOnly to[3] = {};
+ TrivialMoveOnly to[3] = {};
std::move(std::begin(from), std::end(from), std::begin(to));
assert(to[0] == TrivialMoveOnly(1));
assert(to[1] == TrivialMoveOnly(2));
@@ -135,6 +160,16 @@ TEST_CONSTEXPR_CXX20 bool test() {
}
}
+#if TEST_STD_VER >= 23
+ { // Test vector<bool>::iterator optimization
+ TestBitIter<8>()();
+ TestBitIter<16>()();
+ TestBitIter<32>()();
+ TestBitIter<64>()();
+ TestBitIter<1024>()();
+ }
+#endif
+
return true;
}
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
index 61dea47b510716..6856d25a44190c 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -19,6 +19,7 @@
#include <cassert>
#include <iterator>
#include <memory>
+#include <vector>
#include "MoveOnly.h"
#include "test_iterators.h"
@@ -44,24 +45,22 @@ struct Test {
template <class OutIter>
TEST_CONSTEXPR_CXX20 void operator()() {
const unsigned N = 1000;
- int ia[N] = {};
+ int ia[N] = {};
for (unsigned i = 0; i < N; ++i)
- ia[i] = i;
+ ia[i] = i;
int ib[N] = {0};
- OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
+ OutIter r = std::move_backward(InIter(ia), InIter(ia + N), OutIter(ib + N));
assert(base(r) == ib);
for (unsigned i = 0; i < N; ++i)
- assert(ia[i] == ib[i]);
+ assert(ia[i] == ib[i]);
}
};
struct TestOutIters {
template <class InIter>
TEST_CONSTEXPR_CXX20 void operator()() {
- types::for_each(
- types::concatenate_t<types::bidirectional_iterator_list<int*> >(),
- Test<InIter>());
+ types::for_each(types::concatenate_t<types::bidirectional_iterator_list<int*> >(), Test<InIter>());
}
};
@@ -72,24 +71,48 @@ struct Test1 {
const unsigned N = 100;
std::unique_ptr<int> ia[N];
for (unsigned i = 0; i < N; ++i)
- ia[i].reset(new int(i));
+ ia[i].reset(new int(i));
std::unique_ptr<int> ib[N];
- OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
+ OutIter r = std::move_backward(InIter(ia), InIter(ia + N), OutIter(ib + N));
assert(base(r) == ib);
for (unsigned i = 0; i < N; ++i)
- assert(*ib[i] == static_cast<int>(i));
+ assert(*ib[i] == static_cast<int>(i));
}
};
struct Test1OutIters {
template <class InIter>
TEST_CONSTEXPR_CXX23 void operator()() {
- types::for_each(types::concatenate_t<types::bidirectional_iterator_list<std::unique_ptr<int>*> >(),
- Test1<InIter>());
+ types::for_each(
+ types::concatenate_t<types::bidirectional_iterator_list<std::unique_ptr<int>*> >(), Test1<InIter>());
}
};
+#if TEST_STD_VER >= 23
+template <std::size_t N>
+struct TestBitIter {
+ std::vector<bool> in;
+ TEST_CONSTEXPR_CXX20 TestBitIter() : in(N, false) {
+ for (std::size_t i = 0; i < N; i += 2)
+ in[i] = true;
+ }
+ TEST_CONSTEXPR_CXX20 void operator()() {
+ { // Test move_backward with aligned bytes
+ std::vector<bool> out(N);
+ std::move_backward(in.begin(), in.end(), out.end());
+ assert(in == out);
+ }
+ { // Test move_backward with unaligned bytes
+ std::vector<bool> out(N + 8);
+ std::move_backward(in.begin(), in.end(), out.end() - 4);
+ for (std::size_t i = 0; i < N; ++i)
+ assert(out[i + 4] == in[i]);
+ }
+ }
+};
+#endif
+
TEST_CONSTEXPR_CXX20 bool test() {
types::for_each(types::bidirectional_iterator_list<int*>(), TestOutIters());
if (TEST_STD_AT_LEAST_23_OR_RUNTIME_EVALUATED)
@@ -117,7 +140,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
// When non-trivial
{
MoveOnly from[3] = {1, 2, 3};
- MoveOnly to[3] = {};
+ MoveOnly to[3] = {};
std::move_backward(std::begin(from), std::end(from), std::end(to));
assert(to[0] == MoveOnly(1));
assert(to[1] == MoveOnly(2));
@@ -126,7 +149,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
// When trivial
{
TrivialMoveOnly from[3] = {1, 2, 3};
- TrivialMoveOnly to[3] = {};
+ TrivialMoveOnly to[3] = {};
std::move_backward(std::begin(from), std::end(from), std::end(to));
assert(to[0] == TrivialMoveOnly(1));
assert(to[1] == TrivialMoveOnly(2));
@@ -134,11 +157,20 @@ TEST_CONSTEXPR_CXX20 bool test() {
}
}
+#if TEST_STD_VER >= 23
+ { // Test vector<bool>::iterator optimization
+ TestBitIter<8>()();
+ TestBitIter<16>()();
+ TestBitIter<32>()();
+ TestBitIter<64>()();
+ TestBitIter<1024>()();
+ }
+#endif
+
return true;
}
-int main(int, char**)
-{
+int main(int, char**) {
test();
#if TEST_STD_VER >= 20
static_assert(test());
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
index a0d1473360a14e..8fb3234b98af62 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp
@@ -65,7 +65,7 @@ constexpr void test(std::array<int, N> in) {
{
std::array<int, N> out;
std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
- std::ranges::move(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data()));
+ std::ranges::move(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data()));
assert(in == out);
assert(base(ret.in) == in.data() + in.size());
assert(base(ret.out) == out.data() + out.size());
@@ -73,8 +73,7 @@ constexpr void test(std::array<int, N> in) {
{
std::array<int, N> out;
auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
- std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
- std::ranges::move(range, Out(out.data()));
+ std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret = std::ranges::move(range, Out(out.data()));
assert(in == out);
assert(base(ret.in) == in.data() + in.size());
assert(base(ret.out) == out.data() + out.size());
@@ -84,16 +83,16 @@ constexpr void test(std::array<int, N> in) {
template <class InContainer, class OutContainer, class In, class Out, class Sent = In>
constexpr void test_containers() {
{
- InContainer in {1, 2, 3, 4};
+ InContainer in{1, 2, 3, 4};
OutContainer out(4);
std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
- std::ranges::move(In(in.begin()), Sent(In(in.end())), Out(out.begin()));
+ std::ranges::move(In(in.begin()), Sent(In(in.end())), Out(out.begin()));
assert(std::ranges::equal(in, out));
assert(base(ret.in) == in.end());
assert(base(ret.out) == out.end());
}
{
- InContainer in {1, 2, 3, 4};
+ InContainer in{1, 2, 3, 4};
OutContainer out(4);
auto range = std::ranges::subrange(In(in.begin()), Sent(In(in.end())));
std::same_as<std::ranges::in_out_result<In, Out>> auto ret = std::ranges::move(range, Out(out.begin()));
@@ -165,22 +164,51 @@ constexpr void test_proxy_in_iterators() {
}
struct IteratorWithMoveIter {
- using value_type = int;
- using difference_type = int;
+ using value_type = int;
+ using difference_type = int;
explicit IteratorWithMoveIter() = default;
int* ptr;
constexpr IteratorWithMoveIter(int* ptr_) : ptr(ptr_) {}
constexpr int& operator*() const; // iterator with iter_move should not be dereferenced
- constexpr IteratorWithMoveIter& operator++() { ++ptr; return *this; }
- constexpr IteratorWithMoveIter operator++(int) { auto ret = *this; ++*this; return ret; }
+ constexpr IteratorWithMoveIter& operator++() {
+ ++ptr;
+ return *this;
+ }
+ constexpr IteratorWithMoveIter operator++(int) {
+ auto ret = *this;
+ ++*this;
+ return ret;
+ }
friend constexpr int iter_move(const IteratorWithMoveIter&) { return 42; }
constexpr bool operator==(const IteratorWithMoveIter& other) const = default;
};
+template <std::size_t N>
+struct TestBitIter {
+ std::vector<bool> in;
+ TEST_CONSTEXPR_CXX20 TestBitIter() : in(N, false) {
+ for (std::size_t i = 0; i < N; i += 2)
+ in[i] = true;
+ }
+ TEST_CONSTEXPR_CXX20 void operator()() {
+ { // Test move with aligned bytes
+ std::vector<bool> out(N);
+ std::ranges::move(in, out.begin());
+ assert(in == out);
+ }
+ { // Test move with unaligned bytes
+ std::vector<bool> out(N + 8);
+ std::ranges::move(in, out.begin() + 4);
+ for (std::size_t i = 0; i < N; ++i)
+ assert(out[i + 4] == in[i]);
+ }
+ }
+};
+
// cpp17_intput_iterator has a defaulted template argument
template <class Iter>
using Cpp17InIter = cpp17_input_iterator<Iter>;
@@ -267,13 +295,13 @@ constexpr bool test() {
{ // check that ranges::dangling is returned
std::array<int, 4> out;
std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> decltype(auto) ret =
- std::ranges::move(std::array {1, 2, 3, 4}, out.data());
+ std::ranges::move(std::array{1, 2, 3, 4}, out.data());
assert(ret.out == out.data() + 4);
assert((out == std::array{1, 2, 3, 4}));
}
{ // check that an iterator is returned with a borrowing range
- std::array in {1, 2, 3, 4};
+ std::array in{1, 2, 3, 4};
std::array<int, 4> out;
std::same_as<std::ranges::in_out_result<std::array<int, 4>::iterator, int*>> decltype(auto) ret =
std::ranges::move(std::views::all(in), out.data());
@@ -284,8 +312,8 @@ constexpr bool test() {
{ // check that every element is moved exactly once
struct MoveOnce {
- bool moved = false;
- constexpr MoveOnce() = default;
+ bool moved = false;
+ constexpr MoveOnce() = default;
constexpr MoveOnce(const MoveOnce& other) = delete;
constexpr MoveOnce& operator=(MoveOnce&& other) {
assert(!other.moved);
@@ -294,16 +322,16 @@ constexpr bool test() {
}
};
{
- std::array<MoveOnce, 4> in {};
- std::array<MoveOnce, 4> out {};
+ std::array<MoveOnce, 4> in{};
+ std::array<MoveOnce, 4> out{};
auto ret = std::ranges::move(in.begin(), in.end(), out.begin());
assert(ret.in == in.end());
assert(ret.out == out.end());
assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
}
{
- std::array<MoveOnce, 4> in {};
- std::array<MoveOnce, 4> out {};
+ std::array<MoveOnce, 4> in{};
+ std::array<MoveOnce, 4> out{};
auto ret = std::ranges::move(in, out.begin());
assert(ret.in == in.end());
assert(ret.out == out.end());
@@ -314,8 +342,8 @@ constexpr bool test() {
{ // check that the range is moved forwards
struct OnlyForwardsMovable {
OnlyForwardsMovable* next = nullptr;
- bool canMove = false;
- OnlyForwardsMovable() = default;
+ bool canMove = false;
+ OnlyForwardsMovable() = default;
constexpr OnlyForwardsMovable& operator=(OnlyForwardsMovable&&) {
assert(canMove);
if (next != nullptr)
@@ -324,12 +352,12 @@ constexpr bool test() {
}
};
{
- std::array<OnlyForwardsMovable, 3> in {};
- std::array<OnlyForwardsMovable, 3> out {};
- out[0].next = &out[1];
- out[1].next = &out[2];
+ std::array<OnlyForwardsMovable, 3> in{};
+ std::array<OnlyForwardsMovable, 3> out{};
+ out[0].next = &out[1];
+ out[1].next = &out[2];
out[0].canMove = true;
- auto ret = std::ranges::move(in.begin(), in.end(), out.begin());
+ auto ret = std::ranges::move(in.begin(), in.end(), out.begin());
assert(ret.in == in.end());
assert(ret.out == out.end());
assert(out[0].canMove);
@@ -337,12 +365,12 @@ constexpr bool test() {
assert(out[2].canMove);
}
{
- std::array<OnlyForwardsMovable, 3> in {};
- std::array<OnlyForwardsMovable, 3> out {};
- out[0].next = &out[1];
- out[1].next = &out[2];
+ std::array<OnlyForwardsMovable, 3> in{};
+ std::array<OnlyForwardsMovable, 3> out{};
+ out[0].next = &out[1];
+ out[1].next = &out[2];
out[0].canMove = true;
- auto ret = std::ranges::move(in, out.begin());
+ auto ret = std::ranges::move(in, out.begin());
assert(ret.in == in.end());
assert(ret.out == out.end());
assert(out[0].canMove);
@@ -358,19 +386,27 @@ constexpr bool test() {
auto ret = std::ranges::move(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4), b.data());
assert(ret.in == a + 4);
assert(ret.out == b.data() + 4);
- assert((b == std::array {42, 42, 42, 42}));
+ assert((b == std::array{42, 42, 42, 42}));
}
{
int a[] = {1, 2, 3, 4};
std::array<int, 4> b;
auto range = std::ranges::subrange(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4));
- auto ret = std::ranges::move(range, b.data());
+ auto ret = std::ranges::move(range, b.data());
assert(ret.in == a + 4);
assert(ret.out == b.data() + 4);
- assert((b == std::array {42, 42, 42, 42}));
+ assert((b == std::array{42, 42, 42, 42}));
}
}
+ { // Test vector<bool>::iterator optimization
+ TestBitIter<8>()();
+ TestBitIter<16>()();
+ TestBitIter<32>()();
+ TestBitIter<64>()();
+ TestBitIter<1024>()();
+ }
+
return true;
}
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
index 47cf178636ad13..f83a52bfd6c33c 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp
@@ -65,7 +65,7 @@ constexpr void test(std::array<int, N> in) {
{
std::array<int, N> out;
std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
- std::ranges::move_backward(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data() + out.size()));
+ std::ranges::move_backward(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data() + out.size()));
assert(in == out);
assert(base(ret.in) == in.data() + in.size());
assert(base(ret.out) == out.data());
@@ -92,16 +92,16 @@ constexpr void test_iterators() {
template <class InContainer, class OutContainer, class In, class Out, class Sent = In>
constexpr void test_containers() {
{
- InContainer in {1, 2, 3, 4};
+ InContainer in{1, 2, 3, 4};
OutContainer out(4);
std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
- std::ranges::move_backward(In(in.begin()), Sent(In(in.end())), Out(out.end()));
+ std::ranges::move_backward(In(in.begin()), Sent(In(in.end())), Out(out.end()));
assert(std::ranges::equal(in, out));
assert(base(ret.in) == in.end());
assert(base(ret.out) == out.begin());
}
{
- InContainer in {1, 2, 3, 4};
+ InContainer in{1, 2, 3, 4};
OutContainer out(4);
auto range = std::ranges::subrange(In(in.begin()), Sent(In(in.end())));
std::same_as<std::ranges::in_out_result<In, Out>> auto ret = std::ranges::move_backward(range, Out(out.end()));
@@ -159,25 +159,61 @@ constexpr void test_proxy_in_iterators() {
}
struct IteratorWithMoveIter {
- using value_type = int;
- using difference_type = int;
+ using value_type = int;
+ using difference_type = int;
explicit IteratorWithMoveIter() = default;
int* ptr;
constexpr IteratorWithMoveIter(int* ptr_) : ptr(ptr_) {}
constexpr int& operator*() const; // iterator with iter_move should not be dereferenced
- constexpr IteratorWithMoveIter& operator++() { ++ptr; return *this; }
- constexpr IteratorWithMoveIter operator++(int) { auto ret = *this; ++*this; return ret; }
+ constexpr IteratorWithMoveIter& operator++() {
+ ++ptr;
+ return *this;
+ }
+ constexpr IteratorWithMoveIter operator++(int) {
+ auto ret = *this;
+ ++*this;
+ return ret;
+ }
- constexpr IteratorWithMoveIter& operator--() { --ptr; return *this; }
- constexpr IteratorWithMoveIter operator--(int) { auto ret = *this; --*this; return ret; }
+ constexpr IteratorWithMoveIter& operator--() {
+ --ptr;
+ return *this;
+ }
+ constexpr IteratorWithMoveIter operator--(int) {
+ auto ret = *this;
+ --*this;
+ return ret;
+ }
friend constexpr int iter_move(const IteratorWithMoveIter&) { return 42; }
constexpr bool operator==(const IteratorWithMoveIter& other) const = default;
};
+template <std::size_t N>
+struct TestBitIter {
+ std::vector<bool> in;
+ TEST_CONSTEXPR_CXX20 TestBitIter() : in(N, false) {
+ for (std::size_t i = 0; i < N; i += 2)
+ in[i] = true;
+ }
+ TEST_CONSTEXPR_CXX20 void operator()() {
+ { // Test move_backward with aligned bytes
+ std::vector<bool> out(N);
+ std::ranges::move_backward(in, out.end());
+ assert(in == out);
+ }
+ { // Test move_backward with unaligned bytes
+ std::vector<bool> out(N + 8);
+ std::ranges::move_backward(in, out.end() - 4);
+ for (std::size_t i = 0; i < N; ++i)
+ assert(out[i + 4] == in[i]);
+ }
+ }
+};
+
constexpr bool test() {
test_in_iterators<bidirectional_iterator>();
test_in_iterators<random_access_iterator>();
@@ -243,7 +279,8 @@ constexpr bool test() {
MoveOnly b[3];
ProxyRange proxyA{a};
ProxyRange proxyB{b};
- std::ranges::move_backward(std::begin(proxyA), std::end(proxyA), std::ranges::next(proxyB.begin(), std::end(proxyB)));
+ std::ranges::move_backward(
+ std::begin(proxyA), std::end(proxyA), std::ranges::next(proxyB.begin(), std::end(proxyB)));
assert(b[0].get() == 1);
assert(b[1].get() == 2);
assert(b[2].get() == 3);
@@ -253,13 +290,13 @@ constexpr bool test() {
{ // check that ranges::dangling is returned
std::array<int, 4> out;
std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> auto ret =
- std::ranges::move_backward(std::array {1, 2, 3, 4}, out.data() + out.size());
+ std::ranges::move_backward(std::array{1, 2, 3, 4}, out.data() + out.size());
assert(ret.out == out.data());
assert((out == std::array{1, 2, 3, 4}));
}
{ // check that an iterator is returned with a borrowing range
- std::array in {1, 2, 3, 4};
+ std::array in{1, 2, 3, 4};
std::array<int, 4> out;
std::same_as<std::ranges::in_out_result<std::array<int, 4>::iterator, int*>> auto ret =
std::ranges::move_backward(std::views::all(in), out.data() + out.size());
@@ -270,8 +307,8 @@ constexpr bool test() {
{ // check that every element is moved exactly once
struct MoveOnce {
- bool moved = false;
- constexpr MoveOnce() = default;
+ bool moved = false;
+ constexpr MoveOnce() = default;
constexpr MoveOnce(const MoveOnce& other) = delete;
constexpr MoveOnce& operator=(const MoveOnce& other) {
assert(!other.moved);
@@ -280,16 +317,16 @@ constexpr bool test() {
}
};
{
- std::array<MoveOnce, 4> in {};
- std::array<MoveOnce, 4> out {};
+ std::array<MoveOnce, 4> in{};
+ std::array<MoveOnce, 4> out{};
auto ret = std::ranges::move_backward(in.begin(), in.end(), out.end());
assert(ret.in == in.end());
assert(ret.out == out.begin());
assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
}
{
- std::array<MoveOnce, 4> in {};
- std::array<MoveOnce, 4> out {};
+ std::array<MoveOnce, 4> in{};
+ std::array<MoveOnce, 4> out{};
auto ret = std::ranges::move_backward(in, out.end());
assert(ret.in == in.end());
assert(ret.out == out.begin());
@@ -300,8 +337,8 @@ constexpr bool test() {
{ // check that the range is moved backwards
struct OnlyBackwardsMovable {
OnlyBackwardsMovable* next = nullptr;
- bool canMove = false;
- OnlyBackwardsMovable() = default;
+ bool canMove = false;
+ OnlyBackwardsMovable() = default;
constexpr OnlyBackwardsMovable& operator=(const OnlyBackwardsMovable&) {
assert(canMove);
if (next != nullptr)
@@ -310,12 +347,12 @@ constexpr bool test() {
}
};
{
- std::array<OnlyBackwardsMovable, 3> in {};
- std::array<OnlyBackwardsMovable, 3> out {};
- out[1].next = &out[0];
- out[2].next = &out[1];
+ std::array<OnlyBackwardsMovable, 3> in{};
+ std::array<OnlyBackwardsMovable, 3> out{};
+ out[1].next = &out[0];
+ out[2].next = &out[1];
out[2].canMove = true;
- auto ret = std::ranges::move_backward(in, out.end());
+ auto ret = std::ranges::move_backward(in, out.end());
assert(ret.in == in.end());
assert(ret.out == out.begin());
assert(out[0].canMove);
@@ -323,12 +360,12 @@ constexpr bool test() {
assert(out[2].canMove);
}
{
- std::array<OnlyBackwardsMovable, 3> in {};
- std::array<OnlyBackwardsMovable, 3> out {};
- out[1].next = &out[0];
- out[2].next = &out[1];
+ std::array<OnlyBackwardsMovable, 3> in{};
+ std::array<OnlyBackwardsMovable, 3> out{};
+ out[1].next = &out[0];
+ out[2].next = &out[1];
out[2].canMove = true;
- auto ret = std::ranges::move_backward(in.begin(), in.end(), out.end());
+ auto ret = std::ranges::move_backward(in.begin(), in.end(), out.end());
assert(ret.in == in.end());
assert(ret.out == out.begin());
assert(out[0].canMove);
@@ -344,19 +381,27 @@ constexpr bool test() {
auto ret = std::ranges::move_backward(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4), b.data() + b.size());
assert(ret.in == a + 4);
assert(ret.out == b.data());
- assert((b == std::array {42, 42, 42, 42}));
+ assert((b == std::array{42, 42, 42, 42}));
}
{
int a[] = {1, 2, 3, 4};
std::array<int, 4> b;
auto range = std::ranges::subrange(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4));
- auto ret = std::ranges::move_backward(range, b.data() + b.size());
+ auto ret = std::ranges::move_backward(range, b.data() + b.size());
assert(ret.in == a + 4);
assert(ret.out == b.data());
- assert((b == std::array {42, 42, 42, 42}));
+ assert((b == std::array{42, 42, 42, 42}));
}
}
+ { // Test vector<bool>::iterator optimization
+ TestBitIter<8>()();
+ TestBitIter<16>()();
+ TestBitIter<32>()();
+ TestBitIter<64>()();
+ TestBitIter<1024>()();
+ }
+
return true;
}
More information about the libcxx-commits
mailing list