HostDArray.h

#ifndef PSCF_HOST_D_ARRAY_H
#define PSCF_HOST_D_ARRAY_H
 
/*
* PSCF - Polymer Self-Consistent Field 
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/containers/DArray.h>
 
namespace Pscf {
 
   // Forward declaration
   template <typename T> class DeviceArray;
 
   using namespace Util;

   template <typename Data>
   class HostDArray : public DArray<Data>
   {
 
   public:

      using ValueType = Data;

      HostDArray();

      HostDArray(int capacity);
 
      HostDArray(HostDArray<Data> const & other) = default;

      HostDArray(DeviceArray<Data> const & other);

      virtual ~HostDArray();
 
      HostDArray<Data>& operator = (HostDArray<Data> const & other) = default;

      HostDArray<Data>& operator = (DeviceArray<Data> const & other);

      void copySlice(DeviceArray<Data> const & other, int beginId);
 
   };
 
} // namespace Pscf
 
#include "DeviceArray.h"
#include "cudaErrorCheck.h"
#include <util/global.h>
#include <cuda_runtime.h>
 
namespace Pscf {
 
   /*
   * 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 - deep copy DeviceArray from device to host.
   */
   template <typename Data>
   HostDArray<Data>::HostDArray(const DeviceArray<Data>& other)
    : DArray<Data>() 
   {  
      // Precondition - RHS array must be allocated
      if (!other.isAllocated()) {
         UTIL_THROW("RHS DeviceArray<Data> must be allocated.");
      }
 
      DArray<Data>::allocate(other.capacity());
      cudaErrorCheck( cudaMemcpy(DArray<Data>::cArray(), other.cArray(), 
                                 DArray<Data>::capacity() * sizeof(Data), 
                                 cudaMemcpyDeviceToHost) );
   }
 
   /*
   * 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 = (DeviceArray<Data> const & 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