my_mirror_view.hpp

Go to the documentation of this file.

#ifndef MY_MIRROR_VIEW_HPP
#define MY_MIRROR_VIEW_HPP

#include "space_settings.hpp"
#include "globals.hpp"

/* Creating my own mirror view because there is not currently a NoInit option with the standard mirror view */

// 1D mirrorview
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T>
View<T*,CLayout,Device> my_mirror_view(const View<T*,CLayout,Device>& view, Device nd){
    return view;
}

template<class NewDevice, class Device, typename T>
View<T*,CLayout,NewDevice> my_mirror_view(const View<T*,CLayout,Device>& view, NewDevice nd){
    return View<T*,CLayout,NewDevice>(NoInit("mirror"), view.layout());
}

// 1D mirrorview - with scratch
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T>
View<T*,CLayout,Device> my_mirror_view(const View<T*,CLayout,Device>& view, Device nd, const View<T*,CLayout,Device> scratch_view){
    return view;
}

template<class NewDevice, class Device, typename T>
View<T*,CLayout,NewDevice> my_mirror_view(const View<T*,CLayout,Device>& view, NewDevice nd, const View<T*,CLayout,NewDevice> scratch_view){
    return scratch_view;
}

// 2D mirrorview
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T>
View<T**,CLayout,Device> my_mirror_view(const View<T**,CLayout,Device>& view, Device nd){
    return view;
}

template<class NewDevice, class Device, typename T>
View<T**,CLayout,NewDevice> my_mirror_view(const View<T**,CLayout,Device>& view, NewDevice nd){
    return View<T**,CLayout,NewDevice>(NoInit("mirror"), view.layout());
}

// 2D mirrorview with scratch
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T>
View<T**,CLayout,Device> my_mirror_view(const View<T**,CLayout,Device>& view, Device nd, const View<T**,CLayout,Device> scratch_view){
    return view;
}

template<class NewDevice, class Device, typename T>
View<T**,CLayout,NewDevice> my_mirror_view(const View<T**,CLayout,Device>& view, NewDevice nd, const View<T**,CLayout,NewDevice> scratch_view){
    return scratch_view;
}

// 1D mirrorview - unmanaged
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T, typename T2>
View<T*,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>> my_mirror_view(const View<T*,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, Device nd, const T2& scratch_view){
    return view;
}

template<class NewDevice, class Device, typename T, typename T2>
View<T*,CLayout,NewDevice, Kokkos::MemoryTraits<Kokkos::Unmanaged>> my_mirror_view(const View<T*,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, NewDevice nd, const T2& scratch_view){
    return View<T*,CLayout,NewDevice, Kokkos::MemoryTraits<Kokkos::Unmanaged>>(scratch_view.data(), view.layout());
}

// 2D mirrorview - unmanaged
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
// scratch_view is if there is already a place for the mirror to go if needed
template<class Device, typename T, typename T2>
View<T**,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>> my_mirror_view(const View<T**,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, Device nd, const T2& scratch_view){
    return view;
}

template<class NewDevice, class Device, typename T, typename T2>
View<T**,CLayout,NewDevice, Kokkos::MemoryTraits<Kokkos::Unmanaged>> my_mirror_view(const View<T**,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, NewDevice nd, const T2& scratch_view){
    return View<T**,CLayout,NewDevice, Kokkos::MemoryTraits<Kokkos::Unmanaged>>(scratch_view.data(), view.layout());
}

// 1D mirror scratch view - A managed view to reflect an unmanaged view if needed
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
template<class Device, typename T>
View<T*,CLayout,Device> my_mirror_scratch_view(const View<T*,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, Device nd){
    return View<T*,CLayout,Device>();
}

template<class NewDevice, class Device, typename T>
View<T*,CLayout,NewDevice> my_mirror_scratch_view(const View<T*,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, NewDevice nd){
    return View<T*,CLayout,NewDevice>("mirror_scratch", view.layout());
}

// 2D mirror scratch view - A managed view to reflect an unmanaged view if needed
// view is the view that the output will mirror
// nd is used only for the templating, to get the new device (a bit cleaner than the alternative since partial template specialization is not permitted)
template<class Device, typename T>
View<T**,CLayout,Device> my_mirror_scratch_view(const View<T**,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, Device nd){
    return View<T**,CLayout,Device>();
}

template<class NewDevice, class Device, typename T>
View<T**,CLayout,NewDevice> my_mirror_scratch_view(const View<T**,CLayout,Device, Kokkos::MemoryTraits<Kokkos::Unmanaged>>& view, NewDevice nd){
    return View<T**,CLayout,NewDevice>("mirror_scratch", view.layout());
}

// Copies from view_src to view_dest unless they are pointing to the same location.
// This may already be checked in Kokkos::deep_copy.
template<class T1, class T2>
void mirror_copy(T1& view_dest, const T2& view_src){
    if(std::is_same<typename T1::device_type,typename T2::device_type>() && view_dest.data()==view_src.data()){
        // No-op
    }else{
        Kokkos::deep_copy(view_dest, view_src);
    }
}

#endif