host_array.hpp

Go to the documentation of this file.

#ifndef HOST_ARRAY_HPP
#define HOST_ARRAY_HPP

/* The purpose of this class is to allow an object that gets sent to device via a lambda function (copy by value) to also contain an array of member objects (in host memory only) that contain Kokkos Views.
 * This is not allowed by std::vector due to the vector destructor not compiling with cuda, and using a Kokkos::View creates warnings and is generally overkill.
 * All we want is an array that does not get deallocated when a copy of the array is destroyed.
 * The default constructor, copy assignment, copy constructor, and destructor can be safely called from device; none of these allocate or deallocate memory.
 * All other operations are host-only.
 */
template<typename T>
class HostArray{

    T* array;

    bool owns_array;
    size_t n;

    public:

    // Default constructor
    KOKKOS_INLINE_FUNCTION HostArray()
      : owns_array(false),
        n(0) {}

    // Constructor allocates
    HostArray(size_t n_in)
      : owns_array(true),
        n(n_in)
    {
        array = new T[n_in];
    }

    // Destructor
    KOKKOS_INLINE_FUNCTION ~HostArray(){
        // Deallocate only if this was the object that did the allocation
        if(owns_array) delete[] array;
    }
 
    // Copy constructor
    KOKKOS_INLINE_FUNCTION HostArray(const HostArray& other)
      : array(other.array),
        owns_array(false),
        n(other.n) {}
 
    // Copy assignment
    KOKKOS_INLINE_FUNCTION HostArray& operator=(const HostArray& other){
        HostArray new_array(other);
        new_array.owns_array = false;
        new_array.n = other.n;
        return *this = new_array;
    }

    // Move constructor
    HostArray(HostArray&& other) noexcept 
      : owns_array(other.owns_array),
        n(other.n),
        array(std::exchange(other.array, nullptr))
    {
        other.owns_array = false;
        other.n = 0;
    }
 
    // Move assignment
    HostArray& operator=(HostArray&& other) noexcept{
        n = other.n;
        owns_array = other.owns_array;
        std::swap(array, other.array);
        other.owns_array = false;
        other.n = 0;
        return *this;
    }

    // Accessors ()
    T operator ()(int i) const {return array[i];}
    T& operator ()(int i) {return array[i];}

    // Size
    size_t size() const{
        return n;
    }
};

#endif