Kokkos Core Kernels Package Version of the Day
Loading...
Searching...
No Matches
Kokkos_DynRankView.hpp
Go to the documentation of this file.
1//@HEADER
2// ************************************************************************
3//
4// Kokkos v. 4.0
5// Copyright (2022) National Technology & Engineering
6// Solutions of Sandia, LLC (NTESS).
7//
8// Under the terms of Contract DE-NA0003525 with NTESS,
9// the U.S. Government retains certain rights in this software.
10//
11// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
12// See https://kokkos.org/LICENSE for license information.
13// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
14//
15//@HEADER
16
22
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
28#endif
29
30#include <Kokkos_Core.hpp>
31#include <impl/Kokkos_Error.hpp>
32#include <type_traits>
33
34namespace Kokkos {
35
36template <typename DataType, class... Properties>
37class DynRankView; // forward declare
38
39namespace Impl {
40
41template <typename Specialize>
42struct DynRankDimTraits {
43 enum : size_t { unspecified = KOKKOS_INVALID_INDEX };
44
45 // Compute the rank of the view from the nonzero dimension arguments.
46 KOKKOS_INLINE_FUNCTION
47 static size_t computeRank(const size_t N0, const size_t N1, const size_t N2,
48 const size_t N3, const size_t N4, const size_t N5,
49 const size_t N6, const size_t /* N7 */) {
50 return (
51 (N6 == unspecified && N5 == unspecified && N4 == unspecified &&
52 N3 == unspecified && N2 == unspecified && N1 == unspecified &&
53 N0 == unspecified)
54 ? 0
55 : ((N6 == unspecified && N5 == unspecified && N4 == unspecified &&
56 N3 == unspecified && N2 == unspecified && N1 == unspecified)
57 ? 1
58 : ((N6 == unspecified && N5 == unspecified &&
59 N4 == unspecified && N3 == unspecified &&
60 N2 == unspecified)
61 ? 2
62 : ((N6 == unspecified && N5 == unspecified &&
63 N4 == unspecified && N3 == unspecified)
64 ? 3
65 : ((N6 == unspecified && N5 == unspecified &&
66 N4 == unspecified)
67 ? 4
68 : ((N6 == unspecified &&
69 N5 == unspecified)
70 ? 5
71 : ((N6 == unspecified)
72 ? 6
73 : 7)))))));
74 }
75
76 // Compute the rank of the view from the nonzero layout arguments.
77 template <typename Layout>
78 KOKKOS_INLINE_FUNCTION static size_t computeRank(const Layout& layout) {
79 return computeRank(layout.dimension[0], layout.dimension[1],
80 layout.dimension[2], layout.dimension[3],
81 layout.dimension[4], layout.dimension[5],
82 layout.dimension[6], layout.dimension[7]);
83 }
84
85 // Extra overload to match that for specialize types v2
86 template <typename Layout, typename... P>
87 KOKKOS_INLINE_FUNCTION static size_t computeRank(
88 const Kokkos::Impl::ViewCtorProp<P...>& /* prop */,
89 const Layout& layout) {
90 return computeRank(layout);
91 }
92
93 // Create the layout for the rank-7 view.
94 // Non-strided Layout
95 template <typename Layout>
96 KOKKOS_INLINE_FUNCTION static std::enable_if_t<
97 (std::is_same<Layout, Kokkos::LayoutRight>::value ||
98 std::is_same<Layout, Kokkos::LayoutLeft>::value),
99 Layout>
100 createLayout(const Layout& layout) {
101 return Layout(layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
102 layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
103 layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
104 layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
105 layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
106 layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
107 layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
108 layout.dimension[7] != unspecified ? layout.dimension[7] : 1);
109 }
110
111 // LayoutStride
112 template <typename Layout>
113 KOKKOS_INLINE_FUNCTION static std::enable_if_t<
114 (std::is_same<Layout, Kokkos::LayoutStride>::value), Layout>
115 createLayout(const Layout& layout) {
116 return Layout(layout.dimension[0] != unspecified ? layout.dimension[0] : 1,
117 layout.stride[0],
118 layout.dimension[1] != unspecified ? layout.dimension[1] : 1,
119 layout.stride[1],
120 layout.dimension[2] != unspecified ? layout.dimension[2] : 1,
121 layout.stride[2],
122 layout.dimension[3] != unspecified ? layout.dimension[3] : 1,
123 layout.stride[3],
124 layout.dimension[4] != unspecified ? layout.dimension[4] : 1,
125 layout.stride[4],
126 layout.dimension[5] != unspecified ? layout.dimension[5] : 1,
127 layout.stride[5],
128 layout.dimension[6] != unspecified ? layout.dimension[6] : 1,
129 layout.stride[6],
130 layout.dimension[7] != unspecified ? layout.dimension[7] : 1,
131 layout.stride[7]);
132 }
133
134 // Extra overload to match that for specialize types
135 template <typename Traits, typename... P>
136 KOKKOS_INLINE_FUNCTION static std::enable_if_t<
137 (std::is_same<typename Traits::array_layout,
138 Kokkos::LayoutRight>::value ||
139 std::is_same<typename Traits::array_layout, Kokkos::LayoutLeft>::value ||
140 std::is_same<typename Traits::array_layout,
141 Kokkos::LayoutStride>::value),
142 typename Traits::array_layout>
143 createLayout(const Kokkos::Impl::ViewCtorProp<P...>& /* prop */,
144 const typename Traits::array_layout& layout) {
145 return createLayout(layout);
146 }
147
148 // Create a view from the given dimension arguments.
149 // This is only necessary because the shmem constructor doesn't take a layout.
150 // NDE shmem View's are not compatible with the added view_alloc value_type
151 // / fad_dim deduction functionality
152 template <typename ViewType, typename ViewArg>
153 static ViewType createView(const ViewArg& arg, const size_t N0,
154 const size_t N1, const size_t N2, const size_t N3,
155 const size_t N4, const size_t N5, const size_t N6,
156 const size_t N7) {
157 return ViewType(arg, N0 != unspecified ? N0 : 1, N1 != unspecified ? N1 : 1,
158 N2 != unspecified ? N2 : 1, N3 != unspecified ? N3 : 1,
159 N4 != unspecified ? N4 : 1, N5 != unspecified ? N5 : 1,
160 N6 != unspecified ? N6 : 1, N7 != unspecified ? N7 : 1);
161 }
162};
163
164// Non-strided Layout
165template <typename Layout, typename iType>
166KOKKOS_INLINE_FUNCTION static std::enable_if_t<
167 (std::is_same<Layout, Kokkos::LayoutRight>::value ||
168 std::is_same<Layout, Kokkos::LayoutLeft>::value) &&
169 std::is_integral<iType>::value,
170 Layout>
171reconstructLayout(const Layout& layout, iType dynrank) {
172 return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
173 dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
174 dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
175 dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
176 dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
177 dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
178 dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
179 dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX);
180}
181
182// LayoutStride
183template <typename Layout, typename iType>
184KOKKOS_INLINE_FUNCTION static std::enable_if_t<
185 (std::is_same<Layout, Kokkos::LayoutStride>::value) &&
186 std::is_integral<iType>::value,
187 Layout>
188reconstructLayout(const Layout& layout, iType dynrank) {
189 return Layout(dynrank > 0 ? layout.dimension[0] : KOKKOS_INVALID_INDEX,
190 dynrank > 0 ? layout.stride[0] : (0),
191 dynrank > 1 ? layout.dimension[1] : KOKKOS_INVALID_INDEX,
192 dynrank > 1 ? layout.stride[1] : (0),
193 dynrank > 2 ? layout.dimension[2] : KOKKOS_INVALID_INDEX,
194 dynrank > 2 ? layout.stride[2] : (0),
195 dynrank > 3 ? layout.dimension[3] : KOKKOS_INVALID_INDEX,
196 dynrank > 3 ? layout.stride[3] : (0),
197 dynrank > 4 ? layout.dimension[4] : KOKKOS_INVALID_INDEX,
198 dynrank > 4 ? layout.stride[4] : (0),
199 dynrank > 5 ? layout.dimension[5] : KOKKOS_INVALID_INDEX,
200 dynrank > 5 ? layout.stride[5] : (0),
201 dynrank > 6 ? layout.dimension[6] : KOKKOS_INVALID_INDEX,
202 dynrank > 6 ? layout.stride[6] : (0),
203 dynrank > 7 ? layout.dimension[7] : KOKKOS_INVALID_INDEX,
204 dynrank > 7 ? layout.stride[7] : (0));
205}
206
208// Enhanced debug checking - most infrastructure matches that of functions in
209// Kokkos_ViewMapping; additional checks for extra arguments beyond rank are 0
210template <unsigned, typename iType0, class MapType>
211KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
212 const iType0&, const MapType&) {
213 return true;
214}
215
216template <unsigned R, typename iType0, class MapType, typename iType1,
217 class... Args>
218KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
219 const iType0& rank, const MapType& map, const iType1& i, Args... args) {
220 if (static_cast<iType0>(R) < rank) {
221 return (size_t(i) < map.extent(R)) &&
222 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
223 } else if (i != 0) {
224 KOKKOS_IMPL_DO_NOT_USE_PRINTF(
225 "DynRankView Debug Bounds Checking Error: at rank %u\n Extra "
226 "arguments beyond the rank must be zero \n",
227 R);
228 return (false) &&
229 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
230 } else {
231 return (true) &&
232 dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
233 }
234}
235
236template <unsigned, class MapType>
237inline void dyn_rank_view_error_operator_bounds(char*, int, const MapType&) {}
238
239template <unsigned R, class MapType, class iType, class... Args>
240inline void dyn_rank_view_error_operator_bounds(char* buf, int len,
241 const MapType& map,
242 const iType& i, Args... args) {
243 const int n = snprintf(
244 buf, len, " %ld < %ld %c", static_cast<unsigned long>(i),
245 static_cast<unsigned long>(map.extent(R)), (sizeof...(Args) ? ',' : ')'));
246 dyn_rank_view_error_operator_bounds<R + 1>(buf + n, len - n, map, args...);
247}
248
249// op_rank = rank of the operator version that was called
250template <typename MemorySpace, typename iType0, typename iType1, class MapType,
251 class... Args>
252KOKKOS_INLINE_FUNCTION void dyn_rank_view_verify_operator_bounds(
253 const iType0& op_rank, const iType1& rank,
254 const Kokkos::Impl::SharedAllocationTracker& tracker, const MapType& map,
255 Args... args) {
256 if (static_cast<iType0>(rank) > op_rank) {
257 Kokkos::abort(
258 "DynRankView Bounds Checking Error: Need at least rank arguments to "
259 "the operator()");
260 }
261
262 if (!dyn_rank_view_verify_operator_bounds<0>(rank, map, args...)) {
263 KOKKOS_IF_ON_HOST(
264 (enum {LEN = 1024}; char buffer[LEN];
265 const std::string label = tracker.template get_label<MemorySpace>();
266 int n = snprintf(buffer, LEN, "DynRankView bounds error of view %s (",
267 label.c_str());
268 dyn_rank_view_error_operator_bounds<0>(buffer + n, LEN - n, map,
269 args...);
270 Kokkos::Impl::throw_runtime_exception(std::string(buffer));))
271
272 KOKKOS_IF_ON_DEVICE(
273 ((void)tracker; Kokkos::abort("DynRankView bounds error");))
274 }
275}
276
278struct ViewToDynRankViewTag {};
279
280} // namespace Impl
281
282namespace Impl {
283
284template <class DstTraits, class SrcTraits>
285class ViewMapping<
286 DstTraits, SrcTraits,
287 std::enable_if_t<(std::is_same<typename DstTraits::memory_space,
288 typename SrcTraits::memory_space>::value &&
289 std::is_void<typename DstTraits::specialize>::value &&
290 std::is_void<typename SrcTraits::specialize>::value &&
291 (std::is_same<typename DstTraits::array_layout,
292 typename SrcTraits::array_layout>::value ||
293 ((std::is_same<typename DstTraits::array_layout,
294 Kokkos::LayoutLeft>::value ||
295 std::is_same<typename DstTraits::array_layout,
296 Kokkos::LayoutRight>::value ||
297 std::is_same<typename DstTraits::array_layout,
298 Kokkos::LayoutStride>::value) &&
299 (std::is_same<typename SrcTraits::array_layout,
300 Kokkos::LayoutLeft>::value ||
301 std::is_same<typename SrcTraits::array_layout,
302 Kokkos::LayoutRight>::value ||
303 std::is_same<typename SrcTraits::array_layout,
304 Kokkos::LayoutStride>::value)))),
305 Kokkos::Impl::ViewToDynRankViewTag>> {
306 private:
307 enum {
308 is_assignable_value_type =
309 std::is_same<typename DstTraits::value_type,
310 typename SrcTraits::value_type>::value ||
311 std::is_same<typename DstTraits::value_type,
312 typename SrcTraits::const_value_type>::value
313 };
314
315 enum {
316 is_assignable_layout =
317 std::is_same<typename DstTraits::array_layout,
318 typename SrcTraits::array_layout>::value ||
319 std::is_same<typename DstTraits::array_layout,
320 Kokkos::LayoutStride>::value
321 };
322
323 public:
324 enum { is_assignable = is_assignable_value_type && is_assignable_layout };
325
326 using DstType = ViewMapping<DstTraits, typename DstTraits::specialize>;
327 using SrcType = ViewMapping<SrcTraits, typename SrcTraits::specialize>;
328
329 template <typename DT, typename... DP, typename ST, typename... SP>
330 KOKKOS_INLINE_FUNCTION static void assign(
331 Kokkos::DynRankView<DT, DP...>& dst, const Kokkos::View<ST, SP...>& src) {
332 static_assert(
333 is_assignable_value_type,
334 "View assignment must have same value type or const = non-const");
335
336 static_assert(
337 is_assignable_layout,
338 "View assignment must have compatible layout or have rank <= 1");
339
340 // Removed dimension checks...
341
342 using dst_offset_type = typename DstType::offset_type;
343 dst.m_map.m_impl_offset = dst_offset_type(
344 std::integral_constant<unsigned, 0>(),
345 src.layout()); // Check this for integer input1 for padding, etc
346 dst.m_map.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
347 src.m_map.m_impl_handle, src.m_track.m_tracker);
348 dst.m_track.assign(src.m_track.m_tracker, DstTraits::is_managed);
349 dst.m_rank = Kokkos::View<ST, SP...>::rank();
350 }
351};
352
353} // namespace Impl
354
355/* \class DynRankView
356 * \brief Container that creates a Kokkos view with rank determined at runtime.
357 * Essentially this is a rank 7 view
358 *
359 * Changes from View
360 * 1. The rank of the DynRankView is returned by the method rank()
361 * 2. Max rank of a DynRankView is 7
362 * 3. subview called with 'subview(...)' or 'subdynrankview(...)' (backward
363 * compatibility)
364 * 4. Every subview is returned with LayoutStride
365 * 5. Copy and Copy-Assign View to DynRankView
366 * 6. deep_copy between Views and DynRankViews
367 * 7. rank( view ); returns the rank of View or DynRankView
368 *
369 */
370
371template <class>
372struct is_dyn_rank_view : public std::false_type {};
373
374template <class D, class... P>
375struct is_dyn_rank_view<Kokkos::DynRankView<D, P...>> : public std::true_type {
376};
377
378template <class T>
379inline constexpr bool is_dyn_rank_view_v = is_dyn_rank_view<T>::value;
380
381template <typename DataType, class... Properties>
382class DynRankView : public ViewTraits<DataType, Properties...> {
383 static_assert(!std::is_array<DataType>::value &&
384 !std::is_pointer<DataType>::value,
385 "Cannot template DynRankView with array or pointer datatype - "
386 "must be pod");
387
388 private:
389 template <class, class...>
390 friend class DynRankView;
391 template <class, class...>
392 friend class Kokkos::Impl::ViewMapping;
393
394 public:
395 using drvtraits = ViewTraits<DataType, Properties...>;
396
397 using view_type = View<DataType*******, Properties...>;
398
399 using traits = ViewTraits<DataType*******, Properties...>;
400
401 private:
402 using map_type =
403 Kokkos::Impl::ViewMapping<traits, typename traits::specialize>;
404 using track_type = Kokkos::Impl::SharedAllocationTracker;
405
406 track_type m_track;
407 map_type m_map;
408 unsigned m_rank;
409
410 public:
411 KOKKOS_INLINE_FUNCTION
412 view_type& DownCast() const { return (view_type&)(*this); }
413 KOKKOS_INLINE_FUNCTION
414 const view_type& ConstDownCast() const { return (const view_type&)(*this); }
415
416 // Types below - at least the HostMirror requires the value_type, NOT the rank
417 // 7 data_type of the traits
418
420 using array_type = DynRankView<
421 typename drvtraits::scalar_array_type, typename drvtraits::array_layout,
422 typename drvtraits::device_type, typename drvtraits::memory_traits>;
423
425 using const_type = DynRankView<
426 typename drvtraits::const_data_type, typename drvtraits::array_layout,
427 typename drvtraits::device_type, typename drvtraits::memory_traits>;
428
430 using non_const_type = DynRankView<
431 typename drvtraits::non_const_data_type, typename drvtraits::array_layout,
432 typename drvtraits::device_type, typename drvtraits::memory_traits>;
433
435 using HostMirror = DynRankView<typename drvtraits::non_const_data_type,
436 typename drvtraits::array_layout,
437 typename drvtraits::host_mirror_space>;
438
439 //----------------------------------------
440 // Domain rank and extents
441
442 // enum { Rank = map_type::Rank }; //Will be dyn rank of 7 always, keep the
443 // enum?
444
445 template <typename iType>
446 KOKKOS_INLINE_FUNCTION constexpr std::enable_if_t<
447 std::is_integral<iType>::value, size_t>
448 extent(const iType& r) const {
449 return m_map.extent(r);
450 }
451
452 template <typename iType>
453 KOKKOS_INLINE_FUNCTION constexpr std::enable_if_t<
454 std::is_integral<iType>::value, int>
455 extent_int(const iType& r) const {
456 return static_cast<int>(m_map.extent(r));
457 }
458
459 KOKKOS_INLINE_FUNCTION constexpr typename traits::array_layout layout() const;
460
461 //----------------------------------------
462 /* Deprecate all 'dimension' functions in favor of
463 * ISO/C++ vocabulary 'extent'.
464 */
465
466 KOKKOS_INLINE_FUNCTION constexpr size_t size() const {
467 return m_map.extent(0) * m_map.extent(1) * m_map.extent(2) *
468 m_map.extent(3) * m_map.extent(4) * m_map.extent(5) *
469 m_map.extent(6) * m_map.extent(7);
470 }
471
472 KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
473 return m_map.stride_0();
474 }
475 KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
476 return m_map.stride_1();
477 }
478 KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
479 return m_map.stride_2();
480 }
481 KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
482 return m_map.stride_3();
483 }
484 KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
485 return m_map.stride_4();
486 }
487 KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
488 return m_map.stride_5();
489 }
490 KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
491 return m_map.stride_6();
492 }
493 KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
494 return m_map.stride_7();
495 }
496
497 template <typename iType>
498 KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
499 m_map.stride(s);
500 }
501
502 //----------------------------------------
503 // Range span is the span which contains all members.
504
505 using reference_type = typename map_type::reference_type;
506 using pointer_type = typename map_type::pointer_type;
507
508 enum {
509 reference_type_is_lvalue_reference =
510 std::is_lvalue_reference<reference_type>::value
511 };
512
513 KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return m_map.span(); }
514 KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
515 return m_map.span_is_contiguous();
516 }
517 KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
518 return m_map.data();
519 }
520 KOKKOS_INLINE_FUNCTION constexpr bool is_allocated() const {
521 return (m_map.data() != nullptr);
522 }
523
524 //----------------------------------------
525 // Allow specializations to query their specialized map
526 KOKKOS_INLINE_FUNCTION
527 const Kokkos::Impl::ViewMapping<traits, typename traits::specialize>&
528 impl_map() const {
529 return m_map;
530 }
531
532 //----------------------------------------
533
534 private:
535 enum {
536 is_layout_left =
537 std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value,
538
539 is_layout_right =
540 std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value,
541
542 is_layout_stride = std::is_same<typename traits::array_layout,
543 Kokkos::LayoutStride>::value,
544
545 is_default_map = std::is_void<typename traits::specialize>::value &&
546 (is_layout_left || is_layout_right || is_layout_stride)
547 };
548
549// Bounds checking macros
550#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
551
552// rank of the calling operator - included as first argument in ARG
553#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
554 Kokkos::Impl::runtime_check_memory_access_violation< \
555 typename traits::memory_space>( \
556 "Kokkos::DynRankView ERROR: attempt to access inaccessible memory " \
557 "space"); \
558 Kokkos::Impl::dyn_rank_view_verify_operator_bounds< \
559 typename traits::memory_space> \
560 ARG;
561
562#else
563
564#define KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(ARG) \
565 Kokkos::Impl::runtime_check_memory_access_violation< \
566 typename traits::memory_space>( \
567 "Kokkos::DynRankView ERROR: attempt to access inaccessible memory " \
568 "space");
569
570#endif
571
572 public:
573 KOKKOS_INLINE_FUNCTION
574 constexpr unsigned rank() const { return m_rank; }
575
576 // operators ()
577 // Rank 0
578 KOKKOS_INLINE_FUNCTION
579 reference_type operator()() const {
580 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((0, this->rank(), m_track, m_map))
581 return impl_map().reference();
582 // return m_map.reference(0,0,0,0,0,0,0);
583 }
584
585 // Rank 1
586 // This assumes a contiguous underlying memory (i.e. no padding, no
587 // striding...)
588 template <typename iType>
589 KOKKOS_INLINE_FUNCTION std::enable_if_t<
590 std::is_same<typename drvtraits::value_type,
591 typename drvtraits::scalar_array_type>::value &&
592 std::is_integral<iType>::value,
593 reference_type>
594 operator[](const iType& i0) const {
595 // Phalanx is violating this, since they use the operator to access ALL
596 // elements in the allocation KOKKOS_IMPL_VIEW_OPERATOR_VERIFY( (1 ,
597 // this->rank(), m_track, m_map) )
598 return data()[i0];
599 }
600
601 // This assumes a contiguous underlying memory (i.e. no padding, no
602 // striding... AND a Trilinos/Sacado scalar type )
603 template <typename iType>
604 KOKKOS_INLINE_FUNCTION std::enable_if_t<
605 !std::is_same<typename drvtraits::value_type,
606 typename drvtraits::scalar_array_type>::value &&
607 std::is_integral<iType>::value,
608 reference_type>
609 operator[](const iType& i0) const {
610 // auto map = impl_map();
611 const size_t dim_scalar = m_map.dimension_scalar();
612 const size_t bytes = this->span() / dim_scalar;
613
614 using tmp_view_type = Kokkos::View<
615 DataType*, typename traits::array_layout, typename traits::device_type,
616 Kokkos::MemoryTraits<traits::memory_traits::is_unmanaged |
617 traits::memory_traits::is_random_access |
618 traits::memory_traits::is_atomic>>;
619 tmp_view_type rankone_view(this->data(), bytes, dim_scalar);
620 return rankone_view(i0);
621 }
622
623 // Rank 1 parenthesis
624 template <typename iType>
625 KOKKOS_INLINE_FUNCTION
626 std::enable_if_t<(std::is_void<typename traits::specialize>::value &&
627 std::is_integral<iType>::value),
628 reference_type>
629 operator()(const iType& i0) const {
630 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
631 return m_map.reference(i0);
632 }
633
634 template <typename iType>
635 KOKKOS_INLINE_FUNCTION
636 std::enable_if_t<!(std::is_void<typename traits::specialize>::value &&
637 std::is_integral<iType>::value),
638 reference_type>
639 operator()(const iType& i0) const {
640 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
641 return m_map.reference(i0, 0, 0, 0, 0, 0, 0);
642 }
643
644 // Rank 2
645 template <typename iType0, typename iType1>
646 KOKKOS_INLINE_FUNCTION std::enable_if_t<
647 (std::is_void<typename traits::specialize>::value &&
648 std::is_integral<iType0>::value && std::is_integral<iType1>::value),
649 reference_type>
650 operator()(const iType0& i0, const iType1& i1) const {
651 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
652 return m_map.reference(i0, i1);
653 }
654
655 template <typename iType0, typename iType1>
656 KOKKOS_INLINE_FUNCTION
657 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
658 std::is_integral<iType0>::value),
659 reference_type>
660 operator()(const iType0& i0, const iType1& i1) const {
661 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
662 return m_map.reference(i0, i1, 0, 0, 0, 0, 0);
663 }
664
665 // Rank 3
666 template <typename iType0, typename iType1, typename iType2>
667 KOKKOS_INLINE_FUNCTION std::enable_if_t<
668 (std::is_void<typename traits::specialize>::value &&
669 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
670 std::is_integral<iType2>::value),
671 reference_type>
672 operator()(const iType0& i0, const iType1& i1, const iType2& i2) const {
673 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
674 (3, this->rank(), m_track, m_map, i0, i1, i2))
675 return m_map.reference(i0, i1, i2);
676 }
677
678 template <typename iType0, typename iType1, typename iType2>
679 KOKKOS_INLINE_FUNCTION
680 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
681 std::is_integral<iType0>::value),
682 reference_type>
683 operator()(const iType0& i0, const iType1& i1, const iType2& i2) const {
684 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
685 (3, this->rank(), m_track, m_map, i0, i1, i2))
686 return m_map.reference(i0, i1, i2, 0, 0, 0, 0);
687 }
688
689 // Rank 4
690 template <typename iType0, typename iType1, typename iType2, typename iType3>
691 KOKKOS_INLINE_FUNCTION std::enable_if_t<
692 (std::is_void<typename traits::specialize>::value &&
693 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
694 std::is_integral<iType2>::value && std::is_integral<iType3>::value),
695 reference_type>
696 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
697 const iType3& i3) const {
698 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
699 (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
700 return m_map.reference(i0, i1, i2, i3);
701 }
702
703 template <typename iType0, typename iType1, typename iType2, typename iType3>
704 KOKKOS_INLINE_FUNCTION
705 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
706 std::is_integral<iType0>::value),
707 reference_type>
708 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
709 const iType3& i3) const {
710 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
711 (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
712 return m_map.reference(i0, i1, i2, i3, 0, 0, 0);
713 }
714
715 // Rank 5
716 template <typename iType0, typename iType1, typename iType2, typename iType3,
717 typename iType4>
718 KOKKOS_INLINE_FUNCTION std::enable_if_t<
719 (std::is_void<typename traits::specialize>::value &&
720 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
721 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
722 std::is_integral<iType4>::value),
723 reference_type>
724 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
725 const iType3& i3, const iType4& i4) const {
726 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
727 (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
728 return m_map.reference(i0, i1, i2, i3, i4);
729 }
730
731 template <typename iType0, typename iType1, typename iType2, typename iType3,
732 typename iType4>
733 KOKKOS_INLINE_FUNCTION
734 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
735 std::is_integral<iType0>::value),
736 reference_type>
737 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
738 const iType3& i3, const iType4& i4) const {
739 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
740 (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
741 return m_map.reference(i0, i1, i2, i3, i4, 0, 0);
742 }
743
744 // Rank 6
745 template <typename iType0, typename iType1, typename iType2, typename iType3,
746 typename iType4, typename iType5>
747 KOKKOS_INLINE_FUNCTION std::enable_if_t<
748 (std::is_void<typename traits::specialize>::value &&
749 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
750 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
751 std::is_integral<iType4>::value && std::is_integral<iType5>::value),
752 reference_type>
753 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
754 const iType3& i3, const iType4& i4, const iType5& i5) const {
755 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
756 (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
757 return m_map.reference(i0, i1, i2, i3, i4, i5);
758 }
759
760 template <typename iType0, typename iType1, typename iType2, typename iType3,
761 typename iType4, typename iType5>
762 KOKKOS_INLINE_FUNCTION
763 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
764 std::is_integral<iType0>::value),
765 reference_type>
766 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
767 const iType3& i3, const iType4& i4, const iType5& i5) const {
768 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
769 (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
770 return m_map.reference(i0, i1, i2, i3, i4, i5, 0);
771 }
772
773 // Rank 7
774 template <typename iType0, typename iType1, typename iType2, typename iType3,
775 typename iType4, typename iType5, typename iType6>
776 KOKKOS_INLINE_FUNCTION std::enable_if_t<
777 (std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
778 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
779 std::is_integral<iType4>::value && std::is_integral<iType5>::value &&
780 std::is_integral<iType6>::value),
781 reference_type>
782 operator()(const iType0& i0, const iType1& i1, const iType2& i2,
783 const iType3& i3, const iType4& i4, const iType5& i5,
784 const iType6& i6) const {
785 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
786 (7, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
787 return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
788 }
789
790 // Rank 0
791 KOKKOS_INLINE_FUNCTION
792 reference_type access() const {
793 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((0, this->rank(), m_track, m_map))
794 return impl_map().reference();
795 // return m_map.reference(0,0,0,0,0,0,0);
796 }
797
798 // Rank 1
799 // Rank 1 parenthesis
800 template <typename iType>
801 KOKKOS_INLINE_FUNCTION
802 std::enable_if_t<(std::is_void<typename traits::specialize>::value &&
803 std::is_integral<iType>::value),
804 reference_type>
805 access(const iType& i0) const {
806 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
807 return m_map.reference(i0);
808 }
809
810 template <typename iType>
811 KOKKOS_INLINE_FUNCTION
812 std::enable_if_t<!(std::is_void<typename traits::specialize>::value &&
813 std::is_integral<iType>::value),
814 reference_type>
815 access(const iType& i0) const {
816 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((1, this->rank(), m_track, m_map, i0))
817 return m_map.reference(i0, 0, 0, 0, 0, 0, 0);
818 }
819
820 // Rank 2
821 template <typename iType0, typename iType1>
822 KOKKOS_INLINE_FUNCTION std::enable_if_t<
823 (std::is_void<typename traits::specialize>::value &&
824 std::is_integral<iType0>::value && std::is_integral<iType1>::value),
825 reference_type>
826 access(const iType0& i0, const iType1& i1) const {
827 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
828 return m_map.reference(i0, i1);
829 }
830
831 template <typename iType0, typename iType1>
832 KOKKOS_INLINE_FUNCTION
833 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
834 std::is_integral<iType0>::value),
835 reference_type>
836 access(const iType0& i0, const iType1& i1) const {
837 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY((2, this->rank(), m_track, m_map, i0, i1))
838 return m_map.reference(i0, i1, 0, 0, 0, 0, 0);
839 }
840
841 // Rank 3
842 template <typename iType0, typename iType1, typename iType2>
843 KOKKOS_INLINE_FUNCTION std::enable_if_t<
844 (std::is_void<typename traits::specialize>::value &&
845 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
846 std::is_integral<iType2>::value),
847 reference_type>
848 access(const iType0& i0, const iType1& i1, const iType2& i2) const {
849 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
850 (3, this->rank(), m_track, m_map, i0, i1, i2))
851 return m_map.reference(i0, i1, i2);
852 }
853
854 template <typename iType0, typename iType1, typename iType2>
855 KOKKOS_INLINE_FUNCTION
856 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
857 std::is_integral<iType0>::value),
858 reference_type>
859 access(const iType0& i0, const iType1& i1, const iType2& i2) const {
860 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
861 (3, this->rank(), m_track, m_map, i0, i1, i2))
862 return m_map.reference(i0, i1, i2, 0, 0, 0, 0);
863 }
864
865 // Rank 4
866 template <typename iType0, typename iType1, typename iType2, typename iType3>
867 KOKKOS_INLINE_FUNCTION std::enable_if_t<
868 (std::is_void<typename traits::specialize>::value &&
869 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
870 std::is_integral<iType2>::value && std::is_integral<iType3>::value),
871 reference_type>
872 access(const iType0& i0, const iType1& i1, const iType2& i2,
873 const iType3& i3) const {
874 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
875 (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
876 return m_map.reference(i0, i1, i2, i3);
877 }
878
879 template <typename iType0, typename iType1, typename iType2, typename iType3>
880 KOKKOS_INLINE_FUNCTION
881 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
882 std::is_integral<iType0>::value),
883 reference_type>
884 access(const iType0& i0, const iType1& i1, const iType2& i2,
885 const iType3& i3) const {
886 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
887 (4, this->rank(), m_track, m_map, i0, i1, i2, i3))
888 return m_map.reference(i0, i1, i2, i3, 0, 0, 0);
889 }
890
891 // Rank 5
892 template <typename iType0, typename iType1, typename iType2, typename iType3,
893 typename iType4>
894 KOKKOS_INLINE_FUNCTION std::enable_if_t<
895 (std::is_void<typename traits::specialize>::value &&
896 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
897 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
898 std::is_integral<iType4>::value),
899 reference_type>
900 access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
901 const iType4& i4) const {
902 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
903 (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
904 return m_map.reference(i0, i1, i2, i3, i4);
905 }
906
907 template <typename iType0, typename iType1, typename iType2, typename iType3,
908 typename iType4>
909 KOKKOS_INLINE_FUNCTION
910 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
911 std::is_integral<iType0>::value),
912 reference_type>
913 access(const iType0& i0, const iType1& i1, const iType2& i2,
914 const iType3& i3, const iType4& i4) const {
915 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
916 (5, this->rank(), m_track, m_map, i0, i1, i2, i3, i4))
917 return m_map.reference(i0, i1, i2, i3, i4, 0, 0);
918 }
919
920 // Rank 6
921 template <typename iType0, typename iType1, typename iType2, typename iType3,
922 typename iType4, typename iType5>
923 KOKKOS_INLINE_FUNCTION std::enable_if_t<
924 (std::is_void<typename traits::specialize>::value &&
925 std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
926 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
927 std::is_integral<iType4>::value && std::is_integral<iType5>::value),
928 reference_type>
929 access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
930 const iType4& i4, const iType5& i5) const {
931 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
932 (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
933 return m_map.reference(i0, i1, i2, i3, i4, i5);
934 }
935
936 template <typename iType0, typename iType1, typename iType2, typename iType3,
937 typename iType4, typename iType5>
938 KOKKOS_INLINE_FUNCTION
939 std::enable_if_t<!(std::is_void<typename drvtraits::specialize>::value &&
940 std::is_integral<iType0>::value),
941 reference_type>
942 access(const iType0& i0, const iType1& i1, const iType2& i2,
943 const iType3& i3, const iType4& i4, const iType5& i5) const {
944 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
945 (6, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5))
946 return m_map.reference(i0, i1, i2, i3, i4, i5, 0);
947 }
948
949 // Rank 7
950 template <typename iType0, typename iType1, typename iType2, typename iType3,
951 typename iType4, typename iType5, typename iType6>
952 KOKKOS_INLINE_FUNCTION std::enable_if_t<
953 (std::is_integral<iType0>::value && std::is_integral<iType1>::value &&
954 std::is_integral<iType2>::value && std::is_integral<iType3>::value &&
955 std::is_integral<iType4>::value && std::is_integral<iType5>::value &&
956 std::is_integral<iType6>::value),
957 reference_type>
958 access(const iType0& i0, const iType1& i1, const iType2& i2, const iType3& i3,
959 const iType4& i4, const iType5& i5, const iType6& i6) const {
960 KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(
961 (7, this->rank(), m_track, m_map, i0, i1, i2, i3, i4, i5, i6))
962 return m_map.reference(i0, i1, i2, i3, i4, i5, i6);
963 }
964
965#undef KOKKOS_IMPL_VIEW_OPERATOR_VERIFY
966
967 //----------------------------------------
968 // Standard constructor, destructor, and assignment operators...
969
970 KOKKOS_DEFAULTED_FUNCTION
971 ~DynRankView() = default;
972
973 KOKKOS_INLINE_FUNCTION
974 DynRankView() : m_track(), m_map(), m_rank() {} // Default ctor
975
976 KOKKOS_INLINE_FUNCTION
977 DynRankView(const DynRankView& rhs)
978 : m_track(rhs.m_track), m_map(rhs.m_map), m_rank(rhs.m_rank) {}
979
980 KOKKOS_INLINE_FUNCTION
981 DynRankView(DynRankView&& rhs)
982 : m_track(rhs.m_track), m_map(rhs.m_map), m_rank(rhs.m_rank) {}
983
984 KOKKOS_INLINE_FUNCTION
985 DynRankView& operator=(const DynRankView& rhs) {
986 m_track = rhs.m_track;
987 m_map = rhs.m_map;
988 m_rank = rhs.m_rank;
989 return *this;
990 }
991
992 KOKKOS_INLINE_FUNCTION
993 DynRankView& operator=(DynRankView&& rhs) {
994 m_track = rhs.m_track;
995 m_map = rhs.m_map;
996 m_rank = rhs.m_rank;
997 return *this;
998 }
999
1000 //----------------------------------------
1001 // Compatible view copy constructor and assignment
1002 // may assign unmanaged from managed.
1003 template <class RT, class... RP>
1004 KOKKOS_INLINE_FUNCTION DynRankView(const DynRankView<RT, RP...>& rhs)
1005 : m_track(rhs.m_track, traits::is_managed), m_map(), m_rank(rhs.m_rank) {
1006 using SrcTraits = typename DynRankView<RT, RP...>::traits;
1007 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits,
1008 typename traits::specialize>;
1009 static_assert(Mapping::is_assignable,
1010 "Incompatible DynRankView copy construction");
1011 Mapping::assign(m_map, rhs.m_map, rhs.m_track);
1012 }
1013
1014 template <class RT, class... RP>
1015 KOKKOS_INLINE_FUNCTION DynRankView& operator=(
1016 const DynRankView<RT, RP...>& rhs) {
1017 using SrcTraits = typename DynRankView<RT, RP...>::traits;
1018 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits,
1019 typename traits::specialize>;
1020 static_assert(Mapping::is_assignable,
1021 "Incompatible DynRankView copy construction");
1022 Mapping::assign(m_map, rhs.m_map, rhs.m_track);
1023 m_track.assign(rhs.m_track, traits::is_managed);
1024 m_rank = rhs.rank();
1025 return *this;
1026 }
1027
1028 // Copy/Assign View to DynRankView
1029 template <class RT, class... RP>
1030 KOKKOS_INLINE_FUNCTION DynRankView(const View<RT, RP...>& rhs)
1031 : m_track(), m_map(), m_rank(View<RT, RP...>::rank()) {
1032 using SrcTraits = typename View<RT, RP...>::traits;
1033 using Mapping =
1034 Kokkos::Impl::ViewMapping<traits, SrcTraits,
1035 Kokkos::Impl::ViewToDynRankViewTag>;
1036 static_assert(Mapping::is_assignable,
1037 "Incompatible View to DynRankView copy construction");
1038 Mapping::assign(*this, rhs);
1039 }
1040
1041 template <class RT, class... RP>
1042 KOKKOS_INLINE_FUNCTION DynRankView& operator=(const View<RT, RP...>& rhs) {
1043 using SrcTraits = typename View<RT, RP...>::traits;
1044 using Mapping =
1045 Kokkos::Impl::ViewMapping<traits, SrcTraits,
1046 Kokkos::Impl::ViewToDynRankViewTag>;
1047 static_assert(Mapping::is_assignable,
1048 "Incompatible View to DynRankView copy assignment");
1049 Mapping::assign(*this, rhs);
1050 return *this;
1051 }
1052
1053 //----------------------------------------
1054 // Allocation tracking properties
1055
1056 KOKKOS_INLINE_FUNCTION
1057 int use_count() const { return m_track.use_count(); }
1058
1059 inline const std::string label() const {
1060 return m_track.template get_label<typename traits::memory_space>();
1061 }
1062
1063 //----------------------------------------
1064 // Allocation according to allocation properties and array layout
1065 // unused arg_layout dimensions must be set to KOKKOS_INVALID_INDEX so that
1066 // rank deduction can properly take place
1067 template <class... P>
1068 explicit inline DynRankView(
1069 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1070 std::enable_if_t<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1071 typename traits::array_layout> const& arg_layout)
1072 : m_track(),
1073 m_map(),
1074 m_rank(Impl::DynRankDimTraits<typename traits::specialize>::
1075 template computeRank<typename traits::array_layout, P...>(
1076 arg_prop, arg_layout)) {
1077 // Copy the input allocation properties with possibly defaulted properties
1078 auto prop_copy = Impl::with_properties_if_unset(
1079 arg_prop, std::string{}, typename traits::device_type::memory_space{},
1080 typename traits::device_type::execution_space{});
1081 using alloc_prop = decltype(prop_copy);
1082
1083 static_assert(traits::is_managed,
1084 "View allocation constructor requires managed memory");
1085
1086 if (alloc_prop::initialize &&
1087 !alloc_prop::execution_space::impl_is_initialized()) {
1088 // If initializing view data then
1089 // the execution space must be initialized.
1090 Kokkos::Impl::throw_runtime_exception(
1091 "Constructing DynRankView and initializing data with uninitialized "
1092 "execution space");
1093 }
1094
1095 Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
1096 prop_copy,
1097 Impl::DynRankDimTraits<typename traits::specialize>::
1098 template createLayout<traits, P...>(arg_prop, arg_layout),
1099 Impl::ViewCtorProp<P...>::has_execution_space);
1100
1101 // Setup and initialization complete, start tracking
1102 m_track.assign_allocated_record_to_uninitialized(record);
1103 }
1104
1105 // Wrappers
1106 template <class... P>
1107 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1108 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1109 std::enable_if_t<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1110 typename traits::array_layout> const& arg_layout)
1111 : m_track() // No memory tracking
1112 ,
1113 m_map(arg_prop,
1114 Impl::DynRankDimTraits<typename traits::specialize>::
1115 template createLayout<traits, P...>(arg_prop, arg_layout)),
1116 m_rank(Impl::DynRankDimTraits<typename traits::specialize>::
1117 template computeRank<typename traits::array_layout, P...>(
1118 arg_prop, arg_layout)) {
1119 static_assert(
1120 std::is_same<pointer_type,
1121 typename Impl::ViewCtorProp<P...>::pointer_type>::value,
1122 "Constructing DynRankView to wrap user memory must supply matching "
1123 "pointer type");
1124 }
1125
1126 //----------------------------------------
1127 // Constructor(s)
1128
1129 // Simple dimension-only layout
1130 template <class... P>
1131 explicit inline DynRankView(
1132 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1133 std::enable_if_t<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1134 size_t> const arg_N0 = KOKKOS_INVALID_INDEX,
1135 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1136 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1137 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1138 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1139 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1140 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1141 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1142 : DynRankView(arg_prop, typename traits::array_layout(
1143 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
1144 arg_N5, arg_N6, arg_N7)) {}
1145
1146 template <class... P>
1147 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1148 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1149 std::enable_if_t<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1150 size_t> const arg_N0 = KOKKOS_INVALID_INDEX,
1151 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1152 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1153 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1154 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1155 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1156 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1157 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1158 : DynRankView(arg_prop, typename traits::array_layout(
1159 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4,
1160 arg_N5, arg_N6, arg_N7)) {}
1161
1162 // Allocate with label and layout
1163 template <typename Label>
1164 explicit inline DynRankView(
1165 const Label& arg_label,
1166 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value,
1167 typename traits::array_layout> const& arg_layout)
1168 : DynRankView(Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
1169 arg_layout) {}
1170
1171 // Allocate label and layout, must disambiguate from subview constructor
1172 template <typename Label>
1173 explicit inline DynRankView(
1174 const Label& arg_label,
1175 std::enable_if_t<Kokkos::Impl::is_view_label<Label>::value, const size_t>
1176 arg_N0 = KOKKOS_INVALID_INDEX,
1177 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1178 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1179 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1180 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1181 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1182 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1183 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1184 : DynRankView(
1185 Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
1186 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1187 arg_N4, arg_N5, arg_N6, arg_N7)) {}
1188
1189 //----------------------------------------
1190 // Memory span required to wrap these dimensions.
1191 static constexpr size_t required_allocation_size(
1192 const size_t arg_N0 = 0, const size_t arg_N1 = 0, const size_t arg_N2 = 0,
1193 const size_t arg_N3 = 0, const size_t arg_N4 = 0, const size_t arg_N5 = 0,
1194 const size_t arg_N6 = 0, const size_t arg_N7 = 0) {
1195 return map_type::memory_span(typename traits::array_layout(
1196 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
1197 }
1198
1199 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1200 pointer_type arg_ptr, const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1201 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1202 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1203 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1204 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1205 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1206 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1207 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1208 : DynRankView(Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr), arg_N0,
1209 arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7) {}
1210
1211 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1212 pointer_type arg_ptr, typename traits::array_layout& arg_layout)
1213 : DynRankView(Kokkos::Impl::ViewCtorProp<pointer_type>(arg_ptr),
1214 arg_layout) {}
1215
1216 //----------------------------------------
1217 // Shared scratch memory constructor
1218
1219 static inline size_t shmem_size(const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1220 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1221 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1222 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1223 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1224 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1225 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1226 const size_t arg_N7 = KOKKOS_INVALID_INDEX) {
1227 const size_t num_passed_args =
1228 (arg_N0 != KOKKOS_INVALID_INDEX) + (arg_N1 != KOKKOS_INVALID_INDEX) +
1229 (arg_N2 != KOKKOS_INVALID_INDEX) + (arg_N3 != KOKKOS_INVALID_INDEX) +
1230 (arg_N4 != KOKKOS_INVALID_INDEX) + (arg_N5 != KOKKOS_INVALID_INDEX) +
1231 (arg_N6 != KOKKOS_INVALID_INDEX) + (arg_N7 != KOKKOS_INVALID_INDEX);
1232
1233 if (std::is_void<typename traits::specialize>::value &&
1234 num_passed_args != traits::rank_dynamic) {
1235 Kokkos::abort(
1236 "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n");
1237 }
1238 {}
1239
1240 return map_type::memory_span(typename traits::array_layout(
1241 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7));
1242 }
1243
1244 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1245 const typename traits::execution_space::scratch_memory_space& arg_space,
1246 const typename traits::array_layout& arg_layout)
1247 : DynRankView(
1248 Kokkos::Impl::ViewCtorProp<pointer_type>(
1249 reinterpret_cast<pointer_type>(
1250 arg_space.get_shmem(map_type::memory_span(
1251 Impl::DynRankDimTraits<typename traits::specialize>::
1252 createLayout(arg_layout) // is this correct?
1253 )))),
1254 arg_layout) {}
1255
1256 explicit KOKKOS_INLINE_FUNCTION DynRankView(
1257 const typename traits::execution_space::scratch_memory_space& arg_space,
1258 const size_t arg_N0 = KOKKOS_INVALID_INDEX,
1259 const size_t arg_N1 = KOKKOS_INVALID_INDEX,
1260 const size_t arg_N2 = KOKKOS_INVALID_INDEX,
1261 const size_t arg_N3 = KOKKOS_INVALID_INDEX,
1262 const size_t arg_N4 = KOKKOS_INVALID_INDEX,
1263 const size_t arg_N5 = KOKKOS_INVALID_INDEX,
1264 const size_t arg_N6 = KOKKOS_INVALID_INDEX,
1265 const size_t arg_N7 = KOKKOS_INVALID_INDEX)
1266
1267 : DynRankView(
1268 Kokkos::Impl::ViewCtorProp<pointer_type>(
1269 reinterpret_cast<pointer_type>(
1270 arg_space.get_shmem(map_type::memory_span(
1271 Impl::DynRankDimTraits<typename traits::specialize>::
1272 createLayout(typename traits::array_layout(
1273 arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5,
1274 arg_N6, arg_N7)))))),
1275 typename traits::array_layout(arg_N0, arg_N1, arg_N2, arg_N3,
1276 arg_N4, arg_N5, arg_N6, arg_N7)) {}
1277};
1278
1279template <typename D, class... P>
1280KOKKOS_INLINE_FUNCTION constexpr unsigned rank(
1281 const DynRankView<D, P...>& DRV) {
1282 return DRV.rank();
1283} // needed for transition to common constexpr method in view and dynrankview
1284 // to return rank
1285
1286//----------------------------------------------------------------------------
1287// Subview mapping.
1288// Deduce destination view type from source view traits and subview arguments
1289
1290namespace Impl {
1291
1292struct DynRankSubviewTag {};
1293
1294} // namespace Impl
1295
1296namespace Impl {
1297
1298template <class SrcTraits, class... Args>
1299class ViewMapping<
1300 std::enable_if_t<(std::is_void<typename SrcTraits::specialize>::value &&
1301 (std::is_same<typename SrcTraits::array_layout,
1302 Kokkos::LayoutLeft>::value ||
1303 std::is_same<typename SrcTraits::array_layout,
1304 Kokkos::LayoutRight>::value ||
1305 std::is_same<typename SrcTraits::array_layout,
1306 Kokkos::LayoutStride>::value)),
1307 Kokkos::Impl::DynRankSubviewTag>,
1308 SrcTraits, Args...> {
1309 private:
1310 enum {
1311 RZ = false,
1312 R0 = bool(is_integral_extent<0, Args...>::value),
1313 R1 = bool(is_integral_extent<1, Args...>::value),
1314 R2 = bool(is_integral_extent<2, Args...>::value),
1315 R3 = bool(is_integral_extent<3, Args...>::value),
1316 R4 = bool(is_integral_extent<4, Args...>::value),
1317 R5 = bool(is_integral_extent<5, Args...>::value),
1318 R6 = bool(is_integral_extent<6, Args...>::value)
1319 };
1320
1321 enum {
1322 rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3) +
1323 unsigned(R4) + unsigned(R5) + unsigned(R6)
1324 };
1325
1326 using array_layout = Kokkos::LayoutStride;
1327
1328 using value_type = typename SrcTraits::value_type;
1329
1330 using data_type = value_type*******;
1331
1332 public:
1333 using traits_type = Kokkos::ViewTraits<data_type, array_layout,
1334 typename SrcTraits::device_type,
1335 typename SrcTraits::memory_traits>;
1336
1337 using type =
1338 Kokkos::View<data_type, array_layout, typename SrcTraits::device_type,
1339 typename SrcTraits::memory_traits>;
1340
1341 template <class MemoryTraits>
1342 struct apply {
1343 static_assert(Kokkos::is_memory_traits<MemoryTraits>::value, "");
1344
1345 using traits_type =
1346 Kokkos::ViewTraits<data_type, array_layout,
1347 typename SrcTraits::device_type, MemoryTraits>;
1348
1349 using type = Kokkos::View<data_type, array_layout,
1350 typename SrcTraits::device_type, MemoryTraits>;
1351 };
1352
1353 using dimension = typename SrcTraits::dimension;
1354
1355 template <class Arg0 = int, class Arg1 = int, class Arg2 = int,
1356 class Arg3 = int, class Arg4 = int, class Arg5 = int,
1357 class Arg6 = int>
1358 struct ExtentGenerator {
1359 KOKKOS_INLINE_FUNCTION
1360 static SubviewExtents<7, rank> generator(
1361 const dimension& dim, Arg0 arg0 = Arg0(), Arg1 arg1 = Arg1(),
1362 Arg2 arg2 = Arg2(), Arg3 arg3 = Arg3(), Arg4 arg4 = Arg4(),
1363 Arg5 arg5 = Arg5(), Arg6 arg6 = Arg6()) {
1364 return SubviewExtents<7, rank>(dim, arg0, arg1, arg2, arg3, arg4, arg5,
1365 arg6);
1366 }
1367 };
1368
1369 using ret_type = Kokkos::DynRankView<value_type, array_layout,
1370 typename SrcTraits::device_type,
1371 typename SrcTraits::memory_traits>;
1372
1373 template <typename T, class... P>
1374 KOKKOS_INLINE_FUNCTION static ret_type subview(
1375 const unsigned src_rank, Kokkos::DynRankView<T, P...> const& src,
1376 Args... args) {
1377 using DstType = ViewMapping<traits_type, typename traits_type::specialize>;
1378
1379 using DstDimType = std::conditional_t<
1380 (rank == 0), ViewDimension<>,
1381 std::conditional_t<
1382 (rank == 1), ViewDimension<0>,
1383 std::conditional_t<
1384 (rank == 2), ViewDimension<0, 0>,
1385 std::conditional_t<
1386 (rank == 3), ViewDimension<0, 0, 0>,
1387 std::conditional_t<
1388 (rank == 4), ViewDimension<0, 0, 0, 0>,
1389 std::conditional_t<
1390 (rank == 5), ViewDimension<0, 0, 0, 0, 0>,
1391 std::conditional_t<
1392 (rank == 6), ViewDimension<0, 0, 0, 0, 0, 0>,
1393 ViewDimension<0, 0, 0, 0, 0, 0, 0>>>>>>>>;
1394
1395 using dst_offset_type = ViewOffset<DstDimType, Kokkos::LayoutStride>;
1396 using dst_handle_type = typename DstType::handle_type;
1397
1398 ret_type dst;
1399
1400 const SubviewExtents<7, rank> extents = ExtentGenerator<Args...>::generator(
1401 src.m_map.m_impl_offset.m_dim, args...);
1402
1403 dst_offset_type tempdst(src.m_map.m_impl_offset, extents);
1404
1405 dst.m_track = src.m_track;
1406
1407 dst.m_map.m_impl_offset.m_dim.N0 = tempdst.m_dim.N0;
1408 dst.m_map.m_impl_offset.m_dim.N1 = tempdst.m_dim.N1;
1409 dst.m_map.m_impl_offset.m_dim.N2 = tempdst.m_dim.N2;
1410 dst.m_map.m_impl_offset.m_dim.N3 = tempdst.m_dim.N3;
1411 dst.m_map.m_impl_offset.m_dim.N4 = tempdst.m_dim.N4;
1412 dst.m_map.m_impl_offset.m_dim.N5 = tempdst.m_dim.N5;
1413 dst.m_map.m_impl_offset.m_dim.N6 = tempdst.m_dim.N6;
1414
1415 dst.m_map.m_impl_offset.m_stride.S0 = tempdst.m_stride.S0;
1416 dst.m_map.m_impl_offset.m_stride.S1 = tempdst.m_stride.S1;
1417 dst.m_map.m_impl_offset.m_stride.S2 = tempdst.m_stride.S2;
1418 dst.m_map.m_impl_offset.m_stride.S3 = tempdst.m_stride.S3;
1419 dst.m_map.m_impl_offset.m_stride.S4 = tempdst.m_stride.S4;
1420 dst.m_map.m_impl_offset.m_stride.S5 = tempdst.m_stride.S5;
1421 dst.m_map.m_impl_offset.m_stride.S6 = tempdst.m_stride.S6;
1422
1423 dst.m_map.m_impl_handle =
1424 dst_handle_type(src.m_map.m_impl_handle +
1425 src.m_map.m_impl_offset(
1426 extents.domain_offset(0), extents.domain_offset(1),
1427 extents.domain_offset(2), extents.domain_offset(3),
1428 extents.domain_offset(4), extents.domain_offset(5),
1429 extents.domain_offset(6)));
1430
1431 dst.m_rank =
1432 (src_rank > 0 ? unsigned(R0) : 0) + (src_rank > 1 ? unsigned(R1) : 0) +
1433 (src_rank > 2 ? unsigned(R2) : 0) + (src_rank > 3 ? unsigned(R3) : 0) +
1434 (src_rank > 4 ? unsigned(R4) : 0) + (src_rank > 5 ? unsigned(R5) : 0) +
1435 (src_rank > 6 ? unsigned(R6) : 0);
1436
1437 return dst;
1438 }
1439};
1440
1441} // namespace Impl
1442
1443template <class V, class... Args>
1444using Subdynrankview =
1445 typename Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag, V,
1446 Args...>::ret_type;
1447
1448template <class D, class... P, class... Args>
1449KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
1450subdynrankview(const Kokkos::DynRankView<D, P...>& src, Args... args) {
1451 if (src.rank() > sizeof...(Args)) // allow sizeof...(Args) >= src.rank(),
1452 // ignore the remaining args
1453 {
1454 Kokkos::abort(
1455 "subdynrankview: num of args must be >= rank of the source "
1456 "DynRankView");
1457 }
1458
1459 using metafcn =
1460 Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag,
1461 Kokkos::ViewTraits<D*******, P...>, Args...>;
1462
1463 return metafcn::subview(src.rank(), src, args...);
1464}
1465
1466// Wrapper to allow subview function name
1467template <class D, class... P, class... Args>
1468KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
1469subview(const Kokkos::DynRankView<D, P...>& src, Args... args) {
1470 return subdynrankview(src, args...);
1471}
1472
1473} // namespace Kokkos
1474
1475namespace Kokkos {
1476
1477// overload == and !=
1478template <class LT, class... LP, class RT, class... RP>
1479KOKKOS_INLINE_FUNCTION bool operator==(const DynRankView<LT, LP...>& lhs,
1480 const DynRankView<RT, RP...>& rhs) {
1481 // Same data, layout, dimensions
1482 using lhs_traits = ViewTraits<LT, LP...>;
1483 using rhs_traits = ViewTraits<RT, RP...>;
1484
1485 return std::is_same<typename lhs_traits::const_value_type,
1486 typename rhs_traits::const_value_type>::value &&
1487 std::is_same<typename lhs_traits::array_layout,
1488 typename rhs_traits::array_layout>::value &&
1489 std::is_same<typename lhs_traits::memory_space,
1490 typename rhs_traits::memory_space>::value &&
1491 lhs.rank() == rhs.rank() && lhs.data() == rhs.data() &&
1492 lhs.span() == rhs.span() && lhs.extent(0) == rhs.extent(0) &&
1493 lhs.extent(1) == rhs.extent(1) && lhs.extent(2) == rhs.extent(2) &&
1494 lhs.extent(3) == rhs.extent(3) && lhs.extent(4) == rhs.extent(4) &&
1495 lhs.extent(5) == rhs.extent(5) && lhs.extent(6) == rhs.extent(6) &&
1496 lhs.extent(7) == rhs.extent(7);
1497}
1498
1499template <class LT, class... LP, class RT, class... RP>
1500KOKKOS_INLINE_FUNCTION bool operator!=(const DynRankView<LT, LP...>& lhs,
1501 const DynRankView<RT, RP...>& rhs) {
1502 return !(operator==(lhs, rhs));
1503}
1504
1505} // namespace Kokkos
1506
1507//----------------------------------------------------------------------------
1508//----------------------------------------------------------------------------
1509namespace Kokkos {
1510namespace Impl {
1511
1512template <class OutputView, class Enable = void>
1513struct DynRankViewFill {
1514 using const_value_type = typename OutputView::traits::const_value_type;
1515
1516 const OutputView output;
1517 const_value_type input;
1518
1519 KOKKOS_INLINE_FUNCTION
1520 void operator()(const size_t i0) const {
1521 const size_t n1 = output.extent(1);
1522 const size_t n2 = output.extent(2);
1523 const size_t n3 = output.extent(3);
1524 const size_t n4 = output.extent(4);
1525 const size_t n5 = output.extent(5);
1526 const size_t n6 = output.extent(6);
1527
1528 for (size_t i1 = 0; i1 < n1; ++i1) {
1529 for (size_t i2 = 0; i2 < n2; ++i2) {
1530 for (size_t i3 = 0; i3 < n3; ++i3) {
1531 for (size_t i4 = 0; i4 < n4; ++i4) {
1532 for (size_t i5 = 0; i5 < n5; ++i5) {
1533 for (size_t i6 = 0; i6 < n6; ++i6) {
1534 output.access(i0, i1, i2, i3, i4, i5, i6) = input;
1535 }
1536 }
1537 }
1538 }
1539 }
1540 }
1541 }
1542
1543 DynRankViewFill(const OutputView& arg_out, const_value_type& arg_in)
1544 : output(arg_out), input(arg_in) {
1545 using execution_space = typename OutputView::execution_space;
1546 using Policy = Kokkos::RangePolicy<execution_space>;
1547
1548 Kokkos::parallel_for("Kokkos::DynRankViewFill", Policy(0, output.extent(0)),
1549 *this);
1550 }
1551};
1552
1553template <class OutputView>
1554struct DynRankViewFill<OutputView, std::enable_if_t<OutputView::rank == 0>> {
1555 DynRankViewFill(const OutputView& dst,
1556 const typename OutputView::const_value_type& src) {
1557 Kokkos::Impl::DeepCopy<typename OutputView::memory_space,
1558 Kokkos::HostSpace>(
1559 dst.data(), &src, sizeof(typename OutputView::const_value_type));
1560 }
1561};
1562
1563template <class OutputView, class InputView,
1564 class ExecSpace = typename OutputView::execution_space>
1565struct DynRankViewRemap {
1566 const OutputView output;
1567 const InputView input;
1568 const size_t n0;
1569 const size_t n1;
1570 const size_t n2;
1571 const size_t n3;
1572 const size_t n4;
1573 const size_t n5;
1574 const size_t n6;
1575 const size_t n7;
1576
1577 DynRankViewRemap(const ExecSpace& exec_space, const OutputView& arg_out,
1578 const InputView& arg_in)
1579 : output(arg_out),
1580 input(arg_in),
1581 n0(std::min((size_t)arg_out.extent(0), (size_t)arg_in.extent(0))),
1582 n1(std::min((size_t)arg_out.extent(1), (size_t)arg_in.extent(1))),
1583 n2(std::min((size_t)arg_out.extent(2), (size_t)arg_in.extent(2))),
1584 n3(std::min((size_t)arg_out.extent(3), (size_t)arg_in.extent(3))),
1585 n4(std::min((size_t)arg_out.extent(4), (size_t)arg_in.extent(4))),
1586 n5(std::min((size_t)arg_out.extent(5), (size_t)arg_in.extent(5))),
1587 n6(std::min((size_t)arg_out.extent(6), (size_t)arg_in.extent(6))),
1588 n7(std::min((size_t)arg_out.extent(7), (size_t)arg_in.extent(7))) {
1589 using Policy = Kokkos::RangePolicy<ExecSpace>;
1590
1591 Kokkos::parallel_for("Kokkos::DynRankViewRemap", Policy(exec_space, 0, n0),
1592 *this);
1593 }
1594
1595 DynRankViewRemap(const OutputView& arg_out, const InputView& arg_in)
1596 : output(arg_out),
1597 input(arg_in),
1598 n0(std::min((size_t)arg_out.extent(0), (size_t)arg_in.extent(0))),
1599 n1(std::min((size_t)arg_out.extent(1), (size_t)arg_in.extent(1))),
1600 n2(std::min((size_t)arg_out.extent(2), (size_t)arg_in.extent(2))),
1601 n3(std::min((size_t)arg_out.extent(3), (size_t)arg_in.extent(3))),
1602 n4(std::min((size_t)arg_out.extent(4), (size_t)arg_in.extent(4))),
1603 n5(std::min((size_t)arg_out.extent(5), (size_t)arg_in.extent(5))),
1604 n6(std::min((size_t)arg_out.extent(6), (size_t)arg_in.extent(6))),
1605 n7(std::min((size_t)arg_out.extent(7), (size_t)arg_in.extent(7))) {
1606 using Policy = Kokkos::RangePolicy<ExecSpace>;
1607
1608 Kokkos::parallel_for("Kokkos::DynRankViewRemap", Policy(0, n0), *this);
1609 }
1610
1611 KOKKOS_INLINE_FUNCTION
1612 void operator()(const size_t i0) const {
1613 for (size_t i1 = 0; i1 < n1; ++i1) {
1614 for (size_t i2 = 0; i2 < n2; ++i2) {
1615 for (size_t i3 = 0; i3 < n3; ++i3) {
1616 for (size_t i4 = 0; i4 < n4; ++i4) {
1617 for (size_t i5 = 0; i5 < n5; ++i5) {
1618 for (size_t i6 = 0; i6 < n6; ++i6) {
1619 output.access(i0, i1, i2, i3, i4, i5, i6) =
1620 input.access(i0, i1, i2, i3, i4, i5, i6);
1621 }
1622 }
1623 }
1624 }
1625 }
1626 }
1627 }
1628};
1629
1630} /* namespace Impl */
1631} /* namespace Kokkos */
1632
1633namespace Kokkos {
1634
1635namespace Impl {
1636
1637/* \brief Returns a View of the requested rank, aliasing the
1638 underlying memory, to facilitate implementation of deep_copy() and
1639 other routines that are defined on View */
1640template <unsigned N, typename T, typename... Args>
1641KOKKOS_FUNCTION auto as_view_of_rank_n(
1642 DynRankView<T, Args...> v,
1643 typename std::enable_if<std::is_same<
1644 typename ViewTraits<T, Args...>::specialize, void>::value>::type* =
1645 nullptr) {
1646 if (v.rank() != N) {
1647 KOKKOS_IF_ON_HOST(
1648 const std::string message =
1649 "Converting DynRankView of rank " + std::to_string(v.rank()) +
1650 " to a View of mis-matched rank " + std::to_string(N) + "!";
1651 Kokkos::abort(message.c_str());)
1652 KOKKOS_IF_ON_DEVICE(
1653 Kokkos::abort("Converting DynRankView to a View of mis-matched rank!");)
1654 }
1655
1656 return View<typename RankDataType<T, N>::type, Args...>(
1657 v.data(), v.impl_map().layout());
1658}
1659
1660template <typename Function, typename... Args>
1661void apply_to_view_of_static_rank(Function&& f, DynRankView<Args...> a) {
1662 switch (rank(a)) {
1663 case 0: f(as_view_of_rank_n<0>(a)); break;
1664 case 1: f(as_view_of_rank_n<1>(a)); break;
1665 case 2: f(as_view_of_rank_n<2>(a)); break;
1666 case 3: f(as_view_of_rank_n<3>(a)); break;
1667 case 4: f(as_view_of_rank_n<4>(a)); break;
1668 case 5: f(as_view_of_rank_n<5>(a)); break;
1669 case 6: f(as_view_of_rank_n<6>(a)); break;
1670 case 7: f(as_view_of_rank_n<7>(a)); break;
1671 default:
1672 KOKKOS_IF_ON_HOST(
1673 Kokkos::abort(
1674 std::string(
1675 "Trying to apply a function to a view of unexpected rank " +
1676 std::to_string(rank(a)))
1677 .c_str());)
1678 KOKKOS_IF_ON_DEVICE(
1679 Kokkos::abort(
1680 "Trying to apply a function to a view of unexpected rank");)
1681 }
1682}
1683
1684} // namespace Impl
1685
1686template <typename D, class... P>
1687KOKKOS_INLINE_FUNCTION constexpr auto DynRankView<D, P...>::layout() const ->
1688 typename traits::array_layout {
1689 switch (rank()) {
1690 case 0: return Impl::as_view_of_rank_n<0>(*this).layout();
1691 case 1: return Impl::as_view_of_rank_n<1>(*this).layout();
1692 case 2: return Impl::as_view_of_rank_n<2>(*this).layout();
1693 case 3: return Impl::as_view_of_rank_n<3>(*this).layout();
1694 case 4: return Impl::as_view_of_rank_n<4>(*this).layout();
1695 case 5: return Impl::as_view_of_rank_n<5>(*this).layout();
1696 case 6: return Impl::as_view_of_rank_n<6>(*this).layout();
1697 case 7: return Impl::as_view_of_rank_n<7>(*this).layout();
1698 default:
1699 KOKKOS_IF_ON_HOST(
1700 Kokkos::abort(
1701 std::string(
1702 "Calling DynRankView::layout on DRV of unexpected rank " +
1703 std::to_string(rank()))
1704 .c_str());)
1705 KOKKOS_IF_ON_DEVICE(
1706 Kokkos::abort(
1707 "Calling DynRankView::layout on DRV of unexpected rank");)
1708 }
1709 // control flow should never reach here
1710 return m_map.layout();
1711}
1712
1714template <class ExecSpace, class DT, class... DP>
1715inline void deep_copy(
1716 const ExecSpace& e, const DynRankView<DT, DP...>& dst,
1717 typename ViewTraits<DT, DP...>::const_value_type& value,
1718 std::enable_if_t<std::is_same<typename ViewTraits<DT, DP...>::specialize,
1719 void>::value>* = nullptr) {
1720 static_assert(
1721 std::is_same<typename ViewTraits<DT, DP...>::non_const_value_type,
1722 typename ViewTraits<DT, DP...>::value_type>::value,
1723 "deep_copy requires non-const type");
1724
1725 Impl::apply_to_view_of_static_rank(
1726 [=](auto view) { deep_copy(e, view, value); }, dst);
1727}
1728
1729template <class DT, class... DP>
1730inline void deep_copy(
1731 const DynRankView<DT, DP...>& dst,
1732 typename ViewTraits<DT, DP...>::const_value_type& value,
1733 std::enable_if_t<std::is_same<typename ViewTraits<DT, DP...>::specialize,
1734 void>::value>* = nullptr) {
1735 Impl::apply_to_view_of_static_rank([=](auto view) { deep_copy(view, value); },
1736 dst);
1737}
1738
1740template <class ExecSpace, class ST, class... SP>
1741inline void deep_copy(
1742 const ExecSpace& e,
1743 typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1744 const DynRankView<ST, SP...>& src,
1745 std::enable_if_t<std::is_same<typename ViewTraits<ST, SP...>::specialize,
1746 void>::value>* = 0) {
1747 deep_copy(e, dst, Impl::as_view_of_rank_n<0>(src));
1748}
1749
1750template <class ST, class... SP>
1751inline void deep_copy(
1752 typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1753 const DynRankView<ST, SP...>& src,
1754 std::enable_if_t<std::is_same<typename ViewTraits<ST, SP...>::specialize,
1755 void>::value>* = 0) {
1756 deep_copy(dst, Impl::as_view_of_rank_n<0>(src));
1757}
1758
1759//----------------------------------------------------------------------------
1765template <class ExecSpace, class DstType, class SrcType>
1766inline void deep_copy(
1767 const ExecSpace& exec_space, const DstType& dst, const SrcType& src,
1768 std::enable_if_t<
1769 (std::is_void<typename DstType::traits::specialize>::value &&
1770 std::is_void<typename SrcType::traits::specialize>::value &&
1771 (Kokkos::is_dyn_rank_view<DstType>::value ||
1772 Kokkos::is_dyn_rank_view<SrcType>::value))>* = nullptr) {
1773 static_assert(
1774 std::is_same<typename DstType::traits::value_type,
1775 typename DstType::traits::non_const_value_type>::value,
1776 "deep_copy requires non-const destination type");
1777
1778 switch (rank(dst)) {
1779 case 0:
1780 deep_copy(exec_space, Impl::as_view_of_rank_n<0>(dst),
1781 Impl::as_view_of_rank_n<0>(src));
1782 break;
1783 case 1:
1784 deep_copy(exec_space, Impl::as_view_of_rank_n<1>(dst),
1785 Impl::as_view_of_rank_n<1>(src));
1786 break;
1787 case 2:
1788 deep_copy(exec_space, Impl::as_view_of_rank_n<2>(dst),
1789 Impl::as_view_of_rank_n<2>(src));
1790 break;
1791 case 3:
1792 deep_copy(exec_space, Impl::as_view_of_rank_n<3>(dst),
1793 Impl::as_view_of_rank_n<3>(src));
1794 break;
1795 case 4:
1796 deep_copy(exec_space, Impl::as_view_of_rank_n<4>(dst),
1797 Impl::as_view_of_rank_n<4>(src));
1798 break;
1799 case 5:
1800 deep_copy(exec_space, Impl::as_view_of_rank_n<5>(dst),
1801 Impl::as_view_of_rank_n<5>(src));
1802 break;
1803 case 6:
1804 deep_copy(exec_space, Impl::as_view_of_rank_n<6>(dst),
1805 Impl::as_view_of_rank_n<6>(src));
1806 break;
1807 case 7:
1808 deep_copy(exec_space, Impl::as_view_of_rank_n<7>(dst),
1809 Impl::as_view_of_rank_n<7>(src));
1810 break;
1811 default:
1812 Kokkos::Impl::throw_runtime_exception(
1813 "Calling DynRankView deep_copy with a view of unexpected rank " +
1814 std::to_string(rank(dst)));
1815 }
1816}
1817
1818template <class DstType, class SrcType>
1819inline void deep_copy(
1820 const DstType& dst, const SrcType& src,
1821 std::enable_if_t<
1822 (std::is_void<typename DstType::traits::specialize>::value &&
1823 std::is_void<typename SrcType::traits::specialize>::value &&
1824 (Kokkos::is_dyn_rank_view<DstType>::value ||
1825 Kokkos::is_dyn_rank_view<SrcType>::value))>* = nullptr) {
1826 static_assert(
1827 std::is_same<typename DstType::traits::value_type,
1828 typename DstType::traits::non_const_value_type>::value,
1829 "deep_copy requires non-const destination type");
1830
1831 switch (rank(dst)) {
1832 case 0:
1833 deep_copy(Impl::as_view_of_rank_n<0>(dst),
1834 Impl::as_view_of_rank_n<0>(src));
1835 break;
1836 case 1:
1837 deep_copy(Impl::as_view_of_rank_n<1>(dst),
1838 Impl::as_view_of_rank_n<1>(src));
1839 break;
1840 case 2:
1841 deep_copy(Impl::as_view_of_rank_n<2>(dst),
1842 Impl::as_view_of_rank_n<2>(src));
1843 break;
1844 case 3:
1845 deep_copy(Impl::as_view_of_rank_n<3>(dst),
1846 Impl::as_view_of_rank_n<3>(src));
1847 break;
1848 case 4:
1849 deep_copy(Impl::as_view_of_rank_n<4>(dst),
1850 Impl::as_view_of_rank_n<4>(src));
1851 break;
1852 case 5:
1853 deep_copy(Impl::as_view_of_rank_n<5>(dst),
1854 Impl::as_view_of_rank_n<5>(src));
1855 break;
1856 case 6:
1857 deep_copy(Impl::as_view_of_rank_n<6>(dst),
1858 Impl::as_view_of_rank_n<6>(src));
1859 break;
1860 case 7:
1861 deep_copy(Impl::as_view_of_rank_n<7>(dst),
1862 Impl::as_view_of_rank_n<7>(src));
1863 break;
1864 default:
1865 Kokkos::Impl::throw_runtime_exception(
1866 "Calling DynRankView deep_copy with a view of unexpected rank " +
1867 std::to_string(rank(dst)));
1868 }
1869}
1870
1871} // namespace Kokkos
1872
1873//----------------------------------------------------------------------------
1874//----------------------------------------------------------------------------
1875
1876namespace Kokkos {
1877namespace Impl {
1878
1879// Deduce Mirror Types
1880template <class Space, class T, class... P>
1881struct MirrorDRViewType {
1882 // The incoming view_type
1883 using src_view_type = typename Kokkos::DynRankView<T, P...>;
1884 // The memory space for the mirror view
1885 using memory_space = typename Space::memory_space;
1886 // Check whether it is the same memory space
1887 enum {
1888 is_same_memspace =
1889 std::is_same<memory_space, typename src_view_type::memory_space>::value
1890 };
1891 // The array_layout
1892 using array_layout = typename src_view_type::array_layout;
1893 // The data type (we probably want it non-const since otherwise we can't even
1894 // deep_copy to it.
1895 using data_type = typename src_view_type::non_const_data_type;
1896 // The destination view type if it is not the same memory space
1897 using dest_view_type = Kokkos::DynRankView<data_type, array_layout, Space>;
1898 // If it is the same memory_space return the existsing view_type
1899 // This will also keep the unmanaged trait if necessary
1900 using view_type =
1901 std::conditional_t<is_same_memspace, src_view_type, dest_view_type>;
1902};
1903
1904template <class Space, class T, class... P>
1905struct MirrorDRVType {
1906 // The incoming view_type
1907 using src_view_type = typename Kokkos::DynRankView<T, P...>;
1908 // The memory space for the mirror view
1909 using memory_space = typename Space::memory_space;
1910 // Check whether it is the same memory space
1911 enum {
1912 is_same_memspace =
1913 std::is_same<memory_space, typename src_view_type::memory_space>::value
1914 };
1915 // The array_layout
1916 using array_layout = typename src_view_type::array_layout;
1917 // The data type (we probably want it non-const since otherwise we can't even
1918 // deep_copy to it.
1919 using data_type = typename src_view_type::non_const_data_type;
1920 // The destination view type if it is not the same memory space
1921 using view_type = Kokkos::DynRankView<data_type, array_layout, Space>;
1922};
1923
1924} // namespace Impl
1925
1926namespace Impl {
1927template <class T, class... P, class... ViewCtorArgs>
1928inline typename DynRankView<T, P...>::HostMirror create_mirror(
1929 const DynRankView<T, P...>& src,
1930 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1931 std::enable_if_t<!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
1932 nullptr) {
1933 using src_type = DynRankView<T, P...>;
1934 using dst_type = typename src_type::HostMirror;
1935
1936 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1937
1938 static_assert(
1939 !alloc_prop_input::has_label,
1940 "The view constructor arguments passed to Kokkos::create_mirror "
1941 "must not include a label!");
1942 static_assert(
1943 !alloc_prop_input::has_pointer,
1944 "The view constructor arguments passed to Kokkos::create_mirror must "
1945 "not include a pointer!");
1946 static_assert(
1947 !alloc_prop_input::allow_padding,
1948 "The view constructor arguments passed to Kokkos::create_mirror must "
1949 "not explicitly allow padding!");
1950
1951 auto prop_copy = Impl::with_properties_if_unset(
1952 arg_prop, std::string(src.label()).append("_mirror"));
1953
1954 return dst_type(prop_copy, Impl::reconstructLayout(src.layout(), src.rank()));
1955}
1956
1957template <class T, class... P, class... ViewCtorArgs>
1958inline auto create_mirror(
1959 const DynRankView<T, P...>& src,
1960 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1961 std::enable_if_t<Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
1962 nullptr) {
1963 using dst_type = typename Impl::MirrorDRVType<
1964 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
1965 P...>::view_type;
1966
1967 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1968
1969 static_assert(
1970 !alloc_prop_input::has_label,
1971 "The view constructor arguments passed to Kokkos::create_mirror "
1972 "must not include a label!");
1973 static_assert(
1974 !alloc_prop_input::has_pointer,
1975 "The view constructor arguments passed to Kokkos::create_mirror must "
1976 "not include a pointer!");
1977 static_assert(
1978 !alloc_prop_input::allow_padding,
1979 "The view constructor arguments passed to Kokkos::create_mirror must "
1980 "not explicitly allow padding!");
1981
1982 auto prop_copy = Impl::with_properties_if_unset(
1983 arg_prop, std::string(src.label()).append("_mirror"));
1984
1985 return dst_type(prop_copy, Impl::reconstructLayout(src.layout(), src.rank()));
1986}
1987
1988} // namespace Impl
1989
1990// Create a mirror in host space
1991template <class T, class... P>
1992inline typename DynRankView<T, P...>::HostMirror create_mirror(
1993 const DynRankView<T, P...>& src,
1994 std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
1995 void>::value>* = nullptr) {
1996 return Impl::create_mirror(src, Kokkos::Impl::ViewCtorProp<>{});
1997}
1998
1999template <class T, class... P>
2000inline typename DynRankView<T, P...>::HostMirror create_mirror(
2001 Kokkos::Impl::WithoutInitializing_t wi, const DynRankView<T, P...>& src,
2002 std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
2003 void>::value>* = nullptr) {
2004 return Impl::create_mirror(src, Kokkos::view_alloc(wi));
2005}
2006
2007template <class T, class... P, class... ViewCtorArgs>
2008inline typename DynRankView<T, P...>::HostMirror create_mirror(
2009 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2010 const DynRankView<T, P...>& src,
2011 std::enable_if_t<
2012 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
2013 !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* = nullptr) {
2014 return Impl::create_mirror(src, arg_prop);
2015}
2016
2017// Create a mirror in a new space
2018template <class Space, class T, class... P,
2019 typename Enable = std::enable_if_t<
2020 Kokkos::is_space<Space>::value &&
2021 std::is_void<typename ViewTraits<T, P...>::specialize>::value>>
2022typename Impl::MirrorDRVType<Space, T, P...>::view_type create_mirror(
2023 const Space&, const Kokkos::DynRankView<T, P...>& src) {
2024 return Impl::create_mirror(
2025 src, Kokkos::view_alloc(typename Space::memory_space{}));
2026}
2027
2028template <class Space, class T, class... P>
2029typename Impl::MirrorDRVType<Space, T, P...>::view_type create_mirror(
2030 Kokkos::Impl::WithoutInitializing_t wi, const Space&,
2031 const Kokkos::DynRankView<T, P...>& src,
2032 std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
2033 void>::value>* = nullptr) {
2034 return Impl::create_mirror(
2035 src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
2036}
2037
2038template <class T, class... P, class... ViewCtorArgs>
2039inline auto create_mirror(
2040 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2041 const DynRankView<T, P...>& src,
2042 std::enable_if_t<
2043 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
2044 Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* = nullptr) {
2045 using ReturnType = typename Impl::MirrorDRVType<
2046 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2047 P...>::view_type;
2048 return ReturnType{Impl::create_mirror(src, arg_prop)};
2049}
2050
2051namespace Impl {
2052template <class T, class... P, class... ViewCtorArgs>
2053inline std::enable_if_t<
2054 !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
2055 std::is_same<
2056 typename DynRankView<T, P...>::memory_space,
2057 typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
2058 std::is_same<
2059 typename DynRankView<T, P...>::data_type,
2060 typename DynRankView<T, P...>::HostMirror::data_type>::value,
2061 typename DynRankView<T, P...>::HostMirror>
2062create_mirror_view(const DynRankView<T, P...>& src,
2063 const typename Impl::ViewCtorProp<ViewCtorArgs...>&) {
2064 return src;
2065}
2066
2067template <class T, class... P, class... ViewCtorArgs>
2068inline std::enable_if_t<
2069 !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
2070 !(std::is_same<
2071 typename DynRankView<T, P...>::memory_space,
2072 typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
2073 std::is_same<
2074 typename DynRankView<T, P...>::data_type,
2075 typename DynRankView<T, P...>::HostMirror::data_type>::value),
2076 typename DynRankView<T, P...>::HostMirror>
2077create_mirror_view(
2078 const DynRankView<T, P...>& src,
2079 const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
2080 return Kokkos::Impl::create_mirror(src, arg_prop);
2081}
2082
2083template <class T, class... P, class... ViewCtorArgs,
2084 class = std::enable_if_t<
2085 Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
2086inline std::enable_if_t<
2087 Kokkos::is_space<
2088 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space>::value &&
2089 Impl::MirrorDRViewType<
2090 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2091 P...>::is_same_memspace,
2092 typename Impl::MirrorDRViewType<
2093 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2094 P...>::view_type>
2095create_mirror_view(const Kokkos::DynRankView<T, P...>& src,
2096 const typename Impl::ViewCtorProp<ViewCtorArgs...>&) {
2097 return src;
2098}
2099
2100template <class T, class... P, class... ViewCtorArgs,
2101 class = std::enable_if_t<
2102 Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
2103inline std::enable_if_t<
2104 Kokkos::is_space<
2105 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space>::value &&
2106 !Impl::MirrorDRViewType<
2107 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2108 P...>::is_same_memspace,
2109 typename Impl::MirrorDRViewType<
2110 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2111 P...>::view_type>
2112create_mirror_view(
2113 const Kokkos::DynRankView<T, P...>& src,
2114 const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
2115 return Kokkos::Impl::create_mirror(src, arg_prop);
2116}
2117} // namespace Impl
2118
2119// Create a mirror view in host space
2120template <class T, class... P>
2121inline std::enable_if_t<
2122 (std::is_same<
2123 typename DynRankView<T, P...>::memory_space,
2124 typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
2125 std::is_same<typename DynRankView<T, P...>::data_type,
2126 typename DynRankView<T, P...>::HostMirror::data_type>::value),
2127 typename DynRankView<T, P...>::HostMirror>
2128create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
2129 return src;
2130}
2131
2132template <class T, class... P>
2133inline std::enable_if_t<
2134 !(std::is_same<
2135 typename DynRankView<T, P...>::memory_space,
2136 typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
2137 std::is_same<
2138 typename DynRankView<T, P...>::data_type,
2139 typename DynRankView<T, P...>::HostMirror::data_type>::value),
2140 typename DynRankView<T, P...>::HostMirror>
2141create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
2142 return Kokkos::create_mirror(src);
2143}
2144
2145template <class T, class... P>
2146inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
2147 const DynRankView<T, P...>& src) {
2148 return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
2149}
2150
2151// Create a mirror view in a new space
2152// FIXME_C++17 Improve SFINAE here.
2153template <class Space, class T, class... P,
2154 class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
2155inline typename Impl::MirrorDRViewType<Space, T, P...>::view_type
2156create_mirror_view(
2157 const Space&, const Kokkos::DynRankView<T, P...>& src,
2158 std::enable_if_t<
2159 Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>* = nullptr) {
2160 return src;
2161}
2162
2163// FIXME_C++17 Improve SFINAE here.
2164template <class Space, class T, class... P,
2165 class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
2166inline typename Impl::MirrorDRViewType<Space, T, P...>::view_type
2167create_mirror_view(
2168 const Space& space, const Kokkos::DynRankView<T, P...>& src,
2169 std::enable_if_t<
2170 !Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>* = nullptr) {
2171 return Kokkos::create_mirror(space, src);
2172}
2173
2174template <class Space, class T, class... P>
2175inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
2176 const Space&,
2177 const Kokkos::DynRankView<T, P...>& src) {
2178 return Impl::create_mirror_view(
2179 src, Kokkos::view_alloc(typename Space::memory_space{}, wi));
2180}
2181
2182template <class T, class... P, class... ViewCtorArgs>
2183inline auto create_mirror_view(
2184 const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2185 const Kokkos::DynRankView<T, P...>& src) {
2186 return Impl::create_mirror_view(src, arg_prop);
2187}
2188
2189template <class... ViewCtorArgs, class T, class... P>
2190auto create_mirror_view_and_copy(
2191 const Impl::ViewCtorProp<ViewCtorArgs...>&,
2192 const Kokkos::DynRankView<T, P...>& src,
2193 std::enable_if_t<
2194 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
2195 Impl::MirrorDRViewType<
2196 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2197 P...>::is_same_memspace>* = nullptr) {
2198 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2199 static_assert(
2200 alloc_prop_input::has_memory_space,
2201 "The view constructor arguments passed to "
2202 "Kokkos::create_mirror_view_and_copy must include a memory space!");
2203 static_assert(!alloc_prop_input::has_pointer,
2204 "The view constructor arguments passed to "
2205 "Kokkos::create_mirror_view_and_copy must "
2206 "not include a pointer!");
2207 static_assert(!alloc_prop_input::allow_padding,
2208 "The view constructor arguments passed to "
2209 "Kokkos::create_mirror_view_and_copy must "
2210 "not explicitly allow padding!");
2211
2212 // same behavior as deep_copy(src, src)
2213 if (!alloc_prop_input::has_execution_space)
2214 fence(
2215 "Kokkos::create_mirror_view_and_copy: fence before returning src view");
2216 return src;
2217}
2218
2219template <class... ViewCtorArgs, class T, class... P>
2220auto create_mirror_view_and_copy(
2221 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2222 const Kokkos::DynRankView<T, P...>& src,
2223 std::enable_if_t<
2224 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
2225 !Impl::MirrorDRViewType<
2226 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2227 P...>::is_same_memspace>* = nullptr) {
2228 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2229 static_assert(
2230 alloc_prop_input::has_memory_space,
2231 "The view constructor arguments passed to "
2232 "Kokkos::create_mirror_view_and_copy must include a memory space!");
2233 static_assert(!alloc_prop_input::has_pointer,
2234 "The view constructor arguments passed to "
2235 "Kokkos::create_mirror_view_and_copy must "
2236 "not include a pointer!");
2237 static_assert(!alloc_prop_input::allow_padding,
2238 "The view constructor arguments passed to "
2239 "Kokkos::create_mirror_view_and_copy must "
2240 "not explicitly allow padding!");
2241 using Space = typename alloc_prop_input::memory_space;
2242 using Mirror = typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
2243
2244 auto arg_prop_copy = Impl::with_properties_if_unset(
2245 arg_prop, std::string{}, WithoutInitializing,
2246 typename Space::execution_space{});
2247
2248 std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
2249 if (label.empty()) label = src.label();
2250 auto mirror = typename Mirror::non_const_type{
2251 arg_prop_copy, Impl::reconstructLayout(src.layout(), src.rank())};
2252 if constexpr (alloc_prop_input::has_execution_space) {
2253 deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
2254 mirror, src);
2255 } else
2256 deep_copy(mirror, src);
2257 return mirror;
2258}
2259
2260template <class Space, class T, class... P>
2261auto create_mirror_view_and_copy(const Space&,
2262 const Kokkos::DynRankView<T, P...>& src,
2263 std::string const& name = "") {
2264 return create_mirror_view_and_copy(
2265 Kokkos::view_alloc(typename Space::memory_space{}, name), src);
2266}
2267
2268} // namespace Kokkos
2269
2270//----------------------------------------------------------------------------
2271//----------------------------------------------------------------------------
2272
2273namespace Kokkos {
2276template <class... ViewCtorArgs, class T, class... P>
2277inline void impl_resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2278 DynRankView<T, P...>& v, const size_t n0,
2279 const size_t n1, const size_t n2, const size_t n3,
2280 const size_t n4, const size_t n5, const size_t n6,
2281 const size_t n7) {
2282 using drview_type = DynRankView<T, P...>;
2283 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2284
2285 static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
2286 "Can only resize managed views");
2287 static_assert(!alloc_prop_input::has_label,
2288 "The view constructor arguments passed to Kokkos::resize "
2289 "must not include a label!");
2290 static_assert(!alloc_prop_input::has_pointer,
2291 "The view constructor arguments passed to Kokkos::resize must "
2292 "not include a pointer!");
2293 static_assert(!alloc_prop_input::has_memory_space,
2294 "The view constructor arguments passed to Kokkos::resize must "
2295 "not include a memory space instance!");
2296
2297 auto prop_copy = Impl::with_properties_if_unset(
2298 arg_prop, v.label(), typename drview_type::execution_space{});
2299
2300 drview_type v_resized(prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
2301
2302 if constexpr (alloc_prop_input::has_execution_space)
2303 Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(
2304 Impl::get_property<Impl::ExecutionSpaceTag>(prop_copy), v_resized, v);
2305 else {
2306 Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(v_resized, v);
2307 Kokkos::fence("Kokkos::resize(DynRankView)");
2308 }
2309 v = v_resized;
2310}
2311
2312template <class T, class... P>
2313inline void resize(DynRankView<T, P...>& v,
2314 const size_t n0 = KOKKOS_INVALID_INDEX,
2315 const size_t n1 = KOKKOS_INVALID_INDEX,
2316 const size_t n2 = KOKKOS_INVALID_INDEX,
2317 const size_t n3 = KOKKOS_INVALID_INDEX,
2318 const size_t n4 = KOKKOS_INVALID_INDEX,
2319 const size_t n5 = KOKKOS_INVALID_INDEX,
2320 const size_t n6 = KOKKOS_INVALID_INDEX,
2321 const size_t n7 = KOKKOS_INVALID_INDEX) {
2322 impl_resize(Impl::ViewCtorProp<>{}, v, n0, n1, n2, n3, n4, n5, n6, n7);
2323}
2324
2325template <class... ViewCtorArgs, class T, class... P>
2326void resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2327 DynRankView<T, P...>& v,
2328 const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2329 const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2330 const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2331 const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2332 const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2333 const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2334 const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2335 const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
2336 impl_resize(arg_prop, v, n0, n1, n2, n3, n4, n5, n6, n7);
2337}
2338
2339template <class I, class T, class... P>
2340inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> resize(
2341 const I& arg_prop, DynRankView<T, P...>& v,
2342 const size_t n0 = KOKKOS_INVALID_INDEX,
2343 const size_t n1 = KOKKOS_INVALID_INDEX,
2344 const size_t n2 = KOKKOS_INVALID_INDEX,
2345 const size_t n3 = KOKKOS_INVALID_INDEX,
2346 const size_t n4 = KOKKOS_INVALID_INDEX,
2347 const size_t n5 = KOKKOS_INVALID_INDEX,
2348 const size_t n6 = KOKKOS_INVALID_INDEX,
2349 const size_t n7 = KOKKOS_INVALID_INDEX) {
2350 impl_resize(Kokkos::view_alloc(arg_prop), v, n0, n1, n2, n3, n4, n5, n6, n7);
2351}
2352
2355template <class... ViewCtorArgs, class T, class... P>
2356inline void impl_realloc(DynRankView<T, P...>& v, const size_t n0,
2357 const size_t n1, const size_t n2, const size_t n3,
2358 const size_t n4, const size_t n5, const size_t n6,
2359 const size_t n7,
2360 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
2361 using drview_type = DynRankView<T, P...>;
2362 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2363
2364 static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
2365 "Can only realloc managed views");
2366 static_assert(!alloc_prop_input::has_label,
2367 "The view constructor arguments passed to Kokkos::realloc must "
2368 "not include a label!");
2369 static_assert(!alloc_prop_input::has_pointer,
2370 "The view constructor arguments passed to Kokkos::realloc must "
2371 "not include a pointer!");
2372 static_assert(!alloc_prop_input::has_memory_space,
2373 "The view constructor arguments passed to Kokkos::realloc must "
2374 "not include a memory space instance!");
2375
2376 auto arg_prop_copy = Impl::with_properties_if_unset(arg_prop, v.label());
2377
2378 v = drview_type(); // Deallocate first, if the only view to allocation
2379 v = drview_type(arg_prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
2380}
2381
2382template <class T, class... P, class... ViewCtorArgs>
2383inline void realloc(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2384 DynRankView<T, P...>& v,
2385 const size_t n0 = KOKKOS_INVALID_INDEX,
2386 const size_t n1 = KOKKOS_INVALID_INDEX,
2387 const size_t n2 = KOKKOS_INVALID_INDEX,
2388 const size_t n3 = KOKKOS_INVALID_INDEX,
2389 const size_t n4 = KOKKOS_INVALID_INDEX,
2390 const size_t n5 = KOKKOS_INVALID_INDEX,
2391 const size_t n6 = KOKKOS_INVALID_INDEX,
2392 const size_t n7 = KOKKOS_INVALID_INDEX) {
2393 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, arg_prop);
2394}
2395
2396template <class T, class... P>
2397inline void realloc(DynRankView<T, P...>& v,
2398 const size_t n0 = KOKKOS_INVALID_INDEX,
2399 const size_t n1 = KOKKOS_INVALID_INDEX,
2400 const size_t n2 = KOKKOS_INVALID_INDEX,
2401 const size_t n3 = KOKKOS_INVALID_INDEX,
2402 const size_t n4 = KOKKOS_INVALID_INDEX,
2403 const size_t n5 = KOKKOS_INVALID_INDEX,
2404 const size_t n6 = KOKKOS_INVALID_INDEX,
2405 const size_t n7 = KOKKOS_INVALID_INDEX) {
2406 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Impl::ViewCtorProp<>{});
2407}
2408
2409template <class I, class T, class... P>
2410inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> realloc(
2411 const I& arg_prop, DynRankView<T, P...>& v,
2412 const size_t n0 = KOKKOS_INVALID_INDEX,
2413 const size_t n1 = KOKKOS_INVALID_INDEX,
2414 const size_t n2 = KOKKOS_INVALID_INDEX,
2415 const size_t n3 = KOKKOS_INVALID_INDEX,
2416 const size_t n4 = KOKKOS_INVALID_INDEX,
2417 const size_t n5 = KOKKOS_INVALID_INDEX,
2418 const size_t n6 = KOKKOS_INVALID_INDEX,
2419 const size_t n7 = KOKKOS_INVALID_INDEX) {
2420 impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Kokkos::view_alloc(arg_prop));
2421}
2422
2423} // namespace Kokkos
2424
2425#ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
2426#undef KOKKOS_IMPL_PUBLIC_INCLUDE
2427#undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
2428#endif
2429#endif
View
View
Definition Kokkos_View.hpp:577
ReturnType
ReturnType
Kokkos::Impl
ScopeGuard Some user scope issues have been identified with some Kokkos::finalize calls; ScopeGuard a...
Definition Kokkos_AnonymousSpace.hpp:61
Kokkos::Impl::dyn_rank_view_verify_operator_bounds
KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(const iType0 &, const MapType &)
Debug bounds-checking routines.
Definition Kokkos_DynRankView.hpp:211
Kokkos::Impl::ViewToDynRankViewTag
Assign compatible default mappings.
Definition Kokkos_DynRankView.hpp:278
Kokkos::LayoutStride
Memory layout tag indicated arbitrarily strided multi-index mapping into contiguous memory.
Definition Kokkos_Layout.hpp:138
Kokkos::ViewTraits
Traits class for accessing attributes of a View.
Definition Kokkos_View.hpp:245
Generated by doxygen 1.17.0