Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Kokkos_DynRankView_Fad.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Sacado Package
4 //
5 // Copyright 2006 NTESS and the Sacado contributors.
6 // SPDX-License-Identifier: LGPL-2.1-or-later
7 // *****************************************************************************
8 // @HEADER
9 
10 #ifndef KOKKOS_DYN_RANK_VIEW_SACADO_FAD_HPP
11 #define KOKKOS_DYN_RANK_VIEW_SACADO_FAD_HPP
12 
13 #include "Sacado_ConfigDefs.h"
14 
15 // This file is setup to always work even when KokkosContainers (which contains
16 // Kokkos::DynRankView) isn't enabled.
17 
18 #if defined(HAVE_SACADO_KOKKOS)
19 
20 // We are hooking into Kokkos Core internals here
21 // Need to define this macro since we include non-public headers
22 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
23 #define KOKKOS_IMPL_PUBLIC_INCLUDE
24 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
25 #endif
26 // Only include forward declarations so any overloads appear before they
27 // might be used inside Kokkos
28 #include "Kokkos_Core_fwd.hpp"
29 #include "Kokkos_Layout.hpp"
30 //#include "Kokkos_DynRankView.hpp"
31 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
32 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
33 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
34 #endif
35 
36 #ifndef SACADO_HAS_NEW_KOKKOS_VIEW_IMPL
37 namespace Kokkos {
38 
39 template< class DataType , class ... Properties >
40 struct ViewTraits ;
41 
42 template< class DataType , class ... Properties >
43 class DynRankView ;
44 
45 namespace Impl {
46 
47 template<class Space, class T, class ... P>
48 struct MirrorDRViewType;
49 
50 }
51 
52 template <typename view_type>
53 struct is_dynrankview_fad { static const bool value = false; };
54 
55 template <typename view_type>
56 struct is_dynrankview_fad_contiguous { static const bool value = false; };
57 
58 }
59 
60 #if defined(HAVE_SACADO_VIEW_SPEC) && !defined(SACADO_DISABLE_FAD_VIEW_SPEC)
61 
62 #include "Kokkos_View_Fad.hpp"
63 
64 namespace Kokkos {
65 
66 // Declare overloads of create_mirror() so they are in scope
67 // Kokkos_DynRankView.hpp is included below
68 
69 template< class T , class ... P >
70 inline
71 typename Kokkos::DynRankView<T,P...>::host_mirror_type
72 create_mirror(
73  const Kokkos::DynRankView<T,P...> & src,
74  typename std::enable_if<
75  ( std::is_same< typename ViewTraits<T,P...>::specialize ,
76  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
77  std::is_same< typename ViewTraits<T,P...>::specialize ,
78  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value ) &&
79  !std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout,
80  Kokkos::LayoutStride >::value >::type * = 0);
81 
82 
83 template< class T , class ... P >
84 inline
85 typename Kokkos::DynRankView<T,P...>::host_mirror_type
86 create_mirror(
87  const Kokkos::DynRankView<T,P...> & src,
88  typename std::enable_if<
89  ( std::is_same< typename ViewTraits<T,P...>::specialize ,
90  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
91  std::is_same< typename ViewTraits<T,P...>::specialize ,
92  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value ) &&
93  std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout,
94  Kokkos::LayoutStride >::value >::type * = 0);
95 
96 template<class Space, class T, class ... P>
97 typename Impl::MirrorDRViewType<Space,T,P ...>::dest_view_type
98 create_mirror(
99  const Space&,
100  const Kokkos::DynRankView<T,P...> & src,
101  typename std::enable_if<
102  std::is_same< typename ViewTraits<T,P...>::specialize ,
103  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
104  std::is_same< typename ViewTraits<T,P...>::specialize ,
105  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value >::type * = 0);
106 
107 namespace Impl {
108 
109 template <unsigned N, typename T, typename... Args>
110 KOKKOS_FUNCTION auto as_view_of_rank_n(
111  DynRankView<T, Args...> v,
112  typename std::enable_if<
113  ( std::is_same< typename ViewTraits<T,Args...>::specialize,
114  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
115  std::is_same< typename ViewTraits<T,Args...>::specialize ,
116  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
117  >::type * = 0 );
118 
119 }
120 
121 } // namespace Kokkos
122 
123 #include "Kokkos_DynRankView.hpp"
124 
125 namespace Kokkos {
126 namespace Impl {
127 
128 template <>
129 struct DynRankDimTraits<Kokkos::Impl::ViewSpecializeSacadoFad> {
130 
131  enum : size_t{unspecified = ~size_t(0)};
132 
133  // Compute the rank of the view from the nonzero dimension arguments.
134  // For views of Fad, the rank is one less than the rank determined by the nonzero dimension args
135  KOKKOS_INLINE_FUNCTION
136  static size_t computeRank( const size_t N0
137  , const size_t N1
138  , const size_t N2
139  , const size_t N3
140  , const size_t N4
141  , const size_t N5
142  , const size_t N6
143  , const size_t N7 )
144  {
145  return
146  ( (N7 == unspecified && N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified && N1 == unspecified && N0 == unspecified) ? 0
147  : ( (N7 == unspecified && N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified && N1 == unspecified) ? 0
148  : ( (N7 == unspecified && N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified && N2 == unspecified) ? 1
149  : ( (N7 == unspecified && N6 == unspecified && N5 == unspecified && N4 == unspecified && N3 == unspecified) ? 2
150  : ( (N7 == unspecified && N6 == unspecified && N5 == unspecified && N4 == unspecified) ? 3
151  : ( (N7 == unspecified && N6 == unspecified && N5 == unspecified) ? 4
152  : ( (N7 == unspecified && N6 == unspecified) ? 5
153  : ( (N7 == unspecified) ? 6
154  : 7 ) ) ) ) ) ) ) );
155  }
156 
157  // Compute the rank of the view from the nonzero layout arguments.
158  template <typename Layout>
159  KOKKOS_INLINE_FUNCTION
160  static size_t computeRank( const Layout& layout )
161  {
162  return computeRank( layout.dimension[0]
163  , layout.dimension[1]
164  , layout.dimension[2]
165  , layout.dimension[3]
166  , layout.dimension[4]
167  , layout.dimension[5]
168  , layout.dimension[6]
169  , layout.dimension[7] );
170  }
171 
172  // Compute the rank of the view from the nonzero layout arguments and possible hidden dim
173  template <typename Layout, typename ... P>
174  KOKKOS_INLINE_FUNCTION
175  static size_t computeRank( const ViewCtorProp<P...>& /* prop */, const Layout& layout )
176  {
177  size_t rank = computeRank( layout.dimension[0]
178  , layout.dimension[1]
179  , layout.dimension[2]
180  , layout.dimension[3]
181  , layout.dimension[4]
182  , layout.dimension[5]
183  , layout.dimension[6]
184  , layout.dimension[7] );
185 
186  // Check if has_common_view_alloc_prop; if so, return rank+1, else rank
187  enum { test_traits_check = Kokkos::Impl::check_has_common_view_alloc_prop< P... >::value };
188  return (test_traits_check == true) ? rank+1 : rank;
189  }
190 
191  // Create the layout for the rank-7 view.
192  // For Fad we have to move the fad dimension to the last (rank 8 since the DynRankView is rank-7)
193  // LayoutLeft or LayoutRight
194  template <typename Layout>
195  KOKKOS_INLINE_FUNCTION
196  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutRight>::value || std::is_same<Layout , Kokkos::LayoutLeft>::value) , Layout >::type createLayout( const Layout& layout )
197  {
198  Layout l( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
199  , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
200  , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
201  , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
202  , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
203  , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
204  , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
205  , layout.dimension[7] != unspecified ? layout.dimension[7] : 1 );
206  const unsigned fad_dim = computeRank(layout);
207  const size_t fad_size = layout.dimension[fad_dim];
208  l.dimension[fad_dim] = 1;
209  l.dimension[7] = fad_size;
210 
211  return l;
212  }
213 
214  //LayoutStride
215  template <typename Layout>
216  KOKKOS_INLINE_FUNCTION
217  static typename std::enable_if< (std::is_same<Layout , Kokkos::LayoutStride>::value) , Layout>::type createLayout( const Layout& layout )
218  {
219  Layout l( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
220  , layout.stride[0]
221  , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
222  , layout.stride[1]
223  , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
224  , layout.stride[2]
225  , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
226  , layout.stride[3]
227  , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
228  , layout.stride[4]
229  , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
230  , layout.stride[5]
231  , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
232  , layout.stride[6]
233  , layout.dimension[7] != unspecified ? layout.dimension[7] : 1
234  , layout.stride[7]
235  );
236  const unsigned fad_dim = computeRank(layout);
237  const size_t fad_size = layout.dimension[fad_dim];
238  l.dimension[fad_dim] = 1;
239  l.dimension[7] = fad_size;
240  const size_t fad_stride = layout.stride[fad_dim];
241  l.stride[fad_dim] = 0;
242  l.stride[7] = fad_stride;
243 
244  return l;
245  }
246 
247  // If fad_dim is stored in ViewCtorProp
248  // LayoutLeft or LayoutRight
249  template <typename Traits, typename ... P>
250  KOKKOS_INLINE_FUNCTION
251  static typename std::enable_if< (std::is_same<typename Traits::array_layout , Kokkos::LayoutRight>::value || std::is_same<typename Traits::array_layout , Kokkos::LayoutLeft>::value) , typename Traits::array_layout >::type createLayout( const ViewCtorProp<P...> & arg_prop, const typename Traits::array_layout& layout )
252  {
253  using Layout = typename Traits::array_layout;
254 
255  Layout l( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
256  , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
257  , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
258  , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
259  , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
260  , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
261  , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
262  , layout.dimension[7] != unspecified ? layout.dimension[7] : 1 );
263 
264  enum { test_traits_check = Kokkos::Impl::check_has_common_view_alloc_prop< P... >::value };
265  if (test_traits_check == true) {
266  l.dimension[7] = compute_fad_dim_from_alloc_prop<P...>::eval(arg_prop);
267  }
268  else {
269  const unsigned fad_dim = computeRank(layout);
270  const size_t fad_size = layout.dimension[fad_dim];
271  l.dimension[fad_dim] = 1;
272  l.dimension[7] = fad_size;
273  }
274 
275  return l;
276  }
277 
278  // If fad_dim is stored in ViewCtorProp
279  //LayoutStride
280  template <typename Traits, typename ... P>
281  KOKKOS_INLINE_FUNCTION
282  static typename std::enable_if< (std::is_same<typename Traits::array_layout , Kokkos::LayoutStride>::value) , typename Traits::array_layout>::type createLayout( const ViewCtorProp<P...> & arg_prop, const typename Traits::array_layout& layout )
283  {
284  using Layout = typename Traits::array_layout;
285 
286  Layout l( layout.dimension[0] != unspecified ? layout.dimension[0] : 1
287  , layout.stride[0]
288  , layout.dimension[1] != unspecified ? layout.dimension[1] : 1
289  , layout.stride[1]
290  , layout.dimension[2] != unspecified ? layout.dimension[2] : 1
291  , layout.stride[2]
292  , layout.dimension[3] != unspecified ? layout.dimension[3] : 1
293  , layout.stride[3]
294  , layout.dimension[4] != unspecified ? layout.dimension[4] : 1
295  , layout.stride[4]
296  , layout.dimension[5] != unspecified ? layout.dimension[5] : 1
297  , layout.stride[5]
298  , layout.dimension[6] != unspecified ? layout.dimension[6] : 1
299  , layout.stride[6]
300  , layout.dimension[7] != unspecified ? layout.dimension[7] : 1
301  , layout.stride[7]
302  );
303 
304  enum { test_traits_check = Kokkos::Impl::check_has_common_view_alloc_prop< P... >::value };
305  const unsigned fad_dim = computeRank(layout);
306  if (test_traits_check == true) {
307  l.dimension[fad_dim] = 1;
308  l.dimension[7] = compute_fad_dim_from_alloc_prop<P...>::eval(arg_prop);
309  }
310  else {
311  const size_t fad_size = layout.dimension[fad_dim];
312  l.dimension[fad_dim] = 1;
313  l.dimension[7] = fad_size;
314  }
315  const size_t fad_stride = layout.stride[fad_dim];
316  l.stride[fad_dim] = 0;
317  l.stride[7] = fad_stride;
318 
319  return l;
320  }
321 
322  // Create a view from the given dimension arguments.
323  // This is only necessary because the shmem constructor doesn't take a layout.
324  template <typename ViewType, typename ViewArg>
325  static ViewType createView( const ViewArg& arg
326  , const size_t N0
327  , const size_t N1
328  , const size_t N2
329  , const size_t N3
330  , const size_t N4
331  , const size_t N5
332  , const size_t N6
333  , const size_t N7 )
334  {
335  typename ViewType::array_layout l( N0, N1, N2, N3, N4, N5, N6, N7 );
336  typename ViewType::array_layout l_fad = createLayout(l);
337  return ViewType( arg
338  , l_fad.dimension[0]
339  , l_fad.dimension[1]
340  , l_fad.dimension[2]
341  , l_fad.dimension[3]
342  , l_fad.dimension[4]
343  , l_fad.dimension[5]
344  , l_fad.dimension[6]
345  , l_fad.dimension[7] );
346  }
347 
348 };
349 
350 }} // namespace Kokkos::Impl
351 
352 namespace Kokkos {
353 namespace Impl {
354 
355 template <unsigned> struct AssignDim7 {
356  template <typename Dst>
357  KOKKOS_INLINE_FUNCTION
358  static void eval(Dst& dst, const size_t src_dim) {}
359 };
360 template <> struct AssignDim7<0u> {
361  template <typename Dst>
362  KOKKOS_INLINE_FUNCTION
363  static void eval(Dst& dst, const size_t src_dim) {
364  dst.N7 = src_dim;
365  }
366 };
367 
368 // Utility class that handles calculation of the stride in Fad subview
369 template <unsigned,unsigned> struct AssignFadDimStride {};
370 template <unsigned StaticDim> struct AssignFadDimStride<0u,StaticDim> {
371  template <typename Src, typename Dst>
372  KOKKOS_INLINE_FUNCTION
373  static void eval(Dst& dst, const Src& src) {
374  dst.m_stride.S0 = 0 ;
375  dst.m_stride.S1 = 0 ;
376  dst.m_stride.S2 = 0 ;
377  dst.m_stride.S3 = 0 ;
378  dst.m_stride.S4 = 0 ;
379  dst.m_stride.S5 = 0 ;
380  dst.m_stride.S6 = 0 ;
381  dst.m_stride.S7 = src.m_stride.S0 ;
382 
383  dst.m_dim.N0 = 1 ;
384  dst.m_dim.N1 = 1 ;
385  dst.m_dim.N2 = 1 ;
386  dst.m_dim.N3 = 1 ;
387  dst.m_dim.N4 = 1 ;
388  dst.m_dim.N5 = 1 ;
389  dst.m_dim.N6 = 1 ;
390  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N0 );
391  }
392 };
393 template <unsigned StaticDim> struct AssignFadDimStride<1u,StaticDim> {
394  template <typename Src, typename Dst>
395  KOKKOS_INLINE_FUNCTION
396  static void eval(Dst& dst, const Src& src) {
397  dst.m_stride.S0 = src.m_stride.S0 ;
398  dst.m_stride.S1 = 0 ;
399  dst.m_stride.S2 = 0 ;
400  dst.m_stride.S3 = 0 ;
401  dst.m_stride.S4 = 0 ;
402  dst.m_stride.S5 = 0 ;
403  dst.m_stride.S6 = 0 ;
404  dst.m_stride.S7 = src.m_stride.S1 ;
405 
406  dst.m_dim.N0 = src.m_dim.N0 ;
407  dst.m_dim.N1 = 1 ;
408  dst.m_dim.N2 = 1 ;
409  dst.m_dim.N3 = 1 ;
410  dst.m_dim.N4 = 1 ;
411  dst.m_dim.N5 = 1 ;
412  dst.m_dim.N6 = 1 ;
413  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N1 );
414  }
415 };
416 template <unsigned StaticDim> struct AssignFadDimStride<2u,StaticDim> {
417  template <typename Src, typename Dst>
418  KOKKOS_INLINE_FUNCTION
419  static void eval(Dst& dst, const Src& src) {
420  dst.m_stride.S0 = src.m_stride.S0 ;
421  dst.m_stride.S1 = src.m_stride.S1 ;
422  dst.m_stride.S2 = 0 ;
423  dst.m_stride.S3 = 0 ;
424  dst.m_stride.S4 = 0 ;
425  dst.m_stride.S5 = 0 ;
426  dst.m_stride.S6 = 0 ;
427  dst.m_stride.S7 = src.m_stride.S2 ;
428 
429  dst.m_dim.N0 = src.m_dim.N0 ;
430  dst.m_dim.N1 = src.m_dim.N1 ;
431  dst.m_dim.N2 = 1 ;
432  dst.m_dim.N3 = 1 ;
433  dst.m_dim.N4 = 1 ;
434  dst.m_dim.N5 = 1 ;
435  dst.m_dim.N6 = 1 ;
436  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N2 );
437  }
438 };
439 template <unsigned StaticDim> struct AssignFadDimStride<3u,StaticDim> {
440  template <typename Src, typename Dst>
441  KOKKOS_INLINE_FUNCTION
442  static void eval(Dst& dst, const Src& src) {
443  dst.m_stride.S0 = src.m_stride.S0 ;
444  dst.m_stride.S1 = src.m_stride.S1 ;
445  dst.m_stride.S2 = src.m_stride.S2 ;
446  dst.m_stride.S3 = 0 ;
447  dst.m_stride.S4 = 0 ;
448  dst.m_stride.S5 = 0 ;
449  dst.m_stride.S6 = 0 ;
450  dst.m_stride.S7 = src.m_stride.S3 ;
451 
452  dst.m_dim.N0 = src.m_dim.N0 ;
453  dst.m_dim.N1 = src.m_dim.N1 ;
454  dst.m_dim.N2 = src.m_dim.N2 ;
455  dst.m_dim.N3 = 1 ;
456  dst.m_dim.N4 = 1 ;
457  dst.m_dim.N5 = 1 ;
458  dst.m_dim.N6 = 1 ;
459  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N3 );
460  }
461 };
462 template <unsigned StaticDim> struct AssignFadDimStride<4u,StaticDim> {
463  template <typename Src, typename Dst>
464  KOKKOS_INLINE_FUNCTION
465  static void eval(Dst& dst, const Src& src) {
466  dst.m_stride.S0 = src.m_stride.S0 ;
467  dst.m_stride.S1 = src.m_stride.S1 ;
468  dst.m_stride.S2 = src.m_stride.S2 ;
469  dst.m_stride.S3 = src.m_stride.S3 ;
470  dst.m_stride.S4 = 0 ;
471  dst.m_stride.S5 = 0 ;
472  dst.m_stride.S6 = 0 ;
473  dst.m_stride.S7 = src.m_stride.S4 ;
474 
475  dst.m_dim.N0 = src.m_dim.N0 ;
476  dst.m_dim.N1 = src.m_dim.N1 ;
477  dst.m_dim.N2 = src.m_dim.N2 ;
478  dst.m_dim.N3 = src.m_dim.N3 ;
479  dst.m_dim.N4 = 1 ;
480  dst.m_dim.N5 = 1 ;
481  dst.m_dim.N6 = 1 ;
482  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N4 );
483  }
484 };
485 template <unsigned StaticDim> struct AssignFadDimStride<5u,StaticDim> {
486  template <typename Src, typename Dst>
487  KOKKOS_INLINE_FUNCTION
488  static void eval(Dst& dst, const Src& src) {
489  dst.m_stride.S0 = src.m_stride.S0 ;
490  dst.m_stride.S1 = src.m_stride.S1 ;
491  dst.m_stride.S2 = src.m_stride.S2 ;
492  dst.m_stride.S3 = src.m_stride.S3 ;
493  dst.m_stride.S4 = src.m_stride.S4 ;
494  dst.m_stride.S5 = 0 ;
495  dst.m_stride.S6 = 0 ;
496  dst.m_stride.S7 = src.m_stride.S5 ;
497 
498  dst.m_dim.N0 = src.m_dim.N0 ;
499  dst.m_dim.N1 = src.m_dim.N1 ;
500  dst.m_dim.N2 = src.m_dim.N2 ;
501  dst.m_dim.N3 = src.m_dim.N3 ;
502  dst.m_dim.N4 = src.m_dim.N4 ;
503  dst.m_dim.N5 = 1 ;
504  dst.m_dim.N6 = 1 ;
505  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N5 );
506  }
507 };
508 template <unsigned StaticDim> struct AssignFadDimStride<6u,StaticDim> {
509  template <typename Src, typename Dst>
510  KOKKOS_INLINE_FUNCTION
511  static void eval(Dst& dst, const Src& src) {
512  dst.m_stride.S0 = src.m_stride.S0 ;
513  dst.m_stride.S1 = src.m_stride.S1 ;
514  dst.m_stride.S2 = src.m_stride.S2 ;
515  dst.m_stride.S3 = src.m_stride.S3 ;
516  dst.m_stride.S4 = src.m_stride.S4 ;
517  dst.m_stride.S5 = src.m_stride.S5 ;
518  dst.m_stride.S6 = 0 ;
519  dst.m_stride.S7 = src.m_stride.S6 ;
520 
521  dst.m_dim.N0 = src.m_dim.N0 ;
522  dst.m_dim.N1 = src.m_dim.N1 ;
523  dst.m_dim.N2 = src.m_dim.N2 ;
524  dst.m_dim.N3 = src.m_dim.N3 ;
525  dst.m_dim.N4 = src.m_dim.N4 ;
526  dst.m_dim.N5 = src.m_dim.N5 ;
527  dst.m_dim.N6 = 1 ;
528  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N6 );
529  }
530 };
531 template <unsigned StaticDim> struct AssignFadDimStride<7u,StaticDim> {
532  template <typename Src, typename Dst>
533  KOKKOS_INLINE_FUNCTION
534  static void eval(Dst& dst, const Src& src) {
535  dst.m_stride.S0 = src.m_stride.S0 ;
536  dst.m_stride.S1 = src.m_stride.S1 ;
537  dst.m_stride.S2 = src.m_stride.S2 ;
538  dst.m_stride.S3 = src.m_stride.S3 ;
539  dst.m_stride.S4 = src.m_stride.S4 ;
540  dst.m_stride.S5 = src.m_stride.S5 ;
541  dst.m_stride.S6 = src.m_stride.S6 ;
542  dst.m_stride.S7 = src.m_stride.S7 ;
543 
544  dst.m_dim.N0 = src.m_dim.N0 ;
545  dst.m_dim.N1 = src.m_dim.N1 ;
546  dst.m_dim.N2 = src.m_dim.N2 ;
547  dst.m_dim.N3 = src.m_dim.N3 ;
548  dst.m_dim.N4 = src.m_dim.N4 ;
549  dst.m_dim.N5 = src.m_dim.N5 ;
550  dst.m_dim.N6 = src.m_dim.N6 ;
551  AssignDim7<StaticDim>::eval( dst.m_dim, src.m_dim.N7 );
552  }
553 };
554 
555 // Specializations for subdynrankview
556 template< class SrcTraits , class ... Args >
557 struct ViewMapping
558  < typename std::enable_if<(
559  std::is_same< typename SrcTraits::specialize ,
560  Kokkos::Impl::ViewSpecializeSacadoFad >::value
561  &&
562  (
563  std::is_same< typename SrcTraits::array_layout
564  , Kokkos::LayoutLeft >::value ||
565  std::is_same< typename SrcTraits::array_layout
566  , Kokkos::LayoutRight >::value ||
567  std::is_same< typename SrcTraits::array_layout
568  , Kokkos::LayoutStride >::value
569  )
570  ), Kokkos::Impl::DynRankSubviewTag >::type
571  , SrcTraits
572  , Args ... >
573 {
574 private:
575 
576  enum
577  { RZ = false
578  , R0 = bool(is_integral_extent<0,Args...>::value)
579  , R1 = bool(is_integral_extent<1,Args...>::value)
580  , R2 = bool(is_integral_extent<2,Args...>::value)
581  , R3 = bool(is_integral_extent<3,Args...>::value)
582  , R4 = bool(is_integral_extent<4,Args...>::value)
583  , R5 = bool(is_integral_extent<5,Args...>::value)
584  , R6 = bool(is_integral_extent<6,Args...>::value)
585  };
586 
587  enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
588  + unsigned(R4) + unsigned(R5) + unsigned(R6) };
589 
590  typedef Kokkos::LayoutStride array_layout ;
591 
592  typedef typename SrcTraits::value_type value_type ;
593 
594  typedef value_type******* data_type ;
595 
596 public:
597 
598  typedef Kokkos::ViewTraits
599  < data_type
600  , array_layout
601  , typename SrcTraits::device_type
602  , typename SrcTraits::memory_traits > traits_type ;
603 
604  typedef Kokkos::View
605  < data_type
606  , array_layout
607  , typename SrcTraits::device_type
608  , typename SrcTraits::memory_traits > type ;
609 
610 
611  template< class MemoryTraits >
612  struct apply {
613 
614  static_assert( Kokkos::is_memory_traits< MemoryTraits >::value , "" );
615 
616  typedef Kokkos::ViewTraits
617  < data_type
618  , array_layout
619  , typename SrcTraits::device_type
620  , MemoryTraits > traits_type ;
621 
622  typedef Kokkos::View
623  < data_type
624  , array_layout
625  , typename SrcTraits::device_type
626  , MemoryTraits > type ;
627  };
628 
629  template < class Arg0 = int, class Arg1 = int, class Arg2 = int, class Arg3 = int, class Arg4 = int, class Arg5 = int, class Arg6 = int >
630  struct ExtentGenerator {
631  template <typename dimension>
632  KOKKOS_INLINE_FUNCTION
633  static SubviewExtents< 7 , rank > generator ( const dimension & dim , Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(), Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(), Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6() )
634  {
635  return SubviewExtents< 7 , rank >( dim , arg0 , arg1 , arg2 , arg3 ,
636  arg4 , arg5 , arg6 );
637  }
638  };
639 
640  template < class Arg0 = int, class Arg1 = int, class Arg2 = int, class Arg3 = int, class Arg4 = int, class Arg5 = int, class Arg6 = int >
641  struct ArrayExtentGenerator {
642  template <typename dimension>
643  KOKKOS_INLINE_FUNCTION
644  static SubviewExtents< 8 , rank+1 > generator ( const dimension & dim , Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(), Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(), Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6() )
645  {
646  return SubviewExtents< 8 , rank+1 >( dim , arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , Kokkos::ALL() );
647  }
648  };
649 
650  typedef DynRankView< value_type , array_layout , typename SrcTraits::device_type , typename SrcTraits::memory_traits > ret_type;
651 
652  template < typename T , class ... P >
653  KOKKOS_INLINE_FUNCTION
654  static ret_type subview( const unsigned src_rank , Kokkos::DynRankView< T , P...> const & src , Args ... args )
655  {
656 
657  typedef ViewMapping< traits_type, typename traits_type::specialize> DstType ;
658  typedef ViewMapping< SrcTraits, typename SrcTraits::specialize> SrcType;
659  enum { FadStaticDim = SrcType::FadStaticDimension };
660  typedef typename std::conditional< (rank==0) , ViewDimension<>
661  , typename std::conditional< (rank==1) , ViewDimension<0>
662  , typename std::conditional< (rank==2) , ViewDimension<0,0>
663  , typename std::conditional< (rank==3) , ViewDimension<0,0,0>
664  , typename std::conditional< (rank==4) , ViewDimension<0,0,0,0>
665  , typename std::conditional< (rank==5) , ViewDimension<0,0,0,0,0>
666  , typename std::conditional< (rank==6) , ViewDimension<0,0,0,0,0,0>
667  , ViewDimension<0,0,0,0,0,0,0>
668  >::type >::type >::type >::type >::type >::type >::type DstDimType ;
669  typedef typename std::conditional< (rank==0) , ViewDimension<FadStaticDim>
670  , typename std::conditional< (rank==1) , ViewDimension<0,FadStaticDim>
671  , typename std::conditional< (rank==2) , ViewDimension<0,0,FadStaticDim>
672  , typename std::conditional< (rank==3) , ViewDimension<0,0,0,FadStaticDim>
673  , typename std::conditional< (rank==4) , ViewDimension<0,0,0,0,FadStaticDim>
674  , typename std::conditional< (rank==5) , ViewDimension<0,0,0,0,0,FadStaticDim>
675  , typename std::conditional< (rank==6) , ViewDimension<0,0,0,0,0,0,FadStaticDim>
676  , ViewDimension<0,0,0,0,0,0,0,FadStaticDim>
677  >::type >::type >::type >::type >::type >::type >::type DstArrayDimType ;
678 
679  typedef ViewOffset< DstDimType , Kokkos::LayoutStride > dst_offset_type ;
680  typedef ViewOffset< DstArrayDimType , Kokkos::LayoutStride > dst_array_offset_type ;
681  typedef typename DstType::handle_type dst_handle_type ;
682 
683  ret_type dst ;
684 
685  const SubviewExtents< 7 , rank > extents =
686  ExtentGenerator< Args ... >::generator(
687  src.m_map.m_impl_offset.m_dim , args... ) ;
688  const SubviewExtents< 8 , rank+1 > array_extents =
689  ArrayExtentGenerator< Args ... >::generator(
690  src.m_map.m_array_offset.m_dim , args... ) ;
691 
692  dst_offset_type tempdst( src.m_map.m_impl_offset , extents ) ;
693  dst_array_offset_type temparraydst(
694  src.m_map.m_array_offset , array_extents ) ;
695 
696  dst.m_track = src.m_track ;
697 
698  dst.m_map.m_impl_offset.m_dim.N0 = tempdst.m_dim.N0 ;
699  dst.m_map.m_impl_offset.m_dim.N1 = tempdst.m_dim.N1 ;
700  dst.m_map.m_impl_offset.m_dim.N2 = tempdst.m_dim.N2 ;
701  dst.m_map.m_impl_offset.m_dim.N3 = tempdst.m_dim.N3 ;
702  dst.m_map.m_impl_offset.m_dim.N4 = tempdst.m_dim.N4 ;
703  dst.m_map.m_impl_offset.m_dim.N5 = tempdst.m_dim.N5 ;
704  dst.m_map.m_impl_offset.m_dim.N6 = tempdst.m_dim.N6 ;
705 
706  dst.m_map.m_impl_offset.m_stride.S0 = tempdst.m_stride.S0;
707  dst.m_map.m_impl_offset.m_stride.S1 = tempdst.m_stride.S1;
708  dst.m_map.m_impl_offset.m_stride.S2 = tempdst.m_stride.S2;
709  dst.m_map.m_impl_offset.m_stride.S3 = tempdst.m_stride.S3;
710  dst.m_map.m_impl_offset.m_stride.S4 = tempdst.m_stride.S4;
711  dst.m_map.m_impl_offset.m_stride.S5 = tempdst.m_stride.S5;
712  dst.m_map.m_impl_offset.m_stride.S6 = tempdst.m_stride.S6;
713 
714  // Move last non-unit dim and stride to N7/S7 since subview collapses
715  // out all singleton dimensions between the last rank and the fad
716  // dimension. Equivalent to:
717  // dst.m_map.m_impl_offset.m_dim.N* = tempdst.m_dim.N*
718  // dst.m_map.m_impl_offset.m_dim.N7 = tempdst.m_dim.N{rank}
719  // dst.m_map.m_impl_offset.m_stride.S* = tempdst.m_stride.S*
720  // dst.m_map.m_impl_offset.m_stride.S7 = tempdst.m_stride.S{rank}
721  AssignFadDimStride<rank,FadStaticDim>::eval( dst.m_map.m_array_offset, temparraydst );
722 
723  dst.m_track = src.m_track ;
724 
725  dst.m_map.m_impl_handle =
726  dst_handle_type(
727  src.m_map.m_impl_handle +
728  src.m_map.m_array_offset( array_extents.domain_offset(0)
729  , array_extents.domain_offset(1)
730  , array_extents.domain_offset(2)
731  , array_extents.domain_offset(3)
732  , array_extents.domain_offset(4)
733  , array_extents.domain_offset(5)
734  , array_extents.domain_offset(6)
735  , array_extents.domain_offset(7)
736  ) );
737 
738  dst.m_map.m_fad_size = src.m_map.m_fad_size;
739  dst.m_map.m_fad_stride = src.m_map.m_fad_stride.value;
740 
741  dst.m_rank = ( src_rank > 0 ? unsigned(R0) : 0 )
742  + ( src_rank > 1 ? unsigned(R1) : 0 )
743  + ( src_rank > 2 ? unsigned(R2) : 0 )
744  + ( src_rank > 3 ? unsigned(R3) : 0 )
745  + ( src_rank > 4 ? unsigned(R4) : 0 )
746  + ( src_rank > 5 ? unsigned(R5) : 0 )
747  + ( src_rank > 6 ? unsigned(R6) : 0 ) ;
748 
749  return dst ;
750  }
751 };
752 
753 // ViewMapping for copy and copy-assign from View to DynRankView
754 template <unsigned> struct AssignFadDim7 {
755  template <typename Src, typename Dst>
756  KOKKOS_INLINE_FUNCTION
757  static void eval(Dst& dst, const Src& src , const unsigned dim ) {}
758 };
759 
760 template <> struct AssignFadDim7<0u> {
761  template <typename Src, typename Dst>
762  KOKKOS_INLINE_FUNCTION
763  static void eval(Dst& dst, const Src& src , const unsigned dim ) {
764  dst.m_dim.N7 = src.m_dim.extent(dim);
765  }
766 };
767 
768 // Copy a layout, moving the Fad dimension to the last
769 template <typename Layout>
770 KOKKOS_INLINE_FUNCTION
771 static Layout
772 permute_fad_layout(const Layout& src, const unsigned rank) {
773  Layout dst = src;
774  dst.dimension[rank] = 1;
775  dst.dimension[7] = src.dimension[rank];
776  return dst;
777 }
778 KOKKOS_INLINE_FUNCTION
779 static LayoutStride
780 permute_fad_layout(const LayoutStride& src, const unsigned rank) {
781  LayoutStride dst = src;
782  dst.dimension[rank] = 1;
783  dst.stride[rank] = 1;
784  dst.dimension[7] = src.dimension[rank];
785  dst.stride[7] = src.stride[rank];
786  return dst;
787 }
788 
793 template< class DstTraits , class SrcTraits >
794 class ViewMapping< DstTraits , SrcTraits ,
795  typename std::enable_if<(
796  Kokkos::Impl::MemorySpaceAccess
797  < typename DstTraits::memory_space
798  , typename SrcTraits::memory_space >::assignable
799  &&
800  // Destination view has FAD only
801  std::is_same< typename DstTraits::specialize
802  , Kokkos::Impl::ViewSpecializeSacadoFad >::value
803  &&
804  // Source view has FAD only
805  std::is_same< typename SrcTraits::specialize
806  , Kokkos::Impl::ViewSpecializeSacadoFad >::value
807  ), Kokkos::Impl::ViewToDynRankViewTag >::type >
808 {
809 public:
810 
811  enum { is_assignable = true };
812  enum { is_assignable_data_type = true };
813 
814  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
815  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
816  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcFadType ;
817 
818  template < typename DT , typename ... DP , typename ST , typename ... SP >
819  KOKKOS_INLINE_FUNCTION static
820  void assign( Kokkos::DynRankView< DT , DP... > & dst
821  , const Kokkos::View< ST , SP... >& src )
822  {
823  static_assert(
824  (
825  std::is_same< typename DstTraits::array_layout
826  , Kokkos::LayoutLeft >::value ||
827  std::is_same< typename DstTraits::array_layout
828  , Kokkos::LayoutRight >::value ||
829  std::is_same< typename DstTraits::array_layout
830  , Kokkos::LayoutStride >::value
831  )
832  &&
833  (
834  std::is_same< typename SrcTraits::array_layout
835  , Kokkos::LayoutLeft >::value ||
836  std::is_same< typename SrcTraits::array_layout
837  , Kokkos::LayoutRight >::value ||
838  std::is_same< typename SrcTraits::array_layout
839  , Kokkos::LayoutStride >::value
840  )
841  , "View of FAD requires LayoutLeft, LayoutRight, or LayoutStride" );
842 
843  static_assert(
844  std::is_same< typename DstTraits::value_type
845  , typename SrcTraits::value_type >::value ||
846  std::is_same< typename DstTraits::value_type
847  , typename SrcTraits::const_value_type >::value ,
848  "View assignment must have same value type or const = non-const" );
849 
850  typedef typename DstType::offset_type dst_offset_type;
851  typedef typename DstType::array_offset_type dst_array_offset_type;
852  dst.m_map.m_array_offset =
853  dst_array_offset_type(std::integral_constant<unsigned,0>(),
854  permute_fad_layout(src.m_map.m_array_offset.layout(),
855  SrcTraits::rank) );
856  dst.m_map.m_impl_offset =
857  dst_offset_type(std::integral_constant<unsigned,0>(),
858  src.m_map.m_impl_offset.layout() );
859 
860  dst.m_map.m_impl_handle = src.m_map.m_impl_handle ;
861  dst.m_rank = src.rank ;
862 
863  dst.m_map.m_fad_size = src.m_map.m_fad_size ;
864  dst.m_map.m_fad_stride = src.m_map.m_fad_stride ;
865  }
866 };
867 
872 template< class DstTraits , class SrcTraits >
873 class ViewMapping< DstTraits , SrcTraits ,
874  typename std::enable_if<(
875  Kokkos::Impl::MemorySpaceAccess
876  < typename DstTraits::memory_space
877  , typename SrcTraits::memory_space >::assignable
878  &&
879  // Destination view has ordinary
880  std::is_same< typename DstTraits::specialize , void >::value
881  &&
882  // Source view has FAD only
883  std::is_same< typename SrcTraits::specialize
884  , ViewSpecializeSacadoFad >::value
885  ), Kokkos::Impl::ViewToDynRankViewTag >::type >
886 {
887 public:
888 
889  enum { is_assignable = true };
890  enum { is_assignable_data_type = true };
891 
892  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
893  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
894  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcFadType ;
895 
896  template < typename DT , typename ... DP , typename ST , typename ... SP >
897  KOKKOS_INLINE_FUNCTION static
898  void assign( Kokkos::DynRankView< DT , DP... > & dst
899  , const Kokkos::View< ST , SP... >& src )
900  {
901  static_assert(
902  (
903  std::is_same< typename DstTraits::array_layout
904  , Kokkos::LayoutLeft >::value ||
905  std::is_same< typename DstTraits::array_layout
906  , Kokkos::LayoutRight >::value ||
907  std::is_same< typename DstTraits::array_layout
908  , Kokkos::LayoutStride >::value
909  )
910  &&
911  (
912  std::is_same< typename SrcTraits::array_layout
913  , Kokkos::LayoutLeft >::value ||
914  std::is_same< typename SrcTraits::array_layout
915  , Kokkos::LayoutRight >::value ||
916  std::is_same< typename SrcTraits::array_layout
917  , Kokkos::LayoutStride >::value
918  )
919  , "View of FAD requires LayoutLeft, LayoutRight, or LayoutStride" );
920 
921  static_assert(
922  std::is_same< typename DstTraits::value_type
923  , typename SrcTraits::value_type >::value ||
924  std::is_same< typename DstTraits::value_type
925  , typename SrcTraits::const_value_type >::value ,
926  "View assignment must have same value type or const = non-const" );
927 
928  typedef typename DstType::offset_type dst_offset_type;
929  dst.m_map.m_impl_offset =
930  dst_offset_type(std::integral_constant<unsigned,0>(),
931  permute_fad_layout(src.m_map.m_array_offset.layout(),
932  SrcTraits::rank));
933 
934  dst.m_map.m_impl_handle = src.m_map.m_impl_handle ;
935  dst.m_rank = src.Rank ;
936  }
937 };
938 
939 }} //end Kokkos::Impl
940 
941 namespace Kokkos {
942 
943 template <typename T, typename ... P>
944 struct is_dynrankview_fad< DynRankView<T,P...> > {
945  typedef DynRankView<T,P...> view_type;
946  static const bool value =
947  std::is_same< typename view_type::traits::specialize,
948  Impl::ViewSpecializeSacadoFad >::value ||
949  std::is_same< typename view_type::traits::specialize,
950  Impl::ViewSpecializeSacadoFadContiguous >::value;
951 };
952 
953 template <typename T, typename ... P>
954 struct is_dynrankview_fad_contiguous< DynRankView<T,P...> > {
955  typedef DynRankView<T,P...> view_type;
956  static const bool value =
957  std::is_same< typename view_type::traits::specialize,
958  Impl::ViewSpecializeSacadoFadContiguous >::value;
959 };
960 
961 template <typename T, typename ... P>
962 KOKKOS_INLINE_FUNCTION
963 constexpr typename
964 std::enable_if< is_dynrankview_fad< DynRankView<T,P...> >::value, unsigned >::type
965 dimension_scalar(const DynRankView<T,P...>& view) {
966 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
967  return view.implementation_map().dimension_scalar();
968 #else
969  return view.impl_map().dimension_scalar();
970 #endif
971 }
972 
973 
974 // Overload of deep_copy for Fad views intializing to a constant scalar
975 template< class DT, class ... DP >
976 void deep_copy(
977  const DynRankView<DT,DP...> & view ,
978  const typename Sacado::ScalarType< typename DynRankView<DT,DP...>::value_type >::type & value
979  , typename std::enable_if<(
980  std::is_same< typename ViewTraits<DT,DP...>::specialize
981  , Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
982  std::is_same< typename ViewTraits<DT,DP...>::specialize
983  , Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value
984  )>::type * = 0 )
985 {
986  static_assert(
987  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
988  typename ViewTraits<DT,DP...>::non_const_value_type >::value
989  , "Can only deep copy into non-const type" );
990 
991  switch(view.rank()) {
992  case 0: deep_copy(Impl::as_view_of_rank_n<0>(view), value); break;
993  case 1: deep_copy(Impl::as_view_of_rank_n<1>(view), value); break;
994  case 2: deep_copy(Impl::as_view_of_rank_n<2>(view), value); break;
995  case 3: deep_copy(Impl::as_view_of_rank_n<3>(view), value); break;
996  case 4: deep_copy(Impl::as_view_of_rank_n<4>(view), value); break;
997  case 5: deep_copy(Impl::as_view_of_rank_n<5>(view), value); break;
998  case 6: deep_copy(Impl::as_view_of_rank_n<6>(view), value); break;
999  case 7: deep_copy(Impl::as_view_of_rank_n<7>(view), value); break;
1000  }
1001 }
1002 
1003 // Overload of deep_copy for Fad views intializing to a constant Fad
1004 template< class DT, class ... DP >
1005 void deep_copy(
1006  const DynRankView<DT,DP...> & view ,
1007  const typename DynRankView<DT,DP...>::value_type & value
1008  , typename std::enable_if<(
1009  std::is_same< typename ViewTraits<DT,DP...>::specialize
1010  , Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1011  std::is_same< typename ViewTraits<DT,DP...>::specialize
1012  , Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value
1013  )>::type * = 0 )
1014 {
1015  static_assert(
1016  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
1017  typename ViewTraits<DT,DP...>::non_const_value_type >::value
1018  , "Can only deep copy into non-const type" );
1019 
1020  switch(view.rank()) {
1021  case 0: deep_copy(Impl::as_view_of_rank_n<0>(view), value); break;
1022  case 1: deep_copy(Impl::as_view_of_rank_n<1>(view), value); break;
1023  case 2: deep_copy(Impl::as_view_of_rank_n<2>(view), value); break;
1024  case 3: deep_copy(Impl::as_view_of_rank_n<3>(view), value); break;
1025  case 4: deep_copy(Impl::as_view_of_rank_n<4>(view), value); break;
1026  case 5: deep_copy(Impl::as_view_of_rank_n<5>(view), value); break;
1027  case 6: deep_copy(Impl::as_view_of_rank_n<6>(view), value); break;
1028  case 7: deep_copy(Impl::as_view_of_rank_n<7>(view), value); break;
1029  }
1030 }
1031 
1032 template< class DstType , class SrcType >
1033 inline
1034 void deep_copy
1035  ( const DstType & dst
1036  , const SrcType & src
1037  , typename std::enable_if<(
1038  ( std::is_same< typename DstType::traits::specialize
1039  , Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1040  std::is_same< typename DstType::traits::specialize
1041  , Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1042  &&
1043  ( std::is_same< typename SrcType::traits::specialize
1044  , Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1045  std::is_same< typename SrcType::traits::specialize
1046  , Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1047  &&
1048  ( Kokkos::is_dyn_rank_view<DstType>::value || Kokkos::is_dyn_rank_view<SrcType
1049 >::value )
1050  )>::type * = 0 )
1051 {
1052  static_assert(
1053  std::is_same< typename DstType::traits::value_type ,
1054  typename DstType::traits::non_const_value_type >::value
1055  , "deep_copy requires non-const destination type" );
1056 
1057  typedef DstType dst_type ;
1058  typedef SrcType src_type ;
1059 
1060  typedef typename dst_type::execution_space dst_execution_space ;
1061  typedef typename src_type::execution_space src_execution_space ;
1062  typedef typename dst_type::memory_space dst_memory_space ;
1063  typedef typename src_type::memory_space src_memory_space ;
1064 
1065  enum { DstExecCanAccessSrc =
1066  Kokkos::SpaceAccessibility< typename dst_execution_space::memory_space, src_memory_space >::accessible };
1067 
1068  enum { SrcExecCanAccessDst =
1069  Kokkos::SpaceAccessibility< typename src_execution_space::memory_space, dst_memory_space >::accessible };
1070 
1071  if ( (void *) dst.data() != (void*) src.data() ) {
1072 
1073  // Concern: If overlapping views then a parallel copy will be erroneous.
1074  // ...
1075 
1076  // If same type, equal layout, equal dimensions, equal span, and contiguous memory then can byte-wise copy
1077  if ( rank(src) == 0 && rank(dst) == 0 )
1078  {
1079  typedef typename dst_type::value_type::value_type value_type ;
1080  const size_t nbytes = sizeof(value_type) * dst.span() ;
1081  Kokkos::fence();
1082  Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , nbytes );
1083  Kokkos::fence();
1084  }
1085  else if ( std::is_same< typename DstType::traits::value_type ,
1086  typename SrcType::traits::non_const_value_type >::value &&
1087  (
1088  ( std::is_same< typename DstType::traits::array_layout ,
1089  typename SrcType::traits::array_layout >::value
1090  &&
1091  ( std::is_same< typename DstType::traits::array_layout ,
1092  typename Kokkos::LayoutLeft>::value
1093  ||
1094  std::is_same< typename DstType::traits::array_layout ,
1095  typename Kokkos::LayoutRight>::value
1096  )
1097  )
1098  ||
1099  (
1100  rank(dst) == 1
1101  &&
1102  rank(src) == 1
1103  )
1104  ) &&
1105  dst.span_is_contiguous() &&
1106  src.span_is_contiguous() &&
1107  dst.span() == src.span() &&
1108  dst.extent(0) == src.extent(0) &&
1109  dst.extent(1) == src.extent(1) &&
1110  dst.extent(2) == src.extent(2) &&
1111  dst.extent(3) == src.extent(3) &&
1112  dst.extent(4) == src.extent(4) &&
1113  dst.extent(5) == src.extent(5) &&
1114  dst.extent(6) == src.extent(6) &&
1115  dst.extent(7) == src.extent(7) ) {
1116 
1117 // const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span() * dimension_scalar(dst) ;
1118  //const size_t nbytes = sizeof(typename dst_type::scalar_array_type) * dst.span() ;
1119  const size_t nbytes = sizeof(typename dst_type::value_type::value_type) * dst.span() ;
1120  //dst_type::value_type is outer FAD type, dst_type::value_type::value_type is inner FAD type
1121  Kokkos::fence();
1122  Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , nbytes );
1123  Kokkos::fence();
1124  }
1125  else if ( std::is_same< typename DstType::traits::value_type ,
1126  typename SrcType::traits::non_const_value_type >::value &&
1127  (
1128  ( std::is_same< typename DstType::traits::array_layout ,
1129  typename SrcType::traits::array_layout >::value
1130  &&
1131  std::is_same< typename DstType::traits::array_layout ,
1132  typename Kokkos::LayoutStride>::value
1133  )
1134  ||
1135  (
1136  rank(dst) == 1
1137  &&
1138  rank(src) == 1
1139  )
1140  ) &&
1141  dst.span_is_contiguous() &&
1142  src.span_is_contiguous() &&
1143  dst.span() == src.span() &&
1144  dst.extent(0) == src.extent(0) &&
1145  dst.extent(1) == src.extent(1) &&
1146  dst.extent(2) == src.extent(2) &&
1147  dst.extent(3) == src.extent(3) &&
1148  dst.extent(4) == src.extent(4) &&
1149  dst.extent(5) == src.extent(5) &&
1150  dst.extent(6) == src.extent(6) &&
1151  dst.extent(7) == src.extent(7) &&
1152 #if KOKKOS_VERSION >= 40799
1153  dst.stride(0) == src.stride(0) &&
1154  dst.stride(1) == src.stride(1) &&
1155  dst.stride(2) == src.stride(2) &&
1156  dst.stride(3) == src.stride(3) &&
1157  dst.stride(4) == src.stride(4) &&
1158  dst.stride(5) == src.stride(5) &&
1159  dst.stride(6) == src.stride(6) &&
1160  dst.stride(7) == src.stride(7)
1161 #else
1162  dst.stride_0() == src.stride_0() &&
1163  dst.stride_1() == src.stride_1() &&
1164  dst.stride_2() == src.stride_2() &&
1165  dst.stride_3() == src.stride_3() &&
1166  dst.stride_4() == src.stride_4() &&
1167  dst.stride_5() == src.stride_5() &&
1168  dst.stride_6() == src.stride_6() &&
1169  dst.stride_7() == src.stride_7()
1170 #endif
1171  ) {
1172 
1173  const size_t nbytes = sizeof(typename dst_type::value_type::value_type) * dst.span() ;
1174  Kokkos::fence();
1175  Kokkos::Impl::DeepCopy< dst_memory_space , src_memory_space >( dst.data() , src.data() , nbytes );
1176  Kokkos::fence();
1177  }
1178  else if ( DstExecCanAccessSrc ) {
1179  // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
1180  Kokkos::fence();
1181  Kokkos::Impl::DynRankViewRemap< dst_type , src_type >( dst , src );
1182  Kokkos::fence();
1183  }
1184  else if ( SrcExecCanAccessDst ) {
1185  // Copying data between views in accessible memory spaces and either non-contiguous or incompatible shape.
1186  Kokkos::fence();
1187  Kokkos::Impl::DynRankViewRemap< dst_type , src_type , src_execution_space >( dst , src );
1188  Kokkos::fence();
1189  }
1190  else {
1191  Kokkos::Impl::throw_runtime_exception("deep_copy given views that would require a temporary allocation");
1192  }
1193  }
1194  else {
1195  Kokkos::fence();
1196  }
1197 }
1198 
1199 template< class T , class ... P >
1200 inline
1201 typename Kokkos::DynRankView<T,P...>::host_mirror_type
1202 create_mirror( const Kokkos::DynRankView<T,P...> & src
1203  , typename std::enable_if<
1204  ( std::is_same< typename ViewTraits<T,P...>::specialize ,
1205  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1206  std::is_same< typename ViewTraits<T,P...>::specialize ,
1207  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1208  &&
1209  ! std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
1210  , Kokkos::LayoutStride >::value
1211  >::type *
1212  )
1213 {
1214  typedef DynRankView<T,P...> src_type ;
1215  typedef typename src_type::host_mirror_type dst_type ;
1216 
1217  typename src_type::array_layout layout = src.layout();
1218  layout.dimension[src.rank()] = Kokkos::dimension_scalar(src);
1219 
1220  return dst_type(std::string(src.label()).append("_mirror"),
1221  Impl::reconstructLayout(layout, src.rank()+1));
1222 }
1223 
1224 template< class T , class ... P >
1225 inline
1226 typename Kokkos::DynRankView<T,P...>::host_mirror_type
1227 create_mirror( const Kokkos::DynRankView<T,P...> & src
1228  , typename std::enable_if<
1229  ( std::is_same< typename ViewTraits<T,P...>::specialize ,
1230  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1231  std::is_same< typename ViewTraits<T,P...>::specialize ,
1232  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1233  &&
1234  std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
1235  , Kokkos::LayoutStride >::value
1236  >::type *
1237  )
1238 {
1239  typedef DynRankView<T,P...> src_type ;
1240  typedef typename src_type::host_mirror_type dst_type ;
1241 
1242  Kokkos::LayoutStride layout ;
1243 
1244  layout.dimension[0] = src.extent(0);
1245  layout.dimension[1] = src.extent(1);
1246  layout.dimension[2] = src.extent(2);
1247  layout.dimension[3] = src.extent(3);
1248  layout.dimension[4] = src.extent(4);
1249  layout.dimension[5] = src.extent(5);
1250  layout.dimension[6] = src.extent(6);
1251  layout.dimension[7] = src.extent(7);
1252 
1253  layout.stride[0] = src.stride_0();
1254  layout.stride[1] = src.stride_1();
1255  layout.stride[2] = src.stride_2();
1256  layout.stride[3] = src.stride_3();
1257  layout.stride[4] = src.stride_4();
1258  layout.stride[5] = src.stride_5();
1259  layout.stride[6] = src.stride_6();
1260  layout.stride[7] = src.stride_7();
1261 
1262  layout.dimension[src.rank()] = Kokkos::dimension_scalar(src);
1263 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE
1264  layout.stride[src.rank()] = src.implementation_map().stride_scalar();
1265 #else
1266  layout.stride[src.rank()] = src.impl_map().stride_scalar();
1267 #endif
1268 
1269  return dst_type(std::string(src.label()).append("_mirror"),
1270  Impl::reconstructLayout(layout, src.rank()+1));
1271 }
1272 
1273 template<class Space, class T, class ... P>
1274 typename Impl::MirrorDRViewType<Space,T,P ...>::dest_view_type
1275 create_mirror(const Space& , const Kokkos::DynRankView<T,P...> & src
1276  , typename std::enable_if<
1277  ( std::is_same< typename ViewTraits<T,P...>::specialize ,
1278  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1279  std::is_same< typename ViewTraits<T,P...>::specialize ,
1280  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1281  >::type *) {
1282  typedef DynRankView<T,P...> src_type ;
1283  typename src_type::array_layout layout = src.layout();
1284  layout.dimension[src.rank()] = Kokkos::dimension_scalar(src);
1285  return typename Impl::MirrorDRViewType<Space,T,P ...>::dest_view_type(
1286  src.label(),Impl::reconstructLayout(layout, src.rank()+1));
1287 }
1288 
1289 namespace Impl {
1290 
1291 template <unsigned N, typename T, typename... Args>
1292 KOKKOS_FUNCTION auto as_view_of_rank_n(
1293  DynRankView<T, Args...> v,
1294  typename std::enable_if<
1295  ( std::is_same< typename ViewTraits<T,Args...>::specialize,
1296  Kokkos::Impl::ViewSpecializeSacadoFad >::value ||
1297  std::is_same< typename ViewTraits<T,Args...>::specialize ,
1298  Kokkos::Impl::ViewSpecializeSacadoFadContiguous >::value )
1299  >::type*)
1300 {
1301  if (v.rank() != N) {
1302  KOKKOS_IF_ON_HOST(
1303  const std::string message =
1304  "Converting DynRankView of rank " + std::to_string(v.rank()) +
1305  " to a View of mis-matched rank " + std::to_string(N) + "!";
1306  Kokkos::abort(message.c_str());)
1307  KOKKOS_IF_ON_DEVICE(
1308  Kokkos::abort("Converting DynRankView to a View of mis-matched rank!");)
1309  }
1310 
1311  auto layout = v.impl_map().layout();
1312  layout.dimension[v.rank()] = Kokkos::dimension_scalar(v);
1313  return View<typename RankDataType<T, N>::type, Args...>(
1314  v.data(), Impl::reconstructLayout(layout, v.rank()+1));
1315 }
1316 
1317 }
1318 
1319 } // end Kokkos
1320 #endif
1321 
1322 #endif //defined(HAVE_SACADO_VIEW_SPEC) && !defined(SACADO_DISABLE_FAD_VIEW_SPEC)
1323 
1324 #endif // defined(HAVE_SACADO_KOKKOS)
1325 
1326 #ifndef SACADO_HAS_NEW_KOKKOS_VIEW_IMPL
1327 #include "Kokkos_DynRankView_Fad_Contiguous.hpp"
1328 #endif
1329 
1330 #endif /* #ifndef KOKKOS_DYN_RANK_VIEW_SACADO_FAD_HPP */
Sacado::ScalarType
Base template specification for ScalarType.
Definition: Sacado_Traits.hpp:284
Kokkos::subview
KOKKOS_INLINE_FUNCTION auto subview(const View< D, Kokkos::LayoutContiguous< LayoutSrc, StrideSrc >, P...> &src, Args...args)
Definition: Sacado_Fad_Kokkos_Specialization.hpp:101
T
#define T
Definition: Sacado_rad.hpp:553
value
int value
Definition: gmock-actions_test.cc:1762
N
const int N
Definition: SafeSqrtTests.cpp:17
Kokkos_View_Fad.hpp
fad_dim
const int fad_dim
Definition: advection/common.hpp:12
Sacado_ConfigDefs.h
false
expr expr expr bar false
Definition: Sacado_ELRFad_Ops.hpp:171
Kokkos_DynRankView_Fad_Contiguous.hpp
Generated on Fri Oct 10 2025 07:14:31 for Sacado Package Browser (Single Doxygen Collection) by   doxygen 1.8.5