cudaPtr.hpp

Go to the documentation of this file.

/** \file cudaPtr.hpp
  * \author Jared R. Males
  * \brief A wrapper for cuda device pointers
  * \ingroup cuda_files
  *
  */
 
//***********************************************************************//
// Copyright 2019,2020 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef math_cudaPtr_hpp
#define math_cudaPtr_hpp
 
#include <iostream>
 
#include <cuda_runtime.h>
 
#include "templateCuda.hpp"
 
namespace mx
{
namespace cuda
{
   
/// A smart-pointer wrapper for cuda device pointers.
/**
  * \ingroup cuda 
  */ 
template<typename T>
struct cudaPtr
{
   ///The host data type.
   //typedef typename cudaType<T>::hostType hostPtrT;
   typedef T hostPtrT;
   
   ///The device data type
   //typedef typename cudaType<T>::deviceType devicePtrT;
   typedef T devicePtrT;
   
   ///The device pointer
   devicePtrT * m_devicePtr {nullptr};
 
   ///The allocated size
   size_t m_size {0};
   
   ///Destructor, frees memory if allocated.
   ~cudaPtr();
   
   size_t size()
   {
      return m_size;
   }
   
   ///Resize the memory allocation, in 1D
   /** If no size change, this is a no-op.
     *
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     * \test Scenario: scaling a vector with cublas \ref test_math_templateCublas_scal "[test doc]"
     * \test Scenario: scaling and accumulating a vector with cublas \ref test_math_templateCublas_axpy "[test doc]"
     * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
     */
   int resize( size_t sz /**< [in] the new size */);
   
   ///Resize the memory allocation, in 2D
   /** If no size change, this is a no-op.
     *
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     */
   int resize( size_t x_sz, ///< [in] the new x size,
               size_t y_sz  ///< [in] the new y size
             );
   
   ///Resize the memory allocation, in 3D
   /** If no size change, this is a no-op.
     *
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     */
   int resize( size_t x_sz, ///< [in] the new x size,
               size_t y_sz, ///< [in] the new y size,
               size_t z_sz  ///< [in] the new z size
             );
   
   /// Initialize the array bytes to 0.
   /** Just a wrapper to cudaMemset.
     *
     */  
   cudaError_t initialize();
   
   ///Free the memory allocation
   /** 
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     */
   int free();
   
   ///Copy from the host to the device, after allocation.
   /**
     * The device pointer must be allocated.
     * 
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
     */ 
   int upload( const hostPtrT * src /**< [in] The host location */);
   
   ///Copy from the host to the device with allocation.
   /**
     * The device pointer will be re-allocated as needed.
     * 
     * \returns 0 on success.
     * \returns a cuda error code otherwise.
     * 
     * \test Scenario: scaling a vector with cublas \ref test_math_templateCublas_scal "[test doc]"
     * \test Scenario: scaling and accumulating a vector with cublas \ref test_math_templateCublas_axpy "[test doc]"
     * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
     */
   int upload( const hostPtrT * src, ///< [in] The host location
               size_t sz ///< [in] The size of the array
             );
   
   ///Copy from the device to the host.
   /**
     *
     * \test Scenario: scaling a vector with cublas \ref test_math_templateCublas_scal "[test doc]"
     * \test Scenario: scaling and accumulating a vector with cublas \ref test_math_templateCublas_axpy "[test doc]"
     * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
     */ 
   int download( hostPtrT * dest /**< [in] The host location, allocated.*/ );
   
   ///Conversion operator, accesses the device pointer for use in Cuda functions.
   /**
     * \test Scenario: scaling and accumulating a vector with cublas \ref test_math_templateCublas_axpy "[test doc]"
     * \test Scenario: multiplying two vectors element by element \ref test_math_templateCublas_elementwiseXxY "[test doc]"
     */ 
   typename cpp2cudaType<devicePtrT>::cudaType* operator()()
   {
      return (typename cpp2cudaType<devicePtrT>::cudaType*) m_devicePtr;
   }
   
   /// Conversion operator, accesses the device pointer for use in Cuda functions.
   /**
     *
     * \test Scenario: scaling a vector with cublas \ref test_math_templateCublas_scal "[test doc]"
     */ 
   const typename cpp2cudaType<devicePtrT>::cudaType* operator()() const
   {
      return (typename cpp2cudaType<devicePtrT>::cudaType*) m_devicePtr;
   }
   
};
 
template<typename T>
cudaPtr<T>::~cudaPtr()
{
   free();
}
 
template<typename T>
int cudaPtr<T>::resize( size_t sz )
{
   if( m_size == sz ) return 0;
   
   m_size = sz;
   
   cudaError_t rv = cudaMalloc((void **)&m_devicePtr, sz*sizeof(devicePtrT));
   
   if(rv != cudaSuccess)
   {
      std::cerr << "Error from cudaMalloc: ";
      printf("[%s] %s\n", cudaGetErrorName(rv), cudaGetErrorString(rv));
   }
   
   return 0;
   
}
 
template<typename T>
int cudaPtr<T>::resize( size_t x_sz,
                        size_t y_sz
                      )
{
   return resize(x_sz*y_sz);
}
 
template<typename T>
int cudaPtr<T>::resize( size_t x_sz,
                        size_t y_sz,
                        size_t z_sz
                      )
{
   return resize(x_sz*y_sz*z_sz);
}
 
template<typename T>
cudaError_t cudaPtr<T>::initialize()
{
   return ::cudaMemset(m_devicePtr, 0, m_size*sizeof(devicePtrT));
}
   
template<typename T>
int cudaPtr<T>::free()
{
   if(m_devicePtr)
   {
      int rv = cudaFree(m_devicePtr);
      
      if(rv != cudaSuccess)
      {
         std::cerr << "Cuda Free Error \n";
         return rv;
      }  
   }
   
   m_devicePtr = 0;
   m_size = 0;
   
   return 0;
}
 
template<typename T>
int cudaPtr<T>::upload( const hostPtrT * src )
{
    // Copy host memory to device
   int rv = cudaMemcpy( m_devicePtr, src, m_size*sizeof(devicePtrT), cudaMemcpyHostToDevice);
   
   if(rv != cudaSuccess)
   {
      std::cerr << "Cuda Memcpy error \n";
      return rv;
   }
   
   return 0;
}
 
template<typename T>
int cudaPtr<T>::upload( const hostPtrT * src,
                        size_t sz
                      )
{
   int rv;
   
   rv = resize(sz);
   
   if(rv) return rv;
   
   return upload(src);
}
 
template<typename T>
int cudaPtr<T>::download( hostPtrT * dest )
{
    // Copy device memory to host
   int rv = cudaMemcpy( dest,  m_devicePtr, m_size*sizeof(devicePtrT), cudaMemcpyDeviceToHost);
   
   if(rv != cudaSuccess)
   {
      std::cerr << "Cuda Memcpy error \n";
      return rv;
   }
   
   return 0;
}
 
}//namespace cuda 
}//namespace mx
#endif // math_cudaPtr_hpp