[pstl] Fix compile errors when PARALLEL_POLICIES is disabled

[jerryct]

Summary

Wrap all functions dispatched by a parallel policy tag in a conditional directive.

[MikeDvorskiy]

include/pstl/internal/algorithm_impl.h

62–75

What if I suggest excluding the overloaded parallel pattern (here and everywhere) by SFINAE approach, like this:

pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
pattern_any_of(_ExecutionPolicy&& exec, _ForwardIterator first, _ForwardIterator last, _Pred __pred,.....

The macro __PSTL_USE_PAR_POLICIES controls parallel policies definitions and it should be enough.

[akukanov]

include/pstl/internal/algorithm_impl.h

62–75

Mikhail, I think that use of enable_if_execution_policy is inconsistent if only applied to "parallel" overloads, and less clear comparing to the macro.

If the SFINAE way is preferred, we should make it differently, e.g. introduce enable_if_parallel/enable_if_not_parallel and use those instead of is_parallel function parameter which becomes redundant.

[ldionne]

LGTM. I can witness the problem locally with the CMake build and the fix resolves the issue. Thanks!

Committed as r350813.

[rodgert]

See inline comment

include/pstl/internal/algorithm_impl.h

181

Shouldn't this definition be protected by #ifdef __PSTL_USE_PAR_POLICIES?

Sure, it will fail to compile because it calls something that is __PSTL_USE_PAR_POLICIES but what was it ldionne said about being consistent recently?

[rodgert]

See inline notes on __PSTL_USE_PAR_POLICIES #ifdefs

include/pstl/internal/algorithm_impl.h

2432–2439

Shouldn't this definition also be protected by #ifdef __PSTL_USE_PAR_POLICIES?

[rodgert]

Added a reply note to Mihail and Alexey's inline commentary on whether __PSTL_USE_PAR_POLICIES is how we really want to be controlling this.

[ldionne]

include/pstl/internal/algorithm_impl.h

181

I don't understand your comment. What is inconsistent about pattern_walk1_n not being guarded by #ifdef __PSTL_USE_PAR_POLICIES? Sorry, just trying to understand.

FWIW, I think that removing code based on __PSTL_USE_PAR_POLICIES is a misfeature and we should find a more gracious way of handling the lack of parallel policies, for example by having a backend that does everything sequentially if that makes sense. I accepted this revision because it fixed a compilation error under a configuration that currently seems to be supported.

[rodgert]

include/pstl/internal/algorithm_impl.h

181

Sorry, I applied the inline comment to the wrong variant of pattern_walk1_n, it's the next one down, where /*is_parallel=*/std::true_type

I also agree that removing code based on __PSTL_USE_PAR_POLICIES is a misfeature. I want to propose some alternatives based on work I've started on an OpenMP based backend and discussions that came out of SG1 in San Diego about likely future directions with this part of the standard library, but I need to finish this merge and get a patch into libstdc++ before I can return to that work.

In doing the reconciliation with the libstdc++ version of this code with what was submitted upstream (which unfortunately differs far more than what I thought we had agreed for the initial commit), I came across these inconsistencies and am just reporting them (they are fixed in my local branch, and will be part of that submission when it's ready).

2506–2515

This should also be protected by #ifdef __PSTL_USE_PAR_POLICIES

[jerryct]

include/pstl/internal/algorithm_impl.h

181

I addressed you comment in this new change: https://reviews.llvm.org/D57638

[jerryct]

Close because of https://reviews.llvm.org/D57638

include/pstl/internal/algorithm_impl.h

 #include <algorithm>
 
 #include "execution_impl.h"
 #include "memory_impl.h"
 #include "unseq_backend_simd.h"
 
 #if __PSTL_USE_PAR_POLICIES
 #include "parallel_backend.h"
-#endif
 #include "parallel_impl.h"
+#endif
 
 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);
 }
 
 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;
 }
 
 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
                 [__first, __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 _OutputIterator, class _Size, class _Tp>
 _OutputIterator
 brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept
 {
     return std::fill_n(__first, __count, __value);
 }
 
 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
 _OutputIterator
 pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value,
                /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
 {
     return internal::brick_fill_n(__first, __count, __value, __is_vector);
 }
 
 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
 _OutputIterator
 pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value,
                /*is_parallel=*/std::true_type, _IsVector __is_vector)
 {
     return internal::pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value,
                                   std::true_type(), __is_vector);
 }
 
 //------------------------------------------------------------------------
 // generate, generate_n
 //------------------------------------------------------------------------
 template <class _RandomAccessIterator, class _Generator>
 void
 brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g,
                /* is_vector = */ std::true_type) noexcept

 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);
 }
 
 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);
 }
 
 //------------------------------------------------------------------------
 // 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,
         [__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)
                                         _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,
         [__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, __last, __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 */

include/pstl/internal/numeric_impl.h

 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 */