NAME

       Device Management -

   Functions
       CUresult cuDeviceGet (CUdevice *device, int ordinal)
           Returns a handle to a compute device.
       CUresult cuDeviceGetAttribute (int *pi, CUdevice_attribute attrib, CUdevice dev)
           Returns information about the device.
       CUresult cuDeviceGetCount (int *count)
           Returns the number of compute-capable devices.
       CUresult cuDeviceGetName (char *name, int len, CUdevice dev)
           Returns an identifier string for the device.
       CUresult cuDeviceTotalMem (size_t *bytes, CUdevice dev)
           Returns the total amount of memory on the device.

Detailed Description

       \brief device management functions of the low-level CUDA driver API (cuda.h)

       This section describes the device management functions of the low-level CUDA driver
       application programming interface.

Function Documentation

   CUresult cuDeviceGet (CUdevice * device, int ordinal)
       Returns in *device a device handle given an ordinal in the range [0,
       cuDeviceGetCount()-1].

       Parameters:
           device - Returned device handle
           ordinal - Device number to get handle for

       Returns:
           CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
           CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

       Note:
           Note that this function may also return error codes from previous, asynchronous
           launches.

       See also:
           cuDeviceGetAttribute, cuDeviceGetCount, cuDeviceGetName, cuDeviceTotalMem

   CUresult cuDeviceGetAttribute (int * pi, CUdevice_attribute attrib, CUdevice dev)
       Returns in *pi the integer value of the attribute attrib on device dev. The supported
       attributes are:

       • CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK: Maximum number of threads per block;

       • CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X: Maximum x-dimension of a block;

       • CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y: Maximum y-dimension of a block;

       • CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z: Maximum z-dimension of a block;

       • CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X: Maximum x-dimension of a grid;

       • CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y: Maximum y-dimension of a grid;

       • CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z: Maximum z-dimension of a grid;

       • CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK: Maximum amount of shared memory
         available to a thread block in bytes;

       • CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY: Memory available on device for __constant__
         variables in a CUDA C kernel in bytes;

       • CU_DEVICE_ATTRIBUTE_WARP_SIZE: Warp size in threads;

       • CU_DEVICE_ATTRIBUTE_MAX_PITCH: Maximum pitch in bytes allowed by the memory copy
         functions that involve memory regions allocated through cuMemAllocPitch();

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: Maximum 1D texture width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH: Maximum width for a 1D texture bound
         to linear memory;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: Maximum mipmapped 1D texture
         width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: Maximum 2D texture width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: Maximum 2D texture height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH: Maximum width for a 2D texture bound
         to linear memory;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT: Maximum height for a 2D texture
         bound to linear memory;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH: Maximum pitch in bytes for a 2D
         texture bound to linear memory;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: Maximum mipmapped 2D texture
         width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT: Maximum mipmapped 2D texture
         height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: Maximum 3D texture width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: Maximum 3D texture height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: Maximum 3D texture depth;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: Alternate maximum 3D texture
         width, 0 if no alternate maximum 3D texture size is supported;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: Alternate maximum 3D texture
         height, 0 if no alternate maximum 3D texture size is supported;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: Alternate maximum 3D texture
         depth, 0 if no alternate maximum 3D texture size is supported;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH: Maximum cubemap texture width or
         height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: Maximum 1D layered texture width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: Maximum layers in a 1D layered
         texture;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: Maximum 2D layered texture width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: Maximum 2D layered texture height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: Maximum layers in a 2D layered
         texture;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: Maximum cubemap layered
         texture width or height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: Maximum layers in a cubemap
         layered texture;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH: Maximum 1D surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH: Maximum 2D surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT: Maximum 2D surface height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH: Maximum 3D surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT: Maximum 3D surface height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH: Maximum 3D surface depth;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH: Maximum 1D layered surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS: Maximum layers in a 1D layered
         surface;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH: Maximum 2D layered surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT: Maximum 2D layered surface height;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS: Maximum layers in a 2D layered
         surface;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH: Maximum cubemap surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH: Maximum cubemap layered
         surface width;

       • CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS: Maximum layers in a cubemap
         layered surface;

       • CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK: Maximum number of 32-bit registers
         available to a thread block;

       • CU_DEVICE_ATTRIBUTE_CLOCK_RATE: The typical clock frequency in kilohertz;

       • CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT: Alignment requirement; texture base addresses
         aligned to textureAlign bytes do not need an offset applied to texture fetches;

       • CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT: Pitch alignment requirement for 2D texture
         references bound to pitched memory;

       • CU_DEVICE_ATTRIBUTE_GPU_OVERLAP: 1 if the device can concurrently copy memory between
         host and device while executing a kernel, or 0 if not;

       • CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT: Number of multiprocessors on the device;

       • CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT: 1 if there is a run time limit for kernels
         executed on the device, or 0 if not;

       • CU_DEVICE_ATTRIBUTE_INTEGRATED: 1 if the device is integrated with the memory subsystem,
         or 0 if not;

       • CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY: 1 if the device can map host memory into the
         CUDA address space, or 0 if not;

       • CU_DEVICE_ATTRIBUTE_COMPUTE_MODE: Compute mode that device is currently in. Available
         modes are as follows:

         • CU_COMPUTEMODE_DEFAULT: Default mode - Device is not restricted and can have multiple
           CUDA contexts present at a single time.

         • CU_COMPUTEMODE_PROHIBITED: Compute-prohibited mode - Device is prohibited from
           creating new CUDA contexts.

         • CU_COMPUTEMODE_EXCLUSIVE_PROCESS: Compute-exclusive-process mode - Device can have
           only one context used by a single process at a time.

       • CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS: 1 if the device supports executing multiple
         kernels within the same context simultaneously, or 0 if not. It is not guaranteed that
         multiple kernels will be resident on the device concurrently so this feature should not
         be relied upon for correctness;

       • CU_DEVICE_ATTRIBUTE_ECC_ENABLED: 1 if error correction is enabled on the device, 0 if
         error correction is disabled or not supported by the device;

       • CU_DEVICE_ATTRIBUTE_PCI_BUS_ID: PCI bus identifier of the device;

       • CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: PCI device (also known as slot) identifier of the
         device;

       • CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID: PCI domain identifier of the device

       • CU_DEVICE_ATTRIBUTE_TCC_DRIVER: 1 if the device is using a TCC driver. TCC is only
         available on Tesla hardware running Windows Vista or later;

       • CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: Peak memory clock frequency in kilohertz;

       • CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: Global memory bus width in bits;

       • CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: Size of L2 cache in bytes. 0 if the device doesn't
         have L2 cache;

       • CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: Maximum resident threads per
         multiprocessor;

       • CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: 1 if the device shares a unified address space
         with the host, or 0 if not;

       • CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: Major compute capability version number;

       • CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: Minor compute capability version number;

       • CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: 1 if device supports caching globals in
         L1 cache, 0 if caching globals in L1 cache is not supported by the device;

       • CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: 1 if device supports caching locals in L1
         cache, 0 if caching locals in L1 cache is not supported by the device;

       • CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: Maximum amount of shared
         memory available to a multiprocessor in bytes; this amount is shared by all thread
         blocks simultaneously resident on a multiprocessor;

       • CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: Maximum number of 32-bit registers
         available to a multiprocessor; this number is shared by all thread blocks simultaneously
         resident on a multiprocessor;

       • CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: 1 if device supports allocating managed memory on
         this system, 0 if allocating managed memory is not supported by the device on this
         system.

       • CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: 1 if device is on a multi-GPU board, 0 if not.

       • CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: Unique identifier for a group of devices
         associated with the same board. Devices on the same multi-GPU board will share the same
         identifier.

       • CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: 1 if Link between the device and the
         host supports native atomic operations.

       • CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: Ratio of single precision
         performance (in floating-point operations per second) to double precision performance.

       • CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device supports coherently accessing
         pageable memory without calling cudaHostRegister on it.

       • CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: Device can coherently access managed
         memory concurrently with the CPU.

       • CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: Device supports Compute Preemption.

       • CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: Device can access host
         registered memory at the same virtual address as the CPU.

       • CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: The maximum per block shared
         memory size supported on this device. This is the maximum value that can be opted into
         when using the cuFuncSetAttribute() call. For more details see
         CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES

       Parameters:
           pi - Returned device attribute value
           attrib - Device attribute to query
           dev - Device handle

       Returns:
           CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
           CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

       Note:
           Note that this function may also return error codes from previous, asynchronous
           launches.

       See also:
           cuDeviceGetCount, cuDeviceGetName, cuDeviceGet, cuDeviceTotalMem,
           cudaDeviceGetAttribute, cudaGetDeviceProperties

   CUresult cuDeviceGetCount (int * count)
       Returns in *count the number of devices with compute capability greater than or equal to
       2.0 that are available for execution. If there is no such device, cuDeviceGetCount()
       returns 0.

       Parameters:
           count - Returned number of compute-capable devices

       Returns:
           CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
           CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

       Note:
           Note that this function may also return error codes from previous, asynchronous
           launches.

       See also:
           cuDeviceGetAttribute, cuDeviceGetName, cuDeviceGet, cuDeviceTotalMem,
           cudaGetDeviceCount

   CUresult cuDeviceGetName (char * name, int len, CUdevice dev)
       Returns an ASCII string identifying the device dev in the NULL-terminated string pointed
       to by name. len specifies the maximum length of the string that may be returned.

       Parameters:
           name - Returned identifier string for the device
           len - Maximum length of string to store in name
           dev - Device to get identifier string for

       Returns:
           CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
           CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

       Note:
           Note that this function may also return error codes from previous, asynchronous
           launches.

       See also:
           cuDeviceGetAttribute, cuDeviceGetCount, cuDeviceGet, cuDeviceTotalMem,
           cudaGetDeviceProperties

   CUresult cuDeviceTotalMem (size_t * bytes, CUdevice dev)
       Returns in *bytes the total amount of memory available on the device dev in bytes.

       Parameters:
           bytes - Returned memory available on device in bytes
           dev - Device handle

       Returns:
           CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,
           CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

       Note:
           Note that this function may also return error codes from previous, asynchronous
           launches.

       See also:
           cuDeviceGetAttribute, cuDeviceGetCount, cuDeviceGetName, cuDeviceGet, cudaMemGetInfo

Author

       Generated automatically by Doxygen from the source code.