Kokkos Core Kernels Package Version of the Day
Loading...
Searching...
No Matches
Kokkos_DynamicView.hpp
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
17#ifndef KOKKOS_DYNAMIC_VIEW_HPP
18#define KOKKOS_DYNAMIC_VIEW_HPP
19#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
20#define KOKKOS_IMPL_PUBLIC_INCLUDE
21#define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNAMICVIEW
22#endif
23
24#include <cstdio>
25
26#include <Kokkos_Core.hpp>
27#include <impl/Kokkos_Error.hpp>
28
29namespace Kokkos {
30namespace Experimental {
31
32namespace Impl {
33
37template <typename MemorySpace, typename ValueType>
39 using value_type = ValueType;
40 using pointer_type = ValueType*;
41 using track_type = Kokkos::Impl::SharedAllocationTracker;
42
43 ChunkedArrayManager() = default;
46 ChunkedArrayManager& operator=(ChunkedArrayManager&&) = default;
47 ChunkedArrayManager& operator=(const ChunkedArrayManager&) = default;
48
49 template <typename Space, typename Value>
50 friend struct ChunkedArrayManager;
51
52 template <typename Space, typename Value>
54 : m_valid(rhs.m_valid),
55 m_chunk_max(rhs.m_chunk_max),
56 m_chunks((ValueType**)(rhs.m_chunks)),
57 m_track(rhs.m_track),
58 m_chunk_size(rhs.m_chunk_size) {
59 static_assert(
61 "Incompatible ChunkedArrayManager copy construction");
62 }
63
64 ChunkedArrayManager(const unsigned arg_chunk_max,
65 const unsigned arg_chunk_size)
66 : m_chunk_max(arg_chunk_max), m_chunk_size(arg_chunk_size) {}
67
68 private:
69 struct ACCESSIBLE_TAG {};
70 struct INACCESSIBLE_TAG {};
71
72 ChunkedArrayManager(ACCESSIBLE_TAG, pointer_type* arg_chunks,
73 const unsigned arg_chunk_max)
74 : m_valid(true), m_chunk_max(arg_chunk_max), m_chunks(arg_chunks) {}
75
76 ChunkedArrayManager(INACCESSIBLE_TAG, const unsigned arg_chunk_max,
77 const unsigned arg_chunk_size)
78 : m_chunk_max(arg_chunk_max), m_chunk_size(arg_chunk_size) {}
79
80 public:
81 template <typename Space, typename Enable_ = void>
82 struct IsAccessibleFrom;
83
84 template <typename Space>
85 struct IsAccessibleFrom<
86 Space, typename std::enable_if_t<Kokkos::Impl::MemorySpaceAccess<
87 MemorySpace, Space>::accessible>> : std::true_type {};
88
89 template <typename Space>
90 struct IsAccessibleFrom<
91 Space, typename std::enable_if_t<!Kokkos::Impl::MemorySpaceAccess<
92 MemorySpace, Space>::accessible>> : std::false_type {};
93
94 template <typename Space>
95 static ChunkedArrayManager<Space, ValueType> create_mirror(
97 std::enable_if_t<IsAccessibleFrom<Space>::value>* = nullptr) {
99 ACCESSIBLE_TAG{}, other.m_chunks, other.m_chunk_max};
100 }
101
102 template <typename Space>
103 static ChunkedArrayManager<Space, ValueType> create_mirror(
105 std::enable_if_t<!IsAccessibleFrom<Space>::value>* = nullptr) {
106 using tag_type =
108 return ChunkedArrayManager<Space, ValueType>{tag_type{}, other.m_chunk_max,
109 other.m_chunk_size};
110 }
111
112 public:
113 void allocate_device(const std::string& label) {
114 if (m_chunks == nullptr) {
115 m_chunks = reinterpret_cast<pointer_type*>(MemorySpace().allocate(
116 label.c_str(), (sizeof(pointer_type) * (m_chunk_max + 2))));
117 }
118 }
119
120 void initialize() {
121 for (unsigned i = 0; i < m_chunk_max + 2; i++) {
122 m_chunks[i] = nullptr;
123 }
124 m_valid = true;
125 }
126
127 private:
130 template <typename Space>
131 struct Destroy {
132 Destroy() = default;
133 Destroy(Destroy&&) = default;
134 Destroy(const Destroy&) = default;
135 Destroy& operator=(Destroy&&) = default;
136 Destroy& operator=(const Destroy&) = default;
137
138 Destroy(std::string label, value_type** arg_chunk,
139 const unsigned arg_chunk_max, const unsigned arg_chunk_size,
140 value_type** arg_linked)
141 : m_label(label),
142 m_chunks(arg_chunk),
143 m_linked(arg_linked),
144 m_chunk_max(arg_chunk_max),
145 m_chunk_size(arg_chunk_size) {}
146
147 void execute() {
148 // Destroy the array of chunk pointers.
149 // Two entries beyond the max chunks are allocation counters.
150 uintptr_t const len =
151 *reinterpret_cast<uintptr_t*>(m_chunks + m_chunk_max);
152 for (unsigned i = 0; i < len; i++) {
153 Space().deallocate(m_label.c_str(), m_chunks[i],
154 sizeof(value_type) * m_chunk_size);
155 }
156 // Destroy the linked allocation if we have one.
157 if (m_linked != nullptr) {
158 Space().deallocate(m_label.c_str(), m_linked,
159 (sizeof(value_type*) * (m_chunk_max + 2)));
160 }
161 }
162
163 void destroy_shared_allocation() { execute(); }
164
165 std::string m_label;
166 value_type** m_chunks = nullptr;
167 value_type** m_linked = nullptr;
168 unsigned m_chunk_max;
169 unsigned m_chunk_size;
170 };
171
172 public:
173 template <typename Space>
174 void allocate_with_destroy(const std::string& label,
175 pointer_type* linked_allocation = nullptr) {
176 using destroy_type = Destroy<Space>;
177 using record_type =
178 Kokkos::Impl::SharedAllocationRecord<MemorySpace, destroy_type>;
179
180 // Allocate + 2 extra slots so that *m_chunk[m_chunk_max] ==
181 // num_chunks_alloc and *m_chunk[m_chunk_max+1] == extent This must match in
182 // Destroy's execute(...) method
183 record_type* const record = record_type::allocate(
184 MemorySpace(), label, (sizeof(pointer_type) * (m_chunk_max + 2)));
185 m_chunks = static_cast<pointer_type*>(record->data());
186 m_track.assign_allocated_record_to_uninitialized(record);
187
188 record->m_destroy = destroy_type(label, m_chunks, m_chunk_max, m_chunk_size,
189 linked_allocation);
190 }
191
192 pointer_type* get_ptr() const { return m_chunks; }
193
194 template <typename OtherMemorySpace, typename ExecutionSpace>
195 void deep_copy_to(
196 const ExecutionSpace& exec_space,
198 if (other.m_chunks != m_chunks) {
199 Kokkos::Impl::DeepCopy<OtherMemorySpace, MemorySpace, ExecutionSpace>(
200 exec_space, other.m_chunks, m_chunks,
201 sizeof(pointer_type) * (m_chunk_max + 2));
202 }
203 }
204
205 KOKKOS_INLINE_FUNCTION
206 pointer_type* operator+(int i) const { return m_chunks + i; }
207
208 KOKKOS_INLINE_FUNCTION
209 pointer_type& operator[](int i) const { return m_chunks[i]; }
210
211 track_type const& track() const { return m_track; }
212
213 KOKKOS_INLINE_FUNCTION
214 bool valid() const { return m_valid; }
215
216 private:
217 bool m_valid = false;
218 unsigned m_chunk_max = 0;
219 pointer_type* m_chunks = nullptr;
220 track_type m_track;
221 unsigned m_chunk_size = 0;
222};
223
224} /* end namespace Impl */
225
230template <typename DataType, typename... P>
231class DynamicView : public Kokkos::ViewTraits<DataType, P...> {
232 public:
233 using traits = Kokkos::ViewTraits<DataType, P...>;
234
235 using value_type = typename traits::value_type;
236 using device_space = typename traits::memory_space;
237 using host_space =
238 typename Kokkos::Impl::HostMirror<device_space>::Space::memory_space;
241
242 private:
243 template <class, class...>
244 friend class DynamicView;
245
246 using track_type = Kokkos::Impl::SharedAllocationTracker;
247
248 static_assert(traits::rank == 1 && traits::rank_dynamic == 1,
249 "DynamicView must be rank-one");
250
251 // It is assumed that the value_type is trivially copyable;
252 // when this is not the case, potential problems can occur.
253 static_assert(std::is_void<typename traits::specialize>::value,
254 "DynamicView only implemented for non-specialized View type");
255
256 private:
257 device_accessor m_chunks;
258 host_accessor m_chunks_host;
259 unsigned m_chunk_shift; // ceil(log2(m_chunk_size))
260 unsigned m_chunk_mask; // m_chunk_size - 1
261 unsigned m_chunk_max; // number of entries in the chunk array - each pointing
262 // to a chunk of extent == m_chunk_size entries
263 unsigned m_chunk_size; // 2 << (m_chunk_shift - 1)
264
265 public:
266 //----------------------------------------------------------------------
267
271
273 using const_type = DynamicView<typename traits::const_data_type,
274 typename traits::device_type>;
275
277 using non_const_type = DynamicView<typename traits::non_const_data_type,
278 typename traits::device_type>;
279
282
285 Kokkos::Device<typename traits::device_type::execution_space,
286 Kokkos::AnonymousSpace>;
287 using uniform_type = array_type;
299
300 //----------------------------------------------------------------------
301
302 enum { Rank = 1 };
303
304 KOKKOS_INLINE_FUNCTION
305 size_t allocation_extent() const noexcept {
306 uintptr_t n =
307 *reinterpret_cast<const uintptr_t*>(m_chunks_host + m_chunk_max);
308 return (n << m_chunk_shift);
309 }
310
311 KOKKOS_INLINE_FUNCTION
312 size_t chunk_size() const noexcept { return m_chunk_size; }
313
314 KOKKOS_INLINE_FUNCTION
315 size_t chunk_max() const noexcept { return m_chunk_max; }
316
317 KOKKOS_INLINE_FUNCTION
318 size_t size() const noexcept {
319 size_t extent_0 =
320 *reinterpret_cast<const size_t*>(m_chunks_host + m_chunk_max + 1);
321 return extent_0;
322 }
323
324 template <typename iType>
325 KOKKOS_INLINE_FUNCTION size_t extent(const iType& r) const {
326 return r == 0 ? size() : 1;
327 }
328
329 template <typename iType>
330 KOKKOS_INLINE_FUNCTION size_t extent_int(const iType& r) const {
331 return r == 0 ? size() : 1;
332 }
333
334 KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const { return 0; }
335 KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const { return 0; }
336 KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const { return 0; }
337 KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const { return 0; }
338 KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const { return 0; }
339 KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const { return 0; }
340 KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const { return 0; }
341 KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const { return 0; }
342
343 template <typename iType>
344 KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
345 *s = 0;
346 }
347
348 //----------------------------------------
349 // Allocation tracking properties
350
351 KOKKOS_INLINE_FUNCTION
352 int use_count() const { return m_chunks_host.track().use_count(); }
353
354 inline const std::string label() const {
355 return m_chunks_host.track().template get_label<host_space>();
356 }
357
358 //----------------------------------------------------------------------
359 // Range span is the span which contains all members.
360
361 using reference_type = typename traits::value_type&;
362 using pointer_type = typename traits::value_type*;
363
364 enum {
365 reference_type_is_lvalue_reference =
366 std::is_lvalue_reference<reference_type>::value
367 };
368
369 KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
370 return false;
371 }
372 KOKKOS_INLINE_FUNCTION constexpr size_t span() const { return 0; }
373 KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const { return 0; }
374
375 //----------------------------------------
376
377 template <typename I0, class... Args>
378 KOKKOS_INLINE_FUNCTION reference_type
379 operator()(const I0& i0, const Args&... /*args*/) const {
380 static_assert(Kokkos::Impl::are_integral<I0, Args...>::value,
381 "Indices must be integral type");
382
383 Kokkos::Impl::runtime_check_memory_access_violation<
384 typename traits::memory_space>(
385 "Kokkos::DynamicView ERROR: attempt to access inaccessible memory "
386 "space");
387
388 // Which chunk is being indexed.
389 const uintptr_t ic = uintptr_t(i0) >> m_chunk_shift;
390
391#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
392 const uintptr_t n = *reinterpret_cast<uintptr_t*>(m_chunks + m_chunk_max);
393 if (n <= ic) Kokkos::abort("Kokkos::DynamicView array bounds error");
394#endif
395
396 typename traits::value_type** const ch = m_chunks + ic;
397 return (*ch)[i0 & m_chunk_mask];
398 }
399
400 //----------------------------------------
404 template <typename IntType>
405 inline void resize_serial(IntType const& n) {
406 using local_value_type = typename traits::value_type;
407 using value_pointer_type = local_value_type*;
408
409 const uintptr_t NC =
410 (n + m_chunk_mask) >>
411 m_chunk_shift; // New total number of chunks needed for resize
412
413 if (m_chunk_max < NC) {
414 Kokkos::abort("DynamicView::resize_serial exceeded maximum size");
415 }
416
417 // *m_chunks[m_chunk_max] stores the current number of chunks being used
418 uintptr_t* const pc =
419 reinterpret_cast<uintptr_t*>(m_chunks_host + m_chunk_max);
420 std::string _label = m_chunks_host.track().template get_label<host_space>();
421
422 if (*pc < NC) {
423 while (*pc < NC) {
424 m_chunks_host[*pc] =
425 reinterpret_cast<value_pointer_type>(device_space().allocate(
426 _label.c_str(), sizeof(local_value_type) << m_chunk_shift));
427 ++*pc;
428 }
429 } else {
430 while (NC + 1 <= *pc) {
431 --*pc;
432 device_space().deallocate(_label.c_str(), m_chunks_host[*pc],
433 sizeof(local_value_type) << m_chunk_shift);
434 m_chunks_host[*pc] = nullptr;
435 }
436 }
437 // *m_chunks_host[m_chunk_max+1] stores the 'extent' requested by resize
438 *(pc + 1) = n;
439
440 typename device_space::execution_space exec{};
441 m_chunks_host.deep_copy_to(exec, m_chunks);
442 exec.fence(
443 "DynamicView::resize_serial: Fence after copying chunks to the device");
444 }
445
446 KOKKOS_INLINE_FUNCTION bool is_allocated() const {
447 if (m_chunks_host.valid()) {
448 // *m_chunks_host[m_chunk_max] stores the current number of chunks being
449 // used
450 uintptr_t* const pc =
451 reinterpret_cast<uintptr_t*>(m_chunks_host + m_chunk_max);
452 return (*(pc + 1) > 0);
453 } else {
454 return false;
455 }
456 }
457
458 KOKKOS_FUNCTION const device_accessor& impl_get_chunks() const {
459 return m_chunks;
460 }
461
462 KOKKOS_FUNCTION device_accessor& impl_get_chunks() { return m_chunks; }
463
464 //----------------------------------------------------------------------
465
466 ~DynamicView() = default;
467 DynamicView() = default;
468 DynamicView(DynamicView&&) = default;
469 DynamicView(const DynamicView&) = default;
470 DynamicView& operator=(DynamicView&&) = default;
471 DynamicView& operator=(const DynamicView&) = default;
472
473 template <class RT, class... RP>
474 DynamicView(const DynamicView<RT, RP...>& rhs)
475 : m_chunks(rhs.m_chunks),
476 m_chunks_host(rhs.m_chunks_host),
477 m_chunk_shift(rhs.m_chunk_shift),
478 m_chunk_mask(rhs.m_chunk_mask),
479 m_chunk_max(rhs.m_chunk_max),
480 m_chunk_size(rhs.m_chunk_size) {
481 using SrcTraits = typename DynamicView<RT, RP...>::traits;
482 using Mapping = Kokkos::Impl::ViewMapping<traits, SrcTraits, void>;
483 static_assert(Mapping::is_assignable,
484 "Incompatible DynamicView copy construction");
485 }
486
493 template <class... Prop>
494 DynamicView(const Kokkos::Impl::ViewCtorProp<Prop...>& arg_prop,
495 const unsigned min_chunk_size,
496 const unsigned max_extent)
497 : // The chunk size is guaranteed to be a power of two
498 m_chunk_shift(Kokkos::Impl::integral_power_of_two_that_contains(
499 min_chunk_size)) // div ceil(log2(min_chunk_size))
500 ,
501 m_chunk_mask((1 << m_chunk_shift) - 1) // mod
502 ,
503 m_chunk_max((max_extent + m_chunk_mask) >>
504 m_chunk_shift) // max num pointers-to-chunks in array
505 ,
506 m_chunk_size(2 << (m_chunk_shift - 1)) {
507 m_chunks = device_accessor(m_chunk_max, m_chunk_size);
508
509 const std::string& label =
510 Kokkos::Impl::get_property<Kokkos::Impl::LabelTag>(arg_prop);
511
512 if (device_accessor::template IsAccessibleFrom<host_space>::value) {
513 m_chunks.template allocate_with_destroy<device_space>(label);
514 m_chunks.initialize();
515 m_chunks_host =
516 device_accessor::template create_mirror<host_space>(m_chunks);
517 } else {
518 m_chunks.allocate_device(label);
519 m_chunks_host =
520 device_accessor::template create_mirror<host_space>(m_chunks);
521 m_chunks_host.template allocate_with_destroy<device_space>(
522 label, m_chunks.get_ptr());
523 m_chunks_host.initialize();
524
525 using alloc_prop_input = Kokkos::Impl::ViewCtorProp<Prop...>;
526
527 auto arg_prop_copy = ::Kokkos::Impl::with_properties_if_unset(
528 arg_prop, typename device_space::execution_space{});
529
530 const auto& exec =
531 Kokkos::Impl::get_property<Kokkos::Impl::ExecutionSpaceTag>(
532 arg_prop_copy);
533 m_chunks_host.deep_copy_to(exec, m_chunks);
534 if (!alloc_prop_input::has_execution_space)
535 exec.fence(
536 "DynamicView::DynamicView(): Fence after copying chunks to the "
537 "device");
538 }
539 }
540
541 DynamicView(const std::string& arg_label, const unsigned min_chunk_size,
542 const unsigned max_extent)
543 : DynamicView(Kokkos::view_alloc(arg_label), min_chunk_size, max_extent) {
544 }
545};
546
547} // namespace Experimental
548
549template <class>
550struct is_dynamic_view : public std::false_type {};
551
552template <class D, class... P>
553struct is_dynamic_view<Kokkos::Experimental::DynamicView<D, P...>>
554 : public std::true_type {};
555
556} // namespace Kokkos
557
558namespace Kokkos {
559
560namespace Impl {
561
562// Deduce Mirror Types
563template <class Space, class T, class... P>
564struct MirrorDynamicViewType {
565 // The incoming view_type
566 using src_view_type = typename Kokkos::Experimental::DynamicView<T, P...>;
567 // The memory space for the mirror view
568 using memory_space = typename Space::memory_space;
569 // Check whether it is the same memory space
570 enum {
571 is_same_memspace =
572 std::is_same<memory_space, typename src_view_type::memory_space>::value
573 };
574 // The array_layout
575 using array_layout = typename src_view_type::array_layout;
576 // The data type (we probably want it non-const since otherwise we can't even
577 // deep_copy to it.)
578 using data_type = typename src_view_type::non_const_data_type;
579 // The destination view type if it is not the same memory space
580 using dest_view_type =
582 // If it is the same memory_space return the existing view_type
583 // This will also keep the unmanaged trait if necessary
584 using view_type =
585 std::conditional_t<is_same_memspace, src_view_type, dest_view_type>;
586};
587} // namespace Impl
588
589namespace Impl {
590template <class T, class... P, class... ViewCtorArgs>
591inline auto create_mirror(
593 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
594 std::enable_if_t<!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
595 nullptr) {
596 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
597
598 static_assert(
599 !alloc_prop_input::has_label,
600 "The view constructor arguments passed to Kokkos::create_mirror "
601 "must not include a label!");
602 static_assert(
603 !alloc_prop_input::has_pointer,
604 "The view constructor arguments passed to Kokkos::create_mirror must "
605 "not include a pointer!");
606 static_assert(
607 !alloc_prop_input::allow_padding,
608 "The view constructor arguments passed to Kokkos::create_mirror must "
609 "not explicitly allow padding!");
610
611 auto prop_copy = Impl::with_properties_if_unset(
612 arg_prop, std::string(src.label()).append("_mirror"));
613
615 prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
616
617 ret.resize_serial(src.extent(0));
618
619 return ret;
620}
621
622template <class T, class... P, class... ViewCtorArgs>
623inline auto create_mirror(
625 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
626 std::enable_if_t<Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
627 nullptr) {
628 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
629
630 static_assert(
631 !alloc_prop_input::has_label,
632 "The view constructor arguments passed to Kokkos::create_mirror "
633 "must not include a label!");
634 static_assert(
635 !alloc_prop_input::has_pointer,
636 "The view constructor arguments passed to Kokkos::create_mirror must "
637 "not include a pointer!");
638 static_assert(
639 !alloc_prop_input::allow_padding,
640 "The view constructor arguments passed to Kokkos::create_mirror must "
641 "not explicitly allow padding!");
642
643 using MemorySpace = typename alloc_prop_input::memory_space;
644 auto prop_copy = Impl::with_properties_if_unset(
645 arg_prop, std::string(src.label()).append("_mirror"));
646
647 auto ret = typename Kokkos::Impl::MirrorDynamicViewType<
648 MemorySpace, T, P...>::view_type(prop_copy, src.chunk_size(),
649 src.chunk_max() * src.chunk_size());
650
651 ret.resize_serial(src.extent(0));
652
653 return ret;
654}
655} // namespace Impl
656
657// Create a mirror in host space
658template <class T, class... P>
659inline auto create_mirror(
661 return Impl::create_mirror(src, Impl::ViewCtorProp<>{});
662}
663
664template <class T, class... P>
665inline auto create_mirror(
666 Kokkos::Impl::WithoutInitializing_t wi,
668 return Impl::create_mirror(src, Kokkos::view_alloc(wi));
669}
670
671// Create a mirror in a new space
672template <class Space, class T, class... P>
673inline auto create_mirror(
674 const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src) {
675 return Impl::create_mirror(
676 src, Kokkos::view_alloc(typename Space::memory_space{}));
677}
678
679template <class Space, class T, class... P>
680typename Kokkos::Impl::MirrorDynamicViewType<Space, T, P...>::view_type
681create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
683 return Impl::create_mirror(
684 src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
685}
686
687template <class T, class... P, class... ViewCtorArgs>
688inline auto create_mirror(
689 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
691 return Impl::create_mirror(src, arg_prop);
692}
693
694namespace Impl {
695
696template <class T, class... P, class... ViewCtorArgs>
697inline std::enable_if_t<
698 !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
699 (std::is_same<
700 typename Kokkos::Experimental::DynamicView<T, P...>::memory_space,
702 T, P...>::HostMirror::memory_space>::value &&
703 std::is_same<
704 typename Kokkos::Experimental::DynamicView<T, P...>::data_type,
706 T, P...>::HostMirror::data_type>::value),
708create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
709 const Impl::ViewCtorProp<ViewCtorArgs...>&) {
710 return src;
711}
712
713template <class T, class... P, class... ViewCtorArgs>
714inline std::enable_if_t<
715 !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
716 !(std::is_same<
717 typename Kokkos::Experimental::DynamicView<T, P...>::memory_space,
719 T, P...>::HostMirror::memory_space>::value &&
720 std::is_same<
721 typename Kokkos::Experimental::DynamicView<T, P...>::data_type,
723 T, P...>::HostMirror::data_type>::value),
725create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
726 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
727 return Kokkos::create_mirror(arg_prop, src);
728}
729
730template <class T, class... P, class... ViewCtorArgs,
731 class = std::enable_if_t<
732 Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
733std::enable_if_t<Impl::MirrorDynamicViewType<
734 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
735 T, P...>::is_same_memspace,
736 typename Impl::MirrorDynamicViewType<
737 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
738 T, P...>::view_type>
739create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
740 const Impl::ViewCtorProp<ViewCtorArgs...>&) {
741 return src;
742}
743
744template <class T, class... P, class... ViewCtorArgs,
745 class = std::enable_if_t<
746 Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
747std::enable_if_t<!Impl::MirrorDynamicViewType<
748 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
749 T, P...>::is_same_memspace,
750 typename Impl::MirrorDynamicViewType<
751 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
752 T, P...>::view_type>
753create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
754 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
755 return Kokkos::Impl::create_mirror(src, arg_prop);
756}
757} // namespace Impl
758
759// Create a mirror view in host space
760template <class T, class... P>
761inline auto create_mirror_view(
762 const typename Kokkos::Experimental::DynamicView<T, P...>& src) {
763 return Impl::create_mirror_view(src, Impl::ViewCtorProp<>{});
764}
765
766template <class T, class... P>
767inline auto create_mirror_view(
768 Kokkos::Impl::WithoutInitializing_t wi,
769 const typename Kokkos::Experimental::DynamicView<T, P...>& src) {
770 return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
771}
772
773// Create a mirror in a new space
774template <class Space, class T, class... P>
775inline auto create_mirror_view(
776 const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src) {
777 return Impl::create_mirror_view(src,
778 view_alloc(typename Space::memory_space{}));
779}
780
781template <class Space, class T, class... P>
782inline auto create_mirror_view(
783 Kokkos::Impl::WithoutInitializing_t wi, const Space&,
785 return Impl::create_mirror_view(
786 src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
787}
788
789template <class T, class... P, class... ViewCtorArgs>
790inline auto create_mirror_view(
791 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
793 return Impl::create_mirror_view(src, arg_prop);
794}
795
796template <class T, class... DP, class... SP>
797inline void deep_copy(const Kokkos::Experimental::DynamicView<T, DP...>& dst,
799 using dst_type = Kokkos::Experimental::DynamicView<T, DP...>;
800 using src_type = Kokkos::Experimental::DynamicView<T, SP...>;
801
802 using dst_execution_space = typename ViewTraits<T, DP...>::execution_space;
803 using src_execution_space = typename ViewTraits<T, SP...>::execution_space;
804 using dst_memory_space = typename ViewTraits<T, DP...>::memory_space;
805 using src_memory_space = typename ViewTraits<T, SP...>::memory_space;
806
807 constexpr bool DstExecCanAccessSrc =
808 Kokkos::SpaceAccessibility<dst_execution_space,
809 src_memory_space>::accessible;
810 constexpr bool SrcExecCanAccessDst =
811 Kokkos::SpaceAccessibility<src_execution_space,
812 dst_memory_space>::accessible;
813
814 if (DstExecCanAccessSrc)
815 Kokkos::Impl::ViewRemap<dst_type, src_type, dst_execution_space>(dst, src);
816 else if (SrcExecCanAccessDst)
817 Kokkos::Impl::ViewRemap<dst_type, src_type, src_execution_space>(dst, src);
818 else
819 src.impl_get_chunks().deep_copy_to(dst_execution_space{},
820 dst.impl_get_chunks());
821 Kokkos::fence("Kokkos::deep_copy(DynamicView)");
822}
823
824template <class ExecutionSpace, class T, class... DP, class... SP>
825inline void deep_copy(const ExecutionSpace& exec,
828 using dst_type = Kokkos::Experimental::DynamicView<T, DP...>;
829 using src_type = Kokkos::Experimental::DynamicView<T, SP...>;
830
831 using dst_execution_space = typename ViewTraits<T, DP...>::execution_space;
832 using src_execution_space = typename ViewTraits<T, SP...>::execution_space;
833 using dst_memory_space = typename ViewTraits<T, DP...>::memory_space;
834 using src_memory_space = typename ViewTraits<T, SP...>::memory_space;
835
836 constexpr bool DstExecCanAccessSrc =
837 Kokkos::SpaceAccessibility<dst_execution_space,
838 src_memory_space>::accessible;
839 constexpr bool SrcExecCanAccessDst =
840 Kokkos::SpaceAccessibility<src_execution_space,
841 dst_memory_space>::accessible;
842
843 // FIXME use execution space
844 if (DstExecCanAccessSrc)
845 Kokkos::Impl::ViewRemap<dst_type, src_type, dst_execution_space>(dst, src);
846 else if (SrcExecCanAccessDst)
847 Kokkos::Impl::ViewRemap<dst_type, src_type, src_execution_space>(dst, src);
848 else
849 src.impl_get_chunks().deep_copy_to(exec, dst.impl_get_chunks());
850}
851
852template <class T, class... DP, class... SP>
853inline void deep_copy(const View<T, DP...>& dst,
855 using dst_type = View<T, DP...>;
856 using src_type = Kokkos::Experimental::DynamicView<T, SP...>;
857
858 using dst_execution_space = typename ViewTraits<T, DP...>::execution_space;
859 using src_memory_space = typename ViewTraits<T, SP...>::memory_space;
860
861 enum {
862 DstExecCanAccessSrc =
863 Kokkos::SpaceAccessibility<dst_execution_space,
864 src_memory_space>::accessible
865 };
866
867 if (DstExecCanAccessSrc) {
868 // Copying data between views in accessible memory spaces and either
869 // non-contiguous or incompatible shape.
870 Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
871 Kokkos::fence("Kokkos::deep_copy(DynamicView)");
872 } else {
873 Kokkos::Impl::throw_runtime_exception(
874 "deep_copy given views that would require a temporary allocation");
875 }
876}
877
878template <class T, class... DP, class... SP>
879inline void deep_copy(const Kokkos::Experimental::DynamicView<T, DP...>& dst,
880 const View<T, SP...>& src) {
881 using dst_type = Kokkos::Experimental::DynamicView<T, DP...>;
882 using src_type = View<T, SP...>;
883
884 using dst_execution_space = typename ViewTraits<T, DP...>::execution_space;
885 using src_memory_space = typename ViewTraits<T, SP...>::memory_space;
886
887 enum {
888 DstExecCanAccessSrc =
889 Kokkos::SpaceAccessibility<dst_execution_space,
890 src_memory_space>::accessible
891 };
892
893 if (DstExecCanAccessSrc) {
894 // Copying data between views in accessible memory spaces and either
895 // non-contiguous or incompatible shape.
896 Kokkos::Impl::ViewRemap<dst_type, src_type>(dst, src);
897 Kokkos::fence("Kokkos::deep_copy(DynamicView)");
898 } else {
899 Kokkos::Impl::throw_runtime_exception(
900 "deep_copy given views that would require a temporary allocation");
901 }
902}
903
904namespace Impl {
905template <class Arg0, class... DP, class... SP>
906struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>,
907 Kokkos::Experimental::DynamicView<SP...>, 1, Arg0> {
908 using DstType = Kokkos::Experimental::DynamicView<DP...>;
909 using SrcType = Kokkos::Experimental::DynamicView<SP...>;
910 using dst_subview_type = DstType;
911 using src_subview_type = SrcType;
912 dst_subview_type dst_sub;
913 src_subview_type src_sub;
914 CommonSubview(const DstType& dst, const SrcType& src, const Arg0& /*arg0*/)
915 : dst_sub(dst), src_sub(src) {}
916};
917
918template <class... DP, class SrcType, class Arg0>
919struct CommonSubview<Kokkos::Experimental::DynamicView<DP...>, SrcType, 1,
920 Arg0> {
921 using DstType = Kokkos::Experimental::DynamicView<DP...>;
922 using dst_subview_type = DstType;
923 using src_subview_type = typename Kokkos::Subview<SrcType, Arg0>;
924 dst_subview_type dst_sub;
925 src_subview_type src_sub;
926 CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0)
927 : dst_sub(dst), src_sub(src, arg0) {}
928};
929
930template <class DstType, class... SP, class Arg0>
931struct CommonSubview<DstType, Kokkos::Experimental::DynamicView<SP...>, 1,
932 Arg0> {
933 using SrcType = Kokkos::Experimental::DynamicView<SP...>;
934 using dst_subview_type = typename Kokkos::Subview<DstType, Arg0>;
935 using src_subview_type = SrcType;
936 dst_subview_type dst_sub;
937 src_subview_type src_sub;
938 CommonSubview(const DstType& dst, const SrcType& src, const Arg0& arg0)
939 : dst_sub(dst, arg0), src_sub(src) {}
940};
941
942template <class... DP, class ViewTypeB, class Layout, class ExecSpace,
943 typename iType>
944struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>, ViewTypeB, Layout,
945 ExecSpace, 1, iType> {
947 ViewTypeB b;
948
950
952 const ViewTypeB& b_)
953 : a(a_), b(b_) {
954 Kokkos::parallel_for("Kokkos::ViewCopy-1D", policy_type(0, b.extent(0)),
955 *this);
956 }
957
958 KOKKOS_INLINE_FUNCTION
959 void operator()(const iType& i0) const { a(i0) = b(i0); };
960};
961
962template <class... DP, class... SP, class Layout, class ExecSpace,
963 typename iType>
964struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>,
965 Kokkos::Experimental::DynamicView<SP...>, Layout, ExecSpace, 1,
966 iType> {
969
971
974 : a(a_), b(b_) {
975 const iType n = std::min(a.extent(0), b.extent(0));
976 Kokkos::parallel_for("Kokkos::ViewCopy-1D", policy_type(0, n), *this);
977 }
978
979 KOKKOS_INLINE_FUNCTION
980 void operator()(const iType& i0) const { a(i0) = b(i0); };
981};
982
983} // namespace Impl
984
985template <class... ViewCtorArgs, class T, class... P>
986auto create_mirror_view_and_copy(
987 const Impl::ViewCtorProp<ViewCtorArgs...>&,
989 std::enable_if_t<
990 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
991 Impl::MirrorDynamicViewType<
992 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
993 P...>::is_same_memspace>* = nullptr) {
994 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
995 static_assert(
996 alloc_prop_input::has_memory_space,
997 "The view constructor arguments passed to "
998 "Kokkos::create_mirror_view_and_copy must include a memory space!");
999 static_assert(!alloc_prop_input::has_pointer,
1000 "The view constructor arguments passed to "
1001 "Kokkos::create_mirror_view_and_copy must "
1002 "not include a pointer!");
1003 static_assert(!alloc_prop_input::allow_padding,
1004 "The view constructor arguments passed to "
1005 "Kokkos::create_mirror_view_and_copy must "
1006 "not explicitly allow padding!");
1007
1008 // same behavior as deep_copy(src, src)
1009 if (!alloc_prop_input::has_execution_space)
1010 fence(
1011 "Kokkos::create_mirror_view_and_copy: fence before returning src view");
1012 return src;
1013}
1014
1015template <class... ViewCtorArgs, class T, class... P>
1016auto create_mirror_view_and_copy(
1017 const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
1019 std::enable_if_t<
1020 std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
1021 !Impl::MirrorDynamicViewType<
1022 typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
1023 P...>::is_same_memspace>* = nullptr) {
1024 using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
1025 static_assert(
1026 alloc_prop_input::has_memory_space,
1027 "The view constructor arguments passed to "
1028 "Kokkos::create_mirror_view_and_copy must include a memory space!");
1029 static_assert(!alloc_prop_input::has_pointer,
1030 "The view constructor arguments passed to "
1031 "Kokkos::create_mirror_view_and_copy must "
1032 "not include a pointer!");
1033 static_assert(!alloc_prop_input::allow_padding,
1034 "The view constructor arguments passed to "
1035 "Kokkos::create_mirror_view_and_copy must "
1036 "not explicitly allow padding!");
1037 using Space = typename alloc_prop_input::memory_space;
1038 using Mirror =
1039 typename Impl::MirrorDynamicViewType<Space, T, P...>::view_type;
1040
1041 auto arg_prop_copy = Impl::with_properties_if_unset(
1042 arg_prop, std::string{}, WithoutInitializing,
1043 typename Space::execution_space{});
1044
1045 std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
1046 if (label.empty()) label = src.label();
1047 auto mirror = typename Mirror::non_const_type(
1048 arg_prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
1049 mirror.resize_serial(src.extent(0));
1050 if constexpr (alloc_prop_input::has_execution_space) {
1051 deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
1052 mirror, src);
1053 } else
1054 deep_copy(mirror, src);
1055 return mirror;
1056}
1057
1058template <class Space, class T, class... P>
1059auto create_mirror_view_and_copy(
1060 const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src,
1061 std::string const& name = "") {
1062 return create_mirror_view_and_copy(
1063 Kokkos::view_alloc(typename Space::memory_space{}, name), src);
1064}
1065
1066} // namespace Kokkos
1067
1068#ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNAMICVIEW
1069#undef KOKKOS_IMPL_PUBLIC_INCLUDE
1070#undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_DYNAMICVIEW
1071#endif
1072#endif /* #ifndef KOKKOS_DYNAMIC_VIEW_HPP */
View
Dynamic views are restricted to rank-one and no layout. Resize only occurs on host outside of paralle...
DynamicView HostMirror
Must be accessible everywhere.
DynamicView(const Kokkos::Impl::ViewCtorProp< Prop... > &arg_prop, const unsigned min_chunk_size, const unsigned max_extent)
Allocation constructor.
Kokkos::Device< typename traits::device_type::execution_space, Kokkos::AnonymousSpace > uniform_device
Unified types.
DynamicView< typename traits::data_type, typename traits::device_type > array_type
Compatible view of array of scalar types.
void resize_serial(IntType const &n)
Resizing in serial can grow or shrink the array size up to the maximum number of chunks.
DynamicView< typename traits::const_data_type, typename traits::device_type > const_type
Compatible view of const data type.
Execution policy for work over a range of an integral type.
Access relationship between DstMemorySpace and SrcMemorySpace.
Can AccessSpace access MemorySpace ?
Traits class for accessing attributes of a View.