Kokkos Core Kernels Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
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 
34 namespace Kokkos {
35 
36 template <typename DataType, class... Properties>
37 class DynRankView; // forward declare
38 
39 namespace Impl {
40 
41 template <typename Specialize>
42 struct 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
165 template <typename Layout, typename iType>
166 KOKKOS_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>
171 reconstructLayout(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
183 template <typename Layout, typename iType>
184 KOKKOS_INLINE_FUNCTION static std::enable_if_t<
185  (std::is_same<Layout, Kokkos::LayoutStride>::value) &&
186  std::is_integral<iType>::value,
187  Layout>
188 reconstructLayout(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
210 template <unsigned, typename iType0, class MapType>
211 KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
212  const iType0&, const MapType&) {
213  return true;
214 }
215 
216 template <unsigned R, typename iType0, class MapType, typename iType1,
217  class... Args>
218 KOKKOS_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::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 
236 template <unsigned, class MapType>
237 inline void dyn_rank_view_error_operator_bounds(char*, int, const MapType&) {}
238 
239 template <unsigned R, class MapType, class iType, class... Args>
240 inline 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
250 template <typename MemorySpace, typename iType0, typename iType1, class MapType,
251  class... Args>
252 KOKKOS_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 
278 struct ViewToDynRankViewTag {};
279 
280 } // namespace Impl
281 
282 namespace Impl {
283 
284 template <class DstTraits, class SrcTraits>
285 class 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 
371 template <class>
372 struct is_dyn_rank_view : public std::false_type {};
373 
374 template <class D, class... P>
375 struct is_dyn_rank_view<Kokkos::DynRankView<D, P...>> : public std::true_type {
376 };
377 
378 template <class T>
379 inline constexpr bool is_dyn_rank_view_v = is_dyn_rank_view<T>::value;
380 
381 template <typename DataType, class... Properties>
382 class 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 
1279 template <typename D, class... P>
1280 KOKKOS_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 
1290 namespace Impl {
1291 
1292 struct DynRankSubviewTag {};
1293 
1294 } // namespace Impl
1295 
1296 namespace Impl {
1297 
1298 template <class SrcTraits, class... Args>
1299 class 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 
1443 template <class V, class... Args>
1444 using Subdynrankview =
1445  typename Kokkos::Impl::ViewMapping<Kokkos::Impl::DynRankSubviewTag, V,
1446  Args...>::ret_type;
1447 
1448 template <class D, class... P, class... Args>
1449 KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
1450 subdynrankview(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
1467 template <class D, class... P, class... Args>
1468 KOKKOS_INLINE_FUNCTION Subdynrankview<ViewTraits<D*******, P...>, Args...>
1469 subview(const Kokkos::DynRankView<D, P...>& src, Args... args) {
1470  return subdynrankview(src, args...);
1471 }
1472 
1473 } // namespace Kokkos
1474 
1475 namespace Kokkos {
1476 
1477 // overload == and !=
1478 template <class LT, class... LP, class RT, class... RP>
1479 KOKKOS_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 
1499 template <class LT, class... LP, class RT, class... RP>
1500 KOKKOS_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 //----------------------------------------------------------------------------
1509 namespace Kokkos {
1510 namespace Impl {
1511 
1512 template <class OutputView, class Enable = void>
1513 struct 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 
1553 template <class OutputView>
1554 struct 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 
1563 template <class OutputView, class InputView,
1564  class ExecSpace = typename OutputView::execution_space>
1565 struct 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 
1633 namespace Kokkos {
1634 
1635 namespace 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 */
1640 template <unsigned N, typename T, typename... Args>
1641 KOKKOS_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  auto layout = v.impl_map().layout();
1657 
1658  if constexpr (std::is_same_v<decltype(layout), Kokkos::LayoutLeft> ||
1659  std::is_same_v<decltype(layout), Kokkos::LayoutRight> ||
1660  std::is_same_v<decltype(layout), Kokkos::LayoutStride>) {
1661  for (int i = N; i < 7; ++i)
1662  layout.dimension[i] = KOKKOS_IMPL_CTOR_DEFAULT_ARG;
1663  }
1664 
1665  return View<typename RankDataType<T, N>::type, Args...>(v.data(), layout);
1666 }
1667 
1668 template <typename Function, typename... Args>
1669 void apply_to_view_of_static_rank(Function&& f, DynRankView<Args...> a) {
1670  switch (rank(a)) {
1671  case 0: f(as_view_of_rank_n<0>(a)); break;
1672  case 1: f(as_view_of_rank_n<1>(a)); break;
1673  case 2: f(as_view_of_rank_n<2>(a)); break;
1674  case 3: f(as_view_of_rank_n<3>(a)); break;
1675  case 4: f(as_view_of_rank_n<4>(a)); break;
1676  case 5: f(as_view_of_rank_n<5>(a)); break;
1677  case 6: f(as_view_of_rank_n<6>(a)); break;
1678  case 7: f(as_view_of_rank_n<7>(a)); break;
1679  default:
1680  KOKKOS_IF_ON_HOST(
1681  Kokkos::abort(
1682  std::string(
1683  "Trying to apply a function to a view of unexpected rank " +
1684  std::to_string(rank(a)))
1685  .c_str());)
1686  KOKKOS_IF_ON_DEVICE(
1687  Kokkos::abort(
1688  "Trying to apply a function to a view of unexpected rank");)
1689  }
1690 }
1691 
1692 } // namespace Impl
1693 
1694 template <typename D, class... P>
1695 KOKKOS_INLINE_FUNCTION constexpr auto DynRankView<D, P...>::layout() const ->
1696  typename traits::array_layout {
1697  switch (rank()) {
1698  case 0: return Impl::as_view_of_rank_n<0>(*this).layout();
1699  case 1: return Impl::as_view_of_rank_n<1>(*this).layout();
1700  case 2: return Impl::as_view_of_rank_n<2>(*this).layout();
1701  case 3: return Impl::as_view_of_rank_n<3>(*this).layout();
1702  case 4: return Impl::as_view_of_rank_n<4>(*this).layout();
1703  case 5: return Impl::as_view_of_rank_n<5>(*this).layout();
1704  case 6: return Impl::as_view_of_rank_n<6>(*this).layout();
1705  case 7: return Impl::as_view_of_rank_n<7>(*this).layout();
1706  default:
1707  KOKKOS_IF_ON_HOST(
1708  Kokkos::abort(
1709  std::string(
1710  "Calling DynRankView::layout on DRV of unexpected rank " +
1711  std::to_string(rank()))
1712  .c_str());)
1713  KOKKOS_IF_ON_DEVICE(
1714  Kokkos::abort(
1715  "Calling DynRankView::layout on DRV of unexpected rank");)
1716  }
1717  // control flow should never reach here
1718  return m_map.layout();
1719 }
1720 
1722 template <class ExecSpace, class DT, class... DP>
1723 inline void deep_copy(
1724  const ExecSpace& e, const DynRankView<DT, DP...>& dst,
1725  typename ViewTraits<DT, DP...>::const_value_type& value,
1726  std::enable_if_t<std::is_same<typename ViewTraits<DT, DP...>::specialize,
1727  void>::value>* = nullptr) {
1728  static_assert(
1729  std::is_same<typename ViewTraits<DT, DP...>::non_const_value_type,
1730  typename ViewTraits<DT, DP...>::value_type>::value,
1731  "deep_copy requires non-const type");
1732 
1733  Impl::apply_to_view_of_static_rank(
1734  [=](auto view) { deep_copy(e, view, value); }, dst);
1735 }
1736 
1737 template <class DT, class... DP>
1738 inline void deep_copy(
1739  const DynRankView<DT, DP...>& dst,
1740  typename ViewTraits<DT, DP...>::const_value_type& value,
1741  std::enable_if_t<std::is_same<typename ViewTraits<DT, DP...>::specialize,
1742  void>::value>* = nullptr) {
1743  Impl::apply_to_view_of_static_rank([=](auto view) { deep_copy(view, value); },
1744  dst);
1745 }
1746 
1748 template <class ExecSpace, class ST, class... SP>
1749 inline void deep_copy(
1750  const ExecSpace& e,
1751  typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1752  const DynRankView<ST, SP...>& src,
1753  std::enable_if_t<std::is_same<typename ViewTraits<ST, SP...>::specialize,
1754  void>::value>* = 0) {
1755  deep_copy(e, dst, Impl::as_view_of_rank_n<0>(src));
1756 }
1757 
1758 template <class ST, class... SP>
1759 inline void deep_copy(
1760  typename ViewTraits<ST, SP...>::non_const_value_type& dst,
1761  const DynRankView<ST, SP...>& src,
1762  std::enable_if_t<std::is_same<typename ViewTraits<ST, SP...>::specialize,
1763  void>::value>* = 0) {
1764  deep_copy(dst, Impl::as_view_of_rank_n<0>(src));
1765 }
1766 
1767 //----------------------------------------------------------------------------
1773 template <class ExecSpace, class DstType, class SrcType>
1774 inline void deep_copy(
1775  const ExecSpace& exec_space, const DstType& dst, const SrcType& src,
1776  std::enable_if_t<
1777  (std::is_void<typename DstType::traits::specialize>::value &&
1778  std::is_void<typename SrcType::traits::specialize>::value &&
1779  (Kokkos::is_dyn_rank_view<DstType>::value ||
1780  Kokkos::is_dyn_rank_view<SrcType>::value))>* = nullptr) {
1781  static_assert(
1782  std::is_same<typename DstType::traits::value_type,
1783  typename DstType::traits::non_const_value_type>::value,
1784  "deep_copy requires non-const destination type");
1785 
1786  switch (rank(dst)) {
1787  case 0:
1788  deep_copy(exec_space, Impl::as_view_of_rank_n<0>(dst),
1789  Impl::as_view_of_rank_n<0>(src));
1790  break;
1791  case 1:
1792  deep_copy(exec_space, Impl::as_view_of_rank_n<1>(dst),
1793  Impl::as_view_of_rank_n<1>(src));
1794  break;
1795  case 2:
1796  deep_copy(exec_space, Impl::as_view_of_rank_n<2>(dst),
1797  Impl::as_view_of_rank_n<2>(src));
1798  break;
1799  case 3:
1800  deep_copy(exec_space, Impl::as_view_of_rank_n<3>(dst),
1801  Impl::as_view_of_rank_n<3>(src));
1802  break;
1803  case 4:
1804  deep_copy(exec_space, Impl::as_view_of_rank_n<4>(dst),
1805  Impl::as_view_of_rank_n<4>(src));
1806  break;
1807  case 5:
1808  deep_copy(exec_space, Impl::as_view_of_rank_n<5>(dst),
1809  Impl::as_view_of_rank_n<5>(src));
1810  break;
1811  case 6:
1812  deep_copy(exec_space, Impl::as_view_of_rank_n<6>(dst),
1813  Impl::as_view_of_rank_n<6>(src));
1814  break;
1815  case 7:
1816  deep_copy(exec_space, Impl::as_view_of_rank_n<7>(dst),
1817  Impl::as_view_of_rank_n<7>(src));
1818  break;
1819  default:
1820  Kokkos::Impl::throw_runtime_exception(
1821  "Calling DynRankView deep_copy with a view of unexpected rank " +
1822  std::to_string(rank(dst)));
1823  }
1824 }
1825 
1826 template <class DstType, class SrcType>
1827 inline void deep_copy(
1828  const DstType& dst, const SrcType& src,
1829  std::enable_if_t<
1830  (std::is_void<typename DstType::traits::specialize>::value &&
1831  std::is_void<typename SrcType::traits::specialize>::value &&
1832  (Kokkos::is_dyn_rank_view<DstType>::value ||
1833  Kokkos::is_dyn_rank_view<SrcType>::value))>* = nullptr) {
1834  static_assert(
1835  std::is_same<typename DstType::traits::value_type,
1836  typename DstType::traits::non_const_value_type>::value,
1837  "deep_copy requires non-const destination type");
1838 
1839  switch (rank(dst)) {
1840  case 0:
1841  deep_copy(Impl::as_view_of_rank_n<0>(dst),
1842  Impl::as_view_of_rank_n<0>(src));
1843  break;
1844  case 1:
1845  deep_copy(Impl::as_view_of_rank_n<1>(dst),
1846  Impl::as_view_of_rank_n<1>(src));
1847  break;
1848  case 2:
1849  deep_copy(Impl::as_view_of_rank_n<2>(dst),
1850  Impl::as_view_of_rank_n<2>(src));
1851  break;
1852  case 3:
1853  deep_copy(Impl::as_view_of_rank_n<3>(dst),
1854  Impl::as_view_of_rank_n<3>(src));
1855  break;
1856  case 4:
1857  deep_copy(Impl::as_view_of_rank_n<4>(dst),
1858  Impl::as_view_of_rank_n<4>(src));
1859  break;
1860  case 5:
1861  deep_copy(Impl::as_view_of_rank_n<5>(dst),
1862  Impl::as_view_of_rank_n<5>(src));
1863  break;
1864  case 6:
1865  deep_copy(Impl::as_view_of_rank_n<6>(dst),
1866  Impl::as_view_of_rank_n<6>(src));
1867  break;
1868  case 7:
1869  deep_copy(Impl::as_view_of_rank_n<7>(dst),
1870  Impl::as_view_of_rank_n<7>(src));
1871  break;
1872  default:
1873  Kokkos::Impl::throw_runtime_exception(
1874  "Calling DynRankView deep_copy with a view of unexpected rank " +
1875  std::to_string(rank(dst)));
1876  }
1877 }
1878 
1879 } // namespace Kokkos
1880 
1881 //----------------------------------------------------------------------------
1882 //----------------------------------------------------------------------------
1883 
1884 namespace Kokkos {
1885 namespace Impl {
1886 
1887 // Deduce Mirror Types
1888 template <class Space, class T, class... P>
1889 struct MirrorDRViewType {
1890  // The incoming view_type
1891  using src_view_type = typename Kokkos::DynRankView<T, P...>;
1892  // The memory space for the mirror view
1893  using memory_space = typename Space::memory_space;
1894  // Check whether it is the same memory space
1895  enum {
1896  is_same_memspace =
1897  std::is_same<memory_space, typename src_view_type::memory_space>::value
1898  };
1899  // The array_layout
1900  using array_layout = typename src_view_type::array_layout;
1901  // The data type (we probably want it non-const since otherwise we can't even
1902  // deep_copy to it.
1903  using data_type = typename src_view_type::non_const_data_type;
1904  // The destination view type if it is not the same memory space
1905  using dest_view_type = Kokkos::DynRankView<data_type, array_layout, Space>;
1906  // If it is the same memory_space return the existsing view_type
1907  // This will also keep the unmanaged trait if necessary
1908  using view_type =
1909  std::conditional_t<is_same_memspace, src_view_type, dest_view_type>;
1910 };
1911 
1912 template <class Space, class T, class... P>
1913 struct MirrorDRVType {
1914  // The incoming view_type
1915  using src_view_type = typename Kokkos::DynRankView<T, P...>;
1916  // The memory space for the mirror view
1917  using memory_space = typename Space::memory_space;
1918  // Check whether it is the same memory space
1919  enum {
1920  is_same_memspace =
1921  std::is_same<memory_space, typename src_view_type::memory_space>::value
1922  };
1923  // The array_layout
1924  using array_layout = typename src_view_type::array_layout;
1925  // The data type (we probably want it non-const since otherwise we can't even
1926  // deep_copy to it.
1927  using data_type = typename src_view_type::non_const_data_type;
1928  // The destination view type if it is not the same memory space
1929  using view_type = Kokkos::DynRankView<data_type, array_layout, Space>;
1930 };
1931 
1932 } // namespace Impl
1933 
1934 namespace Impl {
1935 
1936 // create a mirror
1937 // private interface that accepts arbitrary view constructor args passed by a
1938 // view_alloc
1939 template <class T, class... P, class... ViewCtorArgs>
1940 inline auto create_mirror(const DynRankView<T, P...>& src,
1941  const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
1942  check_view_ctor_args_create_mirror<ViewCtorArgs...>();
1943 
1944  auto prop_copy = Impl::with_properties_if_unset(
1945  arg_prop, std::string(src.label()).append("_mirror"));
1946 
1947  if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
1948  using dst_type = typename Impl::MirrorDRVType<
1949  typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
1950  P...>::view_type;
1951 
1952  return dst_type(prop_copy,
1953  Impl::reconstructLayout(src.layout(), src.rank()));
1954  } else {
1955  using src_type = DynRankView<T, P...>;
1956  using dst_type = typename src_type::HostMirror;
1957 
1958  return dst_type(prop_copy,
1959  Impl::reconstructLayout(src.layout(), src.rank()));
1960  }
1961 #if defined(KOKKOS_COMPILER_INTEL) || \
1962  (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
1963  !defined(KOKKOS_COMPILER_MSVC))
1964  __builtin_unreachable();
1965 #endif
1966 }
1967 
1968 } // namespace Impl
1969 
1970 // public interface
1971 template <class T, class... P,
1972  class Enable = std::enable_if_t<
1973  std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
1974 inline auto create_mirror(const DynRankView<T, P...>& src) {
1975  return Impl::create_mirror(src, Kokkos::view_alloc());
1976 }
1977 
1978 // public interface that accepts a without initializing flag
1979 template <class T, class... P,
1980  class Enable = std::enable_if_t<
1981  std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
1982 inline auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
1983  const DynRankView<T, P...>& src) {
1984  return Impl::create_mirror(src, Kokkos::view_alloc(wi));
1985 }
1986 
1987 // public interface that accepts a space
1988 template <class Space, class T, class... P,
1989  class Enable = std::enable_if_t<
1990  Kokkos::is_space<Space>::value &&
1991  std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
1992 auto create_mirror(const Space&, const Kokkos::DynRankView<T, P...>& src) {
1993  return Impl::create_mirror(
1994  src, Kokkos::view_alloc(typename Space::memory_space{}));
1995 }
1996 
1997 // public interface that accepts a space and a without initializing flag
1998 template <class Space, class T, class... P,
1999  class Enable = std::enable_if_t<
2000  Kokkos::is_space<Space>::value &&
2001  std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
2002 auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
2003  const Kokkos::DynRankView<T, P...>& src) {
2004  return Impl::create_mirror(
2005  src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
2006 }
2007 
2008 // public interface that accepts arbitrary view constructor args passed by a
2009 // view_alloc
2010 template <class T, class... P, class... ViewCtorArgs,
2011  typename Enable = std::enable_if_t<
2012  std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
2013 inline auto create_mirror(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2014  const DynRankView<T, P...>& src) {
2015  return Impl::create_mirror(src, arg_prop);
2016 }
2017 
2018 namespace Impl {
2019 
2020 // create a mirror view
2021 // private interface that accepts arbitrary view constructor args passed by a
2022 // view_alloc
2023 template <class T, class... P, class... ViewCtorArgs>
2024 inline auto create_mirror_view(
2025  const DynRankView<T, P...>& src,
2026  [[maybe_unused]] const typename Impl::ViewCtorProp<ViewCtorArgs...>&
2027  arg_prop) {
2028  if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
2029  if constexpr (std::is_same<typename DynRankView<T, P...>::memory_space,
2030  typename DynRankView<
2031  T, P...>::HostMirror::memory_space>::value &&
2032  std::is_same<typename DynRankView<T, P...>::data_type,
2033  typename DynRankView<
2034  T, P...>::HostMirror::data_type>::value) {
2035  return typename DynRankView<T, P...>::HostMirror(src);
2036  } else {
2037  return Kokkos::Impl::choose_create_mirror(src, arg_prop);
2038  }
2039  } else {
2040  if constexpr (Impl::MirrorDRViewType<typename Impl::ViewCtorProp<
2041  ViewCtorArgs...>::memory_space,
2042  T, P...>::is_same_memspace) {
2043  return typename Impl::MirrorDRViewType<
2044  typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
2045  P...>::view_type(src);
2046  } else {
2047  return Kokkos::Impl::choose_create_mirror(src, arg_prop);
2048  }
2049  }
2050 #if defined(KOKKOS_COMPILER_INTEL) || \
2051  (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
2052  !defined(KOKKOS_COMPILER_MSVC))
2053  __builtin_unreachable();
2054 #endif
2055 }
2056 
2057 } // namespace Impl
2058 
2059 // public interface
2060 template <class T, class... P>
2061 inline auto create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
2062  return Impl::create_mirror_view(src, Kokkos::view_alloc());
2063 }
2064 
2065 // public interface that accepts a without initializing flag
2066 template <class T, class... P>
2067 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
2068  const DynRankView<T, P...>& src) {
2069  return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
2070 }
2071 
2072 // public interface that accepts a space
2073 template <class Space, class T, class... P,
2074  class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
2075 inline auto create_mirror_view(const Space&,
2076  const Kokkos::DynRankView<T, P...>& src) {
2077  return Impl::create_mirror_view(
2078  src, Kokkos::view_alloc(typename Space::memory_space()));
2079 }
2080 
2081 // public interface that accepts a space and a without initializing flag
2082 template <class Space, class T, class... P,
2083  typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
2084 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
2085  const Space&,
2086  const Kokkos::DynRankView<T, P...>& src) {
2087  return Impl::create_mirror_view(
2088  src, Kokkos::view_alloc(typename Space::memory_space{}, wi));
2089 }
2090 
2091 // public interface that accepts arbitrary view constructor args passed by a
2092 // view_alloc
2093 template <class T, class... P, class... ViewCtorArgs>
2094 inline auto create_mirror_view(
2095  const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2096  const Kokkos::DynRankView<T, P...>& src) {
2097  return Impl::create_mirror_view(src, arg_prop);
2098 }
2099 
2100 // create a mirror view and deep copy it
2101 // public interface that accepts arbitrary view constructor args passed by a
2102 // view_alloc
2103 template <class... ViewCtorArgs, class T, class... P,
2104  class Enable = std::enable_if_t<
2105  std::is_void<typename ViewTraits<T, P...>::specialize>::value>>
2106 auto create_mirror_view_and_copy(
2107  [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2108  const Kokkos::DynRankView<T, P...>& src) {
2109  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2110 
2111  Impl::check_view_ctor_args_create_mirror_view_and_copy<ViewCtorArgs...>();
2112 
2113  if constexpr (Impl::MirrorDRViewType<
2114  typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
2115  T, P...>::is_same_memspace) {
2116  // same behavior as deep_copy(src, src)
2117  if constexpr (!alloc_prop_input::has_execution_space)
2118  fence(
2119  "Kokkos::create_mirror_view_and_copy: fence before returning src "
2120  "view");
2121  return src;
2122  } else {
2123  using Space = typename alloc_prop_input::memory_space;
2124  using Mirror = typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
2125 
2126  auto arg_prop_copy = Impl::with_properties_if_unset(
2127  arg_prop, std::string{}, WithoutInitializing,
2128  typename Space::execution_space{});
2129 
2130  std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
2131  if (label.empty()) label = src.label();
2132  auto mirror = typename Mirror::non_const_type{
2133  arg_prop_copy, Impl::reconstructLayout(src.layout(), src.rank())};
2134  if constexpr (alloc_prop_input::has_execution_space) {
2135  deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
2136  mirror, src);
2137  } else
2138  deep_copy(mirror, src);
2139  return mirror;
2140  }
2141 #if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
2142  !defined(KOKKOS_COMPILER_MSVC)
2143  __builtin_unreachable();
2144 #endif
2145 }
2146 
2147 template <class Space, class T, class... P>
2148 auto create_mirror_view_and_copy(const Space&,
2149  const Kokkos::DynRankView<T, P...>& src,
2150  std::string const& name = "") {
2151  return create_mirror_view_and_copy(
2152  Kokkos::view_alloc(typename Space::memory_space{}, name), src);
2153 }
2154 
2155 } // namespace Kokkos
2156 
2157 //----------------------------------------------------------------------------
2158 //----------------------------------------------------------------------------
2159 
2160 namespace Kokkos {
2163 template <class... ViewCtorArgs, class T, class... P>
2164 inline void impl_resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2165  DynRankView<T, P...>& v, const size_t n0,
2166  const size_t n1, const size_t n2, const size_t n3,
2167  const size_t n4, const size_t n5, const size_t n6,
2168  const size_t n7) {
2169  using drview_type = DynRankView<T, P...>;
2170  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2171 
2172  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
2173  "Can only resize managed views");
2174  static_assert(!alloc_prop_input::has_label,
2175  "The view constructor arguments passed to Kokkos::resize "
2176  "must not include a label!");
2177  static_assert(!alloc_prop_input::has_pointer,
2178  "The view constructor arguments passed to Kokkos::resize must "
2179  "not include a pointer!");
2180  static_assert(!alloc_prop_input::has_memory_space,
2181  "The view constructor arguments passed to Kokkos::resize must "
2182  "not include a memory space instance!");
2183 
2184  auto prop_copy = Impl::with_properties_if_unset(
2185  arg_prop, v.label(), typename drview_type::execution_space{});
2186 
2187  drview_type v_resized(prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
2188 
2189  if constexpr (alloc_prop_input::has_execution_space)
2190  Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(
2191  Impl::get_property<Impl::ExecutionSpaceTag>(prop_copy), v_resized, v);
2192  else {
2193  Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(v_resized, v);
2194  Kokkos::fence("Kokkos::resize(DynRankView)");
2195  }
2196  v = v_resized;
2197 }
2198 
2199 template <class T, class... P>
2200 inline void resize(DynRankView<T, P...>& v,
2201  const size_t n0 = KOKKOS_INVALID_INDEX,
2202  const size_t n1 = KOKKOS_INVALID_INDEX,
2203  const size_t n2 = KOKKOS_INVALID_INDEX,
2204  const size_t n3 = KOKKOS_INVALID_INDEX,
2205  const size_t n4 = KOKKOS_INVALID_INDEX,
2206  const size_t n5 = KOKKOS_INVALID_INDEX,
2207  const size_t n6 = KOKKOS_INVALID_INDEX,
2208  const size_t n7 = KOKKOS_INVALID_INDEX) {
2209  impl_resize(Impl::ViewCtorProp<>{}, v, n0, n1, n2, n3, n4, n5, n6, n7);
2210 }
2211 
2212 template <class... ViewCtorArgs, class T, class... P>
2213 void resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2214  DynRankView<T, P...>& v,
2215  const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2216  const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2217  const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2218  const size_t n3 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2219  const size_t n4 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2220  const size_t n5 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2221  const size_t n6 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
2222  const size_t n7 = KOKKOS_IMPL_CTOR_DEFAULT_ARG) {
2223  impl_resize(arg_prop, v, n0, n1, n2, n3, n4, n5, n6, n7);
2224 }
2225 
2226 template <class I, class T, class... P>
2227 inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> resize(
2228  const I& arg_prop, DynRankView<T, P...>& v,
2229  const size_t n0 = KOKKOS_INVALID_INDEX,
2230  const size_t n1 = KOKKOS_INVALID_INDEX,
2231  const size_t n2 = KOKKOS_INVALID_INDEX,
2232  const size_t n3 = KOKKOS_INVALID_INDEX,
2233  const size_t n4 = KOKKOS_INVALID_INDEX,
2234  const size_t n5 = KOKKOS_INVALID_INDEX,
2235  const size_t n6 = KOKKOS_INVALID_INDEX,
2236  const size_t n7 = KOKKOS_INVALID_INDEX) {
2237  impl_resize(Kokkos::view_alloc(arg_prop), v, n0, n1, n2, n3, n4, n5, n6, n7);
2238 }
2239 
2242 template <class... ViewCtorArgs, class T, class... P>
2243 inline void impl_realloc(DynRankView<T, P...>& v, const size_t n0,
2244  const size_t n1, const size_t n2, const size_t n3,
2245  const size_t n4, const size_t n5, const size_t n6,
2246  const size_t n7,
2247  const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
2248  using drview_type = DynRankView<T, P...>;
2249  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
2250 
2251  static_assert(Kokkos::ViewTraits<T, P...>::is_managed,
2252  "Can only realloc managed views");
2253  static_assert(!alloc_prop_input::has_label,
2254  "The view constructor arguments passed to Kokkos::realloc must "
2255  "not include a label!");
2256  static_assert(!alloc_prop_input::has_pointer,
2257  "The view constructor arguments passed to Kokkos::realloc must "
2258  "not include a pointer!");
2259  static_assert(!alloc_prop_input::has_memory_space,
2260  "The view constructor arguments passed to Kokkos::realloc must "
2261  "not include a memory space instance!");
2262 
2263  auto arg_prop_copy = Impl::with_properties_if_unset(arg_prop, v.label());
2264 
2265  v = drview_type(); // Deallocate first, if the only view to allocation
2266  v = drview_type(arg_prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
2267 }
2268 
2269 template <class T, class... P, class... ViewCtorArgs>
2270 inline void realloc(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
2271  DynRankView<T, P...>& v,
2272  const size_t n0 = KOKKOS_INVALID_INDEX,
2273  const size_t n1 = KOKKOS_INVALID_INDEX,
2274  const size_t n2 = KOKKOS_INVALID_INDEX,
2275  const size_t n3 = KOKKOS_INVALID_INDEX,
2276  const size_t n4 = KOKKOS_INVALID_INDEX,
2277  const size_t n5 = KOKKOS_INVALID_INDEX,
2278  const size_t n6 = KOKKOS_INVALID_INDEX,
2279  const size_t n7 = KOKKOS_INVALID_INDEX) {
2280  impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, arg_prop);
2281 }
2282 
2283 template <class T, class... P>
2284 inline void realloc(DynRankView<T, P...>& v,
2285  const size_t n0 = KOKKOS_INVALID_INDEX,
2286  const size_t n1 = KOKKOS_INVALID_INDEX,
2287  const size_t n2 = KOKKOS_INVALID_INDEX,
2288  const size_t n3 = KOKKOS_INVALID_INDEX,
2289  const size_t n4 = KOKKOS_INVALID_INDEX,
2290  const size_t n5 = KOKKOS_INVALID_INDEX,
2291  const size_t n6 = KOKKOS_INVALID_INDEX,
2292  const size_t n7 = KOKKOS_INVALID_INDEX) {
2293  impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Impl::ViewCtorProp<>{});
2294 }
2295 
2296 template <class I, class T, class... P>
2297 inline std::enable_if_t<Impl::is_view_ctor_property<I>::value> realloc(
2298  const I& arg_prop, DynRankView<T, P...>& v,
2299  const size_t n0 = KOKKOS_INVALID_INDEX,
2300  const size_t n1 = KOKKOS_INVALID_INDEX,
2301  const size_t n2 = KOKKOS_INVALID_INDEX,
2302  const size_t n3 = KOKKOS_INVALID_INDEX,
2303  const size_t n4 = KOKKOS_INVALID_INDEX,
2304  const size_t n5 = KOKKOS_INVALID_INDEX,
2305  const size_t n6 = KOKKOS_INVALID_INDEX,
2306  const size_t n7 = KOKKOS_INVALID_INDEX) {
2307  impl_realloc(v, n0, n1, n2, n3, n4, n5, n6, n7, Kokkos::view_alloc(arg_prop));
2308 }
2309 
2310 } // namespace Kokkos
2311 
2312 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
2313 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
2314 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNRANKVIEW
2315 #endif
2316 #endif
Kokkos::LayoutLeft
Memory layout tag indicating left-to-right (Fortran scheme) striding of multi-indices.
Definition: Kokkos_Layout.hpp:50
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::LayoutStride
Memory layout tag indicated arbitrarily strided multi-index mapping into contiguous memory...
Definition: Kokkos_Layout.hpp:138
Kokkos::View
View to an array of data.
Definition: Kokkos_Core_fwd.hpp:279
Kokkos::HostSpace
Memory management for host memory.
Definition: Kokkos_HostSpace.hpp:49
Kokkos::LayoutRight
Memory layout tag indicating right-to-left (C or lexigraphical scheme) striding of multi-indices...
Definition: Kokkos_Layout.hpp:99
Kokkos::Impl::ViewToDynRankViewTag
Assign compatible default mappings.
Definition: Kokkos_DynRankView.hpp:278
Kokkos::RangePolicy
Execution policy for work over a range of an integral type.
Definition: Kokkos_ExecPolicy.hpp:73
Kokkos::ViewTraits
Traits class for accessing attributes of a View.
Definition: Kokkos_View.hpp:174
Generated on Fri Nov 22 2024 09:17:42 for Kokkos Core Kernels Package by   doxygen 1.8.5