42 #ifndef KOKKOS_EXPERIMENTAL_VIEW_UQ_PCE_CONTIGUOUS_HPP 43 #define KOKKOS_EXPERIMENTAL_VIEW_UQ_PCE_CONTIGUOUS_HPP 47 #include "Kokkos_Core_fwd.hpp" 48 #include "Kokkos_View.hpp" 49 #include "Kokkos_Layout.hpp" 60 template <
typename Storage >
68 template<
class Space,
class T,
class ... P>
75 namespace Experimental {
80 template<
class ... Args >
83 template<
class D ,
class ... P ,
class ... Args >
86 std::is_same<
typename Kokkos::ViewTraits<D,P...>::specialize
89 ( (
sizeof...(Args) == 0 ) ||
102 template<
class T ,
class ... P >
104 typename Kokkos::View<T,P...>::HostMirror
106 const Kokkos::View<T,P...> & src,
107 typename std::enable_if<
108 std::is_same<
typename ViewTraits<T,P...>::specialize ,
110 !std::is_same<
typename Kokkos::ViewTraits<T,P...>::array_layout,
111 Kokkos::LayoutStride >::value >::type * = 0);
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 Space,
class T,
class ... P>
125 typename Impl::MirrorType<Space,T,P ...>::view_type
128 const Kokkos::View<T,P...> & src,
129 typename std::enable_if<
130 std::is_same<
typename ViewTraits<T,P...>::specialize ,
134 template<
class DT,
class ... DP >
136 const View<DT,DP...> & view ,
138 ,
typename std::enable_if<(
139 std::is_same<
typename ViewTraits<DT,DP...>::specialize
144 template<
class DT,
class ... DP >
146 const View<DT,DP...> & view ,
148 ,
typename std::enable_if<(
149 std::is_same<
typename ViewTraits<DT,DP...>::specialize
154 template<
class ExecSpace ,
class DT,
class ... DP >
157 const View<DT,DP...> & view ,
159 ,
typename std::enable_if<(
160 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
161 std::is_same<
typename ViewTraits<DT,DP...>::specialize
166 template<
class ExecSpace ,
class DT,
class ... DP >
169 const View<DT,DP...> & view ,
171 ,
typename std::enable_if<(
172 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
173 std::is_same<
typename ViewTraits<DT,DP...>::specialize
178 template<
class DT ,
class ... DP ,
class ST ,
class ... SP >
180 void deep_copy(
const View<DT,DP...> & dst ,
181 const View<ST,SP...> & src
182 ,
typename std::enable_if<(
183 std::is_same<
typename ViewTraits<DT,DP...>::specialize
186 std::is_same<
typename ViewTraits<ST,SP...>::specialize
190 template <
typename T,
typename ... P>
194 std::is_same<
typename view_type::specialize,
198 template <
typename ViewType>
200 typename std::enable_if< is_view_uq_pce< ViewType >::value >
::type > {
201 typedef typename ViewType::non_const_value_type::cijk_type
type;
204 template <
typename T,
typename ... P>
205 KOKKOS_INLINE_FUNCTION
207 std::enable_if<
is_view_uq_pce< View<T,P...> >::value,
unsigned >::type
209 return view.implementation_map().dimension_scalar();
212 template <
typename view_type>
213 KOKKOS_INLINE_FUNCTION
215 std::enable_if< is_view_uq_pce<view_type>::value,
216 typename CijkType<view_type>::type >::type
218 return view.implementation_map().cijk();
221 template <
typename view_type>
222 KOKKOS_INLINE_FUNCTION
224 std::enable_if< is_view_uq_pce<view_type>::value,
bool >::type
226 return view.implementation_map().is_allocation_contiguous();
229 template <
typename ViewType>
233 size_t N0 = 0,
size_t N1 = 0,
size_t N2 = 0,
size_t N3 = 0,
234 size_t N4 = 0,
size_t N5 = 0,
size_t N6 = 0,
size_t N7 = 0)
236 return ViewType(view_alloc(label,
cijk),
237 N0, N1, N2, N3, N4, N5, N6, N7);
240 template <
typename ViewType>
243 const Impl::WithoutInitializing_t& init,
245 size_t N0 = 0,
size_t N1 = 0,
size_t N2 = 0,
size_t N3 = 0,
246 size_t N4 = 0,
size_t N5 = 0,
size_t N6 = 0,
size_t N7 = 0)
248 return ViewType(view_alloc(label,init,
cijk),
249 N0, N1, N2, N3, N4, N5, N6, N7);
252 template <
typename ViewType>
256 size_t N0 = 0,
size_t N1 = 0,
size_t N2 = 0,
size_t N3 = 0,
257 size_t N4 = 0,
size_t N5 = 0,
size_t N6 = 0,
size_t N7 = 0)
259 return ViewType(view_alloc(init.label,
262 N0, N1, N2, N3, N4, N5, N6, N7);
265 template <
typename ViewType>
266 typename std::enable_if< is_view_uq_pce<ViewType>::value, ViewType>::type
269 size_t N0 = 0,
size_t N1 = 0,
size_t N2 = 0,
size_t N3 = 0,
270 size_t N4 = 0,
size_t N5 = 0,
size_t N6 = 0,
size_t N7 = 0)
272 size_t N[8] = { N0, N1, N2, N3, N4, N5, N6, N7 };
273 N[ViewType::rank] =
cijk.dimension();
274 ViewType v(view_wrap(ptr,
cijk),
275 N[0], N[1], N[2], N[3], N[4], N[5], N[6], N[7]);
281 #include "Sacado_Traits.hpp" 284 #include "Kokkos_Core.hpp" 288 template <
typename D,
typename ... P>
290 typename std::enable_if< is_view_uq_pce< View<D,P...> >::value >
::type > {
292 typedef typename view_type::traits::dimension
dimension;
294 typedef typename Kokkos::Impl::ViewDataType< flat_value_type , dimension >::type
flat_data_type;
298 template<
class T ,
class ... P >
300 typename Kokkos::View<T,P...>::HostMirror
302 ,
typename std::enable_if<
303 std::is_same<
typename ViewTraits<T,P...>::specialize ,
306 ! std::is_same<
typename Kokkos::ViewTraits<T,P...>::array_layout
307 , Kokkos::LayoutStride >::value
311 typedef View<T,P...> src_type ;
312 typedef typename src_type::HostMirror dst_type ;
314 typename src_type::array_layout layout = src.layout();
317 return dst_type(view_alloc(std::string(src.label()).append(
"_mirror"),
318 src.implementation_map().cijk()), layout);
321 template<
class T ,
class ... P >
323 typename Kokkos::View<T,P...>::HostMirror
325 ,
typename std::enable_if<
326 std::is_same<
typename ViewTraits<T,P...>::specialize ,
329 std::is_same<
typename Kokkos::ViewTraits<T,P...>::array_layout
330 , Kokkos::LayoutStride >::value
334 typedef View<T,P...> src_type ;
335 typedef typename src_type::HostMirror dst_type ;
337 Kokkos::LayoutStride layout ;
339 layout.dimension[0] = src.extent(0);
340 layout.dimension[1] = src.extent(1);
341 layout.dimension[2] = src.extent(2);
342 layout.dimension[3] = src.extent(3);
343 layout.dimension[4] = src.extent(4);
344 layout.dimension[5] = src.extent(5);
345 layout.dimension[6] = src.extent(6);
346 layout.dimension[7] = src.extent(7);
348 layout.stride[0] = src.stride_0();
349 layout.stride[1] = src.stride_1();
350 layout.stride[2] = src.stride_2();
351 layout.stride[3] = src.stride_3();
352 layout.stride[4] = src.stride_4();
353 layout.stride[5] = src.stride_5();
354 layout.stride[6] = src.stride_6();
355 layout.stride[7] = src.stride_7();
359 return dst_type(view_alloc(std::string(src.label()).append(
"_mirror"),
360 src.implementation_map().cijk()), layout);
363 template<
class Space,
class T,
class ... P>
364 typename Impl::MirrorType<Space,T,P ...>::view_type
366 ,
typename std::enable_if<
367 std::is_same<
typename ViewTraits<T,P...>::specialize ,
370 typedef View<T,P...> src_type ;
371 typename src_type::array_layout layout = src.layout();
374 view_alloc(src.label(), src.implementation_map().cijk()),layout);
378 template<
class DT,
class ... DP >
380 const View<DT,DP...> & view ,
382 ,
typename std::enable_if<(
383 std::is_same<
typename ViewTraits<DT,DP...>::specialize
389 typename ViewTraits<DT,DP...>::non_const_value_type >::value
390 ,
"Can only deep copy into non-const type" );
392 typedef View<DT,DP...> view_type;
402 template<
class DT,
class ... DP >
404 const View<DT,DP...> & view ,
406 ,
typename std::enable_if<(
407 std::is_same<
typename ViewTraits<DT,DP...>::specialize
413 typename ViewTraits<DT,DP...>::non_const_value_type >::value
414 ,
"Can only deep copy into non-const type" );
420 template<
class ExecSpace ,
class DT,
class ... DP >
423 const View<DT,DP...> & view ,
425 ,
typename std::enable_if<(
426 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
427 std::is_same<
typename ViewTraits<DT,DP...>::specialize
433 typename ViewTraits<DT,DP...>::non_const_value_type >::value
434 ,
"Can only deep copy into non-const type" );
436 typedef View<DT,DP...> view_type;
446 template<
class ExecSpace ,
class DT,
class ... DP >
449 const View<DT,DP...> & view ,
451 ,
typename std::enable_if<(
452 Kokkos::Impl::is_execution_space< ExecSpace >::value &&
453 std::is_same<
typename ViewTraits<DT,DP...>::specialize
459 typename ViewTraits<DT,DP...>::non_const_value_type >::value
460 ,
"Can only deep copy into non-const type" );
465 namespace Experimental {
470 template<
class OutputView ,
class InputView >
480 const InputView & arg_in ) :
483 parallel_for(
output.extent(0) , *this );
484 execution_space::fence();
487 KOKKOS_INLINE_FUNCTION
497 output.access(i0,i1,i2,i3,i4,i5,i6,i7) =
input.access(i0,i1,i2,i3,i4,i5,i6,i7) ;
506 template<
class DT ,
class ... DP ,
class ST ,
class ... SP >
509 const View<ST,SP...> & src
510 ,
typename std::enable_if<(
511 std::is_same<
typename ViewTraits<DT,DP...>::specialize
514 std::is_same<
typename ViewTraits<ST,SP...>::specialize
520 typename ViewTraits<DT,DP...>::non_const_value_type >::value
521 ,
"Deep copy destination must be non-const" );
524 (
unsigned(ViewTraits<DT,DP...>::rank) ==
525 unsigned(ViewTraits<ST,SP...>::rank) )
526 ,
"Deep copy destination and source must have same rank" );
528 typedef View<DT,DP...> dst_type ;
529 typedef View<ST,SP...> src_type ;
530 typedef typename dst_type::array_type dst_array_type ;
531 typedef typename src_type::array_type src_array_type ;
534 dst_array_type dst_array = dst ;
535 src_array_type src_array = src ;
543 if ( Impl::is_same<
typename dst_type::memory_space ,
544 typename src_type::memory_space >::value ) {
550 typedef View<
typename src_type::non_const_data_type ,
551 typename src_type::array_layout ,
553 typedef typename tmp_src_type::array_type tmp_src_array_type;
554 typedef View<
typename dst_type::non_const_data_type ,
555 typename dst_type::array_layout ,
557 typedef typename tmp_dst_type::array_type tmp_dst_array_type;
565 src_dims[0] = src.extent(0);
566 src_dims[1] = src.extent(1);
567 src_dims[2] = src.extent(2);
568 src_dims[3] = src.extent(3);
569 src_dims[4] = src.extent(4);
570 src_dims[5] = src.extent(5);
571 src_dims[6] = src.extent(6);
572 src_dims[7] = src.extent(7);
574 tmp_src_type src_tmp(
575 view_alloc(
"src_tmp" , WithoutInitializing,
cijk(src) ) ,
576 src_dims[0], src_dims[1], src_dims[2], src_dims[3],
577 src_dims[4], src_dims[5], src_dims[6], src_dims[7] );
579 dst_array_type dst_array = dst ;
580 tmp_src_array_type src_array = src_tmp ;
590 dst_dims[0] = dst.extent(0);
591 dst_dims[1] = dst.extent(1);
592 dst_dims[2] = dst.extent(2);
593 dst_dims[3] = dst.extent(3);
594 dst_dims[4] = dst.extent(4);
595 dst_dims[5] = dst.extent(5);
596 dst_dims[6] = dst.extent(6);
597 dst_dims[7] = dst.extent(7);
599 tmp_dst_type dst_tmp(
600 view_alloc(
"dst_tmp" , WithoutInitializing,
cijk(dst) ) ,
601 dst_dims[0], dst_dims[1], dst_dims[2], dst_dims[3],
602 dst_dims[4], dst_dims[5], dst_dims[6], dst_dims[7] );
603 tmp_dst_array_type dst_array = dst_tmp ;
604 src_array_type src_array = src ;
614 src_dims[0] = src.extent(0);
615 src_dims[1] = src.extent(1);
616 src_dims[2] = src.extent(2);
617 src_dims[3] = src.extent(3);
618 src_dims[4] = src.extent(4);
619 src_dims[5] = src.extent(5);
620 src_dims[6] = src.extent(6);
621 src_dims[7] = src.extent(7);
623 tmp_src_type src_tmp(
624 view_alloc(
"src_tmp" , WithoutInitializing,
cijk(src) ) ,
625 src_dims[0], src_dims[1], src_dims[2], src_dims[3],
626 src_dims[4], src_dims[5], src_dims[6], src_dims[7] );
630 dst_dims[0] = dst.extent(0);
631 dst_dims[1] = dst.extent(1);
632 dst_dims[2] = dst.extent(2);
633 dst_dims[3] = dst.extent(3);
634 dst_dims[4] = dst.extent(4);
635 dst_dims[5] = dst.extent(5);
636 dst_dims[6] = dst.extent(6);
637 dst_dims[7] = dst.extent(7);
639 tmp_dst_type dst_tmp(
640 view_alloc(
"dst_tmp" , WithoutInitializing,
cijk(dst) ) ,
641 dst_dims[0], dst_dims[1], dst_dims[2], dst_dims[3],
642 dst_dims[4], dst_dims[5], dst_dims[6], dst_dims[7] );
643 tmp_dst_array_type dst_array = dst_tmp ;
644 tmp_src_array_type src_array = src_tmp ;
663 template<
typename Value,
typename Execution,
typename Memory >
664 struct ViewCtorProp< void ,
Stokhos::CrsProductTensor<Value, Execution, Memory> >
666 ViewCtorProp() = default ;
667 ViewCtorProp(
const ViewCtorProp & ) = default ;
668 ViewCtorProp & operator = (
const ViewCtorProp & ) = default ;
678 template <
typename AllocProp>
684 template<
typename T >
690 template<
typename Value,
typename Execution,
typename Memory >
692 ViewCtorProp<
Stokhos::CrsProductTensor<Value, Execution, Memory> >
698 template<
typename T,
typename ... P >
709 template <
typename CijkType,
typename AllocProp>
710 KOKKOS_INLINE_FUNCTION
711 typename std::enable_if< !Impl::ctor_prop_has_cijk<AllocProp>::value,
718 template <
typename CijkType,
typename AllocProp>
719 KOKKOS_INLINE_FUNCTION
720 typename std::enable_if< Impl::ctor_prop_has_cijk<AllocProp>::value,
724 return ( (
const Impl::ViewCtorProp<void,CijkType>&) prop ).value;
736 template<
class DataType ,
class ArrayLayout ,
typename StorageType >
737 struct ViewDataAnalysis< DataType
739 ,
Sacado::UQ::PCE< StorageType > >
758 ViewDataType< value_type , dimension >::type
type ;
760 ViewDataType< const_value_type , dimension >::type
const_type ;
767 enum { is_const = std::is_same< value_type , const_value_type >::value };
771 std::conditional< is_const , const ScalarType , ScalarType >::type
778 typedef typename array_analysis::dimension::
779 template prepend<0>::type
781 typedef typename array_analysis::dimension::
782 template append<0>::type
784 typedef typename std::conditional<
785 std::is_same< ArrayLayout, Kokkos::LayoutLeft>::value,
796 ViewDataType< const_scalar_type , scalar_dimension >::type
800 ViewDataType< non_const_scalar_type , scalar_dimension >::type
810 namespace Experimental {
818 template <
class ValueType>
827 KOKKOS_INLINE_FUNCTION
828 static constexpr
size_t 833 KOKKOS_INLINE_FUNCTION
836 template <
typename T>
837 KOKKOS_INLINE_FUNCTION
847 KOKKOS_INLINE_FUNCTION
848 void set(
value_type* ptr,
const size_t span,
const unsigned pce_size) {
853 template <
class ExecSpace>
871 const unsigned pce_size,
877 if ( !
m_space.in_parallel() ) {
878 typedef Kokkos::RangePolicy< ExecSpace > PolicyType ;
879 const Kokkos::Impl::ParallelFor< PCEConstruct , PolicyType >
880 closure( *
this , PolicyType( 0 ,
m_span ) );
885 for (
size_t i = 0 ; i <
m_span ; ++i )
operator()(i);
889 KOKKOS_INLINE_FUNCTION
895 template <
class ExecSpace>
908 const bool initialize,
910 const unsigned pce_size,
945 template <
class ExecSpace>
946 inline ConstructDestructFunctor<ExecSpace>
948 const bool initialize,
950 const unsigned pce_size,
952 return ConstructDestructFunctor<ExecSpace>(space, initialize, span,
959 template <
typename T>
974 template<
class Traits >
975 class ViewMapping< Traits ,
976 typename std::enable_if<
977 ( std::is_same< typename Traits::specialize
978 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
980 ( std::is_same< typename Traits::array_layout
981 , Kokkos::LayoutLeft >::value
983 std::is_same< typename Traits::array_layout
984 , Kokkos::LayoutRight >::value
986 std::is_same< typename Traits::array_layout
987 , Kokkos::LayoutStride >::value
993 template< class ,
class ... >
friend class ViewMapping ;
994 template< class ,
class ... >
friend class Kokkos::View ;
1007 typedef ViewOffset<
typename Traits::dimension
1008 ,
typename Traits::array_layout
1015 typedef ViewOffset<
typename array_dimension::
1016 template append<0>::type,
1017 typename Traits::array_layout,
1020 typedef ViewOffset<
typename array_dimension::
1021 template prepend<0>::type,
1022 typename Traits::array_layout,
1025 typedef typename std::conditional<
1026 std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft>::value,
1039 KOKKOS_INLINE_FUNCTION
1041 const size_t sz = this->span();
1048 return last_coeff == last_coeff_expected;
1056 enum { Rank = Traits::dimension::rank };
1059 enum { Sacado_Rank = std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value ? 0 : Rank+1 };
1062 template<
typename iType >
1063 KOKKOS_INLINE_FUNCTION constexpr
size_t extent(
const iType & r )
const 1064 {
return m_offset.m_dim.extent(r); }
1066 KOKKOS_INLINE_FUNCTION constexpr
1068 {
return m_offset.layout(); }
1071 {
return m_offset.dimension_0(); }
1073 {
return m_offset.dimension_1(); }
1075 {
return m_offset.dimension_2(); }
1077 {
return m_offset.dimension_3(); }
1079 {
return m_offset.dimension_4(); }
1081 {
return m_offset.dimension_5(); }
1083 {
return m_offset.dimension_6(); }
1085 {
return m_offset.dimension_7(); }
1092 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_0()
const 1093 {
return m_offset.stride_0(); }
1094 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_1()
const 1095 {
return m_offset.stride_1(); }
1096 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_2()
const 1097 {
return m_offset.stride_2(); }
1098 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_3()
const 1099 {
return m_offset.stride_3(); }
1100 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_4()
const 1101 {
return m_offset.stride_4(); }
1102 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_5()
const 1103 {
return m_offset.stride_5(); }
1104 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_6()
const 1105 {
return m_offset.stride_6(); }
1106 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_7()
const 1107 {
return m_offset.stride_7(); }
1109 template<
typename iType >
1110 KOKKOS_INLINE_FUNCTION
void stride( iType *
const s )
const 1111 { m_offset.stride(s); }
1115 {
return m_sacado_size; }
1118 KOKKOS_FORCEINLINE_FUNCTION
1123 KOKKOS_FORCEINLINE_FUNCTION
1128 KOKKOS_INLINE_FUNCTION
1130 {
return m_is_contiguous; }
1133 static const bool is_static = false ;
1136 static const bool is_contiguous =
true;
1148 KOKKOS_INLINE_FUNCTION constexpr
size_t span()
const 1149 {
return m_offset.span(); }
1153 {
return m_offset.span_is_contiguous() ; }
1161 KOKKOS_FORCEINLINE_FUNCTION
1166 template<
typename I0 >
1167 KOKKOS_FORCEINLINE_FUNCTION
1169 std::enable_if< std::is_integral<I0>::value &&
1170 ! std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
1171 , reference_type >::type
1176 template<
typename I0 >
1177 KOKKOS_FORCEINLINE_FUNCTION
1179 std::enable_if< std::is_integral<I0>::value &&
1180 std::is_same< typename Traits::array_layout , Kokkos::LayoutStride >::value
1181 , reference_type >::type
1183 {
return m_handle.
value_ptr[ m_offset(i0) ]; }
1185 template<
typename I0 ,
typename I1 >
1186 KOKKOS_FORCEINLINE_FUNCTION
1188 {
return m_handle.
value_ptr[ m_offset(i0,i1) ]; }
1190 template<
typename I0 ,
typename I1 ,
typename I2 >
1191 KOKKOS_FORCEINLINE_FUNCTION
1193 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2) ]; }
1195 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3 >
1196 KOKKOS_FORCEINLINE_FUNCTION
1198 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2,i3) ]; }
1200 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
1202 KOKKOS_FORCEINLINE_FUNCTION
1204 ,
const I4 & i4 )
const 1205 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2,i3,i4) ]; }
1207 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
1208 ,
typename I4 ,
typename I5 >
1209 KOKKOS_FORCEINLINE_FUNCTION
1211 ,
const I4 & i4 ,
const I5 & i5 )
const 1212 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2,i3,i4,i5) ]; }
1214 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
1215 ,
typename I4 ,
typename I5 ,
typename I6 >
1216 KOKKOS_FORCEINLINE_FUNCTION
1218 ,
const I4 & i4 ,
const I5 & i5 ,
const I6 & i6 )
const 1219 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2,i3,i4,i5,i6) ]; }
1221 template<
typename I0 ,
typename I1 ,
typename I2 ,
typename I3
1222 ,
typename I4 ,
typename I5 ,
typename I6 ,
typename I7 >
1223 KOKKOS_FORCEINLINE_FUNCTION
1225 ,
const I4 & i4 ,
const I5 & i5 ,
const I6 & i6 ,
const I7 & i7 )
const 1226 {
return m_handle.
value_ptr[ m_offset(i0,i1,i2,i3,i4,i5,i6,i7) ]; }
1231 KOKKOS_INLINE_FUNCTION
1232 static size_t memory_span(
typename Traits::array_layout
const & layout )
1235 typedef std::integral_constant< unsigned , 0 > padding ;
1237 unsigned sacado_size =
1239 return handle_type::memory_span( offset.span(), sacado_size );
1244 KOKKOS_INLINE_FUNCTION ~ViewMapping() = default ;
1250 m_is_contiguous(
true)
1253 KOKKOS_INLINE_FUNCTION ViewMapping(
const ViewMapping & ) = default ;
1254 KOKKOS_INLINE_FUNCTION ViewMapping & operator = (
const ViewMapping & ) = default ;
1256 KOKKOS_INLINE_FUNCTION ViewMapping( ViewMapping && ) = default ;
1257 KOKKOS_INLINE_FUNCTION ViewMapping & operator = ( ViewMapping && ) = default ;
1259 template<
class ... P >
1260 KOKKOS_INLINE_FUNCTION
1262 ( ViewCtorProp< P ... >
const & prop
1263 ,
typename Traits::array_layout
const & layout
1266 , m_offset( std::integral_constant< unsigned , 0 >() , layout )
1269 m_handle.
set( ( (ViewCtorProp<void,pointer_type>
const &) prop ).value
1270 , m_offset.span(), m_sacado_size );
1271 m_cijk = extract_cijk<cijk_type>(prop);
1272 #ifndef __CUDA_ARCH__ 1273 if (m_cijk.dimension() == 0)
1274 m_cijk = getGlobalCijkTensor<cijk_type>();
1277 if (m_sacado_size == 0 || m_sacado_size == 1)
1278 m_sacado_size = m_cijk.dimension();
1280 m_is_contiguous = this->is_data_contiguous();
1288 template<
class ... P >
1289 SharedAllocationRecord<> *
1291 ,
typename Traits::array_layout
const & layout )
1293 typedef ViewCtorProp< P... > ctor_prop ;
1296 typedef typename Traits::memory_space memory_space ;
1297 typedef typename handle_type::template ConstructDestructFunctor<execution_space> functor_type ;
1298 typedef SharedAllocationRecord< memory_space , functor_type > record_type ;
1301 typedef std::integral_constant< unsigned , 0 > padding ;
1305 m_cijk = extract_cijk<cijk_type>(prop);
1306 if (m_cijk.dimension() == 0)
1307 m_cijk = getGlobalCijkTensor<cijk_type>();
1310 if (m_sacado_size == 0 || m_sacado_size == 1)
1311 m_sacado_size = m_cijk.dimension();
1312 m_is_contiguous =
true;
1314 const size_t alloc_size =
1315 handle_type::memory_span( m_offset.span(), m_sacado_size );
1318 record_type *
const record =
1319 record_type::allocate( ( (ViewCtorProp<void,memory_space>
const &) prop ).value
1320 , ( (ViewCtorProp<void,std::string>
const &) prop ).value
1327 m_handle.
set( reinterpret_cast< pointer_type >( record->data() ),
1328 m_offset.span(), m_sacado_size );
1333 ( (ViewCtorProp<void,execution_space>
const &) prop).value
1334 , ctor_prop::initialize
1340 record->m_destroy.construct_shared_allocation();
1360 template<
class DstTraits ,
class SrcTraits >
1361 class ViewMapping< DstTraits , SrcTraits ,
1362 typename std::enable_if<(
1363 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1364 , typename SrcTraits::memory_space >::assignable
1367 std::is_same< typename DstTraits::specialize
1368 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
1371 std::is_same< typename SrcTraits::specialize
1372 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
1377 enum { is_assignable =
true };
1383 KOKKOS_INLINE_FUNCTION
static 1390 std::is_same<
typename DstTraits::array_layout
1391 , Kokkos::LayoutLeft >::value ||
1392 std::is_same<
typename DstTraits::array_layout
1393 , Kokkos::LayoutRight >::value ||
1394 std::is_same<
typename DstTraits::array_layout
1395 , Kokkos::LayoutStride >::value
1399 std::is_same<
typename SrcTraits::array_layout
1400 , Kokkos::LayoutLeft >::value ||
1401 std::is_same<
typename SrcTraits::array_layout
1402 , Kokkos::LayoutRight >::value ||
1403 std::is_same<
typename SrcTraits::array_layout
1404 , Kokkos::LayoutStride >::value
1406 ,
"View of UQ::PCE requires LayoutLeft, LayoutRight, or LayoutStride" );
1409 std::is_same<
typename DstTraits::array_layout
1410 ,
typename SrcTraits::array_layout >::value ||
1411 std::is_same<
typename DstTraits::array_layout
1412 , Kokkos::LayoutStride >::value ||
1413 (
unsigned(DstTraits::rank) == 1 &&
unsigned(SrcTraits::rank) == 1 ) ,
1414 "View assignment must have compatible layout" );
1420 ,
typename SrcTraits::const_value_type >::value ,
1421 "View assignment must have same value type or const = non-const" );
1424 ViewDimensionAssignable
1425 <
typename DstType::offset_type::dimension_type
1426 ,
typename SrcType::offset_type::dimension_type >::value ,
1427 "View assignment must have compatible dimensions" );
1429 dst.m_handle = src.m_handle ;
1430 dst.m_offset = src.m_offset ;
1431 dst.m_sacado_size = src.m_sacado_size ;
1432 dst.m_cijk = src.m_cijk ;
1433 dst.m_is_contiguous = src.m_is_contiguous ;
1442 template<
class DstTraits ,
class SrcTraits >
1443 class ViewMapping< DstTraits , SrcTraits ,
1444 typename std::enable_if<(
1445 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1446 , typename SrcTraits::memory_space >::assignable
1449 std::is_same< typename DstTraits::specialize , void >::value
1452 std::is_same< typename SrcTraits::specialize
1453 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
1456 unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)+1
1461 enum { is_assignable =
true };
1467 KOKKOS_INLINE_FUNCTION
static 1474 std::is_same<
typename DstTraits::array_layout
1475 , Kokkos::LayoutLeft >::value ||
1476 std::is_same<
typename DstTraits::array_layout
1477 , Kokkos::LayoutRight >::value ||
1478 std::is_same<
typename DstTraits::array_layout
1479 , Kokkos::LayoutStride >::value
1483 std::is_same<
typename SrcTraits::array_layout
1484 , Kokkos::LayoutLeft >::value ||
1485 std::is_same<
typename SrcTraits::array_layout
1486 , Kokkos::LayoutRight >::value ||
1487 std::is_same<
typename SrcTraits::array_layout
1488 , Kokkos::LayoutStride >::value
1490 ,
"View of UQ::PCE requires LayoutLeft, LayoutRight, or LayoutStride" );
1493 std::is_same<
typename DstTraits::array_layout
1494 ,
typename SrcTraits::array_layout >::value ||
1495 std::is_same<
typename DstTraits::array_layout
1496 , Kokkos::LayoutStride >::value ,
1497 "View assignment must have compatible layout" );
1500 std::is_same<
typename DstTraits::scalar_array_type
1501 ,
typename SrcTraits::scalar_array_type >::value ||
1502 std::is_same<
typename DstTraits::scalar_array_type
1503 ,
typename SrcTraits::const_scalar_array_type >::value ,
1504 "View assignment must have same value type or const = non-const" );
1507 ViewDimensionAssignable<
1508 typename DstType::offset_type::dimension_type,
1509 typename SrcType::array_offset_type::dimension_type >::value,
1510 "View assignment must have compatible dimensions" );
1512 if ( !src.m_is_contiguous )
1513 Kokkos::abort(
"\n\n ****** Kokkos::View< Sacado::UQ::PCE ... >: can't assign non-contiguous view ******\n\n");
1516 dims[0] = src.m_offset.dimension_0();
1517 dims[1] = src.m_offset.dimension_1();
1518 dims[2] = src.m_offset.dimension_2();
1519 dims[3] = src.m_offset.dimension_3();
1520 dims[4] = src.m_offset.dimension_4();
1521 dims[5] = src.m_offset.dimension_5();
1522 dims[6] = src.m_offset.dimension_6();
1523 dims[7] = src.m_offset.dimension_7();
1524 unsigned rank = SrcTraits::dimension::rank;
1525 unsigned sacado_size = src.m_sacado_size;
1526 if (std::is_same<typename SrcTraits::array_layout, LayoutLeft>::value) {
1528 for (
unsigned i=rank; i>0; --i)
1529 dims[i] = dims[i-1];
1530 dims[0] = sacado_size;
1533 dims[rank] = sacado_size;
1535 typedef typename DstType::offset_type dst_offset_type;
1536 dst.m_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1537 typename DstTraits::array_layout(
1538 dims[0] , dims[1] , dims[2] , dims[3] ,
1539 dims[4] , dims[5] , dims[6] , dims[7] ) );
1540 dst.m_handle = src.m_handle.scalar_ptr ;
1550 template<
class DstTraits ,
class SrcTraits >
1551 class ViewMapping< DstTraits , SrcTraits ,
1552 typename std::enable_if<(
1553 Kokkos::Impl::MemorySpaceAccess< typename DstTraits::memory_space
1554 , typename SrcTraits::memory_space >::assignable
1557 std::is_same< typename DstTraits::specialize , void >::value
1560 std::is_same< typename SrcTraits::specialize
1561 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
1564 unsigned(DstTraits::dimension::rank) == unsigned(SrcTraits::dimension::rank)
1569 enum { is_assignable =
true };
1575 KOKKOS_INLINE_FUNCTION
static 1582 std::is_same<
typename DstTraits::array_layout
1583 , Kokkos::LayoutLeft >::value ||
1584 std::is_same<
typename DstTraits::array_layout
1585 , Kokkos::LayoutRight >::value ||
1586 std::is_same<
typename DstTraits::array_layout
1587 , Kokkos::LayoutStride >::value
1591 std::is_same<
typename SrcTraits::array_layout
1592 , Kokkos::LayoutLeft >::value ||
1593 std::is_same<
typename SrcTraits::array_layout
1594 , Kokkos::LayoutRight >::value ||
1595 std::is_same<
typename SrcTraits::array_layout
1596 , Kokkos::LayoutStride >::value
1598 ,
"View of UQ::PCE requires LayoutLeft, LayoutRight, or LayoutStride" );
1601 std::is_same<
typename DstTraits::array_layout
1602 ,
typename SrcTraits::array_layout >::value ||
1603 std::is_same<
typename DstTraits::array_layout
1604 , Kokkos::LayoutStride >::value ,
1605 "View assignment must have compatible layout" );
1612 "View assignment must have same value type or const = non-const" );
1615 ViewDimensionAssignable<
1616 typename DstType::offset_type::dimension_type,
1617 typename SrcType::offset_type::dimension_type >::value,
1618 "View assignment must have compatible dimensions" );
1620 if ( !src.m_is_contiguous )
1621 Kokkos::abort(
"\n\n ****** Kokkos::View< Sacado::UQ::PCE ... >: can't assign non-contiguous view ******\n\n");
1624 dims[0] = src.m_offset.dimension_0();
1625 dims[1] = src.m_offset.dimension_1();
1626 dims[2] = src.m_offset.dimension_2();
1627 dims[3] = src.m_offset.dimension_3();
1628 dims[4] = src.m_offset.dimension_4();
1629 dims[5] = src.m_offset.dimension_5();
1630 dims[6] = src.m_offset.dimension_6();
1631 dims[7] = src.m_offset.dimension_7();
1632 unsigned rank = SrcTraits::dimension::rank;
1633 unsigned sacado_size = src.m_sacado_size;
1634 if (std::is_same<typename DstTraits::array_layout, LayoutLeft>::value) {
1635 dims[0] = dims[0]*sacado_size;
1639 dims[rank-1] = dims[rank-1]*sacado_size;
1642 typedef typename DstType::offset_type dst_offset_type;
1643 dst.m_offset = dst_offset_type( std::integral_constant< unsigned , 0 >(),
1644 typename DstTraits::array_layout(
1645 dims[0] , dims[1] , dims[2] , dims[3] ,
1646 dims[4] , dims[5] , dims[6] , dims[7] ) );
1647 dst.m_handle = src.m_handle.scalar_ptr ;
1661 template<
class DataType,
class ... P ,
class Arg0,
class ... Args >
1663 < typename std::enable_if<(
1665 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::specialize
1666 , Kokkos::Experimental::Impl::ViewPCEContiguous >::value
1669 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1670 , Kokkos::LayoutLeft >::value ||
1671 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1672 , Kokkos::LayoutRight >::value ||
1673 std::is_same< typename Kokkos::ViewTraits<DataType,P...>::array_layout
1674 , Kokkos::LayoutStride >::value
1677 , Kokkos::ViewTraits<DataType,P...>
1688 , R0 = bool(is_integral_extent<0,Arg0,Args...>::value)
1689 , R1 = bool(is_integral_extent<1,Arg0,Args...>::value)
1690 , R2 = bool(is_integral_extent<2,Arg0,Args...>::value)
1691 , R3 = bool(is_integral_extent<3,Arg0,Args...>::value)
1692 , R4 = bool(is_integral_extent<4,Arg0,Args...>::value)
1693 , R5 = bool(is_integral_extent<5,Arg0,Args...>::value)
1694 , R6 = bool(is_integral_extent<6,Arg0,Args...>::value)
1698 enum { rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3)
1699 + unsigned(R4) + unsigned(R5) + unsigned(R6) };
1702 enum { R0_rev = ( 0 == SrcTraits::rank ? RZ : (
1703 1 == SrcTraits::rank ? R0 : (
1704 2 == SrcTraits::rank ? R1 : (
1705 3 == SrcTraits::rank ? R2 : (
1706 4 == SrcTraits::rank ? R3 : (
1707 5 == SrcTraits::rank ? R4 : (
1708 6 == SrcTraits::rank ? R5 : R6 ))))))) };
1711 typedef typename std::conditional<
1717 ( rank <= 2 && R0 && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutLeft >::value )
1721 ( rank <= 2 && R0_rev && std::is_same< typename SrcTraits::array_layout , Kokkos::LayoutRight >::value )
1722 ),
typename SrcTraits::array_layout , Kokkos::LayoutStride
1740 typedef Kokkos::ViewTraits
1743 ,
typename SrcTraits::device_type
1746 typedef Kokkos::View
1749 ,
typename SrcTraits::device_type
1750 ,
typename SrcTraits::memory_traits >
type ;
1755 template<
class DstTraits >
1756 KOKKOS_INLINE_FUNCTION
1757 static void assign( ViewMapping< DstTraits , void > & dst
1758 , ViewMapping< SrcTraits , void >
const & src
1759 , Arg0 arg0, Args ... args )
1762 ViewMapping< DstTraits , traits_type , void >::is_assignable ,
1763 "Subview destination type must be compatible with subview derived type" );
1765 typedef ViewMapping< DstTraits , void > DstType ;
1766 typedef typename DstType::offset_type dst_offset_type ;
1768 const SubviewExtents< SrcTraits::rank , rank >
1769 extents( src.m_offset.m_dim , arg0 , args... );
1771 const size_t offset = src.m_offset( extents.domain_offset(0)
1772 , extents.domain_offset(1)
1773 , extents.domain_offset(2)
1774 , extents.domain_offset(3)
1775 , extents.domain_offset(4)
1776 , extents.domain_offset(5)
1777 , extents.domain_offset(6)
1778 , extents.domain_offset(7) );
1780 dst.m_offset = dst_offset_type( src.m_offset , extents );
1781 dst.m_handle.value_ptr = src.m_handle.value_ptr + offset;
1782 dst.m_handle.scalar_ptr =
1783 src.m_handle.scalar_ptr + offset * src.m_sacado_size;
1784 dst.m_sacado_size = src.m_sacado_size;
1785 dst.m_cijk = src.m_cijk;
1786 dst.m_is_contiguous = src.m_is_contiguous;
1802 #if defined( KOKKOS_ENABLE_CUDA ) 1803 template<
class OutputView >
1804 struct StokhosViewFill< OutputView ,
1805 typename std::enable_if< std::is_same< typename OutputView::specialize,
1806 Kokkos::Experimental::Impl::ViewPCEContiguous >::value &&
1807 std::is_same< typename OutputView::execution_space,
1808 Cuda >::value >::type >
1811 typedef typename Sacado::ScalarType<const_value_type>::type
scalar_type ;
1813 typedef typename OutputView::size_type size_type ;
1815 template <
unsigned VectorLength>
1824 typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member ;
1826 KOKKOS_INLINE_FUNCTION
1827 void operator()(
const team_member & dev )
const 1829 const size_type tidx = dev.team_rank() % VectorLength;
1830 const size_type tidy = dev.team_rank() / VectorLength;
1831 const size_type nrow = dev.team_size() / VectorLength;
1834 const size_type i0 = dev.league_rank() * nrow + tidy;
1835 if ( i0 >=
output.extent(0) )
return;
1837 for ( size_type i1 = 0 ; i1 <
output.extent(1) ; ++i1 ) {
1838 for ( size_type i2 = 0 ; i2 <
output.extent(2) ; ++i2 ) {
1839 for ( size_type i3 = 0 ; i3 <
output.extent(3) ; ++i3 ) {
1840 for ( size_type i4 = 0 ; i4 <
output.extent(4) ; ++i4 ) {
1841 for ( size_type i5 = 0 ; i5 <
output.extent(5) ; ++i5 ) {
1842 for ( size_type i6 = 0 ; i6 <
output.extent(6) ; ++i6 ) {
1843 for ( size_type i7 = 0 ; i7 <
output.extent(7) ; ++i7 ) {
1844 for ( size_type is = tidx ; is < nvec ; is+=VectorLength ) {
1845 output.access(i0,i1,i2,i3,i4,i5,i6,i7).fastAccessCoeff(is) =
1846 input.fastAccessCoeff(is) ;
1851 template <
unsigned VectorLength>
1852 struct ScalarKernel {
1857 ScalarKernel(
const OutputView & arg_out ,
const scalar_type & arg_in ) :
1860 typedef typename Kokkos::TeamPolicy< execution_space >::member_type team_member ;
1861 KOKKOS_INLINE_FUNCTION
1862 void operator()(
const team_member & dev )
const 1864 const size_type tidx = dev.team_rank() % VectorLength;
1865 const size_type tidy = dev.team_rank() / VectorLength;
1866 const size_type nrow = dev.team_size() / VectorLength;
1869 const size_type i0 = dev.league_rank() * nrow + tidy;
1870 if ( i0 >=
output.extent(0) )
return;
1872 for ( size_type i1 = 0 ; i1 <
output.extent(1) ; ++i1 ) {
1873 for ( size_type i2 = 0 ; i2 <
output.extent(2) ; ++i2 ) {
1874 for ( size_type i3 = 0 ; i3 <
output.extent(3) ; ++i3 ) {
1875 for ( size_type i4 = 0 ; i4 <
output.extent(4) ; ++i4 ) {
1876 for ( size_type i5 = 0 ; i5 <
output.extent(5) ; ++i5 ) {
1877 for ( size_type i6 = 0 ; i6 <
output.extent(6) ; ++i6 ) {
1878 for ( size_type i7 = 0 ; i7 <
output.extent(7) ; ++i7 ) {
1879 for ( size_type is = tidx ; is < npce ; is+=VectorLength ) {
1880 output.access(i0,i1,i2,i3,i4,i5,i6,i7).fastAccessCoeff(is) =
1890 const unsigned vector_length =
1894 const size_type block_size = 256;
1896 const size_type rows_per_block = block_size / vector_length;
1897 const size_type n =
output.extent(0);
1898 const size_type league_size = ( n + rows_per_block-1 ) / rows_per_block;
1899 const size_type team_size = rows_per_block * vector_length;
1900 Kokkos::TeamPolicy< execution_space > config( league_size, team_size );
1904 Kokkos::abort(
"StokhosViewFill: Invalid input value size");
1906 if (
input.size() == 1)
1908 config, ScalarKernel<vector_length>(
output,
input.fastAccessCoeff(0)) );
1910 parallel_for( config, PCEKernel<vector_length>(
output,
input) );
1911 execution_space::fence();
1918 const unsigned vector_length =
1922 const size_type block_size = 256;
1924 const size_type rows_per_block = block_size / vector_length;
1925 const size_type n =
output.extent(0);
1926 const size_type league_size = ( n + rows_per_block-1 ) / rows_per_block;
1927 const size_type team_size = rows_per_block * vector_length;
1928 Kokkos::TeamPolicy< execution_space > config( league_size, team_size );
1930 parallel_for( config, ScalarKernel<vector_length>(
output,
input) );
1931 execution_space::fence();
execution_space::size_type size_type
sacado_uq_pce_type & reference_type
static KOKKOS_INLINE_FUNCTION constexpr size_t memory_span(const size_t span, const unsigned pce_size)
KOKKOS_INLINE_FUNCTION bool is_data_contiguous() const
KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const
KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const
ViewArrayAnalysis< DataType > array_analysis
array_analysis::value_type value_type
Stokhos::StandardStorage< int, double > storage_type
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
PCEConstruct< ExecSpace > PCEFunctorType
Kokkos::Impl::SharedAllocationTracker TrackType
KOKKOS_FORCEINLINE_FUNCTION cijk_type cijk() const
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::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)
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const
KOKKOS_INLINE_FUNCTION PCEAllocation()
KOKKOS_FORCEINLINE_FUNCTION constexpr unsigned dimension_scalar() const
Traits::value_type sacado_uq_pce_type
ViewMapping< SrcTraits, void > SrcType
KOKKOS_INLINE_FUNCTION PCEAllocation & operator=(const PCEAllocation< T > &a)
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3) const
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2) const
Kokkos::DefaultExecutionSpace execution_space
ViewDataType< scalar_type, scalar_dimension >::type scalar_array_type
value_type::cijk_type cijk_type
ViewOffset< typename array_dimension::template append< 0 >::type, typename Traits::array_layout, void > append_offset_type
OutputView::execution_space execution_space
const ScalarType const_scalar_type
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::sacado_uq_pce_type SrcTraits::value_type sacado_uq_pce_type
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
ViewDataType< non_const_value_type, dimension >::type non_const_type
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4) const
ScalarType non_const_scalar_type
KOKKOS_INLINE_FUNCTION void operator()(const size_type i0) 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
Kokkos::Experimental::Impl::PCEAllocation< sacado_uq_pce_type > handle_type
Stokhos::CrsProductTensor< Value, Execution, Memory > type
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::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
view_type::traits::dimension dimension
ViewOffset< typename Traits::dimension, typename Traits::array_layout, void > offset_type
KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const
ConstructDestructFunctor< ExecSpace > create_functor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned pce_size, const cijk_type &cijk) const
sacado_uq_pce_type * pointer_type
Pointer to underlying memory type.
KOKKOS_INLINE_FUNCTION void stride(iType *const s) const
ViewDataType< const_value_type, dimension >::type const_type
KOKKOS_INLINE_FUNCTION constexpr size_t span() const
Span of the mapped range : [ data() .. data() + span() )
StorageType::value_type ScalarType
View< flat_data_type, P... > type
ViewType make_view(const std::string &label, size_t N0=0, size_t N1=0, size_t N2=0, size_t N3=0, size_t N4=0, size_t N5=0, size_t N6=0, size_t N7=0)
KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const
array_analysis::dimension array_dimension
ViewDataType< non_const_scalar_type, scalar_dimension >::type non_const_scalar_array_type
KOKKOS_INLINE_FUNCTION constexpr std::enable_if< is_view_uq_pce< view_type >::value, bool >::type is_allocation_contiguous(const view_type &view)
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
Kokkos::Impl::SharedAllocationTracker TrackType
array_analysis::non_const_value_type non_const_value_type
ViewCtorProp(const type &arg)
OutputView::const_value_type const_value_type
ViewMapping< DstTraits, void > DstType
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::type Kokkos::View< data_type, array_layout, typename SrcTraits::device_type, typename SrcTraits::memory_traits > type
array_analysis::dimension dimension
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::data_type std::conditional< rank==0, sacado_uq_pce_type, typename std::conditional< rank==1, sacado_uq_pce_type *, typename std::conditional< rank==2, sacado_uq_pce_type **, typename std::conditional< rank==3, sacado_uq_pce_type ***, typename std::conditional< rank==4, sacado_uq_pce_type ****, typename std::conditional< rank==5, sacado_uq_pce_type *****, typename std::conditional< rank==6, sacado_uq_pce_type ******, sacado_uq_pce_type *******>::type >::type >::type >::type >::type >::type >::type data_type
ViewType::non_const_value_type::cijk_type type
ViewMapping< SrcTraits, void > SrcType
array_analysis::dimension::template prepend< 0 >::type prepend_scalar_dimension
ViewOffset< typename array_dimension::template prepend< 0 >::type, typename Traits::array_layout, void > prepend_offset_type
std::conditional< is_const, const ScalarType, ScalarType >::type scalar_type
array_analysis::dimension::template append< 0 >::type append_scalar_dimension
std::add_const< intrinsic_scalar_type >::type const_intrinsic_scalar_type
KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const
ViewDataType< const_scalar_type, scalar_dimension >::type const_scalar_array_type
sacado_uq_pce_type::cijk_type cijk_type
KOKKOS_FORCEINLINE_FUNCTION void set_cijk(const cijk_type &cijk)
PCEFunctorType m_pce_functor
DeepCopyNonContiguous(const OutputView &arg_out, const InputView &arg_in)
Top-level namespace for Stokhos classes and functions.
KOKKOS_INLINE_FUNCTION void operator()(const size_t i) const
KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType &r) const
KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const
Raw data access.
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 size_t stride_5() const
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::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
OutputView::execution_space execution_space
KOKKOS_INLINE_FUNCTION void operator()(const size_t i0) const
KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const
static KOKKOS_INLINE_FUNCTION size_t memory_span(typename Traits::array_layout const &layout)
Span, in bytes, of the required memory.
ConstructDestructFunctor & operator=(const ConstructDestructFunctor &)=default
void deep_copy(const Stokhos::CrsMatrix< ValueType, DstDevice, Layout > &dst, const Stokhos::CrsMatrix< ValueType, SrcDevice, Layout > &src)
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const
ViewMapping< DstTraits, void > DstType
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const
StokhosViewFill(const OutputView &arg_out, const_value_type &arg_in)
View< D, P... > view_type
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const
void destroy_shared_allocation()
Kokkos::Impl::SharedAllocationTracker TrackType
Kokkos::Impl::ViewValueFunctor< ExecSpace, scalar_type > ScalarFunctorType
KOKKOS_INLINE_FUNCTION constexpr std::enable_if< is_view_uq_pce< view_type >::value, typename CijkType< view_type >::type >::type cijk(const view_type &view)
Sacado::ValueType< value_type >::type scalar_type
Kokkos::Impl::ViewMapping< typename std::enable_if<(std::is_same< typename Kokkos::ViewTraits< DataType, P... >::specialize, Kokkos::Experimental::Impl::ViewPCEContiguous >::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))>::type, Kokkos::ViewTraits< DataType, P... >, Arg0, Args ... >::SrcTraits Kokkos::ViewTraits< DataType, P... > SrcTraits
KOKKOS_INLINE_FUNCTION ViewMapping()
ScalarFunctorType m_scalar_functor
Kokkos::Experimental::Impl::ViewPCEContiguous specialize
ConstructDestructFunctor(const ExecSpace &space, const bool initialize, const size_t span, const unsigned pce_size, const cijk_type &cijk, scalar_type *scalar_ptr, value_type *value_ptr)
ViewDataType< value_type, dimension >::type 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
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const
ViewMapping< DstTraits, void > DstType
std::false_type is_regular
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
KOKKOS_FORCEINLINE_FUNCTION reference_type reference() const
PCEConstruct(const ExecSpace &space, value_type *p, scalar_type *sp, const size_t span, const unsigned pce_size, const cijk_type &cijk)
Kokkos::Impl::ViewDataType< flat_value_type, dimension >::type flat_data_type
ConstructDestructFunctor()=default
view_type::array_type::value_type flat_value_type
sacado_uq_pce_type::storage_type stokhos_storage_type
KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const
Is the mapped range span contiguous.
ViewArrayAnalysis< typename Traits::data_type > array_analysis
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const
KOKKOS_INLINE_FUNCTION std::enable_if< !Impl::ctor_prop_has_cijk< AllocProp >::value, CijkType >::type extract_cijk(const AllocProp &prop)
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const
KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0, const I1 &i1) const
KOKKOS_INLINE_FUNCTION void set(value_type *ptr, const size_t span, const unsigned pce_size)
KOKKOS_INLINE_FUNCTION bool is_allocation_contiguous() const
std::conditional< std::is_same< ArrayLayout, Kokkos::LayoutLeft >::value, prepend_scalar_dimension, append_scalar_dimension >::type scalar_dimension
PCEConstruct & operator=(const PCEConstruct &)=default
KOKKOS_INLINE_FUNCTION constexpr Traits::array_layout layout() const
KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const
std::conditional< std::is_same< typename Traits::array_layout, Kokkos::LayoutLeft >::value, prepend_offset_type, append_offset_type >::type array_offset_type
SharedAllocationRecord * allocate_shared(ViewCtorProp< P... > const &prop, typename Traits::array_layout const &layout)
Stokhos::CrsMatrix< ValueType, Device, Layout >::HostMirror create_mirror(const Stokhos::CrsMatrix< ValueType, Device, Layout > &A)
array_analysis::const_value_type const_value_type
static KOKKOS_INLINE_FUNCTION void assign(DstType &dst, const SrcType &src, const TrackType &)
stokhos_storage_type::value_type intrinsic_scalar_type
KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const
void construct_shared_allocation()
View< T, P... > view_type
ViewMapping< SrcTraits, void > SrcType