| OpenCV 4.3.0 Open Source Computer Vision

Public Types | Public Member Functions | List of all members
cv::cuda::DeviceInfo Class Reference
CUDA-accelerated Computer Vision » Core part » Initialization and Information

Class providing functionality for querying the specified GPU properties. More...

`#include <opencv2/core/cuda.hpp>`

## Public Types
enum | ComputeMode { ComputeModeDefault, ComputeModeExclusive, ComputeModeProhibited, ComputeModeExclusiveProcess }

## Public Member Functions
| DeviceInfo ()
| creates DeviceInfo object for the current GPU More...
| DeviceInfo (int device_id)
| The constructors. More...
int | asyncEngineCount () const
| number of asynchronous engines More...
bool | canMapHostMemory () const
| device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer More...
int | clockRate () const
| clock frequency in kilohertz More...
DeviceInfo::ComputeMode | computeMode () const
| compute mode More...
bool | concurrentKernels () const
| device can possibly execute multiple kernels concurrently More...
int | deviceID () const
| Returns system index of the CUDA device starting with 0. More...
bool | ECCEnabled () const
| device has ECC support enabled More...
size_t | freeMemory () const
bool | integrated () const
| device is integrated as opposed to discrete More...
bool | isCompatible () const
| Checks the CUDA module and device compatibility. More...
bool | kernelExecTimeoutEnabled () const
| specified whether there is a run time limit on kernels More...
int | l2CacheSize () const
| size of L2 cache in bytes More...
int | majorVersion () const
| major compute capability More...
Vec3i | maxGridSize () const
| maximum size of each dimension of a grid More...
int | maxSurface1D () const
| maximum 1D surface size More...
Vec2i | maxSurface1DLayered () const
| maximum 1D layered surface dimensions More...
Vec2i | maxSurface2D () const
| maximum 2D surface dimensions More...
Vec3i | maxSurface2DLayered () const
| maximum 2D layered surface dimensions More...
Vec3i | maxSurface3D () const
| maximum 3D surface dimensions More...
int | maxSurfaceCubemap () const
| maximum Cubemap surface dimensions More...
Vec2i | maxSurfaceCubemapLayered () const
| maximum Cubemap layered surface dimensions More...
int | maxTexture1D () const
| maximum 1D texture size More...
Vec2i | maxTexture1DLayered () const
| maximum 1D layered texture dimensions More...
int | maxTexture1DLinear () const
| maximum size for 1D textures bound to linear memory More...
int | maxTexture1DMipmap () const
| maximum 1D mipmapped texture size More...
Vec2i | maxTexture2D () const
| maximum 2D texture dimensions More...
Vec2i | maxTexture2DGather () const
| maximum 2D texture dimensions if texture gather operations have to be performed More...
Vec3i | maxTexture2DLayered () const
| maximum 2D layered texture dimensions More...
Vec3i | maxTexture2DLinear () const
| maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory More...
Vec2i | maxTexture2DMipmap () const
| maximum 2D mipmapped texture dimensions More...
Vec3i | maxTexture3D () const
| maximum 3D texture dimensions More...
int | maxTextureCubemap () const
| maximum Cubemap texture dimensions More...
Vec2i | maxTextureCubemapLayered () const
| maximum Cubemap layered texture dimensions More...
Vec3i | maxThreadsDim () const
| maximum size of each dimension of a block More...
int | maxThreadsPerBlock () const
| maximum number of threads per block More...
int | maxThreadsPerMultiProcessor () const
| maximum resident threads per multiprocessor More...
int | memoryBusWidth () const
| global memory bus width in bits More...
int | memoryClockRate () const
| peak memory clock frequency in kilohertz More...
size_t | memPitch () const
| maximum pitch in bytes allowed by memory copies More...
int | minorVersion () const
| minor compute capability More...
int | multiProcessorCount () const
| number of multiprocessors on device More...
const char * | name () const
| ASCII string identifying device. More...
int | pciBusID () const
| PCI bus ID of the device. More...
int | pciDeviceID () const
| PCI device ID of the device. More...
int | pciDomainID () const
| PCI domain ID of the device. More...
void | queryMemory (size_t &totalMemory, size_t &freeMemory) const
| gets free and total device memory More...
int | regsPerBlock () const
| 32-bit registers available per block More...
size_t | sharedMemPerBlock () const
| shared memory available per block in bytes More...
bool | supports (FeatureSet feature_set) const
| Provides information on CUDA feature support. More...
size_t | surfaceAlignment () const
| alignment requirements for surfaces More...
bool | tccDriver () const
| true if device is a Tesla device using TCC driver, false otherwise More...
size_t | textureAlignment () const
| alignment requirement for textures More...
size_t | texturePitchAlignment () const
| pitch alignment requirement for texture references bound to pitched memory More...
size_t | totalConstMem () const
| constant memory available on device in bytes More...
size_t | totalGlobalMem () const
| global memory available on device in bytes More...
size_t | totalMemory () const
bool | unifiedAddressing () const
| device shares a unified address space with the host More...
int | warpSize () const
| warp size in threads More...

## Detailed Description

Class providing functionality for querying the specified GPU properties.

## Member Enumeration Documentation

## ◆ ComputeMode

enum cv::cuda::DeviceInfo::ComputeMode

Enumerator
ComputeModeDefault | default compute mode (Multiple threads can use cudaSetDevice with this device)
ComputeModeExclusive | compute-exclusive-thread mode (Only one thread in one process will be able to use cudaSetDevice with this device)
ComputeModeProhibited | compute-prohibited mode (No threads can use cudaSetDevice with this device)
ComputeModeExclusiveProcess | compute-exclusive-process mode (Many threads in one process will be able to use cudaSetDevice with this device)

## Constructor & Destructor Documentation

## ◆ DeviceInfo() [1/2]

cv::cuda::DeviceInfo::DeviceInfo | ( |  | ) |

Python:
| <cuda_DeviceInfo object> | = | cv.cuda_DeviceInfo( |  | )
| <cuda_DeviceInfo object> | = | cv.cuda_DeviceInfo( | device_id | )

creates DeviceInfo object for the current GPU

## ◆ DeviceInfo() [2/2]

cv::cuda::DeviceInfo::DeviceInfo | ( | int | device_id | ) |

Python:
| <cuda_DeviceInfo object> | = | cv.cuda_DeviceInfo( |  | )
| <cuda_DeviceInfo object> | = | cv.cuda_DeviceInfo( | device_id | )

The constructors.

Parameters

  device_id | System index of the CUDA device starting with 0.

Constructs the DeviceInfo object for the specified device. If device_id parameter is missed, it constructs an object for the current device.

## Member Function Documentation

## ◆ asyncEngineCount()

int cv::cuda::DeviceInfo::asyncEngineCount | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.asyncEngineCount( |  | )

number of asynchronous engines

## ◆ canMapHostMemory()

bool cv::cuda::DeviceInfo::canMapHostMemory | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.canMapHostMemory( |  | )

device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer

## ◆ clockRate()

int cv::cuda::DeviceInfo::clockRate | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.clockRate( |  | )

clock frequency in kilohertz

## ◆ computeMode()

DeviceInfo::ComputeMode cv::cuda::DeviceInfo::computeMode | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.computeMode( |  | )

compute mode

## ◆ concurrentKernels()

bool cv::cuda::DeviceInfo::concurrentKernels | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.concurrentKernels( |  | )

device can possibly execute multiple kernels concurrently

## ◆ deviceID()

int cv::cuda::DeviceInfo::deviceID | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.deviceID( |  | )

Returns system index of the CUDA device starting with 0.

## ◆ ECCEnabled()

bool cv::cuda::DeviceInfo::ECCEnabled | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.ECCEnabled( |  | )

device has ECC support enabled

## ◆ freeMemory()

size_t cv::cuda::DeviceInfo::freeMemory | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.freeMemory( |  | )

## ◆ integrated()

bool cv::cuda::DeviceInfo::integrated | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.integrated( |  | )

device is integrated as opposed to discrete

## ◆ isCompatible()

bool cv::cuda::DeviceInfo::isCompatible | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.isCompatible( |  | )

Checks the CUDA module and device compatibility.

This function returns true if the CUDA module can be run on the specified device. Otherwise, it returns false .

## ◆ kernelExecTimeoutEnabled()

bool cv::cuda::DeviceInfo::kernelExecTimeoutEnabled | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.kernelExecTimeoutEnabled( |  | )

specified whether there is a run time limit on kernels

## ◆ l2CacheSize()

int cv::cuda::DeviceInfo::l2CacheSize | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.l2CacheSize( |  | )

size of L2 cache in bytes

## ◆ majorVersion()

int cv::cuda::DeviceInfo::majorVersion | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.majorVersion( |  | )

major compute capability

## ◆ maxGridSize()

Vec3i cv::cuda::DeviceInfo::maxGridSize | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxGridSize( |  | )

maximum size of each dimension of a grid

## ◆ maxSurface1D()

int cv::cuda::DeviceInfo::maxSurface1D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurface1D( |  | )

maximum 1D surface size

## ◆ maxSurface1DLayered()

Vec2i cv::cuda::DeviceInfo::maxSurface1DLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurface1DLayered( |  | )

maximum 1D layered surface dimensions

## ◆ maxSurface2D()

Vec2i cv::cuda::DeviceInfo::maxSurface2D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurface2D( |  | )

maximum 2D surface dimensions

## ◆ maxSurface2DLayered()

Vec3i cv::cuda::DeviceInfo::maxSurface2DLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurface2DLayered( |  | )

maximum 2D layered surface dimensions

## ◆ maxSurface3D()

Vec3i cv::cuda::DeviceInfo::maxSurface3D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurface3D( |  | )

maximum 3D surface dimensions

## ◆ maxSurfaceCubemap()

int cv::cuda::DeviceInfo::maxSurfaceCubemap | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurfaceCubemap( |  | )

maximum Cubemap surface dimensions

## ◆ maxSurfaceCubemapLayered()

Vec2i cv::cuda::DeviceInfo::maxSurfaceCubemapLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxSurfaceCubemapLayered( |  | )

maximum Cubemap layered surface dimensions

## ◆ maxTexture1D()

int cv::cuda::DeviceInfo::maxTexture1D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture1D( |  | )

maximum 1D texture size

## ◆ maxTexture1DLayered()

Vec2i cv::cuda::DeviceInfo::maxTexture1DLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture1DLayered( |  | )

maximum 1D layered texture dimensions

## ◆ maxTexture1DLinear()

int cv::cuda::DeviceInfo::maxTexture1DLinear | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture1DLinear( |  | )

maximum size for 1D textures bound to linear memory

## ◆ maxTexture1DMipmap()

int cv::cuda::DeviceInfo::maxTexture1DMipmap | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture1DMipmap( |  | )

maximum 1D mipmapped texture size

## ◆ maxTexture2D()

Vec2i cv::cuda::DeviceInfo::maxTexture2D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture2D( |  | )

maximum 2D texture dimensions

## ◆ maxTexture2DGather()

Vec2i cv::cuda::DeviceInfo::maxTexture2DGather | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture2DGather( |  | )

maximum 2D texture dimensions if texture gather operations have to be performed

## ◆ maxTexture2DLayered()

Vec3i cv::cuda::DeviceInfo::maxTexture2DLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture2DLayered( |  | )

maximum 2D layered texture dimensions

## ◆ maxTexture2DLinear()

Vec3i cv::cuda::DeviceInfo::maxTexture2DLinear | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture2DLinear( |  | )

maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory

## ◆ maxTexture2DMipmap()

Vec2i cv::cuda::DeviceInfo::maxTexture2DMipmap | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture2DMipmap( |  | )

maximum 2D mipmapped texture dimensions

## ◆ maxTexture3D()

Vec3i cv::cuda::DeviceInfo::maxTexture3D | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTexture3D( |  | )

maximum 3D texture dimensions

## ◆ maxTextureCubemap()

int cv::cuda::DeviceInfo::maxTextureCubemap | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTextureCubemap( |  | )

maximum Cubemap texture dimensions

## ◆ maxTextureCubemapLayered()

Vec2i cv::cuda::DeviceInfo::maxTextureCubemapLayered | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxTextureCubemapLayered( |  | )

maximum Cubemap layered texture dimensions

## ◆ maxThreadsDim()

Vec3i cv::cuda::DeviceInfo::maxThreadsDim | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxThreadsDim( |  | )

maximum size of each dimension of a block

## ◆ maxThreadsPerBlock()

int cv::cuda::DeviceInfo::maxThreadsPerBlock | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxThreadsPerBlock( |  | )

maximum number of threads per block

## ◆ maxThreadsPerMultiProcessor()

int cv::cuda::DeviceInfo::maxThreadsPerMultiProcessor | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.maxThreadsPerMultiProcessor( |  | )

maximum resident threads per multiprocessor

## ◆ memoryBusWidth()

int cv::cuda::DeviceInfo::memoryBusWidth | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.memoryBusWidth( |  | )

global memory bus width in bits

## ◆ memoryClockRate()

int cv::cuda::DeviceInfo::memoryClockRate | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.memoryClockRate( |  | )

peak memory clock frequency in kilohertz

## ◆ memPitch()

size_t cv::cuda::DeviceInfo::memPitch | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.memPitch( |  | )

maximum pitch in bytes allowed by memory copies

## ◆ minorVersion()

int cv::cuda::DeviceInfo::minorVersion | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.minorVersion( |  | )

minor compute capability

## ◆ multiProcessorCount()

int cv::cuda::DeviceInfo::multiProcessorCount | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.multiProcessorCount( |  | )

number of multiprocessors on device

## ◆ name()

const char* cv::cuda::DeviceInfo::name | ( |  | ) | const

ASCII string identifying device.

## ◆ pciBusID()

int cv::cuda::DeviceInfo::pciBusID | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.pciBusID( |  | )

PCI bus ID of the device.

## ◆ pciDeviceID()

int cv::cuda::DeviceInfo::pciDeviceID | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.pciDeviceID( |  | )

PCI device ID of the device.

## ◆ pciDomainID()

int cv::cuda::DeviceInfo::pciDomainID | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.pciDomainID( |  | )

PCI domain ID of the device.

## ◆ queryMemory()

void cv::cuda::DeviceInfo::queryMemory | ( | size_t & | totalMemory,
|  | size_t & | freeMemory
| ) |  | const

Python:
| None | = | cv.cuda_DeviceInfo.queryMemory( | totalMemory, freeMemory | )

gets free and total device memory

## ◆ regsPerBlock()

int cv::cuda::DeviceInfo::regsPerBlock | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.regsPerBlock( |  | )

32-bit registers available per block

## ◆ sharedMemPerBlock()

size_t cv::cuda::DeviceInfo::sharedMemPerBlock | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.sharedMemPerBlock( |  | )

shared memory available per block in bytes

## ◆ supports()

bool cv::cuda::DeviceInfo::supports | ( | FeatureSet | feature_set | ) | const

Provides information on CUDA feature support.

Parameters

  feature_set | Features to be checked. See cuda::FeatureSet.

This function returns true if the device has the specified CUDA feature. Otherwise, it returns false

## ◆ surfaceAlignment()

size_t cv::cuda::DeviceInfo::surfaceAlignment | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.surfaceAlignment( |  | )

alignment requirements for surfaces

## ◆ tccDriver()

bool cv::cuda::DeviceInfo::tccDriver | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.tccDriver( |  | )

true if device is a Tesla device using TCC driver, false otherwise

## ◆ textureAlignment()

size_t cv::cuda::DeviceInfo::textureAlignment | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.textureAlignment( |  | )

alignment requirement for textures

## ◆ texturePitchAlignment()

size_t cv::cuda::DeviceInfo::texturePitchAlignment | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.texturePitchAlignment( |  | )

pitch alignment requirement for texture references bound to pitched memory

## ◆ totalConstMem()

size_t cv::cuda::DeviceInfo::totalConstMem | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.totalConstMem( |  | )

constant memory available on device in bytes

## ◆ totalGlobalMem()

size_t cv::cuda::DeviceInfo::totalGlobalMem | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.totalGlobalMem( |  | )

global memory available on device in bytes

## ◆ totalMemory()

size_t cv::cuda::DeviceInfo::totalMemory | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.totalMemory( |  | )

## ◆ unifiedAddressing()

bool cv::cuda::DeviceInfo::unifiedAddressing | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.unifiedAddressing( |  | )

device shares a unified address space with the host

## ◆ warpSize()

int cv::cuda::DeviceInfo::warpSize | ( |  | ) | const

Python:
| retval | = | cv.cuda_DeviceInfo.warpSize( |  | )

warp size in threads

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

- opencv2/core/cuda.hpp