HostDArray.h

#ifndef PSCF_HOST_D_ARRAY_H
#define PSCF_HOST_D_ARRAY_H
 
/*
* PSCF Package 
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "DeviceArray.h"
#include "cudaErrorCheck.h"
#include <util/containers/DArray.h>
#include <util/global.h>
#include <cuda_runtime.h>
 
namespace Pscf {
 
   using namespace Util;
 
   template <typename Data>
   class HostDArray : public DArray<Data>
   {
 
   public:
 
      typedef Data ElementType;
 
      HostDArray();
 
      HostDArray(int capacity);
 
      HostDArray(DArray<Data> const & other);
 
      virtual ~HostDArray();
 
      virtual 
      HostDArray<Data>& operator = (const DeviceArray<Data>& other);
 
      void copySlice(DeviceArray<Data> const & other, int beginId);
 
   };
 
   /*
   * Default constructor.
   */
   template <typename Data>
   HostDArray<Data>::HostDArray()
    : DArray<Data>()
   {}
 
   /*
   * Allocating constructor.
   */
   template <typename Data>
   HostDArray<Data>::HostDArray(int capacity)
    : DArray<Data>()
   {  DArray<Data>::allocate(capacity); }
 
   /*
   * Copy constructor. (Copies from any DArray or HostDArray).
   */
   template <typename Data>
   HostDArray<Data>::HostDArray(const DArray<Data>& other)
    : DArray<Data>(other) // Use DArray base class copy constructor
   {}
 
   /*
   * Destructor.
   */
   template <typename Data>
   HostDArray<Data>::~HostDArray()
   {} // DArray base class destructor will deallocate memory
 
   /*
   * Assignment from a DeviceArray<Data> RHS device array.
   */
   template <typename Data>
   HostDArray<Data>& 
   HostDArray<Data>::operator = (const DeviceArray<Data>& other)
   {
      // Precondition - RHS array must be allocated
      if (!other.isAllocated()) {
         UTIL_THROW("RHS DeviceArray<Data> must be allocated.");
      }
 
      // Allocate this if necessary 
      if (!DArray<Data>::isAllocated()) {
         DArray<Data>::allocate(other.capacity());
      } 
 
      // Require equal capacities
      if (DArray<Data>::capacity() != other.capacity()) {
         UTIL_THROW("Cannot assign arrays of unequal capacity");
      }
 
      // Copy all elements
      cudaErrorCheck( cudaMemcpy(DArray<Data>::cArray(), other.cArray(), 
                                 DArray<Data>::capacity() * sizeof(Data), 
                                 cudaMemcpyDeviceToHost) );
 
      return *this;
   }
 
   /*
   * Copy a slice of the data from a larger DeviceArray into this array.
   */
   template <typename Data>
   void HostDArray<Data>::copySlice(DeviceArray<Data> const & other,
                                    int beginId)
   {
      // Precondition - device array must be allocated
      if (!other.isAllocated()) {
         UTIL_THROW("RHS DeviceArray<Data> must be allocated.");
      }
 
      // Precondition - host array must be allocated
      if (!DArray<Data>::isAllocated()) {
         UTIL_THROW("LHS HostDArray<Data> must be allocated.");
      } 
 
      // Slice must not exceed the capacity of device array
      if (DArray<Data>::capacity() + beginId > other.capacity()) {
         UTIL_THROW("Slice must not exceed the capacity of device array.");
      }
 
      // Copy all elements
      cudaErrorCheck( cudaMemcpy(DArray<Data>::cArray(), 
                                 other.cArray() + beginId, 
                                 DArray<Data>::capacity() * sizeof(Data), 
                                 cudaMemcpyDeviceToHost) );
   }
 
}
#endif