[libc++][PSTL] Remove configurations flags

[philnik]

Summary

Some configurations flags are always the same. We can just remove them to make the code a bit cleaner.

[ldionne]

libcxx/include/__pstl/internal/pstl_config.h

35–45

If those are supported by Clang/GCC, let's keep these annotations.

57–58

Let's also check if those are supported. Basically, we should strive to retain as much semantic annotations as we can -- there's no good reason to remove them unless they are not supported by the compiler or they're wrong (but right now we must assume that everything in the original PSTL is correct unless proven otherwise).

[philnik]

Address comments

libcxx/include/__pstl/internal/pstl_config.h

35–45

These seem to be supported. I kept the #if in the simplification patch.

57–58

This seems to be an intel extension.

[philnik]

Fix diff

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Rebased

libcxx/include/__pstl/internal/algorithm_impl.h

 }
 
 template <class _RandomAccessIterator, class _BinaryPredicate>
 _RandomAccessIterator
 __brick_unique(_RandomAccessIterator __first,
                _RandomAccessIterator __last,
                _BinaryPredicate __pred,
                /*is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::unique(__first, __last, __pred);
 }
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator __pattern_unique(
     _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) noexcept {
   return __internal::__brick_unique(__first, __last, __pred, typename _Tag::__is_vector{});
 }

 }
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
 _RandomAccessIterator __brick_partition(
     _RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _UnaryPredicate __pred,
     /*is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::partition(__first, __last, __pred);
 }
 
 template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
 _ForwardIterator __pattern_partition(
     _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) noexcept {
   return __internal::__brick_partition(__first, __last, __pred, typename _Tag::__is_vector{});
 }

 }
 
 template <class _RandomAccessIterator, class _UnaryPredicate>
 _RandomAccessIterator __brick_stable_partition(
     _RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _UnaryPredicate __pred,
     /*__is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::stable_partition(__first, __last, __pred);
 }
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
 _BidirectionalIterator __pattern_stable_partition(
     _Tag,
     _ExecutionPolicy&&,
     _BidirectionalIterator __first,

 _RandomAccessIterator3 __brick_merge(
     _RandomAccessIterator1 __first1,
     _RandomAccessIterator1 __last1,
     _RandomAccessIterator2 __first2,
     _RandomAccessIterator2 __last2,
     _RandomAccessIterator3 __d_first,
     _Compare __comp,
     /* __is_vector = */ std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp);
 }
 
 template <class _Tag,
           class _ExecutionPolicy,
           class _ForwardIterator1,
           class _ForwardIterator2,
           class _OutputIterator,

 
 template <class _RandomAccessIterator, class _Compare>
 void __brick_inplace_merge(
     _RandomAccessIterator __first,
     _RandomAccessIterator __middle,
     _RandomAccessIterator __last,
     _Compare __comp,
     /* __is_vector = */ std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial")
+  // TODO: vectorize
   std::inplace_merge(__first, __middle, __last, __comp);
 }
 
 template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
 void __pattern_inplace_merge(
     _Tag,
     _ExecutionPolicy&&,
     _BidirectionalIterator __first,

 _OutputIterator __brick_set_union(
     _RandomAccessIterator1 __first1,
     _RandomAccessIterator1 __last1,
     _RandomAccessIterator2 __first2,
     _RandomAccessIterator2 __last2,
     _OutputIterator __result,
     _Compare __comp,
     /*__is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
 }
 
 template <class _Tag,
           class _ExecutionPolicy,
           class _ForwardIterator1,
           class _ForwardIterator2,
           class _OutputIterator,

 _RandomAccessIterator3 __brick_set_intersection(
     _RandomAccessIterator1 __first1,
     _RandomAccessIterator1 __last1,
     _RandomAccessIterator2 __first2,
     _RandomAccessIterator2 __last2,
     _RandomAccessIterator3 __result,
     _Compare __comp,
     /*__is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
 }
 
 template <class _Tag,
           class _ExecutionPolicy,
           class _ForwardIterator1,
           class _ForwardIterator2,
           class _OutputIterator,

 _RandomAccessIterator3 __brick_set_difference(
     _RandomAccessIterator1 __first1,
     _RandomAccessIterator1 __last1,
     _RandomAccessIterator2 __first2,
     _RandomAccessIterator2 __last2,
     _RandomAccessIterator3 __result,
     _Compare __comp,
     /*__is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
 }
 
 template <class _Tag,
           class _ExecutionPolicy,
           class _ForwardIterator1,
           class _ForwardIterator2,
           class _OutputIterator,

 _RandomAccessIterator3 __brick_set_symmetric_difference(
     _RandomAccessIterator1 __first1,
     _RandomAccessIterator1 __last1,
     _RandomAccessIterator2 __first2,
     _RandomAccessIterator2 __last2,
     _RandomAccessIterator3 __result,
     _Compare __comp,
     /*__is_vector=*/std::true_type) noexcept {
-  _PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
+  // TODO: vectorize
   return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
 }
 
 template <class _Tag,
           class _ExecutionPolicy,
           class _ForwardIterator1,
           class _ForwardIterator2,
           class _OutputIterator,

 //------------------------------------------------------------------------
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
 std::pair<_ForwardIterator1, _ForwardIterator2> __mismatch_serial(
     _ForwardIterator1 __first1,
     _ForwardIterator1 __last1,
     _ForwardIterator2 __first2,
     _ForwardIterator2 __last2,
     _BinaryPredicate __pred) {
-#if defined(_PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT)
   return std::mismatch(__first1, __last1, __first2, __last2, __pred);
-#else
-  for (; __first1 != __last1 && __first2 != __last2 && __pred(*__first1, *__first2); ++__first1, ++__first2) {
-  }
-  return std::make_pair(__first1, __first2);
-#endif
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
 std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(
     _ForwardIterator1 __first1,
     _ForwardIterator1 __last1,
     _ForwardIterator2 __first2,
     _ForwardIterator2 __last2,

libcxx/include/__pstl/internal/execution_defs.h

 struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type {};
 template <>
 struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type {};
 template <>
 struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type {};
 template <>
 struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type {};
 
-#if defined(_PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT)
 template <class _Tp>
 constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
-#endif
-
 } // namespace v1
 } // namespace execution
 
 namespace __internal {
 template <class _ExecPolicy, class _Tp>
 using __enable_if_execution_policy =
     typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<_ExecPolicy>::type>::value,
                             _Tp>::type;

libcxx/include/__pstl/internal/numeric_impl.h

std::pair<_OutputIterator, _Tp> __brick_transform_scan(
     _OutputIterator __result,
     _UnaryOperation __unary_op,
     _Tp __init,
     _BinaryOperation __binary_op,
     /*Inclusive*/ std::false_type,
     /*is_vector=*/std::false_type) noexcept {
   for (; __first != __last; ++__first, ++__result) {
     *__result = __init;
-    _PSTL_PRAGMA_FORCEINLINE
     __init = __binary_op(__init, __unary_op(*__first));
   }
   return std::make_pair(__result, __init);
 }
 
 // Inclusive form
 template <class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
 std::pair<_OutputIterator, _Tp> __brick_transform_scan(
     _RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _OutputIterator __result,
     _UnaryOperation __unary_op,
     _Tp __init,
     _BinaryOperation __binary_op,
     /*Inclusive*/ std::true_type,
     /*is_vector=*/std::false_type) noexcept {
   for (; __first != __last; ++__first, ++__result) {
-    _PSTL_PRAGMA_FORCEINLINE
     __init    = __binary_op(__init, __unary_op(*__first));
     *__result = __init;
   }
   return std::make_pair(__result, __init);
 }
 
 // type is arithmetic and binary operation is a user defined operation.
 template <typename _Tp, typename _BinaryOperation>
__par_backend::__parallel_strict_scan(
               .second;
         },
         __binary_op,
         [__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) {
           return *(std::transform(__result + __i,
                                   __result + __i + __len,
                                   __result + __i,
                                   [&__initial, &__binary_op](const _Tp& __x) {
-                                    _PSTL_PRAGMA_FORCEINLINE
                                     return __binary_op(__initial, __x);
                                   }) -
                    1);
         },
         [](_Tp) {});
     return __result + (__last - __first);
   });
 }

libcxx/include/__pstl/internal/parallel_backend.h

 }
 #elif defined(_PSTL_PAR_BACKEND_OPENMP)
 #    include "parallel_backend_omp.h"
 namespace __pstl
 {
 namespace __par_backend = __omp_backend;
 }
 #else
-_PSTL_PRAGMA_MESSAGE("Parallel backend was not specified");
+#  error "No backend set"
 #endif
 
 #endif /* _PSTL_PARALLEL_BACKEND_H */

libcxx/include/__pstl/internal/pstl_config.h

 #    define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
 #    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
 #else //no simd
 #    define _PSTL_PRAGMA_SIMD
 #    define _PSTL_PRAGMA_DECLARE_SIMD
 #    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
 #endif //Enable SIMD
 
-#define _PSTL_PRAGMA_FORCEINLINE
-
 // TODO: find out when to enable these annotations
 #if 0
 #    define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
 #    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
 #    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
 #else
 #    define _PSTL_PRAGMA_SIMD_SCAN(PRM)
 #    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
 #    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
 #endif
 
-#define _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT
-#define _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT
-#define _PSTL_CPP14_INTEGER_SEQUENCE_PRESENT
-#define _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
-
 #if defined(_OPENMP) && _OPENMP >= 201307
 #    define _PSTL_UDR_PRESENT
 #endif
 
-#define _PSTL_PRAGMA_SIMD_EARLYEXIT
-#define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM)
-#define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1, PRM2)
+#define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
 
 // Declaration of reduction functor, where
 // NAME - the name of the functor
 // OP - type of the callable object with the reduction operation
 // omp_in - refers to the local partial result
 // omp_out - refers to the final value of the combiner operator
 // omp_priv - refers to the private copy of the initial value
 // omp_orig - refers to the original variable to be reduced
 #define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)                                                                       \
     _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
 
-#define _PSTL_PRAGMA_VECTOR_UNALIGNED
-#define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
-#define _PSTL_PRAGMA_MESSAGE(x)
-#define _PSTL_PRAGMA_MESSAGE_POLICIES(x)
-
 #endif /* _PSTL_CONFIG_H */

libcxx/include/__pstl/internal/unseq_backend_simd.h

__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
     return __first3 + __n;
 }
 
 // TODO: check whether __simd_first() can be used here
 template <class _Index, class _DifferenceType, class _Pred>
 _LIBCPP_HIDE_FROM_ABI bool
 __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
 {
-#if defined(_PSTL_EARLYEXIT_PRESENT)
-    _DifferenceType __i;
-    _PSTL_PRAGMA_VECTOR_UNALIGNED
-    _PSTL_PRAGMA_SIMD_EARLYEXIT
-    for (__i = 0; __i < __n; ++__i)
-        if (__pred(__first[__i]))
-            break;
-    return __i < __n;
-#else
     _DifferenceType __block_size = 4 < __n ? 4 : __n;
     const _Index __last = __first + __n;
     while (__last != __first)
     {
         int32_t __flag = 1;
         _PSTL_PRAGMA_SIMD_REDUCTION(& : __flag)
         for (_DifferenceType __i = 0; __i < __block_size; ++__i)
             if (__pred(*(__first + __i)))
                 __flag = 0;
         if (!__flag)
             return true;
 
         __first += __block_size;
         if (__last - __first >= __block_size << 1)
         {
             // Double the block _Size.  Any unnecessary iterations can be amortized against work done so far.
             __block_size <<= 1;
         }
         else
         {
             __block_size = __last - __first;
         }
     }
     return false;
-#endif
 }
 
 template <class _Index, class _DifferenceType, class _Compare>
 _LIBCPP_HIDE_FROM_ABI _Index
 __simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
 {
-#if defined(_PSTL_EARLYEXIT_PRESENT)
-    _DifferenceType __i = __begin;
-    _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
-        _PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i)
-    {
-        if (__comp(__first, __i))
-        {
-            break;
-        }
-    }
-    return __first + __i;
-#else
     // Experiments show good block sizes like this
     const _DifferenceType __block_size = 8;
     alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
     while (__end - __begin >= __block_size)
     {
         _DifferenceType __found = 0;
-        _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
             _PSTL_PRAGMA_SIMD_REDUCTION(|
                                         : __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size;
                                                         ++__i)
         {
             const _DifferenceType __t = __comp(__first, __i);
             __lane[__i - __begin] = __t;
             __found |= __t;
         }
__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
     {
         if (__comp(__first, __begin))
         {
             return __first + __begin;
         }
         ++__begin;
     }
     return __first + __end;
-#endif //_PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
 _LIBCPP_HIDE_FROM_ABI std::pair<_Index1, _Index2>
 __simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
 {
-#if defined(_PSTL_EARLYEXIT_PRESENT)
-    _DifferenceType __i = 0;
-    _PSTL_PRAGMA_VECTOR_UNALIGNED
-    _PSTL_PRAGMA_SIMD_EARLYEXIT
-    for (; __i < __n; ++__i)
-        if (__pred(__first1[__i], __first2[__i]))
-            break;
-    return std::make_pair(__first1 + __i, __first2 + __i);
-#else
     const _Index1 __last1 = __first1 + __n;
     const _Index2 __last2 = __first2 + __n;
     // Experiments show good block sizes like this
     const _DifferenceType __block_size = 8;
     alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
     while (__last1 - __first1 >= __block_size)
     {
         _DifferenceType __found = 0;
         _DifferenceType __i;
-        _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
             _PSTL_PRAGMA_SIMD_REDUCTION(|
                                         : __found) for (__i = 0; __i < __block_size; ++__i)
         {
             const _DifferenceType __t = __pred(__first1[__i], __first2[__i]);
             __lane[__i] = __t;
             __found |= __t;
         }
         if (__found)
__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
     }
 
     //Keep remainder scalar
     for (; __last1 != __first1; ++__first1, ++__first2)
         if (__pred(*(__first1), *(__first2)))
             return std::make_pair(__first1, __first2);
 
     return std::make_pair(__last1, __last2);
-#endif //_PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index, class _DifferenceType, class _Pred>
 _LIBCPP_HIDE_FROM_ABI _DifferenceType
 __simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
 {
     _DifferenceType __count = 0;
     _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
if (__n == 0)
         return __result;
 
     _DifferenceType __cnt = 1;
     __result[0] = __first[0];
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 1; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (!__pred(__first[__i], __first[__i - 1]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }

 _LIBCPP_HIDE_FROM_ABI _OutputIterator
 __simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt = 0;
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (__pred(__first[__i]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }
__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
                     _Assigner __assigner) noexcept
 {
     _DifferenceType __cnt = 0;
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         if (__mask[__i])
         {
-            _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
             {
                 __assigner(__first + __i, __result + __cnt);
                 ++__cnt;
             }
         }
     }
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
 _LIBCPP_HIDE_FROM_ABI void
 __simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                          _OutputIterator2 __out_false, bool* __mask) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__mask[__i])
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];

 __simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
 {
     if (__last - __first < 2)
         return __last;
 
     typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
     _DifferenceType __i = 0;
 
-#if defined(_PSTL_EARLYEXIT_PRESENT)
-    //Some compiler versions fail to compile the following loop when iterators are used. Indices are used instead
-    const _DifferenceType __n = __last - __first - 1;
-    _PSTL_PRAGMA_VECTOR_UNALIGNED
-    _PSTL_PRAGMA_SIMD_EARLYEXIT
-    for (; __i < __n; ++__i)
-        if (__pred(__first[__i], __first[__i + 1]))
-            break;
-
-    return __i < __n ? __first + __i : __last;
-#else
     // Experiments show good block sizes like this
     //TODO: to consider tuning block_size for various data types
     const _DifferenceType __block_size = 8;
     alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
     while (__last - __first >= __block_size)
     {
         _DifferenceType __found = 0;
-        _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
             _PSTL_PRAGMA_SIMD_REDUCTION(|
                                         : __found) for (__i = 0; __i < __block_size - 1; ++__i)
         {
             //TODO: to improve SIMD vectorization
             const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1));
             __lane[__i] = __t;
             __found |= __t;
         }
while (__last - __first >= __block_size)
         __first += __block_size;
     }
     //Process the rest elements
     for (; __last - __first > 1; ++__first)
         if (__pred(*__first, *(__first + 1)))
             return __first;
 
     return __last;
-#endif
 }
 
 // It was created to reduce the code inside std::enable_if
 template <typename _Tp, typename _BinaryOperation>
 using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
                                                             std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
 
 template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>

 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
-
     _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __result[__i] = __init_.__value;
         _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_)
-        _PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // Inclusive scan for "+" and arithmetic types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>

 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, std::true_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
-
     _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
         _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_)
         __result[__i] = __init_.__value;
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.

 __simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                       _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__pred(__first[__i]))
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];
__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
     {
         return __current;
     }
 
     _DifferenceType __cnt = 0;
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 1; __i < __n; ++__i)
     {
-        _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (!__pred(__current[__i]))
         {
             __current[__cnt] = std::move(__current[__i]);
             ++__cnt;
         }
     }
     return __current + __cnt;
 }
 } // namespace __unseq_backend
 } // namespace __pstl
 
 #endif /* _PSTL_UNSEQ_BACKEND_SIMD_H */