#include <CudaMgr.h>

Public Member Functions
	CudaMgr (const int num_gpus, const int start_gpu=0)

	~CudaMgr ()

void	synchronizeDevices () const

int	getDeviceCount () const

int	getStartGpu () const

const omnisci::DeviceGroup &	getDeviceGroup () const

void	copyHostToDevice (int8_t device_ptr, const int8_t host_ptr, const size_t num_bytes, const int device_num)

void	copyDeviceToHost (int8_t host_ptr, const int8_t device_ptr, const size_t num_bytes, const int device_num)

void	copyDeviceToDevice (int8_t dest_ptr, int8_t src_ptr, const size_t num_bytes, const int dest_device_num, const int src_device_num)

int8_t *	allocatePinnedHostMem (const size_t num_bytes)

int8_t *	allocateDeviceMem (const size_t num_bytes, const int device_num)

void	freePinnedHostMem (int8_t *host_ptr)

void	freeDeviceMem (int8_t *device_ptr)

void	zeroDeviceMem (int8_t *device_ptr, const size_t num_bytes, const int device_num)

void	setDeviceMem (int8_t *device_ptr, const unsigned char uc, const size_t num_bytes, const int device_num)

size_t	getMaxSharedMemoryForAll () const

const std::vector< DeviceProperties > &	getAllDeviceProperties () const

const DeviceProperties *	getDeviceProperties (const size_t device_num) const

bool	isArchMaxwell () const

bool	isArchMaxwellOrLater () const

bool	isArchPascal () const

bool	isArchPascalOrLater () const

bool	isArchMaxwellOrLaterForAll () const

bool	isArchVoltaForAll () const

void	setContext (const int device_num) const

Private Attributes
int	device_count_

int	gpu_driver_version_

int	start_gpu_

size_t	max_shared_memory_for_all_

std::vector< DeviceProperties >	device_properties_

omnisci::DeviceGroup	device_group_

std::vector< CUcontext >	device_contexts_

std::mutex	device_cleanup_mutex_

Detailed Description

Definition at line 82 of file CudaMgr.h.

Constructor & Destructor Documentation

◆ CudaMgr()

CudaMgr_Namespace::CudaMgr::CudaMgr	(	const int	num_gpus,
		const int	start_gpu = `0`
	)

Definition at line 35 of file CudaMgr.cpp.

References CHECK_EQ, CHECK_LE, device_count_, device_group_, device_properties_, and start_gpu_.

     : start_gpu_(start_gpu), max_shared_memory_for_all_(0) {
   checkError(cuInit(0));
   checkError(cuDeviceGetCount(&device_count_));
 
   if (num_gpus > 0) {  // numGpus <= 0 will just use number of gpus found
     CHECK_LE(num_gpus + start_gpu_, device_count_);
     device_count_ = std::min(device_count_, num_gpus);
   } else {
     // if we are using all gpus we cannot start on a gpu other than 0
     CHECK_EQ(start_gpu_, 0);
   }
   fillDeviceProperties();
   initDeviceGroup();
   createDeviceContexts();
   printDeviceProperties();
 }

◆ ~CudaMgr()

CudaMgr_Namespace::CudaMgr::~CudaMgr ( )

Definition at line 60 of file CudaMgr.cpp.

References device_cleanup_mutex_, device_contexts_, device_count_, logger::ERROR, LOG, and synchronizeDevices().

                   {
   try {
     // We don't want to remove the cudaMgr before all other processes have cleaned up.
     // This should be enforced by the lifetime policies, but take this lock to be safe.
     std::lock_guard<std::mutex> gpu_lock(device_cleanup_mutex_);
 
     synchronizeDevices();
     for (int d = 0; d < device_count_; ++d) {
       checkError(cuCtxDestroy(device_contexts_[d]));
     }
   } catch (const CudaErrorException& e) {
     if (e.getStatus() == CUDA_ERROR_DEINITIALIZED) {
       // TODO(adb / asuhan): Verify cuModuleUnload removes the context
       return;
     }
     LOG(ERROR) << "CUDA Error: " << e.what();
   } catch (const std::runtime_error& e) {
     LOG(ERROR) << "CUDA Error: " << e.what();
   }
 }

Here is the call graph for this function:

Member Function Documentation

◆ allocateDeviceMem()

int8_t * CudaMgr_Namespace::CudaMgr::allocateDeviceMem	(	const size_t	num_bytes,
		const int	device_num
	)

Definition at line 224 of file CudaMgr.cpp.

References setContext().

Referenced by Buffer_Namespace::GpuCudaBufferMgr::addSlab().

                                                                                {
   setContext(device_num);
   CUdeviceptr device_ptr;
   checkError(cuMemAlloc(&device_ptr, num_bytes));
   return reinterpret_cast<int8_t*>(device_ptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allocatePinnedHostMem()

int8_t * CudaMgr_Namespace::CudaMgr::allocatePinnedHostMem ( const size_t num_bytes )

Definition at line 217 of file CudaMgr.cpp.

References setContext().

                                                              {
   setContext(0);
   void* host_ptr;
   checkError(cuMemHostAlloc(&host_ptr, num_bytes, CU_MEMHOSTALLOC_PORTABLE));
   return reinterpret_cast<int8_t*>(host_ptr);
 }

Here is the call graph for this function:

◆ copyDeviceToDevice()

void CudaMgr_Namespace::CudaMgr::copyDeviceToDevice	(	int8_t *	dest_ptr,
		int8_t *	src_ptr,
		const size_t	num_bytes,
		const int	dest_device_num,
		const int	src_device_num
	)

Definition at line 106 of file CudaMgr.cpp.

References CHECK, device_cleanup_mutex_, device_contexts_, device_count_, device_properties_, logger::ERROR, gpu_driver_version_, LOG, max_shared_memory_for_all_, setContext(), and start_gpu_.

Referenced by Buffer_Namespace::GpuCudaBuffer::readData(), and Buffer_Namespace::GpuCudaBuffer::writeData().

                                                            {
   // dest_device_num and src_device_num are the device numbers relative to start_gpu_
   // (real_device_num - start_gpu_)
   if (src_device_num == dest_device_num) {
     setContext(src_device_num);
     checkError(cuMemcpy(reinterpret_cast<CUdeviceptr>(dest_ptr),
                         reinterpret_cast<CUdeviceptr>(src_ptr),
                         num_bytes));
   } else {
     checkError(cuMemcpyPeer(reinterpret_cast<CUdeviceptr>(dest_ptr),
                             device_contexts_[dest_device_num],
                             reinterpret_cast<CUdeviceptr>(src_ptr),
                             device_contexts_[src_device_num],
                             num_bytes));  // will we always have peer?
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyDeviceToHost()

void CudaMgr_Namespace::CudaMgr::copyDeviceToHost	(	int8_t *	host_ptr,
		const int8_t *	device_ptr,
		const size_t	num_bytes,
		const int	device_num
	)

Definition at line 97 of file CudaMgr.cpp.

References setContext().

Referenced by Buffer_Namespace::GpuCudaBuffer::readData(), and Buffer_Namespace::CpuBuffer::writeData().

                                                      {
   setContext(device_num);
   checkError(
       cuMemcpyDtoH(host_ptr, reinterpret_cast<const CUdeviceptr>(device_ptr), num_bytes));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyHostToDevice()

void CudaMgr_Namespace::CudaMgr::copyHostToDevice	(	int8_t *	device_ptr,
		const int8_t *	host_ptr,
		const size_t	num_bytes,
		const int	device_num
	)

Definition at line 88 of file CudaMgr.cpp.

References setContext().

Referenced by Buffer_Namespace::CpuBuffer::readData(), and Buffer_Namespace::GpuCudaBuffer::writeData().

                                                      {
   setContext(device_num);
   checkError(
       cuMemcpyHtoD(reinterpret_cast<CUdeviceptr>(device_ptr), host_ptr, num_bytes));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ freeDeviceMem()

void CudaMgr_Namespace::CudaMgr::freeDeviceMem ( int8_t * device_ptr )

Definition at line 235 of file CudaMgr.cpp.

References device_cleanup_mutex_.

Referenced by Buffer_Namespace::GpuCudaBufferMgr::freeAllMem().

                                               {
   std::lock_guard<std::mutex> gpu_lock(device_cleanup_mutex_);
 
   checkError(cuMemFree(reinterpret_cast<CUdeviceptr>(device_ptr)));
 }

Here is the caller graph for this function:

◆ freePinnedHostMem()

void CudaMgr_Namespace::CudaMgr::freePinnedHostMem ( int8_t * host_ptr )

Definition at line 231 of file CudaMgr.cpp.

                                                 {
   checkError(cuMemFreeHost(reinterpret_cast<void*>(host_ptr)));
 }

◆ getAllDeviceProperties()

const std::vector<DeviceProperties>& CudaMgr_Namespace::CudaMgr::getAllDeviceProperties ( ) const

inline

Definition at line 118 of file CudaMgr.h.

                                                                     {
     return device_properties_;
   }

◆ getDeviceCount()

int CudaMgr_Namespace::CudaMgr::getDeviceCount ( ) const

inline

Definition at line 88 of file CudaMgr.h.

Referenced by CodeGenerator::generateNativeGPUCode(), and get_available_gpus().

88 { return device_count_; }

CudaMgr_Namespace::CudaMgr::device_count_

int device_count_

Definition: CudaMgr.h:172

Here is the caller graph for this function:

◆ getDeviceGroup()

const omnisci::DeviceGroup& CudaMgr_Namespace::CudaMgr::getDeviceGroup ( ) const

inline

Definition at line 90 of file CudaMgr.h.

90 { return device_group_; }

CudaMgr_Namespace::CudaMgr::device_group_

omnisci::DeviceGroup device_group_

Definition: CudaMgr.h:177

◆ getDeviceProperties()

const DeviceProperties* CudaMgr_Namespace::CudaMgr::getDeviceProperties ( const size_t device_num ) const

inline

Definition at line 121 of file CudaMgr.h.

References to_string().

                                                                              {
     // device_num is the device number relative to start_gpu_ (real_device_num -
     // start_gpu_)
     if (device_num < device_properties_.size()) {
       return &device_properties_[device_num];
     }
     throw std::runtime_error("Specified device number " + std::to_string(device_num) +
                              " is out of range of number of devices (" +
                              std::to_string(device_properties_.size()) + ")");
   }

Here is the call graph for this function:

◆ getMaxSharedMemoryForAll()

size_t CudaMgr_Namespace::CudaMgr::getMaxSharedMemoryForAll ( ) const

inline

Definition at line 116 of file CudaMgr.h.

116 { return max_shared_memory_for_all_; }

CudaMgr_Namespace::CudaMgr::max_shared_memory_for_all_

size_t max_shared_memory_for_all_

Definition: CudaMgr.h:175

◆ getStartGpu()

int CudaMgr_Namespace::CudaMgr::getStartGpu ( ) const

inline

Definition at line 89 of file CudaMgr.h.

89 { return start_gpu_; }

CudaMgr_Namespace::CudaMgr::start_gpu_

int start_gpu_

Definition: CudaMgr.h:174

◆ isArchMaxwell()

bool CudaMgr_Namespace::CudaMgr::isArchMaxwell ( ) const

inline

Definition at line 131 of file CudaMgr.h.

                                     {
     return (getDeviceCount() > 0 && device_properties_[0].computeMajor == 5);
   }

◆ isArchMaxwellOrLater()

bool CudaMgr_Namespace::CudaMgr::isArchMaxwellOrLater ( ) const

inline

Definition at line 134 of file CudaMgr.h.

                                            {
     return (getDeviceCount() > 0 && device_properties_[0].computeMajor >= 5);
   }

◆ isArchMaxwellOrLaterForAll()

bool CudaMgr_Namespace::CudaMgr::isArchMaxwellOrLaterForAll ( ) const

Returns true if all devices have Maxwell micro-architecture, or later. Returns false, if there is any device with compute capability of < 5.0

Definition at line 259 of file CudaMgr.cpp.

References device_count_, and device_properties_.

                                                {
   for (int i = 0; i < device_count_; i++) {
     if (device_properties_[i].computeMajor < 5) {
       return false;
     }
   }
   return true;
 }

◆ isArchPascal()

bool CudaMgr_Namespace::CudaMgr::isArchPascal ( ) const

inline

Definition at line 137 of file CudaMgr.h.

                                    {
     return (getDeviceCount() > 0 && device_properties_[0].computeMajor == 6);
   }

◆ isArchPascalOrLater()

bool CudaMgr_Namespace::CudaMgr::isArchPascalOrLater ( ) const

inline

Definition at line 140 of file CudaMgr.h.

                                           {
     return (getDeviceCount() > 0 && device_properties_[0].computeMajor >= 6);
   }

◆ isArchVoltaForAll()

bool CudaMgr_Namespace::CudaMgr::isArchVoltaForAll ( ) const

Returns true if all devices have Volta micro-architecture Returns false, if there is any non-Volta device available.

Definition at line 272 of file CudaMgr.cpp.

References CHECK_EQ, device_contexts_, device_count_, device_properties_, logger::ERROR, CudaMgr_Namespace::errorMessage(), and LOG.

                                       {
   for (int i = 0; i < device_count_; i++) {
     if (device_properties_[i].computeMajor != 7) {
       return false;
     }
   }
   return true;
 }

Here is the call graph for this function:

◆ setContext()

void CudaMgr_Namespace::CudaMgr::setContext ( const int device_num ) const

Definition at line 322 of file CudaMgr.cpp.

References CHECK_LT, device_contexts_, device_count_, device_properties_, logger::INFO, LOG, and VLOG.

Referenced by allocateDeviceMem(), allocatePinnedHostMem(), copyDeviceToDevice(), copyDeviceToHost(), copyHostToDevice(), setDeviceMem(), and synchronizeDevices().

                                                    {
   // deviceNum is the device number relative to startGpu (realDeviceNum - startGpu_)
   CHECK_LT(device_num, device_count_);
   cuCtxSetCurrent(device_contexts_[device_num]);
 }

Here is the caller graph for this function:

◆ setDeviceMem()

void CudaMgr_Namespace::CudaMgr::setDeviceMem	(	int8_t *	device_ptr,
		const unsigned char	uc,
		const size_t	num_bytes,
		const int	device_num
	)

Definition at line 247 of file CudaMgr.cpp.

References setContext().

Referenced by zeroDeviceMem().

                                                  {
   setContext(device_num);
   checkError(cuMemsetD8(reinterpret_cast<CUdeviceptr>(device_ptr), uc, num_bytes));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ synchronizeDevices()

void CudaMgr_Namespace::CudaMgr::synchronizeDevices ( ) const

Definition at line 81 of file CudaMgr.cpp.

References device_count_, and setContext().

Referenced by ~CudaMgr(), and Buffer_Namespace::GpuCudaBufferMgr::~GpuCudaBufferMgr().

                                        {
   for (int d = 0; d < device_count_; ++d) {
     setContext(d);
     checkError(cuCtxSynchronize());
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zeroDeviceMem()

void CudaMgr_Namespace::CudaMgr::zeroDeviceMem	(	int8_t *	device_ptr,
		const size_t	num_bytes,
		const int	device_num
	)

Definition at line 241 of file CudaMgr.cpp.

References setDeviceMem().

Referenced by ResultSet::ResultSet().

                                                   {
   setDeviceMem(device_ptr, 0, num_bytes, device_num);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ device_cleanup_mutex_

std::mutex CudaMgr_Namespace::CudaMgr::device_cleanup_mutex_

mutableprivate

Definition at line 180 of file CudaMgr.h.

Referenced by copyDeviceToDevice(), freeDeviceMem(), and ~CudaMgr().

◆ device_contexts_

std::vector<CUcontext> CudaMgr_Namespace::CudaMgr::device_contexts_

private

Definition at line 178 of file CudaMgr.h.

Referenced by copyDeviceToDevice(), isArchVoltaForAll(), setContext(), and ~CudaMgr().

◆ device_count_

int CudaMgr_Namespace::CudaMgr::device_count_

private

Definition at line 172 of file CudaMgr.h.

Referenced by copyDeviceToDevice(), CudaMgr(), isArchMaxwellOrLaterForAll(), isArchVoltaForAll(), setContext(), synchronizeDevices(), and ~CudaMgr().

◆ device_group_

omnisci::DeviceGroup CudaMgr_Namespace::CudaMgr::device_group_

private

Definition at line 177 of file CudaMgr.h.

Referenced by CudaMgr().

◆ device_properties_

std::vector<DeviceProperties> CudaMgr_Namespace::CudaMgr::device_properties_

private

Definition at line 176 of file CudaMgr.h.

Referenced by copyDeviceToDevice(), CudaMgr(), isArchMaxwellOrLaterForAll(), isArchVoltaForAll(), and setContext().

◆ gpu_driver_version_

int CudaMgr_Namespace::CudaMgr::gpu_driver_version_

private

Definition at line 173 of file CudaMgr.h.

Referenced by copyDeviceToDevice().

◆ max_shared_memory_for_all_

size_t CudaMgr_Namespace::CudaMgr::max_shared_memory_for_all_

private

Definition at line 175 of file CudaMgr.h.

Referenced by copyDeviceToDevice().

◆ start_gpu_

int CudaMgr_Namespace::CudaMgr::start_gpu_

private

Definition at line 174 of file CudaMgr.h.

Referenced by copyDeviceToDevice(), and CudaMgr().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/CudaMgr/CudaMgr.h
/home/jenkins-slave/workspace/core-os-doxygen/CudaMgr/CudaMgr.cpp
/home/jenkins-slave/workspace/core-os-doxygen/CudaMgr/CudaMgrNoCuda.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CudaMgr()

◆ ~CudaMgr()

Member Function Documentation

◆ allocateDeviceMem()

◆ allocatePinnedHostMem()

◆ copyDeviceToDevice()

◆ copyDeviceToHost()

◆ copyHostToDevice()

◆ freeDeviceMem()

◆ freePinnedHostMem()

◆ getAllDeviceProperties()

◆ getDeviceCount()

◆ getDeviceGroup()

◆ getDeviceProperties()

◆ getMaxSharedMemoryForAll()

◆ getStartGpu()

◆ isArchMaxwell()

◆ isArchMaxwellOrLater()

◆ isArchMaxwellOrLaterForAll()

◆ isArchPascal()

◆ isArchPascalOrLater()

◆ isArchVoltaForAll()

◆ setContext()

◆ setDeviceMem()

◆ synchronizeDevices()

◆ zeroDeviceMem()

Member Data Documentation

◆ device_cleanup_mutex_

◆ device_contexts_

◆ device_count_

◆ device_group_

◆ device_properties_

◆ gpu_driver_version_

◆ max_shared_memory_for_all_

◆ start_gpu_