Ensure converstion to bool is checked

Author: winner245

libcxx/docs/ReleaseNotes/21.rst

@@ -84,6 +84,11 @@ Improvements and New Features
 - The ``flat_map::insert`` and ``flat_set::insert_range`` have been optimized, resulting in a performance improvement of up
   to 10x for inserting elements into a ``flat_map`` when the input range is a ``flat_map`` or a ``zip_view``.
 
+- The ``std::copy`` and ``std::ranges::copy`` algorithms have been optimized for copying from ``random_access_iterator``s
+  to ``std::vector<bool>::iterator``, resulting in a performance improvement of up to 3x. As a result, range-based
+  operations of ``std::vector<bool>``, including construction, ``assign_range``, ``insert_range``, ``append_range``, and
+  their iterator-pair counterparts, have also benefited from a similar 3x speedup.
+
 Deprecations and Removals
 -------------------------
 

libcxx/include/__algorithm/copy.h

@@ -250,8 +250,11 @@ struct __copy_impl {
         __storage_type __w   = *__result.__seg_;
         __storage_type __m   = std::__middle_mask<__storage_type>(__clz - __dn, __result.__ctz_);
         __w &= ~__m;
-        for (__storage_type __i = 0; __i < __dn; ++__i, ++__first)
-          __w |= static_cast<__storage_type>(*__first) << __result.__ctz_++;
+        for (__storage_type __i = 0; __i < __dn; ++__i, ++__first) {
+          if (*__first)
+            __w |= static_cast<__storage_type>(1) << (__result.__ctz_ + __i);
+        }
+        __result.__ctz_ += __dn;
         *__result.__seg_ = __w;
         if (__result.__ctz_ == __bits_per_word) {
           __result.__ctz_ = 0;
@@ -265,15 +268,19 @@ struct __copy_impl {
     __n -= __nw * __bits_per_word;
     for (; __nw; --__nw) {
       __storage_type __w = 0;
-      for (__storage_type __i = 0; __i < __bits_per_word; ++__i, ++__first)
-        __w |= static_cast<__storage_type>(*__first) << __i;
+      for (__storage_type __i = 0; __i < __bits_per_word; ++__i, ++__first) {
+        if (*__first)
+          __w |= static_cast<__storage_type>(1) << __i;
+      }
       *__result.__seg_++ = __w;
     }
     // do last partial word, if present
     if (__n) {
       __storage_type __w = 0;
-      for (__storage_type __i = 0; __i < __n; ++__i, ++__first)
-        __w |= static_cast<__storage_type>(*__first) << __i;
+      for (__storage_type __i = 0; __i < __n; ++__i, ++__first) {
+        if (*__first)
+          __w |= static_cast<__storage_type>(1) << __i;
+      }
       __storage_type __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
       *__result.__seg_ &= ~__m;
       *__result.__seg_ |= __w;

libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp

@@ -90,30 +90,6 @@ int main(int argc, char** argv) {
 #endif
   }
 
-  // {std,ranges}::copy(random_access_iterator, random_access_iterator, vector<bool>)
-  {
-    auto bm = []<template <class> class Iter>(std::string name, auto copy) {
-      benchmark::RegisterBenchmark(name, [copy](auto& st) {
-        std::size_t const n = st.range(0);
-        std::vector<int> in(n, 1);
-        std::vector<bool> out(n);
-        auto first = Iter(in.begin());
-        auto last  = Iter(in.end());
-        auto dst   = out.begin();
-        for ([[maybe_unused]] auto _ : st) {
-          benchmark::DoNotOptimize(in);
-          benchmark::DoNotOptimize(out);
-          auto result = copy(first, last, dst);
-          benchmark::DoNotOptimize(result);
-        }
-      })->Range(64, 1 << 20);
-    };
-    bm.operator()<random_access_iterator>("std::copy(random_access_iterator, vector<bool>)", std_copy);
-#if TEST_STD_VER >= 23 // vector<bool>::iterator is not an output_iterator before C++23
-    bm.operator()<random_access_iterator>("rng::copy(random_access_iterator, vector<bool>)", std::ranges::copy);
-#endif
-  }
-
   benchmark::Initialize(&argc, argv);
   benchmark::RunSpecifiedBenchmarks();
   benchmark::Shutdown();

libcxx/test/benchmarks/containers/sequence/sequence_container_benchmarks.h

@@ -530,13 +530,13 @@ void sequence_container_benchmarks(std::string container) {
 
 #if defined(__cpp_lib_containers_ranges) && __cpp_lib_containers_ranges >= 202202L
     { // Range-ctor
-      auto bm = [&generators, &bench_vb, &tostr]<template <class, class> class Range>(std::string range) {
+      auto bm = [&generators, &bench_vb, &tostr]<template <class> class Iter>(std::string range) {
         for (auto gen : generators)
           bench_vb("ctor(" + range + ")" + tostr(gen), [gen](auto& st) {
             auto const size = st.range(0);
             std::vector<int> in;
             std::generate_n(std::back_inserter(in), size, gen);
-            Range rg(std::ranges::begin(in), std::ranges::end(in));
+            std::ranges::subrange rg(Iter(std::ranges::begin(in)), Iter(std::ranges::end(in)));
             benchmark::DoNotOptimize(in);
 
             for ([[maybe_unused]] auto _ : st) {
@@ -545,18 +545,18 @@ void sequence_container_benchmarks(std::string container) {
             }
           });
       };
-      bm.template operator()<random_access_range_wrapper>("ra_range");
+      bm.template operator()<cpp20_random_access_iterator>("ra_range");
     }
     { // Range-assignment
-      auto bm = [&generators, &bench_vb, &tostr]<template <class, class> class Range>(std::string range) {
+      auto bm = [&generators, &bench_vb, &tostr]<template <class> class Iter>(std::string range) {
         for (auto gen : generators)
           bench_vb("assign_range(" + range + ")" + tostr(gen), [gen](auto& st) {
             auto const size = st.range(0);
             std::vector<int> in1, in2;
             std::generate_n(std::back_inserter(in1), size, gen);
             std::generate_n(std::back_inserter(in2), size, gen);
-            Range rg1(std::ranges::begin(in1), std::ranges::end(in1));
-            Range rg2(std::ranges::begin(in2), std::ranges::end(in2));
+            std::ranges::subrange rg1(Iter(std::ranges::begin(in1)), Iter(std::ranges::end(in1)));
+            std::ranges::subrange rg2(Iter(std::ranges::begin(in2)), Iter(std::ranges::end(in2)));
             DoNotOptimizeData(in1);
             DoNotOptimizeData(in2);
 
@@ -570,49 +570,49 @@ void sequence_container_benchmarks(std::string container) {
             }
           });
       };
-      bm.template operator()<random_access_range_wrapper>("ra_range");
+      bm.template operator()<cpp20_random_access_iterator>("ra_range");
     }
     { // Range-insertion
-      auto bm = [&generators, &bench_vb, &tostr]<template <class, class> class Range>(std::string range) {
+      auto bm = [&generators, &bench_vb, &tostr]<template <class> class Iter>(std::string range) {
         for (auto gen : generators)
           bench_vb("insert_range(" + range + ")" + tostr(gen), [gen](auto& st) {
             auto const size = st.range(0);
             std::vector<int> in;
             Container c;
             std::generate_n(std::back_inserter(in), size, gen);
             std::generate_n(std::back_inserter(c), size, gen);
-            Range rg(std::ranges::begin(in), std::ranges::end(in));
+            std::ranges::subrange rg(Iter(std::ranges::begin(in)), Iter(std::ranges::end(in)));
             DoNotOptimizeData(in);
             DoNotOptimizeData(c);
 
             for ([[maybe_unused]] auto _ : st) {
-              c.insert_range(c.begin(), in);
+              c.insert_range(c.begin(), rg);
               c.erase(c.begin() + size, c.end()); // avoid growing indefinitely
               DoNotOptimizeData(c);
             }
           });
       };
-      bm.template operator()<random_access_range_wrapper>("ra_range");
+      bm.template operator()<cpp20_random_access_iterator>("ra_range");
     }
     { // Range-append
-      auto bm = [&generators, &bench_vb, &tostr]<template <class, class> class Range>(std::string range) {
+      auto bm = [&generators, &bench_vb, &tostr]<template <class> class Iter>(std::string range) {
         for (auto gen : generators)
           bench_vb("append_range(" + range + ")" + tostr(gen), [gen](auto& st) {
             auto const size = st.range(0);
             std::vector<int> in;
             std::generate_n(std::back_inserter(in), size, gen);
-            Range rg(std::ranges::begin(in), std::ranges::end(in));
+            std::ranges::subrange rg(Iter(std::ranges::begin(in)), Iter(std::ranges::end(in)));
             DoNotOptimizeData(in);
 
             Container c;
             for ([[maybe_unused]] auto _ : st) {
-              c.append_range(in);
+              c.append_range(rg);
               c.erase(c.begin(), c.end()); // avoid growing indefinitely
               DoNotOptimizeData(c);
             }
           });
       };
-      bm.template operator()<random_access_range_wrapper>("ra_range");
+      bm.template operator()<cpp20_random_access_iterator>("ra_range");
     }
 #endif
   }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

@@ -140,12 +140,12 @@ test_segmented_iterator() { // TODO: Mark as TEST_CONSTEXPR_CXX26 once std::dequ
     assert(in == out);
   }
   { // Copy from segmented input to vector<bool> output
-    std::deque<bool> in(199, false);
-    for (std::size_t i = 0; i < in.size(); i += 2)
-      in[i] = true;
+    int a[] = {8, 4, 2, 1, 0};
+    std::deque<int> in(a, a + sizeof(a) / sizeof(int));
     std::vector<bool> out(in.size());
     std::copy(in.begin(), in.end(), out.begin());
-    assert(std::equal(in.begin(), in.end(), out.begin()));
+    for (std::deque<int>::size_type i = 0; i != in.size(); ++i)
+      assert(out[i] == (in[i] != 0));
   }
   { // Copy from vector<bool> input to segmented output
     std::vector<bool> in(199, false);
@@ -175,12 +175,14 @@ test_segmented_iterator() { // TODO: Mark as TEST_CONSTEXPR_CXX26 once std::dequ
     assert(out == expected);
   }
   { // Copy from segmented input to vector<bool> output
-    std::vector<std::vector<int>> v{{1, 1}, {1, 0, 1}, {0, 0}, {1, 1, 1}, {1}, {1, 1, 1, 1}, {0, 0, 1, 1, 0, 1, 1}};
+    std::vector<std::vector<int>> v{{1, 2}, {1, 2, 3}, {0, 0}, {3, 4, 5}, {6}, {7, 8, 9, 6}, {0, 1, 2, 3, 0, 1, 2}};
     auto jv = std::ranges::join_view(v);
-    std::vector<bool> expected(jv.begin(), jv.end());
-    std::vector<bool> out(expected.size());
+    std::vector<bool> out(std::ranges::distance(jv.begin(), jv.end()));
     std::copy(jv.begin(), jv.end(), out.begin());
-    assert(out == expected);
+    std::size_t i = 0;
+    for (auto it = jv.begin(); it != jv.end(); ++it, ++i)
+      assert(out[i] == (*it != 0));
+    assert(i == out.size());
   }
 #endif
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp

@@ -177,12 +177,12 @@ test_segmented_iterator() { // TODO: Mark as TEST_CONSTEXPR_CXX26 once std::dequ
   }
 #if TEST_STD_VER >= 23
   { // Copy from segmented input to vector<bool> output
-    std::deque<bool> in(199, false);
-    for (std::size_t i = 0; i < in.size(); i += 2)
-      in[i] = true;
+    int a[] = {8, 4, 2, 1, 0};
+    std::deque<int> in(a, a + sizeof(a) / sizeof(int));
     std::vector<bool> out(in.size());
     std::ranges::copy(in, out.begin());
-    assert(std::equal(in.begin(), in.end(), out.begin()));
+    for (std::deque<int>::size_type i = 0; i != in.size(); ++i)
+      assert(out[i] == (in[i] != 0));
   }
 #endif // TEST_STD_VER >= 23
   {    // Copy from vector<bool> input to segmented output
@@ -215,12 +215,14 @@ test_segmented_iterator() { // TODO: Mark as TEST_CONSTEXPR_CXX26 once std::dequ
 #endif // TEST_STD_VER >= 20
 #if TEST_STD_VER >= 23
   { // Copy from segmented input to vector<bool> output
-    std::vector<std::vector<int>> v{{1, 1}, {1, 0, 1}, {0, 0}, {1, 1, 1}, {1}, {1, 1, 1, 1}, {0, 0, 1, 1, 0, 1, 1}};
+    std::vector<std::vector<int>> v{{1, 2}, {1, 2, 3}, {0, 0}, {3, 4, 5}, {6}, {7, 8, 9, 6}, {0, 1, 2, 3, 0, 1, 2}};
     auto jv = std::ranges::join_view(v);
-    std::vector<bool> expected(jv.begin(), jv.end());
-    std::vector<bool> out(expected.size());
+    std::vector<bool> out(std::ranges::distance(jv.begin(), jv.end()));
     std::ranges::copy(jv, out.begin());
-    assert(out == expected);
+    std::size_t i = 0;
+    for (auto it = jv.begin(); it != jv.end(); ++it, ++i)
+      assert(out[i] == (*it != 0));
+    assert(i == out.size());
   }
 #endif // TEST_STD_VER >= 23
 }

libcxx/test/std/containers/from_range_helpers.h

@@ -50,25 +50,6 @@ constexpr auto wrap_input(std::vector<T>& input) {
   return std::ranges::subrange(std::move(b), std::move(e));
 }
 
-template <class Iter, class Sent>
-class random_access_range_wrapper {
-public:
-  using _Iter = cpp20_random_access_iterator<Iter>;
-  using _Sent = sized_sentinel<_Iter>;
-
-  random_access_range_wrapper() = default;
-  random_access_range_wrapper(Iter begin, Iter end) : begin_(std::move(begin)), end_(std::move(end)) {}
-  _Iter begin() { return _Iter(std::move(begin_)); }
-  _Sent end() { return _Sent(_Iter(std::move(end_))); }
-
-private:
-  Iter begin_;
-  Sent end_;
-};
-
-template <class Iter, class Sent>
-random_access_range_wrapper(Iter, Sent) -> random_access_range_wrapper<Iter, Sent>;
-
 struct KeyValue {
   int key;    // Only the key is considered for equality comparison.
   char value; // Allows distinguishing equivalent instances.