[libc++] Optimize std::find_if

Author: philnik777

libcxx/include/CMakeLists.txt

@@ -2,6 +2,7 @@ set(files
   __algorithm/adjacent_find.h
   __algorithm/all_of.h
   __algorithm/any_of.h
+  __algorithm/assume_valid_range.h
   __algorithm/binary_search.h
   __algorithm/clamp.h
   __algorithm/comp.h

libcxx/include/__algorithm/assume_valid_range.h

@@ -0,0 +1,41 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_ASSUME_VALID_RANGE_H
+#define _LIBCPP___ALGORITHM_ASSUME_VALID_RANGE_H
+
+#include <__config>
+#include <__memory/assume_aligned.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Iter, class _Sent>
+pair<_Iter, _Sent> __assume_valid_range(_Iter __first, _Sent __last) {
+  return std::make_pair(std::move(__first), std::move(__last));
+}
+
+template <class _Tp>
+pair<_Tp*, _Tp*> __assume_valid_range(_Tp* __first, _Tp* __last) {
+#if __has_builtin(__builtin_assume_dereferenceable)
+  __builtin_assume_dereferenceable(__first, (__last - __first) * sizeof(_Tp));
+#endif
+  __first = std::__assume_aligned<_LIBCPP_ALIGNOF(_Tp)>(__first);
+  __last  = std::__assume_aligned<_LIBCPP_ALIGNOF(_Tp)>(__last);
+  return std::make_pair(__first, __last);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_ASSUME_VALID_RANGE_H

libcxx/include/__algorithm/find_if.h

@@ -10,6 +10,8 @@
 #ifndef _LIBCPP___ALGORITHM_FIND_IF_H
 #define _LIBCPP___ALGORITHM_FIND_IF_H
 
+#include <__algorithm/assume_valid_range.h>
+#include <__algorithm/unwrap_iter.h>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -21,10 +23,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _InputIterator, class _Predicate>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
 find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
-  for (; __first != __last; ++__first)
-    if (__pred(*__first))
+  auto [__ufirst, __ulast] = std::__assume_valid_range(std::__unwrap_iter(__first), std::__unwrap_iter(__last));
+
+  for (; __ufirst != __ulast; ++__ufirst) {
+    if (__pred(*__ufirst))
       break;
-  return __first;
+  }
+  return std::__rewrap_iter(__first, __ufirst);
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/benchmarks/algorithms/nonmodifying/find.bench.cpp

@@ -21,30 +21,18 @@
 int main(int argc, char** argv) {
   auto std_find    = [](auto first, auto last, auto const& value) { return std::find(first, last, value); };
   auto std_find_if = [](auto first, auto last, auto const& value) {
-    return std::find_if(first, last, [&](auto element) {
-      benchmark::DoNotOptimize(element);
-      return element == value;
-    });
+    return std::find_if(first, last, [&](auto element) { return element == value; });
   };
   auto std_find_if_not = [](auto first, auto last, auto const& value) {
-    return std::find_if_not(first, last, [&](auto element) {
-      benchmark::DoNotOptimize(element);
-      return element != value;
-    });
+    return std::find_if_not(first, last, [&](auto element) { return element != value; });
   };
 
   auto ranges_find    = [](auto first, auto last, auto const& value) { return std::ranges::find(first, last, value); };
   auto ranges_find_if = [](auto first, auto last, auto const& value) {
-    return std::ranges::find_if(first, last, [&](auto element) {
-      benchmark::DoNotOptimize(element);
-      return element == value;
-    });
+    return std::ranges::find_if(first, last, [&](auto element) { return element == value; });
   };
   auto ranges_find_if_not = [](auto first, auto last, auto const& value) {
-    return std::ranges::find_if_not(first, last, [&](auto element) {
-      benchmark::DoNotOptimize(element);
-      return element != value;
-    });
+    return std::ranges::find_if_not(first, last, [&](auto element) { return element != value; });
   };
 
   auto register_benchmarks = [&](auto bm, std::string comment) {

libcxx/test/benchmarks/algorithms/nonmodifying/find_if.bench.cpp

@@ -0,0 +1,51 @@
+#include <benchmark/benchmark.h>
+
+template <class Iter, class ValueT>
+Iter my_find(Iter first, Iter last, const ValueT& i) {
+  for (; first != last; ++first) {
+    if (*first == i)
+      break;
+  }
+  return first;
+}
+
+static auto bm_find_if_no_vectorization(benchmark::State& state) {
+  std::size_t const size = 8192;
+  std::vector<short> c(size, 0);
+
+  for ([[maybe_unused]] auto _ : state) {
+    benchmark::DoNotOptimize(c);
+    std::vector<short>::iterator result;
+    [[clang::noinline]] result = my_find(c.begin(), c.end(), 1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(bm_find_if_no_vectorization);
+
+static auto bm_find_if_autovectorization(benchmark::State& state) {
+  std::size_t const size = 8192;
+  std::vector<short> c(size, 0);
+
+  for ([[maybe_unused]] auto _ : state) {
+    benchmark::DoNotOptimize(c);
+    std::vector<short>::iterator result;
+    [[clang::noinline]] result = find_if(c.begin(), c.end(), [](short i) { return i == 1; });
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(bm_find_if_autovectorization);
+
+static auto bm_find_manual_vectorization(benchmark::State& state) {
+  std::size_t const size = 8192;
+  std::vector<short> c(size, 0);
+
+  for ([[maybe_unused]] auto _ : state) {
+    benchmark::DoNotOptimize(c);
+    std::vector<short>::iterator result;
+    [[clang::noinline]] result = find(c.begin(), c.end(), 1);
+    benchmark::DoNotOptimize(result);
+  }
+}
+BENCHMARK(bm_find_manual_vectorization);
+
+BENCHMARK_MAIN();