1 // -*- C++ -*-
2 //===-- unique.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++03, c++11, c++14
11
12 // Test for unique
13 #include "support/pstl_test_config.h"
14
15 #include <execution>
16 #include <algorithm>
17
18 #include "support/utils.h"
19
20 using namespace TestUtils;
21
22 struct run_unique
23 {
24 #if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) || \
25 defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) //dummy specialization by policy type, in case of broken configuration
26 template <typename ForwardIt, typename Generator>
27 void
operator ()run_unique28 operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
29 ForwardIt last2, Generator generator)
30 {
31 }
32
33 template <typename ForwardIt, typename Generator>
34 void
operator ()run_unique35 operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
36 ForwardIt last2, Generator generator)
37 {
38 }
39
40 template <typename ForwardIt, typename BinaryPred, typename Generator>
41 void
operator ()run_unique42 operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
43 ForwardIt last2, BinaryPred pred, Generator generator)
44 {
45 }
46
47 template <typename ForwardIt, typename BinaryPred, typename Generator>
48 void
operator ()run_unique49 operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
50 ForwardIt last2, BinaryPred pred, Generator generator)
51 {
52 }
53 #endif
54
55 template <typename Policy, typename ForwardIt, typename Generator>
56 void
operator ()run_unique57 operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator)
58 {
59 using namespace std;
60
61 // Preparation
62 fill_data(first1, last1, generator);
63 fill_data(first2, last2, generator);
64
65 ForwardIt i = unique(first1, last1);
66 ForwardIt k = unique(exec, first2, last2);
67
68 auto n = std::distance(first1, i);
69 EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique without predicate");
70 EXPECT_EQ_N(first1, first2, n, "wrong effect from unique without predicate");
71 }
72
73 template <typename Policy, typename ForwardIt, typename BinaryPred, typename Generator>
74 void
operator ()run_unique75 operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, BinaryPred pred,
76 Generator generator)
77 {
78 using namespace std;
79
80 // Preparation
81 fill_data(first1, last1, generator);
82 fill_data(first2, last2, generator);
83
84 ForwardIt i = unique(first1, last1, pred);
85 ForwardIt k = unique(exec, first2, last2, pred);
86
87 auto n = std::distance(first1, i);
88 EXPECT_TRUE(std::distance(first2, k) == n, "wrong return value from unique with predicate");
89 EXPECT_EQ_N(first1, first2, n, "wrong effect from unique with predicate");
90 }
91 };
92
93 template <typename T, typename Generator, typename Predicate>
94 void
test(Generator generator,Predicate pred)95 test(Generator generator, Predicate pred)
96 {
97 const std::size_t max_size = 1000000;
98 Sequence<T> in(max_size, [](size_t v) { return T(v); });
99 Sequence<T> exp(max_size, [](size_t v) { return T(v); });
100
101 for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
102 {
103 invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, generator);
104 invoke_on_all_policies(run_unique(), exp.begin(), exp.begin() + n, in.begin(), in.begin() + n, pred, generator);
105 }
106 }
107
108 template <typename T>
109 struct LocalWrapper
110 {
111 T my_val;
112
LocalWrapperLocalWrapper113 explicit LocalWrapper(T k) : my_val(k) {}
LocalWrapperLocalWrapper114 LocalWrapper(LocalWrapper&& input) : my_val(std::move(input.my_val)) {}
115 LocalWrapper&
operator =LocalWrapper116 operator=(LocalWrapper&& input)
117 {
118 my_val = std::move(input.my_val);
119 return *this;
120 }
121 friend bool
operator ==(const LocalWrapper<T> & x,const LocalWrapper<T> & y)122 operator==(const LocalWrapper<T>& x, const LocalWrapper<T>& y)
123 {
124 return x.my_val == y.my_val;
125 }
126 };
127
128 template <typename T>
129 struct test_non_const
130 {
131 template <typename Policy, typename Iterator>
132 void
operator ()test_non_const133 operator()(Policy&& exec, Iterator iter)
134 {
135 invoke_if(exec, [&]() { unique(exec, iter, iter, non_const(std::equal_to<T>())); });
136 }
137 };
138
139 int
main()140 main()
141 {
142 #if !defined(_PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN)
143 test<int32_t>([](size_t j) { return j / 3; },
144 [](const int32_t& val1, const int32_t& val2) { return val1 * val1 == val2 * val2; });
145 test<float64_t>([](size_t) { return float64_t(1); },
146 [](const float64_t& val1, const float64_t& val2) { return val1 != val2; });
147 #endif
148 test<LocalWrapper<uint32_t>>([](size_t j) { return LocalWrapper<uint32_t>(j); },
149 [](const LocalWrapper<uint32_t>& val1, const LocalWrapper<uint32_t>& val2) {
150 return val1.my_val != val2.my_val;
151 });
152
153 test_algo_basic_single<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
154
155 test<MemoryChecker>(
156 [](std::size_t idx){ return MemoryChecker{std::int32_t(idx / 3)}; },
157 [](const MemoryChecker& val1, const MemoryChecker& val2){ return val1.value() == val2.value(); });
158 EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from unique: number of ctors calls < num of dtors calls");
159 EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from unique: number of ctors calls > num of dtors calls");
160
161 std::cout << done() << std::endl;
162 return 0;
163 }
164