DeviceVector.h

Go to the documentation of this file.

 
#pragma once
 
// STL Includes
#include <algorithm>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
// External Includes
 
// Local Includes
#include "../global/global.h"
#include "../global/global_cuda.h"
#include "../utils/gpu.hpp"
 
// =============================================================================
// Declaration of DeviceVector class
// =============================================================================
namespace cuda_utilities
{
template <typename T>
class DeviceVector
{
  static_assert(std::is_trivially_copyable_v<T>,
                "DeviceVector can only be used with trivially_copyable types due to the internal "
                "usage of functions like cudaMemcpy, cudaMemcpyPeer, cudaMemset");
 
 public:
  typedef T value_type;
 
  DeviceVector() noexcept : _size(0), _ptr(nullptr) {}
 
  DeviceVector(size_t const size, bool const initialize = false);
 
  DeviceVector(DeviceVector<T> &&other) noexcept
      : _size(std::exchange(other._size, 0)), _ptr(std::exchange(other._ptr, nullptr))
  {
  }
 
  DeviceVector &operator=(DeviceVector<T> &&other) noexcept
  {
    std::swap(_size, other._size);
    std::swap(_ptr, other._ptr);
    return *this;
  }
 
  ~DeviceVector() { _deAllocate(); }
 
  /* The following are deleted because they currently lead to invalid state.
   * (But they can all easily be implemented in the future).
   */
  DeviceVector(const DeviceVector<T> &)                    = delete;
  DeviceVector<T> &operator=(const DeviceVector<T> &other) = delete;
 
  T *data() { return _ptr; }
 
  size_t size() { return _size; }
 
  T operator[](size_t const &index);
 
  T at(size_t const index);
 
  void assign(T const &hostValue, size_t const &index = 0);
 
  void resize(size_t const newSize);
 
  void reset(size_t const newSize);
 
  void cpyHostToDevice(const T *arrIn, size_t const &arrSize);
 
  void cpyHostToDevice(std::vector<T> const &vecIn) { cpyHostToDevice(vecIn.data(), vecIn.size()); }
 
  void cpyDeviceToHost(T *arrOut, size_t const &arrSize);
 
  void cpyDeviceToHost(std::vector<T> &vecOut) { cpyDeviceToHost(vecOut.data(), vecOut.size()); }
 
 private:
  size_t _size;
 
  T *_ptr = nullptr;
 
  void _allocate(size_t const size)
  {
    _size = size;
    if (size == 0) {
      _ptr = nullptr;
    } else {
      GPU_Error_Check(cudaMalloc(&_ptr, _size * sizeof(T)));
    }
  }
 
  void _deAllocate()
  {
    if (_ptr != nullptr) GPU_Error_Check(cudaFree(_ptr));
  }
};
}  // namespace cuda_utilities
// =============================================================================
// End declaration of DeviceVector class
// =============================================================================
 
// =============================================================================
// Definition of DeviceVector class
// =============================================================================
namespace cuda_utilities
{
// =========================================================================
// Public Methods
// =========================================================================
 
// =========================================================================
template <typename T>
DeviceVector<T>::DeviceVector(size_t const size, bool const initialize) : DeviceVector()
{
  if (size > 0) {
    _allocate(size);
 
    if (initialize) {
      GPU_Error_Check(cudaMemset(_ptr, 0, _size * sizeof(T)));
    }
  }
}
// =========================================================================
 
// =========================================================================
template <typename T>
void DeviceVector<T>::resize(size_t const newSize)
{
  // Assign old array to a new pointer
  T *oldDevPtr = _ptr;
 
  // Determine how many elements to copy
  size_t const count = std::min(_size, newSize) * sizeof(T);
 
  // Allocate new array
  _allocate(newSize);
 
  if (oldDevPtr != nullptr) {
    // Copy the values from the old array to the new array
    GPU_Error_Check(cudaMemcpyPeer(_ptr, 0, oldDevPtr, 0, count));
 
    // Free the old array
    GPU_Error_Check(cudaFree(oldDevPtr));
  }
}
// =========================================================================
 
// =========================================================================
template <typename T>
void DeviceVector<T>::reset(size_t const newSize)
{
  _deAllocate();
  _allocate(newSize);
}
// =========================================================================
 
// =========================================================================
template <typename T>
T DeviceVector<T>::operator[](size_t const &index)
{
  T hostValue;
  GPU_Error_Check(cudaMemcpy(&hostValue, &(_ptr[index]), sizeof(T), cudaMemcpyDeviceToHost));
  return hostValue;
}
// =========================================================================
 
// =========================================================================
template <typename T>
T DeviceVector<T>::at(size_t const index)
{
  if (index < _size) {
    // Use the overloaded [] operator to grab the value from GPU memory
    // into host memory
    return (*this)[index];
  } else {
    throw std::out_of_range(
        "Warning: DeviceVector.at() detected an"
        " out of bounds memory access. Tried to"
        " access element " +
        std::to_string(index) + " of " + std::to_string(_size));
  }
}
// =========================================================================
 
// =========================================================================
template <typename T>
void DeviceVector<T>::assign(T const &hostValue, size_t const &index)
{
  GPU_Error_Check(cudaMemcpy(&(_ptr[index]),  // destination
                             &hostValue,      // source
                             sizeof(T), cudaMemcpyHostToDevice));
}
// =========================================================================
 
// =========================================================================
template <typename T>
void DeviceVector<T>::cpyHostToDevice(const T *arrIn, size_t const &arrSize)
{
  if (arrSize <= _size) {
    GPU_Error_Check(cudaMemcpy(_ptr, arrIn, arrSize * sizeof(T), cudaMemcpyHostToDevice));
  } else {
    throw std::out_of_range(
        "Warning: Couldn't copy array to device,"
        " device array is too small. Host array"
        " size=" +
        std::to_string(arrSize) + ", device array size=" + std::to_string(arrSize));
  }
}
// =========================================================================
 
// =========================================================================
template <typename T>
void DeviceVector<T>::cpyDeviceToHost(T *arrOut, size_t const &arrSize)
{
  if (_size <= arrSize) {
    GPU_Error_Check(cudaMemcpy(arrOut, _ptr, _size * sizeof(T), cudaMemcpyDeviceToHost));
  } else {
    throw std::out_of_range(
        "Warning: Couldn't copy array to host, "
        "host array is too small. Host array "
        "size=" +
        std::to_string(arrSize) + ", device array size=" + std::to_string(arrSize));
  }
}
// =========================================================================
}  // end namespace cuda_utilities
   // =============================================================================
   // End definition of DeviceVector class
   // =============================================================================