1 // -*- C++ -*- 2 //===-- nth_element.pass.cpp ----------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 // UNSUPPORTED: c++98, c++03, c++11, c++14 11 12 #include "support/pstl_test_config.h" 13 14 #include <iostream> 15 #include <execution> 16 #include <algorithm> 17 18 #include "support/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&&, Iterator1, Iterator1, Iterator1, Iterator1, Size, Size, 117 Generator1, Generator2, Compare) 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 } 177