23 #ifndef KOKKOS_DYNRANKVIEW_HPP
24 #define KOKKOS_DYNRANKVIEW_HPP
25 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
26 #define KOKKOS_IMPL_PUBLIC_INCLUDE
27 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
30 #include <Kokkos_Core.hpp>
31 #include <KokkosExp_InterOp.hpp>
32 #include <impl/Kokkos_Error.hpp>
33 #include <type_traits>
37 template <
typename DataType,
class... Properties>
42 template <
class T,
size_t Rank>
43 struct ViewDataTypeFromRank {
44 using type =
typename ViewDataTypeFromRank<T, Rank - 1>::type*;
48 struct ViewDataTypeFromRank<T, 0> {
52 template <
unsigned N,
typename T,
typename... Args>
53 KOKKOS_FUNCTION View<typename ViewDataTypeFromRank<T, N>::type, Args...>
55 DynRankView<T, Args...> v,
56 std::enable_if_t<std::is_same_v<
typename ViewTraits<T, Args...>::specialize,
60 template <
typename Specialize>
61 struct DynRankDimTraits {
62 enum :
size_t { unspecified = KOKKOS_INVALID_INDEX };
65 KOKKOS_INLINE_FUNCTION
66 static size_t computeRank(
const size_t N0,
const size_t N1,
const size_t N2,
67 const size_t N3,
const size_t N4,
const size_t N5,
68 const size_t N6,
const size_t ) {
70 (N6 == unspecified && N5 == unspecified && N4 == unspecified &&
71 N3 == unspecified && N2 == unspecified && N1 == unspecified &&
74 : ((N6 == unspecified && N5 == unspecified && N4 == unspecified &&
75 N3 == unspecified && N2 == unspecified && N1 == unspecified)
77 : ((N6 == unspecified && N5 == unspecified &&
78 N4 == unspecified && N3 == unspecified &&
81 : ((N6 == unspecified && N5 == unspecified &&
82 N4 == unspecified && N3 == unspecified)
84 : ((N6 == unspecified && N5 == unspecified &&
87 : ((N6 == unspecified &&
90 : ((N6 == unspecified)
96 template <
typename Layout>
97 KOKKOS_INLINE_FUNCTION
static size_t computeRank(
const Layout& layout) {
98 return computeRank(layout.dimension[0], layout.dimension[1],
99 layout.dimension[2], layout.dimension[3],
100 layout.dimension[4], layout.dimension[5],
101 layout.dimension[6], layout.dimension[7]);
105 template <
typename Layout,
typename... P>
106 KOKKOS_INLINE_FUNCTION
static size_t computeRank(
107 const Kokkos::Impl::ViewCtorProp<P...>& ,
108 const Layout& layout) {
109 return computeRank(layout);
117 template <
typename Layout>
118 KOKKOS_INLINE_FUNCTION
static std::enable_if_t<
119 (std::is_same_v<Layout, Kokkos::LayoutRight> ||
120 std::is_same_v<Layout, Kokkos::LayoutLeft>),
122 createLayout(
const Layout& layout) {
124 layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
125 layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
126 layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
127 layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
128 layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
129 layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
130 layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
131 layout.dimension[7] != unspecified ? layout.dimension[7] : unspecified);
133 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
139 if constexpr (!std::is_same_v<Specialize, void> &&
140 std::is_same_v<Layout, Kokkos::LayoutRight>) {
141 if (layout.dimension[6] == unspecified) {
142 new_layout.stride = unspecified;
144 new_layout.stride = layout.stride;
148 new_layout.stride = layout.stride;
153 template <
typename Layout>
154 KOKKOS_INLINE_FUNCTION
static std::enable_if_t<
155 (std::is_same_v<Layout, Kokkos::LayoutStride>), Layout>
156 createLayout(
const Layout& layout) {
158 layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
160 layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
162 layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
164 layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
166 layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
168 layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
170 layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
172 layout.dimension[7] != unspecified ? layout.dimension[7] : unspecified,
177 template <
typename Traits,
typename... P>
178 KOKKOS_INLINE_FUNCTION
static std::enable_if_t<
179 (std::is_same_v<typename Traits::array_layout, Kokkos::LayoutRight> ||
180 std::is_same_v<typename Traits::array_layout, Kokkos::LayoutLeft> ||
181 std::is_same_v<typename Traits::array_layout, Kokkos::LayoutStride>),
182 typename Traits::array_layout>
183 createLayout([[maybe_unused]]
const Kokkos::Impl::ViewCtorProp<P...>& prop,
184 typename Traits::array_layout layout) {
186 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
187 if constexpr (Traits::impl_is_customized &&
188 !Kokkos::Impl::ViewCtorProp<P...>::has_accessor_arg) {
189 auto rank = computeRank(prop, layout) - 1;
190 layout.dimension[rank] = unspecified;
193 return createLayout(layout);
200 template <
typename ViewType,
typename ViewArg>
201 static ViewType createView(
const ViewArg& arg,
const size_t N0,
202 const size_t N1,
const size_t N2,
const size_t N3,
203 const size_t N4,
const size_t N5,
const size_t N6,
205 return ViewType(arg, N0 != unspecified ? N0 : 1, N1 != unspecified ? N1 : 1,
206 N2 != unspecified ? N2 : 1, N3 != unspecified ? N3 : 1,
207 N4 != unspecified ? N4 : 1, N5 != unspecified ? N5 : 1,
208 N6 != unspecified ? N6 : 1, N7 != unspecified ? N7 : 1);
213 template <
typename Layout,
typename iType>
214 KOKKOS_INLINE_FUNCTION std::enable_if_t<
215 (std::is_same_v<Layout, Kokkos::LayoutRight> ||
216 std::is_same_v<Layout, Kokkos::LayoutLeft>)&&std::is_integral_v<iType>,
218 reconstructLayout(
const Layout& layout, iType dynrank) {
219 return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
220 dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
221 dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
222 dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
223 dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
224 dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
225 dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
226 dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX);
230 template <
typename Layout,
typename iType>
231 KOKKOS_INLINE_FUNCTION std::enable_if_t<
232 (std::is_same_v<Layout, Kokkos::LayoutStride>)&&std::is_integral_v<iType>,
234 reconstructLayout(
const Layout& layout, iType dynrank) {
235 return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
236 dynrank > 0 ? layout.stride[0] : (0),
237 dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
238 dynrank > 1 ? layout.stride[1] : (0),
239 dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
240 dynrank > 2 ? layout.stride[2] : (0),
241 dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
242 dynrank > 3 ? layout.stride[3] : (0),
243 dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
244 dynrank > 4 ? layout.stride[4] : (0),
245 dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
246 dynrank > 5 ? layout.stride[5] : (0),
247 dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
248 dynrank > 6 ? layout.stride[6] : (0),
249 dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX,
250 dynrank > 7 ? layout.stride[7] : (0));
256 template <
unsigned,
typename iType0,
class MapType>
258 const iType0&,
const MapType&) {
262 template <
unsigned R,
typename iType0,
class MapType,
typename iType1,
265 const iType0& rank,
const MapType& map,
const iType1& i, Args... args) {
266 if (static_cast<iType0>(R) < rank) {
267 return (
size_t(i) < map.extent(R)) &&
268 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
271 "DynRankView Debug Bounds Checking Error: at rank %u\n Extra "
272 "arguments beyond the rank must be zero \n",
275 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
278 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
282 template <
unsigned,
class MapType>
283 inline void dyn_rank_view_error_operator_bounds(
char*,
int,
const MapType&) {}
285 template <
unsigned R,
class MapType,
class iType,
class... Args>
286 inline void dyn_rank_view_error_operator_bounds(
char* buf,
int len,
288 const iType& i, Args... args) {
289 const int n = snprintf(
290 buf, len,
" %ld < %ld %c", static_cast<unsigned long>(i),
291 static_cast<unsigned long>(map.extent(R)), (
sizeof...(Args) ?
',' :
')'));
292 dyn_rank_view_error_operator_bounds<R + 1>(buf + n, len - n, map, args...);
296 template <
typename MemorySpace,
typename iType0,
typename iType1,
class MapType,
299 const iType0& op_rank,
const iType1& rank,
300 const Kokkos::Impl::SharedAllocationTracker& tracker,
const MapType& map,
302 if (static_cast<iType0>(rank) > op_rank) {
304 "DynRankView Bounds Checking Error: Need at least rank arguments to "
308 if (!dyn_rank_view_verify_operator_bounds<0>(rank, map, args...)) {
310 (
enum {LEN = 1024};
char buffer[LEN];
311 const std::string label = tracker.template get_label<MemorySpace>();
312 int n = snprintf(buffer, LEN,
"DynRankView bounds error of view %s (",
314 dyn_rank_view_error_operator_bounds<0>(buffer + n, LEN - n, map,
316 Kokkos::Impl::throw_runtime_exception(std::string(buffer));))
319 ((
void)tracker; Kokkos::abort("DynRankView bounds error");))
330 template <
class DstTraits,
class SrcTraits>
332 DstTraits, SrcTraits,
334 (std::is_same_v<typename DstTraits::memory_space,
335 typename SrcTraits::memory_space> &&
336 std::is_void_v<typename DstTraits::specialize> &&
337 std::is_void_v<typename SrcTraits::specialize> &&
338 (std::is_same_v<typename DstTraits::array_layout,
339 typename SrcTraits::array_layout> ||
340 ((std::is_same_v<typename DstTraits::array_layout,
341 Kokkos::LayoutLeft> ||
342 std::is_same_v<typename DstTraits::array_layout,
343 Kokkos::LayoutRight> ||
345 typename DstTraits::array_layout,
346 Kokkos::LayoutStride>)&&(std::is_same_v<typename SrcTraits::
348 Kokkos::LayoutLeft> ||
350 typename SrcTraits::array_layout,
351 Kokkos::LayoutRight> ||
353 typename SrcTraits::array_layout,
354 Kokkos::LayoutStride>)))),
355 Kokkos::Impl::ViewToDynRankViewTag>> {
358 is_assignable_value_type =
359 std::is_same_v<
typename DstTraits::value_type,
360 typename SrcTraits::value_type> ||
361 std::is_same_v<
typename DstTraits::value_type,
362 typename SrcTraits::const_value_type>
366 is_assignable_layout =
367 std::is_same_v<
typename DstTraits::array_layout,
368 typename SrcTraits::array_layout> ||
369 std::is_same_v<typename DstTraits::array_layout, Kokkos::LayoutStride>
373 enum { is_assignable = is_assignable_value_type && is_assignable_layout };
375 using DstType = ViewMapping<DstTraits, typename DstTraits::specialize>;
376 using SrcType = ViewMapping<SrcTraits, typename SrcTraits::specialize>;
378 template <
typename DT,
typename... DP,
typename ST,
typename... SP>
379 KOKKOS_INLINE_FUNCTION
static void assign(
380 Kokkos::DynRankView<DT, DP...>& dst,
const Kokkos::View<ST, SP...>& src) {
382 is_assignable_value_type,
383 "View assignment must have same value type or const = non-const");
386 is_assignable_layout,
387 "View assignment must have compatible layout or have rank <= 1");
391 using dst_offset_type =
typename DstType::offset_type;
392 dst.m_map.m_impl_offset = dst_offset_type(
393 std::integral_constant<unsigned, 0>(),
395 dst.m_map.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
396 src.m_map.m_impl_handle, src.m_track.m_tracker);
397 dst.m_track.m_tracker.assign(src.m_track.m_tracker, DstTraits::is_managed);
398 dst.m_rank = Kokkos::View<ST, SP...>::rank();
421 struct is_dyn_rank_view :
public std::false_type {};
423 template <
class D,
class... P>
424 struct is_dyn_rank_view<Kokkos::DynRankView<D, P...>> :
public std::true_type {
428 inline constexpr
bool is_dyn_rank_view_v = is_dyn_rank_view<T>::value;
432 template <
typename DataType,
class... Properties>
433 class DynRankView :
private View<DataType*******, Properties...> {
434 static_assert(!std::is_array_v<DataType> && !std::is_pointer_v<DataType>,
435 "Cannot template DynRankView with array or pointer datatype - "
439 template <
class,
class...>
440 friend class DynRankView;
441 template <
class,
class...>
442 friend class Kokkos::Impl::ViewMapping;
447 using drvtraits = ViewTraits<DataType, Properties...>;
449 using view_type =
View<DataType*******, Properties...>;
452 #ifdef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
453 using drdtraits = Impl::DynRankDimTraits<typename view_type::specialize>;
455 using drdtraits = Impl::DynRankDimTraits<
456 std::conditional_t<view_type::traits::impl_is_customized, bool, void>>;
460 using data_type =
typename drvtraits::data_type;
461 using const_data_type =
typename drvtraits::const_data_type;
462 using non_const_data_type =
typename drvtraits::non_const_data_type;
465 using value_type =
typename view_type::value_type;
466 using const_value_type =
typename view_type::const_value_type;
467 using non_const_value_type =
typename view_type::non_const_value_type;
468 using traits =
typename view_type::traits;
469 using array_layout =
typename view_type::array_layout;
471 using execution_space =
typename view_type::execution_space;
472 using memory_space =
typename view_type::memory_space;
473 using device_type =
typename view_type::device_type;
475 using memory_traits =
typename view_type::memory_traits;
476 using host_mirror_space =
typename view_type::host_mirror_space;
477 using size_type =
typename view_type::size_type;
479 using reference_type =
typename view_type::reference_type;
480 using pointer_type =
typename view_type::pointer_type;
482 using scalar_array_type = value_type;
483 using const_scalar_array_type = const_value_type;
484 using non_const_scalar_array_type = non_const_value_type;
485 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
486 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
487 using specialize KOKKOS_DEPRECATED = void;
490 using specialize =
typename view_type::specialize;
496 using index_type =
typename view_type::index_type;
497 using element_type =
typename view_type::element_type;
498 using rank_type =
typename view_type::rank_type;
499 using reference = reference_type;
500 using data_handle_type = pointer_type;
503 view_type& DownCast()
const {
return (view_type&)(*this); }
508 const view_type& ConstDownCast()
const {
return (
const view_type&)(*this); }
518 using array_type = DynRankView<
519 typename drvtraits::scalar_array_type,
typename drvtraits::array_layout,
520 typename drvtraits::device_type,
typename drvtraits::memory_traits>;
523 using const_type = DynRankView<
524 typename drvtraits::const_data_type,
typename drvtraits::array_layout,
525 typename drvtraits::device_type,
typename drvtraits::memory_traits>;
528 using non_const_type = DynRankView<
529 typename drvtraits::non_const_data_type,
typename drvtraits::array_layout,
530 typename drvtraits::device_type,
typename drvtraits::memory_traits>;
533 using HostMirror = DynRankView<
typename drvtraits::non_const_data_type,
534 typename drvtraits::array_layout,
535 typename drvtraits::host_mirror_space>;
537 using host_mirror_type = HostMirror;
554 std::is_same_v<typename traits::array_layout, Kokkos::LayoutLeft>,
557 std::is_same_v<typename traits::array_layout, Kokkos::LayoutRight>,
560 std::is_same_v<typename traits::array_layout, Kokkos::LayoutStride>,
562 is_default_map = std::is_void_v<typename traits::specialize> &&
563 (is_layout_left || is_layout_right || is_layout_stride),
566 is_default_map && std::is_same_v<reference_type, element_type&>
570 #if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
573 #define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
574 Kokkos::Impl::runtime_check_memory_access_violation< \
575 typename traits::memory_space>( \
576 "Kokkos::DynRankView ERROR: attempt to access inaccessible memory " \
578 Kokkos::Impl::dyn_rank_view_verify_operator_bounds< \
579 typename traits::memory_space> \
584 #define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
585 Kokkos::Impl::runtime_check_memory_access_violation< \
586 typename traits::memory_space>( \
587 "Kokkos::DynRankView ERROR: attempt to access inaccessible memory " \
594 constexpr
unsigned rank()
const {
return m_rank; }
596 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
597 using view_type::accessor;
598 using view_type::mapping;
600 using view_type::data;
601 using view_type::extent;
602 using view_type::extent_int;
603 using view_type::impl_map;
604 using view_type::is_allocated;
605 using view_type::label;
606 using view_type::size;
607 using view_type::span;
608 using view_type::span_is_contiguous;
609 using view_type::stride;
610 using view_type::stride_0;
611 using view_type::stride_1;
612 using view_type::stride_2;
613 using view_type::stride_3;
614 using view_type::stride_4;
615 using view_type::stride_5;
616 using view_type::stride_6;
617 using view_type::stride_7;
618 using view_type::use_count;
620 #ifdef KOKKOS_ENABLE_CUDA
621 KOKKOS_FUNCTION reference_type
622 operator()(index_type i0 = 0, index_type i1 = 0, index_type i2 = 0,
623 index_type i3 = 0, index_type i4 = 0, index_type i5 = 0,
624 index_type i6 = 0)
const {
625 return view_type::operator()(i0, i1, i2, i3, i4, i5, i6);
635 KOKKOS_FUNCTION reference_type operator()()
const {
636 #ifdef KOKKOS_ENABLE_DEBUG
639 "DynRankView rank 0 operator() called with invalid number of "
642 #ifndef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
643 if constexpr (is_default_access) {
644 return view_type::data()[0];
648 return view_type::operator()(0, 0, 0, 0, 0, 0, 0);
652 KOKKOS_FUNCTION reference_type operator()(index_type i0)
const {
653 #ifdef KOKKOS_ENABLE_DEBUG
658 "DynRankView rank 1 operator() called with invalid number of "
661 #ifndef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
662 if constexpr (is_default_access) {
663 if constexpr (is_layout_stride) {
664 return view_type::data()[i0 * view_type::stride(0)];
666 return view_type::data()[i0];
671 return view_type::operator()(i0, 0, 0, 0, 0, 0, 0);
673 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
674 !defined(KOKKOS_COMPILER_MSVC)
675 __builtin_unreachable();
679 KOKKOS_FUNCTION reference_type operator()(index_type i0,
680 index_type i1)
const {
681 #ifdef KOKKOS_ENABLE_DEBUG
686 "DynRankView rank 2 operator() called with invalid number of "
689 #ifndef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
690 if constexpr (is_default_access) {
691 if constexpr (is_layout_left) {
692 return view_type::data()[i0 + i1 * view_type::stride(1)];
693 }
else if constexpr (is_layout_right) {
694 return view_type::data()[i0 * view_type::extent(1) + i1];
696 return view_type::data()[i0 * view_type::stride(0) +
697 i1 * view_type::stride(1)];
702 return view_type::operator()(i0, i1, 0, 0, 0, 0, 0);
704 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
705 !defined(KOKKOS_COMPILER_MSVC)
706 __builtin_unreachable();
710 KOKKOS_FUNCTION reference_type operator()(index_type i0, index_type i1,
711 index_type i2)
const {
712 #ifdef KOKKOS_ENABLE_DEBUG
717 "DynRankView rank 3 operator() called with invalid number of "
720 #ifndef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
721 if constexpr (is_default_access) {
722 if constexpr (is_layout_left) {
723 return view_type::data()[i0 + view_type::stride(1) *
724 (i1 + i2 * view_type::extent(1))];
725 }
else if constexpr (is_layout_right) {
726 return view_type::data()[(i0 * view_type::extent(1) + i1) *
727 view_type::extent(2) +
730 return view_type::data()[i0 * view_type::stride(0) +
731 i1 * view_type::stride(1) +
732 i2 * view_type::stride(2)];
737 return view_type::operator()(i0, i1, i2, 0, 0, 0, 0);
739 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
740 !defined(KOKKOS_COMPILER_MSVC)
741 __builtin_unreachable();
745 KOKKOS_FUNCTION reference_type operator()(index_type i0, index_type i1,
746 index_type i2, index_type i3,
749 index_type i6 = 0)
const {
750 return view_type::operator()(i0, i1, i2, i3, i4, i5, i6);
756 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
757 KOKKOS_FUNCTION reference_type operator[](index_type i0)
const {
758 if constexpr (std::is_same_v<
typename drvtraits::value_type,
759 typename drvtraits::scalar_array_type>) {
760 return view_type::data()[i0];
762 const size_t dim_scalar = view_type::impl_map().dimension_scalar();
763 const size_t bytes = view_type::span() / dim_scalar;
765 using tmp_view_type =
766 Kokkos::View<DataType*,
typename traits::array_layout,
767 typename traits::device_type,
768 Kokkos::MemoryTraits<traits::memory_traits::impl_value |
769 unsigned(Kokkos::Unmanaged)>>;
770 tmp_view_type rankone_view(view_type::data(), bytes, dim_scalar);
771 return rankone_view(i0);
775 KOKKOS_FUNCTION reference_type operator[](index_type i0)
const {
776 #ifdef KOKKOS_ENABLE_DEBUG
778 Kokkos::abort(
"DynRankView operator[] can only be used for rank-1");
780 return view_type::operator()(i0, 0, 0, 0, 0, 0, 0);
784 KOKKOS_FUNCTION reference_type access(index_type i0 = 0, index_type i1 = 0,
785 index_type i2 = 0, index_type i3 = 0,
786 index_type i4 = 0, index_type i5 = 0,
787 index_type i6 = 0)
const {
788 return view_type::operator()(i0, i1, i2, i3, i4, i5, i6);
794 KOKKOS_DEFAULTED_FUNCTION
795 ~DynRankView() =
default;
797 KOKKOS_DEFAULTED_FUNCTION DynRankView() =
default;
803 template <
class RT,
class... RP>
804 KOKKOS_FUNCTION DynRankView(
const DynRankView<RT, RP...>& rhs)
805 : view_type(rhs), m_rank(rhs.m_rank) {}
807 template <
class RT,
class... RP>
808 KOKKOS_FUNCTION DynRankView& operator=(
const DynRankView<RT, RP...>& rhs) {
809 view_type::operator=(rhs);
814 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
817 KOKKOS_FUNCTION
typename view_type::extents_type create_rank7_extents(
819 return typename view_type::extents_type(
820 ext.rank() > 0 ? ext.extent(0) : 1, ext.rank() > 1 ? ext.extent(1) : 1,
821 ext.rank() > 2 ? ext.extent(2) : 1, ext.rank() > 3 ? ext.extent(3) : 1,
822 ext.rank() > 4 ? ext.extent(4) : 1, ext.rank() > 5 ? ext.extent(5) : 1,
823 ext.rank() > 6 ? ext.extent(6) : 1);
828 template <
class RT,
class... RP>
829 KOKKOS_INLINE_FUNCTION DynRankView(
const View<RT, RP...>& rhs,
831 : view_type(rhs.data_handle(),
832 Impl::mapping_from_array_layout<
833 typename view_type::mdspan_type::mapping_type>(
834 drdtraits::createLayout(rhs.layout())),
837 if (new_rank > View<RT, RP...>::rank())
839 "Attempting to construct DynRankView from View and new rank, with "
840 "the new rank being too large.");
843 template <
class RT,
class... RP>
844 KOKKOS_INLINE_FUNCTION DynRankView& operator=(
const View<RT, RP...>& rhs) {
845 view_type::operator=(
846 view_type(rhs.data_handle(),
847 Impl::mapping_from_array_layout<
848 typename view_type::mdspan_type::mapping_type>(
849 drdtraits::createLayout(rhs.layout())),
855 template <
class RT,
class... RP>
856 KOKKOS_FUNCTION DynRankView(
const View<RT, RP...>& rhs,
size_t new_rank) {
857 using SrcTraits =
typename View<RT, RP...>::traits;
859 Kokkos::Impl::ViewMapping<traits, SrcTraits,
861 static_assert(Mapping::is_assignable,
862 "Incompatible View to DynRankView copy assignment");
863 if (new_rank > View<RT, RP...>::rank())
865 "Attempting to construct DynRankView from View and new rank, with "
866 "the new rank being too large.");
867 Mapping::assign(*
this, rhs);
871 template <
class RT,
class... RP>
872 KOKKOS_FUNCTION DynRankView& operator=(
const View<RT, RP...>& rhs) {
873 using SrcTraits =
typename View<RT, RP...>::traits;
875 Kokkos::Impl::ViewMapping<traits, SrcTraits,
876 Kokkos::Impl::ViewToDynRankViewTag>;
877 static_assert(Mapping::is_assignable,
878 "Incompatible View to DynRankView copy assignment");
879 Mapping::assign(*
this, rhs);
880 m_rank = View<RT, RP...>::rank();
885 template <
class RT,
class... RP>
886 KOKKOS_FUNCTION DynRankView(
const View<RT, RP...>& rhs)
887 : DynRankView(rhs,
View<RT, RP...>::rank()) {}
899 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
902 template <
class... P>
903 KOKKOS_FUNCTION
auto attach_accessor_arg_if_needed(
904 const Impl::ViewCtorProp<P...>& arg_prop,
905 std::enable_if_t<((!std::is_same_v<P, std::string>)&&...),
906 const typename traits::array_layout&>
908 if constexpr (traits::impl_is_customized) {
910 while (r < 7 && layout.dimension[r] != KOKKOS_INVALID_INDEX) r++;
914 static_cast<const Impl::ViewCtorProp<void, P>&
>(arg_prop).value...,
915 Impl::AccessorArg_t{r > 0 ?
size_t(layout.dimension[r - 1]) : 0ul});
920 template <
class... P>
921 auto attach_accessor_arg_if_needed(
922 const Impl::ViewCtorProp<P...>& arg_prop,
923 std::enable_if_t<(std::is_same_v<P, std::string> || ...),
924 const typename traits::array_layout&>
926 if constexpr (traits::impl_is_customized &&
927 !Impl::ViewCtorProp<P...>::has_accessor_arg) {
929 while (r < 7 && layout.dimension[r] != KOKKOS_INVALID_INDEX) r++;
932 static_cast<const Impl::ViewCtorProp<void, P>&
>(arg_prop).value...,
933 Impl::AccessorArg_t{r > 0 ?
size_t(layout.dimension[r - 1]) : 0ul});
946 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_GNU)
947 #if KOKKOS_COMPILER_GNU < 900
948 #define KOKKOS_IMPL_SKIP_OPTIMIZATION
952 #ifdef KOKKOS_IMPL_SKIP_OPTIMIZATION
955 #pragma diag_suppress = unrecognized_gcc_pragma
956 #pragma GCC push_options
957 #pragma GCC optimize("O1")
959 template <
class... P>
960 explicit KOKKOS_FUNCTION DynRankView(
961 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
962 std::enable_if_t<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
963 typename traits::array_layout
const&>
965 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
966 : view_type(attach_accessor_arg_if_needed(arg_prop, arg_layout),
967 drdtraits::template createLayout<traits, P...>(arg_prop,
969 m_rank(drdtraits::computeRank(arg_prop, arg_layout) -
970 (traits::impl_is_customized ? 1 : 0)){}
972 : view_type(arg_prop, drdtraits::template createLayout<traits, P...>(
973 arg_prop, arg_layout)),
974 m_rank(drdtraits::computeRank(arg_prop, arg_layout)) {
978 template <
class... P>
979 explicit DynRankView(
980 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
981 std::enable_if_t<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
982 typename traits::array_layout
const&>
984 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
985 : view_type(attach_accessor_arg_if_needed(arg_prop, arg_layout),
986 drdtraits::template createLayout<traits, P...>(arg_prop,
988 m_rank(drdtraits::computeRank(arg_prop, arg_layout) -
989 (traits::impl_is_customized &&
990 !Kokkos::Impl::ViewCtorProp<P...>::has_accessor_arg
994 : view_type(arg_prop, drdtraits::template createLayout<traits, P...>(
995 arg_prop, arg_layout)),
996 m_rank(drdtraits::computeRank(arg_prop, arg_layout)) {
1000 #ifdef KOKKOS_IMPL_SKIP_OPTIMIZATION
1001 #pragma GCC pop_options
1003 #undef KOKKOS_IMPL_SKIP_OPTIMIZATION
1012 template <
class... P>
1013 explicit KOKKOS_FUNCTION DynRankView(
1014 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1015 std::enable_if_t<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1017 arg_N0 = KOKKOS_INVALID_INDEX,
1018 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1019 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1020 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1021 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1022 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1023 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1024 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1025 : DynRankView(arg_prop, typename traits::array_layout(
1026 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
1027 arg_N5, arg_N6, arg_N7)) {
1030 template <
class... P>
1031 explicit DynRankView(
1032 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1033 std::enable_if_t<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1035 arg_N0 = KOKKOS_INVALID_INDEX,
1036 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1037 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1038 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1039 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1040 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1041 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1042 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1043 : DynRankView(arg_prop, typename traits::array_layout(
1044 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
1045 arg_N5, arg_N6, arg_N7)) {}
1048 template <
typename Label>
1049 explicit inline DynRankView(
1050 const Label& arg_label,
1051 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value,
1052 typename traits::array_layout>
const& arg_layout)
1053 : DynRankView(Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
1057 template <
typename Label>
1058 explicit inline DynRankView(
1059 const Label& arg_label,
1060 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value,
const size_t>
1061 arg_N0 = KOKKOS_INVALID_INDEX,
1062 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1063 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1064 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1065 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1066 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1067 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1068 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1070 Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
1071 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1072 arg_N4, arg_N5, arg_N6, arg_N7)) {}
1077 static constexpr
size_t required_allocation_size(
1078 const size_t arg_N0 = 1,
const size_t arg_N1 = 1,
const size_t arg_N2 = 1,
1079 const size_t arg_N3 = 1,
const size_t arg_N4 = 1,
const size_t arg_N5 = 1,
1080 const size_t arg_N6 = 1,
1081 [[maybe_unused]]
const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
1083 return view_type::required_allocation_size(arg_N0, arg_N1, arg_N2, arg_N3,
1084 arg_N4, arg_N5, arg_N6);
1087 explicit KOKKOS_FUNCTION DynRankView(
1088 typename view_type::pointer_type arg_ptr,
1089 const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1090 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1091 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1092 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1093 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1094 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1095 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1096 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1098 Kokkos::Impl::ViewCtorProp<typename view_type::pointer_type>(
1100 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7) {}
1102 explicit KOKKOS_FUNCTION DynRankView(
1103 typename view_type::pointer_type arg_ptr,
1104 typename traits::array_layout& arg_layout)
1106 Kokkos::Impl::ViewCtorProp<typename view_type::pointer_type>(
1114 static inline size_t shmem_size(
1115 const size_t arg_N0 = 1,
const size_t arg_N1 = 1,
const size_t arg_N2 = 1,
1116 const size_t arg_N3 = 1,
const size_t arg_N4 = 1,
const size_t arg_N5 = 1,
1117 const size_t arg_N6 = 1,
const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
1118 return view_type::shmem_size(arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5,
1122 explicit KOKKOS_FUNCTION DynRankView(
1123 const typename traits::execution_space::scratch_memory_space& arg_space,
1124 const typename traits::array_layout& arg_layout)
1125 : view_type(arg_space, drdtraits::createLayout(arg_layout)),
1126 m_rank(drdtraits::computeRank(arg_layout)) {}
1128 explicit KOKKOS_FUNCTION DynRankView(
1129 const typename traits::execution_space::scratch_memory_space& arg_space,
1130 const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1131 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1132 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1133 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1134 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1135 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1136 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1137 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1139 : DynRankView(arg_space, typename traits::array_layout(
1140 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
1141 arg_N5, arg_N6, arg_N7)) {}
1143 KOKKOS_FUNCTION constexpr
auto layout()
const {
1145 case 0:
return Impl::as_view_of_rank_n<0>(*this).layout();
1146 case 1:
return Impl::as_view_of_rank_n<1>(*this).layout();
1147 case 2:
return Impl::as_view_of_rank_n<2>(*this).layout();
1148 case 3:
return Impl::as_view_of_rank_n<3>(*this).layout();
1149 case 4:
return Impl::as_view_of_rank_n<4>(*this).layout();
1150 case 5:
return Impl::as_view_of_rank_n<5>(*this).layout();
1151 case 6:
return Impl::as_view_of_rank_n<6>(*this).layout();
1152 case 7:
return Impl::as_view_of_rank_n<7>(*this).layout();
1157 "Calling DynRankView::layout on DRV of unexpected rank " +
1158 std::to_string(rank()))
1160 KOKKOS_IF_ON_DEVICE(
1162 "Calling DynRankView::layout on DRV of unexpected rank");)
1165 return view_type::layout();
1169 template <
typename D,
class... P>
1170 KOKKOS_FUNCTION constexpr
unsigned rank(
const DynRankView<D, P...>& DRV) {
1181 struct DynRankSubviewTag {};
1185 template <
class V,
class... Args>
1186 using Subdynrankview =
1187 typename Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag, V,
1190 template <
class... DRVArgs,
class SubArg0 = int,
class SubArg1 = int,
1191 class SubArg2 = int,
class SubArg3 = int,
class SubArg4 = int,
1192 class SubArg5 = int,
class SubArg6 =
int>
1193 KOKKOS_INLINE_FUNCTION
auto subdynrankview(
1194 const DynRankView<DRVArgs...>& drv, SubArg0 arg0 = SubArg0{},
1195 SubArg1 arg1 = SubArg1{}, SubArg2 arg2 = SubArg2{},
1196 SubArg3 arg3 = SubArg3{}, SubArg4 arg4 = SubArg4{},
1197 SubArg5 arg5 = SubArg5{}, SubArg6 arg6 = SubArg6{}) {
1198 auto sub = subview(drv.DownCast(), arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1199 using sub_t = decltype(sub);
1200 size_t new_rank = (drv.rank() > 0 && !std::is_integral_v<SubArg0> ? 1 : 0) +
1201 (drv.rank() > 1 && !std::is_integral_v<SubArg1> ? 1 : 0) +
1202 (drv.rank() > 2 && !std::is_integral_v<SubArg2> ? 1 : 0) +
1203 (drv.rank() > 3 && !std::is_integral_v<SubArg3> ? 1 : 0) +
1204 (drv.rank() > 4 && !std::is_integral_v<SubArg4> ? 1 : 0) +
1205 (drv.rank() > 5 && !std::is_integral_v<SubArg5> ? 1 : 0) +
1206 (drv.rank() > 6 && !std::is_integral_v<SubArg6> ? 1 : 0);
1210 typename sub_t::device_type,
typename sub_t::memory_traits>;
1211 return static_cast<return_type
>(
1212 DynRankView<
typename sub_t::value_type,
typename sub_t::array_layout,
1213 typename sub_t::device_type,
typename sub_t::memory_traits>(
1216 template <
class... DRVArgs,
class SubArg0 = int,
class SubArg1 = int,
1217 class SubArg2 = int,
class SubArg3 = int,
class SubArg4 = int,
1218 class SubArg5 = int,
class SubArg6 =
int>
1219 KOKKOS_INLINE_FUNCTION
auto subview(
1220 const DynRankView<DRVArgs...>& drv, SubArg0 arg0 = SubArg0{},
1221 SubArg1 arg1 = SubArg1{}, SubArg2 arg2 = SubArg2{},
1222 SubArg3 arg3 = SubArg3{}, SubArg4 arg4 = SubArg4{},
1223 SubArg5 arg5 = SubArg5{}, SubArg6 arg6 = SubArg6{}) {
1224 return subdynrankview(drv, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1232 template <
class LT,
class... LP,
class RT,
class... RP>
1233 KOKKOS_INLINE_FUNCTION
bool operator==(
const DynRankView<LT, LP...>& lhs,
1234 const DynRankView<RT, RP...>& rhs) {
1236 using lhs_traits = ViewTraits<LT, LP...>;
1237 using rhs_traits = ViewTraits<RT, RP...>;
1239 return std::is_same_v<
typename lhs_traits::const_value_type,
1240 typename rhs_traits::const_value_type> &&
1241 std::is_same_v<
typename lhs_traits::array_layout,
1242 typename rhs_traits::array_layout> &&
1243 std::is_same_v<
typename lhs_traits::memory_space,
1244 typename rhs_traits::memory_space> &&
1245 lhs.rank() == rhs.rank() && lhs.data() == rhs.data() &&
1246 lhs.span() == rhs.span() && lhs.extent(0) == rhs.extent(0) &&
1247 lhs.extent(1) == rhs.extent(1) && lhs.extent(2) == rhs.extent(2) &&
1248 lhs.extent(3) == rhs.extent(3) && lhs.extent(4) == rhs.extent(4) &&
1249 lhs.extent(5) == rhs.extent(5) && lhs.extent(6) == rhs.extent(6) &&
1250 lhs.extent(7) == rhs.extent(7);
1253 template <
class LT,
class... LP,
class RT,
class... RP>
1254 KOKKOS_INLINE_FUNCTION
bool operator!=(
const DynRankView<LT, LP...>& lhs,
1255 const DynRankView<RT, RP...>& rhs) {
1256 return !(operator==(lhs, rhs));
1266 template <
class OutputView,
class InputView,
1267 class ExecSpace =
typename OutputView::execution_space>
1268 struct DynRankViewRemap {
1269 const OutputView output;
1270 const InputView input;
1280 DynRankViewRemap(
const ExecSpace& exec_space,
const OutputView& arg_out,
1281 const InputView& arg_in)
1284 n0(std::min((size_t)arg_out.extent(0), (size_t)arg_in.extent(0))),
1285 n1(std::min((size_t)arg_out.extent(1), (size_t)arg_in.extent(1))),
1286 n2(std::min((size_t)arg_out.extent(2), (size_t)arg_in.extent(2))),
1287 n3(std::min((size_t)arg_out.extent(3), (size_t)arg_in.extent(3))),
1288 n4(std::min((size_t)arg_out.extent(4), (size_t)arg_in.extent(4))),
1289 n5(std::min((size_t)arg_out.extent(5), (size_t)arg_in.extent(5))),
1290 n6(std::min((size_t)arg_out.extent(6), (size_t)arg_in.extent(6))),
1291 n7(std::min((size_t)arg_out.extent(7), (size_t)arg_in.extent(7))) {
1294 Kokkos::parallel_for(
"Kokkos::DynRankViewRemap", Policy(exec_space, 0, n0),
1298 DynRankViewRemap(
const OutputView& arg_out,
const InputView& arg_in)
1301 n0(std::min((size_t)arg_out.extent(0), (size_t)arg_in.extent(0))),
1302 n1(std::min((size_t)arg_out.extent(1), (size_t)arg_in.extent(1))),
1303 n2(std::min((size_t)arg_out.extent(2), (size_t)arg_in.extent(2))),
1304 n3(std::min((size_t)arg_out.extent(3), (size_t)arg_in.extent(3))),
1305 n4(std::min((size_t)arg_out.extent(4), (size_t)arg_in.extent(4))),
1306 n5(std::min((size_t)arg_out.extent(5), (size_t)arg_in.extent(5))),
1307 n6(std::min((size_t)arg_out.extent(6), (size_t)arg_in.extent(6))),
1308 n7(std::min((size_t)arg_out.extent(7), (size_t)arg_in.extent(7))) {
1311 Kokkos::parallel_for(
"Kokkos::DynRankViewRemap", Policy(0, n0), *
this);
1314 KOKKOS_INLINE_FUNCTION
1315 void operator()(
const size_t i0)
const {
1316 for (
size_t i1 = 0; i1 < n1; ++i1) {
1317 for (
size_t i2 = 0; i2 < n2; ++i2) {
1318 for (
size_t i3 = 0; i3 < n3; ++i3) {
1319 for (
size_t i4 = 0; i4 < n4; ++i4) {
1320 for (
size_t i5 = 0; i5 < n5; ++i5) {
1321 for (
size_t i6 = 0; i6 < n6; ++i6) {
1322 output.access(i0, i1, i2, i3, i4, i5, i6) =
1323 input.access(i0, i1, i2, i3, i4, i5, i6);
1343 template <
unsigned N,
typename T,
typename... Args>
1344 KOKKOS_FUNCTION View<typename ViewDataTypeFromRank<T, N>::type, Args...>
1346 DynRankView<T, Args...> v,
1348 std::is_same_v<
typename ViewTraits<T, Args...>::specialize,
void>>*) {
1349 if (v.rank() != N) {
1351 const std::string message =
1352 "Converting DynRankView of rank " + std::to_string(v.rank()) +
1353 " to a View of mis-matched rank " + std::to_string(N) +
"!";
1354 Kokkos::abort(message.c_str());)
1355 KOKKOS_IF_ON_DEVICE(
1356 Kokkos::abort(
"Converting DynRankView to a View of mis-matched rank!");)
1359 auto layout = v.DownCast().layout();
1364 for (
int i = N; i < 7; ++i)
1365 layout.dimension[i] = KOKKOS_IMPL_CTOR_DEFAULT_ARG;
1368 #ifndef KOKKOS_ENABLE_IMPL_VIEW_LEGACY
1369 if constexpr (ViewTraits<T, Args...>::impl_is_customized) {
1370 return View<typename RankDataType<T, N>::type, Args...>(
1372 v.data(), Kokkos::Impl::AccessorArg_t{v.accessor().fad_size() + 1}),
1376 return View<typename RankDataType<T, N>::type, Args...>(v.data(), layout);
1379 template <
typename... Args>
1380 struct ApplyToViewOfStaticRank<DynRankView<Args...>> {
1381 template <
typename Function>
1382 static void apply(Function&& f, DynRankView<Args...> a) {
1384 case 0: f(as_view_of_rank_n<0>(a));
break;
1385 case 1: f(as_view_of_rank_n<1>(a));
break;
1386 case 2: f(as_view_of_rank_n<2>(a));
break;
1387 case 3: f(as_view_of_rank_n<3>(a));
break;
1388 case 4: f(as_view_of_rank_n<4>(a));
break;
1389 case 5: f(as_view_of_rank_n<5>(a));
break;
1390 case 6: f(as_view_of_rank_n<6>(a));
break;
1391 case 7: f(as_view_of_rank_n<7>(a));
break;
1396 "Trying to apply a function to a view of unexpected rank " +
1397 std::to_string(rank(a)))
1399 KOKKOS_IF_ON_DEVICE(
1401 "Trying to apply a function to a view of unexpected rank");)
1409 template <
class ExecSpace,
class DT,
class... DP>
1410 inline void deep_copy(
1411 const ExecSpace& e,
const DynRankView<DT, DP...>& dst,
1412 typename ViewTraits<DT, DP...>::const_value_type& value,
1413 std::enable_if_t<std::is_same_v<
typename ViewTraits<DT, DP...>::specialize,
1414 void>>* =
nullptr) {
1416 std::is_same_v<
typename ViewTraits<DT, DP...>::non_const_value_type,
1417 typename ViewTraits<DT, DP...>::value_type>,
1418 "deep_copy requires non-const type");
1420 Impl::ApplyToViewOfStaticRank<DynRankView<DT, DP...>>::apply(
1421 [=](
auto view) { deep_copy(e, view, value); }, dst);
1424 template <
class DT,
class... DP>
1425 inline void deep_copy(
1426 const DynRankView<DT, DP...>& dst,
1427 typename ViewTraits<DT, DP...>::const_value_type& value,
1428 std::enable_if_t<std::is_same_v<
typename ViewTraits<DT, DP...>::specialize,
1429 void>>* =
nullptr) {
1430 Impl::ApplyToViewOfStaticRank<DynRankView<DT, DP...>>::apply(
1431 [=](
auto view) { deep_copy(view, value); }, dst);
1435 template <
class ExecSpace,
class ST,
class... SP>
1436 inline void deep_copy(
1438 typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1439 const DynRankView<ST, SP...>& src,
1440 std::enable_if_t<std::is_same_v<
typename ViewTraits<ST, SP...>::specialize,
1442 deep_copy(e, dst, Impl::as_view_of_rank_n<0>(src));
1445 template <
class ST,
class... SP>
1446 inline void deep_copy(
1447 typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1448 const DynRankView<ST, SP...>& src,
1449 std::enable_if_t<std::is_same_v<
typename ViewTraits<ST, SP...>::specialize,
1451 deep_copy(dst, Impl::as_view_of_rank_n<0>(src));
1460 template <
class ExecSpace,
class DstType,
class SrcType>
1461 inline void deep_copy(
1462 const ExecSpace& exec_space,
const DstType& dst,
const SrcType& src,
1463 std::enable_if_t<(std::is_void_v<typename DstType::traits::specialize> &&
1464 std::is_void_v<typename SrcType::traits::specialize> &&
1465 (Kokkos::is_dyn_rank_view<DstType>::value ||
1466 Kokkos::is_dyn_rank_view<SrcType>::value))>* =
nullptr) {
1467 static_assert(std::is_same_v<
typename DstType::traits::value_type,
1468 typename DstType::traits::non_const_value_type>,
1469 "deep_copy requires non-const destination type");
1471 switch (rank(dst)) {
1473 deep_copy(exec_space, Impl::as_view_of_rank_n<0>(dst),
1474 Impl::as_view_of_rank_n<0>(src));
1477 deep_copy(exec_space, Impl::as_view_of_rank_n<1>(dst),
1478 Impl::as_view_of_rank_n<1>(src));
1481 deep_copy(exec_space, Impl::as_view_of_rank_n<2>(dst),
1482 Impl::as_view_of_rank_n<2>(src));
1485 deep_copy(exec_space, Impl::as_view_of_rank_n<3>(dst),
1486 Impl::as_view_of_rank_n<3>(src));
1489 deep_copy(exec_space, Impl::as_view_of_rank_n<4>(dst),
1490 Impl::as_view_of_rank_n<4>(src));
1493 deep_copy(exec_space, Impl::as_view_of_rank_n<5>(dst),
1494 Impl::as_view_of_rank_n<5>(src));
1497 deep_copy(exec_space, Impl::as_view_of_rank_n<6>(dst),
1498 Impl::as_view_of_rank_n<6>(src));
1501 deep_copy(exec_space, Impl::as_view_of_rank_n<7>(dst),
1502 Impl::as_view_of_rank_n<7>(src));
1505 Kokkos::Impl::throw_runtime_exception(
1506 "Calling DynRankView deep_copy with a view of unexpected rank " +
1507 std::to_string(rank(dst)));
1511 template <
class DstType,
class SrcType>
1512 inline void deep_copy(
1513 const DstType& dst,
const SrcType& src,
1514 std::enable_if_t<(std::is_void_v<typename DstType::traits::specialize> &&
1515 std::is_void_v<typename SrcType::traits::specialize> &&
1516 (Kokkos::is_dyn_rank_view<DstType>::value ||
1517 Kokkos::is_dyn_rank_view<SrcType>::value))>* =
nullptr) {
1518 static_assert(std::is_same_v<
typename DstType::traits::value_type,
1519 typename DstType::traits::non_const_value_type>,
1520 "deep_copy requires non-const destination type");
1522 switch (rank(dst)) {
1524 deep_copy(Impl::as_view_of_rank_n<0>(dst),
1525 Impl::as_view_of_rank_n<0>(src));
1528 deep_copy(Impl::as_view_of_rank_n<1>(dst),
1529 Impl::as_view_of_rank_n<1>(src));
1532 deep_copy(Impl::as_view_of_rank_n<2>(dst),
1533 Impl::as_view_of_rank_n<2>(src));
1536 deep_copy(Impl::as_view_of_rank_n<3>(dst),
1537 Impl::as_view_of_rank_n<3>(src));
1540 deep_copy(Impl::as_view_of_rank_n<4>(dst),
1541 Impl::as_view_of_rank_n<4>(src));
1544 deep_copy(Impl::as_view_of_rank_n<5>(dst),
1545 Impl::as_view_of_rank_n<5>(src));
1548 deep_copy(Impl::as_view_of_rank_n<6>(dst),
1549 Impl::as_view_of_rank_n<6>(src));
1552 deep_copy(Impl::as_view_of_rank_n<7>(dst),
1553 Impl::as_view_of_rank_n<7>(src));
1556 Kokkos::Impl::throw_runtime_exception(
1557 "Calling DynRankView deep_copy with a view of unexpected rank " +
1558 std::to_string(rank(dst)));
1571 template <
class Space,
class T,
class... P>
1572 struct MirrorDRViewType {
1574 using src_view_type =
typename Kokkos::DynRankView<T, P...>;
1576 using memory_space =
typename Space::memory_space;
1580 std::is_same_v<memory_space, typename src_view_type::memory_space>
1583 using array_layout =
typename src_view_type::array_layout;
1586 using data_type =
typename src_view_type::non_const_data_type;
1588 using dest_view_type = Kokkos::DynRankView<data_type, array_layout, Space>;
1592 std::conditional_t<is_same_memspace, src_view_type, dest_view_type>;
1602 template <
class T,
class... P,
class... ViewCtorArgs>
1603 inline auto create_mirror(
const DynRankView<T, P...>& src,
1604 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
1605 check_view_ctor_args_create_mirror<ViewCtorArgs...>();
1607 auto prop_copy = Impl::with_properties_if_unset(
1608 arg_prop, std::string(src.label()).append(
"_mirror"));
1610 if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
1611 using dst_type =
typename Impl::MirrorDRViewType<
1612 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
1613 P...>::dest_view_type;
1614 return dst_type(prop_copy,
1615 Impl::reconstructLayout(src.layout(), src.rank()));
1617 using src_type = DynRankView<T, P...>;
1618 using dst_type =
typename src_type::HostMirror;
1620 return dst_type(prop_copy,
1621 Impl::reconstructLayout(src.layout(), src.rank()));
1623 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
1624 !defined(KOKKOS_COMPILER_MSVC)
1625 __builtin_unreachable();
1632 template <
class T,
class... P,
1633 class Enable = std::enable_if_t<
1634 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1635 inline auto create_mirror(
const DynRankView<T, P...>& src) {
1636 return Impl::create_mirror(src, Kokkos::view_alloc());
1640 template <
class T,
class... P,
1641 class Enable = std::enable_if_t<
1642 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1643 inline auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
1644 const DynRankView<T, P...>& src) {
1645 return Impl::create_mirror(src, Kokkos::view_alloc(wi));
1649 template <
class Space,
class T,
class... P,
1650 class Enable = std::enable_if_t<
1651 Kokkos::is_space<Space>::value &&
1652 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1653 inline auto create_mirror(
const Space&,
1654 const Kokkos::DynRankView<T, P...>& src) {
1655 return Impl::create_mirror(
1656 src, Kokkos::view_alloc(
typename Space::memory_space{}));
1660 template <
class Space,
class T,
class... P,
1661 class Enable = std::enable_if_t<
1662 Kokkos::is_space<Space>::value &&
1663 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1664 inline auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
const Space&,
1665 const Kokkos::DynRankView<T, P...>& src) {
1666 return Impl::create_mirror(
1667 src, Kokkos::view_alloc(wi,
typename Space::memory_space{}));
1672 template <
class T,
class... P,
class... ViewCtorArgs,
1673 typename Enable = std::enable_if_t<
1674 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1675 inline auto create_mirror(
const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1676 const DynRankView<T, P...>& src) {
1677 return Impl::create_mirror(src, arg_prop);
1685 template <
class T,
class... P,
class... ViewCtorArgs>
1686 inline auto create_mirror_view(
1687 const DynRankView<T, P...>& src,
1688 [[maybe_unused]]
const typename Impl::ViewCtorProp<ViewCtorArgs...>&
1690 if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
1691 if constexpr (std::is_same_v<
typename DynRankView<T, P...>::memory_space,
1692 typename DynRankView<
1693 T, P...>::HostMirror::memory_space> &&
1695 typename DynRankView<T, P...>::data_type,
1696 typename DynRankView<T, P...>::HostMirror::data_type>) {
1697 return typename DynRankView<T, P...>::HostMirror(src);
1699 return Kokkos::Impl::choose_create_mirror(src, arg_prop);
1702 if constexpr (Impl::MirrorDRViewType<
typename Impl::ViewCtorProp<
1703 ViewCtorArgs...>::memory_space,
1704 T, P...>::is_same_memspace) {
1705 return typename Impl::MirrorDRViewType<
1706 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
1707 P...>::view_type(src);
1709 return Kokkos::Impl::choose_create_mirror(src, arg_prop);
1712 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
1713 !defined(KOKKOS_COMPILER_MSVC)
1714 __builtin_unreachable();
1721 template <
class T,
class... P>
1722 inline auto create_mirror_view(
const Kokkos::DynRankView<T, P...>& src) {
1723 return Impl::create_mirror_view(src, Kokkos::view_alloc());
1727 template <
class T,
class... P>
1728 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
1729 const DynRankView<T, P...>& src) {
1730 return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
1734 template <
class Space,
class T,
class... P,
1735 class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
1736 inline auto create_mirror_view(
const Space&,
1737 const Kokkos::DynRankView<T, P...>& src) {
1738 return Impl::create_mirror_view(
1739 src, Kokkos::view_alloc(
typename Space::memory_space()));
1743 template <
class Space,
class T,
class... P,
1744 typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
1745 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
1747 const Kokkos::DynRankView<T, P...>& src) {
1748 return Impl::create_mirror_view(
1749 src, Kokkos::view_alloc(
typename Space::memory_space{}, wi));
1754 template <
class T,
class... P,
class... ViewCtorArgs>
1755 inline auto create_mirror_view(
1756 const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1757 const Kokkos::DynRankView<T, P...>& src) {
1758 return Impl::create_mirror_view(src, arg_prop);
1764 template <
class... ViewCtorArgs,
class T,
class... P,
1765 class Enable = std::enable_if_t<
1766 std::is_void_v<
typename ViewTraits<T, P...>::specialize>>>
1767 auto create_mirror_view_and_copy(
1768 [[maybe_unused]]
const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1769 const Kokkos::DynRankView<T, P...>& src) {
1770 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1772 Impl::check_view_ctor_args_create_mirror_view_and_copy<ViewCtorArgs...>();
1774 if constexpr (Impl::MirrorDRViewType<
1775 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
1776 T, P...>::is_same_memspace) {
1778 if constexpr (!alloc_prop_input::has_execution_space)
1780 "Kokkos::create_mirror_view_and_copy: fence before returning src "
1784 using Space =
typename alloc_prop_input::memory_space;
1785 using Mirror =
typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
1787 auto arg_prop_copy = Impl::with_properties_if_unset(
1788 arg_prop, std::string{}, WithoutInitializing,
1789 typename Space::execution_space{});
1791 std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
1792 if (label.empty()) label = src.label();
1793 auto mirror =
typename Mirror::non_const_type{
1794 arg_prop_copy, Impl::reconstructLayout(src.layout(), src.rank())};
1795 if constexpr (alloc_prop_input::has_execution_space) {
1796 deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
1799 deep_copy(mirror, src);
1802 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
1803 !defined(KOKKOS_COMPILER_MSVC)
1804 __builtin_unreachable();
1808 template <
class Space,
class T,
class... P>
1809 auto create_mirror_view_and_copy(
const Space&,
1810 const Kokkos::DynRankView<T, P...>& src,
1811 std::string
const& name =
"") {
1812 return create_mirror_view_and_copy(
1813 Kokkos::view_alloc(
typename Space::memory_space{}, name), src);
1824 template <
class... ViewCtorArgs,
class T,
class... P>
1825 inline void impl_resize(
const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1826 DynRankView<T, P...>& v,
const size_t n0,
1827 const size_t n1,
const size_t n2,
const size_t n3,
1828 const size_t n4,
const size_t n5,
const size_t n6,
1830 using drview_type = DynRankView<T, P...>;
1831 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1833 static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
1834 "Can only resize managed views");
1835 static_assert(!alloc_prop_input::has_label,
1836 "The view constructor arguments passed to Kokkos::resize "
1837 "must not include a label!");
1838 static_assert(!alloc_prop_input::has_pointer,
1839 "The view constructor arguments passed to Kokkos::resize must "
1840 "not include a pointer!");
1841 static_assert(!alloc_prop_input::has_memory_space,
1842 "The view constructor arguments passed to Kokkos::resize must "
1843 "not include a memory space instance!");
1845 auto prop_copy = Impl::with_properties_if_unset(
1846 arg_prop, v.label(),
typename drview_type::execution_space{});
1848 drview_type v_resized(prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
1850 if constexpr (alloc_prop_input::has_execution_space)
1851 Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(
1852 Impl::get_property<Impl::ExecutionSpaceTag>(prop_copy), v_resized, v);
1855 Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(v_resized, v);
1856 Kokkos::fence(
"Kokkos::resize(DynRankView)");
1861 template <
class T,
class... P>
1862 inline void resize(DynRankView<T, P...>& v,
1863 const size_t n0 = KOKKOS_INVALID_INDEX,
1864 const size_t n1 = KOKKOS_INVALID_INDEX,
1865 const size_t n2 = KOKKOS_INVALID_INDEX,
1866 const size_t n3 = KOKKOS_INVALID_INDEX,
1867 const size_t n4 = KOKKOS_INVALID_INDEX,
1868 const size_t n5 = KOKKOS_INVALID_INDEX,
1869 const size_t n6 = KOKKOS_INVALID_INDEX,
1870 const size_t n7 = KOKKOS_INVALID_INDEX) {
1871 impl_resize(Impl::ViewCtorProp<>{}, v, n0, n1, n2, n3, n4, n5, n6, n7);
1874 template <
class... ViewCtorArgs,
class T,
class... P>
1875 void resize(
const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1876 DynRankView<T, P...>& v,
1877 const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1878 const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1879 const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1880 const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1881 const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1882 const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1883 const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
1884 const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
1885 impl_resize(arg_prop, v, n0, n1, n2, n3, n4, n5, n6, n7);
1888 template <
class I,
class T,
class... P>
1889 inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> resize(
1890 const I& arg_prop, DynRankView<T, P...>& v,
1891 const size_t n0 = KOKKOS_INVALID_INDEX,
1892 const size_t n1 = KOKKOS_INVALID_INDEX,
1893 const size_t n2 = KOKKOS_INVALID_INDEX,
1894 const size_t n3 = KOKKOS_INVALID_INDEX,
1895 const size_t n4 = KOKKOS_INVALID_INDEX,
1896 const size_t n5 = KOKKOS_INVALID_INDEX,
1897 const size_t n6 = KOKKOS_INVALID_INDEX,
1898 const size_t n7 = KOKKOS_INVALID_INDEX) {
1899 impl_resize(Kokkos::view_alloc(arg_prop), v, n0, n1, n2, n3, n4, n5, n6, n7);
1904 template <
class... ViewCtorArgs,
class T,
class... P>
1905 inline void impl_realloc(DynRankView<T, P...>& v,
const size_t n0,
1906 const size_t n1,
const size_t n2,
const size_t n3,
1907 const size_t n4,
const size_t n5,
const size_t n6,
1909 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
1910 using drview_type = DynRankView<T, P...>;
1911 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1913 static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
1914 "Can only realloc managed views");
1915 static_assert(!alloc_prop_input::has_label,
1916 "The view constructor arguments passed to Kokkos::realloc must "
1917 "not include a label!");
1918 static_assert(!alloc_prop_input::has_pointer,
1919 "The view constructor arguments passed to Kokkos::realloc must "
1920 "not include a pointer!");
1921 static_assert(!alloc_prop_input::has_memory_space,
1922 "The view constructor arguments passed to Kokkos::realloc must "
1923 "not include a memory space instance!");
1925 auto arg_prop_copy = Impl::with_properties_if_unset(arg_prop, v.label());
1928 v = drview_type(arg_prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
1931 template <
class T,
class... P,
class... ViewCtorArgs>
1932 inline void realloc(
const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1933 DynRankView<T, P...>& v,
1934 const size_t n0 = KOKKOS_INVALID_INDEX,
1935 const size_t n1 = KOKKOS_INVALID_INDEX,
1936 const size_t n2 = KOKKOS_INVALID_INDEX,
1937 const size_t n3 = KOKKOS_INVALID_INDEX,
1938 const size_t n4 = KOKKOS_INVALID_INDEX,
1939 const size_t n5 = KOKKOS_INVALID_INDEX,
1940 const size_t n6 = KOKKOS_INVALID_INDEX,
1941 const size_t n7 = KOKKOS_INVALID_INDEX) {
1942 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, arg_prop);
1945 template <
class T,
class... P>
1946 inline void realloc(DynRankView<T, P...>& v,
1947 const size_t n0 = KOKKOS_INVALID_INDEX,
1948 const size_t n1 = KOKKOS_INVALID_INDEX,
1949 const size_t n2 = KOKKOS_INVALID_INDEX,
1950 const size_t n3 = KOKKOS_INVALID_INDEX,
1951 const size_t n4 = KOKKOS_INVALID_INDEX,
1952 const size_t n5 = KOKKOS_INVALID_INDEX,
1953 const size_t n6 = KOKKOS_INVALID_INDEX,
1954 const size_t n7 = KOKKOS_INVALID_INDEX) {
1955 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Impl::ViewCtorProp<>{});
1958 template <
class I,
class T,
class... P>
1959 inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> realloc(
1960 const I& arg_prop, DynRankView<T, P...>& v,
1961 const size_t n0 = KOKKOS_INVALID_INDEX,
1962 const size_t n1 = KOKKOS_INVALID_INDEX,
1963 const size_t n2 = KOKKOS_INVALID_INDEX,
1964 const size_t n3 = KOKKOS_INVALID_INDEX,
1965 const size_t n4 = KOKKOS_INVALID_INDEX,
1966 const size_t n5 = KOKKOS_INVALID_INDEX,
1967 const size_t n6 = KOKKOS_INVALID_INDEX,
1968 const size_t n7 = KOKKOS_INVALID_INDEX) {
1969 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Kokkos::view_alloc(arg_prop));
1972 namespace Experimental {
1973 template <
class T,
class... P>
1974 struct python_view_type<DynRankView<T, P...>> {
1975 using type = Kokkos::Impl::python_view_type_impl_t<
1976 typename DynRankView<T, P...>::array_type>;
1982 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
1983 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
1984 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
Memory layout tag indicating left-to-right (Fortran scheme) striding of multi-indices.
KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(const iType0 &, const MapType &)
Debug bounds-checking routines.
Memory layout tag indicated arbitrarily strided multi-index mapping into contiguous memory...
Memory layout tag indicating right-to-left (C or lexigraphical scheme) striding of multi-indices...
Assign compatible default mappings.
Execution policy for work over a range of an integral type.