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