RAJA
RAJA provides a collection of platform portability abstractions for C++ HPC applications.
sort.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_sort_HPP
21 #define RAJA_sort_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 Compare = operators::less<RAJA::detail::ContainerVal<Container>>>
56 concepts::enable_if_t<resources::EventProxy<Res>,
57  type_traits::is_execution_policy<ExecPolicy>,
58  type_traits::is_resource<Res>,
59  std::is_constructible<camp::resources::Resource, Res>,
60  type_traits::is_range<Container>>
61 sort(ExecPolicy&& p, Res r, Container&& c, Compare comp = Compare {})
62 {
63  using std::begin;
64  using std::distance;
65  using std::end;
66  using T = RAJA::detail::ContainerVal<Container>;
67  static_assert(type_traits::is_binary_function<Compare, bool, T, T>::value,
68  "Compare must model BinaryFunction");
69  static_assert(type_traits::is_random_access_range<Container>::value,
70  "Container must model RandomAccessRange");
71 
72  auto begin_it = begin(c);
73  auto end_it = end(c);
74  auto N = distance(begin_it, end_it);
75 
76  if (N > 1)
77  {
78  return impl::sort::unstable(r, std::forward<ExecPolicy>(p), begin_it,
79  end_it, comp);
80  }
81  else
82  {
83  return resources::EventProxy<Res>(r);
84  }
85 }
86 
88 template<
89  typename ExecPolicy,
90  typename Container,
91  typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>,
92  typename Res = typename resources::get_resource<ExecPolicy>::type>
93 concepts::enable_if_t<
94  resources::EventProxy<Res>,
95  type_traits::is_execution_policy<ExecPolicy>,
96  type_traits::is_range<Container>,
97  concepts::negate<
98  std::is_constructible<camp::resources::Resource, Container>>>
99 sort(ExecPolicy&& p, Container&& c, Compare comp = Compare {})
100 {
101  Res r = Res::get_default();
102  return ::RAJA::policy_by_value_interface::sort(
103  std::forward<ExecPolicy>(p), r, std::forward<Container>(c), comp);
104 }
105 
118 template<
119  typename ExecPolicy,
120  typename Res,
121  typename Container,
122  typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>>
123 concepts::enable_if_t<resources::EventProxy<Res>,
124  type_traits::is_execution_policy<ExecPolicy>,
125  type_traits::is_resource<Res>,
126  std::is_constructible<camp::resources::Resource, Res>,
127  type_traits::is_range<Container>>
128 stable_sort(ExecPolicy&& p, Res r, Container&& c, Compare comp = Compare {})
129 {
130  using std::begin;
131  using std::distance;
132  using std::end;
133  using T = RAJA::detail::ContainerVal<Container>;
134  static_assert(type_traits::is_binary_function<Compare, bool, T, T>::value,
135  "Compare must model BinaryFunction");
136  static_assert(type_traits::is_random_access_range<Container>::value,
137  "Container must model RandomAccessRange");
138 
139  auto begin_it = begin(c);
140  auto end_it = end(c);
141  auto N = distance(begin_it, end_it);
142 
143  if (N > 1)
144  {
145  return impl::sort::stable(r, std::forward<ExecPolicy>(p), begin_it, end_it,
146  comp);
147  }
148  else
149  {
150  return resources::EventProxy<Res>(r);
151  }
152 }
153 
155 template<
156  typename ExecPolicy,
157  typename Container,
158  typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>,
159  typename Res = typename resources::get_resource<ExecPolicy>::type>
160 concepts::enable_if_t<
161  resources::EventProxy<Res>,
162  type_traits::is_execution_policy<ExecPolicy>,
163  type_traits::is_range<Container>,
164  concepts::negate<
165  std::is_constructible<camp::resources::Resource, Container>>>
166 stable_sort(ExecPolicy&& p, Container&& c, Compare comp = Compare {})
167 {
168  Res r = Res::get_default();
169  return ::RAJA::policy_by_value_interface::stable_sort(
170  std::forward<ExecPolicy>(p), r, std::forward<Container>(c), comp);
171 }
172 
186 template<typename ExecPolicy,
187  typename Res,
188  typename KeyContainer,
189  typename ValContainer,
190  typename Compare =
191  operators::less<RAJA::detail::ContainerVal<KeyContainer>>>
192 concepts::enable_if_t<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<KeyContainer>,
197  type_traits::is_range<ValContainer>>
198 sort_pairs(ExecPolicy&& p,
199  Res r,
200  KeyContainer&& keys,
201  ValContainer&& vals,
202  Compare comp = Compare {})
203 {
204  using std::begin;
205  using std::distance;
206  using std::end;
207  using T = RAJA::detail::ContainerVal<KeyContainer>;
208  static_assert(type_traits::is_binary_function<Compare, bool, T, T>::value,
209  "Compare must model BinaryFunction");
210  static_assert(type_traits::is_random_access_range<KeyContainer>::value,
211  "KeyContainer must model RandomAccessRange");
212  static_assert(type_traits::is_random_access_range<ValContainer>::value,
213  "ValContainer must model RandomAccessRange");
214 
215  auto begin_key = begin(keys);
216  auto end_key = end(keys);
217  auto N = distance(begin_key, end_key);
218 
219  if (N > 1)
220  {
221  return impl::sort::unstable_pairs(r, std::forward<ExecPolicy>(p), begin_key,
222  end_key, begin(vals), comp);
223  }
224  else
225  {
226  return resources::EventProxy<Res>(r);
227  }
228 }
229 
231 template<typename ExecPolicy,
232  typename KeyContainer,
233  typename ValContainer,
234  typename Compare =
235  operators::less<RAJA::detail::ContainerVal<KeyContainer>>,
236  typename Res = typename resources::get_resource<ExecPolicy>::type>
237 concepts::enable_if_t<
238  resources::EventProxy<Res>,
239  type_traits::is_execution_policy<ExecPolicy>,
240  type_traits::is_range<KeyContainer>,
241  concepts::negate<
242  std::is_constructible<camp::resources::Resource, KeyContainer>>,
243  type_traits::is_range<ValContainer>>
244 sort_pairs(ExecPolicy&& p,
245  KeyContainer&& keys,
246  ValContainer&& vals,
247  Compare comp = Compare {})
248 {
249  Res r = Res::get_default();
250  return ::RAJA::policy_by_value_interface::sort_pairs(
251  std::forward<ExecPolicy>(p), r, std::forward<KeyContainer>(keys),
252  std::forward<ValContainer>(vals), comp);
253 }
254 
268 template<typename ExecPolicy,
269  typename Res,
270  typename KeyContainer,
271  typename ValContainer,
272  typename Compare =
273  operators::less<RAJA::detail::ContainerVal<KeyContainer>>>
274 concepts::enable_if_t<resources::EventProxy<Res>,
275  type_traits::is_execution_policy<ExecPolicy>,
276  type_traits::is_resource<Res>,
277  std::is_constructible<camp::resources::Resource, Res>,
278  type_traits::is_range<KeyContainer>,
279  type_traits::is_range<ValContainer>>
280 stable_sort_pairs(ExecPolicy&& p,
281  Res r,
282  KeyContainer&& keys,
283  ValContainer&& vals,
284  Compare comp = Compare {})
285 {
286  using std::begin;
287  using std::distance;
288  using std::end;
289  using T = RAJA::detail::ContainerVal<KeyContainer>;
290  static_assert(type_traits::is_binary_function<Compare, bool, T, T>::value,
291  "Compare must model BinaryFunction");
292  static_assert(type_traits::is_random_access_range<KeyContainer>::value,
293  "KeyContainer must model RandomAccessRange");
294  static_assert(type_traits::is_random_access_range<ValContainer>::value,
295  "ValContainer must model RandomAccessRange");
296 
297  auto begin_key = begin(keys);
298  auto end_key = end(keys);
299  auto N = distance(begin_key, end_key);
300 
301  if (N > 1)
302  {
303  return impl::sort::stable_pairs(r, std::forward<ExecPolicy>(p), begin_key,
304  end_key, begin(vals), comp);
305  }
306  else
307  {
308  return resources::EventProxy<Res>(r);
309  }
310 }
311 
313 template<typename ExecPolicy,
314  typename KeyContainer,
315  typename ValContainer,
316  typename Compare =
317  operators::less<RAJA::detail::ContainerVal<KeyContainer>>,
318  typename Res = typename resources::get_resource<ExecPolicy>::type>
319 concepts::enable_if_t<
320  resources::EventProxy<Res>,
321  type_traits::is_execution_policy<ExecPolicy>,
322  type_traits::is_range<KeyContainer>,
323  concepts::negate<
324  std::is_constructible<camp::resources::Resource, KeyContainer>>,
325  type_traits::is_range<ValContainer>>
326 stable_sort_pairs(ExecPolicy&& p,
327  KeyContainer&& keys,
328  ValContainer&& vals,
329  Compare comp = Compare {})
330 {
331  Res r = Res::get_default();
332  return ::RAJA::policy_by_value_interface::stable_sort_pairs(
333  std::forward<ExecPolicy>(p), r, std::forward<KeyContainer>(keys),
334  std::forward<ValContainer>(vals), comp);
335 }
336 
337 } // namespace policy_by_value_interface
338 
339 // =============================================================================
340 
347 template<typename ExecPolicy,
348  typename... Args,
349  typename Res = typename resources::get_resource<ExecPolicy>::type>
350 concepts::enable_if_t<resources::EventProxy<Res>,
351  type_traits::is_execution_policy<ExecPolicy>>
352 sort(Args&&... args)
353 {
354  Res r = Res::get_default();
355  return ::RAJA::policy_by_value_interface::sort<ExecPolicy>(
356  ExecPolicy(), r, std::forward<Args>(args)...);
357 }
358 
360 template<typename ExecPolicy, typename Res, typename... Args>
361 concepts::enable_if_t<resources::EventProxy<Res>,
362  type_traits::is_execution_policy<ExecPolicy>,
363  type_traits::is_resource<Res>>
364 sort(Res r, Args&&... args)
365 {
366  return ::RAJA::policy_by_value_interface::sort(ExecPolicy(), r,
367  std::forward<Args>(args)...);
368 }
369 
376 template<typename ExecPolicy,
377  typename... Args,
378  typename Res = typename resources::get_resource<ExecPolicy>::type>
379 concepts::enable_if_t<resources::EventProxy<Res>,
380  type_traits::is_execution_policy<ExecPolicy>>
381 stable_sort(Args&&... args)
382 {
383  Res r = Res::get_default();
384  return ::RAJA::policy_by_value_interface::stable_sort<ExecPolicy>(
385  ExecPolicy(), r, std::forward<Args>(args)...);
386 }
387 
389 template<typename ExecPolicy, typename Res, typename... Args>
390 concepts::enable_if_t<resources::EventProxy<Res>,
391  type_traits::is_execution_policy<ExecPolicy>,
392  type_traits::is_resource<Res>>
393 stable_sort(Res r, Args&&... args)
394 {
395  return ::RAJA::policy_by_value_interface::stable_sort(
396  ExecPolicy(), r, std::forward<Args>(args)...);
397 }
398 
405 template<typename ExecPolicy,
406  typename... Args,
407  typename Res = typename resources::get_resource<ExecPolicy>::type>
408 concepts::enable_if_t<resources::EventProxy<Res>,
409  type_traits::is_execution_policy<ExecPolicy>>
410 sort_pairs(Args&&... args)
411 {
412  Res r = Res::get_default();
413  return ::RAJA::policy_by_value_interface::sort_pairs<ExecPolicy>(
414  ExecPolicy(), r, std::forward<Args>(args)...);
415 }
416 
418 template<typename ExecPolicy, typename Res, typename... Args>
419 concepts::enable_if_t<resources::EventProxy<Res>,
420  type_traits::is_execution_policy<ExecPolicy>,
421  type_traits::is_resource<Res>>
422 sort_pairs(Res r, Args&&... args)
423 {
424  return ::RAJA::policy_by_value_interface::sort_pairs(
425  ExecPolicy(), r, std::forward<Args>(args)...);
426 }
427 
434 template<typename ExecPolicy,
435  typename... Args,
436  typename Res = typename resources::get_resource<ExecPolicy>::type>
437 concepts::enable_if_t<resources::EventProxy<Res>,
438  type_traits::is_execution_policy<ExecPolicy>>
439 stable_sort_pairs(Args&&... args)
440 {
441  Res r = Res::get_default();
442  return ::RAJA::policy_by_value_interface::stable_sort_pairs<ExecPolicy>(
443  ExecPolicy(), r, std::forward<Args>(args)...);
444 }
445 
447 template<typename ExecPolicy, typename Res, typename... Args>
448 concepts::enable_if_t<resources::EventProxy<Res>,
449  type_traits::is_execution_policy<ExecPolicy>,
450  type_traits::is_resource<Res>>
451 stable_sort_pairs(Res r, Args&&... args)
452 {
453  return ::RAJA::policy_by_value_interface::stable_sort_pairs(
454  ExecPolicy(), r, std::forward<Args>(args)...);
455 }
456 
457 } // namespace RAJA
458 
459 #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::sort::detail::openmp::sort
void sort(Sorter sorter, Iter begin, Iter end, Compare comp)
sort given range using sorter and comparison function
Definition: sort.hpp:155
RAJA::impl::sort::stable_pairs
concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< ExecPolicy > > stable_pairs(resources::Host host_res, const ExecPolicy &, KeyIter keys_begin, KeyIter keys_end, ValIter vals_begin, Compare comp)
Definition: sort.hpp:276
RAJA::impl::sort::stable
concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< ExecPolicy > > stable(resources::Host host_res, const ExecPolicy &, Iter begin, Iter end, Compare comp)
stable sort given range using comparison function
Definition: sort.hpp:230
RAJA::impl::sort::unstable
concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< ExecPolicy > > unstable(resources::Host host_res, const ExecPolicy &, Iter begin, Iter end, Compare comp)
sort given range using comparison function
Definition: sort.hpp:213
RAJA::impl::sort::unstable_pairs
concepts::enable_if_t< resources::EventProxy< resources::Host >, type_traits::is_openmp_policy< ExecPolicy > > unstable_pairs(resources::Host host_res, const ExecPolicy &, KeyIter keys_begin, KeyIter keys_end, ValIter vals_begin, Compare comp)
sort given range of pairs using comparison function on keys
Definition: sort.hpp:250
RAJA::policy_by_value_interface::stable_sort
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 > > stable_sort(ExecPolicy &&p, Res r, Container &&c, Compare comp=Compare {})
stable sort execution pattern
Definition: sort.hpp:128
RAJA::policy_by_value_interface::stable_sort_pairs
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< KeyContainer >, type_traits::is_range< ValContainer > > stable_sort_pairs(ExecPolicy &&p, Res r, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
stable sort pairs execution pattern
Definition: sort.hpp:280
RAJA::policy_by_value_interface::sort_pairs
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< KeyContainer >, type_traits::is_range< ValContainer > > sort_pairs(ExecPolicy &&p, Res r, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
sort pairs execution pattern
Definition: sort.hpp:198
RAJA::policy_by_value_interface::sort
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 > > sort(ExecPolicy &&p, Res r, Container &&c, Compare comp=Compare {})
sort execution pattern
Definition: sort.hpp:61
RAJA
Definition: AlignedRangeIndexSetBuilders.cpp:35
RAJA::stable_sort_pairs
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > stable_sort_pairs(Res r, Args &&... args)
Definition: sort.hpp:451
RAJA::sort_pairs
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > sort_pairs(Res r, Args &&... args)
Definition: sort.hpp:422
RAJA::stable_sort
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > > stable_sort(Res r, Args &&... args)
Definition: sort.hpp:393
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