[pstl] r350813 - [pstl] Fix compile errors when PARALLEL_POLICIES is disabled
Louis Dionne
ldionne at apple.com
Thu Jan 10 03:23:34 PST 2019
Author: ldionne
Date: Thu Jan 10 03:23:33 2019
New Revision: 350813
URL: http://llvm.org/viewvc/llvm-project?rev=350813&view=rev
Log:
[pstl] Fix compile errors when PARALLEL_POLICIES is disabled
Reviewed as https://reviews.llvm.org/D56139.
Thanks to @jerryct for the patch.
Modified:
pstl/trunk/include/pstl/internal/algorithm_impl.h
pstl/trunk/include/pstl/internal/numeric_impl.h
Modified: pstl/trunk/include/pstl/internal/algorithm_impl.h
URL: http://llvm.org/viewvc/llvm-project/pstl/trunk/include/pstl/internal/algorithm_impl.h?rev=350813&r1=350812&r2=350813&view=diff
==============================================================================
--- pstl/trunk/include/pstl/internal/algorithm_impl.h (original)
+++ pstl/trunk/include/pstl/internal/algorithm_impl.h Thu Jan 10 03:23:33 2019
@@ -23,8 +23,8 @@
#if __PSTL_USE_PAR_POLICIES
#include "parallel_backend.h"
-#endif
#include "parallel_impl.h"
+#endif
namespace __pstl
{
@@ -59,6 +59,7 @@ pattern_any_of(_ExecutionPolicy&&, _Forw
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,
@@ -71,6 +72,7 @@ pattern_any_of(_ExecutionPolicy&& __exec
});
});
}
+#endif
// [alg.foreach]
// for_each_n with no policy
@@ -113,6 +115,7 @@ pattern_walk1(_ExecutionPolicy&&, _Forwa
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,
@@ -126,6 +129,7 @@ pattern_walk1(_ExecutionPolicy&& __exec,
});
});
}
+#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void
@@ -135,6 +139,7 @@ pattern_walk_brick(_ExecutionPolicy&&, _
__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,
@@ -145,6 +150,7 @@ pattern_walk_brick(_ExecutionPolicy&& __
[__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
});
}
+#endif
//------------------------------------------------------------------------
// walk1_n
@@ -191,6 +197,7 @@ pattern_walk_brick_n(_ExecutionPolicy&&,
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,
@@ -203,6 +210,7 @@ pattern_walk_brick_n(_ExecutionPolicy&&
return __first + __n;
});
}
+#endif
//------------------------------------------------------------------------
// walk2 (pseudo)
@@ -253,6 +261,7 @@ pattern_walk2(_ExecutionPolicy&&, _Forwa
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,
@@ -266,6 +275,7 @@ pattern_walk2(_ExecutionPolicy&& __exec,
return __first2 + (__last1 - __first1);
});
}
+#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
class _IsVector>
@@ -294,6 +304,7 @@ pattern_walk2_brick(_ExecutionPolicy&&,
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,
@@ -308,7 +319,9 @@ pattern_walk2_brick(_ExecutionPolicy&& _
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,
@@ -323,6 +336,7 @@ pattern_walk2_brick_n(_ExecutionPolicy&&
return __first2 + __n;
});
}
+#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
_ForwardIterator2
@@ -364,6 +378,7 @@ pattern_walk3(_ExecutionPolicy&&, _Forwa
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
@@ -381,6 +396,7 @@ pattern_walk3(_ExecutionPolicy&& __exec,
return __first3 + (__last1 - __first1);
});
}
+#endif
//------------------------------------------------------------------------
// equal
@@ -412,6 +428,7 @@ pattern_equal(_ExecutionPolicy&&, _Forwa
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
@@ -427,6 +444,7 @@ pattern_equal(_ExecutionPolicy&& __exec,
});
});
}
+#endif
//------------------------------------------------------------------------
// find_if
@@ -459,6 +477,7 @@ pattern_find_if(_ExecutionPolicy&&, _For
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,
@@ -474,6 +493,7 @@ pattern_find_if(_ExecutionPolicy&& __exe
/*is_first=*/true);
});
}
+#endif
//------------------------------------------------------------------------
// find_end
@@ -600,6 +620,7 @@ pattern_find_end(_ExecutionPolicy&&, _Fo
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
@@ -626,6 +647,7 @@ pattern_find_end(_ExecutionPolicy&& __ex
});
}
}
+#endif
//------------------------------------------------------------------------
// find_first_of
@@ -656,6 +678,7 @@ pattern_find_first_of(_ExecutionPolicy&&
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
@@ -672,6 +695,7 @@ pattern_find_first_of(_ExecutionPolicy&&
std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
});
}
+#endif
//------------------------------------------------------------------------
// search
@@ -702,6 +726,7 @@ pattern_search(_ExecutionPolicy&&, _Forw
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
@@ -727,6 +752,7 @@ pattern_search(_ExecutionPolicy&& __exec
});
}
}
+#endif
//------------------------------------------------------------------------
// search_n
@@ -757,6 +783,7 @@ pattern_search_n(_ExecutionPolicy&&, _Fo
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
@@ -784,6 +811,7 @@ pattern_search_n(_ExecutionPolicy&& __ex
});
}
}
+#endif
//------------------------------------------------------------------------
// copy_n
@@ -989,6 +1017,7 @@ pattern_copy_if(_ExecutionPolicy&&, _For
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
@@ -1023,6 +1052,7 @@ pattern_copy_if(_ExecutionPolicy&& __exe
// trivial sequence - use serial algorithm
return brick_copy_if(__first, __last, __result, __pred, __is_vector);
}
+#endif
//------------------------------------------------------------------------
// count
@@ -1051,6 +1081,7 @@ pattern_count(_ExecutionPolicy&&, _Forwa
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,
@@ -1066,6 +1097,7 @@ pattern_count(_ExecutionPolicy&& __exec,
std::plus<_SizeType>());
});
}
+#endif
//------------------------------------------------------------------------
// unique
@@ -1096,6 +1128,7 @@ pattern_unique(_ExecutionPolicy&&, _Forw
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>
@@ -1172,7 +1205,9 @@ remove_elements(_ExecutionPolicy&& __exe
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,
@@ -1198,6 +1233,7 @@ pattern_unique(_ExecutionPolicy&& __exec
},
__is_vector);
}
+#endif
//------------------------------------------------------------------------
// unique_copy
@@ -1254,6 +1290,7 @@ brick_calc_mask_2(_RandomAccessIterator
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
@@ -1303,6 +1340,7 @@ pattern_unique_copy(_ExecutionPolicy&& _
// trivial sequence - use serial algorithm
return brick_unique_copy(__first, __last, __result, __pred, __is_vector);
}
+#endif
//------------------------------------------------------------------------
// reverse
@@ -1364,6 +1402,7 @@ pattern_reverse(_ExecutionPolicy&&, _Bid
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,
@@ -1375,6 +1414,7 @@ pattern_reverse(_ExecutionPolicy&& __exe
brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector);
});
}
+#endif
//------------------------------------------------------------------------
// reverse_copy
@@ -1408,6 +1448,7 @@ pattern_reverse_copy(_ExecutionPolicy&&,
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,
@@ -1422,6 +1463,7 @@ pattern_reverse_copy(_ExecutionPolicy&&
});
return __d_first + __len;
}
+#endif
//------------------------------------------------------------------------
// rotate
@@ -1487,6 +1529,7 @@ pattern_rotate(_ExecutionPolicy&&, _Forw
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,
@@ -1546,6 +1589,7 @@ pattern_rotate(_ExecutionPolicy&& __exec
});
}
}
+#endif
//------------------------------------------------------------------------
// rotate_copy
@@ -1576,6 +1620,7 @@ pattern_rotate_copy(_ExecutionPolicy&&,
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,
@@ -1605,6 +1650,7 @@ pattern_rotate_copy(_ExecutionPolicy&& _
});
return __result + (__last - __first);
}
+#endif
//------------------------------------------------------------------------
// is_partitioned
@@ -1653,6 +1699,7 @@ pattern_is_partitioned(_ExecutionPolicy&
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,
@@ -1751,6 +1798,7 @@ pattern_is_partitioned(_ExecutionPolicy&
});
}
}
+#endif
//------------------------------------------------------------------------
// partition
@@ -1781,6 +1829,7 @@ pattern_partition(_ExecutionPolicy&&, _F
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,
@@ -1848,6 +1897,7 @@ pattern_partition(_ExecutionPolicy&& __e
return __result.__pivot;
});
}
+#endif
//------------------------------------------------------------------------
// stable_partition
@@ -1878,6 +1928,7 @@ pattern_stable_partition(_ExecutionPolic
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,
@@ -1930,6 +1981,7 @@ pattern_stable_partition(_ExecutionPolic
return __result.__pivot;
});
}
+#endif
//------------------------------------------------------------------------
// partition_copy
@@ -1965,6 +2017,7 @@ pattern_partition_copy(_ExecutionPolicy&
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>
@@ -2003,6 +2056,7 @@ pattern_partition_copy(_ExecutionPolicy&
// trivial sequence - use serial algorithm
return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
}
+#endif
//------------------------------------------------------------------------
// sort
@@ -2017,6 +2071,7 @@ pattern_sort(_ExecutionPolicy&&, _Random
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,
@@ -2029,6 +2084,7 @@ pattern_sort(_ExecutionPolicy&& __exec,
__last - __first);
});
}
+#endif
//------------------------------------------------------------------------
// stable_sort
@@ -2042,6 +2098,7 @@ pattern_stable_sort(_ExecutionPolicy&&,
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,
@@ -2053,6 +2110,7 @@ pattern_stable_sort(_ExecutionPolicy&& _
_Compare __comp) { std::stable_sort(__first, __last, __comp); });
});
}
+#endif
//------------------------------------------------------------------------
// partial_sort
@@ -2066,6 +2124,7 @@ pattern_partial_sort(_ExecutionPolicy&&,
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,
@@ -2084,6 +2143,7 @@ pattern_partial_sort(_ExecutionPolicy&&
__n);
});
}
+#endif
//------------------------------------------------------------------------
// partial_sort_copy
@@ -2098,6 +2158,7 @@ pattern_partial_sort_copy(_ExecutionPoli
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,
@@ -2166,6 +2227,7 @@ pattern_partial_sort_copy(_ExecutionPoli
}
});
}
+#endif
//------------------------------------------------------------------------
// adjacent_find
@@ -2194,6 +2256,7 @@ pattern_adjacent_find(_ExecutionPolicy&&
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,
@@ -2239,6 +2302,7 @@ pattern_adjacent_find(_ExecutionPolicy&&
);
});
}
+#endif
//------------------------------------------------------------------------
// nth_element
@@ -2252,6 +2316,7 @@ pattern_nth_element(_ExecutionPolicy&&,
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,
@@ -2297,6 +2362,7 @@ pattern_nth_element(_ExecutionPolicy&& _
}
} while (__x != __nth);
}
+#endif
//------------------------------------------------------------------------
// fill, fill_n
@@ -2325,6 +2391,7 @@ pattern_fill(_ExecutionPolicy&&, _Forwar
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,
@@ -2338,6 +2405,7 @@ pattern_fill(_ExecutionPolicy&& __exec,
return __last;
});
}
+#endif
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
@@ -2397,6 +2465,7 @@ pattern_generate(_ExecutionPolicy&&, _Fo
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,
@@ -2410,6 +2479,7 @@ pattern_generate(_ExecutionPolicy&& __ex
return __last;
});
}
+#endif
template <class OutputIterator, class Size, class _Generator>
OutputIterator
@@ -2476,6 +2546,7 @@ pattern_remove_if(_ExecutionPolicy&&, _F
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,
@@ -2496,6 +2567,7 @@ pattern_remove_if(_ExecutionPolicy&& __e
},
__is_vector);
}
+#endif
//------------------------------------------------------------------------
// merge
@@ -2530,6 +2602,7 @@ pattern_merge(_ExecutionPolicy&&, _Forwa
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
@@ -2544,6 +2617,7 @@ pattern_merge(_ExecutionPolicy&& __exec,
_Compare __comp) { return brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); });
return __d_first + (__last1 - __first1) + (__last2 - __first2);
}
+#endif
//------------------------------------------------------------------------
// inplace_merge
@@ -2574,6 +2648,7 @@ pattern_inplace_merge(_ExecutionPolicy&&
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,
@@ -2614,6 +2689,7 @@ pattern_inplace_merge(_ExecutionPolicy&&
});
});
}
+#endif
//------------------------------------------------------------------------
// includes
@@ -2628,6 +2704,7 @@ pattern_includes(_ExecutionPolicy&& __ex
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,
@@ -2682,9 +2759,11 @@ pattern_includes(_ExecutionPolicy&& __ex
});
});
}
+#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
@@ -2773,7 +2852,9 @@ parallel_set_op(_ExecutionPolicy&& __exe
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>
@@ -2888,6 +2969,7 @@ parallel_set_union_op(_ExecutionPolicy&&
__comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
__is_vector);
}
+#endif
//------------------------------------------------------------------------
// set_union
@@ -2922,6 +3004,7 @@ pattern_set_union(_ExecutionPolicy&&, _F
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
@@ -2946,6 +3029,7 @@ pattern_set_union(_ExecutionPolicy&& __e
},
__is_vector);
}
+#endif
//------------------------------------------------------------------------
// set_intersection
@@ -2980,6 +3064,7 @@ pattern_set_intersection(_ExecutionPolic
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
@@ -3041,6 +3126,7 @@ pattern_set_intersection(_ExecutionPolic
// [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
@@ -3075,6 +3161,7 @@ pattern_set_difference(_ExecutionPolicy&
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
@@ -3135,6 +3222,7 @@ pattern_set_difference(_ExecutionPolicy&
// use serial algorithm
return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
}
+#endif
//------------------------------------------------------------------------
// set_symmetric_difference
@@ -3170,6 +3258,7 @@ pattern_set_symmetric_difference(_Execut
__is_vector);
}
+#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
@@ -3194,6 +3283,7 @@ pattern_set_symmetric_difference(_Execut
},
__is_vector);
}
+#endif
//------------------------------------------------------------------------
// is_heap_until
@@ -3254,6 +3344,7 @@ is_heap_until_local(_RandomAccessIterato
[&__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,
@@ -3271,6 +3362,7 @@ pattern_is_heap_until(_ExecutionPolicy&&
std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
});
}
+#endif
//------------------------------------------------------------------------
// min_element
@@ -3304,6 +3396,7 @@ pattern_min_element(_ExecutionPolicy&&,
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,
@@ -3325,6 +3418,7 @@ pattern_min_element(_ExecutionPolicy&& _
});
});
}
+#endif
//------------------------------------------------------------------------
// minmax_element
@@ -3358,6 +3452,7 @@ pattern_minmax_element(_ExecutionPolicy&
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,
@@ -3384,6 +3479,7 @@ pattern_minmax_element(_ExecutionPolicy&
});
});
}
+#endif
//------------------------------------------------------------------------
// mismatch
@@ -3429,6 +3525,7 @@ pattern_mismatch(_ExecutionPolicy&&, _Fo
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>
@@ -3449,6 +3546,7 @@ pattern_mismatch(_ExecutionPolicy&& __ex
return std::make_pair(__result, __first2 + (__result - __first1));
});
}
+#endif
//------------------------------------------------------------------------
// lexicographical_compare
@@ -3507,6 +3605,7 @@ pattern_lexicographical_compare(_Executi
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,
@@ -3550,6 +3649,7 @@ pattern_lexicographical_compare(_Executi
}
}
}
+#endif
} // namespace internal
} // namespace __pstl
Modified: pstl/trunk/include/pstl/internal/numeric_impl.h
URL: http://llvm.org/viewvc/llvm-project/pstl/trunk/include/pstl/internal/numeric_impl.h?rev=350813&r1=350812&r2=350813&view=diff
==============================================================================
--- pstl/trunk/include/pstl/internal/numeric_impl.h (original)
+++ pstl/trunk/include/pstl/internal/numeric_impl.h Thu Jan 10 03:23:33 2019
@@ -64,6 +64,7 @@ pattern_transform_reduce(_ExecutionPolic
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
@@ -86,6 +87,7 @@ pattern_transform_reduce(_ExecutionPolic
});
});
}
+#endif
//------------------------------------------------------------------------
// transform_reduce (version with unary and binary functions)
@@ -124,6 +126,7 @@ pattern_transform_reduce(_ExecutionPolic
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
@@ -140,6 +143,7 @@ pattern_transform_reduce(_ExecutionPolic
});
});
}
+#endif
//------------------------------------------------------------------------
// transform_exclusive_scan
@@ -225,6 +229,7 @@ pattern_transform_scan(_ExecutionPolicy&
.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
@@ -253,7 +258,9 @@ pattern_transform_scan(_ExecutionPolicy&
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
@@ -289,6 +296,7 @@ pattern_transform_scan(_ExecutionPolicy&
return __result + (__last - __first);
});
}
+#endif
//------------------------------------------------------------------------
// adjacent_difference
@@ -329,6 +337,7 @@ pattern_adjacent_difference(_ExecutionPo
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
@@ -352,6 +361,7 @@ pattern_adjacent_difference(_ExecutionPo
});
return __d_first + (__last - __first);
}
+#endif
} // namespace internal
} // namespace __pstl
More information about the libcxx-commits
mailing list