42 #ifndef KOKKOS_EXPERIMENTAL_VIEW_MP_VECTOR_CONTIGUOUS_HPP 43 #define KOKKOS_EXPERIMENTAL_VIEW_MP_VECTOR_CONTIGUOUS_HPP 45 #include "Sacado_Traits.hpp" 51 #include "Kokkos_Core_fwd.hpp" 52 #include "Kokkos_View.hpp" 53 #include "Kokkos_Layout.hpp" 63 template<
class Space,
class T,
class ... P>
70 namespace Experimental {
75 template<
class ... Args >
78 template<
class D ,
class ... P ,
class ... Args >
81 std::is_same<
typename Kokkos::ViewTraits<D,P...>::specialize
84 ( (
sizeof...(Args) == 0 ) ||
94 template <
typename T,
typename ... P>
98 std::is_same<
typename view_type::specialize,
102 template <
typename T,
typename ... P>
103 KOKKOS_INLINE_FUNCTION
107 return view.implementation_map().dimension_scalar();
113 template<
class T ,
class ... P >
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);
124 template<
class T ,
class ... P >
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);
135 template<
class Space,
class T,
class ... P>
136 typename Impl::MirrorType<Space,T,P ...>::view_type
139 const Kokkos::View<T,P...> & src,
140 typename std::enable_if<
141 std::is_same<
typename ViewTraits<T,P...>::specialize ,
145 template<
class DT,
class ... DP >
147 const View<DT,DP...> & view ,
149 ,
typename std::enable_if<(
150 std::is_same<
typename ViewTraits<DT,DP...>::specialize
155 template<
class DT,
class ... DP >
157 const View<DT,DP...> & view ,
159 ,
typename std::enable_if<(
160 std::is_same<
typename ViewTraits<DT,DP...>::specialize
165 template<
class ExecSpace ,
class DT,
class ... DP >
168 const View<DT,DP...> & view ,
170 ,
typename std::enable_if<(
171 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
172 std::is_same<
typename ViewTraits<DT,DP...>::specialize
177 template<
class ExecSpace ,
class DT,
class ... DP >
180 const View<DT,DP...> & view ,
182 ,
typename std::enable_if<(
183 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
184 std::is_same<
typename ViewTraits<DT,DP...>::specialize
189 template<
class DT ,
class ... DP ,
class ST ,
class ... SP >
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
197 std::is_same<
typename ViewTraits<ST,SP...>::specialize
205 #include "Kokkos_Core.hpp" 209 template <
typename D,
typename ... P>
211 typename std::enable_if< is_view_mp_vector< View<D,P...> >::value >
::type > {
213 typedef typename view_type::traits::dimension
dimension;
215 typedef typename Kokkos::Impl::ViewDataType< flat_value_type , dimension >::type
flat_data_type;
219 template<
class T ,
class ... P >
221 typename Kokkos::View<T,P...>::HostMirror
223 ,
typename std::enable_if<
224 std::is_same<
typename ViewTraits<T,P...>::specialize ,
227 ! std::is_same<
typename Kokkos::ViewTraits<T,P...>::array_layout
228 , Kokkos::LayoutStride >::value
232 typedef View<T,P...> src_type ;
233 typedef typename src_type::HostMirror dst_type ;
235 typename src_type::array_layout layout = src.layout();
238 return dst_type(std::string(src.label()).append(
"_mirror"), layout);
241 template<
class T ,
class ... P >
243 typename Kokkos::View<T,P...>::HostMirror
245 ,
typename std::enable_if<
246 std::is_same<
typename ViewTraits<T,P...>::specialize ,
249 std::is_same<
typename Kokkos::ViewTraits<T,P...>::array_layout
250 , Kokkos::LayoutStride >::value
254 typedef View<T,P...> src_type ;
255 typedef typename src_type::HostMirror dst_type ;
257 Kokkos::LayoutStride layout ;
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);
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();
279 return dst_type(std::string(src.label()).append(
"_mirror"), layout);
282 template<
class Space,
class T,
class ... P>
283 typename Impl::MirrorType<Space,T,P ...>::view_type
285 ,
typename std::enable_if<
286 std::is_same<
typename ViewTraits<T,P...>::specialize ,
289 typedef View<T,P...> src_type ;
290 typename src_type::array_layout layout = src.layout();
296 template<
class DT,
class ... DP >
298 const View<DT,DP...> & view ,
300 ,
typename std::enable_if<(
301 std::is_same<
typename ViewTraits<DT,DP...>::specialize
307 typename ViewTraits<DT,DP...>::non_const_value_type >::value
308 ,
"Can only deep copy into non-const type" );
310 typedef typename FlatArrayType< View<DT,DP...> >::type flat_array_type;
315 template<
class DT,
class ... DP >
317 const View<DT,DP...> & view ,
319 ,
typename std::enable_if<(
320 std::is_same<
typename ViewTraits<DT,DP...>::specialize
326 typename ViewTraits<DT,DP...>::non_const_value_type >::value
327 ,
"Can only deep copy into non-const type" );
340 template<
class ExecSpace ,
class DT,
class ... DP >
343 const View<DT,DP...> & view ,
345 ,
typename std::enable_if<(
346 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
347 std::is_same<
typename ViewTraits<DT,DP...>::specialize
353 typename ViewTraits<DT,DP...>::non_const_value_type >::value
354 ,
"Can only deep copy into non-const type" );
356 typedef typename FlatArrayType< View<DT,DP...> >::type flat_array_type;
361 template<
class ExecSpace ,
class DT,
class ... DP >
364 const View<DT,DP...> & view ,
366 ,
typename std::enable_if<(
367 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
368 std::is_same<
typename ViewTraits<DT,DP...>::specialize
374 typename ViewTraits<DT,DP...>::non_const_value_type >::value
375 ,
"Can only deep copy into non-const type" );
388 template<
class DT ,
class ... DP ,
class ST ,
class ... SP >
391 const View<ST,SP...> & src
392 ,
typename std::enable_if<(
393 std::is_same<
typename ViewTraits<DT,DP...>::specialize
396 std::is_same<
typename ViewTraits<ST,SP...>::specialize
402 typename ViewTraits<DT,DP...>::non_const_value_type >::value
403 ,
"Deep copy destination must be non-const" );
406 (
unsigned(ViewTraits<DT,DP...>::rank) ==
407 unsigned(ViewTraits<ST,SP...>::rank) )
408 ,
"Deep copy destination and source must have same rank" );
430 template<
class DataType ,
class ArrayLayout ,
typename StorageType >
431 struct ViewDataAnalysis< DataType
433 ,
Sacado::MP::Vector< StorageType > >
439 static const int DimVector = StorageType::static_size;
453 ViewDataType< value_type , dimension >::type
type ;
455 ViewDataType< const_value_type , dimension >::type
const_type ;
462 enum { is_const = std::is_same< value_type , const_value_type >::value };
466 std::conditional< is_const , const ScalarType , ScalarType >::type
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,
492 ViewDataType< const_scalar_type , scalar_dimension >::type
496 ViewDataType< non_const_scalar_type , scalar_dimension >::type
506 namespace Experimental {
509 template <
class ValueType,
510 bool is_static = Sacado::IsStaticallySized<ValueType>::value >
516 template <
class ValueType>
524 KOKKOS_INLINE_FUNCTION
525 static constexpr
size_t 530 KOKKOS_INLINE_FUNCTION
533 template <
typename T>
534 KOKKOS_INLINE_FUNCTION
536 value_ptr = a.value_ptr;
537 scalar_ptr = a.scalar_ptr;
541 KOKKOS_INLINE_FUNCTION
542 void set(
value_type* ptr,
const size_t span,
const unsigned vector_size) {
547 template <
class ExecSpace>
548 struct ConstructDestructFunctor {
549 typedef Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type >
FunctorType ;
553 ConstructDestructFunctor() =
default;
554 ConstructDestructFunctor(
const ConstructDestructFunctor&) =
default;
555 ConstructDestructFunctor& operator=(
const ConstructDestructFunctor&) =
default;
558 const bool initialize,
560 const unsigned vector_size,
562 m_functor( space , scalar_ptr , span*vector_size ),
563 m_initialize(initialize) {}
567 m_functor.construct_shared_allocation();
572 m_functor.destroy_shared_allocation();
577 template <
class ExecSpace>
578 inline ConstructDestructFunctor<ExecSpace>
580 const bool initialize,
582 const unsigned vector_size)
const {
583 return ConstructDestructFunctor<ExecSpace>(space, initialize, span, vector_size, scalar_ptr);
587 template <
typename T>
588 KOKKOS_INLINE_FUNCTION
590 value_ptr =
reinterpret_cast<value_type*
>(ptr);
601 template <
class ValueType>
609 KOKKOS_INLINE_FUNCTION
610 static constexpr
size_t 615 KOKKOS_INLINE_FUNCTION
618 template <
typename T>
619 KOKKOS_INLINE_FUNCTION
621 value_ptr = a.value_ptr;
622 scalar_ptr = a.scalar_ptr;
629 KOKKOS_INLINE_FUNCTION
630 void set(
value_type* ptr,
const size_t span,
const unsigned vector_size) {
632 scalar_ptr =
reinterpret_cast<scalar_type*
>(ptr+span);
635 template <
class ExecSpace>
636 struct VectorConstruct {
643 VectorConstruct() =
default;
644 VectorConstruct(
const VectorConstruct&) =
default;
645 VectorConstruct& operator=(
const VectorConstruct&) =
default;
652 const unsigned vector_size) :
653 m_space(space), m_p(p), m_sp(sp), m_span(span), m_vector_size(vector_size) {}
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 ) );
664 for (
size_t i = 0 ; i < m_span ; ++i )
operator()(i);
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);
674 template <
class ExecSpace>
675 struct ConstructDestructFunctor {
682 ConstructDestructFunctor() =
default;
683 ConstructDestructFunctor(
const ConstructDestructFunctor&) =
default;
684 ConstructDestructFunctor& operator=(
const ConstructDestructFunctor&) =
default;
687 const bool initialize,
689 const unsigned vector_size,
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) {}
699 m_scalar_functor.construct_shared_allocation();
711 m_vector_functor.execute();
718 m_scalar_functor.destroy_shared_allocation();
723 template <
class ExecSpace>
724 inline ConstructDestructFunctor<ExecSpace>
726 const bool initialize,
728 const unsigned vector_size)
const {
729 return ConstructDestructFunctor<ExecSpace>(space, initialize, span, vector_size, scalar_ptr, value_ptr);
734 template <
typename T>
735 KOKKOS_INLINE_FUNCTION
737 value_ptr =
reinterpret_cast<value_type*
>(ptr);
739 scalar_ptr = value_ptr->coeff();
750 template<
class Traits >
751 class ViewMapping< Traits ,
752 typename std::enable_if<
753 ( std::is_same< typename Traits::specialize
754 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
756 ( std::is_same< typename Traits::array_layout
757 , Kokkos::LayoutLeft >::value
759 std::is_same< typename Traits::array_layout
760 , Kokkos::LayoutRight >::value
762 std::is_same< typename Traits::array_layout
763 , Kokkos::LayoutStride >::value
769 template< class ,
class ... >
friend class ViewMapping ;
770 template< class ,
class ... >
friend class Kokkos::View ;
778 enum { StokhosStorageStaticDimension = stokhos_storage_type::static_size };
779 typedef Sacado::integral_nonzero< unsigned , StokhosStorageStaticDimension >
sacado_size_type;
783 typedef ViewOffset<
typename Traits::dimension
784 ,
typename Traits::array_layout
792 typedef ViewOffset<
typename array_dimension::
793 template append<StokhosStorageStaticDimension>::type,
794 typename Traits::array_layout,
797 typedef ViewOffset<
typename array_dimension::
798 template prepend<0>::type,
799 typename Traits::array_layout,
802 typedef typename std::conditional<
803 std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft>::value,
837 enum { Rank = Traits::dimension::rank };
840 enum { Sacado_Rank = std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value ? 0 : Rank+1 };
843 template<
typename iType >
844 KOKKOS_INLINE_FUNCTION constexpr
size_t extent(
const iType & r )
const 845 {
return m_offset.m_dim.extent(r); }
847 KOKKOS_INLINE_FUNCTION constexpr
848 typename Traits::array_layout
layout()
const 849 {
return m_offset.layout(); }
852 {
return m_offset.dimension_0(); }
854 {
return m_offset.dimension_1(); }
856 {
return m_offset.dimension_2(); }
858 {
return m_offset.dimension_3(); }
860 {
return m_offset.dimension_4(); }
862 {
return m_offset.dimension_5(); }
864 {
return m_offset.dimension_6(); }
866 {
return m_offset.dimension_7(); }
874 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_0()
const 875 {
return m_offset.stride_0(); }
876 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_1()
const 877 {
return m_offset.stride_1(); }
878 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_2()
const 879 {
return m_offset.stride_2(); }
880 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_3()
const 881 {
return m_offset.stride_3(); }
882 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_4()
const 883 {
return m_offset.stride_4(); }
884 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_5()
const 885 {
return m_offset.stride_5(); }
886 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_6()
const 887 {
return m_offset.stride_6(); }
888 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_7()
const 889 {
return m_offset.stride_7(); }
891 template<
typename iType >
892 KOKKOS_INLINE_FUNCTION
void stride( iType *
const s )
const 893 { m_offset.stride(s); }
897 {
return m_sacado_size.value; }
900 static const bool is_static = stokhos_storage_type::is_static ;
903 static const bool is_contiguous =
true;
915 KOKKOS_INLINE_FUNCTION constexpr
size_t span()
const 916 {
return m_offset.span(); }
920 {
return m_offset.span_is_contiguous() && (m_stride == 1); }
924 {
return m_handle.value_ptr ; }
928 KOKKOS_FORCEINLINE_FUNCTION
930 {
return *m_handle.value_ptr; }
933 template<
typename I0 >
934 KOKKOS_FORCEINLINE_FUNCTION
936 std::enable_if< std::is_integral<I0>::value &&
937 ! std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
938 , reference_type >::type
940 {
return m_handle.value_ptr[m_stride * i0]; }
943 template<
typename I0 >
944 KOKKOS_FORCEINLINE_FUNCTION
946 std::enable_if< std::is_integral<I0>::value &&
947 std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
948 , reference_type >::type
950 {
return m_handle.value_ptr[ m_stride * m_offset(i0) ]; }
952 template<
typename I0 ,
typename I1 >
953 KOKKOS_FORCEINLINE_FUNCTION
955 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1) ]; }
957 template<
typename I0 ,
typename I1 ,
typename I2 >
958 KOKKOS_FORCEINLINE_FUNCTION
960 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2) ]; }
962 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3 >
963 KOKKOS_FORCEINLINE_FUNCTION
965 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2,i3) ]; }
967 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
969 KOKKOS_FORCEINLINE_FUNCTION
971 ,
const I4 & i4 )
const 972 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2,i3,i4) ]; }
974 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
975 ,
typename I4 ,
typename I5 >
976 KOKKOS_FORCEINLINE_FUNCTION
978 ,
const I4 & i4 ,
const I5 & i5 )
const 979 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2,i3,i4,i5) ]; }
981 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
982 ,
typename I4 ,
typename I5 ,
typename I6 >
983 KOKKOS_FORCEINLINE_FUNCTION
985 ,
const I4 & i4 ,
const I5 & i5 ,
const I6 & i6 )
const 986 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2,i3,i4,i5,i6) ]; }
988 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
989 ,
typename I4 ,
typename I5 ,
typename I6 ,
typename I7 >
990 KOKKOS_FORCEINLINE_FUNCTION
992 ,
const I4 & i4 ,
const I5 & i5 ,
const I6 & i6 ,
const I7 & i7 )
const 993 {
return m_handle.value_ptr[ m_stride * m_offset(i0,i1,i2,i3,i4,i5,i6,i7) ]; }
998 KOKKOS_INLINE_FUNCTION
999 static size_t memory_span(
typename Traits::array_layout
const & layout )
1002 typedef std::integral_constant< unsigned , 0 > padding ;
1006 return handle_type::memory_span( offset.span(), sacado_size.value );
1011 KOKKOS_INLINE_FUNCTION ~ViewMapping() = default ;
1019 KOKKOS_INLINE_FUNCTION ViewMapping(
const ViewMapping & ) = default ;
1020 KOKKOS_INLINE_FUNCTION ViewMapping & operator = (
const ViewMapping & ) = default ;
1022 KOKKOS_INLINE_FUNCTION ViewMapping( ViewMapping && ) = default ;
1023 KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( ViewMapping && ) = default ;
1025 template<
class ... P >
1026 KOKKOS_INLINE_FUNCTION
1028 ( ViewCtorProp< P ... >
const & prop
1029 ,
typename Traits::array_layout
const & layout
1032 , m_offset( std::integral_constant< unsigned , 0 >()
1037 m_handle.set( ( (ViewCtorProp<void,pointer_type>
const &) prop ).value,
1038 m_offset.span(), m_sacado_size.value );
1046 template<
class ... P >
1047 SharedAllocationRecord<> *
1049 ,
typename Traits::array_layout
const & layout )
1051 typedef ViewCtorProp< P... > ctor_prop ;
1054 typedef typename Traits::memory_space memory_space ;
1055 typedef typename handle_type::template ConstructDestructFunctor<execution_space> functor_type ;
1056 typedef SharedAllocationRecord< memory_space , functor_type > record_type ;
1059 typedef std::integral_constant< unsigned , 0 > padding ;
1065 const size_t alloc_size =
1066 handle_type::memory_span( m_offset.span(), m_sacado_size.value );
1069 record_type *
const record =
1070 record_type::allocate( ( (ViewCtorProp<void,memory_space>
const &) prop ).value
1071 , ( (ViewCtorProp<void,std::string>
const &) prop ).value
1078 m_handle.set( reinterpret_cast< pointer_type >( record->data() ),
1079 m_offset.span(), m_sacado_size.value );
1083 record->m_destroy = m_handle.create_functor(
1084 ( (ViewCtorProp<void,execution_space>
const &) prop).value
1085 , ctor_prop::initialize
1087 , m_sacado_size.value );
1090 record->m_destroy.construct_shared_allocation();
1126 template<
class DstTraits ,
class SrcTraits >
1127 class ViewMapping< DstTraits , SrcTraits ,
1128 typename std::enable_if<(
1129 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1130 , typename SrcTraits::memory_space >::assignable
1133 std::is_same< typename DstTraits::specialize
1134 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1137 std::is_same< typename SrcTraits::specialize
1138 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1143 enum { is_assignable =
true };
1149 KOKKOS_INLINE_FUNCTION
static 1156 std::is_same<
typename DstTraits::array_layout
1157 , Kokkos::LayoutLeft >::value ||
1158 std::is_same<
typename DstTraits::array_layout
1159 , Kokkos::LayoutRight >::value ||
1160 std::is_same<
typename DstTraits::array_layout
1161 , Kokkos::LayoutStride >::value
1165 std::is_same<
typename SrcTraits::array_layout
1166 , Kokkos::LayoutLeft >::value ||
1167 std::is_same<
typename SrcTraits::array_layout
1168 , Kokkos::LayoutRight >::value ||
1169 std::is_same<
typename SrcTraits::array_layout
1170 , Kokkos::LayoutStride >::value
1172 ,
"View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1175 std::is_same<
typename DstTraits::array_layout
1176 ,
typename SrcTraits::array_layout >::value ||
1177 std::is_same<
typename DstTraits::array_layout
1178 , Kokkos::LayoutStride >::value ||
1179 (
unsigned(DstTraits::rank) == 0 &&
unsigned(SrcTraits::rank) == 0 ) ||
1180 (
unsigned(DstTraits::rank) == 1 &&
unsigned(SrcTraits::rank) == 1 ) ,
1181 "View assignment must have compatible layout" );
1187 ,
typename SrcTraits::const_value_type >::value ,
1188 "View assignment must have same value type or const = non-const" );
1191 ViewDimensionAssignable
1192 <
typename DstType::offset_type::dimension_type
1193 ,
typename SrcType::offset_type::dimension_type >::value ,
1194 "View assignment must have compatible dimensions" );
1196 dst.m_handle = src.m_handle ;
1197 dst.m_offset = src.m_offset ;
1198 dst.m_stride = src.m_stride ;
1199 dst.m_sacado_size = src.m_sacado_size ;
1208 template<
class DstTraits ,
class SrcTraits >
1209 class ViewMapping< DstTraits , SrcTraits ,
1210 typename std::enable_if<(
1211 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1212 , typename SrcTraits::memory_space >::assignable
1215 std::is_same< typename DstTraits::specialize , void >::value
1218 std::is_same< typename SrcTraits::specialize
1219 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1222 unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)+1
1227 enum { is_assignable =
true };
1233 KOKKOS_INLINE_FUNCTION
static 1240 std::is_same<
typename DstTraits::array_layout
1241 , Kokkos::LayoutLeft >::value ||
1242 std::is_same<
typename DstTraits::array_layout
1243 , Kokkos::LayoutRight >::value ||
1244 std::is_same<
typename DstTraits::array_layout
1245 , Kokkos::LayoutStride >::value
1249 std::is_same<
typename SrcTraits::array_layout
1250 , Kokkos::LayoutLeft >::value ||
1251 std::is_same<
typename SrcTraits::array_layout
1252 , Kokkos::LayoutRight >::value ||
1253 std::is_same<
typename SrcTraits::array_layout
1254 , Kokkos::LayoutStride >::value
1256 ,
"View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1259 std::is_same<
typename DstTraits::array_layout
1260 ,
typename SrcTraits::array_layout >::value ||
1261 std::is_same<
typename DstTraits::array_layout
1262 , Kokkos::LayoutStride >::value ,
1263 "View assignment must have compatible layout" );
1266 std::is_same<
typename DstTraits::scalar_array_type
1267 ,
typename SrcTraits::scalar_array_type >::value ||
1268 std::is_same<
typename DstTraits::scalar_array_type
1269 ,
typename SrcTraits::const_scalar_array_type >::value ,
1270 "View assignment must have same value type or const = non-const" );
1273 ViewDimensionAssignable<
1274 typename DstType::offset_type::dimension_type,
1275 typename SrcType::array_offset_type::dimension_type >::value,
1276 "View assignment must have compatible dimensions" );
1278 if ( src.m_stride != 1 ) {
1279 Kokkos::abort(
"\n\n ****** Kokkos::View< Sacado::MP::Vector ... > cannot assign with non-unit stride ******\n\n");
1283 dims[0] = src.m_offset.dimension_0();
1284 dims[1] = src.m_offset.dimension_1();
1285 dims[2] = src.m_offset.dimension_2();
1286 dims[3] = src.m_offset.dimension_3();
1287 dims[4] = src.m_offset.dimension_4();
1288 dims[5] = src.m_offset.dimension_5();
1289 dims[6] = src.m_offset.dimension_6();
1290 dims[7] = src.m_offset.dimension_7();
1291 unsigned rank = SrcTraits::dimension::rank;
1292 unsigned sacado_size = src.m_sacado_size.value;
1293 if (std::is_same<typename SrcTraits::array_layout, LayoutLeft>::value) {
1295 for (
unsigned i=rank; i>0; --i)
1296 dims[i] = dims[i-1];
1297 dims[0] = sacado_size;
1300 dims[rank] = sacado_size;
1302 typedef typename DstType::offset_type dst_offset_type;
1303 dst.m_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1304 typename DstTraits::array_layout(
1305 dims[0] , dims[1] , dims[2] , dims[3] ,
1306 dims[4] , dims[5] , dims[6] , dims[7] ) );
1307 dst.m_handle = src.m_handle.scalar_ptr ;
1317 template<
class DstTraits ,
class SrcTraits >
1318 class ViewMapping< DstTraits , SrcTraits ,
1319 typename std::enable_if<(
1320 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1321 , typename SrcTraits::memory_space >::assignable
1324 std::is_same< typename DstTraits::specialize , void >::value
1327 std::is_same< typename SrcTraits::specialize
1328 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1331 unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)
1336 enum { is_assignable =
true };
1342 KOKKOS_INLINE_FUNCTION
static 1349 std::is_same<
typename DstTraits::array_layout
1350 , Kokkos::LayoutLeft >::value ||
1351 std::is_same<
typename DstTraits::array_layout
1352 , Kokkos::LayoutRight >::value ||
1353 std::is_same<
typename DstTraits::array_layout
1354 , Kokkos::LayoutStride >::value
1358 std::is_same<
typename SrcTraits::array_layout
1359 , Kokkos::LayoutLeft >::value ||
1360 std::is_same<
typename SrcTraits::array_layout
1361 , Kokkos::LayoutRight >::value ||
1362 std::is_same<
typename SrcTraits::array_layout
1363 , Kokkos::LayoutStride >::value
1365 ,
"View of MP::Vector requires LayoutLeft, LayoutRight, or LayoutStride" );
1368 std::is_same<
typename DstTraits::array_layout
1369 ,
typename SrcTraits::array_layout >::value ||
1370 std::is_same<
typename DstTraits::array_layout
1371 , Kokkos::LayoutStride >::value ,
1372 "View assignment must have compatible layout" );
1379 "View assignment must have same value type or const = non-const" );
1382 ViewDimensionAssignable<
1383 typename DstType::offset_type::dimension_type,
1384 typename SrcType::offset_type::dimension_type >::value,
1385 "View assignment must have compatible dimensions" );
1387 if ( src.m_stride != 1 ) {
1388 Kokkos::abort(
"\n\n ****** Kokkos::View< Sacado::MP::Vector ... > cannot assign with non-unit stride ******\n\n");
1392 dims[0] = src.m_offset.dimension_0();
1393 dims[1] = src.m_offset.dimension_1();
1394 dims[2] = src.m_offset.dimension_2();
1395 dims[3] = src.m_offset.dimension_3();
1396 dims[4] = src.m_offset.dimension_4();
1397 dims[5] = src.m_offset.dimension_5();
1398 dims[6] = src.m_offset.dimension_6();
1399 dims[7] = src.m_offset.dimension_7();
1400 unsigned rank = SrcTraits::dimension::rank;
1401 unsigned sacado_size = src.m_sacado_size.value;
1402 if (std::is_same<typename DstTraits::array_layout, LayoutLeft>::value) {
1403 dims[0] = dims[0]*sacado_size;
1407 dims[rank-1] = dims[rank-1]*sacado_size;
1410 typedef typename DstType::offset_type dst_offset_type;
1411 dst.m_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1412 typename DstTraits::array_layout(
1413 dims[0] , dims[1] , dims[2] , dims[3] ,
1414 dims[4] , dims[5] , dims[6] , dims[7] ) );
1415 dst.m_handle = src.m_handle.scalar_ptr ;
1429 template<
class DataType,
class ... P ,
class Arg0,
class ... Args >
1431 < typename std::enable_if<(
1433 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::specialize
1434 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1437 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1438 , Kokkos::LayoutLeft >::value ||
1439 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1440 , Kokkos::LayoutRight >::value ||
1441 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1442 , Kokkos::LayoutStride >::value
1444 && !Sacado::MP::is_vector_partition<Arg0>::value
1446 , Kokkos::ViewTraits<DataType,P...>
1457 , R0 = bool(is_integral_extent<0,Arg0,Args...>::value)
1458 , R1 = bool(is_integral_extent<1,Arg0,Args...>::value)
1459 , R2 = bool(is_integral_extent<2,Arg0,Args...>::value)
1460 , R3 = bool(is_integral_extent<3,Arg0,Args...>::value)
1461 , R4 = bool(is_integral_extent<4,Arg0,Args...>::value)
1462 , R5 = bool(is_integral_extent<5,Arg0,Args...>::value)
1463 , R6 = bool(is_integral_extent<6,Arg0,Args...>::value)
1467 enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
1468 + unsigned(R4) + unsigned(R5) + unsigned(R6) };
1471 enum { R0_rev = ( 0 == SrcTraits::rank ? RZ : (
1472 1 == SrcTraits::rank ? R0 : (
1473 2 == SrcTraits::rank ? R1 : (
1474 3 == SrcTraits::rank ? R2 : (
1475 4 == SrcTraits::rank ? R3 : (
1476 5 == SrcTraits::rank ? R4 : (
1477 6 == SrcTraits::rank ? R5 : R6 ))))))) };
1480 typedef typename std::conditional<
1486 ( rank <= 2 && R0 && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value )
1490 ( rank <= 2 && R0_rev && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value )
1491 ),
typename SrcTraits::array_layout , Kokkos::LayoutStride
1509 typedef Kokkos::ViewTraits
1512 ,
typename SrcTraits::device_type
1515 typedef Kokkos::View
1518 ,
typename SrcTraits::device_type
1519 ,
typename SrcTraits::memory_traits >
type ;
1524 template<
class DstTraits >
1525 KOKKOS_INLINE_FUNCTION
1526 static void assign( ViewMapping< DstTraits , void > & dst
1527 , ViewMapping< SrcTraits , void >
const & src
1528 , Arg0 arg0, Args ... args )
1531 ViewMapping< DstTraits , traits_type , void >::is_assignable ,
1532 "Subview destination type must be compatible with subview derived type" );
1534 typedef ViewMapping< DstTraits , void > DstType ;
1535 typedef typename DstType::offset_type dst_offset_type ;
1537 const SubviewExtents< SrcTraits::rank , rank >
1538 extents( src.m_offset.m_dim , arg0 , args... );
1540 const size_t offset = src.m_offset( extents.domain_offset(0)
1541 , extents.domain_offset(1)
1542 , extents.domain_offset(2)
1543 , extents.domain_offset(3)
1544 , extents.domain_offset(4)
1545 , extents.domain_offset(5)
1546 , extents.domain_offset(6)
1547 , extents.domain_offset(7) );
1549 dst.m_offset = dst_offset_type( src.m_offset , extents );
1550 dst.m_handle.value_ptr = src.m_handle.value_ptr + offset;
1551 dst.m_handle.scalar_ptr =
1552 src.m_handle.scalar_ptr + offset * src.m_stride * src.m_sacado_size.value;
1553 dst.m_stride = src.m_stride;
1554 dst.m_sacado_size = src.m_sacado_size;
1571 template<
class DataType,
class ...P,
unsigned Size >
1574 ViewTraits<DataType,P...> ,
1575 Sacado::MP::VectorPartition<Size> >
1579 enum { is_assignable =
true };
1596 KOKKOS_INLINE_FUNCTION
static 1599 ,
const Sacado::MP::VectorPartition<Size> & part )
1603 static_assert( storage_type::is_static,
1604 "For performance reasons, partitioned assignment is only implemented for statically-sized MP::Vector types" );
1606 unsigned len = part.end - part.begin;
1607 if ( Size != len || Size == 0 ) {
1608 Kokkos::abort(
"\n\n ****** Kokkos::View< Sacado::MP::Vector ... > Invalid size in partitioned view assignment ******\n\n");
1611 dst.m_handle.value_ptr =
1614 dst.m_handle.scalar_ptr = src.m_handle.scalar_ptr +
1615 (part.begin / len) * src.m_stride * src.m_sacado_size.value ;
1616 dst.m_offset = src.m_offset ;
1617 dst.m_stride = src.m_stride * src.m_sacado_size.value / Size ;
1618 dst.m_sacado_size = len ;
1627 template<
unsigned Size,
typename D,
typename ... P >
1628 KOKKOS_INLINE_FUNCTION
1629 typename Kokkos::Impl::ViewMapping< void,
typename Kokkos::ViewTraits<D,P...>, Sacado::MP::VectorPartition<Size> >::type
1631 const unsigned beg )
1633 typedef Kokkos::ViewTraits<D,P...> traits;
1634 typedef typename Kokkos::Impl::ViewMapping< void, traits, Sacado::MP::VectorPartition<Size> >::type DstViewType;
1635 const Sacado::MP::VectorPartition<Size> part( beg , beg+Size );
1636 return DstViewType(src, part);
1649 #if defined( KOKKOS_ENABLE_CUDA ) 1650 template<
class OutputView >
1651 struct StokhosViewFill< OutputView ,
1652 typename std::enable_if< std::is_same< typename OutputView::specialize,
1653 Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&
1654 std::is_same< typename OutputView::execution_space,
1655 Cuda >::value >::type >
1659 typedef typename OutputView::size_type size_type ;
1661 template <
unsigned VectorLength>
1670 typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member ;
1672 KOKKOS_INLINE_FUNCTION
1673 void operator()(
const team_member & dev )
const 1675 const size_type tidx = dev.team_rank() % VectorLength;
1676 const size_type tidy = dev.team_rank() / VectorLength;
1677 const size_type nrow = dev.team_size() / VectorLength;
1680 const size_type i0 = dev.league_rank() * nrow + tidy;
1681 if ( i0 >=
output.extent(0) )
return;
1683 for ( size_type i1 = 0 ; i1 <
output.extent(1) ; ++i1 ) {
1684 for ( size_type i2 = 0 ; i2 <
output.extent(2) ; ++i2 ) {
1685 for ( size_type i3 = 0 ; i3 <
output.extent(3) ; ++i3 ) {
1686 for ( size_type i4 = 0 ; i4 <
output.extent(4) ; ++i4 ) {
1687 for ( size_type i5 = 0 ; i5 <
output.extent(5) ; ++i5 ) {
1688 for ( size_type i6 = 0 ; i6 <
output.extent(6) ; ++i6 ) {
1689 for ( size_type i7 = 0 ; i7 <
output.extent(7) ; ++i7 ) {
1690 for ( size_type is = tidx ; is < nvec ; is+=VectorLength ) {
1691 output.access(i0,i1,i2,i3,i4,i5,i6,i7).fastAccessCoeff(is) =
1692 input.fastAccessCoeff(is) ;
1706 const unsigned vector_length =
1710 const size_type block_size = 256;
1712 const size_type rows_per_block = block_size / vector_length;
1713 const size_type n =
output.extent(0);
1714 const size_type league_size = ( n + rows_per_block-1 ) / rows_per_block;
1715 const size_type team_size = rows_per_block * vector_length;
1716 Kokkos::TeamPolicy< execution_space > config( league_size, team_size );
1718 parallel_for( config, Kernel<vector_length>(
output,
input) );
1719 execution_space::fence();
1736 struct ViewSpecializeSacadoFad;
1744 template<
class DstTraits ,
class SrcTraits >
1745 class ViewMapping< DstTraits , SrcTraits ,
1746 typename std::enable_if<(
1747 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1748 , typename SrcTraits::memory_space >::assignable
1751 std::is_same< typename DstTraits::specialize
1752 , Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value
1755 std::is_same< typename SrcTraits::specialize
1756 , ViewSpecializeSacadoFad >::value
1761 enum { is_assignable =
true };
1767 template<
class DstType >
1768 KOKKOS_INLINE_FUNCTION
static 1775 std::is_same<
typename DstTraits::array_layout
1776 , Kokkos::LayoutLeft >::value ||
1777 std::is_same<
typename DstTraits::array_layout
1778 , Kokkos::LayoutRight >::value ||
1779 std::is_same<
typename DstTraits::array_layout
1780 , Kokkos::LayoutStride >::value
1784 std::is_same<
typename SrcTraits::array_layout
1785 , Kokkos::LayoutLeft >::value ||
1786 std::is_same<
typename SrcTraits::array_layout
1787 , Kokkos::LayoutRight >::value ||
1788 std::is_same<
typename SrcTraits::array_layout
1789 , Kokkos::LayoutStride >::value
1791 ,
"View of FAD requires LayoutLeft, LayoutRight, or LayoutStride" );
1794 std::is_same<
typename DstTraits::array_layout
1795 ,
typename SrcTraits::array_layout >::value ||
1796 std::is_same<
typename DstTraits::array_layout
1797 , Kokkos::LayoutStride >::value ,
1798 "View assignment must have compatible layout" );
1801 std::is_same<
typename DstTraits::data_type
1802 ,
typename SrcTraits::scalar_array_type >::value ||
1803 std::is_same<
typename DstTraits::data_type
1804 ,
typename SrcTraits::const_scalar_array_type >::value ,
1805 "View assignment must have same value type or const = non-const" );
1808 ViewDimensionAssignable
1809 <
typename DstType::offset_type::dimension_type
1810 ,
typename SrcFadType::array_offset_type::dimension_type >::value ,
1811 "View assignment must have compatible dimensions" );
1813 typedef typename DstType::offset_type dst_offset_type ;
1815 dst.m_offset = dst_offset_type( src.m_array_offset );
1816 dst.m_handle.assign(src.m_handle) ;
1820 static_assert( DstType::is_static,
1821 "Destination view must be statically allocated" );
KOKKOS_INLINE_FUNCTION void stride(iType *const s) const
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4) const
KOKKOS_INLINE_FUNCTION constexpr Traits::array_layout layout() const
ViewDataType< const_scalar_type, scalar_dimension >::type const_scalar_array_type
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2) const
static KOKKOS_INLINE_FUNCTION void assign(dst_type &dst, const src_type &src, const Sacado::MP::VectorPartition< Size > &part)
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5) const
KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const
Sacado::ValueType< value_type >::type scalar_type
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
KOKKOS_INLINE_FUNCTION constexpr size_t span() const
Span of the mapped range : [ data() .. data() + span() )
KOKKOS_INLINE_FUNCTION MPVectorAllocation & operator=(const MPVectorAllocation< T, true > &a)
mp_vector_type::storage_type storage_type
Stokhos::StandardStorage< int, double > storage_type
void destroy_shared_allocation()
ViewDataType< scalar_type, scalar_dimension >::type scalar_array_type
ScalarType non_const_scalar_type
VectorConstruct< ExecSpace > VectorFunctorType
VectorFunctorType m_vector_functor
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const
ViewMapping< dst_traits, void > dst_type
ViewMapping< SrcTraits, void > SrcType
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
ViewDataType< value_type, dimension >::type type
static KOKKOS_INLINE_FUNCTION constexpr size_t memory_span(const size_t span, const unsigned vector_size)
array_analysis::const_value_type const_value_type
KOKKOS_INLINE_FUNCTION MPVectorAllocation & operator=(const MPVectorAllocation< T, false > &a)
Kokkos::Impl::SharedAllocationTracker TrackType
sacado_mp_vector_type::storage_type stokhos_storage_type
Kokkos::DefaultExecutionSpace execution_space
Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type > ScalarFunctorType
KOKKOS_INLINE_FUNCTION MPVectorAllocation()
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const
ViewMapping< DstTraits, void > DstType
KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const
Kokkos::Experimental::Impl::MPVectorAllocation< sacado_mp_vector_type > handle_type
View< strided_data_type, P... > type
std::conditional< std::is_same< ArrayLayout, Kokkos::LayoutLeft >::value, prepend_scalar_dimension, append_scalar_dimension >::type scalar_dimension
array_analysis::non_const_value_type non_const_value_type
Kokkos::Impl::SharedAllocationTracker TrackType
ViewOffset< typename array_dimension::template append< StokhosStorageStaticDimension >::type, typename Traits::array_layout, void > append_offset_type
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::data_type 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
view_type::array_type::value_type flat_value_type
KOKKOS_FORCEINLINE_FUNCTION std::enable_if< std::is_integral< I0 >::value &&std::is_same< typename Traits::array_layout, Kokkos::LayoutStride >::value, reference_type >::type reference(const I0 &i0) const
ViewDataType< const_value_type, dimension >::type const_type
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const
std::add_const< intrinsic_scalar_type >::type const_intrinsic_scalar_type
View< D, P... > view_type
KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType &r) const
ViewMapping< DstTraits, void > DstType
KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const
ConstructDestructFunctor< ExecSpace > create_functor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size) const
KOKKOS_FORCEINLINE_FUNCTION constexpr unsigned dimension_scalar() const
Sacado::MP::Vector< strided_storage_type > strided_value_type
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const
OutputView::const_value_type const_value_type
KOKKOS_INLINE_FUNCTION void assign(T *ptr)
Kokkos::Impl::SharedAllocationTracker TrackType
ViewTraits< DataType, P... > src_traits
void construct_shared_allocation()
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::array_layout std::conditional<((rank==0)||(rank<=2 &&R0 &&std::is_same< typename SrcTraits::array_layout, Kokkos::LayoutLeft >::value)||(rank<=2 &&R0_rev &&std::is_same< typename SrcTraits::array_layout, Kokkos::LayoutRight >::value)), typename SrcTraits::array_layout, Kokkos::LayoutStride >::type array_layout
ViewMapping< SrcTraits, void > SrcFadType
Kokkos::Impl::ViewDataType< flat_value_type, dimension >::type flat_data_type
KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7) const
StorageType::value_type ScalarType
VectorConstruct(const ExecSpace &space, value_type *p, scalar_type *sp, const size_t span, const unsigned vector_size)
KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const
Raw data access.
void construct_shared_allocation()
void destroy_shared_allocation()
std::false_type is_regular
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::traits_type Kokkos::ViewTraits< data_type, array_layout, typename SrcTraits::device_type, typename SrcTraits::memory_traits > traits_type
storage_apply::type strided_storage_type
static KOKKOS_INLINE_FUNCTION constexpr size_t memory_span(const size_t span, const unsigned vector_size)
std::conditional< is_const, const ScalarType, ScalarType >::type scalar_type
KOKKOS_INLINE_FUNCTION constexpr std::enable_if< is_view_uq_pce< View< T, P... > >::value, unsigned >::type dimension_scalar(const View< T, P... > &view)
KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
Is the mapped range span contiguous.
sacado_mp_vector_type & reference_type
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const
View< flat_data_type, P... > type
std::conditional< std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value, prepend_offset_type, append_offset_type >::type array_offset_type
src_traits::value_type mp_vector_type
ViewMapping< DstTraits, void > DstType
KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const
OutputView::execution_space execution_space
KOKKOS_INLINE_FUNCTION void operator()(const size_t i0) const
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3) const
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)
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const
Kokkos::Impl::SharedAllocationTracker TrackType
StokhosViewFill(const OutputView &arg_out, const_value_type &arg_in)
KOKKOS_FORCEINLINE_FUNCTION reference_type reference() const
KOKKOS_INLINE_FUNCTION ViewMapping()
array_analysis::dimension array_dimension
src_type::offset_type::dimension_type src_dimension
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6) const
ViewOffset< typename Traits::dimension, typename Traits::array_layout, void > offset_type
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcFadType &src, const TrackType &)
ConstructDestructFunctor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size, scalar_type *scalar_ptr, value_type *value_ptr)
storage_type::template apply_N< Size > storage_apply
Sacado::integral_nonzero< unsigned, StokhosStorageStaticDimension > sacado_size_type
Kokkos::Experimental::Impl::ViewMPVectorContiguous specialize
ViewMapping< SrcTraits, void > SrcType
static KOKKOS_INLINE_FUNCTION size_t memory_span(typename Traits::array_layout const &layout)
Span, in bytes, of the required memory.
ViewArrayAnalysis< typename Traits::data_type > array_analysis
ConstructDestructFunctor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size, scalar_type *scalar_ptr)
ViewDataType< non_const_scalar_type, scalar_dimension >::type non_const_scalar_array_type
view_type::traits::dimension dimension
ViewMapping< DstTraits, void > DstType
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::assign static KOKKOS_INLINE_FUNCTION void assign(ViewMapping< DstTraits, void > &dst, ViewMapping< SrcTraits, void > const &src, Arg0 arg0, Args ... args)
sacado_size_type m_sacado_size
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::SrcTraits Kokkos::ViewTraits< DataType, P... > SrcTraits
array_analysis::value_type value_type
Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type > FunctorType
sacado_mp_vector_type * pointer_type
Pointer to underlying memory type.
KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() 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)
KOKKOS_INLINE_FUNCTION MPVectorAllocation()
KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const
ViewArrayAnalysis< DataType > array_analysis
Sacado::ValueType< value_type >::type scalar_type
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1) const
array_analysis::dimension::template prepend< 0 >::type prepend_scalar_dimension
const ScalarType const_scalar_type
ViewMapping< SrcTraits, void > SrcType
ViewOffset< typename array_dimension::template prepend< 0 >::type, typename Traits::array_layout, void > prepend_offset_type
stokhos_storage_type::value_type intrinsic_scalar_type
ViewDataType< strided_value_type, src_dimension >::type strided_data_type
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::type Kokkos::View< data_type, array_layout, typename SrcTraits::device_type, typename SrcTraits::memory_traits > type
KOKKOS_INLINE_FUNCTION void assign(T *ptr)
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewMPVectorContiguous >::value &&(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutLeft >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutRight >::value||std::is_same< typename Kokkos::ViewTraits< DataType, P... >::array_layout, Kokkos::LayoutStride >::value) &&!Sacado::MP::is_vector_partition< Arg0 >::value)>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::sacado_mp_vector_type SrcTraits::value_type sacado_mp_vector_type
ViewMapping< src_traits, void > src_type
array_analysis::dimension dimension
KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const
Stokhos::CrsMatrix< ValueType, Device, Layout >::HostMirror create_mirror(const Stokhos::CrsMatrix< ValueType, Device, Layout > &A)
ScalarFunctorType m_scalar_functor
array_analysis::dimension::template append< DimVector >::type append_scalar_dimension
SharedAllocationRecord * allocate_shared(ViewCtorProp< P... > const &prop, typename Traits::array_layout const &layout)
ConstructDestructFunctor< ExecSpace > create_functor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned vector_size) const
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const
KOKKOS_FORCEINLINE_FUNCTION std::enable_if< std::is_integral< I0 >::value &&! std::is_same< typename Traits::array_layout, Kokkos::LayoutStride >::value, reference_type >::type reference(const I0 &i0) const
Traits::value_type sacado_mp_vector_type
View< T, P... > view_type
ViewDataType< non_const_value_type, dimension >::type non_const_type
ViewTraits< strided_data_type, P... > dst_traits