CudaMgr_Namespace::CudaMgr Class Reference

#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 87 of file CudaMgr.h.

Constructor & Destructor Documentation

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

Definition at line 28 of file CudaMgr.cpp.

References CHECK_EQ, CHECK_LE, device_count_, 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_Namespace::CudaMgr::~CudaMgr

(

)

Definition at line 53 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 217 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 210 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 99 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 90 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 81 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:

void CudaMgr_Namespace::CudaMgr::freeDeviceMem

(

int8_t *

device_ptr

)

Definition at line 228 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 224 of file CudaMgr.cpp.

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

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

inline

Definition at line 123 of file CudaMgr.h.

References device_properties_.

                                                                    {
    return device_properties_;
  }

int CudaMgr_Namespace::CudaMgr::getDeviceCount ( ) const

inline

Definition at line 93 of file CudaMgr.h.

References device_count_.

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

{ return device_count_; }

Here is the caller graph for this function:

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

inline

Definition at line 95 of file CudaMgr.h.

References device_group_.

{ return device_group_; }

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

inline

Definition at line 126 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::getMaxSharedMemoryForAll ( ) const

inline

Definition at line 121 of file CudaMgr.h.

References max_shared_memory_for_all_.

{ return max_shared_memory_for_all_; }

int CudaMgr_Namespace::CudaMgr::getStartGpu ( ) const

inline

Definition at line 94 of file CudaMgr.h.

References start_gpu_.

{ return start_gpu_; }

bool CudaMgr_Namespace::CudaMgr::isArchMaxwell ( ) const

inline

Definition at line 136 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 139 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 252 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 142 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 145 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 265 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 311 of file CudaMgr.cpp.

References CHECK_LT, and device_contexts_.

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:

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 240 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 74 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 234 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 185 of file CudaMgr.h.

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

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

private

Definition at line 183 of file CudaMgr.h.

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

int CudaMgr_Namespace::CudaMgr::device_count_

private

Definition at line 177 of file CudaMgr.h.

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

omnisci::DeviceGroup CudaMgr_Namespace::CudaMgr::device_group_

private

Definition at line 182 of file CudaMgr.h.

Referenced by getDeviceGroup().

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

private

Definition at line 181 of file CudaMgr.h.

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

int CudaMgr_Namespace::CudaMgr::gpu_driver_version_

private

Definition at line 178 of file CudaMgr.h.

size_t CudaMgr_Namespace::CudaMgr::max_shared_memory_for_all_

private

Definition at line 180 of file CudaMgr.h.

Referenced by getMaxSharedMemoryForAll().

int CudaMgr_Namespace::CudaMgr::start_gpu_

private

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