1 /*
2 //@HEADER
3 // ************************************************************************
4 //
5 // Kokkos v. 3.0
6 // Copyright (2020) National Technology & Engineering
7 // Solutions of Sandia, LLC (NTESS).
8 //
9 // Under the terms of Contract DE-NA0003525 with NTESS,
10 // the U.S. Government retains certain rights in this software.
11 //
12 // Redistribution and use in source and binary forms, with or without
13 // modification, are permitted provided that the following conditions are
14 // met:
15 //
16 // 1. Redistributions of source code must retain the above copyright
17 // notice, this list of conditions and the following disclaimer.
18 //
19 // 2. Redistributions in binary form must reproduce the above copyright
20 // notice, this list of conditions and the following disclaimer in the
21 // documentation and/or other materials provided with the distribution.
22 //
23 // 3. Neither the name of the Corporation nor the names of the
24 // contributors may be used to endorse or promote products derived from
25 // this software without specific prior written permission.
26 //
27 // THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
28 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
31 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 //
39 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
40 //
41 // ************************************************************************
42 //@HEADER
43 */
44
45 #include <cstdio>
46
47 #include <gtest/gtest.h>
48
49 #include <Kokkos_Core.hpp>
50
51 namespace Test {
52
53 namespace {
54
55 template <class ViewType>
56 struct CheckResult {
57 using value_type = typename ViewType::non_const_value_type;
58 ViewType v;
59 value_type value;
CheckResultTest::__anon7e62aaef0111::CheckResult60 CheckResult(ViewType v_, value_type value_) : v(v_), value(value_){};
61 KOKKOS_FUNCTION
operator ()Test::__anon7e62aaef0111::CheckResult62 void operator()(const int i, int& lsum) const {
63 for (int j = 0; j < static_cast<int>(v.extent(1)); j++) {
64 if (v.access(i, j) != value) lsum++;
65 }
66 }
67 };
68
69 template <class ViewType>
run_check(ViewType v,typename ViewType::value_type value)70 bool run_check(ViewType v, typename ViewType::value_type value) {
71 using exec_space = typename ViewType::memory_space::execution_space;
72 int errors = 0;
73 Kokkos::fence();
74 Kokkos::parallel_reduce(Kokkos::RangePolicy<exec_space>(0, v.extent(0)),
75 CheckResult<ViewType>(v, value), errors);
76 return errors == 0;
77 }
78
79 } // namespace
80
TEST(TEST_CATEGORY,view_copy_tests_rank_0)81 TEST(TEST_CATEGORY, view_copy_tests_rank_0) {
82 Kokkos::View<int, TEST_EXECSPACE> defaulted;
83 Kokkos::View<int, TEST_EXECSPACE> a("A");
84 Kokkos::View<int, TEST_EXECSPACE> b("B");
85 auto h_a = Kokkos::create_mirror(a);
86 auto h_b = Kokkos::create_mirror(b);
87 auto m_a = Kokkos::create_mirror_view(a);
88 auto dev = typename TEST_EXECSPACE::execution_space();
89 auto host = Kokkos::DefaultHostExecutionSpace();
90
91 // No execution space
92 { Kokkos::deep_copy(defaulted, defaulted); }
93 {
94 Kokkos::deep_copy(a, 1);
95 ASSERT_TRUE(run_check(a, 1));
96 }
97 {
98 Kokkos::deep_copy(a, a);
99 ASSERT_TRUE(run_check(a, 1));
100 }
101 {
102 Kokkos::deep_copy(m_a, a);
103 ASSERT_TRUE(run_check(m_a, 1));
104 }
105 {
106 Kokkos::deep_copy(m_a, 2);
107 ASSERT_TRUE(run_check(m_a, 2));
108 }
109 {
110 Kokkos::deep_copy(a, m_a);
111 ASSERT_TRUE(run_check(a, 2));
112 }
113 {
114 Kokkos::deep_copy(b, 3);
115 ASSERT_TRUE(run_check(b, 3));
116 }
117 {
118 Kokkos::deep_copy(h_a, 4);
119 ASSERT_TRUE(run_check(h_a, 4));
120 }
121 {
122 Kokkos::deep_copy(a, b);
123 ASSERT_TRUE(run_check(a, 3));
124 }
125 {
126 Kokkos::deep_copy(h_b, h_a);
127 ASSERT_TRUE(run_check(h_b, 4));
128 }
129 {
130 Kokkos::deep_copy(h_a, a);
131 ASSERT_TRUE(run_check(h_a, 3));
132 }
133 {
134 Kokkos::deep_copy(b, h_b);
135 ASSERT_TRUE(run_check(b, 4));
136 }
137
138 // Device
139 { Kokkos::deep_copy(dev, defaulted, defaulted); }
140 {
141 Kokkos::deep_copy(dev, a, 1);
142 ASSERT_TRUE(run_check(a, 1));
143 }
144 {
145 Kokkos::deep_copy(dev, a, a);
146 ASSERT_TRUE(run_check(a, 1));
147 }
148 {
149 Kokkos::deep_copy(dev, m_a, a);
150 ASSERT_TRUE(run_check(m_a, 1));
151 }
152 {
153 Kokkos::deep_copy(dev, m_a, 2);
154 ASSERT_TRUE(run_check(m_a, 2));
155 }
156 {
157 Kokkos::deep_copy(dev, a, m_a);
158 ASSERT_TRUE(run_check(a, 2));
159 }
160 {
161 Kokkos::deep_copy(dev, b, 3);
162 ASSERT_TRUE(run_check(b, 3));
163 }
164 {
165 Kokkos::deep_copy(dev, h_a, 4);
166 ASSERT_TRUE(run_check(h_a, 4));
167 }
168 {
169 Kokkos::deep_copy(dev, a, b);
170 ASSERT_TRUE(run_check(a, 3));
171 }
172 {
173 Kokkos::deep_copy(dev, h_b, h_a);
174 ASSERT_TRUE(run_check(h_b, 4));
175 }
176 {
177 Kokkos::deep_copy(dev, h_a, a);
178 ASSERT_TRUE(run_check(h_a, 3));
179 }
180 {
181 Kokkos::deep_copy(dev, b, h_b);
182 ASSERT_TRUE(run_check(b, 4));
183 }
184
185 // Host
186 { Kokkos::deep_copy(host, defaulted, defaulted); }
187 {
188 Kokkos::deep_copy(host, a, 1);
189 ASSERT_TRUE(run_check(a, 1));
190 }
191 {
192 Kokkos::deep_copy(host, a, a);
193 ASSERT_TRUE(run_check(a, 1));
194 }
195 {
196 Kokkos::deep_copy(host, m_a, a);
197 ASSERT_TRUE(run_check(m_a, 1));
198 }
199 {
200 Kokkos::deep_copy(host, m_a, 2);
201 ASSERT_TRUE(run_check(m_a, 2));
202 }
203 {
204 Kokkos::deep_copy(host, a, m_a);
205 ASSERT_TRUE(run_check(a, 2));
206 }
207 {
208 Kokkos::deep_copy(host, b, 3);
209 ASSERT_TRUE(run_check(b, 3));
210 }
211 {
212 Kokkos::deep_copy(host, h_a, 4);
213 ASSERT_TRUE(run_check(h_a, 4));
214 }
215 {
216 Kokkos::deep_copy(host, a, b);
217 ASSERT_TRUE(run_check(a, 3));
218 }
219 {
220 Kokkos::deep_copy(host, h_b, h_a);
221 ASSERT_TRUE(run_check(h_b, 4));
222 }
223 {
224 Kokkos::deep_copy(host, h_a, a);
225 ASSERT_TRUE(run_check(h_a, 3));
226 }
227 {
228 Kokkos::deep_copy(host, b, h_b);
229 ASSERT_TRUE(run_check(b, 4));
230 }
231 }
232
TEST(TEST_CATEGORY,view_copy_degenerated)233 TEST(TEST_CATEGORY, view_copy_degenerated) {
234 Kokkos::View<int*, TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
235 v_um_def_1;
236 Kokkos::View<int*, TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
237 v_um_1(reinterpret_cast<int*>(-1), 0);
238 Kokkos::View<int*, TEST_EXECSPACE> v_m_def_1;
239 Kokkos::View<int*, TEST_EXECSPACE> v_m_1("v_m_1", 0);
240
241 Kokkos::View<int*, TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
242 v_um_def_2;
243 Kokkos::View<int*, TEST_EXECSPACE, Kokkos::MemoryTraits<Kokkos::Unmanaged>>
244 v_um_2(reinterpret_cast<int*>(-1), 0);
245 Kokkos::View<int*, TEST_EXECSPACE> v_m_def_2;
246 Kokkos::View<int*, TEST_EXECSPACE> v_m_2("v_m_2", 0);
247
248 Kokkos::deep_copy(v_um_def_1, v_um_def_2);
249 Kokkos::deep_copy(v_um_def_1, v_um_2);
250 Kokkos::deep_copy(v_um_def_1, v_m_def_2);
251 Kokkos::deep_copy(v_um_def_1, v_m_2);
252
253 Kokkos::deep_copy(v_um_1, v_um_def_2);
254 Kokkos::deep_copy(v_um_1, v_um_2);
255 Kokkos::deep_copy(v_um_1, v_m_def_2);
256 Kokkos::deep_copy(v_um_1, v_m_2);
257
258 Kokkos::deep_copy(v_m_def_1, v_um_def_2);
259 Kokkos::deep_copy(v_m_def_1, v_um_2);
260 Kokkos::deep_copy(v_m_def_1, v_m_def_2);
261 Kokkos::deep_copy(v_m_def_1, v_m_2);
262
263 Kokkos::deep_copy(v_m_1, v_um_def_2);
264 Kokkos::deep_copy(v_m_1, v_um_2);
265 Kokkos::deep_copy(v_m_1, v_m_def_2);
266 Kokkos::deep_copy(v_m_1, v_m_2);
267 }
268 } // namespace Test
269