View source for CUDA Programming/DeviceQuery

[[CUDA_Programming|&larr; Back to project main page]]

Both CUDA API allows us to gather certain information such as the driver version, available devices, very detailed device properties like total available memory, bandwidth, computing capabilities etc.

= Implementation =
First of all, for the simplicity of the example, we did not include any error detection & correction and ignored error values retuned by functions.

We need to know the number of CUDA-capable devices on the system to begin with:

 <b><code>cudaError_t cudaGetDeviceCount(int *count)</code></b>
  Stores the number of devices with [[CUDA_Programming/Terminology#Compute_Capability|compute capability]] greater than or equal to 1.0, 
  and are avabilable for execution, in <i>count</i>.

Devices are enumerated, starting from 0, incrementally. Then for each device we need to query their properties. Properties are encapsulated in the following structure:

  <b><code>struct cudaDeviceProp</code></b>
  <b><code>{</code></b>
  <b><code>  char name[256];</code></b>
      Identifies the device
  <b><code>  size_t totalGlobalMem;</code></b>
      Total amount of global memory available on the device in bytes
  <b><code>  size_t sharedMemPerBlock</code></b>
      Maximum amount of shared memory available to a [[CUDA_Programming/Terminology#Thread_Block|thread block]] in bytes
  <b><code>  int regsPerBlock;</code></b>
      Maximum number of 32-bit registers available to a [[CUDA_Programming/Terminology#Thread_Block|thread block]] 
  <b><code>  int warpsize;</code></b>
      [[CUDA_Programming/Terminology#Warp|Warp]] size in [[CUDA_Programming/Terminology#Thread|thread]]s
  <b><code>  size_t memPitch;</code></b>
      Maximum [[CUDA_Programming/Terminology#Pitch|pitch]] in bytes allowed by the memory copy functions that involve
      memory regions allocated through cudaMallocPitch() call
  <b><code>  int maxThreadsPerBlock;</code></b>
      Maximum number of [[CUDA_Programming/Terminology#Thread|threads]] per [[CUDA_Programming/Terminology#Thread_Block|block]]
  <b><code>  int maxThreadsDim[3];</code></b>
      Maximum size of each dimension of a [[CUDA_Programming/Terminology#Thread_Block|block]]
  <b><code>  int maxGridSize[3];</code></b>
      Maximum size of each dimension of a [[CUDA_Programming/Terminology#Thread_Grid|grid]]
  <b><code>  size_t totalConstMem;</code></b>
      Total amount of constant memory available on the device in bytes
  <b><code>  int major;</code></b>
      Represents the major revision number of the device's [[CUDA_Programming/Terminology#Compute_Capability|compute capability]]
  <b><code>  int minor;</code></b>
      Represents the minor revision number of the device's [[CUDA_Programming/Terminology#Compute_Capability|compute capability]]
  <b><code>  int clockRate;</code></b>
      Clock frequency in kilohertz
  <b><code>  size_t textureAlignment;</code></b>
      Defines the alignment requirement; texture base addresses that are aligned 
      to textureAlignment number of bytes do not need an offset applied to texture fetches
  <b><code>  int deviceOverlap;</code></b>
      Specifies whether the device can concurrently copy memory between host and device while executing a kernel
      Return value of one indicates that the device supports device overlap
  <b><code>  int multiProcessorCount;</code></b>
      Number of multiprocessors on the device
  <b><code>  int kernelExecTimeoutEnabled;</code></b>
      Specifies if there is a run time limit for [[CUDA_Programming/Terminology#Kernel|kernels]] on the device
      Return value of 1 has positive indication
  <b><code>  int integrated;</code></b>
      Specifies if the device is an integrated (motherboard) GPU or a discrete (card) component
      Return value of 0 represents discrete, value of 1 represents integrated option
  <b><code>  int canMapHostMemory;</code></b>
      Specifies whether the device can map host memory into the CUDA address space
      Return value of 1 has positive indication
  <b><code>  int computeMode;</code></b>
      Specifies the compute mode that the device is currently in.
      Return value of <i>cudaComputeModeDefault</i> means that multiple [[CUDA_Programming/Terminology#Thread|threads]] can call cudaSetDevice()
      Return value of <i>cudaComputeModeExclusive</i> means that only one [[CUDA_Programming/Terminology#Thread|thread]] can call cudaSetDevice()
      Return value of <i>cudaComputeModeProhibited<i/> means that no [[CUDA_Programming/Terminology#Thread|threads]] can call cudaSetDevice()
  <b><code>  int concurrentKernels;</code></b>
      Specifies whether the device supports executing multiple [[CUDA_Programming/Terminology#Kernel|kernels]] within the same context simultaneously or not
      Return value of 1 has positive indication
  <b><code>  int ECCEnabled;</code></b>
      Specifies whether the device has ECC support or not
      Return value of 1 has positive indication
  <b><code>  int pciBusID;</code></b>
      PCI bus identifier of the device
  <b><code>  int pciDeviceID;</code></b>
      PCI device, or slot, identifier of the device
  <b><code>  int tccDriver;</code></b>
      Specifies if the driver is using a TCC driver or not
      Return value of 1 has positive indication
  <b><code>}</code></b>

We can obtain the device properties using the following call:

  <b><code>cudaError_t cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device)</code></b>
  Stores the properties of the device, whose id is <i>device</i>, in argument <i>prop</i>

So, with the assumption of a function with the given definition:

  <b><code>void printDeviceProperties(const struct cudaDeviceProp *prop)</code></b>
  Prints out the device properties stored in <i>prop</i>

the main section of the program looks like this:

  <code>struct cudaDeviceProp **cudaDevices;</code>
  <code>int count, i;</code>
  <code></code>
  <code>cudaGetDeviceCount(&count);</code>
  <code>cudaDevices = (struct cudaDeviceProp **)malloc( sizeof(struct cudaDeviceProp *) * count );</code>
  <code></code>
  <code>for (i = 0; i < count; ++i)</code>
  <code>{</code>
  <code>  cudaDevices[i] = (struct cudaDeviceProp *)malloc(sizeof(struct cudaDeviceProp));</code>
  <code>  cudaGetDeviceProperties(cudaDevices[i], i);</code>
  <code>  printDeviceProperties(cudaDevices[i]);</code>
  <code>  free(cudaDevices[i]);</code>
  <code>}</code>
  <code>free(cudaDevices);</code>