RAJA
RAJA provides a collection of platform portability abstractions for C++ HPC applications.
scan.hpp
Go to the documentation of this file.
1 
11 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
12 // Copyright (c) Lawrence Livermore National Security, LLC and other
13 // RAJA Project Developers. See top-level LICENSE and COPYRIGHT
14 // files for dates and other details. No copyright assignment is required
15 // to contribute to RAJA.
16 //
17 // SPDX-License-Identifier: (BSD-3-Clause)
18 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
19 
20 #ifndef RAJA_scan_HPP
21 #define RAJA_scan_HPP
22 
23 #include "RAJA/config.hpp"
24 
25 #include <iterator>
26 #include <type_traits>
27 
28 #include "RAJA/policy/PolicyBase.hpp"
29 #include "RAJA/util/concepts.hpp"
30 #include "RAJA/util/Operators.hpp"
31 #include "RAJA/pattern/detail/algorithm.hpp"
32 
33 namespace RAJA
34 {
35 
36 inline namespace policy_by_value_interface
37 {
38 
51 template<
52  typename ExecPolicy,
53  typename Res,
54  typename Container,
55  typename Function = operators::plus<RAJA::detail::ContainerVal<Container>>>
56 RAJA_INLINE concepts::enable_if_t<
57  resources::EventProxy<Res>,
58  type_traits::is_execution_policy<ExecPolicy>,
59  type_traits::is_resource<Res>,
60  std::is_constructible<camp::resources::Resource, Res>,
61  type_traits::is_range<Container>>
62 inclusive_scan_inplace(ExecPolicy&& p,
63  Res r,
64  Container&& c,
65  Function binop = Function {})
66 {
67  using std::begin;
68  using std::end;
69  using R = RAJA::detail::ContainerVal<Container>;
70  static_assert(type_traits::is_binary_function<Function, R, R, R>::value,
71  "Function must model BinaryFunction");
72  static_assert(type_traits::is_random_access_range<Container>::value,
73  "Container must model RandomAccessRange");
74  if (begin(c) == end(c))
75  {
76  return resources::EventProxy<Res>(r);
77  }
78  return impl::scan::inclusive_inplace(r, std::forward<ExecPolicy>(p), begin(c),
79  end(c), binop);
80 }
81 
83 template<
84  typename ExecPolicy,
85  typename Container,
86  typename Function = operators::plus<RAJA::detail::ContainerVal<Container>>,
87  typename Res = typename resources::get_resource<ExecPolicy>::type>
88 RAJA_INLINE concepts::enable_if_t<
89  resources::EventProxy<Res>,
90  type_traits::is_execution_policy<ExecPolicy>,
91  type_traits::is_range<Container>,
92  concepts::negate<
93  std::is_constructible<camp::resources::Resource, Container>>>
94 inclusive_scan_inplace(ExecPolicy&& p,
95  Container&& c,
96  Function binop = Function {})
97 {
98  auto r = Res::get_default();
99  return ::RAJA::policy_by_value_interface::inclusive_scan_inplace(
100  std::forward<ExecPolicy>(p), r, std::forward<Container>(c), binop);
101 }
102 
115 template<typename ExecPolicy,
116  typename Res,
117  typename Container,
118  typename T = RAJA::detail::ContainerVal<Container>,
119  typename Function = operators::plus<T>>
120 RAJA_INLINE concepts::enable_if_t<
121  resources::EventProxy<Res>,
122  type_traits::is_execution_policy<ExecPolicy>,
123  type_traits::is_resource<Res>,
124  std::is_constructible<camp::resources::Resource, Res>,
125  type_traits::is_range<Container>>
126 exclusive_scan_inplace(ExecPolicy&& p,
127  Res r,
128  Container&& c,
129  Function binop = Function {},
130  T value = Function::identity())
131 {
132  using std::begin;
133  using std::end;
134  using R = RAJA::detail::ContainerVal<Container>;
135  static_assert(type_traits::is_binary_function<Function, R, T, R>::value,
136  "Function must model BinaryFunction");
137  static_assert(type_traits::is_random_access_range<Container>::value,
138  "Container must model RandomAccessRange");
139  if (begin(c) == end(c))
140  {
141  return resources::EventProxy<Res>(r);
142  }
143  return impl::scan::exclusive_inplace(r, std::forward<ExecPolicy>(p), begin(c),
144  end(c), binop, value);
145 }
146 
148 template<typename ExecPolicy,
149  typename Container,
150  typename T = RAJA::detail::ContainerVal<Container>,
151  typename Function = operators::plus<T>,
152  typename Res = typename resources::get_resource<ExecPolicy>::type>
153 RAJA_INLINE concepts::enable_if_t<
154  resources::EventProxy<Res>,
155  type_traits::is_execution_policy<ExecPolicy>,
156  type_traits::is_range<Container>,
157  concepts::negate<
158  std::is_constructible<camp::resources::Resource, Container>>>
159 exclusive_scan_inplace(ExecPolicy&& p,
160  Container&& c,
161  Function binop = Function {},
162  T value = Function::identity())
163 {
164  auto r = Res::get_default();
165  return ::RAJA::policy_by_value_interface::exclusive_scan_inplace(
166  std::forward<ExecPolicy>(p), r, std::forward<Container>(c), binop, value);
167 }
168 
185 template<typename ExecPolicy,
186  typename Res,
187  typename InContainer,
188  typename OutContainer,
189  typename Function =
190  operators::plus<RAJA::detail::ContainerVal<InContainer>>>
191 RAJA_INLINE concepts::enable_if_t<
192  resources::EventProxy<Res>,
193  type_traits::is_execution_policy<ExecPolicy>,
194  type_traits::is_resource<Res>,
195  std::is_constructible<camp::resources::Resource, Res>,
196  type_traits::is_range<InContainer>,
197  type_traits::is_range<OutContainer>>
198 inclusive_scan(ExecPolicy&& p,
199  Res r,
200  InContainer&& in,
201  OutContainer&& out,
202  Function binop = Function {})
203 {
204  using std::begin;
205  using std::end;
206  using T = RAJA::detail::ContainerVal<InContainer>;
207  using R = RAJA::detail::ContainerVal<OutContainer>;
208  static_assert(type_traits::is_binary_function<Function, R, T, R>::value,
209  "Function must model BinaryFunction");
210  static_assert(type_traits::is_random_access_range<InContainer>::value,
211  "InContainer must model RandomAccessRange");
212  static_assert(type_traits::is_random_access_range<OutContainer>::value,
213  "OutContainer must model RandomAccessRange");
214  if (begin(in) == end(in))
215  {
216  return resources::EventProxy<Res>(r);
217  }
218  return impl::scan::inclusive(r, std::forward<ExecPolicy>(p), begin(in),
219  end(in), begin(out), binop);
220 }
221 
223 template<typename ExecPolicy,
224  typename InContainer,
225  typename OutContainer,
226  typename Function =
227  operators::plus<RAJA::detail::ContainerVal<InContainer>>,
228  typename Res = typename resources::get_resource<ExecPolicy>::type>
229 RAJA_INLINE concepts::enable_if_t<
230  resources::EventProxy<Res>,
231  type_traits::is_execution_policy<ExecPolicy>,
232  type_traits::is_range<InContainer>,
233  concepts::negate<
234  std::is_constructible<camp::resources::Resource, InContainer>>,
235  type_traits::is_range<OutContainer>>
236 inclusive_scan(ExecPolicy&& p,
237  InContainer&& in,
238  OutContainer&& out,
239  Function binop = Function {})
240 {
241  auto r = Res::get_default();
242  return ::RAJA::policy_by_value_interface::inclusive_scan(
243  std::forward<ExecPolicy>(p), r, std::forward<InContainer>(in),
244  std::forward<OutContainer>(out), binop);
245 }
246 
263 template<typename ExecPolicy,
264  typename Res,
265  typename InContainer,
266  typename OutContainer,
267  typename T = RAJA::detail::ContainerVal<InContainer>,
268  typename Function = operators::plus<T>>
269 RAJA_INLINE concepts::enable_if_t<
270  resources::EventProxy<Res>,
271  type_traits::is_execution_policy<ExecPolicy>,
272  type_traits::is_resource<Res>,
273  std::is_constructible<camp::resources::Resource, Res>,
274  type_traits::is_range<InContainer>,
275  type_traits::is_range<OutContainer>>
276 exclusive_scan(ExecPolicy&& p,
277  Res r,
278  InContainer&& in,
279  OutContainer&& out,
280  Function binop = Function {},
281  T value = Function::identity())
282 {
283  using std::begin;
284  using std::end;
285  using U = RAJA::detail::ContainerVal<InContainer>;
286  using R = RAJA::detail::ContainerVal<OutContainer>;
287  static_assert(type_traits::is_binary_function<Function, R, T, U>::value,
288  "Function must model BinaryFunction");
289  static_assert(type_traits::is_random_access_range<InContainer>::value,
290  "InContainer must model RandomAccessRange");
291  static_assert(type_traits::is_random_access_range<OutContainer>::value,
292  "OutContainer must model RandomAccessRange");
293  if (begin(in) == end(in))
294  {
295  return resources::EventProxy<Res>(r);
296  }
297  return impl::scan::exclusive(r, std::forward<ExecPolicy>(p), begin(in),
298  end(in), begin(out), binop, value);
299 }
300 
302 template<typename ExecPolicy,
303  typename InContainer,
304  typename OutContainer,
305  typename T = RAJA::detail::ContainerVal<InContainer>,
306  typename Function = operators::plus<T>,
307  typename Res = typename resources::get_resource<ExecPolicy>::type>
308 RAJA_INLINE concepts::enable_if_t<
309  resources::EventProxy<Res>,
310  type_traits::is_execution_policy<ExecPolicy>,
311  type_traits::is_range<InContainer>,
312  concepts::negate<
313  std::is_constructible<camp::resources::Resource, InContainer>>,
314  type_traits::is_range<OutContainer>>
315 exclusive_scan(ExecPolicy&& p,
316  InContainer&& in,
317  OutContainer&& out,
318  Function binop = Function {},
319  T value = Function::identity())
320 {
321  auto r = Res::get_default();
322  return ::RAJA::policy_by_value_interface::exclusive_scan(
323  std::forward<ExecPolicy>(p), r, std::forward<InContainer>(in),
324  std::forward<OutContainer>(out), binop, value);
325 }
326 
327 } // namespace policy_by_value_interface
328 
335 template<typename ExecPolicy,
336  typename... Args,
337  typename Res = typename resources::get_resource<ExecPolicy>::type>
338 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
339  type_traits::is_execution_policy<ExecPolicy>>
340 exclusive_scan(Args&&... args)
341 {
342  Res r = Res::get_default();
343  return ::RAJA::policy_by_value_interface::exclusive_scan<ExecPolicy>(
344  ExecPolicy(), r, std::forward<Args>(args)...);
345 }
346 
348 template<typename ExecPolicy, typename Res, typename... Args>
349 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
350  type_traits::is_execution_policy<ExecPolicy>,
351  type_traits::is_resource<Res>>
352 exclusive_scan(Res r, Args&&... args)
353 {
354  return ::RAJA::policy_by_value_interface::exclusive_scan(
355  ExecPolicy(), r, std::forward<Args>(args)...);
356 }
357 
364 template<typename ExecPolicy,
365  typename... Args,
366  typename Res = typename resources::get_resource<ExecPolicy>::type>
367 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
368  type_traits::is_execution_policy<ExecPolicy>>
369 inclusive_scan(Args&&... args)
370 {
371  Res r = Res::get_default();
372  return ::RAJA::policy_by_value_interface::inclusive_scan<ExecPolicy>(
373  ExecPolicy(), r, std::forward<Args>(args)...);
374 }
375 
377 template<typename ExecPolicy, typename Res, typename... Args>
378 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
379  type_traits::is_execution_policy<ExecPolicy>,
380  type_traits::is_resource<Res>>
381 inclusive_scan(Res r, Args&&... args)
382 {
383  return ::RAJA::policy_by_value_interface::inclusive_scan(
384  ExecPolicy(), r, std::forward<Args>(args)...);
385 }
386 
393 template<typename ExecPolicy,
394  typename... Args,
395  typename Res = typename resources::get_resource<ExecPolicy>::type>
396 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
397  type_traits::is_execution_policy<ExecPolicy>>
398 exclusive_scan_inplace(Args&&... args)
399 {
400  Res r = Res::get_default();
401  return ::RAJA::policy_by_value_interface::exclusive_scan_inplace<ExecPolicy>(
402  ExecPolicy(), r, std::forward<Args>(args)...);
403 }
404 
406 template<typename ExecPolicy, typename Res, typename... Args>
407 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
408  type_traits::is_execution_policy<ExecPolicy>,
409  type_traits::is_resource<Res>>
410 exclusive_scan_inplace(Res r, Args&&... args)
411 {
412  return ::RAJA::policy_by_value_interface::exclusive_scan_inplace(
413  ExecPolicy(), r, std::forward<Args>(args)...);
414 }
415 
422 template<typename ExecPolicy,
423  typename... Args,
424  typename Res = typename resources::get_resource<ExecPolicy>::type>
425 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
426  type_traits::is_execution_policy<ExecPolicy>>
427 inclusive_scan_inplace(Args&&... args)
428 {
429  Res r = Res::get_default();
430  return ::RAJA::policy_by_value_interface::inclusive_scan_inplace<ExecPolicy>(
431  ExecPolicy(), r, std::forward<Args>(args)...);
432 }
433 
435 template<typename ExecPolicy, typename Res, typename... Args>
436 RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>,
437  type_traits::is_execution_policy<ExecPolicy>,
438  type_traits::is_resource<Res>>
439 inclusive_scan_inplace(Res r, Args&&... args)
440 {
441  return ::RAJA::policy_by_value_interface::inclusive_scan_inplace(
442  ExecPolicy(), r, std::forward<Args>(args)...);
443 }
444 
445 } // namespace RAJA
446 
447 #endif // closing endif for header file include guard
Operators.hpp
Header file for RAJA operator definitions.
PolicyBase.hpp
Header file for basic RAJA policy mechanics.
algorithm.hpp
Header file for RAJA algorithm definitions.
concepts.hpp
Header file for RAJA concept definitions.
RAJA::detail::ContainerVal
camp::decay< decltype(*camp::val< camp::iterator_from< Container > >())> ContainerVal
Definition: algorithm.hpp:51
RAJA::detail::args
Args args
Definition: WorkRunner.hpp:212
RAJA::impl::scan::inclusive
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< Policy > > inclusive(resources::Host host_res, const Policy &exec, Iter begin, Iter end, OutIter out, BinFn f)
Definition: scan.hpp:144
RAJA::impl::scan::exclusive
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< Policy > > exclusive(resources::Host host_res, const Policy &exec, Iter begin, Iter end, OutIter out, BinFn f, ValueT v)
Definition: scan.hpp:167
RAJA::impl::scan::inclusive_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< Policy > > inclusive_inplace(resources::Host host_res, const Policy &, Iter begin, Iter end, BinFn f)
Definition: scan.hpp:51
RAJA::impl::scan::exclusive_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< Policy > > exclusive_inplace(resources::Host host_res, const Policy &, Iter begin, Iter end, BinFn f, ValueT v)
Definition: scan.hpp:96
RAJA::policy_by_value_interface::inclusive_scan_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > > inclusive_scan_inplace(ExecPolicy &&p, Res r, Container &&c, Function binop=Function {})
inclusive in-place scan execution pattern
Definition: scan.hpp:62
RAJA::policy_by_value_interface::exclusive_scan
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< InContainer >, type_traits::is_range< OutContainer > > exclusive_scan(ExecPolicy &&p, Res r, InContainer &&in, OutContainer &&out, Function binop=Function {}, T value=Function::identity())
exclusive scan execution pattern
Definition: scan.hpp:276
RAJA::policy_by_value_interface::exclusive_scan_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > > exclusive_scan_inplace(ExecPolicy &&p, Res r, Container &&c, Function binop=Function {}, T value=Function::identity())
exclusive in-place scan execution pattern
Definition: scan.hpp:126
RAJA::policy_by_value_interface::inclusive_scan
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< InContainer >, type_traits::is_range< OutContainer > > inclusive_scan(ExecPolicy &&p, Res r, InContainer &&in, OutContainer &&out, Function binop=Function {})
inclusive scan execution pattern
Definition: scan.hpp:198
RAJA
Definition: AlignedRangeIndexSetBuilders.cpp:35
RAJA::inclusive_scan
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > inclusive_scan(Res r, Args &&... args)
Definition: scan.hpp:381
RAJA::exclusive_scan_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > exclusive_scan_inplace(Res r, Args &&... args)
Definition: scan.hpp:410
RAJA::exclusive_scan
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > exclusive_scan(Res r, Args &&... args)
Definition: scan.hpp:352
RAJA::inclusive_scan_inplace
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > inclusive_scan_inplace(Res r, Args &&... args)
Definition: scan.hpp:439
RAJA::policy::indexset::ExecPolicy
Definition: IndexSet.hpp:70
RAJA::resources::get_resource::type
camp::resources::Host type
Definition: resource.hpp:49
Generated by doxygen 1.9.1