571 template <
class,
class...>
573 template <
class,
class...>
574 friend class Kokkos::Impl::ViewMapping;
576 using view_tracker_type = Kokkos::Impl::ViewTracker<View>;
583 Kokkos::Impl::ViewMapping<traits, typename traits::specialize>;
584 template <
typename V>
585 friend struct Kokkos::Impl::ViewTracker;
586 using hooks_policy =
typename traits::hooks_policy;
588 view_tracker_type m_track;
595 View<
typename traits::scalar_array_type,
typename traits::array_layout,
597 typename traits::memory_traits>;
601 View<
typename traits::const_data_type,
typename traits::array_layout,
603 typename traits::memory_traits>;
607 View<
typename traits::non_const_data_type,
typename traits::array_layout,
609 typename traits::memory_traits>;
613 View<
typename traits::non_const_data_type,
typename traits::array_layout,
614 Device<DefaultHostExecutionSpace,
615 typename traits::host_mirror_space::memory_space>,
616 typename traits::hooks_policy>;
620 View<
typename traits::non_const_data_type,
typename traits::array_layout,
621 typename traits::host_mirror_space,
typename traits::hooks_policy>;
625 using uniform_const_type =
626 typename Impl::ViewUniformType<View, 0>::const_type;
627 using uniform_runtime_type =
628 typename Impl::ViewUniformType<View, 0>::runtime_type;
629 using uniform_runtime_const_type =
630 typename Impl::ViewUniformType<View, 0>::runtime_const_type;
631 using uniform_nomemspace_type =
632 typename Impl::ViewUniformType<View, 0>::nomemspace_type;
633 using uniform_const_nomemspace_type =
634 typename Impl::ViewUniformType<View, 0>::const_nomemspace_type;
635 using uniform_runtime_nomemspace_type =
636 typename Impl::ViewUniformType<View, 0>::runtime_nomemspace_type;
637 using uniform_runtime_const_nomemspace_type =
638 typename Impl::ViewUniformType<View, 0>::runtime_const_nomemspace_type;
643 enum { Rank = map_type::Rank };
651 template <
typename iType>
652 KOKKOS_INLINE_FUNCTION
constexpr std::enable_if_t<
653 std::is_integral<iType>::value,
size_t>
655 return m_map.extent(r);
658 static KOKKOS_INLINE_FUNCTION
constexpr size_t static_extent(
659 const unsigned r)
noexcept {
660 return map_type::static_extent(r);
663 template <
typename iType>
664 KOKKOS_INLINE_FUNCTION
constexpr std::enable_if_t<
665 std::is_integral<iType>::value,
int>
666 extent_int(
const iType& r)
const noexcept {
667 return static_cast<int>(m_map.extent(r));
670 KOKKOS_INLINE_FUNCTION
constexpr typename traits::array_layout layout()
672 return m_map.layout();
680 KOKKOS_INLINE_FUNCTION
constexpr size_t size()
const {
681 return m_map.dimension_0() * m_map.dimension_1() * m_map.dimension_2() *
682 m_map.dimension_3() * m_map.dimension_4() * m_map.dimension_5() *
683 m_map.dimension_6() * m_map.dimension_7();
686 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_0()
const {
687 return m_map.stride_0();
689 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_1()
const {
690 return m_map.stride_1();
692 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_2()
const {
693 return m_map.stride_2();
695 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_3()
const {
696 return m_map.stride_3();
698 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_4()
const {
699 return m_map.stride_4();
701 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_5()
const {
702 return m_map.stride_5();
704 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_6()
const {
705 return m_map.stride_6();
707 KOKKOS_INLINE_FUNCTION
constexpr size_t stride_7()
const {
708 return m_map.stride_7();
711 template <
typename iType>
712 KOKKOS_INLINE_FUNCTION
constexpr std::enable_if_t<
713 std::is_integral<iType>::value,
size_t>
714 stride(iType r)
const {
730 : m_map.stride_7())))))));
733 template <
typename iType>
734 KOKKOS_INLINE_FUNCTION
void stride(iType*
const s)
const {
741 using reference_type =
typename map_type::reference_type;
742 using pointer_type =
typename map_type::pointer_type;
745 reference_type_is_lvalue_reference =
746 std::is_lvalue_reference<reference_type>::value
749 KOKKOS_INLINE_FUNCTION
constexpr size_t span()
const {
return m_map.span(); }
750 KOKKOS_INLINE_FUNCTION
bool span_is_contiguous()
const {
751 return m_map.span_is_contiguous();
753 KOKKOS_INLINE_FUNCTION
constexpr bool is_allocated()
const {
754 return m_map.data() !=
nullptr;
756 KOKKOS_INLINE_FUNCTION
constexpr pointer_type data()
const {
763 KOKKOS_INLINE_FUNCTION
764 const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
768 KOKKOS_INLINE_FUNCTION
769 const Kokkos::Impl::SharedAllocationTracker& impl_track()
const {
770 return m_track.m_tracker;
775 static constexpr bool is_layout_left =
776 std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value;
778 static constexpr bool is_layout_right =
779 std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value;
781 static constexpr bool is_layout_stride =
782 std::is_same<typename traits::array_layout, Kokkos::LayoutStride>::value;
784 static constexpr bool is_default_map =
785 std::is_void<typename traits::specialize>::value &&
786 (is_layout_left || is_layout_right || is_layout_stride);
788#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
790#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(...) \
791 Kokkos::Impl::runtime_check_memory_access_violation< \
792 typename traits::memory_space>( \
793 "Kokkos::View ERROR: attempt to access inaccessible memory space", \
795 Kokkos::Impl::view_verify_operator_bounds<typename traits::memory_space>( \
800#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(...) \
801 Kokkos::Impl::runtime_check_memory_access_violation< \
802 typename traits::memory_space>( \
803 "Kokkos::View ERROR: attempt to access inaccessible memory space", \
808 template <
typename... Is>
809 static KOKKOS_FUNCTION
void check_access_member_function_valid_args(Is...) {
810 static_assert(Rank <=
sizeof...(Is),
"");
811 static_assert(
sizeof...(Is) <= 8,
"");
812 static_assert(Kokkos::Impl::are_integral<Is...>::value,
"");
815 template <
typename... Is>
816 static KOKKOS_FUNCTION
void check_operator_parens_valid_args(Is...) {
817 static_assert(Rank ==
sizeof...(Is),
"");
818 static_assert(Kokkos::Impl::are_integral<Is...>::value,
"");
825 template <
typename I0>
826 KOKKOS_FORCEINLINE_FUNCTION
827 std::enable_if_t<(Kokkos::Impl::always_true<I0>::value &&
828 (1 == Rank) && is_default_map && !is_layout_stride),
830 operator()(I0 i0)
const {
831 check_operator_parens_valid_args(i0);
832 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
833 return m_map.m_impl_handle[i0];
836 template <
typename I0>
837 KOKKOS_FORCEINLINE_FUNCTION
838 std::enable_if_t<(Kokkos::Impl::always_true<I0>::value &&
839 (1 == Rank) && is_default_map && is_layout_stride),
841 operator()(I0 i0)
const {
842 check_operator_parens_valid_args(i0);
843 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
844 return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
850 template <
typename I0>
851 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
852 ((1 == Rank) && Kokkos::Impl::are_integral<I0>::value && !is_default_map),
854 operator[](I0 i0)
const {
855 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
856 return m_map.reference(i0);
859 template <
typename I0>
860 KOKKOS_FORCEINLINE_FUNCTION
861 std::enable_if_t<((1 == Rank) && Kokkos::Impl::are_integral<I0>::value &&
862 is_default_map && !is_layout_stride),
864 operator[](I0 i0)
const {
865 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
866 return m_map.m_impl_handle[i0];
869 template <
typename I0>
870 KOKKOS_FORCEINLINE_FUNCTION
871 std::enable_if_t<((1 == Rank) && Kokkos::Impl::are_integral<I0>::value &&
872 is_default_map && is_layout_stride),
874 operator[](I0 i0)
const {
875 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
876 return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
882 template <
typename I0,
typename I1>
883 KOKKOS_FORCEINLINE_FUNCTION
884 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&
885 (2 == Rank) && is_default_map && is_layout_left &&
886 (traits::rank_dynamic == 0)),
888 operator()(I0 i0, I1 i1)
const {
889 check_operator_parens_valid_args(i0, i1);
890 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
891 return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
894 template <
typename I0,
typename I1>
895 KOKKOS_FORCEINLINE_FUNCTION
896 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&
897 (2 == Rank) && is_default_map && is_layout_left &&
898 (traits::rank_dynamic != 0)),
900 operator()(I0 i0, I1 i1)
const {
901 check_operator_parens_valid_args(i0, i1);
902 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
903 return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
906 template <
typename I0,
typename I1>
907 KOKKOS_FORCEINLINE_FUNCTION
908 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&
909 (2 == Rank) && is_default_map && is_layout_right &&
910 (traits::rank_dynamic == 0)),
912 operator()(I0 i0, I1 i1)
const {
913 check_operator_parens_valid_args(i0, i1);
914 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
915 return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
918 template <
typename I0,
typename I1>
919 KOKKOS_FORCEINLINE_FUNCTION
920 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&
921 (2 == Rank) && is_default_map && is_layout_right &&
922 (traits::rank_dynamic != 0)),
924 operator()(I0 i0, I1 i1)
const {
925 check_operator_parens_valid_args(i0, i1);
926 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
927 return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
930 template <
typename I0,
typename I1>
931 KOKKOS_FORCEINLINE_FUNCTION
932 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&
933 (2 == Rank) && is_default_map && is_layout_stride),
935 operator()(I0 i0, I1 i1)
const {
936 check_operator_parens_valid_args(i0, i1);
937 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
938 return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
939 i1 * m_map.m_impl_offset.m_stride.S1];
945 template <
typename... Is>
946 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
947 (Kokkos::Impl::always_true<Is...>::value &&
948 (2 != Rank) && (1 != Rank) && (0 != Rank) && is_default_map),
950 operator()(Is... indices)
const {
951 check_operator_parens_valid_args(indices...);
952 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, indices...)
953 return m_map.m_impl_handle[m_map.m_impl_offset(indices...)];
956 template <typename... Is>
957 KOKKOS_FORCEINLINE_FUNCTION
958 std::enable_if_t<(Kokkos::Impl::always_true<Is...>::value &&
959 ((0 == Rank) || !is_default_map)),
961 operator()(Is... indices)
const {
962 check_operator_parens_valid_args(indices...);
963 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, indices...)
964 return m_map.reference(indices...);
970 template <typename... Is>
971 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
972 (Kokkos::Impl::always_true<Is...>::value && (0 == Rank)), reference_type>
973 access(Is... extra)
const {
974 check_access_member_function_valid_args(extra...);
975 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, extra...)
976 return m_map.reference();
982 template <typename I0, typename... Is>
983 KOKKOS_FORCEINLINE_FUNCTION
984 std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
985 (1 == Rank) && !is_default_map),
987 access(I0 i0, Is... extra)
const {
988 check_access_member_function_valid_args(i0, extra...);
989 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, extra...)
990 return m_map.reference(i0);
993 template <typename I0, typename... Is>
994 KOKKOS_FORCEINLINE_FUNCTION
995 std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
996 (1 == Rank) && is_default_map && !is_layout_stride),
998 access(I0 i0, Is... extra)
const {
999 check_access_member_function_valid_args(i0, extra...);
1000 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, extra...)
1001 return m_map.m_impl_handle[i0];
1004 template <typename I0, typename... Is>
1005 KOKKOS_FORCEINLINE_FUNCTION
1006 std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
1007 (1 == Rank) && is_default_map && is_layout_stride),
1009 access(I0 i0, Is... extra)
const {
1010 check_access_member_function_valid_args(i0, extra...);
1011 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, extra...)
1012 return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * i0];
1018 template <typename I0, typename I1, typename... Is>
1019 KOKKOS_FORCEINLINE_FUNCTION
1020 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, Is...>::value &&
1021 (2 == Rank) && !is_default_map),
1023 access(I0 i0, I1 i1, Is... extra)
const {
1024 check_access_member_function_valid_args(i0, i1, extra...);
1025 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1026 return m_map.reference(i0, i1);
1029 template <typename I0, typename I1, typename... Is>
1030 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1031 (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
1032 is_default_map && is_layout_left && (traits::rank_dynamic == 0)),
1034 access(I0 i0, I1 i1, Is... extra)
const {
1035 check_access_member_function_valid_args(i0, i1, extra...);
1036 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1037 return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
1040 template <typename I0, typename I1, typename... Is>
1041 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1042 (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
1043 is_default_map && is_layout_left && (traits::rank_dynamic != 0)),
1045 access(I0 i0, I1 i1, Is... extra)
const {
1046 check_access_member_function_valid_args(i0, i1, extra...);
1047 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1048 return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
1051 template <typename I0, typename I1, typename... Is>
1052 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1053 (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
1054 is_default_map && is_layout_right && (traits::rank_dynamic == 0)),
1056 access(I0 i0, I1 i1, Is... extra)
const {
1057 check_access_member_function_valid_args(i0, i1, extra...);
1058 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1059 return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
1062 template <typename I0, typename I1, typename... Is>
1063 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1064 (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
1065 is_default_map && is_layout_right && (traits::rank_dynamic != 0)),
1067 access(I0 i0, I1 i1, Is... extra)
const {
1068 check_access_member_function_valid_args(i0, i1, extra...);
1069 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1070 return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
1073 template <typename I0, typename I1, typename... Is>
1074 KOKKOS_FORCEINLINE_FUNCTION
1075 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, Is...>::value &&
1076 (2 == Rank) && is_default_map && is_layout_stride),
1078 access(I0 i0, I1 i1, Is... extra)
const {
1079 check_access_member_function_valid_args(i0, i1, extra...);
1080 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
1081 return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
1082 i1 * m_map.m_impl_offset.m_stride.S1];
1088 template <typename I0, typename I1, typename I2, typename... Is>
1089 KOKKOS_FORCEINLINE_FUNCTION
1090 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, Is...>::value &&
1091 (3 == Rank) && is_default_map),
1093 access(I0 i0, I1 i1, I2 i2, Is... extra)
const {
1094 check_access_member_function_valid_args(i0, i1, i2, extra...);
1095 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, extra...)
1096 return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2)];
1099 template <typename I0, typename I1, typename I2, typename... Is>
1100 KOKKOS_FORCEINLINE_FUNCTION
1101 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, Is...>::value &&
1102 (3 == Rank) && !is_default_map),
1104 access(I0 i0, I1 i1, I2 i2, Is... extra)
const {
1105 check_access_member_function_valid_args(i0, i1, i2, extra...);
1106 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, extra...)
1107 return m_map.reference(i0, i1, i2);
1113 template <typename I0, typename I1, typename I2, typename I3, typename... Is>
1114 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1115 (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == Rank) &&
1118 access(I0 i0, I1 i1, I2 i2, I3 i3, Is... extra)
const {
1119 check_access_member_function_valid_args(i0, i1, i2, i3, extra...);
1120 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, extra...)
1121 return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3)];
1124 template <typename I0, typename I1, typename I2, typename I3, typename... Is>
1125 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1126 (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == Rank) &&
1129 access(I0 i0, I1 i1, I2 i2, I3 i3, Is... extra)
const {
1130 check_access_member_function_valid_args(i0, i1, i2, i3, extra...);
1131 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, extra...)
1132 return m_map.reference(i0, i1, i2, i3);
1138 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1140 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1141 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, Is...>::value &&
1142 (5 == Rank) && is_default_map),
1144 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, Is... extra)
const {
1145 check_access_member_function_valid_args(i0, i1, i2, i3, i4, extra...);
1146 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4,
1148 return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4)];
1151 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1153 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1154 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, Is...>::value &&
1155 (5 == Rank) && !is_default_map),
1157 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, Is... extra)
const {
1158 check_access_member_function_valid_args(i0, i1, i2, i3, i4, extra...);
1159 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4,
1161 return m_map.reference(i0, i1, i2, i3, i4);
1167 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1168 typename I5, typename... Is>
1169 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1170 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, Is...>::value &&
1171 (6 == Rank) && is_default_map),
1173 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, Is... extra)
const {
1174 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, extra...);
1175 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5,
1177 return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5)];
1180 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1181 typename I5, typename... Is>
1182 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1183 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, Is...>::value &&
1184 (6 == Rank) && !is_default_map),
1186 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, Is... extra)
const {
1187 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, extra...);
1188 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5,
1190 return m_map.reference(i0, i1, i2, i3, i4, i5);
1196 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1197 typename I5, typename I6, typename... Is>
1198 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1199 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6, Is...>::value &&
1200 (7 == Rank) && is_default_map),
1202 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, Is... extra)
const {
1203 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6,
1205 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5, i6,
1207 return m_map.m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6)];
1210 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1211 typename I5, typename I6, typename... Is>
1212 KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
1213 (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6, Is...>::value &&
1214 (7 == Rank) && !is_default_map),
1216 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, Is... extra)
const {
1217 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6,
1219 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5, i6,
1221 return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
1227 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1228 typename I5, typename I6, typename I7, typename... Is>
1229 KOKKOS_FORCEINLINE_FUNCTION
1230 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6,
1231 I7, Is...>::value &&
1232 (8 == Rank) && is_default_map),
1234 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, I7 i7,
1235 Is... extra)
const {
1236 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6, i7,
1238 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5, i6,
1241 .m_impl_handle[m_map.m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7)];
1244 template <typename I0, typename I1, typename I2, typename I3, typename I4,
1245 typename I5, typename I6, typename I7, typename... Is>
1246 KOKKOS_FORCEINLINE_FUNCTION
1247 std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6,
1248 I7, Is...>::value &&
1249 (8 == Rank) && !is_default_map),
1251 access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, I7 i7,
1252 Is... extra)
const {
1253 check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6, i7,
1255 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, i2, i3, i4, i5, i6,
1257 return m_map.reference(i0, i1, i2, i3, i4, i5, i6, i7);
1260#undef KOKKOS_IMPL_VIEW_OPERATOR_VERIFY
1265 KOKKOS_DEFAULTED_FUNCTION
1268 KOKKOS_DEFAULTED_FUNCTION
1272 View(
const View& other) : m_track(other.m_track), m_map(other.m_map) {
1273 KOKKOS_IF_ON_HOST((hooks_policy::copy_construct(*
this, other);))
1278 : m_track{std::move(other.m_track)}, m_map{std::move(other.m_map)} {
1279 KOKKOS_IF_ON_HOST((hooks_policy::move_construct(*
this, other);))
1283 View& operator=(
const View& other) {
1284 m_map = other.m_map;
1285 m_track = other.m_track;
1287 KOKKOS_IF_ON_HOST((hooks_policy::copy_assign(*
this, other);))
1293 View& operator=(View&& other) {
1294 m_map = std::move(other.m_map);
1295 m_track = std::move(other.m_track);
1297 KOKKOS_IF_ON_HOST((hooks_policy::move_assign(*
this, other);))
1306 template <
class RT,
class... RP>
1307 KOKKOS_INLINE_FUNCTION
View(
1308 const View<RT, RP...>& rhs,
1309 std::enable_if_t<Kokkos::Impl::ViewMapping<
1310 traits,
typename View<RT, RP...>::traits,
1311 typename traits::specialize>::is_assignable_data_type>* =
nullptr)
1312 : m_track(rhs), m_map() {
1313 using SrcTraits =
typename View<RT, RP...>::traits;
1314 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits,
1315 typename traits::specialize>;
1316 static_assert(Mapping::is_assignable,
1317 "Incompatible View copy construction");
1318 Mapping::assign(m_map, rhs.m_map, rhs.m_track.m_tracker);
1321 template <
class RT,
class... RP>
1322 KOKKOS_INLINE_FUNCTION std::enable_if_t<
1323 Kokkos::Impl::ViewMapping<
1324 traits,
typename View<RT, RP...>::traits,
1325 typename traits::specialize>::is_assignable_data_type,
1327 operator=(
const View<RT, RP...>& rhs) {
1328 using SrcTraits =
typename View<RT, RP...>::traits;
1329 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits,
1330 typename traits::specialize>;
1331 static_assert(Mapping::is_assignable,
"Incompatible View copy assignment");
1332 Mapping::assign(m_map, rhs.m_map, rhs.m_track.m_tracker);
1333 m_track.assign(rhs);
1341 template <
class RT,
class... RP,
class Arg0,
class... Args>
1342 KOKKOS_INLINE_FUNCTION
View(
const View<RT, RP...>& src_view,
const Arg0 arg0,
1344 : m_track(src_view), m_map() {
1345 using SrcType =
View<RT, RP...>;
1347 using Mapping = Kokkos::Impl::ViewMapping<void,
typename SrcType::traits,
1350 using DstType =
typename Mapping::type;
1353 Kokkos::Impl::ViewMapping<traits,
typename DstType::traits,
1354 typename traits::specialize>::is_assignable,
1355 "Subview construction requires compatible view and subview arguments");
1357 Mapping::assign(m_map, src_view.m_map, arg0, args...);
1363 KOKKOS_INLINE_FUNCTION
1364 int use_count()
const {
return m_track.m_tracker.use_count(); }
1366 inline const std::string label()
const {
1367 return m_track.m_tracker
1368 .template get_label<typename traits::memory_space>();
1375 template <
class... P>
1376 explicit inline View(
1377 const Impl::ViewCtorProp<P...>& arg_prop,
1378 std::enable_if_t<!Impl::ViewCtorProp<P...>::has_pointer,
1379 typename traits::array_layout>
const& arg_layout)
1380 : m_track(), m_map() {
1383 auto prop_copy_tmp =
1384 Impl::with_properties_if_unset(arg_prop, std::string{});
1385 auto prop_copy = Impl::with_properties_if_unset(
1386 prop_copy_tmp,
typename traits::device_type::memory_space{},
1387 typename traits::device_type::execution_space{});
1388 using alloc_prop =
decltype(prop_copy);
1390 static_assert(traits::is_managed,
1391 "View allocation constructor requires managed memory");
1393 if (alloc_prop::initialize &&
1394 !alloc_prop::execution_space::impl_is_initialized()) {
1397 Kokkos::Impl::throw_runtime_exception(
1398 "Constructing View and initializing data with uninitialized "
1402 size_t i0 = arg_layout.dimension[0];
1403 size_t i1 = arg_layout.dimension[1];
1404 size_t i2 = arg_layout.dimension[2];
1405 size_t i3 = arg_layout.dimension[3];
1406 size_t i4 = arg_layout.dimension[4];
1407 size_t i5 = arg_layout.dimension[5];
1408 size_t i6 = arg_layout.dimension[6];
1409 size_t i7 = arg_layout.dimension[7];
1411 const std::string& alloc_name =
1412 Impl::get_property<Impl::LabelTag>(prop_copy);
1413 Impl::runtime_check_rank(
1414 traits::rank, traits::rank_dynamic,
1415 std::is_same<typename traits::specialize, void>::value, i0, i1, i2, i3,
1416 i4, i5, i6, i7, alloc_name);
1419#if defined(KOKKOS_ENABLE_CUDA)
1426 typename traits::device_type::memory_space>::value) {
1427 typename traits::device_type::memory_space::execution_space().fence(
1428 "Kokkos::View<...>::View: fence before allocating UVM");
1433 Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
1434 prop_copy, arg_layout, Impl::ViewCtorProp<P...>::has_execution_space);
1437#if defined(KOKKOS_ENABLE_CUDA)
1439 typename traits::device_type::memory_space>::value) {
1440 typename traits::device_type::memory_space::execution_space().fence(
1441 "Kokkos::View<...>::View: fence after allocating UVM");
1447 m_track.m_tracker.assign_allocated_record_to_uninitialized(record);
1450 KOKKOS_INLINE_FUNCTION
1451 void assign_data(pointer_type arg_data) {
1452 m_track.m_tracker.
clear();
1453 m_map.assign_data(arg_data);
1457 template <
class... P>
1458 explicit KOKKOS_INLINE_FUNCTION
View(
1459 const Impl::ViewCtorProp<P...>& arg_prop,
1460 std::enable_if_t<Impl::ViewCtorProp<P...>::has_pointer,
1461 typename traits::array_layout>
const& arg_layout)
1464 m_map(arg_prop, arg_layout) {
1466 std::is_same<pointer_type,
1467 typename Impl::ViewCtorProp<P...>::pointer_type>::value,
1468 "Constructing View to wrap user memory must supply matching pointer "
1473 template <
class... P>
1474 explicit inline View(
1475 const Impl::ViewCtorProp<P...>& arg_prop,
1476 std::enable_if_t<!Impl::ViewCtorProp<P...>::has_pointer,
size_t>
const
1477 arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1478 const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1479 const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1480 const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1481 const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1482 const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1483 const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1484 const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
1486 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1487 arg_N4, arg_N5, arg_N6, arg_N7)) {
1488 static_assert(traits::array_layout::is_extent_constructible,
1489 "Layout is not constructible from extent arguments. Use "
1490 "overload taking a layout object instead.");
1493 template <
class... P>
1494 explicit KOKKOS_INLINE_FUNCTION
View(
1495 const Impl::ViewCtorProp<P...>& arg_prop,
1496 std::enable_if_t<Impl::ViewCtorProp<P...>::has_pointer,
size_t>
const
1497 arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1498 const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1499 const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1500 const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1501 const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1502 const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1503 const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1504 const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
1506 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1507 arg_N4, arg_N5, arg_N6, arg_N7)) {
1508 static_assert(traits::array_layout::is_extent_constructible,
1509 "Layout is not constructible from extent arguments. Use "
1510 "overload taking a layout object instead.");
1514 template <
typename Label>
1515 explicit inline View(
1516 const Label& arg_label,
1517 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value,
1518 typename traits::array_layout>
const& arg_layout)
1519 :
View(Impl::ViewCtorProp<std::string>(arg_label), arg_layout) {}
1522 template <
typename Label>
1523 explicit inline View(
1524 const Label& arg_label,
1525 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value,
const size_t>
1526 arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1527 const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1528 const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1529 const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1530 const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1531 const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1532 const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1533 const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
1534 :
View(Impl::ViewCtorProp<std::string>(arg_label),
1535 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1536 arg_N4, arg_N5, arg_N6, arg_N7)) {
1537 static_assert(traits::array_layout::is_extent_constructible,
1538 "Layout is not constructible from extent arguments. Use "
1539 "overload taking a layout object instead.");
1545 template <
class Traits>
1546 KOKKOS_INLINE_FUNCTION
View(
1547 const view_tracker_type& track,
1548 const Kokkos::Impl::ViewMapping<Traits, typename Traits::specialize>& map)
1549 : m_track(track), m_map() {
1551 Kokkos::Impl::ViewMapping<traits, Traits, typename traits::specialize>;
1552 static_assert(Mapping::is_assignable,
1553 "Incompatible View copy construction");
1554 Mapping::assign(m_map, map, track.m_tracker);
1560 template <
class Traits>
1561 KOKKOS_INLINE_FUNCTION
View(
1562 const typename view_tracker_type::track_type& track,
1563 const Kokkos::Impl::ViewMapping<Traits, typename Traits::specialize>& map)
1564 : m_track(track), m_map() {
1566 Kokkos::Impl::ViewMapping<traits, Traits, typename traits::specialize>;
1567 static_assert(Mapping::is_assignable,
1568 "Incompatible View copy construction");
1569 Mapping::assign(m_map, map, track);
1574 static constexpr size_t required_allocation_size(
1575 typename traits::array_layout
const& layout) {
1576 return map_type::memory_span(layout);
1579 static constexpr size_t required_allocation_size(
1580 const size_t arg_N0 = 0,
const size_t arg_N1 = 0,
const size_t arg_N2 = 0,
1581 const size_t arg_N3 = 0,
const size_t arg_N4 = 0,
const size_t arg_N5 = 0,
1582 const size_t arg_N6 = 0,
const size_t arg_N7 = 0) {
1583 static_assert(traits::array_layout::is_extent_constructible,
1584 "Layout is not constructible from extent arguments. Use "
1585 "overload taking a layout object instead.");
1586 return map_type::memory_span(
typename traits::array_layout(
1587 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
1590 explicit KOKKOS_INLINE_FUNCTION
View(
1591 pointer_type arg_ptr,
const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1592 const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1593 const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1594 const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1595 const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1596 const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1597 const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1598 const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
1599 :
View(Impl::ViewCtorProp<pointer_type>(arg_ptr),
1600 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1601 arg_N4, arg_N5, arg_N6, arg_N7)) {
1602 static_assert(traits::array_layout::is_extent_constructible,
1603 "Layout is not constructible from extent arguments. Use "
1604 "overload taking a layout object instead.");
1607 explicit KOKKOS_INLINE_FUNCTION
View(
1608 pointer_type arg_ptr,
const typename traits::array_layout& arg_layout)
1609 :
View(Impl::ViewCtorProp<pointer_type>(arg_ptr), arg_layout) {}
1614 static KOKKOS_INLINE_FUNCTION
size_t
1615 shmem_size(
const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1616 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1617 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1618 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1619 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1620 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1621 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1622 const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
1623 static_assert(traits::array_layout::is_extent_constructible,
1624 "Layout is not constructible from extent arguments. Use "
1625 "overload taking a layout object instead.");
1626 const size_t num_passed_args = Impl::count_valid_integers(
1627 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
1629 if (std::is_void<typename traits::specialize>::value &&
1630 num_passed_args != traits::rank_dynamic) {
1632 "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n");
1635 return View::shmem_size(
typename traits::array_layout(
1636 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
1642 static constexpr size_t scratch_value_alignment =
1643 max({
sizeof(
typename traits::value_type),
1644 alignof(
typename traits::value_type),
1645 static_cast<size_t>(
1646 traits::execution_space::scratch_memory_space::ALIGN)});
1649 static KOKKOS_INLINE_FUNCTION
size_t
1650 shmem_size(
typename traits::array_layout
const& arg_layout) {
1651 return map_type::memory_span(arg_layout) + scratch_value_alignment;
1654 explicit KOKKOS_INLINE_FUNCTION
View(
1655 const typename traits::execution_space::scratch_memory_space& arg_space,
1656 const typename traits::array_layout& arg_layout)
1657 :
View(Impl::ViewCtorProp<pointer_type>(reinterpret_cast<pointer_type>(
1658 arg_space.get_shmem_aligned(map_type::memory_span(arg_layout),
1659 scratch_value_alignment))),
1662 explicit KOKKOS_INLINE_FUNCTION
View(
1663 const typename traits::execution_space::scratch_memory_space& arg_space,
1664 const size_t arg_N0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1665 const size_t arg_N1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1666 const size_t arg_N2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1667 const size_t arg_N3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1668 const size_t arg_N4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1669 const size_t arg_N5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1670 const size_t arg_N6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1671 const size_t arg_N7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG)
1672 :
View(Impl::ViewCtorProp<pointer_type>(
1673 reinterpret_cast<pointer_type>(arg_space.get_shmem_aligned(
1674 map_type::memory_span(typename traits::array_layout(
1675 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6,
1677 scratch_value_alignment))),
1678 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1679 arg_N4, arg_N5, arg_N6, arg_N7)) {
1680 static_assert(traits::array_layout::is_extent_constructible,
1681 "Layout is not constructible from extent arguments. Use "
1682 "overload taking a layout object instead.");