Debian Codegraph @

packages/stokhos/src/sacado/kokkos/Stokhos_StaticArrayTraits.hpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Stokhos Package
4 //
5 // Copyright 2009 NTESS and the Stokhos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 #ifndef STOKHOS_STATIC_ARRAY_TRAITS_HPP
11 #define STOKHOS_STATIC_ARRAY_TRAITS_HPP
12
13 #include <cstring>
14
15 #include "Sacado_Traits.hpp"
16
17 #include "Kokkos_Macros.hpp"
18
19 #include "Stokhos_MemoryTraits.hpp"
20
21 namespace Stokhos {
22
23 /*!
24 * \brief Static array allocation class
25 */
26 template <typename T, typename device,
27 bool isScalar = Sacado::IsScalarType<T>::value>
28 struct StaticArrayTraits {};
29
30 /*!
31 * \brief Static array allocation class that works for any type
32 */
33 template <typename T, typename D>
34 struct StaticArrayTraits<T, D, false> {
35
36 typedef T value_type;
37 typedef D execution_space;
38
39 //! Copy array from \c src to \c dest of length \c sz
40 static
41 KOKKOS_INLINE_FUNCTION
42 void copy(const volatile T* src, volatile T* dest, std::size_t sz) {
43 for (std::size_t i=0; i<sz; ++i)
44 *(dest++) = *(src++);
45 }
46
47 //! Copy array from \c src to \c dest of length \c sz
48 static
49 KOKKOS_INLINE_FUNCTION
50 void copy(const volatile T* src, T* dest, std::size_t sz) {
51 for (std::size_t i=0; i<sz; ++i)
52 *(dest++) = *(src++);
53 }
54
55 //! Copy array from \c src to \c dest of length \c sz
56 static
57 KOKKOS_INLINE_FUNCTION
58 void copy(const T* src, volatile T* dest, std::size_t sz) {
59 for (std::size_t i=0; i<sz; ++i)
60 *(dest++) = *(src++);
61 }
62
63 //! Copy array from \c src to \c dest of length \c sz
64 static
65 KOKKOS_INLINE_FUNCTION
66 void copy(const T* src, T* dest, std::size_t sz) {
67 for (std::size_t i=0; i<sz; ++i)
68 *(dest++) = *(src++);
69 }
70
71 //! Zero out array \c dest of length \c sz
72 static
73 KOKKOS_INLINE_FUNCTION
74 void zero(T* dest, std::size_t sz) {
75 for (std::size_t i=0; i<sz; ++i)
76 *(dest++) = T(0.);
77 }
78
79 //! Zero out array \c dest of length \c sz
80 static
81 KOKKOS_INLINE_FUNCTION
82 void zero(volatile T* dest, std::size_t sz) {
83 for (std::size_t i=0; i<sz; ++i)
84 *(dest++) = T(0.);
85 }
86
87 //! Fill array \c dest of length \c sz with value \c v
88 static
89 KOKKOS_INLINE_FUNCTION
90 void fill(T* dest, std::size_t sz, const T& v) {
91 for (std::size_t i=0; i<sz; ++i)
92 *(dest++) = v;
93 }
94
95 //! Fill array \c dest of length \c sz with value \c v
96 static
97 KOKKOS_INLINE_FUNCTION
98 void fill(volatile T* dest, std::size_t sz, const T& v) {
99 for (std::size_t i=0; i<sz; ++i)
100 *(dest++) = v;
101 }
102
103 };
104
105 /*!
106 * \brief Static array allocation class that is specialized for scalar
107 * i.e., fundamental or built-in types (float, double, etc...).
108 */
109 template <typename T, typename D>
110 struct StaticArrayTraits<T,D,true> {
111
112 typedef T value_type;
113 typedef D execution_space;
114
115 //! Copy array from \c src to \c dest of length \c sz
116 static
117 KOKKOS_INLINE_FUNCTION
118 void copy(const volatile T* src, volatile T* dest, std::size_t sz) {
119 // if (sz > 0)
120 // std::memcpy(const_cast<const T*>(dest),const_cast<T*>(src),sz*sizeof(T));
121 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
122 #pragma ivdep
123 #endif
124 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
125 #pragma vector aligned
126 #endif
127 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
128 #pragma unroll
129 #endif
130 for (std::size_t i=0; i<sz; ++i)
131 *(dest++) = *(src++);
132 }
133
134 //! Copy array from \c src to \c dest of length \c sz
135 static
136 KOKKOS_INLINE_FUNCTION
137 void copy(const volatile T* src, T* dest, std::size_t sz) {
138 // if (sz > 0)
139 // std::memcpy(dest,const_cast<const T*>(src),sz*sizeof(T));
140 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
141 #pragma ivdep
142 #endif
143 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
144 #pragma vector aligned
145 #endif
146 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
147 #pragma unroll
148 #endif
149 for (std::size_t i=0; i<sz; ++i)
150 *(dest++) = *(src++);
151 }
152
153 //! Copy array from \c src to \c dest of length \c sz
154 static
155 KOKKOS_INLINE_FUNCTION
156 void copy(const T* src, volatile T* dest, std::size_t sz) {
157 // if (sz > 0)
158 // std::memcpy(const_cast<T*>(dest),src,sz*sizeof(T));
159 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
160 #pragma ivdep
161 #endif
162 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
163 #pragma vector aligned
164 #endif
165 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
166 #pragma unroll
167 #endif
168 for (std::size_t i=0; i<sz; ++i)
169 *(dest++) = *(src++);
170 }
171
172 //! Copy array from \c src to \c dest of length \c sz
173 static
174 KOKKOS_INLINE_FUNCTION
175 void copy(const T* src, T* dest, std::size_t sz) {
176 //if (sz > 0) std::memcpy(dest,src,sz*sizeof(T));
177 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
178 #pragma ivdep
179 #endif
180 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
181 #pragma vector aligned
182 #endif
183 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
184 #pragma unroll
185 #endif
186 for (std::size_t i=0; i<sz; ++i)
187 *(dest++) = *(src++);
188 }
189
190 //! Zero out array \c dest of length \c sz
191 static
192 KOKKOS_INLINE_FUNCTION
193 void zero(T* dest, std::size_t sz) {
194 // if (sz > 0) std::memset(dest,0,sz*sizeof(T));
195 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
196 #pragma ivdep
197 #endif
198 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
199 #pragma vector aligned
200 #endif
201 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
202 #pragma unroll
203 #endif
204 for (std::size_t i=0; i<sz; ++i)
205 *(dest++) = T(0.);
206 }
207
208 //! Zero out array \c dest of length \c sz
209 static
210 KOKKOS_INLINE_FUNCTION
211 void zero(volatile T* dest, std::size_t sz) {
212 // if (sz > 0) std::memset(const_cast<T*>(dest),0,sz*sizeof(T));
213 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
214 #pragma ivdep
215 #endif
216 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
217 #pragma vector aligned
218 #endif
219 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
220 #pragma unroll
221 #endif
222 for (std::size_t i=0; i<sz; ++i)
223 *(dest++) = T(0.);
224 }
225
226 //! Fill array \c dest of length \c sz with value \c v
227 static
228 KOKKOS_INLINE_FUNCTION
229 void fill(T* dest, std::size_t sz, T v) {
230 //std::memset(dest,v,sz*sizeof(T)); // memset doesn't work if v != 0?
231 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
232 #pragma ivdep
233 #endif
234 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
235 #pragma vector aligned
236 #endif
237 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
238 #pragma unroll
239 #endif
240 for (std::size_t i=0; i<sz; ++i)
241 *(dest++) = v;
242 }
243
244 //! Fill array \c dest of length \c sz with value \c v
245 static
246 KOKKOS_INLINE_FUNCTION
247 void fill(volatile T* dest, std::size_t sz, T v) {
248 //std::memset(dest,v,sz*sizeof(T)); // memset doesn't work if v != 0?
249 #ifdef STOKHOS_HAVE_PRAGMA_IVDEP
250 #pragma ivdep
251 #endif
252 #ifdef STOKHOS_HAVE_PRAGMA_VECTOR_ALIGNED
253 #pragma vector aligned
254 #endif
255 #ifdef STOKHOS_HAVE_PRAGMA_UNROLL
256 #pragma unroll
257 #endif
258 for (std::size_t i=0; i<sz; ++i)
259 *(dest++) = v;
260 }
261
262 };
263
264 } // namespace Stokhos
265
266 #endif // STOKHOS_STATIC_ARRAY_TRAITS_HPP