1 // -*- C++ -*-
2 //===-- inplace_merge.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 #include "support/pstl_test_config.h"
13
14 #include <execution>
15 #include <algorithm>
16
17 #include "support/utils.h"
18
19 using namespace TestUtils;
20
21 struct test_one_policy
22 {
23 #if defined(_PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) || \
24 defined(_PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN) // dummy specialization by policy type, in case of broken configuration
25 template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
26 void
operator ()test_one_policy27 operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
28 Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
29 {
30 }
31
32 template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
33 void
operator ()test_one_policy34 operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2,
35 BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
36 {
37 }
38 #endif
39
40 // inplace_merge works with bidirectional iterators at least
41 template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
42 typename Compare>
43 typename std::enable_if<!is_same_iterator_category<BiDirIt1, std::forward_iterator_tag>::value, void>::type
operator ()test_one_policy44 operator()(Policy&& exec, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2, Size n, Size m,
45 Generator1 generator1, Generator2 generator2, Compare comp)
46 {
47 const BiDirIt1 mid1 = std::next(first1, m);
48 fill_data(first1, mid1, generator1);
49 fill_data(mid1, last1, generator2);
50
51 const BiDirIt1 mid2 = std::next(first2, m);
52 fill_data(first2, mid2, generator1);
53 fill_data(mid2, last2, generator2);
54
55 std::inplace_merge(first1, mid1, last1, comp);
56 std::inplace_merge(exec, first2, mid2, last2, comp);
57 EXPECT_EQ_N(first1, first2, n, "wrong effect from inplace_merge with predicate");
58 }
59
60 template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
61 typename Compare>
62 typename std::enable_if<is_same_iterator_category<BiDirIt1, std::forward_iterator_tag>::value, void>::type
operator ()test_one_policy63 operator()(Policy&&, BiDirIt1, BiDirIt1, BiDirIt1, BiDirIt1, Size, Size, Generator1, Generator2, Compare)
64 {
65 }
66 };
67
68 template <typename T, typename Generator1, typename Generator2, typename Compare>
69 void
test_by_type(Generator1 generator1,Generator2 generator2,Compare comp)70 test_by_type(Generator1 generator1, Generator2 generator2, Compare comp)
71 {
72 using namespace std;
73 size_t max_size = 100000;
74 Sequence<T> in1(max_size, [](size_t v) { return T(v); });
75 Sequence<T> exp(max_size, [](size_t v) { return T(v); });
76 size_t m;
77
78 for (size_t n = 0; n <= max_size; n = n <= 16 ? n + 1 : size_t(3.1415 * n))
79 {
80 m = 0;
81 invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
82 generator1, generator2, comp);
83
84 m = n / 3;
85 invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
86 generator1, generator2, comp);
87
88 m = 2 * n / 3;
89 invoke_on_all_policies(test_one_policy(), in1.begin(), in1.begin() + n, exp.begin(), exp.begin() + n, n, m,
90 generator1, generator2, comp);
91 }
92 }
93
94 template <typename T>
95 struct LocalWrapper
96 {
LocalWrapperLocalWrapper97 explicit LocalWrapper(int32_t k) : my_val(k) {}
LocalWrapperLocalWrapper98 LocalWrapper(LocalWrapper&& input) { my_val = std::move(input.my_val); }
99 LocalWrapper&
operator =LocalWrapper100 operator=(LocalWrapper&& input)
101 {
102 my_val = std::move(input.my_val);
103 return *this;
104 }
105 bool
operator <LocalWrapper106 operator<(const LocalWrapper<T>& w) const
107 {
108 return my_val < w.my_val;
109 }
110 friend bool
operator ==(const LocalWrapper<T> & x,const LocalWrapper<T> & y)111 operator==(const LocalWrapper<T>& x, const LocalWrapper<T>& y)
112 {
113 return x.my_val == y.my_val;
114 }
115 friend std::ostream&
operator <<(std::ostream & stream,const LocalWrapper<T> & input)116 operator<<(std::ostream& stream, const LocalWrapper<T>& input)
117 {
118 return stream << input.my_val;
119 }
120
121 private:
122 T my_val;
123 };
124
125 template <typename T>
126 struct test_non_const
127 {
128 template <typename Policy, typename Iterator>
129 void
operator ()test_non_const130 operator()(Policy&& exec, Iterator iter)
131 {
132 invoke_if(exec, [&]() { inplace_merge(exec, iter, iter, iter, non_const(std::less<T>())); });
133 }
134 };
135
136 int
main()137 main()
138 {
139 test_by_type<float64_t>([](int32_t i) { return -2 * i; }, [](int32_t i) { return -(2 * i + 1); },
140 [](const float64_t x, const float64_t y) { return x > y; });
141
142 test_by_type<int32_t>([](int32_t i) { return 10 * i; }, [](int32_t i) { return i + 1; }, std::less<int32_t>());
143
144 test_by_type<LocalWrapper<float32_t>>([](int32_t i) { return LocalWrapper<float32_t>(2 * i + 1); },
145 [](int32_t i) { return LocalWrapper<float32_t>(2 * i); },
146 std::less<LocalWrapper<float32_t>>());
147
148 test_algo_basic_single<int32_t>(run_for_rnd_bi<test_non_const<int32_t>>());
149
150 test_by_type<MemoryChecker>(
151 [](std::size_t idx){ return MemoryChecker{std::int32_t(idx * 2)}; },
152 [](std::size_t idx){ return MemoryChecker{std::int32_t(idx * 2 + 1)}; },
153 [](const MemoryChecker& val1, const MemoryChecker& val2){ return val1.value() == val2.value(); });
154 EXPECT_FALSE(MemoryChecker::alive_objects() < 0, "wrong effect from inplace_merge: number of ctors calls < num of dtors calls");
155 EXPECT_FALSE(MemoryChecker::alive_objects() > 0, "wrong effect from inplace_merge: number of ctors calls > num of dtors calls");
156
157 std::cout << done() << std::endl;
158 return 0;
159 }
160