view.hpp

Go to the documentation of this file.

// core — shared Kokkos device-memory abstraction for the suite's portable path.
//
// One place defines the execution/memory spaces, the 1D device array the halo exchange operates on
// (it gathers/scatters by flat x-fastest local index, so a contiguous per-cell field is a View<T>),
// and the 3D structured field (x-fastest => Kokkos::LayoutLeft). Including this header requires
// Kokkos (build with -DPECLET_CORE_ENABLE_KOKKOS=ON); the CPU and legacy-CUDA paths do NOT pull it
// in.
#ifndef PECLET_CORE_COMMON_VIEW_HPP
#define PECLET_CORE_COMMON_VIEW_HPP
 
#include <Kokkos_Core.hpp>
#include <string>
#include <utility>
#include <vector>
 
#include "peclet/core/common/types.hpp"
 
namespace peclet::core {
 
using ExecSpace = Kokkos::DefaultExecutionSpace;
using MemSpace = ExecSpace::memory_space;
 
template <class T>
using View = Kokkos::View<T*, MemSpace>;
 
template <class T>
using HostView = decltype(Kokkos::create_mirror_view(std::declval<View<T>>()));
 
using IndexView = Kokkos::View<Index*, MemSpace>;
 
template <class T>
using Field3D = Kokkos::View<T***, Kokkos::LayoutLeft, MemSpace>;
 
template <class T>
inline View<T> toDevice(const std::vector<T>& h, const std::string& label) {
  View<T> d(Kokkos::view_alloc(label, Kokkos::WithoutInitializing), h.size());
  if (!h.empty()) {
    Kokkos::View<const T*, Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> hv(h.data(),
                                                                                          h.size());
    Kokkos::deep_copy(d, hv);
  }
  return d;
}
 
template <class V>
std::vector<std::remove_const_t<typename V::value_type>> toVector(const V& view) {
  using T = std::remove_const_t<typename V::value_type>;
  std::vector<T> out(view.size());
  if (view.size()) {
    // `view` may be a STRIDED subview (e.g. [0:numReal] of a larger LayoutLeft device View once the
    // SoA has grown past numReal): a cross-space (device->host) deep_copy of a strided layout has no
    // valid copy mechanism and aborts. Repack into a CONTIGUOUS buffer in the SOURCE space first
    // (same-space deep_copy handles the strided->contiguous gather via a kernel), then hop to host.
    // A no-op memcpy when `view` is already contiguous. Only extent(0) is a runtime dimension for the
    // suite's particle getters (float* / float*[N]).
    Kokkos::View<typename V::non_const_data_type, typename V::memory_space> contig(
        Kokkos::view_alloc(Kokkos::WithoutInitializing, "peclet::core::toVector::contig"),
        view.extent(0));
    Kokkos::deep_copy(contig, view);
    auto host = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), contig);
    Kokkos::LayoutRight layout;
    for (std::size_t i = 0; i < V::rank; ++i)
      layout.dimension[i] = view.extent(i);
    Kokkos::View<typename V::non_const_data_type, Kokkos::LayoutRight, Kokkos::HostSpace,
                 Kokkos::MemoryTraits<Kokkos::Unmanaged>>
        dst(out.data(), layout);
    Kokkos::deep_copy(dst, host);
  }
  return out;
}
 
}  // namespace peclet::core
 
#endif  // PECLET_CORE_COMMON_VIEW_HPP