Initial PSTL commit
[lldb.git] / pstl / test / test_nth_element.cpp
1 // -*- C++ -*-
2 //===-- test_nth_element.cpp ----------------------------------------------===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 #include "pstl_test_config.h"
12
13 #include <algorithm>
14 #include <iostream>
15 #include "pstl/execution"
16 #include "pstl/algorithm"
17
18 #include "utils.h"
19
20 using namespace TestUtils;
21
22 // User defined type with minimal requirements
23 template <typename T>
24 struct DataType
25 {
26     explicit DataType(int32_t k) : my_val(k) {}
27     DataType(DataType&& input)
28     {
29         my_val = std::move(input.my_val);
30         input.my_val = T(0);
31     }
32     DataType&
33     operator=(DataType&& input)
34     {
35         my_val = std::move(input.my_val);
36         input.my_val = T(0);
37         return *this;
38     }
39     T
40     get_val() const
41     {
42         return my_val;
43     }
44
45     friend std::ostream&
46     operator<<(std::ostream& stream, const DataType<T>& input)
47     {
48         return stream << input.my_val;
49     }
50
51   private:
52     T my_val;
53 };
54
55 template <typename T>
56 bool
57 is_equal(const DataType<T>& x, const DataType<T>& y)
58 {
59     return x.get_val() == y.get_val();
60 }
61
62 template <typename T>
63 bool
64 is_equal(const T& x, const T& y)
65 {
66     return x == y;
67 }
68
69 struct test_one_policy
70 {
71 #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
72     __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
73     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
74     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
75     operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
76                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
77     {
78     }
79     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
80     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
81     operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
82                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
83     {
84     }
85 #endif
86
87     // nth_element works only with random access iterators
88     template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
89               typename Compare>
90     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
91     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m,
92                Generator1 generator1, Generator2 generator2, Compare comp)
93     {
94
95         using T = typename std::iterator_traits<Iterator1>::value_type;
96         const Iterator1 mid1 = std::next(first1, m);
97         const Iterator1 mid2 = std::next(first2, m);
98
99         fill_data(first1, mid1, generator1);
100         fill_data(mid1, last1, generator2);
101         fill_data(first2, mid2, generator1);
102         fill_data(mid2, last2, generator2);
103         std::nth_element(first1, mid1, last1, comp);
104         std::nth_element(exec, first2, mid2, last2, comp);
105         if (m > 0 && m < n)
106         {
107             EXPECT_TRUE(is_equal(*mid1, *mid2), "wrong result from nth_element with predicate");
108         }
109         EXPECT_TRUE(std::find_first_of(first2, mid2, mid2, last2, [comp](T& x, T& y) { return comp(y, x); }) == mid2,
110                     "wrong effect from nth_element with predicate");
111     }
112
113     template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
114               typename Compare>
115     typename std::enable_if<!is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
116     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator1 first2, Iterator1 last2, Size n, Size m,
117                Generator1 generator1, Generator2 generator2, Compare comp)
118     {
119     }
120 };
121
122 template <typename T, typename Generator1, typename Generator2, typename Compare>
123 void
124 test_by_type(Generator1 generator1, Generator2 generator2, Compare comp)
125 {
126     using namespace std;
127     size_t max_size = 10000;
128     Sequence<T> in1(max_size, [](size_t v) { return T(v); });
129     Sequence<T> exp(max_size, [](size_t v) { return T(v); });
130     size_t m;
131
132     for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
133     {
134         m = 0;
135         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
136                                generator1, generator2, comp);
137         m = n / 7;
138         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
139                                generator1, generator2, comp);
140         m = 3 * n / 5;
141         invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + n, in1.begin(), in1.begin() + n, n, m,
142                                generator1, generator2, comp);
143     }
144     invoke_on_all_policies(test_one_policy(), exp.begin(), exp.begin() + max_size, in1.begin(), in1.begin() + max_size,
145                            max_size, max_size, generator1, generator2, comp);
146 }
147
148 template <typename T>
149 struct test_non_const
150 {
151     template <typename Policy, typename Iterator>
152     void
153     operator()(Policy&& exec, Iterator iter)
154     {
155         invoke_if(exec, [&]() { nth_element(exec, iter, iter, iter, non_const(std::less<T>())); });
156     }
157 };
158
159 int32_t
160 main()
161 {
162     test_by_type<int32_t>([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less<int32_t>());
163     test_by_type<int32_t>([](int32_t) { return 0; }, [](int32_t) { return 0; }, std::less<int32_t>());
164
165     test_by_type<float64_t>([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); },
166                             [](const float64_t x, const float64_t y) { return x > y; });
167
168     test_by_type<DataType<float32_t>>(
169         [](int32_t i) { return DataType<float32_t>(2 * i + 1); }, [](int32_t i) { return DataType<float32_t>(2 * i); },
170         [](const DataType<float32_t>& x, const DataType<float32_t>& y) { return x.get_val() < y.get_val(); });
171
172     test_algo_basic_single<int32_t>(run_for_rnd<test_non_const<int32_t>>());
173
174     std::cout << done() << std::endl;
175     return 0;
176 }