[pstl] Make the default backend be the serial backend and always provide parallel policies

[ldionne]

Summary

Before this change, the default backend was TBB but one could disable
anything related to TBB by removing the parallel policies. This change
uses the serial backend by default and removes the ability to disable
parallel policies, which is not useful anymore.

[ldionne]

Rebase onto master

[ldionne]

Is there still a reason to maintain the _PSTL_USE_PAR_POLICIES configuration? If not, we should move forward with this patch. I know @rodgert has been bitten by this at least a couple of times.

[rodgert]

I am good with this change

[ldionne]

@MikeDvorskiy ping!

pstl/CMakeLists.txt

 set(PARALLELSTL_VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/include/pstl/internal/pstl_config.h")
 file(STRINGS "${PARALLELSTL_VERSION_FILE}" PARALLELSTL_VERSION_SOURCE REGEX "#define PSTL_VERSION .*$")
 string(REGEX REPLACE "#define PSTL_VERSION (.*)$" "\\1" PARALLELSTL_VERSION_SOURCE "${PARALLELSTL_VERSION_SOURCE}")
 math(EXPR VERSION_MAJOR "${PARALLELSTL_VERSION_SOURCE} / 100")
 math(EXPR VERSION_MINOR "${PARALLELSTL_VERSION_SOURCE} % 100")
 
 project(ParallelSTL VERSION ${VERSION_MAJOR}.${VERSION_MINOR} LANGUAGES CXX)
 
-option(PARALLELSTL_USE_PARALLEL_POLICIES "Enable parallel policies" OFF)
-set(PARALLELSTL_BACKEND "tbb" CACHE STRING "Threading backend; defaults to TBB")
+set(PARALLELSTL_BACKEND "serial" CACHE STRING "Threading backend to use. Valid choices are 'serial' and 'tbb'. The default is 'serial'.")
 
 if (NOT TBB_DIR)
     get_filename_component(PSTL_DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
     string(REPLACE pstl tbb TBB_DIR_NAME ${PSTL_DIR_NAME})
     if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake")
         get_filename_component(TBB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake" ABSOLUTE)
     endif()
 endif()
 
 add_library(ParallelSTL INTERFACE)
 add_library(pstl::ParallelSTL ALIAS ParallelSTL)
 target_compile_features(ParallelSTL INTERFACE cxx_std_17)
 
-if (PARALLELSTL_USE_PARALLEL_POLICIES)
-    if (PARALLELSTL_BACKEND STREQUAL "serial")
-        message(STATUS "Parallel STL uses the serial backend")
-        target_compile_definitions(ParallelSTL INTERFACE -D__PSTL_PAR_BACKEND_SERIAL)
-    elseif (PARALLELSTL_BACKEND STREQUAL "tbb")
-        find_package(TBB 2018 REQUIRED tbb OPTIONAL_COMPONENTS tbbmalloc)
-        message(STATUS "Parallel STL uses TBB ${TBB_VERSION} (interface version: ${TBB_INTERFACE_VERSION})")
-        target_link_libraries(ParallelSTL INTERFACE TBB::tbb)
-        target_compile_definitions(ParallelSTL INTERFACE -D__PSTL_PAR_BACKEND_TBB)
-    else()
-        message(FATAL_ERROR "Requested unknown Parallel STL backend '${PARALLELSTL_BACKEND}'.")
-    endif()
-else()
-    target_compile_definitions(ParallelSTL INTERFACE PSTL_USE_PARALLEL_POLICIES=0)
-endif()
 
 target_include_directories(ParallelSTL
     INTERFACE
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
     $<INSTALL_INTERFACE:include>)
 
 include(CMakePackageConfigHelpers)
 write_basic_package_version_file(

pstl/include/pstl/internal/algorithm_impl.h

 #include <type_traits>
 #include <utility>
 #include <functional>
 #include <algorithm>
 
 #include "execution_impl.h"
 #include "memory_impl.h"
 #include "parallel_backend_utils.h"
-#include "unseq_backend_simd.h"
-
-#if __PSTL_USE_PAR_POLICIES
 #include "parallel_backend.h"
 #include "parallel_impl.h"
-#endif
+#include "unseq_backend_simd.h"
 
 namespace __pstl
 {
 namespace internal
 {
 
 //------------------------------------------------------------------------
 // any_of

 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
 bool
 pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
                _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return internal::brick_any_of(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
 bool
 pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
                _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         return internal::parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                      [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                          return internal::brick_any_of(__i, __j, __pred, __is_vector);
                                      });
     });
 }
-#endif
 
 // [alg.foreach]
 // for_each_n with no policy
 
 template <class _ForwardIterator, class _Size, class _Function>
 _ForwardIterator
 for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f)
 {

 void
 pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
               _IsVector __is_vector,
               /*parallel=*/std::false_type) noexcept
 {
     internal::brick_walk1(__first, __last, __f, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
 void
 pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
               _IsVector __is_vector,
               /*parallel=*/std::true_type)
 {
     internal::except_handler([&]() {
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                   [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                       internal::brick_walk1(__i, __j, __f, __is_vector);
                                   });
     });
 }
-#endif
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
 void
 pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
                    /*parallel=*/std::false_type) noexcept
 {
     __brick(__first, __last);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
 void
 pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
                    /*parallel=*/std::true_type)
 {
     internal::except_handler([&]() {
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                   [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // walk1_n
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Size, class _Function>
 _ForwardIterator
 brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type)
 {

 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
 _ForwardIterator
 pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector,
                 /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_walk1_n(__first, __n, __f, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
 _RandomAccessIterator
 pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f,
                 _IsVector __is_vector,
                 /*is_parallel=*/std::true_type)
 {
     internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector,
                             std::true_type());
     return __first + __n;
 }
-#endif
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
 _ForwardIterator
 pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick,
                      /*is_parallel=*/std::false_type) noexcept
 {
     return __brick(__first, __n);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
 _RandomAccessIterator
 pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick,
                      /*is_parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         par_backend::parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first, __first + __n,
             [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); });
         return __first + __n;
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // walk2 (pseudo)
 //
 // walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...)
 //------------------------------------------------------------------------
 template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
 _ForwardIterator2

 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
 _ForwardIterator2
 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
               _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return internal::brick_walk2(__first1, __last1, __first2, __f, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
 _ForwardIterator2
 pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
                                   [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                                       internal::brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector);
                                   });
         return __first2 + (__last1 - __first1);
     });
 }
-#endif
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
           class _IsVector>
 _ForwardIterator2
 pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f,
                 _IsVector is_vector, /*parallel=*/std::false_type) noexcept
 {
     return internal::brick_walk2_n(__first1, n, __first2, f, is_vector);

 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
 _ForwardIterator2
 pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                     _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept
 {
     return __brick(__first1, __last1, __first2);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
 _RandomAccessIterator2
 pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                     _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
 {
     return except_handler([&]() {
         par_backend::parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 __brick(__i, __j, __first2 + (__i - __first1));
             });
         return __first2 + (__last1 - __first1);
     });
 }
-#endif
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
 _RandomAccessIterator2
 pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n,
                       _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
 {
     return except_handler([&]() {
         par_backend::parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
             [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 __brick(__i, __j - __i, __first2 + (__i - __first1));
             });
         return __first2 + __n;
     });
 }
-#endif
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
 _ForwardIterator2
 pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2,
                       _Brick __brick, /*parallel=*/std::false_type) noexcept
 {
     return __brick(__first1, __n, __first2);
 }
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
           class _Function, class _IsVector>
 _ForwardIterator3
 pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
               _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return internal::brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
           class _RandomAccessIterator3, class _Function, class _IsVector>
 _RandomAccessIterator3
 pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
               _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector,
               /*parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         par_backend::parallel_for(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 internal::brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f,
                                       __is_vector);
             });
         return __first3 + (__last1 - __first1);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // equal
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 bool
 brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p,
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 bool
 pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
               _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_equal(__first1, __last1, __first2, __p, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
           class _IsVector>
 bool
 pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
               _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector,
               /*is_parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         return !internal::parallel_or(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 return !brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector);
             });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // find_if
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Predicate>
 _ForwardIterator
 brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
               /*is_vector=*/std::false_type) noexcept

 _ForwardIterator
 pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
                 _IsVector __is_vector,
                 /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_find_if(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 _ForwardIterator
 pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
                 _IsVector __is_vector,
                 /*is_parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         return internal::parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                        [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
                                            return internal::brick_find_if(__i, __j, __pred, __is_vector);
                                        },
                                        std::less<typename std::iterator_traits<_ForwardIterator>::difference_type>(),
                                        /*is_first=*/true);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // find_end
 //------------------------------------------------------------------------
 
 // find the first occurrence of the subsequence [s_first, s_last)
 //   or the  last occurrence of the subsequence in the range [first, last)
 // b_first determines what occurrence we want to find (first or last)

 _ForwardIterator1
 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                  _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
                  /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 _ForwardIterator1
 pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                  _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
                  _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
 {
     if (__last - __first == __s_last - __s_first)
else
                 [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i,
                                                                    _ForwardIterator1 __j) {
                     return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector);
                 },
                 std::greater<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/false);
         });
     }
 }
-#endif
 
 //------------------------------------------------------------------------
 // find_first_of
 //------------------------------------------------------------------------
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 _ForwardIterator1
 brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                     _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept

 _ForwardIterator1
 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
                       _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
                       _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 _ForwardIterator1
 pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                       _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
                       _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
 {
     return except_handler([&]() {
         return internal::parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                 return internal::brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector);
             },
             std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // search
 //------------------------------------------------------------------------
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 _ForwardIterator1
 brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
              _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept

 _ForwardIterator1
 pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
                /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
           class _IsVector>
 _ForwardIterator1
 pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
                /*is_parallel=*/std::true_type) noexcept
 {
     if (__last - __first == __s_last - __s_first)
else
                 std::forward<_ExecutionPolicy>(__exec), __first, __last,
                 [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
                     return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector);
                 },
                 std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
         });
     }
 }
-#endif
 
 //------------------------------------------------------------------------
 // search_n
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
 _ForwardIterator
 brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value,
                _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept

 _ForwardIterator
 pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
                  const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
                  /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_search_n(__first, __last, __count, __value, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
           class _IsVector>
 _RandomAccessIterator
 pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Size __count,
                  const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
                  /*is_parallel=*/std::true_type) noexcept
 {
     if (__last - __first == __count)
else
                 std::forward<_ExecutionPolicy>(__exec), __first, __last,
                 [__last, __count, &__value, __pred, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
                     return internal::find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector);
                 },
                 std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
         });
     }
 }
-#endif
 
 //------------------------------------------------------------------------
 // copy_n
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Size, class _OutputIterator>
 _OutputIterator
 brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept

 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
 _OutputIterator
 pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                 _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
 {
     return internal::brick_copy_if(__first, __last, __result, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
           class _IsVector>
 _OutputIterator
 pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                 _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
     const _DifferenceType __n = __last - __first;
if (_DifferenceType(1) < __n)
                 },
                 [&__m](_DifferenceType __total) { __m = __total; });
             return __result + __m;
         });
     }
     // trivial sequence - use serial algorithm
     return brick_copy_if(__first, __last, __result, __pred, __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // count
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Predicate>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
             /* is_vector = */ std::true_type) noexcept

 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
               /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept
 {
     return brick_count(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
 typename std::iterator_traits<_ForwardIterator>::difference_type
 pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
               /* is_parallel */ std::true_type, _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
     return except_handler([&]() {
         return par_backend::parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0),
             [__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType {
                 return __value + brick_count(__begin, __end, __pred, __is_vector);
             },
             std::plus<_SizeType>());
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // unique
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,

 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_unique(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 // That function is shared between two algorithms - remove_if (pattern_remove_if) and unique (pattern unique). But a mask calculation is different.
 // So, a caller passes _CalcMask brick into remove_elements.
 template <class _ExecutionPolicy, class _ForwardIterator, class _CalcMask, class _IsVector>
 _ForwardIterator
 remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask,
                 _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
return except_handler([&]() {
         // 3. Elements from result are moved to [first, last)
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
                                   [__result, __first, __is_vector](_Tp* __i, _Tp* __j) {
                                       brick_move(__i, __j, __first + (__i - __result), __is_vector);
                                   });
         return __first + __m;
     });
 }
-#endif
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
 
     if (__first == __last)
return remove_elements(
         std::forward<_ExecutionPolicy>(__exec), ++__first, __last,
         [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) {
             brick_walk3(__b, __e, __it - 1, __it,
                         [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); },
                         __is_vector);
         },
         __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // unique_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
 OutputIterator
 brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred,

 template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
 _DifferenceType
 brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
                   _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
 {
     return unseq_backend::simd_calc_mask_2(__first, __last - __first, __mask, __pred);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
           class _IsVector>
 _OutputIterator
 pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                     _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,
                     /*parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
if (_DifferenceType(2) < __n)
                     [&__m](_DifferenceType __total) { __m = __total; });
                 return __result + __m;
             });
         }
     }
     // trivial sequence - use serial algorithm
     return brick_unique_copy(__first, __last, __result, __pred, __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // reverse
 //------------------------------------------------------------------------
 template <class _BidirectionalIterator>
 void
 brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept
 {

 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
 void
 pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _IsVector _is_vector,
                 /*is_parallel=*/std::false_type) noexcept
 {
     brick_reverse(__first, __last, _is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
 void
 pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                 _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     par_backend::parallel_for(
         std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2,
         [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) {
             brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector);
         });
 }
-#endif
 
 //------------------------------------------------------------------------
 // reverse_copy
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator, class _OutputIterator>
 _OutputIterator
 brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,

 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
                      _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_reverse_copy(__first, __last, __d_first, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                      _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     auto __len = __last - __first;
     par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                               [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first,
                                                                        _BidirectionalIterator __inner_last) {
                                   brick_reverse_copy(__inner_first, __inner_last,
                                                      __d_first + (__len - (__inner_last - __first)), __is_vector);
                               });
     return __d_first + __len;
 }
-#endif
 
 //------------------------------------------------------------------------
 // rotate
 //------------------------------------------------------------------------
 template <class _ForwardIterator>
 _ForwardIterator
 brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
              /*is_vector=*/std::false_type) noexcept

 template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
 _ForwardIterator
 pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
                _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_rotate(__first, __middle, __last, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
 _ForwardIterator
 pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
                _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
     auto __n = __last - __first;
     auto __m = __middle - __first;
else
                                       [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) {
                                           brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)), __is_vector);
                                       });
 
             return __first + (__last - __middle);
         });
     }
 }
-#endif
 
 //------------------------------------------------------------------------
 // rotate_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator>
 _OutputIterator
 brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,

 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
                     _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_rotate_copy(__first, __middle, __last, __result, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
 _OutputIterator
 pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
                     _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector,
                     /*is_parallel=*/std::true_type)
 {
     par_backend::parallel_for(
         std::forward<_ExecutionPolicy>(__exec), __first, __last,
par_backend::parallel_for(
                 {
                     brick_copy(__b, __middle, __new_result, __is_vector);
                     brick_copy(__middle, __e, __result, __is_vector);
                 }
             }
         });
     return __result + (__last - __first);
 }
-#endif
 
 //------------------------------------------------------------------------
 // is_partitioned
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _UnaryPredicate>
 bool
 brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,

 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 bool
 pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                        _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_is_partitioned(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 bool
 pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                        _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     if (__first == __last)
     {
         return true;
else
                     }
                     // calculate the result for new big range
                     return __table[__val1 * 4 + __val2];
                 });
             return __init != __broken;
         });
     }
 }
-#endif
 
 //------------------------------------------------------------------------
 // partition
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _UnaryPredicate>
 _ForwardIterator
 brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,

 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                   _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_partition(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                   _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
 
     // partitioned range: elements before pivot satisfy pred (true part),
     //                    elements after pivot don't satisfy pred (false part)
return except_handler([&]() {
 
                 // 2. merging of two ranges (left and right respectively)
                 return __reductor(__value, {__i, __pivot, __j});
             },
             __reductor);
         return __result.__pivot;
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // stable_partition
 //------------------------------------------------------------------------
 
 template <class _BidirectionalIterator, class _UnaryPredicate>
 _BidirectionalIterator
 brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,

 template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
 _BidirectionalIterator
 pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
                          _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
 {
     return internal::brick_stable_partition(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
 _BidirectionalIterator
 pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                          _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::true_type) noexcept
 {
     // partitioned range: elements before pivot satisfy pred (true part),
     //                    elements after pivot don't satisfy pred (false part)
     struct _PartitionRange
return except_handler([&]() {
 
                 // 2. merging of two ranges (left and right respectively)
                 return __reductor(__value, {__i, __pivot, __j});
             },
             __reductor);
         return __result.__pivot;
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // partition_copy
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
 std::pair<_OutputIterator1, _OutputIterator2>
 brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,

 std::pair<_OutputIterator1, _OutputIterator2>
 pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
                        _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
                        _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
 {
     return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
           class _UnaryPredicate, class _IsVector>
 std::pair<_OutputIterator1, _OutputIterator2>
 pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                        _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
                        _IsVector __is_vector, /*is_parallelization=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
if (_DifferenceType(1) < __n)
                     },
                     [&__m](_ReturnType __total) { __m = __total; });
                 return std::make_pair(__out_true + __m.first, __out_false + __m.second);
             });
     }
     // trivial sequence - use serial algorithm
     return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // sort
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
           class _IsMoveConstructible>
 void
 pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
              _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept
 {
     std::sort(__first, __last, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
              _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type)
 {
     except_handler([&]() {
         par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
                                           [](_RandomAccessIterator __first, _RandomAccessIterator __last,
                                              _Compare __comp) { std::sort(__first, __last, __comp); },
                                           __last - __first);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // stable_sort
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
                     _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept
 {
     std::stable_sort(__first, __last, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                     _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type)
 {
     internal::except_handler([&]() {
         par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
                                           [](_RandomAccessIterator __first, _RandomAccessIterator __last,
                                              _Compare __comp) { std::stable_sort(__first, __last, __comp); });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // partial_sort
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle,
                      _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept
 {
     std::partial_sort(__first, __middle, __last, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
                      _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type)
 {
     const auto __n = __middle - __first;
     except_handler([&]() {
         par_backend::parallel_stable_sort(
             std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
             [__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) {
                 if (__n < __end - __begin)
                     std::partial_sort(__begin, __begin + __n, __end, __comp);
                 else
                     std::sort(__begin, __end, __comp);
             },
             __n);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // partial_sort_copy
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
 _RandomAccessIterator
 pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
                           _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector,
                           /*is_parallel=*/std::false_type) noexcept
 {
     return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
 _RandomAccessIterator
 pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                           _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp,
                           _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     if (__last == __first || __d_last == __d_first)
     {
#endif
             par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2,
                                       [__r, __d_first, __is_vector](_T1* __i, _T1* __j) {
                                           brick_move(__i, __j, __d_first + (__i - __r), __is_vector);
                                       });
             return __d_first + __n2;
         }
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // adjacent_find
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                     /* IsVector = */ std::true_type, bool __or_semantic) noexcept

 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
                       /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept
 {
     return internal::brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
 _RandomAccessIterator
 pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector,
                       bool __or_semantic)
 {
     if (__last - __first < 2)
         return __last;
return internal::except_handler([&]() {
                 return __value;
             },
             [](_RandomAccessIterator __x, _RandomAccessIterator __y) -> _RandomAccessIterator {
                 return __x < __y ? __x : __y;
             } //reduce a __value
         );
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // nth_element
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth,
                     _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept
 {
     std::nth_element(__first, __nth, __last, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 void
 pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
                     _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector,
                     /*is_parallel=*/std::true_type) noexcept
 {
     if (__first == __last || __nth == __last)
     {
do
             else
             {
                 iter_swap(__nth, __x);
             }
             __first = __x;
         }
     } while (__x != __nth);
 }
-#endif
 
 //------------------------------------------------------------------------
 // fill, fill_n
 //------------------------------------------------------------------------
 template <class _ForwardIterator, class _Tp>
 void
 brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
            /* __is_vector = */ std::true_type) noexcept

 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
 void
 pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
              /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
 {
     internal::brick_fill(__first, __last, __value, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
 _ForwardIterator
 pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
              /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     return except_handler([&__exec, __first, __last, &__value, __is_vector]() {
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                   [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
                                       internal::brick_fill(__begin, __end, __value, __is_vector);
                                   });
         return __last;
     });
 }
-#endif
 
 template <class _OutputIterator, class _Size, class _Tp>
 _OutputIterator
 brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept
 {
     return unseq_backend::simd_fill_n(__first, __count, __value);
 }
 

 template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
 void
 pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
                  /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
 {
     internal::brick_generate(__first, __last, __g, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
 _ForwardIterator
 pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
                  /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     return internal::except_handler([&]() {
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                   [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
                                       internal::brick_generate(__begin, __end, __g, __is_vector);
                                   });
         return __last;
     });
 }
-#endif
 
 template <class OutputIterator, class Size, class _Generator>
 OutputIterator
 brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept
 {
     return unseq_backend::simd_generate_n(__first, __count, __g);
 }
 
 template <class OutputIterator, class Size, class _Generator>
 OutputIterator
 brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept
 {
     return std::generate_n(__first, __count, __g);
 }
 
 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
 _OutputIterator
 pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g,
                    /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
 {
     return internal::brick_generate_n(__first, __count, __g, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
 _OutputIterator
 pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g,
                    /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     static_assert(internal::is_random_access_iterator<_OutputIterator>::value,
                   "Pattern-brick error. Should be a random access iterator.");
     return internal::pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g,
                                       std::true_type(), __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // remove
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _UnaryPredicate>
 _ForwardIterator
 brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,

 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                   _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept
 {
     return internal::brick_remove_if(__first, __last, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
 _ForwardIterator
 pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
                   _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
 
     if (__first == __last || __first + 1 == __last)
     {
         // Trivial sequence - use serial algorithm
         return brick_remove_if(__first, __last, __pred, __is_vector);
     }
 
     return remove_elements(
         std::forward<_ExecutionPolicy>(__exec), __first, __last,
         [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) {
             brick_walk2(__b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, __is_vector);
         },
         __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // merge
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 _OutputIterator
 pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
               _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector,
               /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
               _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first,
               _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
     par_backend::parallel_merge(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
         [__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2,
                       _RandomAccessIterator2 __l2, _OutputIterator __f3,
                       _Compare __comp) { return brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); });
     return __d_first + (__last1 - __first1) + (__last2 - __first2);
 }
-#endif
 
 //------------------------------------------------------------------------
 // inplace_merge
 //------------------------------------------------------------------------
 template <class _BidirectionalIterator, class _Compare>
 void
 brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
                     _Compare __comp, /* __is_vector = */ std::false_type) noexcept

 void
 pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle,
                       _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
                       /* is_parallel = */ std::false_type) noexcept
 {
     internal::brick_inplace_merge(__first, __middle, __last, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
 void
 pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
                       _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
                       /*is_parallel=*/std::true_type)
 {
     if (__first == __last || __first == __middle || __middle == __last)
     {
except_handler([&]() {
                 return __f3 + (__l1 - __f1) + (__l2 - __f2);
             });
         par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n,
                                   [__r, __first, __is_vector](_Tp* __i, _Tp* __j) {
                                       brick_move(__i, __j, __first + (__i - __r), __is_vector);
                                   });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // includes
 //------------------------------------------------------------------------
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
 bool
 pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                  _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector,
                  /*is_parallel=*/std::false_type) noexcept
 {
     return std::includes(__first1, __last1, __first2, __last2, __comp);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
 bool
 pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                  _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector,
                  /*is_parallel=*/std::true_type)
 {
     if (__first2 >= __last2)
         return true;
return except_handler([&]() {
                 auto __b = std::lower_bound(__first1, __last1, *__i, __comp);
 
                 assert(!__comp(*(__last1 - 1), *__b));
                 assert(!__comp(*(__j - 1), *__i));
                 return !std::includes(__b, __last1, __i, __j, __comp);
             });
     });
 }
-#endif
 
 constexpr auto __set_algo_cut_off = 1000;
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector, class _SizeFunction, class _SetOP>
 _OutputIterator
 parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                 _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector)
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
return except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp,
             [&__m, &__scan](const _SetRange& __total) { // Apex
                 //final scan
                 __scan(0, 0, __total);
                 __m = __total.__pos + __total.__len;
             });
         return __result + __m;
     });
 }
-#endif
 
-#if __PSTL_USE_PAR_POLICIES
 //a shared parallel pattern for 'pattern_set_union' and 'pattern_set_symmetric_difference'
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _SetUnionOp, class _IsVector>
 _OutputIterator
 parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                       _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                       _SetUnionOp __set_union_op, _IsVector __is_vector)
 {
if (__m2 > __set_algo_cut_off)
             });
         return __result;
     }
 
     return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
                            __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
                            __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // set_union
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 _OutputIterator
 pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                   _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector,
                   /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                   _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                   _IsVector __is_vector, /*__is_parallel=*/std::true_type)
 {
 
     const auto __n1 = __last1 - __first1;
     const auto __n2 = __last2 - __first2;
 
     // use serial algorithm
     if (__n1 + __n2 <= __set_algo_cut_off)
         return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
 
     typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
     return parallel_set_union_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
                                  __comp,
                                  [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                                     _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
                                      return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
                                  },
                                  __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // set_intersection
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 _OutputIterator
 pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                          _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
                          _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                          _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
                          _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
if (__m2 > __set_algo_cut_off)
             },
             __is_vector);
         return __result;
     }
 
     // [left_bound_seq_1; last1) and [left_bound_seq_2; last2) - use serial algorithm
     return std::set_intersection(__left_bound_seq_1, __last1, __left_bound_seq_2, __last2, __result, __comp);
 }
-#endif
 
 //------------------------------------------------------------------------
 // set_difference
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 _OutputIterator
 pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                        _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
                        _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
if (__n1 + __n2 > __set_algo_cut_off)
                                   _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
                                    return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
                                },
                                __is_vector);
 
     // use serial algorithm
     return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
 }
-#endif
 
 //------------------------------------------------------------------------
 // set_symmetric_difference
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
 _OutputIterator
 brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                                  _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
                                  _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp,
                                                     __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
           class _Compare, class _IsVector>
 _OutputIterator
 pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                                  _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
                                  _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
 
     const auto __n1 = __last1 - __first1;
     const auto __n2 = __last2 - __first2;
 
     // use serial algorithm
     if (__n1 + __n2 <= __set_algo_cut_off)
         return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
 
     typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
     return parallel_set_union_op(
         std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
         [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
            _T* __result, _Compare __comp) {
             return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
         },
         __is_vector);
 }
-#endif
 
 //------------------------------------------------------------------------
 // is_heap_until
 //------------------------------------------------------------------------
 
 template <class _RandomAccessIterator, class _Compare>
 _RandomAccessIterator
 brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,

 is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
                     /* __is_vector = */ std::true_type) noexcept
 {
     return unseq_backend::simd_first(
         __first, __begin, __end,
         [&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
 _RandomAccessIterator
 pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                       _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
 {
     if (__last - __first < 2)
         return __last;
 
     return internal::except_handler([&]() {
         return internal::parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__first, __comp, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
                 return internal::is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector);
             },
             std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // min_element
 //------------------------------------------------------------------------
 
 template <typename _ForwardIterator, typename _Compare>
 _ForwardIterator
 brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,

 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
 _ForwardIterator
 pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                     _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_min_element(__first, __last, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
 _RandomAccessIterator
 pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                     _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
     if (__first == __last)
         return __last;
 
     return internal::except_handler([&]() {
         return par_backend::parallel_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first,
             [=](_RandomAccessIterator __begin, _RandomAccessIterator __end,
                 _RandomAccessIterator __init) -> _RandomAccessIterator {
                 const _RandomAccessIterator subresult = brick_min_element(__begin, __end, __comp, __is_vector);
                 return internal::cmp_iterators_by_values(__init, subresult, __comp);
             },
             [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator {
                 return internal::cmp_iterators_by_values(__it1, __it2, __comp);
             });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // minmax_element
 //------------------------------------------------------------------------
 
 template <typename _ForwardIterator, typename _Compare>
 std::pair<_ForwardIterator, _ForwardIterator>
 brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,

 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
 std::pair<_ForwardIterator, _ForwardIterator>
 pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                        _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_minmax_element(__first, __last, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
 std::pair<_ForwardIterator, _ForwardIterator>
 pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
                        _IsVector __is_vector, /* is_parallel = */ std::true_type)
 {
     if (__first == __last)
         return std::make_pair(__first, __first);
 
return internal::except_handler([&]() {
             },
             [=](_Result __p1, _Result __p2) -> _Result {
                 return std::make_pair(
                     internal::cmp_iterators_by_values(__p1.first, __p2.first, __comp),
                     internal::cmp_iterators_by_values(__p2.second, __p1.second, internal::not_pred<_Compare>(__comp)));
             });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // mismatch
 //------------------------------------------------------------------------
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 std::pair<_ForwardIterator1, _ForwardIterator2>
 mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                 _ForwardIterator2 __last2, _BinaryPredicate __pred)

 std::pair<_ForwardIterator1, _ForwardIterator2>
 pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
                  _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector,
                  /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
           class _IsVector>
 std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
 pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                  _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred,
                  _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
 {
     return internal::except_handler([&]() {
         auto __n = std::min(__last1 - __first1, __last2 - __first2);
         auto __result = internal::parallel_find(
             std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
             [__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
                 return internal::brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
                                                 __pred, __is_vector)
                     .first;
             },
             std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(), /*is_first=*/true);
         return std::make_pair(__result, __first2 + (__result - __first1));
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // lexicographical_compare
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
 bool
 brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,

 bool
 pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
                                 _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
 {
     return internal::brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
 bool
 pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
                                 _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
 {
     if (__first2 == __last2)
     { // if second sequence is empty
else
             return !__comp(*(__first2 + (__result - __first1)), *__result);
         }
         else
         { // if second sequence shorter than first or both have the same number of elements
             return __comp(*__result, *(__first2 + (__result - __first1)));
         }
     }
 }
-#endif
 
 } // namespace internal
 } // namespace __pstl
 
 #endif /* __PSTL_algorithm_impl_H */

pstl/include/pstl/internal/execution_defs.h

public:
     }
     static constexpr std::false_type
     __allow_parallel()
     {
         return std::false_type{};
     }
 };
 
-#if __PSTL_USE_PAR_POLICIES
 // 2.5, Parallel execution policy
 class parallel_policy
 {
   public:
     // For internal use only
     static constexpr std::false_type
     __allow_unsequenced()
     {
__allow_vector()
         return std::true_type{};
     }
     static constexpr std::true_type
     __allow_parallel()
     {
         return std::true_type{};
     }
 };
-#endif
 
 class unsequenced_policy
 {
   public:
     // For internal use only
     static constexpr std::true_type
     __allow_unsequenced()
     {
         return std::true_type{};
     }
     static constexpr std::true_type
     __allow_vector()
     {
         return std::true_type{};
     }
     static constexpr std::false_type
     __allow_parallel()
     {
         return std::false_type{};
     }
 };
 
 // 2.8, Execution policy objects
 constexpr sequenced_policy seq{};
-#if __PSTL_USE_PAR_POLICIES
 constexpr parallel_policy par{};
 constexpr parallel_unsequenced_policy par_unseq{};
-#endif
 constexpr unsequenced_policy unseq{};
 
 // 2.3, Execution policy type trait
 template <class T>
 struct is_execution_policy : std::false_type
 {
 };
 
 template <>
 struct is_execution_policy<sequenced_policy> : std::true_type
 {
 };
-#if __PSTL_USE_PAR_POLICIES
 template <>
 struct is_execution_policy<parallel_policy> : std::true_type
 {
 };
 template <>
 struct is_execution_policy<parallel_unsequenced_policy> : std::true_type
 {
 };
-#endif
 template <>
 struct is_execution_policy<unsequenced_policy> : std::true_type
 {
 };
 
 #if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
 template <class T>
 constexpr bool is_execution_policy_v = is_execution_policy<T>::value;

pstl/include/pstl/internal/execution_impl.h

 template <>
 struct policy_traits<unsequenced_policy>
 {
     typedef std::false_type allow_parallel;
     typedef std::true_type allow_unsequenced;
     typedef std::true_type allow_vector;
 };
 
-#if __PSTL_USE_PAR_POLICIES
 template <>
 struct policy_traits<parallel_policy>
 {
     typedef std::true_type allow_parallel;
     typedef std::false_type allow_unsequenced;
     typedef std::false_type allow_vector;
 };
 
 template <>
 struct policy_traits<parallel_unsequenced_policy>
 {
     typedef std::true_type allow_parallel;
     typedef std::true_type allow_unsequenced;
     typedef std::true_type allow_vector;
 };
-#endif
 
 template <typename _ExecutionPolicy>
 using collector_t = typename policy_traits<typename std::decay<_ExecutionPolicy>::type>::collector_type;
 
 template <typename _ExecutionPolicy>
 using allow_vector = typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_vector;
 
 template <typename _ExecutionPolicy>

pstl/include/pstl/internal/glue_execution_defs.h

 using __pstl::execution::is_execution_policy_v;
 #endif
 #endif
 
 namespace execution
 {
 // Standard C++ policy classes
 using __pstl::execution::sequenced_policy;
-#if __PSTL_USE_PAR_POLICIES
 using __pstl::execution::parallel_policy;
 using __pstl::execution::parallel_unsequenced_policy;
-#endif
+
 // Standard predefined policy instances
 using __pstl::execution::seq;
-#if __PSTL_USE_PAR_POLICIES
 using __pstl::execution::par;
 using __pstl::execution::par_unseq;
-#endif
+
 // Implementation-defined names
 // Unsequenced policy is not yet standard, but for consistency
 // we include it into namespace std::execution as well
 using __pstl::execution::unseq;
 using __pstl::execution::unsequenced_policy;
 } // namespace execution
 } // namespace std
 
 #endif /* __PSTL_glue_execution_defs_H */

pstl/include/pstl/internal/numeric_impl.h

 // -*- C++ -*-
 //===-- numeric_impl.h ----------------------------------------------------===//
 //
 // 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 __PSTL_numeric_impl_H
 #define __PSTL_numeric_impl_H
 
 #include <iterator>
 #include <type_traits>
 #include <numeric>
 
+#include "parallel_backend.h"
 #include "pstl_config.h"
 #include "execution_impl.h"
 #include "unseq_backend_simd.h"
 
-#if __PSTL_USE_PAR_POLICIES
-#include "parallel_backend.h"
-#endif
-
 namespace __pstl
 {
 namespace internal
 {
 
 //------------------------------------------------------------------------
 // transform_reduce (version with two binary functions, according to draft N4659)
 //------------------------------------------------------------------------

 pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                          _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
                          _BinaryOperation2 __binary_op2, _IsVector __is_vector,
                          /*is_parallel=*/std::false_type) noexcept
 {
     return brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
           class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
 _Tp
 pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
                          _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
                          _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     return internal::except_handler([&]() {
         return par_backend::parallel_transform_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
             [__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable {
                 return __binary_op2(*__i, *(__first2 + (__i - __first1)));
             },
             __init,
             __binary_op1, // Combine
             [__first1, __first2, __binary_op1, __binary_op2,
              __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp {
                 return internal::brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1,
                                                         __binary_op2, __is_vector);
             });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // transform_reduce (version with unary and binary functions)
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
 _Tp
 brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,

 _Tp
 pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
                          _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
                          /*is_parallel=*/std::false_type) noexcept
 {
     return brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
           class _IsVector>
 _Tp
 pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
                          _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
                          /*is_parallel=*/std::true_type)
 {
     return except_handler([&]() {
         return par_backend::parallel_transform_reduce(
             std::forward<_ExecutionPolicy>(__exec), __first, __last,
             [__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op,
             [__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) {
                 return brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector);
             });
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // transform_exclusive_scan
 //
 // walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
 //------------------------------------------------------------------------
 
 // Exclusive form
pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
                        _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
                        _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
 {
     return internal::brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
                                           __is_vector)
         .first;
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation, class _Inclusive, class _IsVector>
 typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
 pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                        _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
                        _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
return internal::except_handler([&]() {
                                                                       _Tp __init) {
                 return internal::brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init,
                                                       __binary_op, _Inclusive(), __is_vector)
                     .second;
             });
         return __result + (__last - __first);
     });
 }
-#endif
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation, class _Inclusive, class _IsVector>
 typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type
 pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
                        _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
                        _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
 {
     typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
return except_handler([&]() {
                                             return __binary_op(__initial, __x);
                                         }) -
                          1);
             },
             [](_Tp __res) {});
         return __result + (__last - __first);
     });
 }
-#endif
 
 //------------------------------------------------------------------------
 // adjacent_difference
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
 _OutputIterator
 brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first,

 _OutputIterator
 pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
                             _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector,
                             /*is_parallel*/ std::false_type) noexcept
 {
     return internal::brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector);
 }
 
-#if __PSTL_USE_PAR_POLICIES
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
           class _IsVector>
 _ForwardIterator2
 pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                             _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector,
                             /*is_parallel=*/std::true_type)
 {
     assert(__first != __last);
     typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
     typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
 
     *__d_first = *__first;
     par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last - 1,
                               [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) {
                                   _ForwardIterator2 __d_b = __d_first + (__b - __first);
                                   brick_walk3(__b, __e, __b + 1, __d_b + 1,
                                               [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) {
                                                   __z = __op(__y, __x);
                                               },
                                               __is_vector);
                               });
     return __d_first + (__last - __first);
 }
-#endif
 
 } // namespace internal
 } // namespace __pstl
 
 #endif /* __PSTL_numeric_impl_H */

pstl/include/pstl/internal/pstl_config.h

 // -*- C++ -*-
 //===-- pstl_config.h -----------------------------------------------------===//
 //
 // 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 __PSTL_config_H
 #define __PSTL_config_H
 
 #define PSTL_VERSION 203
 #define PSTL_VERSION_MAJOR (PSTL_VERSION / 100)
 #define PSTL_VERSION_MINOR (PSTL_VERSION - PSTL_VERSION_MAJOR * 100)
 
-// Check the user-defined macro for parallel policies
-#if defined(PSTL_USE_PARALLEL_POLICIES)
-#undef __PSTL_USE_PAR_POLICIES
-#define __PSTL_USE_PAR_POLICIES PSTL_USE_PARALLEL_POLICIES
-// Check the internal macro for parallel policies
-#elif !defined(__PSTL_USE_PAR_POLICIES)
-#define __PSTL_USE_PAR_POLICIES 1
-#endif
-
 #if !defined(__PSTL_PAR_BACKEND_SERIAL) && !defined(__PSTL_PAR_BACKEND_TBB)
 #   error "The parallel backend is neither serial nor TBB"
 #endif
 
 // Check the user-defined macro for warnings
 #if defined(PSTL_USAGE_WARNINGS)
 #undef __PSTL_USAGE_WARNINGS
 #define __PSTL_USAGE_WARNINGS PSTL_USAGE_WARNINGS

pstl/test/pstl_test_config.h

#define __PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN                                                                       \
     (__i386__ && !_DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && __APPLE__)
 #define __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN                                                            \
     (!_DEBUG && __INTEL_COMPILER >= 1800 && __INTEL_COMPILER < 1900 && _MSC_VER == 1910)
 #define __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN                                                           \
     (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && _MSC_VER >= 1900)
 #define __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN                                                            \
     (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1600 && __INTEL_COMPILER < 1700 && _MSC_VER == 1900)
 #define __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN                                                           \
-    (__PSTL_USE_PAR_POLICIES && ((_M_X64 && _MSC_VER == 1900) || __x86_64) && !_DEBUG && __INTEL_COMPILER < 1700)
+    (((_M_X64 && _MSC_VER == 1900) || __x86_64) && !_DEBUG && __INTEL_COMPILER < 1700)
 #define __PSTL_ICC_16_17_TEST_64_TIMEOUT (__x86_64 && __INTEL_COMPILER && __INTEL_COMPILER < 1800 && !__APPLE__)
 #define __PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN (!_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800)
 #define __PSTL_CLANG_TEST_BIG_OBJ_DEBUG_32_BROKEN                                                                      \
     (__i386__ && PSTL_USE_DEBUG && __clang__ && __PSTL_CLANG_VERSION <= 90000)
 #define __PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN                                                            \
     (!_DEBUG && __INTEL_COMPILER &&                                                                                    \
      (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 3)))
 #define __PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN                                                               \
     (!_DEBUG && __INTEL_COMPILER == 1800 && __AVX__ && !__AVX2__ && !__AVX512__)
 #define __PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN                                                               \
     (!PSTL_USE_DEBUG && (__linux__ || __APPLE__) && __INTEL_COMPILER == 1900)
 #define __PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN                                                              \
     (__INTEL_COMPILER == 1900 && _MSC_VER >= 1900 && _MSC_VER <= 1910)
 #define __PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN (__INTEL_COMPILER == 1900 && _MSC_VER && !_DEBUG)
 
 #endif /* __PSTL_TEST_config_H */

pstl/test/utils.h

for (int32_t i = 0; i < 2; ++i)
         for (int32_t j = 0; j < 2; ++j)
         {
             result.a[i][j] = left.a[i][0] * right.a[0][j] + left.a[i][1] * right.a[1][j];
         }
     }
     return result;
 }
 
-// Check that Intel(R) Threading Building Blocks header files are not used when parallel policies are off
-#if !__PSTL_USE_PAR_POLICIES
-#if defined(TBB_INTERFACE_VERSION)
-#error The parallel backend is used while it should not (__PSTL_USE_PAR_POLICIES==0)
-#endif
-#endif
-
 //============================================================================
 // Adapters for creating different types of iterators.
 //
 // In this block we implemented some adapters for creating differnet types of iterators.
 // It's needed for extending the unit testing of Parallel STL algorithms.
 // We have adapters for iterators with different tags (forward_iterator_tag, bidirectional_iterator_tag), reverse iterators.
 // The input iterator should be const or non-const, non-reverse random access iterator.
 // Iterator creates in "MakeIterator":

 void
 invoke_on_all_policies(Op op, T&&... rest)
 {
     using namespace __pstl::execution;
 
     // Try static execution policies
     invoke_on_all_iterator_types()(seq, op, std::forward<T>(rest)...);
     invoke_on_all_iterator_types()(unseq, op, std::forward<T>(rest)...);
-#if __PSTL_USE_PAR_POLICIES
     invoke_on_all_iterator_types()(par, op, std::forward<T>(rest)...);
     invoke_on_all_iterator_types()(par_unseq, op, std::forward<T>(rest)...);
-#endif
 }
 
 template <typename F>
 struct NonConstAdapter
 {
     F my_f;
     NonConstAdapter(const F& f) : my_f(f) {}