1 // -*- C++ -*-
2 // { dg-options "-ltbb" }
3 // { dg-do run { target c++17 } }
4 // { dg-timeout-factor 3 }
5 // { dg-require-effective-target tbb-backend }
6 
7 //===-- nth_element.pass.cpp ----------------------------------------------===//
8 //
9 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
10 // See https://llvm.org/LICENSE.txt for license information.
11 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "pstl/pstl_test_config.h"
16 
17 #ifdef PSTL_STANDALONE_TESTS
18 #include <algorithm>
19 #include <iostream>
20 #include "pstl/execution"
21 #include "pstl/algorithm"
22 
23 #else
24 #include <execution>
25 #include <algorithm>
26 #endif // PSTL_STANDALONE_TESTS
27 
28 #include "pstl/test_utils.h"
29 
30 using namespace TestUtils;
31 
32 // User defined type with minimal requirements
33 template <typename T>
34 struct DataType
35 {
DataTypeDataType36     explicit DataType(int32_t k) : my_val(k) {}
DataTypeDataType37     DataType(DataType&& input)
38     {
39         my_val = std::move(input.my_val);
40         input.my_val = T(0);
41     }
42     DataType&
operator =DataType43     operator=(DataType&& input)
44     {
45         my_val = std::move(input.my_val);
46         input.my_val = T(0);
47         return *this;
48     }
49     T
get_valDataType50     get_val() const
51     {
52         return my_val;
53     }
54 
55     friend std::ostream&
operator <<(std::ostream & stream,const DataType<T> & input)56     operator<<(std::ostream& stream, const DataType<T>& input)
57     {
58         return stream << input.my_val;
59     }
60 
61   private:
62     T my_val;
63 };
64 
65 template <typename T>
66 bool
is_equal(const DataType<T> & x,const DataType<T> & y)67 is_equal(const DataType<T>& x, const DataType<T>& y)
68 {
69     return x.get_val() == y.get_val();
70 }
71 
72 template <typename T>
73 bool
is_equal(const T & x,const T & y)74 is_equal(const T& x, const T& y)
75 {
76     return x == y;
77 }
78 
79 struct test_one_policy
80 {
81 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
82     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
83     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
84     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator ()test_one_policy85     operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
86                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
87     {
88     }
89     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
90     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator ()test_one_policy91     operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
92                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
93     {
94     }
95 #endif
96 
97     // nth_element works only with random access iterators
98     template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
99               typename Compare>
100     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator ()test_one_policy101     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m,
102                Generator1 generator1, Generator2 generator2, Compare comp)
103     {
104 
105         using T = typename std::iterator_traits<Iterator1>::value_type;
106         const Iterator1 mid1 = std::next(first1, m);
107         const Iterator1 mid2 = std::next(first2, m);
108 
109         fill_data(first1, mid1, generator1);
110         fill_data(mid1, last1, generator2);
111         fill_data(first2, mid2, generator1);
112         fill_data(mid2, last2, generator2);
113         std::nth_element(first1, mid1, last1, comp);
114         std::nth_element(exec, first2, mid2, last2, comp);
115         if (m > 0 && m < n)
116         {
117             EXPECT_TRUE(is_equal(*mid1, *mid2), "wrong result from nth_element with predicate");
118         }
119         EXPECT_TRUE(std::find_first_of(first2, mid2, mid2, last2, [comp](T& x, T& y) { return comp(y, x); }) == mid2,
120                     "wrong effect from nth_element with predicate");
121     }
122 
123     template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
124               typename Compare>
125     typename std::enable_if<!is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
operator ()test_one_policy126     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m,
127                Generator1 generator1, Generator2 generator2, Compare comp)
128     {
129     }
130 };
131 
132 template <typename T, typename Generator1, typename Generator2, typename Compare>
133 void
test_by_type(Generator1 generator1,Generator2 generator2,Compare comp)134 test_by_type(Generator1 generator1, Generator2 generator2, Compare comp)
135 {
136     using namespace std;
137     size_t max_size = 10000;
138     Sequence<T> in1(max_size, [](size_t v) { return T(v); });
139     Sequence<T> exp(max_size, [](size_t v) { return T(v); });
140     size_t m;
141 
142     for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
143     {
144         m = 0;
145         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
146                                generator1, generator2, comp);
147         m = n / 7;
148         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
149                                generator1, generator2, comp);
150         m = 3 * n / 5;
151         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
152                                generator1, generator2, comp);
153     }
154     invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + max_size, in1.begin(), in1.begin() + max_size,
155                            max_size, max_size, generator1, generator2, comp);
156 }
157 
158 template <typename T>
159 struct test_non_const
160 {
161     template <typename Policy, typename Iterator>
162     void
operator ()test_non_const163     operator()(Policy&& exec, Iterator iter)
164     {
165         invoke_if(exec, [&]() { nth_element(exec, iter, iter, iter, non_const(std::less<T>())); });
166     }
167 };
168 
169 int32_t
main()170 main()
171 {
172     test_by_type<int32_t>([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less<int32_t>());
173     test_by_type<int32_t>([](int32_t) { return 0; }, [](int32_t) { return 0; }, std::less<int32_t>());
174 
175     test_by_type<float64_t>([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); },
176                             [](const float64_t x, const float64_t y) { return x > y; });
177 
178     test_by_type<DataType<float32_t>>(
179         [](int32_t i) { return DataType<float32_t>(2 * i + 1); }, [](int32_t i) { return DataType<float32_t>(2 * i); },
180         [](const DataType<float32_t>& x, const DataType<float32_t>& y) { return x.get_val() < y.get_val(); });
181 
182     test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
183 
184     std::cout << done() << std::endl;
185     return 0;
186 }
187