Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
KokkosExp_View_MP_Vector_Contiguous.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Stokhos Package
5 // Copyright (2009) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Eric T. Phipps (etphipp@sandia.gov).
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 #ifndef KOKKOS_EXPERIMENTAL_VIEW_MP_VECTOR_CONTIGUOUS_HPP
43 #define KOKKOS_EXPERIMENTAL_VIEW_MP_VECTOR_CONTIGUOUS_HPP
44 
45 #include "Sacado_Traits.hpp"
46 #include "Sacado_MP_Vector.hpp"
48 
49 // Only include forward declarations so any overloads appear before they
50 // might be used inside Kokkos
51 #include "Kokkos_Core_fwd.hpp"
52 #include "Kokkos_View.hpp"
53 #include "Kokkos_Layout.hpp"
54 #include "Kokkos_View_Utils.hpp"
56 
57 
58 //----------------------------------------------------------------------------
59 
60 namespace Kokkos {
61 
62  namespace Impl {
63  template<class Space, class T, class ... P>
64  struct MirrorType;
65  }
66 
67 }
68 
69 namespace Kokkos {
70 namespace Experimental {
71 namespace Impl {
72 
74 
75 template< class ... Args >
76 struct is_ViewMPVectorContiguous { enum { value = false }; };
77 
78 template< class D , class ... P , class ... Args >
79 struct is_ViewMPVectorContiguous< Kokkos::View<D,P...> , Args... > {
80  enum { value =
81  std::is_same< typename Kokkos::ViewTraits<D,P...>::specialize
83  &&
84  ( ( sizeof...(Args) == 0 ) ||
85  is_ViewMPVectorContiguous< Args... >::value ) };
86 };
87 
88 } // namespace Impl
89 } // namespace Experimental
90 } // namespace Kokkos
91 
92 namespace Kokkos {
93 
94 template <typename T, typename ... P>
95 struct is_view_mp_vector< View<T,P...> > {
96  typedef View<T,P...> view_type;
97  static const bool value =
98  std::is_same< typename view_type::specialize,
100 };
101 
102 template <typename T, typename ... P>
103 KOKKOS_INLINE_FUNCTION
104 constexpr typename
105 std::enable_if< is_view_mp_vector< View<T,P...> >::value, unsigned >::type
106 dimension_scalar(const View<T,P...>& view) {
107  return view.impl_map().dimension_scalar();
108 }
109 
110 // Declare overloads of create_mirror() so they are in scope
111 // Kokkos_Core.hpp is included below
112 
113 template< class T , class ... P >
114 inline
115 typename Kokkos::View<T,P...>::HostMirror
117  const Kokkos::View<T,P...> & src,
118  typename std::enable_if<
119  std::is_same< typename ViewTraits<T,P...>::specialize ,
121  !std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout,
122  Kokkos::LayoutStride >::value >::type * = 0);
123 
124 template< class T , class ... P >
125 inline
126 typename Kokkos::View<T,P...>::HostMirror
128  const Kokkos::View<T,P...> & src,
129  typename std::enable_if<
130  std::is_same< typename ViewTraits<T,P...>::specialize ,
132  std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout,
133  Kokkos::LayoutStride >::value >::type * = 0);
134 
135 template<class Space, class T, class ... P>
136 typename Impl::MirrorType<Space,T,P ...>::view_type
138  const Space&,
139  const Kokkos::View<T,P...> & src,
140  typename std::enable_if<
141  std::is_same< typename ViewTraits<T,P...>::specialize ,
143 
144 // Overload of deep_copy for MP::Vector views intializing to a constant scalar
145 template< class DT, class ... DP >
146 void deep_copy(
147  const View<DT,DP...> & view ,
148  const typename View<DT,DP...>::array_type::value_type & value
149  , typename std::enable_if<(
150  std::is_same< typename ViewTraits<DT,DP...>::specialize
152  )>::type * = 0 );
153 
154 // Overload of deep_copy for MP::Vector views intializing to a constant MP::Vector
155 template< class DT, class ... DP >
156 void deep_copy(
157  const View<DT,DP...> & view ,
158  const typename View<DT,DP...>::value_type & value
159  , typename std::enable_if<(
160  std::is_same< typename ViewTraits<DT,DP...>::specialize
162  )>::type * = 0 );
163 
164 // Overload of deep_copy for MP::Vector views intializing to a constant scalar
165 template< class ExecSpace , class DT, class ... DP >
166 void deep_copy(
167  const ExecSpace &,
168  const View<DT,DP...> & view ,
169  const typename View<DT,DP...>::array_type::value_type & value
170  , typename std::enable_if<(
171  Kokkos::Impl::is_execution_space< ExecSpace >::value &&
172  std::is_same< typename ViewTraits<DT,DP...>::specialize
174  )>::type * = 0 );
175 
176 // Overload of deep_copy for MP::Vector views intializing to a constant MP::Vector
177 template< class ExecSpace , class DT, class ... DP >
178 void deep_copy(
179  const ExecSpace &,
180  const View<DT,DP...> & view ,
181  const typename View<DT,DP...>::value_type & value
182  , typename std::enable_if<(
183  Kokkos::Impl::is_execution_space< ExecSpace >::value &&
184  std::is_same< typename ViewTraits<DT,DP...>::specialize
186  )>::type * = 0 );
187 
188 /* Specialize for deep copy of MP::Vector */
189 template< class DT , class ... DP , class ST , class ... SP >
190 inline
191 void deep_copy( const View<DT,DP...> & dst ,
192  const View<ST,SP...> & src
193  , typename std::enable_if<(
194  std::is_same< typename ViewTraits<DT,DP...>::specialize
196  &&
197  std::is_same< typename ViewTraits<ST,SP...>::specialize
199  )>::type * = 0 );
200 
201 } // namespace Kokkos
202 
203 //----------------------------------------------------------------------------
204 
205 #include "Kokkos_Core.hpp"
206 
207 namespace Kokkos {
208 
209 template <typename D, typename ... P>
210 struct FlatArrayType< View<D,P...>,
211  typename std::enable_if< is_view_mp_vector< View<D,P...> >::value >::type > {
212  typedef View<D,P...> view_type;
213  typedef typename view_type::traits::dimension dimension;
215  typedef typename Kokkos::Impl::ViewDataType< flat_value_type , dimension >::type flat_data_type;
216  typedef View<flat_data_type,P...> type;
217 };
218 
219 template< class T , class ... P >
220 inline
221 typename Kokkos::View<T,P...>::HostMirror
222 create_mirror( const Kokkos::View<T,P...> & src
223  , typename std::enable_if<
224  std::is_same< typename ViewTraits<T,P...>::specialize ,
226  &&
227  ! std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
228  , Kokkos::LayoutStride >::value
229  >::type *
230  )
231 {
232  typedef View<T,P...> src_type ;
233  typedef typename src_type::HostMirror dst_type ;
234 
235  typename src_type::array_layout layout = src.layout();
236  layout.dimension[src_type::rank] = Kokkos::dimension_scalar(src);
237 
238  return dst_type(std::string(src.label()).append("_mirror"), layout);
239 }
240 
241 template< class T , class ... P >
242 inline
243 typename Kokkos::View<T,P...>::HostMirror
244 create_mirror( const Kokkos::View<T,P...> & src
245  , typename std::enable_if<
246  std::is_same< typename ViewTraits<T,P...>::specialize ,
248  &&
249  std::is_same< typename Kokkos::ViewTraits<T,P...>::array_layout
250  , Kokkos::LayoutStride >::value
251  >::type *
252  )
253 {
254  typedef View<T,P...> src_type ;
255  typedef typename src_type::HostMirror dst_type ;
256 
257  Kokkos::LayoutStride layout ;
258 
259  layout.dimension[0] = src.extent(0);
260  layout.dimension[1] = src.extent(1);
261  layout.dimension[2] = src.extent(2);
262  layout.dimension[3] = src.extent(3);
263  layout.dimension[4] = src.extent(4);
264  layout.dimension[5] = src.extent(5);
265  layout.dimension[6] = src.extent(6);
266  layout.dimension[7] = src.extent(7);
267 
268  layout.stride[0] = src.stride_0();
269  layout.stride[1] = src.stride_1();
270  layout.stride[2] = src.stride_2();
271  layout.stride[3] = src.stride_3();
272  layout.stride[4] = src.stride_4();
273  layout.stride[5] = src.stride_5();
274  layout.stride[6] = src.stride_6();
275  layout.stride[7] = src.stride_7();
276 
277  layout.dimension[src_type::rank] = Kokkos::dimension_scalar(src);
278 
279  return dst_type(std::string(src.label()).append("_mirror"), layout);
280 }
281 
282 template<class Space, class T, class ... P>
283 typename Impl::MirrorType<Space,T,P ...>::view_type
284 create_mirror(const Space& , const Kokkos::View<T,P...> & src
285  , typename std::enable_if<
286  std::is_same< typename ViewTraits<T,P...>::specialize ,
288  >::type *) {
289  typedef View<T,P...> src_type ;
290  typename src_type::array_layout layout = src.layout();
291  layout.dimension[src_type::rank] = Kokkos::dimension_scalar(src);
292  return typename Impl::MirrorType<Space,T,P ...>::view_type(src.label(),layout);
293 }
294 
295 // Overload of deep_copy for MP::Vector views intializing to a constant scalar
296 template< class DT, class ... DP >
298  const View<DT,DP...> & view ,
299  const typename View<DT,DP...>::array_type::value_type & value
300  , typename std::enable_if<(
301  std::is_same< typename ViewTraits<DT,DP...>::specialize
303  )>::type * )
304 {
305  static_assert(
306  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
307  typename ViewTraits<DT,DP...>::non_const_value_type >::value
308  , "Can only deep copy into non-const type" );
309 
310  typedef typename FlatArrayType< View<DT,DP...> >::type flat_array_type;
312 }
313 
314 // Overload of deep_copy for MP::Vector views intializing to a constant MP::Vector
315 template< class DT, class ... DP >
317  const View<DT,DP...> & view ,
318  const typename View<DT,DP...>::value_type & value
319  , typename std::enable_if<(
320  std::is_same< typename ViewTraits<DT,DP...>::specialize
322  )>::type * )
323 {
324  static_assert(
325  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
326  typename ViewTraits<DT,DP...>::non_const_value_type >::value
327  , "Can only deep copy into non-const type" );
328 
329  // static_assert(
330  // Sacado::StaticSize< typename View<DT,DP...>::value_type >::value
331  // ||
332  // std::is_same< Kokkos::Impl::ActiveExecutionMemorySpace
333  // , Kokkos::HostSpace >::value
334  // , "Deep copy from a FAD type must be statically sized or host space" );
335 
336  Kokkos::Impl::StokhosViewFill< View<DT,DP...> >( view , value );
337 }
338 
339 // Overload of deep_copy for MP::Vector views intializing to a constant scalar
340 template< class ExecSpace , class DT, class ... DP >
342  const ExecSpace &,
343  const View<DT,DP...> & view ,
344  const typename View<DT,DP...>::array_type::value_type & value
345  , typename std::enable_if<(
346  Kokkos::Impl::is_execution_space< ExecSpace >::value &&
347  std::is_same< typename ViewTraits<DT,DP...>::specialize
349  )>::type * )
350 {
351  static_assert(
352  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
353  typename ViewTraits<DT,DP...>::non_const_value_type >::value
354  , "Can only deep copy into non-const type" );
355 
356  typedef typename FlatArrayType< View<DT,DP...> >::type flat_array_type;
358 }
359 
360 // Overload of deep_copy for MP::Vector views intializing to a constant MP::Vector
361 template< class ExecSpace , class DT, class ... DP >
363  const ExecSpace &,
364  const View<DT,DP...> & view ,
365  const typename View<DT,DP...>::value_type & value
366  , typename std::enable_if<(
367  Kokkos::Impl::is_execution_space< ExecSpace >::value &&
368  std::is_same< typename ViewTraits<DT,DP...>::specialize
370  )>::type * )
371 {
372  static_assert(
373  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
374  typename ViewTraits<DT,DP...>::non_const_value_type >::value
375  , "Can only deep copy into non-const type" );
376 
377  // static_assert(
378  // Sacado::StaticSize< typename View<DT,DP...>::value_type >::value
379  // ||
380  // std::is_same< Kokkos::Impl::ActiveExecutionMemorySpace
381  // , Kokkos::HostSpace >::value
382  // , "Deep copy from a FAD type must be statically sized or host space" );
383 
384  Kokkos::Impl::StokhosViewFill< View<DT,DP...> >( view , value );
385 }
386 
387 /* Specialize for deep copy of MP::Vector */
388 template< class DT , class ... DP , class ST , class ... SP >
389 inline
390 void deep_copy( const View<DT,DP...> & dst ,
391  const View<ST,SP...> & src
392  , typename std::enable_if<(
393  std::is_same< typename ViewTraits<DT,DP...>::specialize
395  &&
396  std::is_same< typename ViewTraits<ST,SP...>::specialize
398  )>::type * )
399 {
400  static_assert(
401  std::is_same< typename ViewTraits<DT,DP...>::value_type ,
402  typename ViewTraits<DT,DP...>::non_const_value_type >::value
403  , "Deep copy destination must be non-const" );
404 
405  static_assert(
406  ( unsigned(ViewTraits<DT,DP...>::rank) ==
407  unsigned(ViewTraits<ST,SP...>::rank) )
408  , "Deep copy destination and source must have same rank" );
409 
410  // Note ETP 09/29/2016: Use FlatArrayType instead of array_type to work
411  // around issue where dst and src are rank-1, but have differing layouts.
412  // Kokkos' deep_copy() doesn't work in this case because the array_type
413  // will be rank-2. It should be possible to make deep_copy() work there,
414  // but this seems easier.
415 
416  // Kokkos::deep_copy(
417  // typename View<DT,DP...>::array_type( dst ) ,
418  // typename View<ST,SP...>::array_type( src ) );
419 
421  typename FlatArrayType< View<DT,DP...> >::type( dst ) ,
422  typename FlatArrayType< View<ST,SP...> >::type( src ) );
423 }
424 
425 }
426 
427 namespace Kokkos {
428 namespace Impl {
429 
430 template< class DataType , class ArrayLayout , typename StorageType >
431 struct ViewDataAnalysis< DataType /* Original view data type */
432  , ArrayLayout
433  , Sacado::MP::Vector< StorageType > >
434 {
435 private:
436 
438  typedef ViewArrayAnalysis< DataType > array_analysis ;
439  static const int DimVector = StorageType::static_size;
440 
441 public:
442 
443  // Specialized view data mapping:
445 
446  typedef typename array_analysis::dimension dimension ;
448  typedef typename array_analysis::const_value_type const_value_type ;
449  typedef typename array_analysis::non_const_value_type non_const_value_type ;
450 
451  // Generate analogous multidimensional array specification type.
452  typedef typename
453  ViewDataType< value_type , dimension >::type type ;
454  typedef typename
455  ViewDataType< const_value_type , dimension >::type const_type ;
456  typedef typename
457  ViewDataType< non_const_value_type , dimension >::type non_const_type ;
458 
459 private:
460 
461  // A const ?
462  enum { is_const = std::is_same< value_type , const_value_type >::value };
463 
464  // The unwrapped scalar types:
465  typedef typename
466  std::conditional< is_const , const ScalarType , ScalarType >::type
468 
471 
472  // Prepend or append the vector dimension based on ArrayLayout
473  // Note: you can't prepend a static dimension, so use 0 for LayoutLeft
474  typedef typename array_analysis::dimension::
475  template prepend<0>::type
477  typedef typename array_analysis::dimension::
478  template append<DimVector>::type
480  typedef typename std::conditional<
481  std::is_same< ArrayLayout, Kokkos::LayoutLeft>::value,
484 
485 public:
486 
487  // Generate "flattened" multidimensional array specification type.
488  typedef typename
489  ViewDataType< scalar_type , scalar_dimension >::type scalar_array_type ;
490 
491  typedef typename
492  ViewDataType< const_scalar_type , scalar_dimension >::type
494 
495  typedef typename
496  ViewDataType< non_const_scalar_type , scalar_dimension >::type
498 };
499 
500 } // namespace Impl
501 } // namespace Kokkos
502 
503 //----------------------------------------------------------------------------
504 
505 namespace Kokkos {
506 namespace Experimental {
507 namespace Impl {
508 
509  template < class ValueType,
510  bool is_static = Sacado::IsStaticallySized<ValueType>::value >
512 
513 // MP::Vector allocation for statically-sized MP::Vector types.
514 // In this case we can reinterpret cast directly between pointers of types
515 // MP::Vector<Storage> and MP::Vector<Storage>::value_type.
516 template <class ValueType>
517 struct MPVectorAllocation<ValueType, true> {
518  typedef ValueType value_type;
519  typedef typename Sacado::ValueType<value_type>::type scalar_type;
520 
523 
524  KOKKOS_INLINE_FUNCTION
525  static constexpr size_t
526  memory_span(const size_t span, const unsigned vector_size) {
527  return span * vector_size * sizeof(scalar_type);
528  }
529 
530  KOKKOS_INLINE_FUNCTION
531  MPVectorAllocation() : value_ptr(0), scalar_ptr(0) {}
532 
533  template <typename T>
534  KOKKOS_INLINE_FUNCTION
536  value_ptr = a.value_ptr;
537  scalar_ptr = a.scalar_ptr;
538  return *this;
539  }
540 
541  KOKKOS_INLINE_FUNCTION
542  void set(value_type* ptr, const size_t span, const unsigned vector_size) {
543  value_ptr = ptr;
544  scalar_ptr = reinterpret_cast<scalar_type*>(ptr);
545  }
546 
547  template <class ExecSpace>
548  struct ConstructDestructFunctor {
549  typedef Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type > FunctorType ;
552 
553  ConstructDestructFunctor() = default;
554  ConstructDestructFunctor(const ConstructDestructFunctor&) = default;
555  ConstructDestructFunctor& operator=(const ConstructDestructFunctor&) = default;
556 
557  ConstructDestructFunctor(const ExecSpace & space,
558  const bool initialize,
559  const size_t span,
560  const unsigned vector_size,
561  scalar_type* scalar_ptr) :
562  m_functor( space , scalar_ptr , span*vector_size ),
563  m_initialize(initialize) {}
564 
566  if (m_initialize)
567  m_functor.construct_shared_allocation();
568  }
569 
571  if (m_initialize)
572  m_functor.destroy_shared_allocation();
573  }
574 
575  };
576 
577  template <class ExecSpace>
578  inline ConstructDestructFunctor<ExecSpace>
579  create_functor(const ExecSpace & space,
580  const bool initialize,
581  const size_t span,
582  const unsigned vector_size) const {
583  return ConstructDestructFunctor<ExecSpace>(space, initialize, span, vector_size, scalar_ptr);
584  }
585 
586  // Assign scalar_type pointer to give ptr
587  template <typename T>
588  KOKKOS_INLINE_FUNCTION
589  void assign(T * ptr) {
590  value_ptr = reinterpret_cast<value_type*>(ptr);
591  scalar_ptr = reinterpret_cast<scalar_type*>(ptr);
592  }
593 
594 };
595 
596 // MP::Vector allocation for dynamically-sized MP::Vector types.
597 // In this case we allocate two chunks of data, the first for the the
598 // MP::Vector<Storage> itself and then for the underlying scalar type
599 // (MP::Vector<Storage>::value_type). The memory is laid out with the
600 // former followed by the latter.
601 template <class ValueType>
602 struct MPVectorAllocation<ValueType, false> {
603  typedef ValueType value_type;
604  typedef typename Sacado::ValueType<value_type>::type scalar_type;
605 
608 
609  KOKKOS_INLINE_FUNCTION
610  static constexpr size_t
611  memory_span(const size_t span, const unsigned vector_size) {
612  return span * ( vector_size * sizeof(scalar_type) + sizeof(value_type) );
613  }
614 
615  KOKKOS_INLINE_FUNCTION
616  MPVectorAllocation() : value_ptr(0), scalar_ptr(0) {}
617 
618  template <typename T>
619  KOKKOS_INLINE_FUNCTION
621  value_ptr = a.value_ptr;
622  scalar_ptr = a.scalar_ptr;
623  return *this;
624  }
625 
626  // We are making an assumption the data is laid out as described above,
627  // which in general may not be true if the view is created from memory
628  // allocated elsewhere. We should check for that.
629  KOKKOS_INLINE_FUNCTION
630  void set(value_type* ptr, const size_t span, const unsigned vector_size) {
631  value_ptr = ptr;
632  scalar_ptr = reinterpret_cast<scalar_type*>(ptr+span);
633  }
634 
635  template <class ExecSpace>
636  struct VectorConstruct {
637  ExecSpace m_space;
640  size_t m_span;
641  unsigned m_vector_size;
642 
643  VectorConstruct() = default;
644  VectorConstruct(const VectorConstruct&) = default;
645  VectorConstruct& operator=(const VectorConstruct&) = default;
646 
647  inline
648  VectorConstruct(const ExecSpace& space,
649  value_type* p,
650  scalar_type* sp,
651  const size_t span,
652  const unsigned vector_size) :
653  m_space(space), m_p(p), m_sp(sp), m_span(span), m_vector_size(vector_size) {}
654 
655  inline void execute() {
656  if ( ! m_space.in_parallel() ) {
657  typedef Kokkos::RangePolicy< ExecSpace > PolicyType ;
658  const Kokkos::Impl::ParallelFor< VectorConstruct , PolicyType >
659  closure( *this , PolicyType( 0 , m_span ) );
660  closure.execute();
661  m_space.fence();
662  }
663  else {
664  for ( size_t i = 0 ; i < m_span ; ++i ) operator()(i);
665  }
666  }
667 
668  KOKKOS_INLINE_FUNCTION
669  void operator() (const size_t i) const {
670  new (m_p+i) value_type(m_vector_size, m_sp+i*m_vector_size, false);
671  }
672  };
673 
674  template <class ExecSpace>
675  struct ConstructDestructFunctor {
676  typedef Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type > ScalarFunctorType ;
677  typedef VectorConstruct< ExecSpace > VectorFunctorType ;
681 
682  ConstructDestructFunctor() = default;
683  ConstructDestructFunctor(const ConstructDestructFunctor&) = default;
684  ConstructDestructFunctor& operator=(const ConstructDestructFunctor&) = default;
685 
686  ConstructDestructFunctor(const ExecSpace & space,
687  const bool initialize,
688  const size_t span,
689  const unsigned vector_size,
690  scalar_type* scalar_ptr,
691  value_type* value_ptr) :
692  m_scalar_functor( space , scalar_ptr , span*vector_size ),
693  m_vector_functor( space , value_ptr , scalar_ptr , span , vector_size ),
694  m_initialize(initialize) {}
695 
697  // First initialize the scalar_type array
698  if (m_initialize)
699  m_scalar_functor.construct_shared_allocation();
700 
701  // Construct each MP::Vector using memory in scalar_ptr array,
702  // setting pointer to MP::Vector values from values array
703  // Equivalent to:
704  // value_type* p = value_ptr;
705  // scalar_type* sp = scalar_ptr;
706  // for (size_t i=0; i<span; ++i) {
707  // new (p++) value_type(vector_size, sp, false);
708  // sp += vector_size;
709  // }
710  // (we always need to do this, regardless of initialization)
711  m_vector_functor.execute();
712  }
713 
715  // We only need to (possibly) call the destructor on values in the
716  // scalar_type array, since the value_type array is a view into it
717  if (m_initialize)
718  m_scalar_functor.destroy_shared_allocation();
719  }
720 
721  };
722 
723  template <class ExecSpace>
724  inline ConstructDestructFunctor<ExecSpace>
725  create_functor(const ExecSpace & space,
726  const bool initialize,
727  const size_t span,
728  const unsigned vector_size) const {
729  return ConstructDestructFunctor<ExecSpace>(space, initialize, span, vector_size, scalar_ptr, value_ptr);
730  }
731 
732  // Assign scalar_type pointer to give ptr
733  // This makes BIG assumption on how the data was allocated
734  template <typename T>
735  KOKKOS_INLINE_FUNCTION
736  void assign(T * ptr) {
737  value_ptr = reinterpret_cast<value_type*>(ptr);
738  if (ptr != 0)
739  scalar_ptr = value_ptr->coeff();
740  else
741  scalar_ptr = 0;
742  }
743 };
744 
745 }}} // namespace Kokkos::Experimental::Impl
746 
747 namespace Kokkos {
748 namespace Impl {
749 
750 template< class Traits >
751 class ViewMapping< Traits , /* View internal mapping */
752  typename std::enable_if<
753  ( std::is_same< typename Traits::specialize
754  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
755  &&
756  ( std::is_same< typename Traits::array_layout
757  , Kokkos::LayoutLeft >::value
758  ||
759  std::is_same< typename Traits::array_layout
760  , Kokkos::LayoutRight >::value
761  ||
762  std::is_same< typename Traits::array_layout
763  , Kokkos::LayoutStride >::value
764  )
765  )
766  , typename Traits::specialize
767  >::type >
768 {
769 private:
770 
771  template< class , class ... > friend class ViewMapping ;
772  template< class , class ... > friend class Kokkos::View ;
773 
777  typedef typename
778  std::add_const< intrinsic_scalar_type >::type const_intrinsic_scalar_type ;
779 
780  enum { StokhosStorageStaticDimension = stokhos_storage_type::static_size };
781  typedef Sacado::integral_nonzero< unsigned , StokhosStorageStaticDimension > sacado_size_type;
782 
784 
785  typedef ViewOffset< typename Traits::dimension
786  , typename Traits::array_layout
787  , void
789 
790  // Prepend or append the vector dimension based on array_layout
791  // Note: you can't prepend a static dimension, so use 0 for LayoutLeft
792  typedef ViewArrayAnalysis< typename Traits::data_type > array_analysis ;
793  typedef typename array_analysis::dimension array_dimension;
794  typedef ViewOffset< typename array_dimension::
795  template append<StokhosStorageStaticDimension>::type,
796  typename Traits::array_layout,
797  void
799  typedef ViewOffset< typename array_dimension::
800  template prepend<0>::type,
801  typename Traits::array_layout,
802  void
804  typedef typename std::conditional<
805  std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft>::value,
808 
811  unsigned m_stride ;
812  sacado_size_type m_sacado_size ; // Size of sacado dimension
813 
814  // Note: if the view is partitioned, m_sacado_size is not the stride in
815  // memory between consecutive MP::Vector entries for given vector index:
816  //
817  // original_sacado_size = m_stride * m_sacado_size
818  // m_stride = 1 for original allocation.
819  //
820  // Stride here has a slightly different meaning than in the standard
821  // View implementation. For the moment we are assuming no padding within
822  // the view array itself and stride is to allow for partitioning the view
823  // by dividing up the scalar type.
824  //
825  // I suspect we could combine this with the way the stride is managed in
826  // the default view, in which case, I don't think we even need a
827  // specialization
828  //
829  // For reshaping by folding the sacado dimension into its next adjacent
830  // dimension, padding wouldn't generally work. So unless there becomes
831  // a way to turn padding off in the default view, a specialization
832  // will be necessary.
833 
834 public:
835 
836  //----------------------------------------
837  // Domain dimensions
838 
839  enum { Rank = Traits::dimension::rank };
840 
841  // Rank corresponding to the sacado dimension
842  enum { Sacado_Rank = std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value ? 0 : Rank+1 };
843 
844  // Using the internal offset mapping so limit to public rank:
845  template< typename iType >
846  KOKKOS_INLINE_FUNCTION constexpr size_t extent( const iType & r ) const
847  { return m_impl_offset.m_dim.extent(r); }
848 
849  KOKKOS_INLINE_FUNCTION constexpr
850  typename Traits::array_layout layout() const
851  { return m_impl_offset.layout(); }
852 
853  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const
854  { return m_impl_offset.dimension_0(); }
855  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const
856  { return m_impl_offset.dimension_1(); }
857  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const
858  { return m_impl_offset.dimension_2(); }
859  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const
860  { return m_impl_offset.dimension_3(); }
861  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const
862  { return m_impl_offset.dimension_4(); }
863  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const
864  { return m_impl_offset.dimension_5(); }
865  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const
866  { return m_impl_offset.dimension_6(); }
867  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const
868  { return m_impl_offset.dimension_7(); }
869 
870  // Is a regular layout with uniform striding for each index.
871  // Since we all for striding within the data type, we can't guarantee
872  // regular striding
873  using is_regular = std::false_type ;
874 
875  // FIXME: Adjust these for m_stride
876  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const
877  { return m_impl_offset.stride_0(); }
878  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const
879  { return m_impl_offset.stride_1(); }
880  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const
881  { return m_impl_offset.stride_2(); }
882  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const
883  { return m_impl_offset.stride_3(); }
884  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const
885  { return m_impl_offset.stride_4(); }
886  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const
887  { return m_impl_offset.stride_5(); }
888  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const
889  { return m_impl_offset.stride_6(); }
890  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const
891  { return m_impl_offset.stride_7(); }
892 
893  template< typename iType >
894  KOKKOS_INLINE_FUNCTION void stride( iType * const s ) const
895  { m_impl_offset.stride(s); }
896 
897  // Size of sacado scalar dimension
898  KOKKOS_FORCEINLINE_FUNCTION constexpr unsigned dimension_scalar() const
899  { return m_sacado_size.value; }
900 
901  // Whether the storage type is statically sized
902  static const bool is_static = stokhos_storage_type::is_static ;
903 
904  // Whether sacado dimension is contiguous
905  static const bool is_contiguous = true;
906 
907  //----------------------------------------
908  // Range of mapping
909 
910  // Return type of reference operators
912 
915 
917  KOKKOS_INLINE_FUNCTION constexpr size_t span() const
918  { return m_impl_offset.span(); }
919 
921  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
922  { return m_impl_offset.span_is_contiguous() && (m_stride == 1); }
923 
925  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const
926  { return m_impl_handle.value_ptr ; }
927 
928  //----------------------------------------
929 
930  KOKKOS_FORCEINLINE_FUNCTION
932  { return *m_impl_handle.value_ptr; }
933 
934  // FIXME: Check this
935  template< typename I0 >
936  KOKKOS_FORCEINLINE_FUNCTION
937  typename
938  std::enable_if< std::is_integral<I0>::value &&
939  ! std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
940  , reference_type >::type
941  reference( const I0 & i0 ) const
942  { return m_impl_handle.value_ptr[m_stride * i0]; }
943 
944  // FIXME: Check this
945  template< typename I0 >
946  KOKKOS_FORCEINLINE_FUNCTION
947  typename
948  std::enable_if< std::is_integral<I0>::value &&
949  std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
950  , reference_type >::type
951  reference( const I0 & i0 ) const
952  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0) ]; }
953 
954  template< typename I0 , typename I1 >
955  KOKKOS_FORCEINLINE_FUNCTION
956  reference_type reference( const I0 & i0 , const I1 & i1 ) const
957  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1) ]; }
958 
959  template< typename I0 , typename I1 , typename I2 >
960  KOKKOS_FORCEINLINE_FUNCTION
961  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 ) const
962  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2) ]; }
963 
964  template< typename I0 , typename I1 , typename I2 , typename I3 >
965  KOKKOS_FORCEINLINE_FUNCTION
966  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3 ) const
967  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2,i3) ]; }
968 
969  template< typename I0 , typename I1 , typename I2 , typename I3
970  , typename I4 >
971  KOKKOS_FORCEINLINE_FUNCTION
972  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
973  , const I4 & i4 ) const
974  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2,i3,i4) ]; }
975 
976  template< typename I0 , typename I1 , typename I2 , typename I3
977  , typename I4 , typename I5 >
978  KOKKOS_FORCEINLINE_FUNCTION
979  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
980  , const I4 & i4 , const I5 & i5 ) const
981  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2,i3,i4,i5) ]; }
982 
983  template< typename I0 , typename I1 , typename I2 , typename I3
984  , typename I4 , typename I5 , typename I6 >
985  KOKKOS_FORCEINLINE_FUNCTION
986  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
987  , const I4 & i4 , const I5 & i5 , const I6 & i6 ) const
988  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2,i3,i4,i5,i6) ]; }
989 
990  template< typename I0 , typename I1 , typename I2 , typename I3
991  , typename I4 , typename I5 , typename I6 , typename I7 >
992  KOKKOS_FORCEINLINE_FUNCTION
993  reference_type reference( const I0 & i0 , const I1 & i1 , const I2 & i2 , const I3 & i3
994  , const I4 & i4 , const I5 & i5 , const I6 & i6 , const I7 & i7 ) const
995  { return m_impl_handle.value_ptr[ m_stride * m_impl_offset(i0,i1,i2,i3,i4,i5,i6,i7) ]; }
996 
997  //----------------------------------------
998 
1000  KOKKOS_INLINE_FUNCTION
1001  static size_t memory_span( typename Traits::array_layout const & layout )
1002  {
1003  // Do not introduce padding...
1004  typedef std::integral_constant< unsigned , 0 > padding ;
1005  offset_type offset( padding(), layout );
1006 
1007  // Always use static dimension if we are static
1008  const unsigned static_dim = StokhosStorageStaticDimension;
1009  if (static_dim > 0)
1010  return handle_type::memory_span( offset.span(), static_dim );
1011 
1012  // Else get size from prescribed layout
1013  const size_t sacado_size =
1015  return handle_type::memory_span( offset.span(), sacado_size );
1016  }
1017 
1018  //----------------------------------------
1019 
1020  KOKKOS_INLINE_FUNCTION ~ViewMapping() = default ;
1021  KOKKOS_INLINE_FUNCTION ViewMapping() :
1022  m_impl_handle(),
1023  m_impl_offset(),
1024  m_stride(1),
1025  m_sacado_size(0)
1026  {}
1027 
1028  KOKKOS_INLINE_FUNCTION ViewMapping( const ViewMapping & ) = default ;
1029  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( const ViewMapping & ) = default ;
1030 
1031  KOKKOS_INLINE_FUNCTION ViewMapping( ViewMapping && ) = default ;
1032  KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( ViewMapping && ) = default ;
1033 
1034  template< class ... P >
1035  KOKKOS_INLINE_FUNCTION
1036  ViewMapping
1037  ( ViewCtorProp< P ... > const & prop
1038  , typename Traits::array_layout const & layout
1039  )
1040  : m_impl_handle()
1041  , m_impl_offset( std::integral_constant< unsigned , 0 >()
1042  , layout )
1043  , m_stride( 1 )
1044  , m_sacado_size( Kokkos::Impl::GetSacadoSize<unsigned(Rank)>::eval(layout) )
1045  {
1046  m_impl_handle.set( ( (ViewCtorProp<void,pointer_type> const &) prop ).value,
1047  m_impl_offset.span(), m_sacado_size.value );
1048  }
1049 
1050  //----------------------------------------
1051  /* Allocate and construct mapped array.
1052  * Allocate via shared allocation record and
1053  * return that record for allocation tracking.
1054  */
1055  template< class ... P >
1056  SharedAllocationRecord<> *
1057  allocate_shared( ViewCtorProp< P... > const & prop
1058  , typename Traits::array_layout const & layout )
1059  {
1060  typedef ViewCtorProp< P... > ctor_prop ;
1061 
1062  typedef typename ctor_prop::execution_space execution_space ;
1063  typedef typename Traits::memory_space memory_space ;
1064  typedef typename handle_type::template ConstructDestructFunctor<execution_space> functor_type ;
1065  typedef SharedAllocationRecord< memory_space , functor_type > record_type ;
1066 
1067  // Disallow padding
1068  typedef std::integral_constant< unsigned , 0 > padding ;
1069 
1070  m_impl_offset = offset_type( padding(), layout );
1071  m_stride = 1;
1072  m_sacado_size = Kokkos::Impl::GetSacadoSize<unsigned(Rank)>::eval(layout);
1073 
1074  const size_t alloc_size =
1075  handle_type::memory_span( m_impl_offset.span(), m_sacado_size.value );
1076 
1077  // Create shared memory tracking record with allocate memory from the memory space
1078  record_type * const record =
1079  record_type::allocate( ( (ViewCtorProp<void,memory_space> const &) prop ).value
1080  , ( (ViewCtorProp<void,std::string> const &) prop ).value
1081  , alloc_size );
1082 
1083  // Only set the the pointer and initialize if the allocation is non-zero.
1084  // May be zero if one of the dimensions is zero.
1085  if ( alloc_size ) {
1086 
1087  m_impl_handle.set( reinterpret_cast< pointer_type >( record->data() ),
1088  m_impl_offset.span(), m_sacado_size.value );
1089 
1090  // Assume destruction is only required when construction is requested.
1091  // The ViewValueFunctor has both value construction and destruction operators.
1092  record->m_destroy = m_impl_handle.create_functor(
1093  ( (ViewCtorProp<void,execution_space> const &) prop).value
1094  , ctor_prop::initialize
1095  , m_impl_offset.span()
1096  , m_sacado_size.value );
1097 
1098  // Construct values
1099  record->m_destroy.construct_shared_allocation();
1100  }
1101 
1102  return record ;
1103  }
1104 
1105  //----------------------------------------
1106  // If the View is to construct or destroy the elements.
1107 
1108  /*
1109  template< class ExecSpace >
1110  void construct( const ExecSpace & space ) const
1111  {
1112  m_impl_handle.construct( space, m_impl_offset.span(), m_sacado_size.value );
1113  }
1114 
1115  template< class ExecSpace >
1116  void destroy( const ExecSpace & space ) const
1117  {
1118  m_impl_handle.destruct( space, m_impl_offset.span(), m_sacado_size.value );
1119  }
1120  */
1121 };
1122 
1123 } // namespace Impl
1124 } // namespace Kokkos
1125 
1126 //----------------------------------------------------------------------------
1127 
1128 namespace Kokkos {
1129 namespace Impl {
1130 
1135 template< class DstTraits , class SrcTraits >
1136 class ViewMapping< DstTraits , SrcTraits ,
1137  typename std::enable_if<(
1138  Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1139  , typename SrcTraits::memory_space >::assignable
1140  &&
1141  // Destination view has MP::Vector
1142  std::is_same< typename DstTraits::specialize
1143  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1144  &&
1145  // Source view has MP::Vector only
1146  std::is_same< typename SrcTraits::specialize
1147  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1148  )
1149  , typename DstTraits::specialize
1150  >::type >
1151 {
1152 public:
1153 
1154  enum { is_assignable = true };
1155 
1156  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
1157  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
1158  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcType ;
1159 
1160  KOKKOS_INLINE_FUNCTION static
1161  void assign( DstType & dst
1162  , const SrcType & src
1163  , const TrackType & )
1164  {
1165  static_assert(
1166  (
1167  std::is_same< typename DstTraits::array_layout
1168  , Kokkos::LayoutLeft >::value ||
1169  std::is_same< typename DstTraits::array_layout
1170  , Kokkos::LayoutRight >::value ||
1171  std::is_same< typename DstTraits::array_layout
1172  , Kokkos::LayoutStride >::value
1173  )
1174  &&
1175  (
1176  std::is_same< typename SrcTraits::array_layout
1177  , Kokkos::LayoutLeft >::value ||
1178  std::is_same< typename SrcTraits::array_layout
1179  , Kokkos::LayoutRight >::value ||
1180  std::is_same< typename SrcTraits::array_layout
1181  , Kokkos::LayoutStride >::value
1182  )
1183  , "View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1184 
1185  static_assert(
1186  std::is_same< typename DstTraits::array_layout
1187  , typename SrcTraits::array_layout >::value ||
1188  std::is_same< typename DstTraits::array_layout
1189  , Kokkos::LayoutStride >::value ||
1190  ( unsigned(DstTraits::rank) == 0 && unsigned(SrcTraits::rank) == 0 ) ||
1191  ( unsigned(DstTraits::rank) == 1 && unsigned(SrcTraits::rank) == 1 ) ,
1192  "View assignment must have compatible layout" );
1193 
1194  static_assert(
1195  std::is_same< typename DstTraits::value_type
1196  , typename SrcTraits::value_type >::value ||
1197  std::is_same< typename DstTraits::value_type
1198  , typename SrcTraits::const_value_type >::value ,
1199  "View assignment must have same value type or const = non-const" );
1200 
1201  static_assert(
1202  ViewDimensionAssignable
1203  < typename DstType::offset_type::dimension_type
1204  , typename SrcType::offset_type::dimension_type >::value ,
1205  "View assignment must have compatible dimensions" );
1206 
1207  dst.m_impl_handle = src.m_impl_handle ;
1208  dst.m_impl_offset = src.m_impl_offset ;
1209  dst.m_stride = src.m_stride ;
1210  dst.m_sacado_size = src.m_sacado_size ;
1211  }
1212 };
1213 
1219 template< class DstTraits , class SrcTraits >
1220 class ViewMapping< DstTraits , SrcTraits ,
1221  typename std::enable_if<(
1222  Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1223  , typename SrcTraits::memory_space >::assignable
1224  &&
1225  // Destination view has ordinary
1226  std::is_same< typename DstTraits::specialize , void >::value
1227  &&
1228  // Source view has MP::Vector only
1229  std::is_same< typename SrcTraits::specialize
1230  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1231  &&
1232  // Ranks match
1233  unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)+1
1234  )
1235  , typename DstTraits::specialize
1236  >::type >
1237 {
1238 public:
1239 
1240  enum { is_assignable = true };
1241 
1242  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
1243  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
1244  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcType ;
1245 
1246  KOKKOS_INLINE_FUNCTION static
1247  void assign( DstType & dst
1248  , const SrcType & src
1249  , const TrackType & )
1250  {
1251  static_assert(
1252  (
1253  std::is_same< typename DstTraits::array_layout
1254  , Kokkos::LayoutLeft >::value ||
1255  std::is_same< typename DstTraits::array_layout
1256  , Kokkos::LayoutRight >::value ||
1257  std::is_same< typename DstTraits::array_layout
1258  , Kokkos::LayoutStride >::value
1259  )
1260  &&
1261  (
1262  std::is_same< typename SrcTraits::array_layout
1263  , Kokkos::LayoutLeft >::value ||
1264  std::is_same< typename SrcTraits::array_layout
1265  , Kokkos::LayoutRight >::value ||
1266  std::is_same< typename SrcTraits::array_layout
1267  , Kokkos::LayoutStride >::value
1268  )
1269  , "View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1270 
1271  static_assert(
1272  std::is_same< typename DstTraits::array_layout
1273  , typename SrcTraits::array_layout >::value ||
1274  std::is_same< typename DstTraits::array_layout
1275  , Kokkos::LayoutStride >::value ,
1276  "View assignment must have compatible layout" );
1277 
1278  static_assert(
1279  std::is_same< typename DstTraits::scalar_array_type
1280  , typename SrcTraits::scalar_array_type >::value ||
1281  std::is_same< typename DstTraits::scalar_array_type
1282  , typename SrcTraits::const_scalar_array_type >::value ,
1283  "View assignment must have same value type or const = non-const" );
1284 
1285  static_assert(
1286  ViewDimensionAssignable<
1287  typename DstType::offset_type::dimension_type,
1288  typename SrcType::array_offset_type::dimension_type >::value,
1289  "View assignment must have compatible dimensions" );
1290 
1291  if ( src.m_stride != 1 ) {
1292  Kokkos::abort("\n\n ****** Kokkos::View< Sacado::MP::Vector ... > cannot assign with non-unit stride ******\n\n");
1293  }
1294 
1295  unsigned dims[8];
1296  dims[0] = src.m_impl_offset.dimension_0();
1297  dims[1] = src.m_impl_offset.dimension_1();
1298  dims[2] = src.m_impl_offset.dimension_2();
1299  dims[3] = src.m_impl_offset.dimension_3();
1300  dims[4] = src.m_impl_offset.dimension_4();
1301  dims[5] = src.m_impl_offset.dimension_5();
1302  dims[6] = src.m_impl_offset.dimension_6();
1303  dims[7] = src.m_impl_offset.dimension_7();
1304  unsigned rank = SrcTraits::dimension::rank;
1305  unsigned sacado_size = src.m_sacado_size.value;
1306  if (std::is_same<typename SrcTraits::array_layout, LayoutLeft>::value) {
1307  // Move sacado_size to the first dimension, shift all others up one
1308  for (unsigned i=rank; i>0; --i)
1309  dims[i] = dims[i-1];
1310  dims[0] = sacado_size;
1311  }
1312  else {
1313  dims[rank] = sacado_size;
1314  }
1315  typedef typename DstType::offset_type dst_offset_type;
1316  dst.m_impl_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1317  typename DstTraits::array_layout(
1318  dims[0] , dims[1] , dims[2] , dims[3] ,
1319  dims[4] , dims[5] , dims[6] , dims[7] ) );
1320  dst.m_impl_handle = src.m_impl_handle.scalar_ptr ;
1321  }
1322 };
1323 
1330 template< class DstTraits , class SrcTraits >
1331 class ViewMapping< DstTraits , SrcTraits ,
1332  typename std::enable_if<(
1333  Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1334  , typename SrcTraits::memory_space >::assignable
1335  &&
1336  // Destination view has ordinary
1337  std::is_same< typename DstTraits::specialize , void >::value
1338  &&
1339  // Source view has MP::Vector only
1340  std::is_same< typename SrcTraits::specialize
1341  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1342  &&
1343  // Ranks match
1344  unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)
1345  )
1346  , typename DstTraits::specialize
1347  >::type >
1348 {
1349 public:
1350 
1351  enum { is_assignable = true };
1352 
1353  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
1354  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
1355  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcType ;
1356 
1357  KOKKOS_INLINE_FUNCTION static
1358  void assign( DstType & dst
1359  , const SrcType & src
1360  , const TrackType & )
1361  {
1362  static_assert(
1363  (
1364  std::is_same< typename DstTraits::array_layout
1365  , Kokkos::LayoutLeft >::value ||
1366  std::is_same< typename DstTraits::array_layout
1367  , Kokkos::LayoutRight >::value ||
1368  std::is_same< typename DstTraits::array_layout
1369  , Kokkos::LayoutStride >::value
1370  )
1371  &&
1372  (
1373  std::is_same< typename SrcTraits::array_layout
1374  , Kokkos::LayoutLeft >::value ||
1375  std::is_same< typename SrcTraits::array_layout
1376  , Kokkos::LayoutRight >::value ||
1377  std::is_same< typename SrcTraits::array_layout
1378  , Kokkos::LayoutStride >::value
1379  )
1380  , "View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1381 
1382  static_assert(
1383  std::is_same< typename DstTraits::array_layout
1384  , typename SrcTraits::array_layout >::value ||
1385  std::is_same< typename DstTraits::array_layout
1386  , Kokkos::LayoutStride >::value ,
1387  "View assignment must have compatible layout" );
1388 
1389  static_assert(
1390  std::is_same< typename DstTraits::value_type
1391  , typename SrcTraits::non_const_value_type::value_type >::value ||
1392  std::is_same< typename DstTraits::value_type
1393  , const typename SrcTraits::non_const_value_type::value_type >::value ,
1394  "View assignment must have same value type or const = non-const" );
1395 
1396  static_assert(
1397  ViewDimensionAssignable<
1398  typename DstType::offset_type::dimension_type,
1399  typename SrcType::offset_type::dimension_type >::value,
1400  "View assignment must have compatible dimensions" );
1401 
1402  if ( src.m_stride != 1 ) {
1403  Kokkos::abort("\n\n ****** Kokkos::View< Sacado::MP::Vector ... > cannot assign with non-unit stride ******\n\n");
1404  }
1405 
1406  unsigned dims[8];
1407  dims[0] = src.m_impl_offset.dimension_0();
1408  dims[1] = src.m_impl_offset.dimension_1();
1409  dims[2] = src.m_impl_offset.dimension_2();
1410  dims[3] = src.m_impl_offset.dimension_3();
1411  dims[4] = src.m_impl_offset.dimension_4();
1412  dims[5] = src.m_impl_offset.dimension_5();
1413  dims[6] = src.m_impl_offset.dimension_6();
1414  dims[7] = src.m_impl_offset.dimension_7();
1415  unsigned rank = SrcTraits::dimension::rank;
1416  unsigned sacado_size = src.m_sacado_size.value;
1417  if (std::is_same<typename DstTraits::array_layout, LayoutLeft>::value) {
1418  dims[0] = dims[0]*sacado_size;
1419  dims[rank] = 0;
1420  }
1421  else {
1422  dims[rank-1] = dims[rank-1]*sacado_size;
1423  dims[rank] = 0;
1424  }
1425  typedef typename DstType::offset_type dst_offset_type;
1426  dst.m_impl_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1427  typename DstTraits::array_layout(
1428  dims[0] , dims[1] , dims[2] , dims[3] ,
1429  dims[4] , dims[5] , dims[6] , dims[7] ) );
1430  dst.m_impl_handle = src.m_impl_handle.scalar_ptr ;
1431  }
1432 };
1433 
1434 } // namespace Impl
1435 } // namespace Kokkos
1436 
1437 //----------------------------------------------------------------------------
1438 
1439 namespace Kokkos {
1440 namespace Impl {
1441 
1442 // Subview mapping
1443 
1444 template< class DataType, class ... P , class Arg0, class ... Args >
1445 struct ViewMapping
1446  < typename std::enable_if<(
1447  // Source view has MP::Vector only
1448  std::is_same< typename Kokkos::ViewTraits<DataType,P...>::specialize
1449  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1450  &&
1451  (
1452  std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1453  , Kokkos::LayoutLeft >::value ||
1454  std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1455  , Kokkos::LayoutRight >::value ||
1456  std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1457  , Kokkos::LayoutStride >::value
1458  )
1459  && !Sacado::MP::is_vector_partition<Arg0>::value
1460  )>::type
1461  , Kokkos::ViewTraits<DataType,P...>
1462  , Arg0, Args ... >
1463 {
1464 private:
1465 
1466  typedef Kokkos::ViewTraits<DataType,P...> SrcTraits;
1467 
1468  //static_assert( SrcTraits::rank == sizeof...(Args) , "" );
1469 
1470  enum
1471  { RZ = false
1472  , R0 = bool(is_integral_extent<0,Arg0,Args...>::value)
1473  , R1 = bool(is_integral_extent<1,Arg0,Args...>::value)
1474  , R2 = bool(is_integral_extent<2,Arg0,Args...>::value)
1475  , R3 = bool(is_integral_extent<3,Arg0,Args...>::value)
1476  , R4 = bool(is_integral_extent<4,Arg0,Args...>::value)
1477  , R5 = bool(is_integral_extent<5,Arg0,Args...>::value)
1478  , R6 = bool(is_integral_extent<6,Arg0,Args...>::value)
1479  };
1480 
1481  // Public rank
1482  enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
1483  + unsigned(R4) + unsigned(R5) + unsigned(R6) };
1484 
1485  // Whether right-most non-MP::Vector rank is a range.
1486  enum { R0_rev = ( 0 == SrcTraits::rank ? RZ : (
1487  1 == SrcTraits::rank ? R0 : (
1488  2 == SrcTraits::rank ? R1 : (
1489  3 == SrcTraits::rank ? R2 : (
1490  4 == SrcTraits::rank ? R3 : (
1491  5 == SrcTraits::rank ? R4 : (
1492  6 == SrcTraits::rank ? R5 : R6 ))))))) };
1493 
1494  // Subview's layout
1495  typedef typename std::conditional<
1496  ( /* Same array layout IF */
1497  ( rank == 0 ) /* output rank zero */
1498  ||
1499  // OutputRank 1 or 2, InputLayout Left, Interval 0
1500  // because single stride one or second index has a stride.
1501  ( rank <= 2 && R0 && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value )
1502  ||
1503  // OutputRank 1 or 2, InputLayout Right, Interval [InputRank-1]
1504  // because single stride one or second index has a stride.
1505  ( rank <= 2 && R0_rev && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value )
1506  ), typename SrcTraits::array_layout , Kokkos::LayoutStride
1508 
1510 
1511  typedef typename std::conditional< rank == 0 , sacado_mp_vector_type ,
1512  typename std::conditional< rank == 1 , sacado_mp_vector_type * ,
1513  typename std::conditional< rank == 2 , sacado_mp_vector_type ** ,
1514  typename std::conditional< rank == 3 , sacado_mp_vector_type *** ,
1515  typename std::conditional< rank == 4 , sacado_mp_vector_type **** ,
1516  typename std::conditional< rank == 5 , sacado_mp_vector_type ***** ,
1517  typename std::conditional< rank == 6 , sacado_mp_vector_type ****** ,
1518  sacado_mp_vector_type *******
1521 
1522 public:
1523 
1524  typedef Kokkos::ViewTraits
1525  < data_type
1526  , array_layout
1527  , typename SrcTraits::device_type
1528  , typename SrcTraits::memory_traits > traits_type ;
1529 
1530  typedef Kokkos::View
1531  < data_type
1532  , array_layout
1533  , typename SrcTraits::device_type
1534  , typename SrcTraits::memory_traits > type ;
1535 
1536 
1537  // The presumed type is 'ViewMapping< traits_type , void >'
1538  // However, a compatible ViewMapping is acceptable.
1539  template< class DstTraits >
1540  KOKKOS_INLINE_FUNCTION
1541  static void assign( ViewMapping< DstTraits , typename DstTraits::specialize > & dst
1542  , ViewMapping< SrcTraits , typename SrcTraits::specialize > const & src
1543  , Arg0 arg0, Args ... args )
1544  {
1545  static_assert(
1546  ViewMapping< DstTraits , traits_type , typename DstTraits::specialize >::is_assignable ,
1547  "Subview destination type must be compatible with subview derived type" );
1548 
1549  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
1550  typedef typename DstType::offset_type dst_offset_type ;
1551 
1552  const SubviewExtents< SrcTraits::rank , rank >
1553  extents( src.m_impl_offset.m_dim , arg0 , args... );
1554 
1555  const size_t offset = src.m_impl_offset( extents.domain_offset(0)
1556  , extents.domain_offset(1)
1557  , extents.domain_offset(2)
1558  , extents.domain_offset(3)
1559  , extents.domain_offset(4)
1560  , extents.domain_offset(5)
1561  , extents.domain_offset(6)
1562  , extents.domain_offset(7) );
1563 
1564  dst.m_impl_offset = dst_offset_type( src.m_impl_offset , extents );
1565  dst.m_impl_handle.value_ptr = src.m_impl_handle.value_ptr + offset;
1566  dst.m_impl_handle.scalar_ptr =
1567  src.m_impl_handle.scalar_ptr + offset * src.m_stride * src.m_sacado_size.value;
1568  dst.m_stride = src.m_stride;
1569  dst.m_sacado_size = src.m_sacado_size;
1570  }
1571 
1572 };
1573 
1574 } // namespace Impl
1575 } // namespace Kokkos
1576 
1577 //----------------------------------------------------------------------------
1578 //----------------------------------------------------------------------------
1579 //----------------------------------------------------------------------------
1580 
1581 namespace Kokkos {
1582 namespace Impl {
1583 
1584 // Partition mapping
1585 
1586 template< class DataType, class ...P, unsigned Size >
1587 class ViewMapping<
1588  void,
1589  ViewTraits<DataType,P...> ,
1590  Sacado::MP::VectorPartition<Size> >
1591 {
1592 public:
1593 
1594  enum { is_assignable = true };
1595 
1596  typedef ViewTraits<DataType,P...> src_traits;
1597  typedef ViewMapping< src_traits , typename src_traits::specialize > src_type ;
1598 
1599  typedef typename src_type::offset_type::dimension_type src_dimension;
1602  typedef typename storage_type::template apply_N<Size> storage_apply;
1603  typedef typename storage_apply::type strided_storage_type;
1605  typedef typename
1606  ViewDataType< strided_value_type , src_dimension >::type strided_data_type;
1607  typedef ViewTraits<strided_data_type,P...> dst_traits;
1608  typedef View<strided_data_type,P...> type;
1609  typedef ViewMapping< dst_traits , typename dst_traits::specialize > dst_type ;
1610 
1611  KOKKOS_INLINE_FUNCTION static
1612  void assign( dst_type & dst
1613  , const src_type & src
1614  , const Sacado::MP::VectorPartition<Size> & part )
1615  {
1616  // The pointer assignments below are not sufficient for dynamically sized
1617  // scalar types, so disallow this case for now
1618  static_assert( storage_type::is_static,
1619  "For performance reasons, partitioned assignment is only implemented for statically-sized MP::Vector types" );
1620 
1621  unsigned len = part.end - part.begin;
1622  if ( Size != len || Size == 0 ) {
1623  Kokkos::abort("\n\n ****** Kokkos::View< Sacado::MP::Vector ... > Invalid size in partitioned view assignment ******\n\n");
1624  }
1625 
1626  dst.m_impl_handle.value_ptr =
1627  reinterpret_cast<strided_value_type*>( src.m_impl_handle.value_ptr ) +
1628  part.begin / len ;
1629  dst.m_impl_handle.scalar_ptr = src.m_impl_handle.scalar_ptr +
1630  (part.begin / len) * src.m_stride * src.m_sacado_size.value ;
1631  dst.m_impl_offset = src.m_impl_offset ;
1632  dst.m_stride = src.m_stride * src.m_sacado_size.value / Size ;
1633  dst.m_sacado_size = len ;
1634  }
1635 };
1636 
1637 } // namespace Impl
1638 } // namespace Kokkos
1639 
1640 namespace Kokkos {
1641 
1642 template< unsigned Size, typename D, typename ... P >
1643 KOKKOS_INLINE_FUNCTION
1644 typename Kokkos::Impl::ViewMapping< void, typename Kokkos::ViewTraits<D,P...>, Sacado::MP::VectorPartition<Size> >::type
1645 partition( const Kokkos::View<D,P...> & src ,
1646  const unsigned beg )
1647 {
1648  typedef Kokkos::ViewTraits<D,P...> traits;
1649  typedef typename Kokkos::Impl::ViewMapping< void, traits, Sacado::MP::VectorPartition<Size> >::type DstViewType;
1650  const Sacado::MP::VectorPartition<Size> part( beg , beg+Size );
1651  return DstViewType(src, part);
1652 }
1653 
1654 } // namespace Kokkos
1655 
1656 //----------------------------------------------------------------------------
1657 //----------------------------------------------------------------------------
1658 //----------------------------------------------------------------------------
1659 
1660 namespace Kokkos {
1661 namespace Impl {
1662 
1663 // Specialization for deep_copy( view, view::value_type ) for Cuda
1664 #if defined( KOKKOS_ENABLE_CUDA )
1665 template< class OutputView >
1666 struct StokhosViewFill< OutputView ,
1667  typename std::enable_if< std::is_same< typename OutputView::specialize,
1668  Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&
1669  std::is_same< typename OutputView::execution_space,
1670  Cuda >::value >::type >
1671 {
1672  typedef typename OutputView::const_value_type const_value_type ;
1673  typedef typename OutputView::execution_space execution_space ;
1674  typedef typename OutputView::size_type size_type ;
1675 
1676  template <unsigned VectorLength>
1677  struct Kernel {
1678  typedef typename OutputView::execution_space execution_space ;
1679  const OutputView output;
1680  const_value_type input;
1681 
1682  Kernel( const OutputView & arg_out , const_value_type & arg_in ) :
1683  output(arg_out), input(arg_in) {}
1684 
1685  typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member ;
1686 
1687  KOKKOS_INLINE_FUNCTION
1688  void operator()( const team_member & dev ) const
1689  {
1690  const size_type tidx = dev.team_rank() % VectorLength;
1691  const size_type tidy = dev.team_rank() / VectorLength;
1692  const size_type nrow = dev.team_size() / VectorLength;
1693  const size_type nvec = dimension_scalar(output);
1694 
1695  const size_type i0 = dev.league_rank() * nrow + tidy;
1696  if ( i0 >= output.extent(0) ) return;
1697 
1698  for ( size_type i1 = 0 ; i1 < output.extent(1) ; ++i1 ) {
1699  for ( size_type i2 = 0 ; i2 < output.extent(2) ; ++i2 ) {
1700  for ( size_type i3 = 0 ; i3 < output.extent(3) ; ++i3 ) {
1701  for ( size_type i4 = 0 ; i4 < output.extent(4) ; ++i4 ) {
1702  for ( size_type i5 = 0 ; i5 < output.extent(5) ; ++i5 ) {
1703  for ( size_type i6 = 0 ; i6 < output.extent(6) ; ++i6 ) {
1704  for ( size_type i7 = 0 ; i7 < output.extent(7) ; ++i7 ) {
1705  for ( size_type is = tidx ; is < nvec ; is+=VectorLength ) {
1706  output.access(i0,i1,i2,i3,i4,i5,i6,i7).fastAccessCoeff(is) =
1707  input.fastAccessCoeff(is) ;
1708  }}}}}}}}
1709  }
1710  };
1711 
1712  StokhosViewFill( const OutputView & output , const_value_type & input )
1713  {
1714  if ( Sacado::is_constant(input) ) {
1715  deep_copy( output , input.fastAccessCoeff(0) );
1716  }
1717  else {
1718 
1719  // Coalesced accesses are 128 bytes in size
1721  const unsigned vector_length =
1722  ( 128 + sizeof(scalar_type)-1 ) / sizeof(scalar_type);
1723 
1724  // 8 warps per block should give good occupancy
1725  const size_type block_size = 256;
1726 
1727  const size_type rows_per_block = block_size / vector_length;
1728  const size_type n = output.extent(0);
1729  const size_type league_size = ( n + rows_per_block-1 ) / rows_per_block;
1730  const size_type team_size = rows_per_block * vector_length;
1731  Kokkos::TeamPolicy< execution_space > config( league_size, team_size );
1732 
1733  parallel_for( config, Kernel<vector_length>(output, input) );
1734  execution_space::fence();
1735  }
1736  }
1737 
1738 };
1739 #endif /* #if defined( KOKKOS_ENABLE_CUDA ) */
1740 
1741 } // namespace Impl
1742 } // namespace Kokkos
1743 
1744 //----------------------------------------------------------------------------
1745 //----------------------------------------------------------------------------
1746 //----------------------------------------------------------------------------
1747 
1748 namespace Kokkos {
1749 namespace Impl {
1750 
1751 struct ViewSpecializeSacadoFad;
1752 
1759 template< class DstTraits , class SrcTraits >
1760 class ViewMapping< DstTraits , SrcTraits ,
1761  typename std::enable_if<(
1762  Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1763  , typename SrcTraits::memory_space >::assignable
1764  &&
1765  // Destination view has MP::Vector only
1766  std::is_same< typename DstTraits::specialize
1767  , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1768  &&
1769  // Source view has FAD only
1770  std::is_same< typename SrcTraits::specialize
1771  , ViewSpecializeSacadoFad >::value
1772  )
1773  , typename DstTraits::specialize
1774  >::type >
1775 {
1776 public:
1777 
1778  enum { is_assignable = true };
1779 
1780  typedef Kokkos::Impl::SharedAllocationTracker TrackType ;
1781  typedef ViewMapping< DstTraits , typename DstTraits::specialize > DstType ;
1782  typedef ViewMapping< SrcTraits , typename SrcTraits::specialize > SrcFadType ;
1783 
1784  template< class DstType >
1785  KOKKOS_INLINE_FUNCTION static
1786  void assign( DstType & dst
1787  , const SrcFadType & src
1788  , const TrackType & )
1789  {
1790  static_assert(
1791  (
1792  std::is_same< typename DstTraits::array_layout
1793  , Kokkos::LayoutLeft >::value ||
1794  std::is_same< typename DstTraits::array_layout
1795  , Kokkos::LayoutRight >::value ||
1796  std::is_same< typename DstTraits::array_layout
1797  , Kokkos::LayoutStride >::value
1798  )
1799  &&
1800  (
1801  std::is_same< typename SrcTraits::array_layout
1802  , Kokkos::LayoutLeft >::value ||
1803  std::is_same< typename SrcTraits::array_layout
1804  , Kokkos::LayoutRight >::value ||
1805  std::is_same< typename SrcTraits::array_layout
1806  , Kokkos::LayoutStride >::value
1807  )
1808  , "View of FAD requires LayoutLeft, LayoutRight, or LayoutStride" );
1809 
1810  static_assert(
1811  std::is_same< typename DstTraits::array_layout
1812  , typename SrcTraits::array_layout >::value ||
1813  std::is_same< typename DstTraits::array_layout
1814  , Kokkos::LayoutStride >::value ,
1815  "View assignment must have compatible layout" );
1816 
1817  static_assert(
1818  std::is_same< typename DstTraits::data_type
1819  , typename SrcTraits::scalar_array_type >::value ||
1820  std::is_same< typename DstTraits::data_type
1821  , typename SrcTraits::const_scalar_array_type >::value ,
1822  "View assignment must have same value type or const = non-const" );
1823 
1824  static_assert(
1825  ViewDimensionAssignable
1826  < typename DstType::offset_type::dimension_type
1827  , typename SrcFadType::array_offset_type::dimension_type >::value ,
1828  "View assignment must have compatible dimensions" );
1829 
1830  typedef typename DstType::offset_type dst_offset_type ;
1831 
1832  dst.m_impl_offset = dst_offset_type( src.m_array_offset );
1833  dst.m_impl_handle.assign(src.m_impl_handle) ;
1834  dst.m_stride = 1;
1835 
1836  // Don't need to set dst.m_sacado_size since it is determined statically
1837  static_assert( DstType::is_static,
1838  "Destination view must be statically allocated" );
1839  }
1840 };
1841 
1842 } // namespace Impl
1843 } // namespace Kokkos
1844 
1845 //----------------------------------------------------------------------------
1846 //----------------------------------------------------------------------------
1847 //----------------------------------------------------------------------------
1848 
1849 #include "Kokkos_View_Utils_Def.hpp"
1850 
1851 #endif /* #ifndef KOKKOS_EXPERIMENTAL_VIEW_MP_VECTOR_CONTIGUOUS_HPP */
KOKKOS_INLINE_FUNCTION MPVectorAllocation & operator=(const MPVectorAllocation< T, true > &a)
Stokhos::StandardStorage< int, double > storage_type
static KOKKOS_INLINE_FUNCTION constexpr size_t memory_span(const size_t span, const unsigned vector_size)
KOKKOS_INLINE_FUNCTION MPVectorAllocation & operator=(const MPVectorAllocation< T, false > &a)
Kokkos::DefaultExecutionSpace execution_space
std::conditional< std::is_same< ArrayLayout, Kokkos::LayoutLeft >::value, prepend_scalar_dimension, append_scalar_dimension >::type scalar_dimension
ConstructDestructFunctor< ExecSpace > create_functor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size) const
KOKKOS_INLINE_FUNCTION void set(value_type *ptr, const size_t span, const unsigned vector_size)
KOKKOS_INLINE_FUNCTION constexpr std::enable_if< is_view_uq_pce< View< T, P...> >::value, unsigned >::type dimension_scalar(const View< T, P...> &view)
std::conditional< rank==0, sacado_mp_vector_type, typename std::conditional< rank==1, sacado_mp_vector_type *, typename std::conditional< rank==2, sacado_mp_vector_type **, typename std::conditional< rank==3, sacado_mp_vector_type ***, typename std::conditional< rank==4, sacado_mp_vector_type ****, typename std::conditional< rank==5, sacado_mp_vector_type *****, typename std::conditional< rank==6, sacado_mp_vector_type ******, sacado_mp_vector_type ******* >::type >::type >::type >::type >::type >::type >::type data_type
KOKKOS_INLINE_FUNCTION void set(value_type *ptr, const size_t span, const unsigned vector_size)
VectorConstruct(const ExecSpace &space, value_type *p, scalar_type *sp, const size_t span, const unsigned vector_size)
static KOKKOS_INLINE_FUNCTION constexpr size_t memory_span(const size_t span, const unsigned vector_size)
KOKKOS_INLINE_FUNCTION bool is_constant(const T &x)
void deep_copy(const Stokhos::CrsMatrix< ValueType, DstDevice, Layout > &dst, const Stokhos::CrsMatrix< ValueType, SrcDevice, Layout > &src)
ConstructDestructFunctor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size, scalar_type *scalar_ptr, value_type *value_ptr)
ConstructDestructFunctor< ExecSpace > create_functor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size) const
KOKKOS_INLINE_FUNCTION Kokkos::Impl::ViewMapping< void, typename Kokkos::ViewTraits< D, P...>, Sacado::MP::VectorPartition< Size > >::type partition(const Kokkos::View< D, P...> &src, const unsigned beg)
ConstructDestructFunctor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size, scalar_type *scalar_ptr)
static KOKKOS_INLINE_FUNCTION void assign(dst_type &dst, const src_type &src, const Sacado::MP::VectorPartition< Size > &part)
Stokhos::CrsMatrix< ValueType, Device, Layout >::HostMirror create_mirror(const Stokhos::CrsMatrix< ValueType, Device, Layout > &A)
int n