#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	getMinSharedMemoryPerBlockForAllDevices () const

size_t	getMinNumMPsForAllDevices () 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

NvidiaDeviceArch	getDeviceArch () const

void	setContext (const int device_num) const

Static Public Member Functions
static std::string	deviceArchToSM (const NvidiaDeviceArch arch)

Private Attributes
int	device_count_

int	start_gpu_

size_t	min_shared_memory_per_block_for_all_devices

size_t	min_num_mps_for_all_devices

std::vector< DeviceProperties >	device_properties_

omnisci::DeviceGroup	device_group_

std::vector< CUcontext >	device_contexts_

std::mutex	device_cleanup_mutex_

Detailed Description

Definition at line 89 of file CudaMgr.h.

Constructor & Destructor Documentation

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

Definition at line 48 of file CudaMgr.cpp.

References CHECK_EQ, CHECK_LE, device_count_, logger::INFO, LOG, nvidia_jit_warmup(), setContext(), and start_gpu_.

     : start_gpu_(start_gpu)
     , min_shared_memory_per_block_for_all_devices(0)
     , min_num_mps_for_all_devices(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();
 
   // warm up the GPU JIT
   LOG(INFO) << "Warming up the GPU JIT Compiler... (this may take several seconds)";
   setContext(0);
   nvidia_jit_warmup();
   LOG(INFO) << "GPU JIT Compiler initialized.";
 }

Here is the call graph for this function:

CudaMgr_Namespace::CudaMgr::~CudaMgr ( )

Definition at line 81 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

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

Definition at line 253 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:

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

Definition at line 246 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:

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 127 of file CudaMgr.cpp.

References device_contexts_, and setContext().

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:

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 118 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:

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 109 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:

static std::string CudaMgr_Namespace::CudaMgr::deviceArchToSM ( const NvidiaDeviceArch arch )

inlinestatic

Definition at line 157 of file CudaMgr.h.

References CudaMgr_Namespace::Kepler, LOG, CudaMgr_Namespace::Maxwell, CudaMgr_Namespace::Pascal, CudaMgr_Namespace::Turing, UNREACHABLE, CudaMgr_Namespace::Volta, and logger::WARNING.

Referenced by UdfCompiler::compileToGpuByteCode().

                                                                {
     // Must match ${CUDA_COMPILATION_ARCH} CMAKE flag
     switch (arch) {
       case NvidiaDeviceArch::Kepler:
         return "sm_35";
       case NvidiaDeviceArch::Maxwell:
         return "sm_50";
       case NvidiaDeviceArch::Pascal:
         return "sm_60";
       case NvidiaDeviceArch::Volta:
         return "sm_70";
       case NvidiaDeviceArch::Turing:
         return "sm_75";
       default:
         LOG(WARNING) << "Unrecognized Nvidia device architecture, falling back to "
                         "Kepler-compatibility.";
         return "sm_35";
     }
     UNREACHABLE();
     return "";
   }

Here is the caller graph for this function:

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

Definition at line 264 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:

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

Definition at line 260 of file CudaMgr.cpp.

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

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

inline

Definition at line 129 of file CudaMgr.h.

References device_properties_.

                                                                     {
     return device_properties_;
   }

NvidiaDeviceArch CudaMgr_Namespace::CudaMgr::getDeviceArch ( ) const

inline

Definition at line 179 of file CudaMgr.h.

References device_properties_, CudaMgr_Namespace::Kepler, CudaMgr_Namespace::Maxwell, CudaMgr_Namespace::Pascal, CudaMgr_Namespace::Turing, and CudaMgr_Namespace::Volta.

                                          {
     if (device_properties_.size() > 0) {
       const auto& device_properties = device_properties_.front();
       switch (device_properties.computeMajor) {
         case 3:
           return NvidiaDeviceArch::Kepler;
         case 5:
           return NvidiaDeviceArch::Maxwell;
         case 6:
           return NvidiaDeviceArch::Pascal;
         case 7:
           if (device_properties.computeMinor == 0) {
             return NvidiaDeviceArch::Volta;
           } else {
             return NvidiaDeviceArch::Turing;
           }
         default:
           return NvidiaDeviceArch::Kepler;
       }
     } else {
       // always fallback to Kepler if an architecture cannot be detected
       return NvidiaDeviceArch::Kepler;
     }
   }

int CudaMgr_Namespace::CudaMgr::getDeviceCount ( ) const

inline

Definition at line 95 of file CudaMgr.h.

References device_count_.

Referenced by get_available_gpus(), isArchMaxwell(), isArchMaxwellOrLater(), isArchPascal(), and isArchPascalOrLater().

95 { return device_count_; }

CudaMgr_Namespace::CudaMgr::device_count_

int device_count_

Definition: CudaMgr.h:241

Here is the caller graph for this function:

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

inline

Definition at line 97 of file CudaMgr.h.

References device_group_.

97 { return device_group_; }

CudaMgr_Namespace::CudaMgr::device_group_

omnisci::DeviceGroup device_group_

Definition: CudaMgr.h:246

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

inline

Definition at line 132 of file CudaMgr.h.

References device_properties_, and 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:

size_t CudaMgr_Namespace::CudaMgr::getMinNumMPsForAllDevices ( ) const

inline

Definition at line 127 of file CudaMgr.h.

References min_num_mps_for_all_devices.

127 { return min_num_mps_for_all_devices; }

CudaMgr_Namespace::CudaMgr::min_num_mps_for_all_devices

size_t min_num_mps_for_all_devices

Definition: CudaMgr.h:244

size_t CudaMgr_Namespace::CudaMgr::getMinSharedMemoryPerBlockForAllDevices ( ) const

inline

Definition at line 123 of file CudaMgr.h.

References min_shared_memory_per_block_for_all_devices.

                                                          {
     return min_shared_memory_per_block_for_all_devices;
   }

int CudaMgr_Namespace::CudaMgr::getStartGpu ( ) const

inline

Definition at line 96 of file CudaMgr.h.

References start_gpu_.

96 { return start_gpu_; }

CudaMgr_Namespace::CudaMgr::start_gpu_

int start_gpu_

Definition: CudaMgr.h:242

bool CudaMgr_Namespace::CudaMgr::isArchMaxwell ( ) const

inline

Definition at line 142 of file CudaMgr.h.

References device_properties_, and getDeviceCount().

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

Here is the call graph for this function:

bool CudaMgr_Namespace::CudaMgr::isArchMaxwellOrLater ( ) const

inline

Definition at line 145 of file CudaMgr.h.

References device_properties_, and getDeviceCount().

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

Here is the call graph for this function:

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 288 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;
 }

bool CudaMgr_Namespace::CudaMgr::isArchPascal ( ) const

inline

Definition at line 148 of file CudaMgr.h.

References device_properties_, and getDeviceCount().

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

Here is the call graph for this function:

bool CudaMgr_Namespace::CudaMgr::isArchPascalOrLater ( ) const

inline

Definition at line 151 of file CudaMgr.h.

References device_properties_, and getDeviceCount().

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

Here is the call graph for this function:

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 301 of file CudaMgr.cpp.

References device_count_, and device_properties_.

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

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

Definition at line 362 of file CudaMgr.cpp.

References CHECK_LT, and device_contexts_.

Referenced by allocateDeviceMem(), allocatePinnedHostMem(), copyDeviceToDevice(), copyDeviceToHost(), copyHostToDevice(), CudaMgr(), Executor::interrupt(), 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:

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 276 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:

void CudaMgr_Namespace::CudaMgr::synchronizeDevices ( ) const

Definition at line 102 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:

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

Definition at line 270 of file CudaMgr.cpp.

References setDeviceMem().

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

Here is the call graph for this function:

Member Data Documentation

std::mutex CudaMgr_Namespace::CudaMgr::device_cleanup_mutex_

mutableprivate

Definition at line 249 of file CudaMgr.h.

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

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

private

Definition at line 247 of file CudaMgr.h.

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

int CudaMgr_Namespace::CudaMgr::device_count_

private

Definition at line 241 of file CudaMgr.h.

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

omnisci::DeviceGroup CudaMgr_Namespace::CudaMgr::device_group_

private

Definition at line 246 of file CudaMgr.h.

Referenced by getDeviceGroup().

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

private

Definition at line 245 of file CudaMgr.h.

Referenced by getAllDeviceProperties(), getDeviceArch(), getDeviceProperties(), isArchMaxwell(), isArchMaxwellOrLater(), isArchMaxwellOrLaterForAll(), isArchPascal(), isArchPascalOrLater(), and isArchVoltaForAll().

size_t CudaMgr_Namespace::CudaMgr::min_num_mps_for_all_devices

private

Definition at line 244 of file CudaMgr.h.

Referenced by getMinNumMPsForAllDevices().

size_t CudaMgr_Namespace::CudaMgr::min_shared_memory_per_block_for_all_devices

private

Definition at line 243 of file CudaMgr.h.

Referenced by getMinSharedMemoryPerBlockForAllDevices().

int CudaMgr_Namespace::CudaMgr::start_gpu_

private

Definition at line 242 of file CudaMgr.h.

Referenced by CudaMgr(), and getStartGpu().

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

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation