8 #ifndef KOKKOS_OFFSETVIEW_HPP_ 9 #define KOKKOS_OFFSETVIEW_HPP_ 11 #include <Kokkos_Core.hpp> 13 #include <Kokkos_View.hpp> 21 template <
class DataType,
class... Properties>
25 struct is_offset_view :
public std::false_type {};
27 template <
class D,
class... P>
28 struct is_offset_view<OffsetView<D, P...> > :
public std::true_type {};
30 template <
class D,
class... P>
31 struct is_offset_view<const OffsetView<D, P...> > :
public std::true_type {};
33 #define KOKKOS_INVALID_OFFSET int64_t(0x7FFFFFFFFFFFFFFFLL) 34 #define KOKKOS_INVALID_INDEX_RANGE \ 35 { KOKKOS_INVALID_OFFSET, KOKKOS_INVALID_OFFSET } 37 template <
typename iType,
38 typename std::enable_if<std::is_integral<iType>::value &&
39 std::is_signed<iType>::value,
43 using index_list_type = std::initializer_list<int64_t>;
52 template <
class ViewType>
53 struct GetOffsetViewTypeFromViewType {
55 OffsetView<
typename ViewType::data_type,
typename ViewType::array_layout,
56 typename ViewType::device_type,
57 typename ViewType::memory_traits>;
60 template <
unsigned,
class MapType,
class BeginsType>
61 KOKKOS_INLINE_FUNCTION
bool offsetview_verify_operator_bounds(
62 const MapType&,
const BeginsType&) {
66 template <
unsigned R,
class MapType,
class BeginsType,
class iType,
68 KOKKOS_INLINE_FUNCTION
bool offsetview_verify_operator_bounds(
69 const MapType& map,
const BeginsType& begins,
const iType& i,
71 const bool legalIndex =
72 (int64_t(i) >= begins[R]) &&
73 (int64_t(i) <= int64_t(begins[R] + map.extent(R) - 1));
75 offsetview_verify_operator_bounds<R + 1>(map, begins, args...);
77 template <
unsigned,
class MapType,
class BeginsType>
78 inline void offsetview_error_operator_bounds(
char*,
int,
const MapType&,
81 template <
unsigned R,
class MapType,
class BeginsType,
class iType,
83 inline void offsetview_error_operator_bounds(
char* buf,
int len,
85 const BeginsType begins,
86 const iType& i, Args... args) {
87 const int64_t b = begins[R];
88 const int64_t e = b + map.extent(R) - 1;
90 snprintf(buf, len,
" %ld <= %ld <= %ld %c", static_cast<unsigned long>(b),
91 static_cast<unsigned long>(i), static_cast<unsigned long>(e),
92 (
sizeof...(Args) ?
',' :
')'));
93 offsetview_error_operator_bounds<R + 1>(buf + n, len - n, map, begins,
97 template <
class MemorySpace,
class MapType,
class BeginsType,
class... Args>
98 KOKKOS_INLINE_FUNCTION
void offsetview_verify_operator_bounds(
99 Kokkos::Impl::SharedAllocationTracker
const& tracker,
const MapType& map,
100 const BeginsType& begins, Args... args) {
101 if (!offsetview_verify_operator_bounds<0>(map, begins, args...)) {
102 #if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST) 105 const std::string label = tracker.template get_label<MemorySpace>();
107 snprintf(buffer, LEN,
"OffsetView bounds error of view labeled %s (",
109 offsetview_error_operator_bounds<0>(buffer + n, LEN - n, map, begins,
111 Kokkos::Impl::throw_runtime_exception(std::string(buffer));
118 if (tracker.has_record()) {
119 Kokkos::Impl::operator_bounds_error_on_device<MapType>(
120 map, Kokkos::Impl::has_printable_label_typedef<MapType>());
122 Kokkos::abort(
"OffsetView bounds error");
128 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 129 KOKKOS_INLINE_FUNCTION
130 void runtime_check_rank_host(
const size_t rank_dynamic,
const size_t rank,
131 const index_list_type minIndices,
132 const std::string& label) {
134 std::string message =
135 "Kokkos::Experimental::OffsetView ERROR: for OffsetView labeled '" +
137 if (rank_dynamic != rank) {
139 "The full rank must be the same as the dynamic rank. full rank = ";
140 message += std::to_string(rank) +
141 " dynamic rank = " + std::to_string(rank_dynamic) +
"\n";
145 size_t numOffsets = 0;
146 for (
size_t i = 0; i < minIndices.size(); ++i) {
147 if (minIndices.begin()[i] != KOKKOS_INVALID_OFFSET) numOffsets++;
149 if (numOffsets != rank_dynamic) {
150 message +=
"The number of offsets provided ( " +
151 std::to_string(numOffsets) +
152 " ) must equal the dynamic rank ( " +
153 std::to_string(rank_dynamic) +
" ).";
157 if (isBad) Kokkos::abort(message.c_str());
161 KOKKOS_INLINE_FUNCTION
162 void runtime_check_rank_device(
const size_t rank_dynamic,
const size_t rank,
163 const index_list_type minIndices) {
164 if (rank_dynamic != rank) {
166 "The full rank of an OffsetView must be the same as the dynamic rank.");
168 size_t numOffsets = 0;
169 for (
size_t i = 0; i < minIndices.size(); ++i) {
170 if (minIndices.begin()[i] != KOKKOS_INVALID_OFFSET) numOffsets++;
172 if (numOffsets != rank) {
174 "The number of offsets provided to an OffsetView constructor must " 175 "equal the dynamic rank.");
180 template <
class DataType,
class... Properties>
181 class OffsetView :
public ViewTraits<DataType, Properties...> {
183 using traits = ViewTraits<DataType, Properties...>;
186 template <
class,
class...>
187 friend class OffsetView;
188 template <
class,
class...>
190 template <
class,
class...>
191 friend class Kokkos::Impl::ViewMapping;
193 using map_type = Kokkos::Impl::ViewMapping<traits, void>;
194 using track_type = Kokkos::Impl::SharedAllocationTracker;
197 enum { Rank = map_type::Rank };
202 typename std::enable_if<std::is_integral<iType>::value, iType>::type = 0>
203 KOKKOS_INLINE_FUNCTION int64_t begin(
const iType local_dimension)
const {
204 return local_dimension < Rank ? m_begins[local_dimension]
205 : KOKKOS_INVALID_OFFSET;
208 KOKKOS_INLINE_FUNCTION
209 begins_type begins()
const {
return m_begins; }
213 typename std::enable_if<std::is_integral<iType>::value, iType>::type = 0>
214 KOKKOS_INLINE_FUNCTION int64_t end(
const iType local_dimension)
const {
215 return begin(local_dimension) + m_map.extent(local_dimension);
221 begins_type m_begins;
227 OffsetView<
typename traits::scalar_array_type,
228 typename traits::array_layout,
typename traits::device_type,
229 typename traits::memory_traits>;
233 OffsetView<
typename traits::const_data_type,
234 typename traits::array_layout,
typename traits::device_type,
235 typename traits::memory_traits>;
238 using non_const_type =
239 OffsetView<
typename traits::non_const_data_type,
240 typename traits::array_layout,
typename traits::device_type,
241 typename traits::memory_traits>;
244 using HostMirror = OffsetView<
typename traits::non_const_data_type,
245 typename traits::array_layout,
246 typename traits::host_mirror_space>;
257 template <
typename iType>
258 KOKKOS_INLINE_FUNCTION constexpr
259 typename std::enable_if<std::is_integral<iType>::value,
size_t>::type
260 extent(
const iType& r)
const {
261 return m_map.extent(r);
264 template <
typename iType>
265 KOKKOS_INLINE_FUNCTION constexpr
266 typename std::enable_if<std::is_integral<iType>::value,
int>::type
267 extent_int(
const iType& r)
const {
268 return static_cast<int>(m_map.extent(r));
271 KOKKOS_INLINE_FUNCTION constexpr
typename traits::array_layout layout()
273 return m_map.layout();
276 KOKKOS_INLINE_FUNCTION constexpr
size_t size()
const {
277 return m_map.dimension_0() * m_map.dimension_1() * m_map.dimension_2() *
278 m_map.dimension_3() * m_map.dimension_4() * m_map.dimension_5() *
279 m_map.dimension_6() * m_map.dimension_7();
282 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_0()
const {
283 return m_map.stride_0();
285 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_1()
const {
286 return m_map.stride_1();
288 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_2()
const {
289 return m_map.stride_2();
291 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_3()
const {
292 return m_map.stride_3();
294 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_4()
const {
295 return m_map.stride_4();
297 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_5()
const {
298 return m_map.stride_5();
300 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_6()
const {
301 return m_map.stride_6();
303 KOKKOS_INLINE_FUNCTION constexpr
size_t stride_7()
const {
304 return m_map.stride_7();
307 template <
typename iType>
308 KOKKOS_INLINE_FUNCTION constexpr
309 typename std::enable_if<std::is_integral<iType>::value,
size_t>::type
310 stride(iType r)
const {
326 : m_map.stride_7())))))));
329 template <
typename iType>
330 KOKKOS_INLINE_FUNCTION
void stride(iType*
const s)
const {
337 using reference_type =
typename map_type::reference_type;
338 using pointer_type =
typename map_type::pointer_type;
341 reference_type_is_lvalue_reference =
342 std::is_lvalue_reference<reference_type>::value
345 KOKKOS_INLINE_FUNCTION constexpr
size_t span()
const {
return m_map.span(); }
346 KOKKOS_INLINE_FUNCTION
bool span_is_contiguous()
const {
347 return m_map.span_is_contiguous();
349 KOKKOS_INLINE_FUNCTION constexpr
bool is_allocated()
const {
350 return m_map.data() !=
nullptr;
352 KOKKOS_INLINE_FUNCTION constexpr pointer_type data()
const {
359 KOKKOS_INLINE_FUNCTION
360 const Kokkos::Impl::ViewMapping<traits, void>& implementation_map()
const {
367 static constexpr
bool is_layout_left =
368 std::is_same<typename traits::array_layout, Kokkos::LayoutLeft>::value;
370 static constexpr
bool is_layout_right =
371 std::is_same<typename traits::array_layout, Kokkos::LayoutRight>::value;
373 static constexpr
bool is_layout_stride =
374 std::is_same<typename traits::array_layout, Kokkos::LayoutStride>::value;
376 static constexpr
bool is_default_map =
377 std::is_same<typename traits::specialize, void>::value &&
378 (is_layout_left || is_layout_right || is_layout_stride);
380 #if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK) 382 #define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(ARG) \ 383 Kokkos::Impl::verify_space<Kokkos::Impl::ActiveExecutionMemorySpace, \ 384 typename traits::memory_space>::check(); \ 385 Kokkos::Experimental::Impl::offsetview_verify_operator_bounds< \ 386 typename traits::memory_space> \ 391 #define KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(ARG) \ 392 Kokkos::Impl::verify_space<Kokkos::Impl::ActiveExecutionMemorySpace, \ 393 typename traits::memory_space>::check(); 400 KOKKOS_FORCEINLINE_FUNCTION
401 reference_type operator()()
const {
return m_map.reference(); }
405 template <
typename I0>
406 KOKKOS_FORCEINLINE_FUNCTION
407 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
408 (1 == Rank) && !is_default_map),
409 reference_type>::type
410 operator()(
const I0& i0)
const {
411 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
412 const size_t j0 = i0 - m_begins[0];
413 return m_map.reference(j0);
416 template <
typename I0>
417 KOKKOS_FORCEINLINE_FUNCTION
418 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
419 (1 == Rank) && is_default_map &&
421 reference_type>::type
422 operator()(
const I0& i0)
const {
423 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
424 const size_t j0 = i0 - m_begins[0];
425 return m_map.m_impl_handle[j0];
428 template <
typename I0>
429 KOKKOS_FORCEINLINE_FUNCTION
430 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
431 (1 == Rank) && is_default_map &&
433 reference_type>::type
434 operator()(
const I0& i0)
const {
435 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
436 const size_t j0 = i0 - m_begins[0];
437 return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * j0];
442 template <
typename I0>
443 KOKKOS_FORCEINLINE_FUNCTION
444 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
445 (1 == Rank) && !is_default_map),
446 reference_type>::type
447 operator[](
const I0& i0)
const {
448 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
449 const size_t j0 = i0 - m_begins[0];
450 return m_map.reference(j0);
453 template <
typename I0>
454 KOKKOS_FORCEINLINE_FUNCTION
455 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
456 (1 == Rank) && is_default_map &&
458 reference_type>::type
459 operator[](
const I0& i0)
const {
460 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
461 const size_t j0 = i0 - m_begins[0];
462 return m_map.m_impl_handle[j0];
465 template <
typename I0>
466 KOKKOS_FORCEINLINE_FUNCTION
467 typename std::enable_if<(Kokkos::Impl::are_integral<I0>::value &&
468 (1 == Rank) && is_default_map &&
470 reference_type>::type
471 operator[](
const I0& i0)
const {
472 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0))
473 const size_t j0 = i0 - m_begins[0];
474 return m_map.m_impl_handle[m_map.m_impl_offset.m_stride.S0 * j0];
480 template <
typename I0,
typename I1>
481 KOKKOS_FORCEINLINE_FUNCTION
482 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
483 (2 == Rank) && !is_default_map),
484 reference_type>::type
485 operator()(
const I0& i0,
const I1& i1)
const {
486 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
487 const size_t j0 = i0 - m_begins[0];
488 const size_t j1 = i1 - m_begins[1];
489 return m_map.reference(j0, j1);
492 template <
typename I0,
typename I1>
493 KOKKOS_FORCEINLINE_FUNCTION
494 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
495 (2 == Rank) && is_default_map &&
496 is_layout_left && (traits::rank_dynamic == 0)),
497 reference_type>::type
498 operator()(
const I0& i0,
const I1& i1)
const {
499 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
500 const size_t j0 = i0 - m_begins[0];
501 const size_t j1 = i1 - m_begins[1];
502 return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_dim.N0 * j1];
505 template <
typename I0,
typename I1>
506 KOKKOS_FORCEINLINE_FUNCTION
507 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
508 (2 == Rank) && is_default_map &&
509 is_layout_left && (traits::rank_dynamic != 0)),
510 reference_type>::type
511 operator()(
const I0& i0,
const I1& i1)
const {
512 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
513 const size_t j0 = i0 - m_begins[0];
514 const size_t j1 = i1 - m_begins[1];
515 return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_stride * j1];
518 template <
typename I0,
typename I1>
519 KOKKOS_FORCEINLINE_FUNCTION
520 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
521 (2 == Rank) && is_default_map &&
522 is_layout_right && (traits::rank_dynamic == 0)),
523 reference_type>::type
524 operator()(
const I0& i0,
const I1& i1)
const {
525 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
526 const size_t j0 = i0 - m_begins[0];
527 const size_t j1 = i1 - m_begins[1];
528 return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_dim.N1 * j0];
531 template <
typename I0,
typename I1>
532 KOKKOS_FORCEINLINE_FUNCTION
533 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
534 (2 == Rank) && is_default_map &&
535 is_layout_right && (traits::rank_dynamic != 0)),
536 reference_type>::type
537 operator()(
const I0& i0,
const I1& i1)
const {
538 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
539 const size_t j0 = i0 - m_begins[0];
540 const size_t j1 = i1 - m_begins[1];
541 return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_stride * j0];
544 template <
typename I0,
typename I1>
545 KOKKOS_FORCEINLINE_FUNCTION
546 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1>::value &&
547 (2 == Rank) && is_default_map &&
549 reference_type>::type
550 operator()(
const I0& i0,
const I1& i1)
const {
551 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
552 const size_t j0 = i0 - m_begins[0];
553 const size_t j1 = i1 - m_begins[1];
554 return m_map.m_impl_handle[j0 * m_map.m_impl_offset.m_stride.S0 +
555 j1 * m_map.m_impl_offset.m_stride.S1];
561 template <
typename I0,
typename I1,
typename I2>
562 KOKKOS_FORCEINLINE_FUNCTION
563 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
564 (3 == Rank) && is_default_map),
565 reference_type>::type
566 operator()(
const I0& i0,
const I1& i1,
const I2& i2)
const {
567 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
568 (m_track, m_map, m_begins, i0, i1, i2))
569 const size_t j0 = i0 - m_begins[0];
570 const size_t j1 = i1 - m_begins[1];
571 const size_t j2 = i2 - m_begins[2];
572 return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2)];
575 template <
typename I0,
typename I1,
typename I2>
576 KOKKOS_FORCEINLINE_FUNCTION
577 typename std::enable_if<(Kokkos::Impl::are_integral<I0, I1, I2>::value &&
578 (3 == Rank) && !is_default_map),
579 reference_type>::type
580 operator()(
const I0& i0,
const I1& i1,
const I2& i2)
const {
581 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
582 (m_track, m_map, m_begins, i0, i1, i2))
583 const size_t j0 = i0 - m_begins[0];
584 const size_t j1 = i1 - m_begins[1];
585 const size_t j2 = i2 - m_begins[2];
586 return m_map.reference(j0, j1, j2);
592 template <
typename I0,
typename I1,
typename I2,
typename I3>
593 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
594 (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
596 reference_type>::type
597 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3)
const {
598 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
599 (m_track, m_map, m_begins, i0, i1, i2, i3))
600 const size_t j0 = i0 - m_begins[0];
601 const size_t j1 = i1 - m_begins[1];
602 const size_t j2 = i2 - m_begins[2];
603 const size_t j3 = i3 - m_begins[3];
604 return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3)];
607 template <
typename I0,
typename I1,
typename I2,
typename I3>
608 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
609 (Kokkos::Impl::are_integral<I0, I1, I2, I3>::value && (4 == Rank) &&
611 reference_type>::type
612 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3)
const {
613 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
614 (m_track, m_map, m_begins, i0, i1, i2, i3))
615 const size_t j0 = i0 - m_begins[0];
616 const size_t j1 = i1 - m_begins[1];
617 const size_t j2 = i2 - m_begins[2];
618 const size_t j3 = i3 - m_begins[3];
619 return m_map.reference(j0, j1, j2, j3);
625 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4>
626 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
627 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
629 reference_type>::type
630 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
631 const I4& i4)
const {
632 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
633 (m_track, m_map, m_begins, i0, i1, i2, i3, i4))
634 const size_t j0 = i0 - m_begins[0];
635 const size_t j1 = i1 - m_begins[1];
636 const size_t j2 = i2 - m_begins[2];
637 const size_t j3 = i3 - m_begins[3];
638 const size_t j4 = i4 - m_begins[4];
639 return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4)];
642 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4>
643 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
644 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4>::value && (5 == Rank) &&
646 reference_type>::type
647 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
648 const I4& i4)
const {
649 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
650 (m_track, m_map, m_begins, i0, i1, i2, i3, i4))
651 const size_t j0 = i0 - m_begins[0];
652 const size_t j1 = i1 - m_begins[1];
653 const size_t j2 = i2 - m_begins[2];
654 const size_t j3 = i3 - m_begins[3];
655 const size_t j4 = i4 - m_begins[4];
656 return m_map.reference(j0, j1, j2, j3, j4);
662 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
664 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
665 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
666 (6 == Rank) && is_default_map),
667 reference_type>::type
668 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
669 const I4& i4,
const I5& i5)
const {
670 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
671 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5))
672 const size_t j0 = i0 - m_begins[0];
673 const size_t j1 = i1 - m_begins[1];
674 const size_t j2 = i2 - m_begins[2];
675 const size_t j3 = i3 - m_begins[3];
676 const size_t j4 = i4 - m_begins[4];
677 const size_t j5 = i5 - m_begins[5];
678 return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5)];
681 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
683 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
684 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5>::value &&
685 (6 == Rank) && !is_default_map),
686 reference_type>::type
687 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
688 const I4& i4,
const I5& i5)
const {
689 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
690 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5))
691 const size_t j0 = i0 - m_begins[0];
692 const size_t j1 = i1 - m_begins[1];
693 const size_t j2 = i2 - m_begins[2];
694 const size_t j3 = i3 - m_begins[3];
695 const size_t j4 = i4 - m_begins[4];
696 const size_t j5 = i5 - m_begins[5];
697 return m_map.reference(j0, j1, j2, j3, j4, j5);
703 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
704 typename I5,
typename I6>
705 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
706 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
707 (7 == Rank) && is_default_map),
708 reference_type>::type
709 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
710 const I4& i4,
const I5& i5,
const I6& i6)
const {
711 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
712 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6))
713 const size_t j0 = i0 - m_begins[0];
714 const size_t j1 = i1 - m_begins[1];
715 const size_t j2 = i2 - m_begins[2];
716 const size_t j3 = i3 - m_begins[3];
717 const size_t j4 = i4 - m_begins[4];
718 const size_t j5 = i5 - m_begins[5];
719 const size_t j6 = i6 - m_begins[6];
720 return m_map.m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5, j6)];
723 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
724 typename I5,
typename I6>
725 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
726 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6>::value &&
727 (7 == Rank) && !is_default_map),
728 reference_type>::type
729 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
730 const I4& i4,
const I5& i5,
const I6& i6)
const {
731 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
732 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6))
733 const size_t j0 = i0 - m_begins[0];
734 const size_t j1 = i1 - m_begins[1];
735 const size_t j2 = i2 - m_begins[2];
736 const size_t j3 = i3 - m_begins[3];
737 const size_t j4 = i4 - m_begins[4];
738 const size_t j5 = i5 - m_begins[5];
739 const size_t j6 = i6 - m_begins[6];
740 return m_map.reference(j0, j1, j2, j3, j4, j5, j6);
746 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
747 typename I5,
typename I6,
typename I7>
748 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
749 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
750 (8 == Rank) && is_default_map),
751 reference_type>::type
752 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
753 const I4& i4,
const I5& i5,
const I6& i6,
const I7& i7)
const {
754 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
755 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6, i7))
756 const size_t j0 = i0 - m_begins[0];
757 const size_t j1 = i1 - m_begins[1];
758 const size_t j2 = i2 - m_begins[2];
759 const size_t j3 = i3 - m_begins[3];
760 const size_t j4 = i4 - m_begins[4];
761 const size_t j5 = i5 - m_begins[5];
762 const size_t j6 = i6 - m_begins[6];
763 const size_t j7 = i7 - m_begins[7];
765 .m_impl_handle[m_map.m_impl_offset(j0, j1, j2, j3, j4, j5, j6, j7)];
768 template <
typename I0,
typename I1,
typename I2,
typename I3,
typename I4,
769 typename I5,
typename I6,
typename I7>
770 KOKKOS_FORCEINLINE_FUNCTION
typename std::enable_if<
771 (Kokkos::Impl::are_integral<I0, I1, I2, I3, I4, I5, I6, I7>::value &&
772 (8 == Rank) && !is_default_map),
773 reference_type>::type
774 operator()(
const I0& i0,
const I1& i1,
const I2& i2,
const I3& i3,
775 const I4& i4,
const I5& i5,
const I6& i6,
const I7& i7)
const {
776 KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY(
777 (m_track, m_map, m_begins, i0, i1, i2, i3, i4, i5, i6, i7))
778 const size_t j0 = i0 - m_begins[0];
779 const size_t j1 = i1 - m_begins[1];
780 const size_t j2 = i2 - m_begins[2];
781 const size_t j3 = i3 - m_begins[3];
782 const size_t j4 = i4 - m_begins[4];
783 const size_t j5 = i5 - m_begins[5];
784 const size_t j6 = i6 - m_begins[6];
785 const size_t j7 = i7 - m_begins[7];
786 return m_map.reference(j0, j1, j2, j3, j4, j5, j6, j7);
789 #undef KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY 794 KOKKOS_DEFAULTED_FUNCTION
795 ~OffsetView() =
default;
797 KOKKOS_INLINE_FUNCTION
798 OffsetView() : m_track(), m_map() {
799 for (
size_t i = 0; i < Rank; ++i) m_begins[i] = KOKKOS_INVALID_OFFSET;
802 KOKKOS_INLINE_FUNCTION
803 OffsetView(
const OffsetView& rhs)
804 : m_track(rhs.m_track, traits::is_managed),
806 m_begins(rhs.m_begins) {}
808 KOKKOS_INLINE_FUNCTION
809 OffsetView(OffsetView&& rhs)
810 : m_track(std::move(rhs.m_track)),
811 m_map(std::move(rhs.m_map)),
812 m_begins(std::move(rhs.m_begins)) {}
814 KOKKOS_INLINE_FUNCTION
815 OffsetView& operator=(
const OffsetView& rhs) {
816 m_track = rhs.m_track;
818 m_begins = rhs.m_begins;
822 KOKKOS_INLINE_FUNCTION
823 OffsetView& operator=(OffsetView&& rhs) {
824 m_track = std::move(rhs.m_track);
825 m_map = std::move(rhs.m_map);
826 m_begins = std::move(rhs.m_begins);
833 View<
typename traits::scalar_array_type,
typename traits::array_layout,
834 typename traits::device_type,
typename traits::memory_traits>;
837 KOKKOS_INLINE_FUNCTION
838 view_type view()
const {
839 view_type v(m_track, m_map);
843 template <
class RT,
class... RP>
844 KOKKOS_INLINE_FUNCTION OffsetView(
const View<RT, RP...>& aview)
845 : m_track(aview.impl_track()), m_map() {
846 using SrcTraits =
typename OffsetView<RT, RP...>::traits;
847 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits, void>;
848 static_assert(Mapping::is_assignable,
849 "Incompatible OffsetView copy construction");
850 Mapping::assign(m_map, aview.impl_map(), m_track);
852 for (
int i = 0; i < aview.Rank; ++i) {
857 template <
class RT,
class... RP>
858 KOKKOS_INLINE_FUNCTION OffsetView(
const View<RT, RP...>& aview,
859 const index_list_type& minIndices)
860 : m_track(aview.impl_track()), m_map() {
861 using SrcTraits =
typename OffsetView<RT, RP...>::traits;
862 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits, void>;
863 static_assert(Mapping::is_assignable,
864 "Incompatible OffsetView copy construction");
865 Mapping::assign(m_map, aview.impl_map(), m_track);
867 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 868 Kokkos::Experimental::Impl::runtime_check_rank_host(
869 traits::rank_dynamic, Rank, minIndices, label());
871 Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic,
876 for (
size_t i = 0; i < minIndices.size(); ++i) {
877 m_begins[i] = minIndices.begin()[i];
880 template <
class RT,
class... RP>
881 KOKKOS_INLINE_FUNCTION OffsetView(
const View<RT, RP...>& aview,
882 const begins_type& beg)
883 : m_track(aview.impl_track()), m_map(), m_begins(beg) {
884 using SrcTraits =
typename OffsetView<RT, RP...>::traits;
885 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits, void>;
886 static_assert(Mapping::is_assignable,
887 "Incompatible OffsetView copy construction");
888 Mapping::assign(m_map, aview.impl_map(), m_track);
902 template <
class RT,
class... RP>
903 KOKKOS_INLINE_FUNCTION OffsetView(
const OffsetView<RT, RP...>& rhs)
904 : m_track(rhs.m_track, traits::is_managed),
906 m_begins(rhs.m_begins) {
907 using SrcTraits =
typename OffsetView<RT, RP...>::traits;
908 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits, void>;
909 static_assert(Mapping::is_assignable,
910 "Incompatible OffsetView copy construction");
911 Mapping::assign(m_map, rhs.m_map, rhs.m_track);
915 enum class subtraction_failure {
922 KOKKOS_INLINE_FUNCTION
static subtraction_failure check_subtraction(
923 int64_t lhs, int64_t rhs) {
924 if (lhs < rhs)
return subtraction_failure::negative;
926 if (static_cast<uint64_t>(-1) / static_cast<uint64_t>(2) <
927 static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs))
928 return subtraction_failure::overflow;
930 return subtraction_failure::none;
937 KOKKOS_INLINE_FUNCTION
938 static int64_t at(
const begins_type& a,
size_t pos) {
return a[pos]; }
940 KOKKOS_INLINE_FUNCTION
941 static int64_t at(index_list_type a,
size_t pos) {
942 return *(a.begin() + pos);
945 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 948 template <
typename B,
typename E>
949 KOKKOS_INLINE_FUNCTION
static subtraction_failure
950 runtime_check_begins_ends_host(
const B& begins,
const E& ends) {
952 if (begins.size() != Rank)
956 std::to_string(begins.size()) +
960 std::to_string(Rank) +
964 if (ends.size() != Rank)
968 std::to_string(begins.size()) +
972 std::to_string(Rank) +
978 size_t rank = begins.size() < ends.size() ? begins.size() : ends.size();
979 for (
size_t i = 0; i != rank; ++i) {
980 subtraction_failure sf = check_subtraction(at(ends, i), at(begins, i));
981 if (sf != subtraction_failure::none) {
989 std::to_string(at(ends, i)) +
997 std::to_string(at(begins, i)) +
1001 case subtraction_failure::negative:
1002 message +=
" must be non-negative\n";
1004 case subtraction_failure::overflow: message +=
" overflows\n";
break;
1010 if (!message.empty()) {
1012 "Kokkos::Experimental::OffsetView ERROR: for unmanaged OffsetView\n" +
1014 Kokkos::Impl::throw_runtime_exception(message);
1017 return subtraction_failure::none;
1019 #endif // KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1022 template <
typename B,
typename E>
1023 KOKKOS_INLINE_FUNCTION
static subtraction_failure
1024 runtime_check_begins_ends_device(
const B& begins,
const E& ends) {
1025 if (begins.size() != Rank)
1027 "Kokkos::Experimental::OffsetView ERROR: for unmanaged " 1028 "OffsetView: begins has bad Rank");
1029 if (ends.size() != Rank)
1031 "Kokkos::Experimental::OffsetView ERROR: for unmanaged " 1032 "OffsetView: ends has bad Rank");
1034 for (
size_t i = 0; i != begins.size(); ++i) {
1035 switch (check_subtraction(at(ends, i), at(begins, i))) {
1036 case subtraction_failure::negative:
1038 "Kokkos::Experimental::OffsetView ERROR: for unmanaged " 1039 "OffsetView: bad range");
1041 case subtraction_failure::overflow:
1043 "Kokkos::Experimental::OffsetView ERROR: for unmanaged " 1044 "OffsetView: range overflows");
1050 return subtraction_failure::none;
1057 template <
typename B,
typename E>
1058 KOKKOS_INLINE_FUNCTION OffsetView(
const pointer_type& p,
const B& begins_,
1060 subtraction_failure)
1063 m_map(
Kokkos::Impl::ViewCtorProp<pointer_type>(p),
1064 typename traits::array_layout(
1065 Rank > 0 ? at(ends_, 0) - at(begins_, 0) : 0,
1066 Rank > 1 ? at(ends_, 1) - at(begins_, 1) : 0,
1067 Rank > 2 ? at(ends_, 2) - at(begins_, 2) : 0,
1068 Rank > 3 ? at(ends_, 3) - at(begins_, 3) : 0,
1069 Rank > 4 ? at(ends_, 4) - at(begins_, 4) : 0,
1070 Rank > 5 ? at(ends_, 5) - at(begins_, 5) : 0,
1071 Rank > 6 ? at(ends_, 6) - at(begins_, 6) : 0,
1072 Rank > 7 ? at(ends_, 7) - at(begins_, 7) : 0)) {
1073 for (
size_t i = 0; i != m_begins.size(); ++i) {
1074 m_begins[i] = at(begins_, i);
1082 KOKKOS_INLINE_FUNCTION
1083 OffsetView(
const pointer_type& p,
const begins_type& begins_,
1084 const begins_type& ends_)
1085 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1086 : OffsetView(p, begins_, ends_,
1087 runtime_check_begins_ends_host(begins_, ends_))
1089 : OffsetView(p, begins_, ends_,
1090 runtime_check_begins_ends_device(begins_, ends_))
1095 KOKKOS_INLINE_FUNCTION
1096 OffsetView(
const pointer_type& p,
const begins_type& begins_,
1097 index_list_type ends_)
1098 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1099 : OffsetView(p, begins_, ends_,
1100 runtime_check_begins_ends_host(begins_, ends_))
1102 : OffsetView(p, begins_, ends_,
1103 runtime_check_begins_ends_device(begins_, ends_))
1108 KOKKOS_INLINE_FUNCTION
1109 OffsetView(
const pointer_type& p, index_list_type begins_,
1110 const begins_type& ends_)
1111 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1112 : OffsetView(p, begins_, ends_,
1113 runtime_check_begins_ends_host(begins_, ends_))
1115 : OffsetView(p, begins_, ends_,
1116 runtime_check_begins_ends_device(begins_, ends_))
1121 KOKKOS_INLINE_FUNCTION
1122 OffsetView(
const pointer_type& p, index_list_type begins_,
1123 index_list_type ends_)
1124 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1125 : OffsetView(p, begins_, ends_,
1126 runtime_check_begins_ends_host(begins_, ends_))
1128 : OffsetView(p, begins_, ends_,
1129 runtime_check_begins_ends_device(begins_, ends_))
1136 KOKKOS_INLINE_FUNCTION
1137 int use_count()
const {
return m_track.use_count(); }
1139 inline const std::string label()
const {
1140 return m_track.template get_label<typename traits::memory_space>();
1143 template <
typename Label>
1144 explicit inline OffsetView(
1145 const Label& arg_label,
1146 typename std::enable_if<Kokkos::Impl::is_view_label<Label>::value,
1147 const index_list_type>::type range0,
1148 const index_list_type range1 = KOKKOS_INVALID_INDEX_RANGE,
1149 const index_list_type range2 = KOKKOS_INVALID_INDEX_RANGE,
1150 const index_list_type range3 = KOKKOS_INVALID_INDEX_RANGE,
1151 const index_list_type range4 = KOKKOS_INVALID_INDEX_RANGE,
1152 const index_list_type range5 = KOKKOS_INVALID_INDEX_RANGE,
1153 const index_list_type range6 = KOKKOS_INVALID_INDEX_RANGE,
1154 const index_list_type range7 = KOKKOS_INVALID_INDEX_RANGE
1157 : OffsetView(
Kokkos::Impl::ViewCtorProp<std::string>(arg_label),
1158 typename traits::array_layout(
1159 range0.begin()[1] - range0.begin()[0] + 1,
1160 range1.begin()[1] - range1.begin()[0] + 1,
1161 range2.begin()[1] - range2.begin()[0] + 1,
1162 range3.begin()[1] - range3.begin()[0] + 1,
1163 range4.begin()[1] - range4.begin()[0] + 1,
1164 range5.begin()[1] - range5.begin()[0] + 1,
1165 range6.begin()[1] - range6.begin()[0] + 1,
1166 range7.begin()[1] - range7.begin()[0] + 1),
1167 {range0.begin()[0], range1.begin()[0], range2.begin()[0],
1168 range3.begin()[0], range4.begin()[0], range5.begin()[0],
1169 range6.begin()[0], range7.begin()[0]}) {}
1171 template <
class... P>
1172 explicit KOKKOS_INLINE_FUNCTION OffsetView(
1173 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1174 typename std::enable_if<Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1175 typename traits::array_layout>::type
const&
1177 const index_list_type minIndices)
1180 m_map(arg_prop, arg_layout) {
1181 for (
size_t i = 0; i < minIndices.size(); ++i) {
1182 m_begins[i] = minIndices.begin()[i];
1185 std::is_same<pointer_type,
typename Kokkos::Impl::ViewCtorProp<
1186 P...>::pointer_type>::value,
1187 "When constructing OffsetView to wrap user memory, you must supply " 1188 "matching pointer type");
1191 template <
class... P>
1192 explicit inline OffsetView(
1193 const Kokkos::Impl::ViewCtorProp<P...>& arg_prop,
1194 typename std::enable_if<!Kokkos::Impl::ViewCtorProp<P...>::has_pointer,
1195 typename traits::array_layout>::type
const&
1197 const index_list_type minIndices)
1202 for (
size_t i = 0; i < Rank; ++i) m_begins[i] = minIndices.begin()[i];
1205 using alloc_prop_input = Kokkos::Impl::ViewCtorProp<P...>;
1209 using alloc_prop = Kokkos::Impl::ViewCtorProp<
1211 typename std::conditional<alloc_prop_input::has_label,
1212 std::integral_constant<unsigned, 0>,
1213 typename std::string>::type,
1214 typename std::conditional<
1215 alloc_prop_input::has_memory_space,
1216 std::integral_constant<unsigned, 1>,
1217 typename traits::device_type::memory_space>::type,
1218 typename std::conditional<
1219 alloc_prop_input::has_execution_space,
1220 std::integral_constant<unsigned, 2>,
1221 typename traits::device_type::execution_space>::type>;
1223 static_assert(traits::is_managed,
1224 "OffsetView allocation constructor requires managed memory");
1226 if (alloc_prop::initialize &&
1227 !alloc_prop::execution_space::impl_is_initialized()) {
1230 Kokkos::Impl::throw_runtime_exception(
1231 "Constructing OffsetView and initializing data with uninitialized " 1236 alloc_prop prop_copy(arg_prop);
1239 #if defined(KOKKOS_ENABLE_CUDA) 1245 if (std::is_same<Kokkos::CudaUVMSpace,
1246 typename traits::device_type::memory_space>::value) {
1247 typename traits::device_type::memory_space::execution_space().fence();
1252 Kokkos::Impl::SharedAllocationRecord<>* record =
1253 m_map.allocate_shared(prop_copy, arg_layout);
1256 #if defined(KOKKOS_ENABLE_CUDA) 1257 if (std::is_same<Kokkos::CudaUVMSpace,
1258 typename traits::device_type::memory_space>::value) {
1259 typename traits::device_type::memory_space::execution_space().fence();
1265 m_track.assign_allocated_record_to_uninitialized(record);
1267 #ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST 1268 Kokkos::Experimental::Impl::runtime_check_rank_host(
1269 traits::rank_dynamic, Rank, minIndices, label());
1271 Kokkos::Experimental::Impl::runtime_check_rank_device(traits::rank_dynamic,
1282 template <
typename D,
class... P>
1283 KOKKOS_INLINE_FUNCTION constexpr
unsigned rank(
const OffsetView<D, P...>& V) {
1292 KOKKOS_INLINE_FUNCTION
1293 typename std::enable_if<std::is_integral<T>::value, T>::type
1294 shift_input(
const T arg,
const int64_t offset) {
1295 return arg - offset;
1298 KOKKOS_INLINE_FUNCTION
1299 Kokkos::Impl::ALL_t shift_input(
const Kokkos::Impl::ALL_t arg,
1305 KOKKOS_INLINE_FUNCTION
typename std::enable_if<std::is_integral<T>::value,
1308 return Kokkos::make_pair<T, T>(arg.
first - offset, arg.
second - offset);
1312 typename std::enable_if<std::is_integral<T>::value, std::pair<T, T> >::type
1313 shift_input(
const std::pair<T, T> arg,
const int64_t offset) {
1314 return std::make_pair<T, T>(arg.first - offset, arg.second - offset);
1317 template <
size_t N,
class Arg,
class A>
1318 KOKKOS_INLINE_FUNCTION
void map_arg_to_new_begin(
1320 typename std::enable_if<N != 0, const Arg>::type shiftedArg,
const Arg arg,
1321 const A viewBegins,
size_t& counter) {
1322 if (!std::is_integral<Arg>::value) {
1323 subviewBegins[counter] = shiftedArg == arg ? viewBegins[i] : 0;
1328 template <
size_t N,
class Arg,
class A>
1329 KOKKOS_INLINE_FUNCTION
void map_arg_to_new_begin(
1331 typename std::enable_if<N == 0, const Arg>::type ,
1332 const Arg ,
const A ,
size_t& ) {}
1334 template <
class D,
class... P,
class T>
1335 KOKKOS_INLINE_FUNCTION
1336 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1337 typename Kokkos::Impl::ViewMapping<
void 1340 ViewTraits<D, P...>, T>::type>::type
1341 subview_offset(
const OffsetView<D, P...>& src, T arg) {
1342 auto theView = src.view();
1343 auto begins = src.begins();
1345 T shiftedArg = shift_input(arg, begins[0]);
1347 constexpr
size_t rank =
1348 Kokkos::Impl::ViewMapping<
void 1351 ViewTraits<D, P...>, T>::type::Rank;
1353 auto theSubview = Kokkos::subview(theView, shiftedArg);
1357 Kokkos::Experimental::Impl::map_arg_to_new_begin(0, subviewBegins, shiftedArg,
1358 arg, begins, counter);
1360 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1361 typename Kokkos::Impl::ViewMapping<
void 1364 ViewTraits<D, P...>, T>::type>::type
1365 offsetView(theSubview, subviewBegins);
1370 template <
class D,
class... P,
class T0,
class T1>
1371 KOKKOS_INLINE_FUNCTION
1372 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1373 typename Kokkos::Impl::ViewMapping<
1376 ViewTraits<D, P...>, T0, T1>::type>::type
1377 subview_offset(
const Kokkos::Experimental::OffsetView<D, P...>& src,
1379 auto theView = src.view();
1380 auto begins = src.begins();
1382 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1383 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1385 auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1);
1386 constexpr
size_t rank =
1387 Kokkos::Impl::ViewMapping<
void 1390 ViewTraits<D, P...>, T0, T1>::type::Rank;
1394 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1395 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1396 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1397 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1399 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1400 typename Kokkos::Impl::ViewMapping<
1403 ViewTraits<D, P...>, T0, T1>::type>::type offsetView(theSubview,
1409 template <
class D,
class... P,
class T0,
class T1,
class T2>
1410 KOKKOS_INLINE_FUNCTION
1411 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1412 typename Kokkos::Impl::ViewMapping<
1415 ViewTraits<D, P...>, T0, T1, T2>::type>::type
1416 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2) {
1417 auto theView = src.view();
1418 auto begins = src.begins();
1420 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1421 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1422 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1425 Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2);
1427 constexpr
size_t rank =
1428 Kokkos::Impl::ViewMapping<
void 1431 ViewTraits<D, P...>, T0, T1, T2>::type::Rank;
1436 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1437 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1438 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1439 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1440 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1441 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1443 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1444 typename Kokkos::Impl::ViewMapping<
1447 ViewTraits<D, P...>, T0, T1, T2>::type>::type
1448 offsetView(theSubview, subviewBegins);
1453 template <
class D,
class... P,
class T0,
class T1,
class T2,
class T3>
1454 KOKKOS_INLINE_FUNCTION
1455 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1456 typename Kokkos::Impl::ViewMapping<
1459 ViewTraits<D, P...>, T0, T1, T2, T3>::type>::type
1460 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
1462 auto theView = src.view();
1463 auto begins = src.begins();
1465 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1466 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1467 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1468 T3 shiftedArg3 = shift_input(arg3, begins[3]);
1470 auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
1471 shiftedArg2, shiftedArg3);
1473 constexpr
size_t rank = Kokkos::Impl::ViewMapping<
1476 ViewTraits<D, P...>, T0, T1, T2, T3>::type::Rank;
1480 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1481 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1482 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1483 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1484 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1485 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1486 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1487 3, subviewBegins, shiftedArg3, arg3, begins, counter);
1489 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1490 typename Kokkos::Impl::ViewMapping<
1493 ViewTraits<D, P...>, T0, T1, T2, T3>::type>::type
1494 offsetView(theSubview, subviewBegins);
1499 template <
class D,
class... P,
class T0,
class T1,
class T2,
class T3,
class T4>
1500 KOKKOS_INLINE_FUNCTION
1501 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1502 typename Kokkos::Impl::ViewMapping<
1505 ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type>::type
1506 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
1508 auto theView = src.view();
1509 auto begins = src.begins();
1511 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1512 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1513 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1514 T3 shiftedArg3 = shift_input(arg3, begins[3]);
1515 T4 shiftedArg4 = shift_input(arg4, begins[4]);
1517 auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
1518 shiftedArg2, shiftedArg3, shiftedArg4);
1520 constexpr
size_t rank = Kokkos::Impl::ViewMapping<
1523 ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type::Rank;
1527 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1528 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1529 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1530 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1531 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1532 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1533 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1534 3, subviewBegins, shiftedArg3, arg3, begins, counter);
1535 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1536 4, subviewBegins, shiftedArg4, arg4, begins, counter);
1538 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1539 typename Kokkos::Impl::ViewMapping<
1542 ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type>::type
1543 offsetView(theSubview, subviewBegins);
1548 template <
class D,
class... P,
class T0,
class T1,
class T2,
class T3,
class T4,
1550 KOKKOS_INLINE_FUNCTION
1551 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1552 typename Kokkos::Impl::ViewMapping<
1555 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type>::type
1556 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
1557 T3 arg3, T4 arg4, T5 arg5) {
1558 auto theView = src.view();
1559 auto begins = src.begins();
1561 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1562 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1563 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1564 T3 shiftedArg3 = shift_input(arg3, begins[3]);
1565 T4 shiftedArg4 = shift_input(arg4, begins[4]);
1566 T5 shiftedArg5 = shift_input(arg5, begins[5]);
1569 Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2,
1570 shiftedArg3, shiftedArg4, shiftedArg5);
1572 constexpr
size_t rank = Kokkos::Impl::ViewMapping<
1575 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type::Rank;
1580 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1581 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1582 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1583 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1584 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1585 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1586 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1587 3, subviewBegins, shiftedArg3, arg3, begins, counter);
1588 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1589 4, subviewBegins, shiftedArg4, arg4, begins, counter);
1590 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1591 5, subviewBegins, shiftedArg5, arg5, begins, counter);
1593 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1594 typename Kokkos::Impl::ViewMapping<
1597 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type>::type
1598 offsetView(theSubview, subviewBegins);
1602 template <
class D,
class... P,
class T0,
class T1,
class T2,
class T3,
class T4,
1604 KOKKOS_INLINE_FUNCTION
1605 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1606 typename Kokkos::Impl::ViewMapping<
1609 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type>::type
1610 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
1611 T3 arg3, T4 arg4, T5 arg5, T6 arg6) {
1612 auto theView = src.view();
1613 auto begins = src.begins();
1615 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1616 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1617 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1618 T3 shiftedArg3 = shift_input(arg3, begins[3]);
1619 T4 shiftedArg4 = shift_input(arg4, begins[4]);
1620 T5 shiftedArg5 = shift_input(arg5, begins[5]);
1621 T6 shiftedArg6 = shift_input(arg6, begins[6]);
1624 Kokkos::subview(theView, shiftedArg0, shiftedArg1, shiftedArg2,
1625 shiftedArg3, shiftedArg4, shiftedArg5, shiftedArg6);
1627 constexpr
size_t rank = Kokkos::Impl::ViewMapping<
1630 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type::Rank;
1635 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1636 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1637 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1638 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1639 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1640 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1641 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1642 3, subviewBegins, shiftedArg3, arg3, begins, counter);
1643 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1644 4, subviewBegins, shiftedArg4, arg4, begins, counter);
1645 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1646 5, subviewBegins, shiftedArg5, arg5, begins, counter);
1647 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1648 6, subviewBegins, shiftedArg6, arg6, begins, counter);
1650 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1651 typename Kokkos::Impl::ViewMapping<
1654 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type>::type
1655 offsetView(theSubview, subviewBegins);
1660 template <
class D,
class... P,
class T0,
class T1,
class T2,
class T3,
class T4,
1661 class T5,
class T6,
class T7>
1662 KOKKOS_INLINE_FUNCTION
1663 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1664 typename Kokkos::Impl::ViewMapping<
1667 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type>::type
1668 subview_offset(
const OffsetView<D, P...>& src, T0 arg0, T1 arg1, T2 arg2,
1669 T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) {
1670 auto theView = src.view();
1671 auto begins = src.begins();
1673 T0 shiftedArg0 = shift_input(arg0, begins[0]);
1674 T1 shiftedArg1 = shift_input(arg1, begins[1]);
1675 T2 shiftedArg2 = shift_input(arg2, begins[2]);
1676 T3 shiftedArg3 = shift_input(arg3, begins[3]);
1677 T4 shiftedArg4 = shift_input(arg4, begins[4]);
1678 T5 shiftedArg5 = shift_input(arg5, begins[5]);
1679 T6 shiftedArg6 = shift_input(arg6, begins[6]);
1680 T7 shiftedArg7 = shift_input(arg7, begins[7]);
1682 auto theSubview = Kokkos::subview(theView, shiftedArg0, shiftedArg1,
1683 shiftedArg2, shiftedArg3, shiftedArg4,
1684 shiftedArg5, shiftedArg6, shiftedArg7);
1686 constexpr
size_t rank = Kokkos::Impl::ViewMapping<
1689 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type::Rank;
1694 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1695 0, subviewBegins, shiftedArg0, arg0, begins, counter);
1696 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1697 1, subviewBegins, shiftedArg1, arg1, begins, counter);
1698 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1699 2, subviewBegins, shiftedArg2, arg2, begins, counter);
1700 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1701 3, subviewBegins, shiftedArg3, arg3, begins, counter);
1702 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1703 4, subviewBegins, shiftedArg4, arg4, begins, counter);
1704 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1705 5, subviewBegins, shiftedArg5, arg5, begins, counter);
1706 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1707 6, subviewBegins, shiftedArg6, arg6, begins, counter);
1708 Kokkos::Experimental::Impl::map_arg_to_new_begin(
1709 7, subviewBegins, shiftedArg7, arg7, begins, counter);
1711 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1712 typename Kokkos::Impl::ViewMapping<
1715 ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type>::type
1716 offsetView(theSubview, subviewBegins);
1722 template <
class D,
class... P,
class... Args>
1723 KOKKOS_INLINE_FUNCTION
1724 typename Kokkos::Experimental::Impl::GetOffsetViewTypeFromViewType<
1725 typename Kokkos::Impl::ViewMapping<
1728 ViewTraits<D, P...>, Args...>::type>::type
1729 subview(
const OffsetView<D, P...>& src, Args... args) {
1731 OffsetView<D, P...>::Rank ==
sizeof...(Args),
1732 "subview requires one argument for each source OffsetView rank");
1734 return Kokkos::Experimental::Impl::subview_offset(src, args...);
1744 template <
class LT,
class... LP,
class RT,
class... RP>
1745 KOKKOS_INLINE_FUNCTION
bool operator==(
const OffsetView<LT, LP...>& lhs,
1746 const OffsetView<RT, RP...>& rhs) {
1748 using lhs_traits = ViewTraits<LT, LP...>;
1749 using rhs_traits = ViewTraits<RT, RP...>;
1751 return std::is_same<
typename lhs_traits::const_value_type,
1752 typename rhs_traits::const_value_type>::value &&
1753 std::is_same<
typename lhs_traits::array_layout,
1754 typename rhs_traits::array_layout>::value &&
1755 std::is_same<
typename lhs_traits::memory_space,
1756 typename rhs_traits::memory_space>::value &&
1757 unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
1758 lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
1759 lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
1760 lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
1761 lhs.extent(4) == rhs.extent(4) && lhs.extent(5) == rhs.extent(5) &&
1762 lhs.extent(6) == rhs.extent(6) && lhs.extent(7) == rhs.extent(7) &&
1763 lhs.begin(0) == rhs.begin(0) && lhs.begin(1) == rhs.begin(1) &&
1764 lhs.begin(2) == rhs.begin(2) && lhs.begin(3) == rhs.begin(3) &&
1765 lhs.begin(4) == rhs.begin(4) && lhs.begin(5) == rhs.begin(5) &&
1766 lhs.begin(6) == rhs.begin(6) && lhs.begin(7) == rhs.begin(7);
1769 template <
class LT,
class... LP,
class RT,
class... RP>
1770 KOKKOS_INLINE_FUNCTION
bool operator!=(
const OffsetView<LT, LP...>& lhs,
1771 const OffsetView<RT, RP...>& rhs) {
1772 return !(operator==(lhs, rhs));
1775 template <
class LT,
class... LP,
class RT,
class... RP>
1776 KOKKOS_INLINE_FUNCTION
bool operator==(
const View<LT, LP...>& lhs,
1777 const OffsetView<RT, RP...>& rhs) {
1779 using lhs_traits = ViewTraits<LT, LP...>;
1780 using rhs_traits = ViewTraits<RT, RP...>;
1782 return std::is_same<
typename lhs_traits::const_value_type,
1783 typename rhs_traits::const_value_type>::value &&
1784 std::is_same<
typename lhs_traits::array_layout,
1785 typename rhs_traits::array_layout>::value &&
1786 std::is_same<
typename lhs_traits::memory_space,
1787 typename rhs_traits::memory_space>::value &&
1788 unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
1789 lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
1790 lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
1791 lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
1792 lhs.extent(4) == rhs.extent(4) && lhs.extent(5) == rhs.extent(5) &&
1793 lhs.extent(6) == rhs.extent(6) && lhs.extent(7) == rhs.extent(7);
1796 template <
class LT,
class... LP,
class RT,
class... RP>
1797 KOKKOS_INLINE_FUNCTION
bool operator==(
const OffsetView<LT, LP...>& lhs,
1798 const View<RT, RP...>& rhs) {
1810 template <
class DT,
class... DP>
1811 inline void deep_copy(
1812 const Experimental::OffsetView<DT, DP...>& dst,
1813 typename ViewTraits<DT, DP...>::const_value_type& value,
1814 typename std::enable_if<std::is_same<
1815 typename ViewTraits<DT, DP...>::specialize,
void>::value>::type* =
1818 std::is_same<
typename ViewTraits<DT, DP...>::non_const_value_type,
1819 typename ViewTraits<DT, DP...>::value_type>::value,
1820 "deep_copy requires non-const type");
1822 auto dstView = dst.view();
1823 Kokkos::deep_copy(dstView, value);
1826 template <
class DT,
class... DP,
class ST,
class... SP>
1827 inline void deep_copy(
1828 const Experimental::OffsetView<DT, DP...>& dst,
1829 const Experimental::OffsetView<ST, SP...>& value,
1830 typename std::enable_if<std::is_same<
1831 typename ViewTraits<DT, DP...>::specialize,
void>::value>::type* =
1834 std::is_same<
typename ViewTraits<DT, DP...>::value_type,
1835 typename ViewTraits<ST, SP...>::non_const_value_type>::value,
1836 "deep_copy requires matching non-const destination type");
1838 auto dstView = dst.view();
1839 Kokkos::deep_copy(dstView, value.view());
1841 template <
class DT,
class... DP,
class ST,
class... SP>
1842 inline void deep_copy(
1843 const Experimental::OffsetView<DT, DP...>& dst,
1844 const View<ST, SP...>& value,
1845 typename std::enable_if<std::is_same<
1846 typename ViewTraits<DT, DP...>::specialize,
void>::value>::type* =
1849 std::is_same<
typename ViewTraits<DT, DP...>::value_type,
1850 typename ViewTraits<ST, SP...>::non_const_value_type>::value,
1851 "deep_copy requires matching non-const destination type");
1853 auto dstView = dst.view();
1854 Kokkos::deep_copy(dstView, value);
1857 template <
class DT,
class... DP,
class ST,
class... SP>
1858 inline void deep_copy(
1859 const View<DT, DP...>& dst,
1860 const Experimental::OffsetView<ST, SP...>& value,
1861 typename std::enable_if<std::is_same<
1862 typename ViewTraits<DT, DP...>::specialize,
void>::value>::type* =
1865 std::is_same<
typename ViewTraits<DT, DP...>::value_type,
1866 typename ViewTraits<ST, SP...>::non_const_value_type>::value,
1867 "deep_copy requires matching non-const destination type");
1869 Kokkos::deep_copy(dst, value.view());
1875 template <
class Space,
class T,
class... P>
1876 struct MirrorOffsetViewType {
1878 using src_view_type =
typename Kokkos::Experimental::OffsetView<T, P...>;
1880 using memory_space =
typename Space::memory_space;
1884 std::is_same<memory_space, typename src_view_type::memory_space>::value
1887 using array_layout =
typename src_view_type::array_layout;
1890 using data_type =
typename src_view_type::non_const_data_type;
1892 using dest_view_type =
1893 Kokkos::Experimental::OffsetView<data_type, array_layout, Space>;
1896 using view_type =
typename std::conditional<is_same_memspace, src_view_type,
1897 dest_view_type>::type;
1900 template <
class Space,
class T,
class... P>
1901 struct MirrorOffsetType {
1903 using src_view_type =
typename Kokkos::Experimental::OffsetView<T, P...>;
1905 using memory_space =
typename Space::memory_space;
1909 std::is_same<memory_space, typename src_view_type::memory_space>::value
1912 using array_layout =
typename src_view_type::array_layout;
1915 using data_type =
typename src_view_type::non_const_data_type;
1918 Kokkos::Experimental::OffsetView<data_type, array_layout, Space>;
1923 template <
class T,
class... P>
1924 inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
1926 const Kokkos::Experimental::OffsetView<T, P...>& src,
1927 typename std::enable_if<
1928 !std::is_same<
typename Kokkos::ViewTraits<T, P...>::array_layout,
1930 using src_type = Experimental::OffsetView<T, P...>;
1931 using dst_type =
typename src_type::HostMirror;
1934 Kokkos::Impl::ViewCtorProp<std::string>(
1935 std::string(src.label()).append(
"_mirror")),
1936 typename Kokkos::ViewTraits<T, P...>::array_layout(
1937 src.extent(0), src.extent(1), src.extent(2), src.extent(3),
1938 src.extent(4), src.extent(5), src.extent(6), src.extent(7)),
1939 {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
1940 src.begin(5), src.begin(6), src.begin(7)});
1943 template <
class T,
class... P>
1944 inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
1946 const Kokkos::Experimental::OffsetView<T, P...>& src,
1947 typename std::enable_if<
1948 std::is_same<
typename Kokkos::ViewTraits<T, P...>::array_layout,
1950 using src_type = Experimental::OffsetView<T, P...>;
1951 using dst_type =
typename src_type::HostMirror;
1955 layout.dimension[0] = src.extent(0);
1956 layout.dimension[1] = src.extent(1);
1957 layout.dimension[2] = src.extent(2);
1958 layout.dimension[3] = src.extent(3);
1959 layout.dimension[4] = src.extent(4);
1960 layout.dimension[5] = src.extent(5);
1961 layout.dimension[6] = src.extent(6);
1962 layout.dimension[7] = src.extent(7);
1964 layout.stride[0] = src.stride_0();
1965 layout.stride[1] = src.stride_1();
1966 layout.stride[2] = src.stride_2();
1967 layout.stride[3] = src.stride_3();
1968 layout.stride[4] = src.stride_4();
1969 layout.stride[5] = src.stride_5();
1970 layout.stride[6] = src.stride_6();
1971 layout.stride[7] = src.stride_7();
1973 return dst_type(std::string(src.label()).append(
"_mirror"), layout,
1974 {src.begin(0), src.begin(1), src.begin(2), src.begin(3),
1975 src.begin(4), src.begin(5), src.begin(6), src.begin(7)});
1979 template <
class Space,
class T,
class... P>
1980 typename Kokkos::Impl::MirrorOffsetType<Space, T, P...>::view_type
1981 create_mirror(
const Space&,
1982 const Kokkos::Experimental::OffsetView<T, P...>& src) {
1983 return typename Kokkos::Impl::MirrorOffsetType<Space, T, P...>::view_type(
1984 src.label(), src.layout(),
1985 {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
1986 src.begin(5), src.begin(6), src.begin(7)});
1989 template <
class T,
class... P>
1990 inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
1992 const typename Kokkos::Experimental::OffsetView<T, P...>& src,
1993 typename std::enable_if<
1995 typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
1996 typename Kokkos::Experimental::OffsetView<
1997 T, P...>::HostMirror::memory_space>::value &&
1999 typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
2000 typename Kokkos::Experimental::OffsetView<
2001 T, P...>::HostMirror::data_type>::value)>::type* =
nullptr) {
2005 template <
class T,
class... P>
2006 inline typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror
2008 const Kokkos::Experimental::OffsetView<T, P...>& src,
2009 typename std::enable_if<
2011 typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
2012 typename Kokkos::Experimental::OffsetView<
2013 T, P...>::HostMirror::memory_space>::value &&
2015 typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
2016 typename Kokkos::Experimental::OffsetView<
2017 T, P...>::HostMirror::data_type>::value)>::type* =
nullptr) {
2018 return Kokkos::create_mirror(src);
2022 template <
class Space,
class T,
class... P>
2023 typename Kokkos::Impl::MirrorOffsetViewType<Space, T, P...>::view_type
2024 create_mirror_view(
const Space&,
2025 const Kokkos::Experimental::OffsetView<T, P...>& src,
2026 typename std::enable_if<Impl::MirrorOffsetViewType<
2027 Space, T, P...>::is_same_memspace>::type* =
nullptr) {
2032 template <
class Space,
class T,
class... P>
2033 typename Kokkos::Impl::MirrorOffsetViewType<Space, T, P...>::view_type
2034 create_mirror_view(
const Space&,
2035 const Kokkos::Experimental::OffsetView<T, P...>& src,
2036 typename std::enable_if<!Impl::MirrorOffsetViewType<
2037 Space, T, P...>::is_same_memspace>::type* =
nullptr) {
2038 return typename Kokkos::Impl::MirrorOffsetViewType<Space, T, P...>::view_type(
2039 src.label(), src.layout(),
2040 {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
2041 src.begin(5), src.begin(6), src.begin(7)});
Derived from the C++17 'std::array'. Dropping the iterator interface.
Replacement for std::pair that works on CUDA devices.
Memory layout tag indicated arbitrarily strided multi-index mapping into contiguous memory...
first_type first
The first element of the pair.
second_type second
The second element of the pair.