1 // -*- C++ -*- 2 //===-- execution_impl.h --------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef __PSTL_execution_impl_H 11 #define __PSTL_execution_impl_H 12 13 #include <iterator> 14 #include <type_traits> 15 16 #include "execution_defs.h" 17 18 namespace __pstl 19 { 20 namespace __internal 21 { 22 23 using namespace __pstl::execution; 24 25 /* predicate */ 26 27 template <typename _Tp> 28 std::false_type __lazy_and(_Tp, std::false_type) 29 { 30 return std::false_type{}; 31 }; 32 33 template <typename _Tp> 34 inline _Tp 35 __lazy_and(_Tp __a, std::true_type) 36 { 37 return __a; 38 } 39 40 template <typename _Tp> 41 std::true_type __lazy_or(_Tp, std::true_type) 42 { 43 return std::true_type{}; 44 }; 45 46 template <typename _Tp> 47 inline _Tp 48 __lazy_or(_Tp __a, std::false_type) 49 { 50 return __a; 51 } 52 53 /* iterator */ 54 template <typename _IteratorType, typename... _OtherIteratorTypes> 55 struct __is_random_access_iterator 56 { 57 static constexpr bool value = 58 __internal::__is_random_access_iterator<_IteratorType>::value && __internal::__is_random_access_iterator<_OtherIteratorTypes...>::value; 59 typedef std::integral_constant<bool, value> type; 60 }; 61 62 template <typename _IteratorType> 63 struct __is_random_access_iterator<_IteratorType> 64 : std::is_same<typename std::iterator_traits<_IteratorType>::iterator_category, std::random_access_iterator_tag> 65 { 66 }; 67 68 /* policy */ 69 template <typename _Policy> 70 struct __policy_traits 71 { 72 }; 73 74 template <> 75 struct __policy_traits<sequenced_policy> 76 { 77 typedef std::false_type allow_parallel; 78 typedef std::false_type allow_unsequenced; 79 typedef std::false_type allow_vector; 80 }; 81 82 template <> 83 struct __policy_traits<unsequenced_policy> 84 { 85 typedef std::false_type allow_parallel; 86 typedef std::true_type allow_unsequenced; 87 typedef std::true_type allow_vector; 88 }; 89 90 #if __PSTL_USE_PAR_POLICIES 91 template <> 92 struct __policy_traits<parallel_policy> 93 { 94 typedef std::true_type allow_parallel; 95 typedef std::false_type allow_unsequenced; 96 typedef std::false_type allow_vector; 97 }; 98 99 template <> 100 struct __policy_traits<parallel_unsequenced_policy> 101 { 102 typedef std::true_type allow_parallel; 103 typedef std::true_type allow_unsequenced; 104 typedef std::true_type allow_vector; 105 }; 106 #endif 107 108 template <typename _ExecutionPolicy> 109 using __collector_t = typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__collector_type; 110 111 template <typename _ExecutionPolicy> 112 using __allow_vector = typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_vector; 113 114 template <typename _ExecutionPolicy> 115 using __allow_unsequenced = typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_unsequenced; 116 117 template <typename _ExecutionPolicy> 118 using __allow_parallel = typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_parallel; 119 120 template <typename _ExecutionPolicy, typename... _IteratorTypes> 121 auto 122 __is_vectorization_preferred(_ExecutionPolicy&& __exec) 123 -> decltype(__internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) 124 { 125 return __internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); 126 } 127 128 template <typename _ExecutionPolicy, typename... _IteratorTypes> 129 auto 130 __is_parallelization_preferred(_ExecutionPolicy&& __exec) 131 -> decltype(__internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) 132 { 133 return __internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); 134 } 135 136 template <typename policy, typename... _IteratorTypes> 137 struct __prefer_unsequenced_tag 138 { 139 static constexpr bool value = 140 __internal::__allow_unsequenced<policy>::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; 141 typedef std::integral_constant<bool, value> type; 142 }; 143 144 template <typename policy, typename... _IteratorTypes> 145 struct __prefer_parallel_tag 146 { 147 static constexpr bool value = 148 __internal::__allow_parallel<policy>::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; 149 typedef std::integral_constant<bool, value> type; 150 }; 151 152 } // namespace __internal 153 } // namespace __pstl 154 155 #endif /* __PSTL_execution_impl_H */ 156