Debian Codegraph @

packages/kokkos-kernels/batched/dense/impl/KokkosBatched_InnerLU_Serial_Impl.hpp

raw
1 //@HEADER
2 // ************************************************************************
3 //
4 // Kokkos v. 4.0
5 // Copyright (2022) National Technology & Engineering
6 // Solutions of Sandia, LLC (NTESS).
7 //
8 // Under the terms of Contract DE-NA0003525 with NTESS,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
12 // See https://kokkos.org/LICENSE for license information.
13 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
14 //
15 //@HEADER
16 #ifndef KOKKOSBATCHED_INNER_LU_SERIAL_IMPL_HPP
17 #define KOKKOSBATCHED_INNER_LU_SERIAL_IMPL_HPP
18
19 /// \author Kyungjoo Kim ([email protected])
20
21 #include "KokkosBatched_Util.hpp"
22 #include "KokkosBatched_InnerLU_Decl.hpp"
23
24 namespace KokkosBatched {
25
26 ///
27 /// Fixed size LU
28 /// ================
29
30 template <>
31 template <typename ValueType>
32 KOKKOS_INLINE_FUNCTION int InnerLU<5>::serial_invoke(ValueType *KOKKOS_RESTRICT A) {
33 // load
34 ValueType a_00 = A[0 * _as0 + 0 * _as1], a_01 = A[0 * _as0 + 1 * _as1], a_02 = A[0 * _as0 + 2 * _as1],
35 a_03 = A[0 * _as0 + 3 * _as1], a_04 = A[0 * _as0 + 4 * _as1], a_10 = A[1 * _as0 + 0 * _as1],
36 a_11 = A[1 * _as0 + 1 * _as1], a_12 = A[1 * _as0 + 2 * _as1], a_13 = A[1 * _as0 + 3 * _as1],
37 a_14 = A[1 * _as0 + 4 * _as1], a_20 = A[2 * _as0 + 0 * _as1], a_21 = A[2 * _as0 + 1 * _as1],
38 a_22 = A[2 * _as0 + 2 * _as1], a_23 = A[2 * _as0 + 3 * _as1], a_24 = A[2 * _as0 + 4 * _as1],
39 a_30 = A[3 * _as0 + 0 * _as1], a_31 = A[3 * _as0 + 1 * _as1], a_32 = A[3 * _as0 + 2 * _as1],
40 a_33 = A[3 * _as0 + 3 * _as1], a_34 = A[3 * _as0 + 4 * _as1], a_40 = A[4 * _as0 + 0 * _as1],
41 a_41 = A[4 * _as0 + 1 * _as1], a_42 = A[4 * _as0 + 2 * _as1], a_43 = A[4 * _as0 + 3 * _as1],
42 a_44 = A[4 * _as0 + 4 * _as1];
43
44 // 0 iteration
45 a_10 /= a_00;
46 a_11 -= a_10 * a_01;
47 a_12 -= a_10 * a_02;
48 a_13 -= a_10 * a_03;
49 a_14 -= a_10 * a_04;
50 a_20 /= a_00;
51 a_21 -= a_20 * a_01;
52 a_22 -= a_20 * a_02;
53 a_23 -= a_20 * a_03;
54 a_24 -= a_20 * a_04;
55 a_30 /= a_00;
56 a_31 -= a_30 * a_01;
57 a_32 -= a_30 * a_02;
58 a_33 -= a_30 * a_03;
59 a_34 -= a_30 * a_04;
60 a_40 /= a_00;
61 a_41 -= a_40 * a_01;
62 a_42 -= a_40 * a_02;
63 a_43 -= a_40 * a_03;
64 a_44 -= a_40 * a_04;
65
66 // 1 iteration
67 a_21 /= a_11;
68 a_22 -= a_21 * a_12;
69 a_23 -= a_21 * a_13;
70 a_24 -= a_21 * a_14;
71 a_31 /= a_11;
72 a_32 -= a_31 * a_12;
73 a_33 -= a_31 * a_13;
74 a_34 -= a_31 * a_14;
75 a_41 /= a_11;
76 a_42 -= a_41 * a_12;
77 a_43 -= a_41 * a_13;
78 a_44 -= a_41 * a_14;
79
80 // 2 iteration
81 a_32 /= a_22;
82 a_33 -= a_32 * a_23;
83 a_34 -= a_32 * a_24;
84 a_42 /= a_22;
85 a_43 -= a_42 * a_23;
86 a_44 -= a_42 * a_24;
87
88 // 3 iteration
89 a_43 /= a_33;
90 a_44 -= a_43 * a_34;
91
92 // store
93 A[1 * _as0 + 0 * _as1] = a_10;
94 A[1 * _as0 + 1 * _as1] = a_11;
95 A[1 * _as0 + 2 * _as1] = a_12;
96 A[1 * _as0 + 3 * _as1] = a_13;
97 A[1 * _as0 + 4 * _as1] = a_14;
98 A[2 * _as0 + 0 * _as1] = a_20;
99 A[2 * _as0 + 1 * _as1] = a_21;
100 A[2 * _as0 + 2 * _as1] = a_22;
101 A[2 * _as0 + 3 * _as1] = a_23;
102 A[2 * _as0 + 4 * _as1] = a_24;
103 A[3 * _as0 + 0 * _as1] = a_30;
104 A[3 * _as0 + 1 * _as1] = a_31;
105 A[3 * _as0 + 2 * _as1] = a_32;
106 A[3 * _as0 + 3 * _as1] = a_33;
107 A[3 * _as0 + 4 * _as1] = a_34;
108 A[4 * _as0 + 0 * _as1] = a_40;
109 A[4 * _as0 + 1 * _as1] = a_41;
110 A[4 * _as0 + 2 * _as1] = a_42;
111 A[4 * _as0 + 3 * _as1] = a_43;
112 A[4 * _as0 + 4 * _as1] = a_44;
113
114 return 0;
115 }
116
117 template <>
118 template <typename ValueType>
119 KOKKOS_INLINE_FUNCTION int InnerLU<4>::serial_invoke(ValueType *KOKKOS_RESTRICT A) {
120 // load
121 ValueType a_00 = A[0 * _as0 + 0 * _as1], a_01 = A[0 * _as0 + 1 * _as1], a_02 = A[0 * _as0 + 2 * _as1],
122 a_03 = A[0 * _as0 + 3 * _as1], a_10 = A[1 * _as0 + 0 * _as1], a_11 = A[1 * _as0 + 1 * _as1],
123 a_12 = A[1 * _as0 + 2 * _as1], a_13 = A[1 * _as0 + 3 * _as1], a_20 = A[2 * _as0 + 0 * _as1],
124 a_21 = A[2 * _as0 + 1 * _as1], a_22 = A[2 * _as0 + 2 * _as1], a_23 = A[2 * _as0 + 3 * _as1],
125 a_30 = A[3 * _as0 + 0 * _as1], a_31 = A[3 * _as0 + 1 * _as1], a_32 = A[3 * _as0 + 2 * _as1],
126 a_33 = A[3 * _as0 + 3 * _as1];
127
128 // 0 iteration
129 a_10 /= a_00;
130 a_11 -= a_10 * a_01;
131 a_12 -= a_10 * a_02;
132 a_13 -= a_10 * a_03;
133 a_20 /= a_00;
134 a_21 -= a_20 * a_01;
135 a_22 -= a_20 * a_02;
136 a_23 -= a_20 * a_03;
137 a_30 /= a_00;
138 a_31 -= a_30 * a_01;
139 a_32 -= a_30 * a_02;
140 a_33 -= a_30 * a_03;
141
142 // 1 iteration
143 a_21 /= a_11;
144 a_22 -= a_21 * a_12;
145 a_23 -= a_21 * a_13;
146 a_31 /= a_11;
147 a_32 -= a_31 * a_12;
148 a_33 -= a_31 * a_13;
149
150 // 2 iteration
151 a_32 /= a_22;
152 a_33 -= a_32 * a_23;
153
154 // store
155 A[1 * _as0 + 0 * _as1] = a_10;
156 A[1 * _as0 + 1 * _as1] = a_11;
157 A[1 * _as0 + 2 * _as1] = a_12;
158 A[1 * _as0 + 3 * _as1] = a_13;
159 A[2 * _as0 + 0 * _as1] = a_20;
160 A[2 * _as0 + 1 * _as1] = a_21;
161 A[2 * _as0 + 2 * _as1] = a_22;
162 A[2 * _as0 + 3 * _as1] = a_23;
163 A[3 * _as0 + 0 * _as1] = a_30;
164 A[3 * _as0 + 1 * _as1] = a_31;
165 A[3 * _as0 + 2 * _as1] = a_32;
166 A[3 * _as0 + 3 * _as1] = a_33;
167
168 return 0;
169 }
170
171 template <>
172 template <typename ValueType>
173 KOKKOS_INLINE_FUNCTION int InnerLU<3>::serial_invoke(ValueType *KOKKOS_RESTRICT A) {
174 // load
175 ValueType a_00 = A[0 * _as0 + 0 * _as1], a_01 = A[0 * _as0 + 1 * _as1], a_02 = A[0 * _as0 + 2 * _as1],
176 a_10 = A[1 * _as0 + 0 * _as1], a_11 = A[1 * _as0 + 1 * _as1], a_12 = A[1 * _as0 + 2 * _as1],
177 a_20 = A[2 * _as0 + 0 * _as1], a_21 = A[2 * _as0 + 1 * _as1], a_22 = A[2 * _as0 + 2 * _as1];
178
179 // 0 iteration
180 a_10 /= a_00;
181 a_11 -= a_10 * a_01;
182 a_12 -= a_10 * a_02;
183 a_20 /= a_00;
184 a_21 -= a_20 * a_01;
185 a_22 -= a_20 * a_02;
186
187 // 1 iteration
188 a_21 /= a_11;
189 a_22 -= a_21 * a_12;
190
191 // store
192 A[1 * _as0 + 0 * _as1] = a_10;
193 A[1 * _as0 + 1 * _as1] = a_11;
194 A[1 * _as0 + 2 * _as1] = a_12;
195 A[2 * _as0 + 0 * _as1] = a_20;
196 A[2 * _as0 + 1 * _as1] = a_21;
197 A[2 * _as0 + 2 * _as1] = a_22;
198
199 return 0;
200 }
201
202 template <>
203 template <typename ValueType>
204 KOKKOS_INLINE_FUNCTION int InnerLU<2>::serial_invoke(ValueType *KOKKOS_RESTRICT A) {
205 // load
206 ValueType a_00 = A[0 * _as0 + 0 * _as1], a_01 = A[0 * _as0 + 1 * _as1], a_10 = A[1 * _as0 + 0 * _as1],
207 a_11 = A[1 * _as0 + 1 * _as1];
208
209 // 0 iteration
210 a_10 /= a_00;
211 a_11 -= a_10 * a_01;
212
213 // store
214 A[1 * _as0 + 0 * _as1] = a_10;
215 A[1 * _as0 + 1 * _as1] = a_11;
216
217 return 0;
218 }
219
220 template <>
221 template <typename ValueType>
222 KOKKOS_INLINE_FUNCTION int InnerLU<1>::serial_invoke(ValueType *KOKKOS_RESTRICT /* A */) {
223 return 0;
224 }
225
226 template <>
227 template <typename ValueType>
228 KOKKOS_INLINE_FUNCTION int InnerLU<5>::serial_invoke(const int m, ValueType *KOKKOS_RESTRICT A) {
229 if (m > 5) Kokkos::abort("InnerLU<5>::serial_invoke, assert failure (m<=5)");
230 if (m <= 0) return 0;
231
232 switch (m) {
233 case 5: {
234 InnerLU<5> inner(_as0, _as1);
235 inner.serial_invoke(A);
236 break;
237 }
238 case 4: {
239 InnerLU<4> inner(_as0, _as1);
240 inner.serial_invoke(A);
241 break;
242 }
243 case 3: {
244 InnerLU<3> inner(_as0, _as1);
245 inner.serial_invoke(A);
246 break;
247 }
248 case 2: {
249 InnerLU<2> inner(_as0, _as1);
250 inner.serial_invoke(A);
251 break;
252 }
253 case 1: {
254 InnerLU<1> inner(_as0, _as1);
255 inner.serial_invoke(A);
256 break;
257 }
258 }
259 return 0;
260 }
261
262 template <>
263 template <typename ValueType>
264 KOKKOS_INLINE_FUNCTION int InnerLU<4>::serial_invoke(const int m, ValueType *KOKKOS_RESTRICT A) {
265 if (m > 4) Kokkos::abort("InnerLU<4>::serial_invoke, assert failure (m<=4)");
266 if (m <= 0) return 0;
267
268 switch (m) {
269 case 4: {
270 InnerLU<4> inner(_as0, _as1);
271 inner.serial_invoke(A);
272 break;
273 }
274 case 3: {
275 InnerLU<3> inner(_as0, _as1);
276 inner.serial_invoke(A);
277 break;
278 }
279 case 2: {
280 InnerLU<2> inner(_as0, _as1);
281 inner.serial_invoke(A);
282 break;
283 }
284 case 1: {
285 InnerLU<1> inner(_as0, _as1);
286 inner.serial_invoke(A);
287 break;
288 }
289 }
290 return 0;
291 }
292
293 template <>
294 template <typename ValueType>
295 KOKKOS_INLINE_FUNCTION int InnerLU<3>::serial_invoke(const int m, ValueType *KOKKOS_RESTRICT A) {
296 if (m > 3) Kokkos::abort("InnerLU<3>::serial_invoke, assert failure (m<=3)");
297 if (m <= 0) return 0;
298
299 switch (m) {
300 case 3: {
301 InnerLU<3> inner(_as0, _as1);
302 inner.serial_invoke(A);
303 break;
304 }
305 case 2: {
306 InnerLU<2> inner(_as0, _as1);
307 inner.serial_invoke(A);
308 break;
309 }
310 case 1: {
311 InnerLU<1> inner(_as0, _as1);
312 inner.serial_invoke(A);
313 break;
314 }
315 }
316 return 0;
317 }
318
319 template <>
320 template <typename ValueType>
321 KOKKOS_INLINE_FUNCTION int InnerLU<2>::serial_invoke(const int m, ValueType *KOKKOS_RESTRICT A) {
322 if (m > 2) Kokkos::abort("InnerLU<2>::serial_invoke, assert failure (m<=2)");
323 if (m <= 0) return 0;
324
325 switch (m) {
326 case 2: {
327 InnerLU<2> inner(_as0, _as1);
328 inner.serial_invoke(A);
329 break;
330 }
331 case 1: {
332 InnerLU<1> inner(_as0, _as1);
333 inner.serial_invoke(A);
334 break;
335 }
336 }
337 return 0;
338 }
339
340 template <>
341 template <typename ValueType>
342 KOKKOS_INLINE_FUNCTION int InnerLU<1>::serial_invoke(const int m, ValueType *KOKKOS_RESTRICT A) {
343 if (m > 1) Kokkos::abort("InnerLU<1>::serial_invoke, assert failure (m<=1)");
344 if (m <= 0) return 0;
345
346 switch (m) {
347 case 1: {
348 InnerLU<1> inner(_as0, _as1);
349 inner.serial_invoke(A);
350 break;
351 }
352 }
353 return 0;
354 }
355
356 // template<int bmn>
357 // template<typename ValueType>
358 // KOKKOS_INLINE_FUNCTION
359 // int
360 // InnerLU<bmn>::
361 // serial_invoke(const int m, const int n,
362 // ValueType *KOKKOS_RESTRICT A) {
363 // if (m <= 0 || n <= 0) return 0;
364 // const int k = m < n ? m : n;
365 // for (int p=0;p<k;++p) {
366 // const ValueType
367 // // inv_alpha11 = 1.0/A[p*_as0+p*_as1],
368 // alpha11 = A[p*_as0+p*_as1],
369 // *KOKKOS_RESTRICT a12t = A + (p )*_as0 + (p+1)*_as1;
370
371 // ValueType
372 // *KOKKOS_RESTRICT a21 = A + (p+1)*_as0 + (p )*_as1,
373 // *KOKKOS_RESTRICT A22 = A + (p+1)*_as0 + (p+1)*_as1;
374
375 // const int
376 // iend = m-p-1,
377 // jend = n-p-1;
378
379 // for (int i=0;i<iend;++i) {
380 // // a21[i*_as0] *= inv_alpha11;
381 // a21[i*_as0] /= alpha11;
382 // for (int j=0;j<jend;++j)
383 // A22[i*_as0+j*_as1] -= a21[i*_as0] * a12t[j*_as1];
384 // }
385 // }
386 // return 0;
387 // }
388
389 } // namespace KokkosBatched
390
391 #endif