master
1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___PSTL_BACKEND_FWD_H
10#define _LIBCPP___PSTL_BACKEND_FWD_H
11
12#include <__config>
13
14#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15# pragma GCC system_header
16#endif
17
18_LIBCPP_PUSH_MACROS
19#include <__undef_macros>
20
21//
22// This header declares available PSTL backends and the functions that must be implemented in order for the
23// PSTL algorithms to be provided.
24//
25// Backends often do not implement the full set of functions themselves -- a configuration of the PSTL is
26// usually a set of backends "stacked" together which each implement some algorithms under some execution
27// policies. It is only necessary for the "stack" of backends to implement all algorithms under all execution
28// policies, but a single backend is not required to implement everything on its own.
29//
30// The signatures used by each backend function are documented below.
31//
32// Exception handling
33// ==================
34//
35// PSTL backends are expected to report errors (i.e. failure to allocate) by returning a disengaged `optional` from
36// their implementation. Exceptions shouldn't be used to report an internal failure-to-allocate, since all exceptions
37// are turned into a program termination at the front-end level. When a backend returns a disengaged `optional` to the
38// frontend, the frontend will turn that into a call to `std::__throw_bad_alloc();` to report the internal failure to
39// the user.
40//
41
42#if _LIBCPP_STD_VER >= 17
43
44_LIBCPP_BEGIN_NAMESPACE_STD
45namespace __pstl {
46
47template <class... _Backends>
48struct __backend_configuration;
49
50struct __default_backend_tag;
51struct __libdispatch_backend_tag;
52struct __serial_backend_tag;
53struct __std_thread_backend_tag;
54
55# if defined(_LIBCPP_PSTL_BACKEND_SERIAL)
56using __current_configuration _LIBCPP_NODEBUG = __backend_configuration<__serial_backend_tag, __default_backend_tag>;
57# elif defined(_LIBCPP_PSTL_BACKEND_STD_THREAD)
58using __current_configuration _LIBCPP_NODEBUG =
59 __backend_configuration<__std_thread_backend_tag, __default_backend_tag>;
60# elif defined(_LIBCPP_PSTL_BACKEND_LIBDISPATCH)
61using __current_configuration _LIBCPP_NODEBUG =
62 __backend_configuration<__libdispatch_backend_tag, __default_backend_tag>;
63# else
64
65// ...New vendors can add parallel backends here...
66
67# error "Invalid PSTL backend configuration"
68# endif
69
70template <class _Backend, class _ExecutionPolicy>
71struct __find_if;
72// template <class _Policy, class _ForwardIterator, class _Predicate>
73// optional<_ForwardIterator>
74// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
75
76template <class _Backend, class _ExecutionPolicy>
77struct __find_if_not;
78// template <class _Policy, class _ForwardIterator, class _Predicate>
79// optional<_ForwardIterator>
80// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
81
82template <class _Backend, class _ExecutionPolicy>
83struct __find;
84// template <class _Policy, class _ForwardIterator, class _Tp>
85// optional<_ForwardIterator>
86// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept;
87
88template <class _Backend, class _ExecutionPolicy>
89struct __any_of;
90// template <class _Policy, class _ForwardIterator, class _Predicate>
91// optional<bool>
92// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
93
94template <class _Backend, class _ExecutionPolicy>
95struct __all_of;
96// template <class _Policy, class _ForwardIterator, class _Predicate>
97// optional<bool>
98// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
99
100template <class _Backend, class _ExecutionPolicy>
101struct __none_of;
102// template <class _Policy, class _ForwardIterator, class _Predicate>
103// optional<bool>
104// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
105
106template <class _Backend, class _ExecutionPolicy>
107struct __is_partitioned;
108// template <class _Policy, class _ForwardIterator, class _Predicate>
109// optional<bool>
110// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
111
112template <class _Backend, class _ExecutionPolicy>
113struct __for_each;
114// template <class _Policy, class _ForwardIterator, class _Function>
115// optional<__empty>
116// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __func) const noexcept;
117
118template <class _Backend, class _ExecutionPolicy>
119struct __for_each_n;
120// template <class _Policy, class _ForwardIterator, class _Size, class _Function>
121// optional<__empty>
122// operator()(_Policy&&, _ForwardIterator __first, _Size __size, _Function __func) const noexcept;
123
124template <class _Backend, class _ExecutionPolicy>
125struct __fill;
126// template <class _Policy, class _ForwardIterator, class _Tp>
127// optional<__empty>
128// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
129
130template <class _Backend, class _ExecutionPolicy>
131struct __fill_n;
132// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
133// optional<__empty>
134// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Tp const& __value) const noexcept;
135
136template <class _Backend, class _ExecutionPolicy>
137struct __replace;
138// template <class _Policy, class _ForwardIterator, class _Tp>
139// optional<__empty>
140// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
141// _Tp const& __old, _Tp const& __new) const noexcept;
142
143template <class _Backend, class _ExecutionPolicy>
144struct __replace_if;
145// template <class _Policy, class _ForwardIterator, class _Predicate, class _Tp>
146// optional<__empty>
147// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
148// _Predicate __pred, _Tp const& __new_value) const noexcept;
149
150template <class _Backend, class _ExecutionPolicy>
151struct __generate;
152// template <class _Policy, class _ForwardIterator, class _Generator>
153// optional<__empty>
154// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) const noexcept;
155
156template <class _Backend, class _ExecutionPolicy>
157struct __generate_n;
158// template <class _Policy, class _ForwardIterator, class _Size, class _Generator>
159// optional<__empty>
160// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Generator __gen) const noexcept;
161
162template <class _Backend, class _ExecutionPolicy>
163struct __merge;
164// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
165// optional<_ForwardOutIterator>
166// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
167// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
168// _ForwardOutIterator __result, _Comp __comp) const noexcept;
169
170template <class _Backend, class _ExecutionPolicy>
171struct __stable_sort;
172// template <class _Policy, class _RandomAccessIterator, class _Comp>
173// optional<__empty>
174// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
175
176template <class _Backend, class _ExecutionPolicy>
177struct __sort;
178// template <class _Policy, class _RandomAccessIterator, class _Comp>
179// optional<__empty>
180// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
181
182template <class _Backend, class _ExecutionPolicy>
183struct __transform;
184// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
185// optional<_ForwardOutIterator>
186// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
187// _ForwardOutIterator __result,
188// _UnaryOperation __op) const noexcept;
189
190template <class _Backend, class _ExecutionPolicy>
191struct __transform_binary;
192// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
193// class _ForwardOutIterator,
194// class _BinaryOperation>
195// optional<_ForwardOutIterator>
196// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
197// _ForwardIterator2 __first2,
198// _ForwardOutIterator __result,
199// _BinaryOperation __op) const noexcept;
200
201template <class _Backend, class _ExecutionPolicy>
202struct __replace_copy_if;
203// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Predicate, class _Tp>
204// optional<__empty>
205// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
206// _ForwardOutIterator __out_it,
207// _Predicate __pred,
208// _Tp const& __new_value) const noexcept;
209
210template <class _Backend, class _ExecutionPolicy>
211struct __replace_copy;
212// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Tp>
213// optional<__empty>
214// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
215// _ForwardOutIterator __out_it,
216// _Tp const& __old_value,
217// _Tp const& __new_value) const noexcept;
218
219template <class _Backend, class _ExecutionPolicy>
220struct __move;
221// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
222// optional<_ForwardOutIterator>
223// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
224// _ForwardOutIterator __out_it) const noexcept;
225
226template <class _Backend, class _ExecutionPolicy>
227struct __copy;
228// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
229// optional<_ForwardOutIterator>
230// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
231// _ForwardOutIterator __out_it) const noexcept;
232
233template <class _Backend, class _ExecutionPolicy>
234struct __copy_n;
235// template <class _Policy, class _ForwardIterator, class _Size, class _ForwardOutIterator>
236// optional<_ForwardOutIterator>
237// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _ForwardOutIterator __out_it) const noexcept;
238
239template <class _Backend, class _ExecutionPolicy>
240struct __rotate_copy;
241// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
242// optional<_ForwardOutIterator>
243// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
244// _ForwardOutIterator __out_it) const noexcept;
245
246template <class _Backend, class _ExecutionPolicy>
247struct __transform_reduce;
248// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
249// optional<_Tp>
250// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
251// _Tp __init,
252// _BinaryOperation __reduce,
253// _UnaryOperation __transform) const noexcept;
254
255template <class _Backend, class _ExecutionPolicy>
256struct __transform_reduce_binary;
257// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
258// class _Tp, class _BinaryOperation1, class _BinaryOperation2>
259// optional<_Tp> operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
260// _ForwardIterator2 __first2,
261// _Tp __init,
262// _BinaryOperation1 __reduce,
263// _BinaryOperation2 __transform) const noexcept;
264
265template <class _Backend, class _ExecutionPolicy>
266struct __count_if;
267// template <class _Policy, class _ForwardIterator, class _Predicate>
268// optional<__iter_diff_t<_ForwardIterator>>
269// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
270
271template <class _Backend, class _ExecutionPolicy>
272struct __count;
273// template <class _Policy, class _ForwardIterator, class _Tp>
274// optional<__iter_diff_t<_ForwardIterator>>
275// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
276
277template <class _Backend, class _ExecutionPolicy>
278struct __equal_3leg;
279// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
280// optional<bool>
281// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
282// _ForwardIterator2 __first2,
283// _Predicate __pred) const noexcept;
284
285template <class _Backend, class _ExecutionPolicy>
286struct __equal;
287// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
288// optional<bool>
289// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
290// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
291// _Predicate __pred) const noexcept;
292
293template <class _Backend, class _ExecutionPolicy>
294struct __reduce;
295// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation>
296// optional<_Tp>
297// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
298// _Tp __init, _BinaryOperation __op) const noexcept;
299
300} // namespace __pstl
301_LIBCPP_END_NAMESPACE_STD
302
303#endif // _LIBCPP_STD_VER >= 17
304
305_LIBCPP_POP_MACROS
306
307#endif // _LIBCPP___PSTL_BACKEND_FWD_H