DeviceAPICalls.h

Go to the documentation of this file.

#ifdef DFTEFE_WITH_DEVICE
 
#  ifndef dftefeDeviceAPICalls_H
#    define dftefeDeviceAPICalls_H
 
#    include "TypeConfig.h"
#    include <utils/DeviceTypeConfig.h>
#    include <iostream>
 
namespace dftefe
{
  namespace utils
  {
    deviceError_t
    deviceReset();
 
    deviceError_t
    deviceMemGetInfo(std::size_t *free, std::size_t *total);
 
    deviceError_t
    getDeviceCount(int *count);
 
    deviceError_t
    getDevice(int *deviceId);
 
    deviceError_t
    setDevice(int deviceId);
 
    deviceError_t
    deviceMalloc(void **devPtr, std::size_t size);
 
    deviceError_t
    deviceMemset(void *devPtr, int value, std::size_t count);
 
    template <typename ValueType>
    void
    deviceSetValue(ValueType *devPtr, ValueType value, std::size_t size);
 
    deviceError_t
    deviceFree(void *devPtr);
 
    deviceError_t
    hostPinnedMalloc(void **hostPtr, std::size_t size);
 
    deviceError_t
    hostPinnedFree(void *hostPtr);
 
    deviceError_t
    deviceMemcpyD2H(void *dst, const void *src, std::size_t count);
 
    deviceError_t
    deviceMemcpyD2D(void *dst, const void *src, std::size_t count);
 
    deviceError_t
    deviceMemcpyH2D(void *dst, const void *src, std::size_t count);
 
    deviceError_t
    deviceMemcpyD2H_2D(void *      dst,
                       std::size_t dpitch,
                       const void *src,
                       std::size_t spitch,
                       std::size_t width,
                       std::size_t height);
 
    deviceError_t
    deviceMemcpyD2D_2D(void *      dst,
                       std::size_t dpitch,
                       const void *src,
                       std::size_t spitch,
                       std::size_t width,
                       std::size_t height);
 
    deviceError_t
    deviceMemcpyH2D_2D(void *      dst,
                       std::size_t dpitch,
                       const void *src,
                       std::size_t spitch,
                       std::size_t width,
                       std::size_t height);
 
    deviceError_t
    deviceSynchronize();
 
    deviceError_t
    deviceMemcpyAsyncD2H(void *         dst,
                         const void *   src,
                         std::size_t    count,
                         deviceStream_t stream = dftefe::utils::defaultStream);
 
    deviceError_t
    deviceMemcpyAsyncD2D(void *         dst,
                         const void *   src,
                         std::size_t    count,
                         deviceStream_t stream = dftefe::utils::defaultStream);
 
    deviceError_t
    deviceMemcpyAsyncH2D(void *         dst,
                         const void *   src,
                         std::size_t    count,
                         deviceStream_t stream = dftefe::utils::defaultStream);
 
 
    deviceError_t
    deviceStreamCreate(deviceStream_t &pStream, const bool nonBlocking = false);
 
    deviceError_t
    deviceStreamDestroy(deviceStream_t &stream);
 
    deviceError_t
    deviceStreamSynchronize(deviceStream_t &stream);
 
    deviceError_t
    deviceEventCreate(deviceEvent_t &pEvent);
 
    deviceError_t
    deviceEventDestroy(deviceEvent_t &event);
 
    deviceError_t
    deviceEventRecord(deviceEvent_t &event,
                      deviceStream_t stream = dftefe::utils::defaultStream);
 
    deviceError_t
    deviceEventSynchronize(deviceEvent_t &event);
 
    deviceError_t
    deviceStreamWaitEvent(deviceStream_t &stream,
                          deviceEvent_t & event,
                          unsigned int    flags = 0);
 
    void
    printPointerLocation(const void *ptr);
  } // namespace utils
} // namespace dftefe
 
#  endif // dftefeDeviceAPICalls_H
#endif   // DFTEFE_WITH_DEVICE