Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/util/UnitTestStkNgpVector.cpp

raw
1 #include <cstddef> // for size_t
2 #include <string> // for string
3
4 #include "Kokkos_Core.hpp"
5 #include "gtest/gtest.h"
6 #include "stk_util/util/StkNgpVector.hpp" // for NgpVector, NgpVector<>::DeviceType
7
8 namespace {
9
10 TEST(StkVectorTest, create_sizeIsZero)
11 {
12 stk::NgpVector<int> vec;
13 EXPECT_EQ(0u, vec.size());
14 }
15 TEST(StkVectorTest, createSizeOne_sizeIsOne)
16 {
17 stk::NgpVector<int> vec(1);
18 EXPECT_EQ(1u, vec.size());
19 }
20 TEST(StkVectorTest, setSingleInt_getInt)
21 {
22 stk::NgpVector<int> vec(1);
23 vec[0] = 2;
24 EXPECT_EQ(2, vec[0]);
25 }
26 TEST(StkVectorTest, setSingleDouble_getDouble)
27 {
28 stk::NgpVector<double> vec(1);
29 vec[0] = 0.5;
30 EXPECT_EQ(0.5, vec[0]);
31 }
32 TEST(StkVectorTest, setTwoInts_getInts)
33 {
34 stk::NgpVector<int> vec(2);
35 vec[0] = 1;
36 vec[1] = 2;
37 EXPECT_EQ(1, vec[0]);
38 EXPECT_EQ(2, vec[1]);
39 }
40 TEST(StkVectorTest, pushBackOnEmtpyVector_sizeIsOne)
41 {
42 stk::NgpVector<double> vec;
43 vec.push_back(2);
44 EXPECT_EQ(1u, vec.size());
45 }
46 TEST(StkVectorTest, pushBackOnEmtpyVector_getValue)
47 {
48 stk::NgpVector<double> vec;
49 vec.push_back(2);
50 EXPECT_EQ(2, vec[0]);
51 }
52 TEST(StkVectorTest, pushTwoValues_sizeIsTwo)
53 {
54 stk::NgpVector<double> vec;
55 vec.push_back(2);
56 vec.push_back(3);
57 EXPECT_EQ(2u, vec.size());
58 }
59 TEST(StkVectorTest, pushTwoValues_getTwoValues)
60 {
61 stk::NgpVector<double> vec;
62 vec.push_back(2);
63 vec.push_back(3);
64 EXPECT_EQ(2, vec[0]);
65 EXPECT_EQ(3, vec[1]);
66 }
67 TEST(StkVectorTest, createWithName_getName)
68 {
69 stk::NgpVector<double> vec("vec");
70 EXPECT_EQ("vec", vec.name().substr(0,3));
71 }
72 TEST(StkVectorTest, createSizedWithName_getName)
73 {
74 stk::NgpVector<double> vec("vec", 1);
75 EXPECT_EQ("vec", vec.name().substr(0,3));
76 EXPECT_EQ(1u, vec.size());
77 // values are uninitialized
78 }
79 TEST(StkVectorTest, createSizedAndInitWithName_getName)
80 {
81 stk::NgpVector<double> vec("vec", 1, 2.0);
82 EXPECT_EQ("vec", vec.name().substr(0,3));
83 EXPECT_EQ(1u, vec.size());
84 EXPECT_EQ(2.0, vec[0]);
85 }
86 TEST(StkVectorTest, createNamedPushBack_getName)
87 {
88 stk::NgpVector<double> vec("vec");
89 vec.push_back(3.0);
90 EXPECT_EQ("vec", vec.name().substr(0,3));
91 EXPECT_EQ(1u, vec.size());
92 EXPECT_EQ(3.0, vec[0]);
93 }
94
95 class StkVectorSpy : public stk::NgpVector<double>
96 {
97 public:
98 StkVectorSpy() : stk::NgpVector<double>("spy"), numAllocations(0)
99 {
100 }
101 size_t num_allocations() const { return numAllocations; }
102 protected:
103 virtual DeviceType get_new_vals_of_size(size_t s)
104 {
105 numAllocations++;
106 return stk::NgpVector<double>::get_new_vals_of_size(s);
107 }
108 private:
109 size_t numAllocations;
110 };
111 void push_back_num_things(stk::NgpVector<double> &vec, size_t num)
112 {
113 for(size_t i=0; i<num; i++)
114 vec.push_back(2);
115 }
116 TEST(StkVectorTest, eightPushBacks_fourAllocations)
117 {
118 StkVectorSpy vec;
119 push_back_num_things(vec, 8);
120 EXPECT_EQ(4u, vec.num_allocations());
121 }
122 TEST(StkVectorTest, ninePushBacks_fiveAllocations)
123 {
124 StkVectorSpy vec;
125 push_back_num_things(vec, 9);
126 EXPECT_EQ(5u, vec.num_allocations());
127 }
128 TEST(StkVectorTest, eightPushBacks_sizeIsEightCapacityIsEight)
129 {
130 stk::NgpVector<double> vec;
131 push_back_num_things(vec, 8);
132 EXPECT_EQ(8u, vec.size());
133 EXPECT_EQ(8u, vec.capacity());
134 }
135 TEST(StkVectorTest, ninePushBacks_sizeIsNineCapacityIsSixteen)
136 {
137 stk::NgpVector<double> vec;
138 push_back_num_things(vec, 9);
139 EXPECT_EQ(9u, vec.size());
140 EXPECT_EQ(16u, vec.capacity());
141 }
142
143 namespace
144 {
145 template <typename DeviceView>
146 void check_device_view(const stk::NgpVector<double> &vec, const DeviceView &view_device)
147 {
148 EXPECT_EQ(vec.size(), view_device.extent(0));
149
150 unsigned num_err = 0;
151 using execution_space = typename DeviceView::execution_space;
152 Kokkos::parallel_reduce(
153 Kokkos::RangePolicy<execution_space>(0, vec.size()),
154 KOKKOS_LAMBDA(size_t i, unsigned &cnt_err) {
155 if (vec.device_get(i) != view_device[i]) ++cnt_err;
156 },
157 num_err);
158 EXPECT_EQ(num_err, 0u);
159 }
160 } // namespace
161 TEST(StkVectorTest, ninePushBacks_checkDeviceView)
162 {
163 stk::NgpVector<double> vec;
164 push_back_num_things(vec, 9);
165 EXPECT_LT(vec.size(), vec.capacity());
166 check_device_view(vec, vec.view_device());
167 }
168 TEST(StkVectorTest, ninePushBacks_checkHostView)
169 {
170 stk::NgpVector<double> vec;
171 push_back_num_things(vec, 9);
172 EXPECT_LT(vec.size(), vec.capacity());
173 const auto view_host = vec.view_host();
174 EXPECT_EQ(vec.size(), view_host.extent(0));
175
176 for (unsigned i = 0; i < vec.size(); ++i) EXPECT_EQ(vec[i], view_host[i]) << "For entry " << i;
177 }
178 TEST(StkVectorTest, specifySizeAndValue_haveNumValues)
179 {
180 stk::NgpVector<double> vec(4, 3.0);
181 ASSERT_EQ(4u, vec.size());
182 for(size_t i=0; i<vec.size(); i++)
183 EXPECT_EQ(3.0, vec[i]);
184 }
185 TEST(StkVectorTest, resizeEmptyVector_hasNumEntries)
186 {
187 stk::NgpVector<double> vec;
188 vec.resize(4);
189 ASSERT_EQ(4u, vec.size());
190 }
191 TEST(StkVectorTest, resizeEmptyVector_hasZeroes)
192 {
193 stk::NgpVector<double> vec;
194 vec.resize(4);
195 for(size_t i=0; i<vec.size(); i++)
196 EXPECT_EQ(0, vec[i]);
197 }
198 TEST(StkVectorTest, resizeEmptyVectorWithInit_hasValue)
199 {
200 stk::NgpVector<double> vec;
201 vec.resize(4, 2);
202 for(size_t i=0; i<vec.size(); i++)
203 EXPECT_EQ(2, vec[i]);
204 }
205 TEST(StkVectorTest, resizeFullVector_hasNewSize)
206 {
207 stk::NgpVector<double> vec(3);
208 vec.resize(5);
209 ASSERT_EQ(5u, vec.size());
210 }
211 TEST(StkVectorTest, resizeFullVectorWithInit_newEntriesHaveValue)
212 {
213 stk::NgpVector<double> vec(3, 1);
214 vec.resize(5, 2);
215 for(size_t i=0; i<3; i++)
216 EXPECT_EQ(1, vec[i]);
217 for(size_t i=3; i<5; i++)
218 EXPECT_EQ(2, vec[i]);
219 }
220 TEST(StkVectorTest, resizeToSameSize_doesNothing)
221 {
222 stk::NgpVector<double> vec(3, 2);
223 vec.resize(3);
224 ASSERT_EQ(3u, vec.size());
225 for(size_t i=0; i<3; i++)
226 EXPECT_EQ(2, vec[i]);
227 }
228 TEST(StkVectorTest, resizeToSmaller_decreasesSize)
229 {
230 stk::NgpVector<double> vec(6);
231 vec.resize(4);
232 ASSERT_EQ(4u, vec.size());
233 }
234 TEST(StkVectorTest, resizeToSmaller_noAllocation)
235 {
236 StkVectorSpy vec;
237 vec.resize(6);
238 EXPECT_EQ(1u, vec.num_allocations());
239 vec.resize(4);
240 EXPECT_EQ(1u, vec.num_allocations());
241 }
242 TEST(StkVectorTest, resizeToSmallerThenLarger_noAllocation)
243 {
244 StkVectorSpy vec;
245 vec.resize(6);
246 EXPECT_EQ(1u, vec.num_allocations());
247 vec.resize(4);
248 EXPECT_EQ(1u, vec.num_allocations());
249 vec.resize(6);
250 EXPECT_EQ(6u, vec.size());
251 EXPECT_EQ(1u, vec.num_allocations());
252 }
253 TEST(StkVectorTest, sizeZero_isEmpty)
254 {
255 stk::NgpVector<double> vec;
256 EXPECT_TRUE(vec.empty());
257 }
258 TEST(StkVectorTest, sizeOne_isNotEmpty)
259 {
260 stk::NgpVector<double> vec(1);
261 EXPECT_TRUE(!vec.empty());
262 }
263 TEST(StkVectorTest, clear_empty)
264 {
265 stk::NgpVector<double> vec(1);
266 vec.clear();
267 EXPECT_TRUE(vec.empty());
268 }
269
270 }