1 // -*- C++ -*-
2 // { dg-options "-std=gnu++17 -ltbb" }
3 // { dg-do run { target c++17 } }
4 // { dg-require-effective-target tbb-backend }
5
6 //===-- partition.pass.cpp ------------------------------------------------===//
7 //
8 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
9 // See https://llvm.org/LICENSE.txt for license information.
10 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
11 //
12 //===----------------------------------------------------------------------===//
13
14 // Tests for stable_partition and partition
15 #include "pstl/pstl_test_config.h"
16
17 #ifdef PSTL_STANDALONE_TESTS
18 #include "pstl/execution"
19 #include "pstl/algorithm"
20 #else
21 #include <execution>
22 #include <algorithm>
23 #endif // PSTL_STANDALONE_TESTS
24
25 #include "pstl/test_utils.h"
26
27 #include <iterator>
28 #include <type_traits>
29
30 using namespace TestUtils;
31
32 template <typename T>
33 struct DataType
34 {
DataTypeDataType35 explicit DataType(int32_t k) : my_val(k) {}
DataTypeDataType36 DataType(DataType&& input) { my_val = std::move(input.my_val); }
37 DataType&
operator =DataType38 operator=(DataType&& input)
39 {
40 my_val = std::move(input.my_val);
41 return *this;
42 }
43 T
get_valDataType44 get_val() const
45 {
46 return my_val;
47 }
48
49 friend std::ostream&
operator <<(std::ostream & stream,const DataType<T> & input)50 operator<<(std::ostream& stream, const DataType<T>& input)
51 {
52 return stream << input.my_val;
53 }
54
55 private:
56 T my_val;
57 };
58
59 template <typename Iterator>
60 typename std::enable_if<std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type
is_equal(Iterator first,Iterator last,Iterator d_first)61 is_equal(Iterator first, Iterator last, Iterator d_first)
62 {
63 return std::equal(first, last, d_first);
64 }
65
66 template <typename Iterator>
67 typename std::enable_if<!std::is_trivial<typename std::iterator_traits<Iterator>::value_type>::value, bool>::type
is_equal(Iterator first,Iterator last,Iterator d_first)68 is_equal(Iterator first, Iterator last, Iterator d_first)
69 {
70 return true;
71 }
72
73 struct test_one_policy
74 {
75 #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || \
76 __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration
77 template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
78 void
operator ()test_one_policy79 operator()(__pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
80 Size n, UnaryOp unary_op, Generator generator)
81 {
82 }
83
84 template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
85 void
operator ()test_one_policy86 operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
87 BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
88 {
89 }
90 #elif __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration
91 template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
92 void
93 operator()(__pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
94 Size n, UnaryOp unary_op, Generator generator)
95 {
96 }
97
98 template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
99 void
100 operator()(__pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
101 BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
102 {
103 }
104 #endif
105
106 template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
107 typename std::enable_if<!is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
operator ()test_one_policy108 operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n,
109 UnaryOp unary_op, Generator generator)
110 {
111 // partition
112 {
113 fill_data(first, last, generator);
114 BiDirIt actual_ret = std::partition(exec, first, last, unary_op);
115 EXPECT_TRUE(std::all_of(first, actual_ret, unary_op) && !std::any_of(actual_ret, last, unary_op),
116 "wrong effect from partition");
117 }
118 // stable_partition
119 {
120 fill_data(exp_first, exp_last, generator);
121 BiDirIt exp_ret = std::stable_partition(exp_first, exp_last, unary_op);
122 fill_data(first, last, generator);
123 BiDirIt actual_ret = std::stable_partition(exec, first, last, unary_op);
124
125 EXPECT_TRUE(std::distance(first, actual_ret) == std::distance(exp_first, exp_ret),
126 "wrong result from stable_partition");
127 EXPECT_TRUE((is_equal<BiDirIt>(exp_first, exp_last, first)), "wrong effect from stable_partition");
128 }
129 }
130 template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
131 typename std::enable_if<is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
operator ()test_one_policy132 operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n,
133 UnaryOp unary_op, Generator generator)
134 {
135 }
136 };
137
138 template <typename T, typename Generator, typename UnaryPred>
139 void
test_by_type(Generator generator,UnaryPred pred)140 test_by_type(Generator generator, UnaryPred pred)
141 {
142
143 using namespace std;
144 size_t max_size = 100000;
145 Sequence<T> in(max_size, [](size_t v) { return T(v); });
146 Sequence<T> exp(max_size, [](size_t v) { return T(v); });
147
148 for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
149 {
150 invoke_on_all_policies(test_one_policy(), in.begin(), in.begin() + n, exp.begin(), exp.begin() + n, n, pred,
151 generator);
152 }
153 }
154
155 struct test_non_const
156 {
157 template <typename Policy, typename Iterator>
158 void
operator ()test_non_const159 operator()(Policy&& exec, Iterator iter)
160 {
161 auto is_even = [&](float64_t v) {
162 uint32_t i = (uint32_t)v;
163 return i % 2 == 0;
164 };
165 invoke_if(exec, [&]() {
166 partition(exec, iter, iter, non_const(is_even));
167 stable_partition(exec, iter, iter, non_const(is_even));
168 });
169 }
170 };
171
172 int32_t
main()173 main()
174 {
175 #if !__PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN
176 test_by_type<int32_t>([](int32_t i) { return i; }, [](int32_t) { return true; });
177 #endif
178 test_by_type<float64_t>([](int32_t i) { return -i; }, [](const float64_t x) { return x < 0; });
179 test_by_type<int64_t>([](int32_t i) { return i + 1; }, [](int64_t x) { return x % 3 == 0; });
180 test_by_type<DataType<float32_t>>([](int32_t i) { return DataType<float32_t>(2 * i + 1); },
181 [](const DataType<float32_t>& x) { return x.get_val() < 0; });
182
183 test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const>());
184
185 std::cout << done() << std::endl;
186 return 0;
187 }
188