Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_StaticArrayTraits.hpp
Go to the documentation of this file.
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 
26  template <typename T, typename device,
27  bool isScalar = Sacado::IsScalarType<T>::value>
28  struct StaticArrayTraits {};
29 
33  template <typename T, typename D>
34  struct StaticArrayTraits<T, D, false> {
35 
36  typedef T value_type;
37  typedef D execution_space;
38 
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 
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 
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 
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 
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 
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 
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 
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 
109  template <typename T, typename D>
110  struct StaticArrayTraits<T,D,true> {
111 
112  typedef T value_type;
113  typedef D execution_space;
114 
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 
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 
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 
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 
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 
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 
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 
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
Stokhos::StaticArrayTraits< T, D, true >::copy
static KOKKOS_INLINE_FUNCTION void copy(const T *src, T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:175
Stokhos_MemoryTraits.hpp
Stokhos::StaticArrayTraits< T, D, true >::zero
static KOKKOS_INLINE_FUNCTION void zero(volatile T *dest, std::size_t sz)
Zero out array dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:211
Stokhos::StaticArrayTraits< T, D, true >::copy
static KOKKOS_INLINE_FUNCTION void copy(const volatile T *src, T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:137
Stokhos::StaticArrayTraits
Static array allocation class.
Definition: Stokhos_StaticArrayTraits.hpp:28
Stokhos::StaticArrayTraits< T, D, false >::fill
static KOKKOS_INLINE_FUNCTION void fill(T *dest, std::size_t sz, const T &v)
Fill array dest of length sz with value v.
Definition: Stokhos_StaticArrayTraits.hpp:90
Stokhos::StaticArrayTraits< T, D, false >::copy
static KOKKOS_INLINE_FUNCTION void copy(const T *src, volatile T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:58
Stokhos::StaticArrayTraits< T, D, true >::copy
static KOKKOS_INLINE_FUNCTION void copy(const T *src, volatile T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:156
Stokhos::StaticArrayTraits< T, D, true >::copy
static KOKKOS_INLINE_FUNCTION void copy(const volatile T *src, volatile T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:118
Stokhos::StaticArrayTraits< T, D, false >::copy
static KOKKOS_INLINE_FUNCTION void copy(const volatile T *src, T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:50
Stokhos::StaticArrayTraits< T, D, false >::copy
static KOKKOS_INLINE_FUNCTION void copy(const T *src, T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:66
Stokhos::StaticArrayTraits< T, D, false >::copy
static KOKKOS_INLINE_FUNCTION void copy(const volatile T *src, volatile T *dest, std::size_t sz)
Copy array from src to dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:42
Stokhos::StaticArrayTraits< T, D, false >::zero
static KOKKOS_INLINE_FUNCTION void zero(volatile T *dest, std::size_t sz)
Zero out array dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:82
device
Kokkos::DefaultExecutionSpace device
Definition: Stokhos_SacadoPromoteUnitTest.cpp:138
Stokhos::StaticArrayTraits< T, D, false >::fill
static KOKKOS_INLINE_FUNCTION void fill(volatile T *dest, std::size_t sz, const T &v)
Fill array dest of length sz with value v.
Definition: Stokhos_StaticArrayTraits.hpp:98
true
true
Definition: Stokhos_LanczosUnitTest.cpp:233
Stokhos::StaticArrayTraits< T, D, true >::fill
static KOKKOS_INLINE_FUNCTION void fill(T *dest, std::size_t sz, T v)
Fill array dest of length sz with value v.
Definition: Stokhos_StaticArrayTraits.hpp:229
Stokhos::StaticArrayTraits< T, D, false >::zero
static KOKKOS_INLINE_FUNCTION void zero(T *dest, std::size_t sz)
Zero out array dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:74
Stokhos::StaticArrayTraits< T, D, true >::zero
static KOKKOS_INLINE_FUNCTION void zero(T *dest, std::size_t sz)
Zero out array dest of length sz.
Definition: Stokhos_StaticArrayTraits.hpp:193
Stokhos::StaticArrayTraits< T, D, true >::fill
static KOKKOS_INLINE_FUNCTION void fill(volatile T *dest, std::size_t sz, T v)
Fill array dest of length sz with value v.
Definition: Stokhos_StaticArrayTraits.hpp:247
Generated by   doxygen 1.8.5