1 // -*- C++ -*-
2 //===-- execution_defs.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_policy_defs_H
11 #define __PSTL_execution_policy_defs_H
12 
13 #include <type_traits>
14 
15 namespace __pstl
16 {
17 namespace execution
18 {
19 inline namespace v1
20 {
21 
22 // 2.4, Sequential execution policy
23 class sequenced_policy
24 {
25   public:
26     // For internal use only
27     static constexpr std::false_type
__allow_unsequenced()28     __allow_unsequenced()
29     {
30         return std::false_type{};
31     }
32     static constexpr std::false_type
__allow_vector()33     __allow_vector()
34     {
35         return std::false_type{};
36     }
37     static constexpr std::false_type
__allow_parallel()38     __allow_parallel()
39     {
40         return std::false_type{};
41     }
42 };
43 
44 #if __PSTL_USE_PAR_POLICIES
45 // 2.5, Parallel execution policy
46 class parallel_policy
47 {
48   public:
49     // For internal use only
50     static constexpr std::false_type
__allow_unsequenced()51     __allow_unsequenced()
52     {
53         return std::false_type{};
54     }
55     static constexpr std::false_type
__allow_vector()56     __allow_vector()
57     {
58         return std::false_type{};
59     }
60     static constexpr std::true_type
__allow_parallel()61     __allow_parallel()
62     {
63         return std::true_type{};
64     }
65 };
66 
67 // 2.6, Parallel+Vector execution policy
68 class parallel_unsequenced_policy
69 {
70   public:
71     // For internal use only
72     static constexpr std::true_type
__allow_unsequenced()73     __allow_unsequenced()
74     {
75         return std::true_type{};
76     }
77     static constexpr std::true_type
__allow_vector()78     __allow_vector()
79     {
80         return std::true_type{};
81     }
82     static constexpr std::true_type
__allow_parallel()83     __allow_parallel()
84     {
85         return std::true_type{};
86     }
87 };
88 #endif
89 
90 class unsequenced_policy
91 {
92   public:
93     // For internal use only
94     static constexpr std::true_type
__allow_unsequenced()95     __allow_unsequenced()
96     {
97         return std::true_type{};
98     }
99     static constexpr std::true_type
__allow_vector()100     __allow_vector()
101     {
102         return std::true_type{};
103     }
104     static constexpr std::false_type
__allow_parallel()105     __allow_parallel()
106     {
107         return std::false_type{};
108     }
109 };
110 
111 // 2.8, Execution policy objects
112 constexpr sequenced_policy seq{};
113 #if __PSTL_USE_PAR_POLICIES
114 constexpr parallel_policy par{};
115 constexpr parallel_unsequenced_policy par_unseq{};
116 #endif
117 constexpr unsequenced_policy unseq{};
118 
119 // 2.3, Execution policy type trait
120 template <class _Tp>
121 struct is_execution_policy : std::false_type
122 {
123 };
124 
125 template <>
126 struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
127 {
128 };
129 #if __PSTL_USE_PAR_POLICIES
130 template <>
131 struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
132 {
133 };
134 template <>
135 struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
136 {
137 };
138 #endif
139 template <>
140 struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
141 {
142 };
143 
144 #if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
145 template <class _Tp>
146 constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
147 #endif
148 
149 } // namespace v1
150 } // namespace execution
151 
152 namespace __internal
153 {
154 template <class _ExecPolicy, class _Tp>
155 using __enable_if_execution_policy =
156     typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<_ExecPolicy>::type>::value,
157                             _Tp>::type;
158 } // namespace __internal
159 
160 } // namespace __pstl
161 
162 #endif /* __PSTL_execution_policy_defs_H */
163