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>
__lazy_and(_Tp,std::false_type)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
__lazy_and(_Tp __a,std::true_type)35 __lazy_and(_Tp __a, std::true_type)
36 {
37 return __a;
38 }
39
40 template <typename _Tp>
__lazy_or(_Tp,std::true_type)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
__lazy_or(_Tp __a,std::false_type)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 = __internal::__is_random_access_iterator<_IteratorType>::value &&
58 __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 template <>
91 struct __policy_traits<parallel_policy>
92 {
93 typedef std::true_type allow_parallel;
94 typedef std::false_type allow_unsequenced;
95 typedef std::false_type allow_vector;
96 };
97
98 template <>
99 struct __policy_traits<parallel_unsequenced_policy>
100 {
101 typedef std::true_type allow_parallel;
102 typedef std::true_type allow_unsequenced;
103 typedef std::true_type allow_vector;
104 };
105
106 template <typename _ExecutionPolicy>
107 using __collector_t =
108 typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__collector_type;
109
110 template <typename _ExecutionPolicy>
111 using __allow_vector =
112 typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_vector;
113
114 template <typename _ExecutionPolicy>
115 using __allow_unsequenced =
116 typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_unsequenced;
117
118 template <typename _ExecutionPolicy>
119 using __allow_parallel =
120 typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_parallel;
121
122 template <typename _ExecutionPolicy, typename... _IteratorTypes>
123 auto
124 __is_vectorization_preferred(_ExecutionPolicy&& __exec)
125 -> decltype(__internal::__lazy_and(__exec.__allow_vector(),
126 typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()))
127 {
128 return __internal::__lazy_and(__exec.__allow_vector(),
129 typename __internal::__is_random_access_iterator<_IteratorTypes...>::type());
130 }
131
132 template <typename _ExecutionPolicy, typename... _IteratorTypes>
133 auto
134 __is_parallelization_preferred(_ExecutionPolicy&& __exec)
135 -> decltype(__internal::__lazy_and(__exec.__allow_parallel(),
136 typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()))
137 {
138 return __internal::__lazy_and(__exec.__allow_parallel(),
139 typename __internal::__is_random_access_iterator<_IteratorTypes...>::type());
140 }
141
142 template <typename policy, typename... _IteratorTypes>
143 struct __prefer_unsequenced_tag
144 {
145 static constexpr bool value = __internal::__allow_unsequenced<policy>::value &&
146 __internal::__is_random_access_iterator<_IteratorTypes...>::value;
147 typedef std::integral_constant<bool, value> type;
148 };
149
150 template <typename policy, typename... _IteratorTypes>
151 struct __prefer_parallel_tag
152 {
153 static constexpr bool value = __internal::__allow_parallel<policy>::value &&
154 __internal::__is_random_access_iterator<_IteratorTypes...>::value;
155 typedef std::integral_constant<bool, value> type;
156 };
157
158 } // namespace __internal
159 } // namespace __pstl
160
161 #endif /* _PSTL_EXECUTION_IMPL_H */
162