| CUDA array type |
Valid extents that must always be met
{(width range in elements), (height range),
(depth range)} |
Valid extents with CUDA_ARRAY3D_SURFACE_LDST set
{(width range in elements), (height range), (depth range)} |
| 1D |
{ (1,TEXTURE1D_WIDTH), 0, 0 } |
{ (1,SURFACE1D_WIDTH), 0, 0 } |
| 2D |
{ (1,TEXTURE2D_WIDTH), (1,TEXTURE2D_HEIGHT), 0 } |
{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 } |
| 3D |
{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) }
OR
{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE),
(1,TEXTURE3D_DEPTH_ALTERNATE) } |
{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT),
(1,SURFACE3D_DEPTH) } |
| 1D Layered |
{ (1,TEXTURE1D_LAYERED_WIDTH), 0,
(1,TEXTURE1D_LAYERED_LAYERS) } |
{ (1,SURFACE1D_LAYERED_WIDTH), 0,
(1,SURFACE1D_LAYERED_LAYERS) } |
| 2D Layered |
{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT),
(1,TEXTURE2D_LAYERED_LAYERS) } |
{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT),
(1,SURFACE2D_LAYERED_LAYERS) } |
| Cubemap |
{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 } |
{ (1,SURFACECUBEMAP_WIDTH),
(1,SURFACECUBEMAP_WIDTH), 6 } |
| Cubemap Layered |
{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH),
(1,TEXTURECUBEMAP_LAYERED_LAYERS) } |
{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH),
(1,SURFACECUBEMAP_LAYERED_LAYERS) } |
Here are examples of CUDA array descriptions:
Description for a CUDA array of 2048 floats:
\code
CUDA_ARRAY3D_DESCRIPTOR desc;
desc.Format = CU_AD_FORMAT_FLOAT;
desc.NumChannels = 1;
desc.Width = 2048;
desc.Height = 0;
desc.Depth = 0;
\endcode
Description for a 64 x 64 CUDA array of floats:
\code
CUDA_ARRAY3D_DESCRIPTOR desc;
desc.Format = CU_AD_FORMAT_FLOAT;
desc.NumChannels = 1;
desc.Width = 64;
desc.Height = 64;
desc.Depth = 0;
\endcode
Description for a \p width x \p height x \p depth CUDA array of 64-bit,
4x16-bit float16's:
\code
CUDA_ARRAY3D_DESCRIPTOR desc;
desc.Format = CU_AD_FORMAT_HALF;
desc.NumChannels = 4;
desc.Width = width;
desc.Height = height;
desc.Depth = depth;
\endcode
\param pHandle - Returned array
\param pAllocateArray - 3D array descriptor
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa ::cuArray3DGetDescriptor, ::cuArrayCreate,
::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost,
::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned,
::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD,
::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync,
::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync,
::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost,
::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc,
::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16,
::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32,
::cudaMalloc3DArray*/
fn cuArray3DCreate_v2(
pHandle: *mut cuda_types::CUarray,
pAllocateArray: *const cuda_types::CUDA_ARRAY3D_DESCRIPTOR,
) -> cuda_types::CUresult;
/** \brief Get a 3D CUDA array descriptor
Returns in \p *pArrayDescriptor a descriptor containing information on the
format and dimensions of the CUDA array \p hArray. It is useful for
subroutines that have been passed a CUDA array, but need to know the CUDA
array parameters for validation or other purposes.
This function may be called on 1D and 2D arrays, in which case the \p Height
and/or \p Depth members of the descriptor struct will be set to 0.
\param pArrayDescriptor - Returned 3D array descriptor
\param hArray - 3D array to get descriptor of
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_CONTEXT_IS_DESTROYED
\notefnerr
\sa ::cuArray3DCreate, ::cuArrayCreate,
::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost,
::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned,
::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD,
::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync,
::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync,
::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost,
::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc,
::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16,
::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32,
::cudaArrayGetInfo*/
fn cuArray3DGetDescriptor_v2(
pArrayDescriptor: *mut cuda_types::CUDA_ARRAY3D_DESCRIPTOR,
hArray: cuda_types::CUarray,
) -> cuda_types::CUresult;
/** \brief Creates a CUDA mipmapped array
Creates a CUDA mipmapped array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure
\p pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array in \p *pHandle.
\p numMipmapLevels specifies the number of mipmap levels to be allocated. This value is
clamped to the range [1, 1 + floor(log2(max(width, height, depth)))].
The ::CUDA_ARRAY3D_DESCRIPTOR is defined as:
\code
typedef struct {
unsigned int Width;
unsigned int Height;
unsigned int Depth;
CUarray_format Format;
unsigned int NumChannels;
unsigned int Flags;
} CUDA_ARRAY3D_DESCRIPTOR;
\endcode
where:
- \p Width, \p Height, and \p Depth are the width, height, and depth of the
CUDA array (in elements); the following types of CUDA arrays can be allocated:
- A 1D mipmapped array is allocated if \p Height and \p Depth extents are both zero.
- A 2D mipmapped array is allocated if only \p Depth extent is zero.
- A 3D mipmapped array is allocated if all three extents are non-zero.
- A 1D layered CUDA mipmapped array is allocated if only \p Height is zero and the
::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The number
of layers is determined by the depth extent.
- A 2D layered CUDA mipmapped array is allocated if all three extents are non-zero and
the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number
of layers is determined by the depth extent.
- A cubemap CUDA mipmapped array is allocated if all three extents are non-zero and the
::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p Height, and
\p Depth must be six. A cubemap is a special type of 2D layered CUDA array,
where the six layers represent the six faces of a cube. The order of the six
layers in memory is the same as that listed in ::CUarray_cubemap_face.
- A cubemap layered CUDA mipmapped array is allocated if all three extents are non-zero,
and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are set.
\p Width must be equal to \p Height, and \p Depth must be a multiple of six.
A cubemap layered CUDA array is a special type of 2D layered CUDA array that
consists of a collection of cubemaps. The first six layers represent the first
cubemap, the next six layers form the second cubemap, and so on.
- ::Format specifies the format of the elements; ::CUarray_format is
defined as:
\code
typedef enum CUarray_format_enum {
CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
CU_AD_FORMAT_SIGNED_INT8 = 0x08,
CU_AD_FORMAT_SIGNED_INT16 = 0x09,
CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
CU_AD_FORMAT_HALF = 0x10,
CU_AD_FORMAT_FLOAT = 0x20
} CUarray_format;
\endcode
- \p NumChannels specifies the number of packed components per CUDA array
element; it may be 1, 2, or 4;
- ::Flags may be set to
- ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA mipmapped arrays. If this flag is set,
\p Depth specifies the number of layers, not the depth of a 3D array.
- ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to individual mipmap levels of
the CUDA mipmapped array. If this flag is not set, ::cuSurfRefSetArray will fail when attempting to
bind a mipmap level of the CUDA mipmapped array to a surface reference.
- ::CUDA_ARRAY3D_CUBEMAP to enable creation of mipmapped cubemaps. If this flag is set, \p Width must be
equal to \p Height, and \p Depth must be six. If the ::CUDA_ARRAY3D_LAYERED flag is also set,
then \p Depth must be a multiple of six.
- ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA mipmapped array will be used for texture gather.
Texture gather can only be performed on 2D CUDA mipmapped arrays.
\p Width, \p Height and \p Depth must meet certain size requirements as listed in the following table.
All values are specified in elements. Note that for brevity's sake, the full name of the device attribute
is not specified. For ex., TEXTURE1D_MIPMAPPED_WIDTH refers to the device attribute
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH.
| CUDA array type |
Valid extents that must always be met
{(width range in elements), (height range),
(depth range)} |
Valid extents with CUDA_ARRAY3D_SURFACE_LDST set
{(width range in elements), (height range), (depth range)} |
| 1D |
{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 } |
{ (1,SURFACE1D_WIDTH), 0, 0 } |
| 2D |
{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_HEIGHT), 0 } |
{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 } |
| 3D |
{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) }
OR
{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE),
(1,TEXTURE3D_DEPTH_ALTERNATE) } |
{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT),
(1,SURFACE3D_DEPTH) } |
| 1D Layered |
{ (1,TEXTURE1D_LAYERED_WIDTH), 0,
(1,TEXTURE1D_LAYERED_LAYERS) } |
{ (1,SURFACE1D_LAYERED_WIDTH), 0,
(1,SURFACE1D_LAYERED_LAYERS) } |
| 2D Layered |
{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT),
(1,TEXTURE2D_LAYERED_LAYERS) } |
{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT),
(1,SURFACE2D_LAYERED_LAYERS) } |
| Cubemap |
{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 } |
{ (1,SURFACECUBEMAP_WIDTH),
(1,SURFACECUBEMAP_WIDTH), 6 } |
| Cubemap Layered |
{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH),
(1,TEXTURECUBEMAP_LAYERED_LAYERS) } |
{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH),
(1,SURFACECUBEMAP_LAYERED_LAYERS) } |
\param pHandle - Returned mipmapped array
\param pMipmappedArrayDesc - mipmapped array descriptor
\param numMipmapLevels - Number of mipmap levels
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cuMipmappedArrayDestroy,
::cuMipmappedArrayGetLevel,
::cuArrayCreate,
::cudaMallocMipmappedArray*/
fn cuMipmappedArrayCreate(
pHandle: *mut cuda_types::CUmipmappedArray,
pMipmappedArrayDesc: *const cuda_types::CUDA_ARRAY3D_DESCRIPTOR,
numMipmapLevels: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Gets a mipmap level of a CUDA mipmapped array
Returns in \p *pLevelArray a CUDA array that represents a single mipmap level
of the CUDA mipmapped array \p hMipmappedArray.
If \p level is greater than the maximum number of levels in this mipmapped array,
::CUDA_ERROR_INVALID_VALUE is returned.
\param pLevelArray - Returned mipmap level CUDA array
\param hMipmappedArray - CUDA mipmapped array
\param level - Mipmap level
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE
\notefnerr
\sa
::cuMipmappedArrayCreate,
::cuMipmappedArrayDestroy,
::cuArrayCreate,
::cudaGetMipmappedArrayLevel*/
fn cuMipmappedArrayGetLevel(
pLevelArray: *mut cuda_types::CUarray,
hMipmappedArray: cuda_types::CUmipmappedArray,
level: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Destroys a CUDA mipmapped array
Destroys the CUDA mipmapped array \p hMipmappedArray.
\param hMipmappedArray - Mipmapped array to destroy
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_ARRAY_IS_MAPPED,
::CUDA_ERROR_CONTEXT_IS_DESTROYED
\notefnerr
\sa
::cuMipmappedArrayCreate,
::cuMipmappedArrayGetLevel,
::cuArrayCreate,
::cudaFreeMipmappedArray*/
fn cuMipmappedArrayDestroy(
hMipmappedArray: cuda_types::CUmipmappedArray,
) -> cuda_types::CUresult;
/** \brief Retrieve handle for an address range
Get a handle of the specified type to an address range. The address range
must have been obtained by a prior call to either ::cuMemAlloc or ::cuMemAddressReserve.
If the address range was obtained via ::cuMemAddressReserve, it must also be fully mapped via ::cuMemMap.
The address range must have been obtained by a prior call to either ::cuMemAllocHost or
::cuMemHostAlloc on Tegra.
Users must ensure the \p dptr and \p size are aligned to the host page size.
When requesting CUmemRangeHandleType::CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD,
users are expected to query for dma_buf support for the platform
by using ::CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED device attribute before calling
this API. The \p handle will be interpreted as a pointer to an integer to store the dma_buf file descriptor.
Users must ensure the entire address range is backed and mapped when
the address range is allocated by ::cuMemAddressReserve. All the physical
allocations backing the address range must be resident on the same device and
have identical allocation properties. Users are also expected to retrieve a
new handle every time the underlying physical allocation(s) corresponding
to a previously queried VA range are changed.
\param[out] handle - Pointer to the location where the returned handle will be stored.
\param[in] dptr - Pointer to a valid CUDA device allocation. Must be aligned to host page size.
\param[in] size - Length of the address range. Must be aligned to host page size.
\param[in] handleType - Type of handle requested (defines type and size of the \p handle output parameter)
\param[in] flags - Reserved, must be zero
\return
CUDA_SUCCESS
CUDA_ERROR_INVALID_VALUE
CUDA_ERROR_NOT_SUPPORTED*/
fn cuMemGetHandleForAddressRange(
handle: *mut ::core::ffi::c_void,
dptr: cuda_types::CUdeviceptr,
size: usize,
handleType: cuda_types::CUmemRangeHandleType,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Allocate an address range reservation.
Reserves a virtual address range based on the given parameters, giving
the starting address of the range in \p ptr. This API requires a system that
supports UVA. The size and address parameters must be a multiple of the
host page size and the alignment must be a power of two or zero for default
alignment.
\param[out] ptr - Resulting pointer to start of virtual address range allocated
\param[in] size - Size of the reserved virtual address range requested
\param[in] alignment - Alignment of the reserved virtual address range requested
\param[in] addr - Fixed starting address range requested
\param[in] flags - Currently unused, must be zero
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemAddressFree*/
fn cuMemAddressReserve(
ptr: *mut cuda_types::CUdeviceptr,
size: usize,
alignment: usize,
addr: cuda_types::CUdeviceptr,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Free an address range reservation.
Frees a virtual address range reserved by cuMemAddressReserve. The size
must match what was given to memAddressReserve and the ptr given must
match what was returned from memAddressReserve.
\param[in] ptr - Starting address of the virtual address range to free
\param[in] size - Size of the virtual address region to free
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemAddressReserve*/
fn cuMemAddressFree(
ptr: cuda_types::CUdeviceptr,
size: usize,
) -> cuda_types::CUresult;
/** \brief Create a CUDA memory handle representing a memory allocation of a given size described by the given properties
This creates a memory allocation on the target device specified through the
\p prop structure. The created allocation will not have any device or host
mappings. The generic memory \p handle for the allocation can be
mapped to the address space of calling process via ::cuMemMap. This handle
cannot be transmitted directly to other processes (see
::cuMemExportToShareableHandle). On Windows, the caller must also pass
an LPSECURITYATTRIBUTE in \p prop to be associated with this handle which
limits or allows access to this handle for a recipient process (see
::CUmemAllocationProp::win32HandleMetaData for more). The \p size of this
allocation must be a multiple of the the value given via
::cuMemGetAllocationGranularity with the ::CU_MEM_ALLOC_GRANULARITY_MINIMUM
flag.
To create a CPU allocation targeting a specific host NUMA node, applications must
set ::CUmemAllocationProp::CUmemLocation::type to ::CU_MEM_LOCATION_TYPE_HOST_NUMA and
::CUmemAllocationProp::CUmemLocation::id must specify the NUMA ID of the CPU.
On systems where NUMA is not available ::CUmemAllocationProp::CUmemLocation::id must be set to 0.
Applications can set ::CUmemAllocationProp::requestedHandleTypes to
::CU_MEM_HANDLE_TYPE_FABRIC in order to create allocations suitable for sharing
within an IMEX domain. An IMEX domain is either an OS instance or a group of securely
connected OS instances using the NVIDIA IMEX daemon. An IMEX channel is a global resource
within the IMEX domain that represents a logical entity that aims to provide fine grained
accessibility control for the participating processes. When exporter and importer CUDA processes
have been granted access to the same IMEX channel, they can securely share memory.
If the allocating process does not have access setup for an IMEX channel, attempting to create
a ::CUmemGenericAllocationHandle with ::CU_MEM_HANDLE_TYPE_FABRIC will result in ::CUDA_ERROR_NOT_PERMITTED.
The nvidia-modprobe CLI provides more information regarding setting up of IMEX channels.
If ::CUmemAllocationProp::allocFlags::usage contains ::CU_MEM_CREATE_USAGE_TILE_POOL flag then
the memory allocation is intended only to be used as backing tile pool for sparse CUDA arrays
and sparse CUDA mipmapped arrays.
(see ::cuMemMapArrayAsync).
\param[out] handle - Value of handle returned. All operations on this allocation are to be performed using this handle.
\param[in] size - Size of the allocation requested
\param[in] prop - Properties of the allocation to create.
\param[in] flags - flags for future use, must be zero now.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\notefnerr
\sa ::cuMemRelease, ::cuMemExportToShareableHandle, ::cuMemImportFromShareableHandle*/
fn cuMemCreate(
handle: *mut cuda_types::CUmemGenericAllocationHandle,
size: usize,
prop: *const cuda_types::CUmemAllocationProp,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Release a memory handle representing a memory allocation which was previously allocated through cuMemCreate.
Frees the memory that was allocated on a device through cuMemCreate.
The memory allocation will be freed when all outstanding mappings to the memory
are unmapped and when all outstanding references to the handle (including it's
shareable counterparts) are also released. The generic memory handle can be
freed when there are still outstanding mappings made with this handle. Each
time a recipient process imports a shareable handle, it needs to pair it with
::cuMemRelease for the handle to be freed. If \p handle is not a valid handle
the behavior is undefined.
\param[in] handle Value of handle which was returned previously by cuMemCreate.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\notefnerr
\sa ::cuMemCreate*/
fn cuMemRelease(
handle: cuda_types::CUmemGenericAllocationHandle,
) -> cuda_types::CUresult;
/** \brief Maps an allocation handle to a reserved virtual address range.
Maps bytes of memory represented by \p handle starting from byte \p offset to
\p size to address range [\p addr, \p addr + \p size]. This range must be an
address reservation previously reserved with ::cuMemAddressReserve, and
\p offset + \p size must be less than the size of the memory allocation.
Both \p ptr, \p size, and \p offset must be a multiple of the value given via
::cuMemGetAllocationGranularity with the ::CU_MEM_ALLOC_GRANULARITY_MINIMUM flag.
If \p handle represents a multicast object, \p ptr, \p size and \p offset must
be aligned to the value returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_MINIMUM_GRANULARITY. For best performance however, it is
recommended that \p ptr, \p size and \p offset be aligned to the value
returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_RECOMMENDED_GRANULARITY.
Please note calling ::cuMemMap does not make the address accessible,
the caller needs to update accessibility of a contiguous mapped VA
range by calling ::cuMemSetAccess.
Once a recipient process obtains a shareable memory handle
from ::cuMemImportFromShareableHandle, the process must
use ::cuMemMap to map the memory into its address ranges before
setting accessibility with ::cuMemSetAccess.
::cuMemMap can only create mappings on VA range reservations
that are not currently mapped.
\param[in] ptr - Address where memory will be mapped.
\param[in] size - Size of the memory mapping.
\param[in] offset - Offset into the memory represented by
- \p handle from which to start mapping
- Note: currently must be zero.
\param[in] handle - Handle to a shareable memory
\param[in] flags - flags for future use, must be zero now.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\notefnerr
\sa ::cuMemUnmap, ::cuMemSetAccess, ::cuMemCreate, ::cuMemAddressReserve, ::cuMemImportFromShareableHandle*/
fn cuMemMap(
ptr: cuda_types::CUdeviceptr,
size: usize,
offset: usize,
handle: cuda_types::CUmemGenericAllocationHandle,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Maps or unmaps subregions of sparse CUDA arrays and sparse CUDA mipmapped arrays
Performs map or unmap operations on subregions of sparse CUDA arrays and sparse CUDA mipmapped arrays.
Each operation is specified by a ::CUarrayMapInfo entry in the \p mapInfoList array of size \p count.
The structure ::CUarrayMapInfo is defined as follow:
\code
typedef struct CUarrayMapInfo_st {
CUresourcetype resourceType;
union {
CUmipmappedArray mipmap;
CUarray array;
} resource;
CUarraySparseSubresourceType subresourceType;
union {
struct {
unsigned int level;
unsigned int layer;
unsigned int offsetX;
unsigned int offsetY;
unsigned int offsetZ;
unsigned int extentWidth;
unsigned int extentHeight;
unsigned int extentDepth;
} sparseLevel;
struct {
unsigned int layer;
unsigned long long offset;
unsigned long long size;
} miptail;
} subresource;
CUmemOperationType memOperationType;
CUmemHandleType memHandleType;
union {
CUmemGenericAllocationHandle memHandle;
} memHandle;
unsigned long long offset;
unsigned int deviceBitMask;
unsigned int flags;
unsigned int reserved[2];
} CUarrayMapInfo;
\endcode
where ::CUarrayMapInfo::resourceType specifies the type of resource to be operated on.
If ::CUarrayMapInfo::resourceType is set to ::CUresourcetype::CU_RESOURCE_TYPE_ARRAY then
::CUarrayMapInfo::resource::array must be set to a valid sparse CUDA array handle.
The CUDA array must be either a 2D, 2D layered or 3D CUDA array and must have been allocated using
::cuArrayCreate or ::cuArray3DCreate with the flag ::CUDA_ARRAY3D_SPARSE
or ::CUDA_ARRAY3D_DEFERRED_MAPPING.
For CUDA arrays obtained using ::cuMipmappedArrayGetLevel, ::CUDA_ERROR_INVALID_VALUE will be returned.
If ::CUarrayMapInfo::resourceType is set to ::CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
then ::CUarrayMapInfo::resource::mipmap must be set to a valid sparse CUDA mipmapped array handle.
The CUDA mipmapped array must be either a 2D, 2D layered or 3D CUDA mipmapped array and must have been
allocated using ::cuMipmappedArrayCreate with the flag ::CUDA_ARRAY3D_SPARSE
or ::CUDA_ARRAY3D_DEFERRED_MAPPING.
::CUarrayMapInfo::subresourceType specifies the type of subresource within the resource.
::CUarraySparseSubresourceType_enum is defined as:
\code
typedef enum CUarraySparseSubresourceType_enum {
CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = 0,
CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = 1
} CUarraySparseSubresourceType;
\endcode
where ::CUarraySparseSubresourceType::CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL indicates a
sparse-miplevel which spans at least one tile in every dimension. The remaining miplevels which
are too small to span at least one tile in any dimension constitute the mip tail region as indicated by
::CUarraySparseSubresourceType::CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL subresource type.
If ::CUarrayMapInfo::subresourceType is set to ::CUarraySparseSubresourceType::CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL
then ::CUarrayMapInfo::subresource::sparseLevel struct must contain valid array subregion offsets and extents.
The ::CUarrayMapInfo::subresource::sparseLevel::offsetX, ::CUarrayMapInfo::subresource::sparseLevel::offsetY
and ::CUarrayMapInfo::subresource::sparseLevel::offsetZ must specify valid X, Y and Z offsets respectively.
The ::CUarrayMapInfo::subresource::sparseLevel::extentWidth, ::CUarrayMapInfo::subresource::sparseLevel::extentHeight
and ::CUarrayMapInfo::subresource::sparseLevel::extentDepth must specify valid width, height and depth extents respectively.
These offsets and extents must be aligned to the corresponding tile dimension.
For CUDA mipmapped arrays ::CUarrayMapInfo::subresource::sparseLevel::level must specify a valid mip level index. Otherwise,
must be zero.
For layered CUDA arrays and layered CUDA mipmapped arrays ::CUarrayMapInfo::subresource::sparseLevel::layer must specify a valid layer index. Otherwise,
must be zero.
::CUarrayMapInfo::subresource::sparseLevel::offsetZ must be zero and ::CUarrayMapInfo::subresource::sparseLevel::extentDepth
must be set to 1 for 2D and 2D layered CUDA arrays and CUDA mipmapped arrays.
Tile extents can be obtained by calling ::cuArrayGetSparseProperties and ::cuMipmappedArrayGetSparseProperties
If ::CUarrayMapInfo::subresourceType is set to ::CUarraySparseSubresourceType::CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL
then ::CUarrayMapInfo::subresource::miptail struct must contain valid mip tail offset in
::CUarrayMapInfo::subresource::miptail::offset and size in ::CUarrayMapInfo::subresource::miptail::size.
Both, mip tail offset and mip tail size must be aligned to the tile size.
For layered CUDA mipmapped arrays which don't have the flag ::CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL set in ::CUDA_ARRAY_SPARSE_PROPERTIES::flags
as returned by ::cuMipmappedArrayGetSparseProperties, ::CUarrayMapInfo::subresource::miptail::layer must specify a valid layer index.
Otherwise, must be zero.
If ::CUarrayMapInfo::resource::array or ::CUarrayMapInfo::resource::mipmap was created with ::CUDA_ARRAY3D_DEFERRED_MAPPING
flag set the ::CUarrayMapInfo::subresourceType and the contents of ::CUarrayMapInfo::subresource will be ignored.
::CUarrayMapInfo::memOperationType specifies the type of operation. ::CUmemOperationType is defined as:
\code
typedef enum CUmemOperationType_enum {
CU_MEM_OPERATION_TYPE_MAP = 1,
CU_MEM_OPERATION_TYPE_UNMAP = 2
} CUmemOperationType;
\endcode
If ::CUarrayMapInfo::memOperationType is set to ::CUmemOperationType::CU_MEM_OPERATION_TYPE_MAP then the subresource
will be mapped onto the tile pool memory specified by ::CUarrayMapInfo::memHandle at offset ::CUarrayMapInfo::offset.
The tile pool allocation has to be created by specifying the ::CU_MEM_CREATE_USAGE_TILE_POOL flag when calling ::cuMemCreate. Also,
::CUarrayMapInfo::memHandleType must be set to ::CUmemHandleType::CU_MEM_HANDLE_TYPE_GENERIC.
If ::CUarrayMapInfo::memOperationType is set to ::CUmemOperationType::CU_MEM_OPERATION_TYPE_UNMAP then an unmapping operation
is performed. ::CUarrayMapInfo::memHandle must be NULL.
::CUarrayMapInfo::deviceBitMask specifies the list of devices that must map or unmap physical memory.
Currently, this mask must have exactly one bit set, and the corresponding device must match the device associated with the stream.
If ::CUarrayMapInfo::memOperationType is set to ::CUmemOperationType::CU_MEM_OPERATION_TYPE_MAP, the device must also match
the device associated with the tile pool memory allocation as specified by ::CUarrayMapInfo::memHandle.
::CUarrayMapInfo::flags and ::CUarrayMapInfo::reserved[] are unused and must be set to zero.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE
\param[in] mapInfoList - List of ::CUarrayMapInfo
\param[in] count - Count of ::CUarrayMapInfo in \p mapInfoList
\param[in] hStream - Stream identifier for the stream to use for map or unmap operations
\sa ::cuMipmappedArrayCreate, ::cuArrayCreate, ::cuArray3DCreate, ::cuMemCreate, ::cuArrayGetSparseProperties, ::cuMipmappedArrayGetSparseProperties*/
fn cuMemMapArrayAsync_ptsz(
mapInfoList: *mut cuda_types::CUarrayMapInfo,
count: ::core::ffi::c_uint,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Unmap the backing memory of a given address range.
The range must be the entire contiguous address range that was mapped to. In
other words, ::cuMemUnmap cannot unmap a sub-range of an address range mapped
by ::cuMemCreate / ::cuMemMap. Any backing memory allocations will be freed
if there are no existing mappings and there are no unreleased memory handles.
When ::cuMemUnmap returns successfully the address range is converted to an
address reservation and can be used for a future calls to ::cuMemMap. Any new
mapping to this virtual address will need to have access granted through
::cuMemSetAccess, as all mappings start with no accessibility setup.
\param[in] ptr - Starting address for the virtual address range to unmap
\param[in] size - Size of the virtual address range to unmap
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\notefnerr
\note_sync
\sa ::cuMemCreate, ::cuMemAddressReserve*/
fn cuMemUnmap(ptr: cuda_types::CUdeviceptr, size: usize) -> cuda_types::CUresult;
/** \brief Set the access flags for each location specified in \p desc for the given virtual address range
Given the virtual address range via \p ptr and \p size, and the locations
in the array given by \p desc and \p count, set the access flags for the
target locations. The range must be a fully mapped address range
containing all allocations created by ::cuMemMap / ::cuMemCreate.
Users cannot specify ::CU_MEM_LOCATION_TYPE_HOST_NUMA accessibility for allocations created on with other location types.
Note: When ::CUmemAccessDesc::CUmemLocation::type is ::CU_MEM_LOCATION_TYPE_HOST_NUMA, ::CUmemAccessDesc::CUmemLocation::id
is ignored.
When setting the access flags for a virtual address range mapping a multicast
object, \p ptr and \p size must be aligned to the value returned by
::cuMulticastGetGranularity with the flag ::CU_MULTICAST_MINIMUM_GRANULARITY.
For best performance however, it is recommended that \p ptr and \p size be
aligned to the value returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_RECOMMENDED_GRANULARITY.
\param[in] ptr - Starting address for the virtual address range
\param[in] size - Length of the virtual address range
\param[in] desc - Array of ::CUmemAccessDesc that describe how to change the
- mapping for each location specified
\param[in] count - Number of ::CUmemAccessDesc in \p desc
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_SUPPORTED
\notefnerr
\note_sync
\sa ::cuMemSetAccess, ::cuMemCreate, :cuMemMap*/
fn cuMemSetAccess(
ptr: cuda_types::CUdeviceptr,
size: usize,
desc: *const cuda_types::CUmemAccessDesc,
count: usize,
) -> cuda_types::CUresult;
/** \brief Get the access \p flags set for the given \p location and \p ptr
\param[out] flags - Flags set for this location
\param[in] location - Location in which to check the flags for
\param[in] ptr - Address in which to check the access flags for
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemSetAccess*/
fn cuMemGetAccess(
flags: *mut ::core::ffi::c_ulonglong,
location: *const cuda_types::CUmemLocation,
ptr: cuda_types::CUdeviceptr,
) -> cuda_types::CUresult;
/** \brief Exports an allocation to a requested shareable handle type
Given a CUDA memory handle, create a shareable memory
allocation handle that can be used to share the memory with other
processes. The recipient process can convert the shareable handle back into a
CUDA memory handle using ::cuMemImportFromShareableHandle and map
it with ::cuMemMap. The implementation of what this handle is and how it
can be transferred is defined by the requested handle type in \p handleType
Once all shareable handles are closed and the allocation is released, the allocated
memory referenced will be released back to the OS and uses of the CUDA handle afterward
will lead to undefined behavior.
This API can also be used in conjunction with other APIs (e.g. Vulkan, OpenGL)
that support importing memory from the shareable type
\param[out] shareableHandle - Pointer to the location in which to store the requested handle type
\param[in] handle - CUDA handle for the memory allocation
\param[in] handleType - Type of shareable handle requested (defines type and size of the \p shareableHandle output parameter)
\param[in] flags - Reserved, must be zero
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemImportFromShareableHandle*/
fn cuMemExportToShareableHandle(
shareableHandle: *mut ::core::ffi::c_void,
handle: cuda_types::CUmemGenericAllocationHandle,
handleType: cuda_types::CUmemAllocationHandleType,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Imports an allocation from a requested shareable handle type.
If the current process cannot support the memory described by this shareable
handle, this API will error as ::CUDA_ERROR_NOT_SUPPORTED.
If \p shHandleType is ::CU_MEM_HANDLE_TYPE_FABRIC and the importer process has not been
granted access to the same IMEX channel as the exporter process, this API will error
as ::CUDA_ERROR_NOT_PERMITTED.
\note Importing shareable handles exported from some graphics APIs(VUlkan, OpenGL, etc)
created on devices under an SLI group may not be supported, and thus this API will
return CUDA_ERROR_NOT_SUPPORTED.
There is no guarantee that the contents of \p handle will be the same CUDA memory handle
for the same given OS shareable handle, or the same underlying allocation.
\param[out] handle - CUDA Memory handle for the memory allocation.
\param[in] osHandle - Shareable Handle representing the memory allocation that is to be imported.
\param[in] shHandleType - handle type of the exported handle ::CUmemAllocationHandleType.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemExportToShareableHandle, ::cuMemMap, ::cuMemRelease*/
fn cuMemImportFromShareableHandle(
handle: *mut cuda_types::CUmemGenericAllocationHandle,
osHandle: *mut ::core::ffi::c_void,
shHandleType: cuda_types::CUmemAllocationHandleType,
) -> cuda_types::CUresult;
/** \brief Calculates either the minimal or recommended granularity
Calculates either the minimal or recommended granularity
for a given allocation specification and returns it in granularity. This
granularity can be used as a multiple for alignment, size, or address mapping.
\param[out] granularity Returned granularity.
\param[in] prop Property for which to determine the granularity for
\param[in] option Determines which granularity to return
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemCreate, ::cuMemMap*/
fn cuMemGetAllocationGranularity(
granularity: *mut usize,
prop: *const cuda_types::CUmemAllocationProp,
option: cuda_types::CUmemAllocationGranularity_flags,
) -> cuda_types::CUresult;
/** \brief Retrieve the contents of the property structure defining properties for this handle
\param[out] prop - Pointer to a properties structure which will hold the information about this handle
\param[in] handle - Handle which to perform the query on
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemCreate, ::cuMemImportFromShareableHandle*/
fn cuMemGetAllocationPropertiesFromHandle(
prop: *mut cuda_types::CUmemAllocationProp,
handle: cuda_types::CUmemGenericAllocationHandle,
) -> cuda_types::CUresult;
/** \brief Given an address \p addr, returns the allocation handle of the backing memory allocation.
The handle is guaranteed to be the same handle value used to map the memory. If the address
requested is not mapped, the function will fail. The returned handle must be released with
corresponding number of calls to ::cuMemRelease.
\note The address \p addr, can be any address in a range previously mapped
by ::cuMemMap, and not necessarily the start address.
\param[out] handle CUDA Memory handle for the backing memory allocation.
\param[in] addr Memory address to query, that has been mapped previously.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMemCreate, ::cuMemRelease, ::cuMemMap*/
fn cuMemRetainAllocationHandle(
handle: *mut cuda_types::CUmemGenericAllocationHandle,
addr: *mut ::core::ffi::c_void,
) -> cuda_types::CUresult;
/** \brief Frees memory with stream ordered semantics
Inserts a free operation into \p hStream.
The allocation must not be accessed after stream execution reaches the free.
After this API returns, accessing the memory from any subsequent work launched on the GPU
or querying its pointer attributes results in undefined behavior.
\note During stream capture, this function results in the creation of a free node and
must therefore be passed the address of a graph allocation.
\param dptr - memory to free
\param hStream - The stream establishing the stream ordering contract.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT (default stream specified with no current context),
::CUDA_ERROR_NOT_SUPPORTED*/
fn cuMemFreeAsync_ptsz(
dptr: cuda_types::CUdeviceptr,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Allocates memory with stream ordered semantics
Inserts an allocation operation into \p hStream.
A pointer to the allocated memory is returned immediately in *dptr.
The allocation must not be accessed until the the allocation operation completes.
The allocation comes from the memory pool current to the stream's device.
\note The default memory pool of a device contains device memory from that device.
\note Basic stream ordering allows future work submitted into the same stream to use the allocation.
Stream query, stream synchronize, and CUDA events can be used to guarantee that the allocation
operation completes before work submitted in a separate stream runs.
\note During stream capture, this function results in the creation of an allocation node. In this case,
the allocation is owned by the graph instead of the memory pool. The memory pool's properties
are used to set the node's creation parameters.
\param[out] dptr - Returned device pointer
\param[in] bytesize - Number of bytes to allocate
\param[in] hStream - The stream establishing the stream ordering contract and the memory pool to allocate from
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT (default stream specified with no current context),
::CUDA_ERROR_NOT_SUPPORTED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemAllocFromPoolAsync, ::cuMemFreeAsync, ::cuDeviceSetMemPool,
::cuDeviceGetDefaultMemPool, ::cuDeviceGetMemPool, ::cuMemPoolCreate,
::cuMemPoolSetAccess, ::cuMemPoolSetAttribute*/
fn cuMemAllocAsync_ptsz(
dptr: *mut cuda_types::CUdeviceptr,
bytesize: usize,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Tries to release memory back to the OS
Releases memory back to the OS until the pool contains fewer than minBytesToKeep
reserved bytes, or there is no more memory that the allocator can safely release.
The allocator cannot release OS allocations that back outstanding asynchronous allocations.
The OS allocations may happen at different granularity from the user allocations.
\note: Allocations that have not been freed count as outstanding.
\note: Allocations that have been asynchronously freed but whose completion has
not been observed on the host (eg. by a synchronize) can count as outstanding.
\param[in] pool - The memory pool to trim
\param[in] minBytesToKeep - If the pool has less than minBytesToKeep reserved,
the TrimTo operation is a no-op. Otherwise the pool will be guaranteed to have
at least minBytesToKeep bytes reserved after the operation.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate*/
fn cuMemPoolTrimTo(
pool: cuda_types::CUmemoryPool,
minBytesToKeep: usize,
) -> cuda_types::CUresult;
/** \brief Sets attributes of a memory pool
Supported attributes are:
- ::CU_MEMPOOL_ATTR_RELEASE_THRESHOLD: (value type = cuuint64_t)
Amount of reserved memory in bytes to hold onto before trying
to release memory back to the OS. When more than the release
threshold bytes of memory are held by the memory pool, the
allocator will try to release memory back to the OS on the
next call to stream, event or context synchronize. (default 0)
- ::CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES: (value type = int)
Allow ::cuMemAllocAsync to use memory asynchronously freed
in another stream as long as a stream ordering dependency
of the allocating stream on the free action exists.
Cuda events and null stream interactions can create the required
stream ordered dependencies. (default enabled)
- ::CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC: (value type = int)
Allow reuse of already completed frees when there is no dependency
between the free and allocation. (default enabled)
- ::CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES: (value type = int)
Allow ::cuMemAllocAsync to insert new stream dependencies
in order to establish the stream ordering required to reuse
a piece of memory released by ::cuMemFreeAsync (default enabled).
- ::CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH: (value type = cuuint64_t)
Reset the high watermark that tracks the amount of backing memory that was
allocated for the memory pool. It is illegal to set this attribute to a non-zero value.
- ::CU_MEMPOOL_ATTR_USED_MEM_HIGH: (value type = cuuint64_t)
Reset the high watermark that tracks the amount of used memory that was
allocated for the memory pool.
\param[in] pool - The memory pool to modify
\param[in] attr - The attribute to modify
\param[in] value - Pointer to the value to assign
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate*/
fn cuMemPoolSetAttribute(
pool: cuda_types::CUmemoryPool,
attr: cuda_types::CUmemPool_attribute,
value: *mut ::core::ffi::c_void,
) -> cuda_types::CUresult;
/** \brief Gets attributes of a memory pool
Supported attributes are:
- ::CU_MEMPOOL_ATTR_RELEASE_THRESHOLD: (value type = cuuint64_t)
Amount of reserved memory in bytes to hold onto before trying
to release memory back to the OS. When more than the release
threshold bytes of memory are held by the memory pool, the
allocator will try to release memory back to the OS on the
next call to stream, event or context synchronize. (default 0)
- ::CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES: (value type = int)
Allow ::cuMemAllocAsync to use memory asynchronously freed
in another stream as long as a stream ordering dependency
of the allocating stream on the free action exists.
Cuda events and null stream interactions can create the required
stream ordered dependencies. (default enabled)
- ::CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC: (value type = int)
Allow reuse of already completed frees when there is no dependency
between the free and allocation. (default enabled)
- ::CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES: (value type = int)
Allow ::cuMemAllocAsync to insert new stream dependencies
in order to establish the stream ordering required to reuse
a piece of memory released by ::cuMemFreeAsync (default enabled).
- ::CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT: (value type = cuuint64_t)
Amount of backing memory currently allocated for the mempool
- ::CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH: (value type = cuuint64_t)
High watermark of backing memory allocated for the mempool since the
last time it was reset.
- ::CU_MEMPOOL_ATTR_USED_MEM_CURRENT: (value type = cuuint64_t)
Amount of memory from the pool that is currently in use by the application.
- ::CU_MEMPOOL_ATTR_USED_MEM_HIGH: (value type = cuuint64_t)
High watermark of the amount of memory from the pool that was in use by the application.
\param[in] pool - The memory pool to get attributes of
\param[in] attr - The attribute to get
\param[out] value - Retrieved value
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate*/
fn cuMemPoolGetAttribute(
pool: cuda_types::CUmemoryPool,
attr: cuda_types::CUmemPool_attribute,
value: *mut ::core::ffi::c_void,
) -> cuda_types::CUresult;
/** \brief Controls visibility of pools between devices
\param[in] pool - The pool being modified
\param[in] map - Array of access descriptors. Each descriptor instructs the access to enable for a single gpu.
\param[in] count - Number of descriptors in the map array.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate*/
fn cuMemPoolSetAccess(
pool: cuda_types::CUmemoryPool,
map: *const cuda_types::CUmemAccessDesc,
count: usize,
) -> cuda_types::CUresult;
/** \brief Returns the accessibility of a pool from a device
Returns the accessibility of the pool's memory from the specified location.
\param[out] flags - the accessibility of the pool from the specified location
\param[in] memPool - the pool being queried
\param[in] location - the location accessing the pool
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate*/
fn cuMemPoolGetAccess(
flags: *mut cuda_types::CUmemAccess_flags,
memPool: cuda_types::CUmemoryPool,
location: *mut cuda_types::CUmemLocation,
) -> cuda_types::CUresult;
/** \brief Creates a memory pool
Creates a CUDA memory pool and returns the handle in \p pool. The \p poolProps determines
the properties of the pool such as the backing device and IPC capabilities.
To create a memory pool targeting a specific host NUMA node, applications must
set ::CUmemPoolProps::CUmemLocation::type to ::CU_MEM_LOCATION_TYPE_HOST_NUMA and
::CUmemPoolProps::CUmemLocation::id must specify the NUMA ID of the host memory node.
By default, the pool's memory will be accessible from the device it is allocated on.
In the case of pools created with ::CU_MEM_LOCATION_TYPE_HOST_NUMA, their default accessibility
will be from the host CPU.
Applications can control the maximum size of the pool by specifying a non-zero value for ::CUmemPoolProps::maxSize.
If set to 0, the maximum size of the pool will default to a system dependent value.
Applications can set ::CUmemPoolProps::handleTypes to ::CU_MEM_HANDLE_TYPE_FABRIC
in order to create ::CUmemoryPool suitable for sharing within an IMEX domain.
An IMEX domain is either an OS instance or a group of securely connected OS instances
using the NVIDIA IMEX daemon. An IMEX channel is a global resource within the IMEX domain
that represents a logical entity that aims to provide fine grained accessibility control
for the participating processes. When exporter and importer CUDA processes have been
granted access to the same IMEX channel, they can securely share memory.
If the allocating process does not have access setup for an IMEX channel, attempting to export
a ::CUmemoryPool with ::CU_MEM_HANDLE_TYPE_FABRIC will result in ::CUDA_ERROR_NOT_PERMITTED.
The nvidia-modprobe CLI provides more information regarding setting up of IMEX channels.
\note Specifying CU_MEM_HANDLE_TYPE_NONE creates a memory pool that will not support IPC.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_NOT_PERMITTED
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuDeviceSetMemPool, ::cuDeviceGetMemPool, ::cuDeviceGetDefaultMemPool,
::cuMemAllocFromPoolAsync, ::cuMemPoolExportToShareableHandle*/
fn cuMemPoolCreate(
pool: *mut cuda_types::CUmemoryPool,
poolProps: *const cuda_types::CUmemPoolProps,
) -> cuda_types::CUresult;
/** \brief Destroys the specified memory pool
If any pointers obtained from this pool haven't been freed or
the pool has free operations that haven't completed
when ::cuMemPoolDestroy is invoked, the function will return immediately and the
resources associated with the pool will be released automatically
once there are no more outstanding allocations.
Destroying the current mempool of a device sets the default mempool of
that device as the current mempool for that device.
\note A device's default memory pool cannot be destroyed.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuMemFreeAsync, ::cuDeviceSetMemPool, ::cuDeviceGetMemPool,
::cuDeviceGetDefaultMemPool, ::cuMemPoolCreate*/
fn cuMemPoolDestroy(pool: cuda_types::CUmemoryPool) -> cuda_types::CUresult;
/** \brief Allocates memory from a specified pool with stream ordered semantics.
Inserts an allocation operation into \p hStream.
A pointer to the allocated memory is returned immediately in *dptr.
The allocation must not be accessed until the the allocation operation completes.
The allocation comes from the specified memory pool.
\note
- The specified memory pool may be from a device different than that of the specified \p hStream.
- Basic stream ordering allows future work submitted into the same stream to use the allocation.
Stream query, stream synchronize, and CUDA events can be used to guarantee that the allocation
operation completes before work submitted in a separate stream runs.
\note During stream capture, this function results in the creation of an allocation node. In this case,
the allocation is owned by the graph instead of the memory pool. The memory pool's properties
are used to set the node's creation parameters.
\param[out] dptr - Returned device pointer
\param[in] bytesize - Number of bytes to allocate
\param[in] pool - The pool to allocate from
\param[in] hStream - The stream establishing the stream ordering semantic
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT (default stream specified with no current context),
::CUDA_ERROR_NOT_SUPPORTED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemAllocAsync, ::cuMemFreeAsync, ::cuDeviceGetDefaultMemPool,
::cuDeviceGetMemPool, ::cuMemPoolCreate, ::cuMemPoolSetAccess,
::cuMemPoolSetAttribute*/
fn cuMemAllocFromPoolAsync_ptsz(
dptr: *mut cuda_types::CUdeviceptr,
bytesize: usize,
pool: cuda_types::CUmemoryPool,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Exports a memory pool to the requested handle type.
Given an IPC capable mempool, create an OS handle to share the pool with another process.
A recipient process can convert the shareable handle into a mempool with ::cuMemPoolImportFromShareableHandle.
Individual pointers can then be shared with the ::cuMemPoolExportPointer and ::cuMemPoolImportPointer APIs.
The implementation of what the shareable handle is and how it can be transferred is defined by the requested
handle type.
\note: To create an IPC capable mempool, create a mempool with a CUmemAllocationHandleType other than CU_MEM_HANDLE_TYPE_NONE.
\param[out] handle_out - Returned OS handle
\param[in] pool - pool to export
\param[in] handleType - the type of handle to create
\param[in] flags - must be 0
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemPoolImportFromShareableHandle, ::cuMemPoolExportPointer,
::cuMemPoolImportPointer, ::cuMemAllocAsync, ::cuMemFreeAsync,
::cuDeviceGetDefaultMemPool, ::cuDeviceGetMemPool, ::cuMemPoolCreate,
::cuMemPoolSetAccess, ::cuMemPoolSetAttribute*/
fn cuMemPoolExportToShareableHandle(
handle_out: *mut ::core::ffi::c_void,
pool: cuda_types::CUmemoryPool,
handleType: cuda_types::CUmemAllocationHandleType,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief imports a memory pool from a shared handle.
Specific allocations can be imported from the imported pool with cuMemPoolImportPointer.
If \p handleType is ::CU_MEM_HANDLE_TYPE_FABRIC and the importer process has not been
granted access to the same IMEX channel as the exporter process, this API will error
as ::CUDA_ERROR_NOT_PERMITTED.
\note Imported memory pools do not support creating new allocations.
As such imported memory pools may not be used in cuDeviceSetMemPool
or ::cuMemAllocFromPoolAsync calls.
\param[out] pool_out - Returned memory pool
\param[in] handle - OS handle of the pool to open
\param[in] handleType - The type of handle being imported
\param[in] flags - must be 0
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemPoolExportToShareableHandle, ::cuMemPoolExportPointer, ::cuMemPoolImportPointer*/
fn cuMemPoolImportFromShareableHandle(
pool_out: *mut cuda_types::CUmemoryPool,
handle: *mut ::core::ffi::c_void,
handleType: cuda_types::CUmemAllocationHandleType,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Export data to share a memory pool allocation between processes.
Constructs \p shareData_out for sharing a specific allocation from an already shared memory pool.
The recipient process can import the allocation with the ::cuMemPoolImportPointer api.
The data is not a handle and may be shared through any IPC mechanism.
\param[out] shareData_out - Returned export data
\param[in] ptr - pointer to memory being exported
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemPoolExportToShareableHandle, ::cuMemPoolImportFromShareableHandle, ::cuMemPoolImportPointer*/
fn cuMemPoolExportPointer(
shareData_out: *mut cuda_types::CUmemPoolPtrExportData,
ptr: cuda_types::CUdeviceptr,
) -> cuda_types::CUresult;
/** \brief Import a memory pool allocation from another process.
Returns in \p ptr_out a pointer to the imported memory.
The imported memory must not be accessed before the allocation operation completes
in the exporting process. The imported memory must be freed from all importing processes before
being freed in the exporting process. The pointer may be freed with cuMemFree
or cuMemFreeAsync. If cuMemFreeAsync is used, the free must be completed
on the importing process before the free operation on the exporting process.
\note The cuMemFreeAsync api may be used in the exporting process before
the cuMemFreeAsync operation completes in its stream as long as the
cuMemFreeAsync in the exporting process specifies a stream with
a stream dependency on the importing process's cuMemFreeAsync.
\param[out] ptr_out - pointer to imported memory
\param[in] pool - pool from which to import
\param[in] shareData - data specifying the memory to import
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa ::cuMemPoolExportToShareableHandle, ::cuMemPoolImportFromShareableHandle, ::cuMemPoolExportPointer*/
fn cuMemPoolImportPointer(
ptr_out: *mut cuda_types::CUdeviceptr,
pool: cuda_types::CUmemoryPool,
shareData: *mut cuda_types::CUmemPoolPtrExportData,
) -> cuda_types::CUresult;
/** \brief Create a generic allocation handle representing a multicast object described by the given properties.
This creates a multicast object as described by \p prop. The number of
participating devices is specified by ::CUmulticastObjectProp::numDevices.
Devices can be added to the multicast object via ::cuMulticastAddDevice.
All participating devices must be added to the multicast object before memory
can be bound to it. Memory is bound to the multicast object via either
::cuMulticastBindMem or ::cuMulticastBindAddr, and can be unbound via
::cuMulticastUnbind. The total amount of memory that can be bound per device
is specified by :CUmulticastObjectProp::size. This size must be a multiple of
the value returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_GRANULARITY_MINIMUM. For best performance however, the size
should be aligned to the value returned by ::cuMulticastGetGranularity with
the flag ::CU_MULTICAST_GRANULARITY_RECOMMENDED.
After all participating devices have been added, multicast objects can also
be mapped to a device's virtual address space using the virtual memory
management APIs (see ::cuMemMap and ::cuMemSetAccess). Multicast objects can
also be shared with other processes by requesting a shareable handle via
::cuMemExportToShareableHandle. Note that the desired types of shareable
handles must be specified in the bitmask ::CUmulticastObjectProp::handleTypes.
Multicast objects can be released using the virtual memory management API
::cuMemRelease.
\param[out] mcHandle Value of handle returned.
\param[in] prop Properties of the multicast object to create.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMulticastAddDevice, ::cuMulticastBindMem, ::cuMulticastBindAddr, ::cuMulticastUnbind
\sa ::cuMemCreate, ::cuMemRelease, ::cuMemExportToShareableHandle, ::cuMemImportFromShareableHandle*/
fn cuMulticastCreate(
mcHandle: *mut cuda_types::CUmemGenericAllocationHandle,
prop: *const cuda_types::CUmulticastObjectProp,
) -> cuda_types::CUresult;
/** \brief Associate a device to a multicast object.
Associates a device to a multicast object. The added device will be a part of
the multicast team of size specified by CUmulticastObjectProp::numDevices
during ::cuMulticastCreate.
The association of the device to the multicast object is permanent during
the life time of the multicast object.
All devices must be added to the multicast team before any memory can be
bound to any device in the team. Any calls to ::cuMulticastBindMem or
::cuMulticastBindAddr will block until all devices have been added.
Similarly all devices must be added to the multicast team before a virtual
address range can be mapped to the multicast object. A call to ::cuMemMap
will block until all devices have been added.
\param[in] mcHandle Handle representing a multicast object.
\param[in] dev Device that will be associated to the multicast
object.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMulticastCreate, ::cuMulticastBindMem, ::cuMulticastBindAddr*/
fn cuMulticastAddDevice(
mcHandle: cuda_types::CUmemGenericAllocationHandle,
dev: cuda_types::CUdevice,
) -> cuda_types::CUresult;
/** \brief Bind a memory allocation represented by a handle to a multicast object.
Binds a memory allocation specified by \p memHandle and created via
::cuMemCreate to a multicast object represented by \p mcHandle and created
via ::cuMulticastCreate. The intended \p size of the bind, the offset in the
multicast range \p mcOffset as well as the offset in the memory \p memOffset
must be a multiple of the value returned by ::cuMulticastGetGranularity with
the flag ::CU_MULTICAST_GRANULARITY_MINIMUM. For best performance however,
\p size, \p mcOffset and \p memOffset should be aligned to the granularity of
the memory allocation(see ::cuMemGetAllocationGranularity) or to the value
returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_GRANULARITY_RECOMMENDED.
The \p size + \p memOffset must be smaller than the size of the allocated
memory. Similarly the \p size + \p mcOffset must be smaller than the size
of the multicast object.
The memory allocation must have beeen created on one of the devices
that was added to the multicast team via ::cuMulticastAddDevice.
Externally shareable as well as imported multicast objects can be bound only
to externally shareable memory.
Note that this call will return CUDA_ERROR_OUT_OF_MEMORY if there are
insufficient resources required to perform the bind. This call may also
return CUDA_ERROR_SYSTEM_NOT_READY if the necessary system software is not
initialized or running.
\param[in] mcHandle Handle representing a multicast object.
\param[in] mcOffset Offset into the multicast object for attachment.
\param[in] memHandle Handle representing a memory allocation.
\param[in] memOffset Offset into the memory for attachment.
\param[in] size Size of the memory that will be bound to the
multicast object.
\param[in] flags Flags for future use, must be zero for now.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_SYSTEM_NOT_READY
\sa ::cuMulticastCreate, ::cuMulticastAddDevice, ::cuMemCreate*/
fn cuMulticastBindMem(
mcHandle: cuda_types::CUmemGenericAllocationHandle,
mcOffset: usize,
memHandle: cuda_types::CUmemGenericAllocationHandle,
memOffset: usize,
size: usize,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Bind a memory allocation represented by a virtual address to a multicast object.
Binds a memory allocation specified by its mapped address \p memptr to a
multicast object represented by \p mcHandle.
The memory must have been allocated via ::cuMemCreate or ::cudaMallocAsync.
The intended \p size of the bind, the offset in the multicast range
\p mcOffset and \p memptr must be a multiple of the value returned by
::cuMulticastGetGranularity with the flag ::CU_MULTICAST_GRANULARITY_MINIMUM.
For best performance however, \p size, \p mcOffset and \p memptr should be
aligned to the value returned by ::cuMulticastGetGranularity with the flag
::CU_MULTICAST_GRANULARITY_RECOMMENDED.
The \p size must be smaller than the size of the allocated memory.
Similarly the \p size + \p mcOffset must be smaller than the total size
of the multicast object.
The memory allocation must have beeen created on one of the devices
that was added to the multicast team via ::cuMulticastAddDevice.
Externally shareable as well as imported multicast objects can be bound only
to externally shareable memory.
Note that this call will return CUDA_ERROR_OUT_OF_MEMORY if there are
insufficient resources required to perform the bind. This call may also
return CUDA_ERROR_SYSTEM_NOT_READY if the necessary system software is not
initialized or running.
\param[in] mcHandle Handle representing a multicast object.
\param[in] mcOffset Offset into multicast va range for attachment.
\param[in] memptr Virtual address of the memory allocation.
\param[in] size Size of memory that will be bound to the
multicast object.
\param[in] flags Flags for future use, must be zero now.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED,
::CUDA_ERROR_OUT_OF_MEMORY,
::CUDA_ERROR_SYSTEM_NOT_READY
\sa ::cuMulticastCreate, ::cuMulticastAddDevice, ::cuMemCreate*/
fn cuMulticastBindAddr(
mcHandle: cuda_types::CUmemGenericAllocationHandle,
mcOffset: usize,
memptr: cuda_types::CUdeviceptr,
size: usize,
flags: ::core::ffi::c_ulonglong,
) -> cuda_types::CUresult;
/** \brief Unbind any memory allocations bound to a multicast object at a given offset and upto a given size.
Unbinds any memory allocations hosted on \p dev and bound to a multicast
object at \p mcOffset and upto a given \p size.
The intended \p size of the unbind and the offset in the multicast range
( \p mcOffset ) must be a multiple of the value returned by
::cuMulticastGetGranularity flag ::CU_MULTICAST_GRANULARITY_MINIMUM.
The \p size + \p mcOffset must be smaller than the total size of the
multicast object.
\note
Warning:
The \p mcOffset and the \p size must match the corresponding values specified
during the bind call. Any other values may result in undefined behavior.
\param[in] mcHandle Handle representing a multicast object.
\param[in] dev Device that hosts the memory allocation.
\param[in] mcOffset Offset into the multicast object.
\param[in] size Desired size to unbind.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMulticastBindMem, ::cuMulticastBindAddr*/
fn cuMulticastUnbind(
mcHandle: cuda_types::CUmemGenericAllocationHandle,
dev: cuda_types::CUdevice,
mcOffset: usize,
size: usize,
) -> cuda_types::CUresult;
/** \brief Calculates either the minimal or recommended granularity for multicast object
Calculates either the minimal or recommended granularity for a given set of
multicast object properties and returns it in granularity. This granularity
can be used as a multiple for size, bind offsets and address mappings of the
multicast object.
\param[out] granularity Returned granularity.
\param[in] prop Properties of the multicast object.
\param[in] option Determines which granularity to return.
\returns
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_NOT_SUPPORTED
\sa ::cuMulticastCreate, ::cuMulticastBindMem, ::cuMulticastBindAddr, ::cuMulticastUnbind*/
fn cuMulticastGetGranularity(
granularity: *mut usize,
prop: *const cuda_types::CUmulticastObjectProp,
option: cuda_types::CUmulticastGranularity_flags,
) -> cuda_types::CUresult;
/** \brief Returns information about a pointer
The supported attributes are:
- ::CU_POINTER_ATTRIBUTE_CONTEXT:
Returns in \p *data the ::CUcontext in which \p ptr was allocated or
registered.
The type of \p data must be ::CUcontext *.
If \p ptr was not allocated by, mapped by, or registered with
a ::CUcontext which uses unified virtual addressing then
::CUDA_ERROR_INVALID_VALUE is returned.
- ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE:
Returns in \p *data the physical memory type of the memory that
\p ptr addresses as a ::CUmemorytype enumerated value.
The type of \p data must be unsigned int.
If \p ptr addresses device memory then \p *data is set to
::CU_MEMORYTYPE_DEVICE. The particular ::CUdevice on which the
memory resides is the ::CUdevice of the ::CUcontext returned by the
::CU_POINTER_ATTRIBUTE_CONTEXT attribute of \p ptr.
If \p ptr addresses host memory then \p *data is set to
::CU_MEMORYTYPE_HOST.
If \p ptr was not allocated by, mapped by, or registered with
a ::CUcontext which uses unified virtual addressing then
::CUDA_ERROR_INVALID_VALUE is returned.
If the current ::CUcontext does not support unified virtual
addressing then ::CUDA_ERROR_INVALID_CONTEXT is returned.
- ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER:
Returns in \p *data the device pointer value through which
\p ptr may be accessed by kernels running in the current
::CUcontext.
The type of \p data must be CUdeviceptr *.
If there exists no device pointer value through which
kernels running in the current ::CUcontext may access
\p ptr then ::CUDA_ERROR_INVALID_VALUE is returned.
If there is no current ::CUcontext then
::CUDA_ERROR_INVALID_CONTEXT is returned.
Except in the exceptional disjoint addressing cases discussed
below, the value returned in \p *data will equal the input
value \p ptr.
- ::CU_POINTER_ATTRIBUTE_HOST_POINTER:
Returns in \p *data the host pointer value through which
\p ptr may be accessed by by the host program.
The type of \p data must be void **.
If there exists no host pointer value through which
the host program may directly access \p ptr then
::CUDA_ERROR_INVALID_VALUE is returned.
Except in the exceptional disjoint addressing cases discussed
below, the value returned in \p *data will equal the input
value \p ptr.
- ::CU_POINTER_ATTRIBUTE_P2P_TOKENS:
Returns in \p *data two tokens for use with the nv-p2p.h Linux
kernel interface. \p data must be a struct of type
CUDA_POINTER_ATTRIBUTE_P2P_TOKENS.
\p ptr must be a pointer to memory obtained from :cuMemAlloc().
Note that p2pToken and vaSpaceToken are only valid for the
lifetime of the source allocation. A subsequent allocation at
the same address may return completely different tokens.
Querying this attribute has a side effect of setting the attribute
::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS for the region of memory that
\p ptr points to.
- ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS:
A boolean attribute which when set, ensures that synchronous memory operations
initiated on the region of memory that \p ptr points to will always synchronize.
See further documentation in the section titled "API synchronization behavior"
to learn more about cases when synchronous memory operations can
exhibit asynchronous behavior.
- ::CU_POINTER_ATTRIBUTE_BUFFER_ID:
Returns in \p *data a buffer ID which is guaranteed to be unique within the process.
\p data must point to an unsigned long long.
\p ptr must be a pointer to memory obtained from a CUDA memory allocation API.
Every memory allocation from any of the CUDA memory allocation APIs will
have a unique ID over a process lifetime. Subsequent allocations do not reuse IDs
from previous freed allocations. IDs are only unique within a single process.
- ::CU_POINTER_ATTRIBUTE_IS_MANAGED:
Returns in \p *data a boolean that indicates whether the pointer points to
managed memory or not.
If \p ptr is not a valid CUDA pointer then ::CUDA_ERROR_INVALID_VALUE is returned.
- ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL:
Returns in \p *data an integer representing a device ordinal of a device against
which the memory was allocated or registered.
- ::CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE:
Returns in \p *data a boolean that indicates if this pointer maps to
an allocation that is suitable for ::cudaIpcGetMemHandle.
- ::CU_POINTER_ATTRIBUTE_RANGE_START_ADDR:
Returns in \p *data the starting address for the allocation referenced
by the device pointer \p ptr. Note that this is not necessarily the
address of the mapped region, but the address of the mappable address
range \p ptr references (e.g. from ::cuMemAddressReserve).
- ::CU_POINTER_ATTRIBUTE_RANGE_SIZE:
Returns in \p *data the size for the allocation referenced by the device
pointer \p ptr. Note that this is not necessarily the size of the mapped
region, but the size of the mappable address range \p ptr references
(e.g. from ::cuMemAddressReserve). To retrieve the size of the mapped
region, see ::cuMemGetAddressRange
- ::CU_POINTER_ATTRIBUTE_MAPPED:
Returns in \p *data a boolean that indicates if this pointer is in a
valid address range that is mapped to a backing allocation.
- ::CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES:
Returns a bitmask of the allowed handle types for an allocation that may
be passed to ::cuMemExportToShareableHandle.
- ::CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE:
Returns in \p *data the handle to the mempool that the allocation was obtained from.
\par
Note that for most allocations in the unified virtual address space
the host and device pointer for accessing the allocation will be the
same. The exceptions to this are
- user memory registered using ::cuMemHostRegister
- host memory allocated using ::cuMemHostAlloc with the
::CU_MEMHOSTALLOC_WRITECOMBINED flag
For these types of allocation there will exist separate, disjoint host
and device addresses for accessing the allocation. In particular
- The host address will correspond to an invalid unmapped device address
(which will result in an exception if accessed from the device)
- The device address will correspond to an invalid unmapped host address
(which will result in an exception if accessed from the host).
For these types of allocations, querying ::CU_POINTER_ATTRIBUTE_HOST_POINTER
and ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER may be used to retrieve the host
and device addresses from either address.
\param data - Returned pointer attribute value
\param attribute - Pointer attribute to query
\param ptr - Pointer
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\sa
::cuPointerSetAttribute,
::cuMemAlloc,
::cuMemFree,
::cuMemAllocHost,
::cuMemFreeHost,
::cuMemHostAlloc,
::cuMemHostRegister,
::cuMemHostUnregister,
::cudaPointerGetAttributes*/
fn cuPointerGetAttribute(
data: *mut ::core::ffi::c_void,
attribute: cuda_types::CUpointer_attribute,
ptr: cuda_types::CUdeviceptr,
) -> cuda_types::CUresult;
/** \brief Prefetches memory to the specified destination device
Note there is a later version of this API, ::cuMemPrefetchAsync_v2. It will
supplant this version in 13.0, which is retained for minor version compatibility.
Prefetches memory to the specified destination device. \p devPtr is the
base device pointer of the memory to be prefetched and \p dstDevice is the
destination device. \p count specifies the number of bytes to copy. \p hStream
is the stream in which the operation is enqueued. The memory range must refer
to managed memory allocated via ::cuMemAllocManaged or declared via __managed__ variables.
Passing in CU_DEVICE_CPU for \p dstDevice will prefetch the data to host memory. If
\p dstDevice is a GPU, then the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS
must be non-zero. Additionally, \p hStream must be associated with a device that has a
non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS.
The start address and end address of the memory range will be rounded down and rounded up
respectively to be aligned to CPU page size before the prefetch operation is enqueued
in the stream.
If no physical memory has been allocated for this region, then this memory region
will be populated and mapped on the destination device. If there's insufficient
memory to prefetch the desired region, the Unified Memory driver may evict pages from other
::cuMemAllocManaged allocations to host memory in order to make room. Device memory
allocated using ::cuMemAlloc or ::cuArrayCreate will not be evicted.
By default, any mappings to the previous location of the migrated pages are removed and
mappings for the new location are only setup on \p dstDevice. The exact behavior however
also depends on the settings applied to this memory range via ::cuMemAdvise as described
below:
If ::CU_MEM_ADVISE_SET_READ_MOSTLY was set on any subset of this memory range,
then that subset will create a read-only copy of the pages on \p dstDevice.
If ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION was called on any subset of this memory
range, then the pages will be migrated to \p dstDevice even if \p dstDevice is not the
preferred location of any pages in the memory range.
If ::CU_MEM_ADVISE_SET_ACCESSED_BY was called on any subset of this memory range,
then mappings to those pages from all the appropriate processors are updated to
refer to the new location if establishing such a mapping is possible. Otherwise,
those mappings are cleared.
Note that this API is not required for functionality and only serves to improve performance
by allowing the application to migrate data to a suitable location before it is accessed.
Memory accesses to this range are always coherent and are allowed even when the data is
actively being migrated.
Note that this function is asynchronous with respect to the host and all work
on other devices.
\param devPtr - Pointer to be prefetched
\param count - Size in bytes
\param dstDevice - Destination device to prefetch to
\param hStream - Stream to enqueue prefetch operation
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\note_async
\note_null_stream
\sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync,
::cuMemcpy3DPeerAsync, ::cuMemAdvise, ::cuMemPrefetchAsync
::cudaMemPrefetchAsync_v2*/
fn cuMemPrefetchAsync_ptsz(
devPtr: cuda_types::CUdeviceptr,
count: usize,
dstDevice: cuda_types::CUdevice,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Prefetches memory to the specified destination location
Prefetches memory to the specified destination location. \p devPtr is the
base device pointer of the memory to be prefetched and \p location specifies the
destination location. \p count specifies the number of bytes to copy. \p hStream
is the stream in which the operation is enqueued. The memory range must refer
to managed memory allocated via ::cuMemAllocManaged or declared via __managed__ variables.
Specifying ::CU_MEM_LOCATION_TYPE_DEVICE for ::CUmemLocation::type will prefetch memory to GPU
specified by device ordinal ::CUmemLocation::id which must have non-zero value for the device attribute
::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Additionally, \p hStream must be associated with a device
that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS.
Specifying ::CU_MEM_LOCATION_TYPE_HOST as ::CUmemLocation::type will prefetch data to host memory.
Applications can request prefetching memory to a specific host NUMA node by specifying
::CU_MEM_LOCATION_TYPE_HOST_NUMA for ::CUmemLocation::type and a valid host NUMA node id in ::CUmemLocation::id
Users can also request prefetching memory to the host NUMA node closest to the current thread's CPU by specifying
::CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT for ::CUmemLocation::type. Note when ::CUmemLocation::type is etiher
::CU_MEM_LOCATION_TYPE_HOST OR ::CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT, ::CUmemLocation::id will be ignored.
The start address and end address of the memory range will be rounded down and rounded up
respectively to be aligned to CPU page size before the prefetch operation is enqueued
in the stream.
If no physical memory has been allocated for this region, then this memory region
will be populated and mapped on the destination device. If there's insufficient
memory to prefetch the desired region, the Unified Memory driver may evict pages from other
::cuMemAllocManaged allocations to host memory in order to make room. Device memory
allocated using ::cuMemAlloc or ::cuArrayCreate will not be evicted.
By default, any mappings to the previous location of the migrated pages are removed and
mappings for the new location are only setup on the destination location. The exact behavior however
also depends on the settings applied to this memory range via ::cuMemAdvise as described
below:
If ::CU_MEM_ADVISE_SET_READ_MOSTLY was set on any subset of this memory range,
then that subset will create a read-only copy of the pages on destination location.
If however the destination location is a host NUMA node, then any pages of that subset
that are already in another host NUMA node will be transferred to the destination.
If ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION was called on any subset of this memory
range, then the pages will be migrated to \p location even if \p location is not the
preferred location of any pages in the memory range.
If ::CU_MEM_ADVISE_SET_ACCESSED_BY was called on any subset of this memory range,
then mappings to those pages from all the appropriate processors are updated to
refer to the new location if establishing such a mapping is possible. Otherwise,
those mappings are cleared.
Note that this API is not required for functionality and only serves to improve performance
by allowing the application to migrate data to a suitable location before it is accessed.
Memory accesses to this range are always coherent and are allowed even when the data is
actively being migrated.
Note that this function is asynchronous with respect to the host and all work
on other devices.
\param devPtr - Pointer to be prefetched
\param count - Size in bytes
\param dstDevice - Destination device to prefetch to
\param flags - flags for future use, must be zero now.
\param hStream - Stream to enqueue prefetch operation
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\note_async
\note_null_stream
\sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync,
::cuMemcpy3DPeerAsync, ::cuMemAdvise, ::cuMemPrefetchAsync
::cudaMemPrefetchAsync_v2*/
fn cuMemPrefetchAsync_v2_ptsz(
devPtr: cuda_types::CUdeviceptr,
count: usize,
location: cuda_types::CUmemLocation,
flags: ::core::ffi::c_uint,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Advise about the usage of a given memory range
Note there is a later version of this API, ::cuMemAdvise_v2. It will
supplant this version in 13.0, which is retained for minor version compatibility.
Advise the Unified Memory subsystem about the usage pattern for the memory range
starting at \p devPtr with a size of \p count bytes. The start address and end address of the memory
range will be rounded down and rounded up respectively to be aligned to CPU page size before the
advice is applied. The memory range must refer to managed memory allocated via ::cuMemAllocManaged
or declared via __managed__ variables. The memory range could also refer to system-allocated pageable
memory provided it represents a valid, host-accessible region of memory and all additional constraints
imposed by \p advice as outlined below are also satisfied. Specifying an invalid system-allocated pageable
memory range results in an error being returned.
The \p advice parameter can take the following values:
- ::CU_MEM_ADVISE_SET_READ_MOSTLY: This implies that the data is mostly going to be read
from and only occasionally written to. Any read accesses from any processor to this region will create a
read-only copy of at least the accessed pages in that processor's memory. Additionally, if ::cuMemPrefetchAsync
is called on this region, it will create a read-only copy of the data on the destination processor.
If any processor writes to this region, all copies of the corresponding page will be invalidated
except for the one where the write occurred. The \p device argument is ignored for this advice.
Note that for a page to be read-duplicated, the accessing processor must either be the CPU or a GPU
that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS.
Also, if a context is created on a device that does not have the device attribute
::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS set, then read-duplication will not occur until
all such contexts are destroyed.
If the memory region refers to valid system-allocated pageable memory, then the accessing device must
have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS for a read-only
copy to be created on that device. Note however that if the accessing device also has a non-zero value for the
device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then setting this advice
will not create a read-only copy when that device accesses this memory region.
- ::CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY and also prevents the
Unified Memory driver from attempting heuristic read-duplication on the memory range. Any read-duplicated
copies of the data will be collapsed into a single copy. The location for the collapsed
copy will be the preferred location if the page has a preferred location and one of the read-duplicated
copies was resident at that location. Otherwise, the location chosen is arbitrary.
- ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred location for the
data to be the memory belonging to \p device. Passing in CU_DEVICE_CPU for \p device sets the
preferred location as host memory. If \p device is a GPU, then it must have a non-zero value for the
device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Setting the preferred location
does not cause data to migrate to that location immediately. Instead, it guides the migration policy
when a fault occurs on that memory region. If the data is already in its preferred location and the
faulting processor can establish a mapping without requiring the data to be migrated, then
data migration will be avoided. On the other hand, if the data is not in its preferred location
or if a direct mapping cannot be established, then it will be migrated to the processor accessing
it. It is important to note that setting the preferred location does not prevent data prefetching
done using ::cuMemPrefetchAsync.
Having a preferred location can override the page thrash detection and resolution logic in the Unified
Memory driver. Normally, if a page is detected to be constantly thrashing between for example host and device
memory, the page may eventually be pinned to host memory by the Unified Memory driver. But
if the preferred location is set as device memory, then the page will continue to thrash indefinitely.
If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the
policies associated with that advice will override the policies of this advice, unless read accesses from
\p device will not result in a read-only copy being created on that device as outlined in description for
the advice ::CU_MEM_ADVISE_SET_READ_MOSTLY.
If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero
value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS.
- ::CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: Undoes the effect of ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION
and changes the preferred location to none.
- ::CU_MEM_ADVISE_SET_ACCESSED_BY: This advice implies that the data will be accessed by \p device.
Passing in ::CU_DEVICE_CPU for \p device will set the advice for the CPU. If \p device is a GPU, then
the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero.
This advice does not cause data migration and has no impact on the location of the data per se. Instead,
it causes the data to always be mapped in the specified processor's page tables, as long as the
location of the data permits a mapping to be established. If the data gets migrated for any reason,
the mappings are updated accordingly.
This advice is recommended in scenarios where data locality is not important, but avoiding faults is.
Consider for example a system containing multiple GPUs with peer-to-peer access enabled, where the
data located on one GPU is occasionally accessed by peer GPUs. In such scenarios, migrating data
over to the other GPUs is not as important because the accesses are infrequent and the overhead of
migration may be too high. But preventing faults can still help improve performance, and so having
a mapping set up in advance is useful. Note that on CPU access of this data, the data may be migrated
to host memory because the CPU typically cannot access device memory directly. Any GPU that had the
::CU_MEM_ADVISE_SET_ACCESSED_BY flag set for this data will now have its mapping updated to point to the
page in host memory.
If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the
policies associated with that advice will override the policies of this advice. Additionally, if the
preferred location of this memory region or any subset of it is also \p device, then the policies
associated with ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION will override the policies of this advice.
If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero
value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has
a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,
then this call has no effect.
- ::CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of ::CU_MEM_ADVISE_SET_ACCESSED_BY. Any mappings to
the data from \p device may be removed at any time causing accesses to result in non-fatal page faults.
If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero
value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has
a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,
then this call has no effect.
\param devPtr - Pointer to memory to set the advice for
\param count - Size in bytes of the memory range
\param advice - Advice to be applied for the specified memory range
\param device - Device to apply the advice for
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\note_async
\note_null_stream
\sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync,
::cuMemcpy3DPeerAsync, ::cuMemPrefetchAsync, ::cuMemAdvise_v2
::cudaMemAdvise*/
fn cuMemAdvise(
devPtr: cuda_types::CUdeviceptr,
count: usize,
advice: cuda_types::CUmem_advise,
device: cuda_types::CUdevice,
) -> cuda_types::CUresult;
/** \brief Advise about the usage of a given memory range
Advise the Unified Memory subsystem about the usage pattern for the memory range
starting at \p devPtr with a size of \p count bytes. The start address and end address of the memory
range will be rounded down and rounded up respectively to be aligned to CPU page size before the
advice is applied. The memory range must refer to managed memory allocated via ::cuMemAllocManaged
or declared via __managed__ variables. The memory range could also refer to system-allocated pageable
memory provided it represents a valid, host-accessible region of memory and all additional constraints
imposed by \p advice as outlined below are also satisfied. Specifying an invalid system-allocated pageable
memory range results in an error being returned.
The \p advice parameter can take the following values:
- ::CU_MEM_ADVISE_SET_READ_MOSTLY: This implies that the data is mostly going to be read
from and only occasionally written to. Any read accesses from any processor to this region will create a
read-only copy of at least the accessed pages in that processor's memory. Additionally, if ::cuMemPrefetchAsync
or ::cuMemPrefetchAsync_v2 is called on this region, it will create a read-only copy of the data on the destination processor.
If the target location for ::cuMemPrefetchAsync_v2 is a host NUMA node and a read-only copy already exists on
another host NUMA node, that copy will be migrated to the targeted host NUMA node.
If any processor writes to this region, all copies of the corresponding page will be invalidated
except for the one where the write occurred. If the writing processor is the CPU and the preferred location of
the page is a host NUMA node, then the page will also be migrated to that host NUMA node. The \p location argument is ignored for this advice.
Note that for a page to be read-duplicated, the accessing processor must either be the CPU or a GPU
that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS.
Also, if a context is created on a device that does not have the device attribute
::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS set, then read-duplication will not occur until
all such contexts are destroyed.
If the memory region refers to valid system-allocated pageable memory, then the accessing device must
have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS for a read-only
copy to be created on that device. Note however that if the accessing device also has a non-zero value for the
device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then setting this advice
will not create a read-only copy when that device accesses this memory region.
- ::CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY and also prevents the
Unified Memory driver from attempting heuristic read-duplication on the memory range. Any read-duplicated
copies of the data will be collapsed into a single copy. The location for the collapsed
copy will be the preferred location if the page has a preferred location and one of the read-duplicated
copies was resident at that location. Otherwise, the location chosen is arbitrary.
Note: The \p location argument is ignored for this advice.
- ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred location for the
data to be the memory belonging to \p location. When ::CUmemLocation::type is ::CU_MEM_LOCATION_TYPE_HOST,
::CUmemLocation::id is ignored and the preferred location is set to be host memory. To set the preferred location
to a specific host NUMA node, applications must set ::CUmemLocation::type to ::CU_MEM_LOCATION_TYPE_HOST_NUMA and
::CUmemLocation::id must specify the NUMA ID of the host NUMA node. If ::CUmemLocation::type is set to ::CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT,
::CUmemLocation::id will be ignored and the the host NUMA node closest to the calling thread's CPU will be used as the preferred location.
If ::CUmemLocation::type is a ::CU_MEM_LOCATION_TYPE_DEVICE, then ::CUmemLocation::id must be a valid device ordinal
and the device must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS.
Setting the preferred location does not cause data to migrate to that location immediately. Instead, it guides the migration policy
when a fault occurs on that memory region. If the data is already in its preferred location and the
faulting processor can establish a mapping without requiring the data to be migrated, then
data migration will be avoided. On the other hand, if the data is not in its preferred location
or if a direct mapping cannot be established, then it will be migrated to the processor accessing
it. It is important to note that setting the preferred location does not prevent data prefetching
done using ::cuMemPrefetchAsync.
Having a preferred location can override the page thrash detection and resolution logic in the Unified
Memory driver. Normally, if a page is detected to be constantly thrashing between for example host and device
memory, the page may eventually be pinned to host memory by the Unified Memory driver. But
if the preferred location is set as device memory, then the page will continue to thrash indefinitely.
If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the
policies associated with that advice will override the policies of this advice, unless read accesses from
\p location will not result in a read-only copy being created on that procesor as outlined in description for
the advice ::CU_MEM_ADVISE_SET_READ_MOSTLY.
If the memory region refers to valid system-allocated pageable memory, and ::CUmemLocation::type is CU_MEM_LOCATION_TYPE_DEVICE
then ::CUmemLocation::id must be a valid device that has a non-zero alue for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS.
- ::CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: Undoes the effect of ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION
and changes the preferred location to none. The \p location argument is ignored for this advice.
- ::CU_MEM_ADVISE_SET_ACCESSED_BY: This advice implies that the data will be accessed by processor \p location.
The ::CUmemLocation::type must be either ::CU_MEM_LOCATION_TYPE_DEVICE with ::CUmemLocation::id representing a valid device
ordinal or ::CU_MEM_LOCATION_TYPE_HOST and ::CUmemLocation::id will be ignored. All other location types are invalid.
If ::CUmemLocation::id is a GPU, then the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero.
This advice does not cause data migration and has no impact on the location of the data per se. Instead,
it causes the data to always be mapped in the specified processor's page tables, as long as the
location of the data permits a mapping to be established. If the data gets migrated for any reason,
the mappings are updated accordingly.
This advice is recommended in scenarios where data locality is not important, but avoiding faults is.
Consider for example a system containing multiple GPUs with peer-to-peer access enabled, where the
data located on one GPU is occasionally accessed by peer GPUs. In such scenarios, migrating data
over to the other GPUs is not as important because the accesses are infrequent and the overhead of
migration may be too high. But preventing faults can still help improve performance, and so having
a mapping set up in advance is useful. Note that on CPU access of this data, the data may be migrated
to host memory because the CPU typically cannot access device memory directly. Any GPU that had the
::CU_MEM_ADVISE_SET_ACCESSED_BY flag set for this data will now have its mapping updated to point to the
page in host memory.
If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the
policies associated with that advice will override the policies of this advice. Additionally, if the
preferred location of this memory region or any subset of it is also \p location, then the policies
associated with ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION will override the policies of this advice.
If the memory region refers to valid system-allocated pageable memory, and ::CUmemLocation::type is ::CU_MEM_LOCATION_TYPE_DEVICE
then device in ::CUmemLocation::id must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS.
Additionally, if ::CUmemLocation::id has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,
then this call has no effect.
- ::CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of ::CU_MEM_ADVISE_SET_ACCESSED_BY. Any mappings to
the data from \p location may be removed at any time causing accesses to result in non-fatal page faults.
If the memory region refers to valid system-allocated pageable memory, and ::CUmemLocation::type is ::CU_MEM_LOCATION_TYPE_DEVICE
then device in ::CUmemLocation::id must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS.
Additionally, if ::CUmemLocation::id has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,
then this call has no effect.
\param devPtr - Pointer to memory to set the advice for
\param count - Size in bytes of the memory range
\param advice - Advice to be applied for the specified memory range
\param location - location to apply the advice for
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\note_async
\note_null_stream
\sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync,
::cuMemcpy3DPeerAsync, ::cuMemPrefetchAsync, ::cuMemAdvise
::cudaMemAdvise*/
fn cuMemAdvise_v2(
devPtr: cuda_types::CUdeviceptr,
count: usize,
advice: cuda_types::CUmem_advise,
location: cuda_types::CUmemLocation,
) -> cuda_types::CUresult;
/** \brief Query an attribute of a given memory range
Query an attribute about the memory range starting at \p devPtr with a size of \p count bytes. The
memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via
__managed__ variables.
The \p attribute parameter can take the following values:
- ::CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: If this attribute is specified, \p data will be interpreted
as a 32-bit integer, and \p dataSize must be 4. The result returned will be 1 if all pages in the given
memory range have read-duplication enabled, or 0 otherwise.
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: If this attribute is specified, \p data will be
interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be a GPU device
id if all pages in the memory range have that GPU as their preferred location, or it will be CU_DEVICE_CPU
if all pages in the memory range have the CPU as their preferred location, or it will be CU_DEVICE_INVALID
if either all the pages don't have the same preferred location or some of the pages don't have a
preferred location at all. Note that the actual location of the pages in the memory range at the time of
the query may be different from the preferred location.
- ::CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: If this attribute is specified, \p data will be interpreted
as an array of 32-bit integers, and \p dataSize must be a non-zero multiple of 4. The result returned
will be a list of device ids that had ::CU_MEM_ADVISE_SET_ACCESSED_BY set for that entire memory range.
If any device does not have that advice set for the entire memory range, that device will not be included.
If \p data is larger than the number of devices that have that advice set for that memory range,
CU_DEVICE_INVALID will be returned in all the extra space provided. For ex., if \p dataSize is 12
(i.e. \p data has 3 elements) and only device 0 has the advice set, then the result returned will be
{ 0, CU_DEVICE_INVALID, CU_DEVICE_INVALID }. If \p data is smaller than the number of devices that have
that advice set, then only as many devices will be returned as can fit in the array. There is no
guarantee on which specific devices will be returned, however.
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: If this attribute is specified, \p data will be
interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be the last location
to which all pages in the memory range were prefetched explicitly via ::cuMemPrefetchAsync. This will either be
a GPU id or CU_DEVICE_CPU depending on whether the last location for prefetch was a GPU or the CPU
respectively. If any page in the memory range was never explicitly prefetched or if all pages were not
prefetched to the same location, CU_DEVICE_INVALID will be returned. Note that this simply returns the
last location that the application requested to prefetch the memory range to. It gives no indication as to
whether the prefetch operation to that location has completed or even begun.
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_TYPE: If this attribute is specified, \p data will be
interpreted as a ::CUmemLocationType, and \p dataSize must be sizeof(CUmemLocationType). The ::CUmemLocationType returned will be
::CU_MEM_LOCATION_TYPE_DEVICE if all pages in the memory range have the same GPU as their preferred location, or ::CUmemLocationType
will be ::CU_MEM_LOCATION_TYPE_HOST if all pages in the memory range have the CPU as their preferred location, or it will be ::CU_MEM_LOCATION_TYPE_HOST_NUMA
if all the pages in the memory range have the same host NUMA node ID as their preferred location or it will be ::CU_MEM_LOCATION_TYPE_INVALID
if either all the pages don't have the same preferred location or some of the pages don't have a preferred location at all.
Note that the actual location type of the pages in the memory range at the time of the query may be different from the preferred location type.
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_ID: If this attribute is specified, \p data will be
interpreted as a 32-bit integer, and \p dataSize must be 4. If the ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_TYPE query for the same address range
returns ::CU_MEM_LOCATION_TYPE_DEVICE, it will be a valid device ordinal or if it returns ::CU_MEM_LOCATION_TYPE_HOST_NUMA, it will be a valid host NUMA node ID
or if it returns any other location type, the id should be ignored.
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_TYPE: If this attribute is specified, \p data will be
interpreted as a ::CUmemLocationType, and \p dataSize must be sizeof(CUmemLocationType). The result returned will be the last location
to which all pages in the memory range were prefetched explicitly via ::cuMemPrefetchAsync. The ::CUmemLocationType returned
will be ::CU_MEM_LOCATION_TYPE_DEVICE if the last prefetch location was a GPU or ::CU_MEM_LOCATION_TYPE_HOST if it was the CPU or ::CU_MEM_LOCATION_TYPE_HOST_NUMA if
the last prefetch location was a specific host NUMA node. If any page in the memory range was never explicitly prefetched or if all pages were not
prefetched to the same location, ::CUmemLocationType will be ::CU_MEM_LOCATION_TYPE_INVALID.
Note that this simply returns the last location type that the application requested to prefetch the memory range to. It gives no indication as to
whether the prefetch operation to that location has completed or even begun.
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_ID: If this attribute is specified, \p data will be
interpreted as a 32-bit integer, and \p dataSize must be 4. If the ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_TYPE query for the same address range
returns ::CU_MEM_LOCATION_TYPE_DEVICE, it will be a valid device ordinal or if it returns ::CU_MEM_LOCATION_TYPE_HOST_NUMA, it will be a valid host NUMA node ID
or if it returns any other location type, the id should be ignored.
\param data - A pointers to a memory location where the result
of each attribute query will be written to.
\param dataSize - Array containing the size of data
\param attribute - The attribute to query
\param devPtr - Start of the range to query
\param count - Size of the range to query
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\note_async
\note_null_stream
\sa ::cuMemRangeGetAttributes, ::cuMemPrefetchAsync,
::cuMemAdvise,
::cudaMemRangeGetAttribute*/
fn cuMemRangeGetAttribute(
data: *mut ::core::ffi::c_void,
dataSize: usize,
attribute: cuda_types::CUmem_range_attribute,
devPtr: cuda_types::CUdeviceptr,
count: usize,
) -> cuda_types::CUresult;
/** \brief Query attributes of a given memory range.
Query attributes of the memory range starting at \p devPtr with a size of \p count bytes. The
memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via
__managed__ variables. The \p attributes array will be interpreted to have \p numAttributes
entries. The \p dataSizes array will also be interpreted to have \p numAttributes entries.
The results of the query will be stored in \p data.
The list of supported attributes are given below. Please refer to ::cuMemRangeGetAttribute for
attribute descriptions and restrictions.
- ::CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION
- ::CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_TYPE
- ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_ID
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_TYPE
- ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_ID
\param data - A two-dimensional array containing pointers to memory
locations where the result of each attribute query will be written to.
\param dataSizes - Array containing the sizes of each result
\param attributes - An array of attributes to query
(numAttributes and the number of attributes in this array should match)
\param numAttributes - Number of attributes to query
\param devPtr - Start of the range to query
\param count - Size of the range to query
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\sa ::cuMemRangeGetAttribute, ::cuMemAdvise,
::cuMemPrefetchAsync,
::cudaMemRangeGetAttributes*/
fn cuMemRangeGetAttributes(
data: *mut *mut ::core::ffi::c_void,
dataSizes: *mut usize,
attributes: *mut cuda_types::CUmem_range_attribute,
numAttributes: usize,
devPtr: cuda_types::CUdeviceptr,
count: usize,
) -> cuda_types::CUresult;
/** \brief Set attributes on a previously allocated memory region
The supported attributes are:
- ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS:
A boolean attribute that can either be set (1) or unset (0). When set,
the region of memory that \p ptr points to is guaranteed to always synchronize
memory operations that are synchronous. If there are some previously initiated
synchronous memory operations that are pending when this attribute is set, the
function does not return until those memory operations are complete.
See further documentation in the section titled "API synchronization behavior"
to learn more about cases when synchronous memory operations can
exhibit asynchronous behavior.
\p value will be considered as a pointer to an unsigned integer to which this attribute is to be set.
\param value - Pointer to memory containing the value to be set
\param attribute - Pointer attribute to set
\param ptr - Pointer to a memory region allocated using CUDA memory allocation APIs
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\sa ::cuPointerGetAttribute,
::cuPointerGetAttributes,
::cuMemAlloc,
::cuMemFree,
::cuMemAllocHost,
::cuMemFreeHost,
::cuMemHostAlloc,
::cuMemHostRegister,
::cuMemHostUnregister*/
fn cuPointerSetAttribute(
value: *const ::core::ffi::c_void,
attribute: cuda_types::CUpointer_attribute,
ptr: cuda_types::CUdeviceptr,
) -> cuda_types::CUresult;
/** \brief Returns information about a pointer.
The supported attributes are (refer to ::cuPointerGetAttribute for attribute descriptions and restrictions):
- ::CU_POINTER_ATTRIBUTE_CONTEXT
- ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE
- ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER
- ::CU_POINTER_ATTRIBUTE_HOST_POINTER
- ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS
- ::CU_POINTER_ATTRIBUTE_BUFFER_ID
- ::CU_POINTER_ATTRIBUTE_IS_MANAGED
- ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
- ::CU_POINTER_ATTRIBUTE_RANGE_START_ADDR
- ::CU_POINTER_ATTRIBUTE_RANGE_SIZE
- ::CU_POINTER_ATTRIBUTE_MAPPED
- ::CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE
- ::CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES
- ::CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE
\param numAttributes - Number of attributes to query
\param attributes - An array of attributes to query
(numAttributes and the number of attributes in this array should match)
\param data - A two-dimensional array containing pointers to memory
locations where the result of each attribute query will be written to.
\param ptr - Pointer to query
Unlike ::cuPointerGetAttribute, this function will not return an error when the \p ptr
encountered is not a valid CUDA pointer. Instead, the attributes are assigned default NULL values
and CUDA_SUCCESS is returned.
If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses UVA
(Unified Virtual Addressing), ::CUDA_ERROR_INVALID_CONTEXT is returned.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\sa
::cuPointerGetAttribute,
::cuPointerSetAttribute,
::cudaPointerGetAttributes*/
fn cuPointerGetAttributes(
numAttributes: ::core::ffi::c_uint,
attributes: *mut cuda_types::CUpointer_attribute,
data: *mut *mut ::core::ffi::c_void,
ptr: cuda_types::CUdeviceptr,
) -> cuda_types::CUresult;
/** \brief Create a stream
Creates a stream and returns a handle in \p phStream. The \p Flags argument
determines behaviors of the stream.
Valid values for \p Flags are:
- ::CU_STREAM_DEFAULT: Default stream creation flag.
- ::CU_STREAM_NON_BLOCKING: Specifies that work running in the created
stream may run concurrently with work in stream 0 (the NULL stream), and that
the created stream should perform no implicit synchronization with stream 0.
\param phStream - Returned newly created stream
\param Flags - Parameters for stream creation
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY
\notefnerr
\sa ::cuStreamDestroy,
::cuStreamCreateWithPriority,
::cuStreamGetPriority,
::cuStreamGetFlags,
::cuStreamWaitEvent,
::cuStreamQuery,
::cuStreamSynchronize,
::cuStreamAddCallback,
::cudaStreamCreate,
::cudaStreamCreateWithFlags*/
fn cuStreamCreate(
phStream: *mut cuda_types::CUstream,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Create a stream with the given priority
Creates a stream with the specified priority and returns a handle in \p phStream.
This affects the scheduling priority of work in the stream. Priorities provide a
hint to preferentially run work with higher priority when possible, but do
not preempt already-running work or provide any other functional guarantee on
execution order.
\p priority follows a convention where lower numbers represent higher priorities.
'0' represents default priority. The range of meaningful numerical priorities can
be queried using ::cuCtxGetStreamPriorityRange. If the specified priority is
outside the numerical range returned by ::cuCtxGetStreamPriorityRange,
it will automatically be clamped to the lowest or the highest number in the range.
\param phStream - Returned newly created stream
\param flags - Flags for stream creation. See ::cuStreamCreate for a list of
valid flags
\param priority - Stream priority. Lower numbers represent higher priorities.
See ::cuCtxGetStreamPriorityRange for more information about
meaningful stream priorities that can be passed.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_OUT_OF_MEMORY
\notefnerr
\note Stream priorities are supported only on GPUs
with compute capability 3.5 or higher.
\note In the current implementation, only compute kernels launched in
priority streams are affected by the stream's priority. Stream priorities have
no effect on host-to-device and device-to-host memory operations.
\sa ::cuStreamDestroy,
::cuStreamCreate,
::cuStreamGetPriority,
::cuCtxGetStreamPriorityRange,
::cuStreamGetFlags,
::cuStreamWaitEvent,
::cuStreamQuery,
::cuStreamSynchronize,
::cuStreamAddCallback,
::cudaStreamCreateWithPriority*/
fn cuStreamCreateWithPriority(
phStream: *mut cuda_types::CUstream,
flags: ::core::ffi::c_uint,
priority: ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Query the priority of a given stream
Query the priority of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority
and return the priority in \p priority. Note that if the stream was created with a
priority outside the numerical range returned by ::cuCtxGetStreamPriorityRange,
this function returns the clamped priority.
See ::cuStreamCreateWithPriority for details about priority clamping.
\param hStream - Handle to the stream to be queried
\param priority - Pointer to a signed integer in which the stream's priority is returned
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_OUT_OF_MEMORY
\notefnerr
\sa ::cuStreamDestroy,
::cuStreamCreate,
::cuStreamCreateWithPriority,
::cuCtxGetStreamPriorityRange,
::cuStreamGetFlags,
::cudaStreamGetPriority*/
fn cuStreamGetPriority_ptsz(
hStream: cuda_types::CUstream,
priority: *mut ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Query the flags of a given stream
Query the flags of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority
and return the flags in \p flags.
\param hStream - Handle to the stream to be queried
\param flags - Pointer to an unsigned integer in which the stream's flags are returned
The value returned in \p flags is a logical 'OR' of all flags that
were used while creating this stream. See ::cuStreamCreate for the list
of valid flags
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_OUT_OF_MEMORY
\notefnerr
\sa ::cuStreamDestroy,
::cuStreamCreate,
::cuStreamGetPriority,
::cudaStreamGetFlags*/
fn cuStreamGetFlags_ptsz(
hStream: cuda_types::CUstream,
flags: *mut ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Returns the unique Id associated with the stream handle supplied
Returns in \p streamId the unique Id which is associated with the given stream handle.
The Id is unique for the life of the program.
The stream handle \p hStream can refer to any of the following:
| Node type | Allowed changes
|
|---|
| kernel | See ::cuGraphExecKernelNodeSetParams
|
| memcpy | Addresses for 1-dimensional copies if allocated in same context; see ::cuGraphExecMemcpyNodeSetParams
|
| memset | Addresses for 1-dimensional memsets if allocated in same context; see ::cuGraphExecMemsetNodeSetParams
|
| host | Unrestricted
|
| child graph | Topology must match and restrictions apply recursively; see ::cuGraphExecUpdate
|
| event wait | Unrestricted
|
| event record | Unrestricted
|
| external semaphore signal | Number of semaphore operations cannot change
|
| external semaphore wait | Number of semaphore operations cannot change
|
| memory allocation | API unsupported
|
| memory free | API unsupported
|
| batch memops | Addresses, values, and operation type for wait operations; see ::cuGraphExecBatchMemOpNodeSetParams
|
\param hGraphExec - The executable graph in which to update the specified node
\param hNode - Corresponding node from the graph from which graphExec was instantiated
\param nodeParams - Updated Parameters to set
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_SUPPORTED
\note_graph_thread_safety
\notefnerr
\sa
::cuGraphAddNode,
::cuGraphNodeSetParams
::cuGraphExecUpdate,
::cuGraphInstantiate*/
fn cuGraphExecNodeSetParams(
hGraphExec: cuda_types::CUgraphExec,
hNode: cuda_types::CUgraphNode,
nodeParams: *mut cuda_types::CUgraphNodeParams,
) -> cuda_types::CUresult;
/** \brief Create a conditional handle
Creates a conditional handle associated with \p hGraph.
The conditional handle must be associated with a conditional node in this graph or one of its children.
Handles not associated with a conditional node may cause graph instantiation to fail.
Handles can only be set from the context with which they are associated.
\param pHandle_out - Pointer used to return the handle to the caller.
\param hGraph - Graph which will contain the conditional node using this handle.
\param ctx - Context for the handle and associated conditional node.
\param defaultLaunchValue - Optional initial value for the conditional variable.
\param flags - Currently must be CU_GRAPH_COND_ASSIGN_DEFAULT or 0.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_SUPPORTED
\note_graph_thread_safety
\notefnerr
\sa
::cuGraphAddNode*/
fn cuGraphConditionalHandleCreate(
pHandle_out: *mut cuda_types::CUgraphConditionalHandle,
hGraph: cuda_types::CUgraph,
ctx: cuda_types::CUcontext,
defaultLaunchValue: ::core::ffi::c_uint,
flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Returns occupancy of a function
Returns in \p *numBlocks the number of the maximum active blocks per
streaming multiprocessor.
\param numBlocks - Returned occupancy
\param func - Kernel for which occupancy is calculated
\param blockSize - Block size the kernel is intended to be launched with
\param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaOccupancyMaxActiveBlocksPerMultiprocessor*/
fn cuOccupancyMaxActiveBlocksPerMultiprocessor(
numBlocks: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
blockSize: ::core::ffi::c_int,
dynamicSMemSize: usize,
) -> cuda_types::CUresult;
/** \brief Returns occupancy of a function
Returns in \p *numBlocks the number of the maximum active blocks per
streaming multiprocessor.
The \p Flags parameter controls how special cases are handled. The
valid flags are:
- ::CU_OCCUPANCY_DEFAULT, which maintains the default behavior as
::cuOccupancyMaxActiveBlocksPerMultiprocessor;
- ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE, which suppresses the
default behavior on platform where global caching affects
occupancy. On such platforms, if caching is enabled, but
per-block SM resource usage would result in zero occupancy, the
occupancy calculator will calculate the occupancy as if caching
is disabled. Setting ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE makes
the occupancy calculator to return 0 in such cases. More information
can be found about this feature in the "Unified L1/Texture Cache"
section of the Maxwell tuning guide.
\param numBlocks - Returned occupancy
\param func - Kernel for which occupancy is calculated
\param blockSize - Block size the kernel is intended to be launched with
\param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes
\param flags - Requested behavior for the occupancy calculator
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags*/
fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(
numBlocks: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
blockSize: ::core::ffi::c_int,
dynamicSMemSize: usize,
flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Suggest a launch configuration with reasonable occupancy
Returns in \p *blockSize a reasonable block size that can achieve
the maximum occupancy (or, the maximum number of active warps with
the fewest blocks per multiprocessor), and in \p *minGridSize the
minimum grid size to achieve the maximum occupancy.
If \p blockSizeLimit is 0, the configurator will use the maximum
block size permitted by the device / function instead.
If per-block dynamic shared memory allocation is not needed, the
user should leave both \p blockSizeToDynamicSMemSize and \p
dynamicSMemSize as 0.
If per-block dynamic shared memory allocation is needed, then if
the dynamic shared memory size is constant regardless of block
size, the size should be passed through \p dynamicSMemSize, and \p
blockSizeToDynamicSMemSize should be NULL.
Otherwise, if the per-block dynamic shared memory size varies with
different block sizes, the user needs to provide a unary function
through \p blockSizeToDynamicSMemSize that computes the dynamic
shared memory needed by \p func for any given block size. \p
dynamicSMemSize is ignored. An example signature is:
\code
// Take block size, returns dynamic shared memory needed
size_t blockToSmem(int blockSize);
\endcode
\param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy
\param blockSize - Returned maximum block size that can achieve the maximum occupancy
\param func - Kernel for which launch configuration is calculated
\param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size
\param dynamicSMemSize - Dynamic shared memory usage intended, in bytes
\param blockSizeLimit - The maximum block size \p func is designed to handle
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaOccupancyMaxPotentialBlockSize*/
fn cuOccupancyMaxPotentialBlockSize(
minGridSize: *mut ::core::ffi::c_int,
blockSize: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
blockSizeToDynamicSMemSize: cuda_types::CUoccupancyB2DSize,
dynamicSMemSize: usize,
blockSizeLimit: ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Suggest a launch configuration with reasonable occupancy
An extended version of ::cuOccupancyMaxPotentialBlockSize. In
addition to arguments passed to ::cuOccupancyMaxPotentialBlockSize,
::cuOccupancyMaxPotentialBlockSizeWithFlags also takes a \p Flags
parameter.
The \p Flags parameter controls how special cases are handled. The
valid flags are:
- ::CU_OCCUPANCY_DEFAULT, which maintains the default behavior as
::cuOccupancyMaxPotentialBlockSize;
- ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE, which suppresses the
default behavior on platform where global caching affects
occupancy. On such platforms, the launch configurations that
produces maximal occupancy might not support global
caching. Setting ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE
guarantees that the the produced launch configuration is global
caching compatible at a potential cost of occupancy. More information
can be found about this feature in the "Unified L1/Texture Cache"
section of the Maxwell tuning guide.
\param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy
\param blockSize - Returned maximum block size that can achieve the maximum occupancy
\param func - Kernel for which launch configuration is calculated
\param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size
\param dynamicSMemSize - Dynamic shared memory usage intended, in bytes
\param blockSizeLimit - The maximum block size \p func is designed to handle
\param flags - Options
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaOccupancyMaxPotentialBlockSizeWithFlags*/
fn cuOccupancyMaxPotentialBlockSizeWithFlags(
minGridSize: *mut ::core::ffi::c_int,
blockSize: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
blockSizeToDynamicSMemSize: cuda_types::CUoccupancyB2DSize,
dynamicSMemSize: usize,
blockSizeLimit: ::core::ffi::c_int,
flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Returns dynamic shared memory available per block when launching \p numBlocks blocks on SM
Returns in \p *dynamicSmemSize the maximum size of dynamic shared memory to allow \p numBlocks blocks per SM.
\param dynamicSmemSize - Returned maximum dynamic shared memory
\param func - Kernel function for which occupancy is calculated
\param numBlocks - Number of blocks to fit on SM
\param blockSize - Size of the blocks
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr*/
fn cuOccupancyAvailableDynamicSMemPerBlock(
dynamicSmemSize: *mut usize,
func: cuda_types::CUfunction,
numBlocks: ::core::ffi::c_int,
blockSize: ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Given the kernel function (\p func) and launch configuration
(\p config), return the maximum cluster size in \p *clusterSize.
The cluster dimensions in \p config are ignored. If func has a required
cluster size set (see ::cudaFuncGetAttributes / ::cuFuncGetAttribute),\p
*clusterSize will reflect the required cluster size.
By default this function will always return a value that's portable on
future hardware. A higher value may be returned if the kernel function
allows non-portable cluster sizes.
This function will respect the compile time launch bounds.
\param clusterSize - Returned maximum cluster size that can be launched
for the given kernel function and launch configuration
\param func - Kernel function for which maximum cluster
size is calculated
\param config - Launch configuration for the given kernel function
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaFuncGetAttributes,
::cuFuncGetAttribute*/
fn cuOccupancyMaxPotentialClusterSize(
clusterSize: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
config: *const cuda_types::CUlaunchConfig,
) -> cuda_types::CUresult;
/** \brief Given the kernel function (\p func) and launch configuration
(\p config), return the maximum number of clusters that could co-exist
on the target device in \p *numClusters.
If the function has required cluster size already set (see
::cudaFuncGetAttributes / ::cuFuncGetAttribute), the cluster size
from config must either be unspecified or match the required size.
Without required sizes, the cluster size must be specified in config,
else the function will return an error.
Note that various attributes of the kernel function may affect occupancy
calculation. Runtime environment may affect how the hardware schedules
the clusters, so the calculated occupancy is not guaranteed to be achievable.
\param numClusters - Returned maximum number of clusters that
could co-exist on the target device
\param func - Kernel function for which maximum number
of clusters are calculated
\param config - Launch configuration for the given kernel function
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_CLUSTER_SIZE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cudaFuncGetAttributes,
::cuFuncGetAttribute*/
fn cuOccupancyMaxActiveClusters(
numClusters: *mut ::core::ffi::c_int,
func: cuda_types::CUfunction,
config: *const cuda_types::CUlaunchConfig,
) -> cuda_types::CUresult;
/** \brief Binds an array as a texture reference
\deprecated
Binds the CUDA array \p hArray to the texture reference \p hTexRef. Any
previous address or CUDA array state associated with the texture reference
is superseded by this function. \p Flags must be set to
::CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to \p hTexRef is
unbound.
\param hTexRef - Texture reference to bind
\param hArray - Array to bind
\param Flags - Options (must be ::CU_TRSA_OVERRIDE_FORMAT)
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetArray(
hTexRef: cuda_types::CUtexref,
hArray: cuda_types::CUarray,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Binds a mipmapped array to a texture reference
\deprecated
Binds the CUDA mipmapped array \p hMipmappedArray to the texture reference \p hTexRef.
Any previous address or CUDA array state associated with the texture reference
is superseded by this function. \p Flags must be set to ::CU_TRSA_OVERRIDE_FORMAT.
Any CUDA array previously bound to \p hTexRef is unbound.
\param hTexRef - Texture reference to bind
\param hMipmappedArray - Mipmapped array to bind
\param Flags - Options (must be ::CU_TRSA_OVERRIDE_FORMAT)
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetMipmappedArray(
hTexRef: cuda_types::CUtexref,
hMipmappedArray: cuda_types::CUmipmappedArray,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Binds an address as a texture reference
\deprecated
Binds a linear address range to the texture reference \p hTexRef. Any
previous address or CUDA array state associated with the texture reference
is superseded by this function. Any memory previously bound to \p hTexRef
is unbound.
Since the hardware enforces an alignment requirement on texture base
addresses, ::cuTexRefSetAddress() passes back a byte offset in
\p *ByteOffset that must be applied to texture fetches in order to read from
the desired memory. This offset must be divided by the texel size and
passed to kernels that read from the texture so they can be applied to the
::tex1Dfetch() function.
If the device memory pointer was returned from ::cuMemAlloc(), the offset
is guaranteed to be 0 and NULL may be passed as the \p ByteOffset parameter.
The total number of elements (or texels) in the linear address range
cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH.
The number of elements is computed as (\p bytes / bytesPerElement),
where bytesPerElement is determined from the data format and number of
components set using ::cuTexRefSetFormat().
\param ByteOffset - Returned byte offset
\param hTexRef - Texture reference to bind
\param dptr - Device pointer to bind
\param bytes - Size of memory to bind in bytes
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetAddress_v2(
ByteOffset: *mut usize,
hTexRef: cuda_types::CUtexref,
dptr: cuda_types::CUdeviceptr,
bytes: usize,
) -> cuda_types::CUresult;
/** \brief Binds an address as a 2D texture reference
\deprecated
Binds a linear address range to the texture reference \p hTexRef. Any
previous address or CUDA array state associated with the texture reference
is superseded by this function. Any memory previously bound to \p hTexRef
is unbound.
Using a ::tex2D() function inside a kernel requires a call to either
::cuTexRefSetArray() to bind the corresponding texture reference to an
array, or ::cuTexRefSetAddress2D() to bind the texture reference to linear
memory.
Function calls to ::cuTexRefSetFormat() cannot follow calls to
::cuTexRefSetAddress2D() for the same texture reference.
It is required that \p dptr be aligned to the appropriate hardware-specific
texture alignment. You can query this value using the device attribute
::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. If an unaligned \p dptr is
supplied, ::CUDA_ERROR_INVALID_VALUE is returned.
\p Pitch has to be aligned to the hardware-specific texture pitch alignment.
This value can be queried using the device attribute
::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. If an unaligned \p Pitch is
supplied, ::CUDA_ERROR_INVALID_VALUE is returned.
Width and Height, which are specified in elements (or texels), cannot exceed
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively.
\p Pitch, which is specified in bytes, cannot exceed
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH.
\param hTexRef - Texture reference to bind
\param desc - Descriptor of CUDA array
\param dptr - Device pointer to bind
\param Pitch - Line pitch in bytes
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetAddress2D_v3(
hTexRef: cuda_types::CUtexref,
desc: *const cuda_types::CUDA_ARRAY_DESCRIPTOR,
dptr: cuda_types::CUdeviceptr,
Pitch: usize,
) -> cuda_types::CUresult;
/** \brief Sets the format for a texture reference
\deprecated
Specifies the format of the data to be read by the texture reference
\p hTexRef. \p fmt and \p NumPackedComponents are exactly analogous to the
::Format and ::NumChannels members of the ::CUDA_ARRAY_DESCRIPTOR structure:
They specify the format of each component and the number of components per
array element.
\param hTexRef - Texture reference
\param fmt - Format to set
\param NumPackedComponents - Number of components per array element
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat,
::cudaCreateChannelDesc*/
fn cuTexRefSetFormat(
hTexRef: cuda_types::CUtexref,
fmt: cuda_types::CUarray_format,
NumPackedComponents: ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Sets the addressing mode for a texture reference
\deprecated
Specifies the addressing mode \p am for the given dimension \p dim of the
texture reference \p hTexRef. If \p dim is zero, the addressing mode is
applied to the first parameter of the functions used to fetch from the
texture; if \p dim is 1, the second, and so on. ::CUaddress_mode is defined
as:
\code
typedef enum CUaddress_mode_enum {
CU_TR_ADDRESS_MODE_WRAP = 0,
CU_TR_ADDRESS_MODE_CLAMP = 1,
CU_TR_ADDRESS_MODE_MIRROR = 2,
CU_TR_ADDRESS_MODE_BORDER = 3
} CUaddress_mode;
\endcode
Note that this call has no effect if \p hTexRef is bound to linear memory.
Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES, is not set, the only
supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP.
\param hTexRef - Texture reference
\param dim - Dimension
\param am - Addressing mode to set
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetAddressMode(
hTexRef: cuda_types::CUtexref,
dim: ::core::ffi::c_int,
am: cuda_types::CUaddress_mode,
) -> cuda_types::CUresult;
/** \brief Sets the filtering mode for a texture reference
\deprecated
Specifies the filtering mode \p fm to be used when reading memory through
the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as:
\code
typedef enum CUfilter_mode_enum {
CU_TR_FILTER_MODE_POINT = 0,
CU_TR_FILTER_MODE_LINEAR = 1
} CUfilter_mode;
\endcode
Note that this call has no effect if \p hTexRef is bound to linear memory.
\param hTexRef - Texture reference
\param fm - Filtering mode to set
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetFilterMode(
hTexRef: cuda_types::CUtexref,
fm: cuda_types::CUfilter_mode,
) -> cuda_types::CUresult;
/** \brief Sets the mipmap filtering mode for a texture reference
\deprecated
Specifies the mipmap filtering mode \p fm to be used when reading memory through
the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as:
\code
typedef enum CUfilter_mode_enum {
CU_TR_FILTER_MODE_POINT = 0,
CU_TR_FILTER_MODE_LINEAR = 1
} CUfilter_mode;
\endcode
Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.
\param hTexRef - Texture reference
\param fm - Filtering mode to set
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetMipmapFilterMode(
hTexRef: cuda_types::CUtexref,
fm: cuda_types::CUfilter_mode,
) -> cuda_types::CUresult;
/** \brief Sets the mipmap level bias for a texture reference
\deprecated
Specifies the mipmap level bias \p bias to be added to the specified mipmap level when
reading memory through the texture reference \p hTexRef.
Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.
\param hTexRef - Texture reference
\param bias - Mipmap level bias
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetMipmapLevelBias(
hTexRef: cuda_types::CUtexref,
bias: f32,
) -> cuda_types::CUresult;
/** \brief Sets the mipmap min/max mipmap level clamps for a texture reference
\deprecated
Specifies the min/max mipmap level clamps, \p minMipmapLevelClamp and \p maxMipmapLevelClamp
respectively, to be used when reading memory through the texture reference
\p hTexRef.
Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.
\param hTexRef - Texture reference
\param minMipmapLevelClamp - Mipmap min level clamp
\param maxMipmapLevelClamp - Mipmap max level clamp
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetMipmapLevelClamp(
hTexRef: cuda_types::CUtexref,
minMipmapLevelClamp: f32,
maxMipmapLevelClamp: f32,
) -> cuda_types::CUresult;
/** \brief Sets the maximum anisotropy for a texture reference
\deprecated
Specifies the maximum anisotropy \p maxAniso to be used when reading memory through
the texture reference \p hTexRef.
Note that this call has no effect if \p hTexRef is bound to linear memory.
\param hTexRef - Texture reference
\param maxAniso - Maximum anisotropy
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetMaxAnisotropy(
hTexRef: cuda_types::CUtexref,
maxAniso: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Sets the border color for a texture reference
\deprecated
Specifies the value of the RGBA color via the \p pBorderColor to the texture reference
\p hTexRef. The color value supports only float type and holds color components in
the following sequence:
pBorderColor[0] holds 'R' component
pBorderColor[1] holds 'G' component
pBorderColor[2] holds 'B' component
pBorderColor[3] holds 'A' component
Note that the color values can be set only when the Address mode is set to
CU_TR_ADDRESS_MODE_BORDER using ::cuTexRefSetAddressMode.
Applications using integer border color values have to "reinterpret_cast" their values to float.
\param hTexRef - Texture reference
\param pBorderColor - RGBA color
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddressMode,
::cuTexRefGetAddressMode, ::cuTexRefGetBorderColor*/
fn cuTexRefSetBorderColor(
hTexRef: cuda_types::CUtexref,
pBorderColor: *mut f32,
) -> cuda_types::CUresult;
/** \brief Sets the flags for a texture reference
\deprecated
Specifies optional flags via \p Flags to specify the behavior of data
returned through the texture reference \p hTexRef. The valid flags are:
- ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of
having the texture promote integer data to floating point data in the
range [0, 1]. Note that texture with 32-bit integer format
would not be promoted, regardless of whether or not this
flag is specified;
- ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the
default behavior of having the texture coordinates range
from [0, Dim) where Dim is the width or height of the CUDA
array. Instead, the texture coordinates [0, 1.0) reference
the entire breadth of the array dimension;
- ::CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION, which disables any trilinear
filtering optimizations. Trilinear optimizations improve texture filtering
performance by allowing bilinear filtering on textures in scenarios where
it can closely approximate the expected results.
\param hTexRef - Texture reference
\param Flags - Optional flags to set
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefSetFlags(
hTexRef: cuda_types::CUtexref,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Gets the address associated with a texture reference
\deprecated
Returns in \p *pdptr the base address bound to the texture reference
\p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference
is not bound to any device memory range.
\param pdptr - Returned device address
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetAddress_v2(
pdptr: *mut cuda_types::CUdeviceptr,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the array bound to a texture reference
\deprecated
Returns in \p *phArray the CUDA array bound to the texture reference
\p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference
is not bound to any CUDA array.
\param phArray - Returned array
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetArray(
phArray: *mut cuda_types::CUarray,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the mipmapped array bound to a texture reference
\deprecated
Returns in \p *phMipmappedArray the CUDA mipmapped array bound to the texture
reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference
is not bound to any CUDA mipmapped array.
\param phMipmappedArray - Returned mipmapped array
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetMipmappedArray(
phMipmappedArray: *mut cuda_types::CUmipmappedArray,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the addressing mode used by a texture reference
\deprecated
Returns in \p *pam the addressing mode corresponding to the
dimension \p dim of the texture reference \p hTexRef. Currently, the only
valid value for \p dim are 0 and 1.
\param pam - Returned addressing mode
\param hTexRef - Texture reference
\param dim - Dimension
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetAddressMode(
pam: *mut cuda_types::CUaddress_mode,
hTexRef: cuda_types::CUtexref,
dim: ::core::ffi::c_int,
) -> cuda_types::CUresult;
/** \brief Gets the filter-mode used by a texture reference
\deprecated
Returns in \p *pfm the filtering mode of the texture reference
\p hTexRef.
\param pfm - Returned filtering mode
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetFilterMode(
pfm: *mut cuda_types::CUfilter_mode,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the format used by a texture reference
\deprecated
Returns in \p *pFormat and \p *pNumChannels the format and number
of components of the CUDA array bound to the texture reference \p hTexRef.
If \p pFormat or \p pNumChannels is NULL, it will be ignored.
\param pFormat - Returned format
\param pNumChannels - Returned number of components
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags*/
fn cuTexRefGetFormat(
pFormat: *mut cuda_types::CUarray_format,
pNumChannels: *mut ::core::ffi::c_int,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the mipmap filtering mode for a texture reference
\deprecated
Returns the mipmap filtering mode in \p pfm that's used when reading memory through
the texture reference \p hTexRef.
\param pfm - Returned mipmap filtering mode
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetMipmapFilterMode(
pfm: *mut cuda_types::CUfilter_mode,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the mipmap level bias for a texture reference
\deprecated
Returns the mipmap level bias in \p pBias that's added to the specified mipmap
level when reading memory through the texture reference \p hTexRef.
\param pbias - Returned mipmap level bias
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetMipmapLevelBias(
pbias: *mut f32,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the min/max mipmap level clamps for a texture reference
\deprecated
Returns the min/max mipmap level clamps in \p pminMipmapLevelClamp and \p pmaxMipmapLevelClamp
that's used when reading memory through the texture reference \p hTexRef.
\param pminMipmapLevelClamp - Returned mipmap min level clamp
\param pmaxMipmapLevelClamp - Returned mipmap max level clamp
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetMipmapLevelClamp(
pminMipmapLevelClamp: *mut f32,
pmaxMipmapLevelClamp: *mut f32,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the maximum anisotropy for a texture reference
\deprecated
Returns the maximum anisotropy in \p pmaxAniso that's used when reading memory through
the texture reference \p hTexRef.
\param pmaxAniso - Returned maximum anisotropy
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat*/
fn cuTexRefGetMaxAnisotropy(
pmaxAniso: *mut ::core::ffi::c_int,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the border color used by a texture reference
\deprecated
Returns in \p pBorderColor, values of the RGBA color used by
the texture reference \p hTexRef.
The color value is of type float and holds color components in
the following sequence:
pBorderColor[0] holds 'R' component
pBorderColor[1] holds 'G' component
pBorderColor[2] holds 'B' component
pBorderColor[3] holds 'A' component
\param hTexRef - Texture reference
\param pBorderColor - Returned Type and Value of RGBA color
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddressMode,
::cuTexRefSetAddressMode, ::cuTexRefSetBorderColor*/
fn cuTexRefGetBorderColor(
pBorderColor: *mut f32,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Gets the flags used by a texture reference
\deprecated
Returns in \p *pFlags the flags of the texture reference \p hTexRef.
\param pFlags - Returned flags
\param hTexRef - Texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefSetAddress,
::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray,
::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat,
::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray,
::cuTexRefGetFilterMode, ::cuTexRefGetFormat*/
fn cuTexRefGetFlags(
pFlags: *mut ::core::ffi::c_uint,
hTexRef: cuda_types::CUtexref,
) -> cuda_types::CUresult;
/** \brief Creates a texture reference
\deprecated
Creates a texture reference and returns its handle in \p *pTexRef. Once
created, the application must call ::cuTexRefSetArray() or
::cuTexRefSetAddress() to associate the reference with allocated memory.
Other texture reference functions are used to specify the format and
interpretation (addressing, filtering, etc.) to be used when the memory is
read through this texture reference.
\param pTexRef - Returned texture reference
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefDestroy*/
fn cuTexRefCreate(pTexRef: *mut cuda_types::CUtexref) -> cuda_types::CUresult;
/** \brief Destroys a texture reference
\deprecated
Destroys the texture reference specified by \p hTexRef.
\param hTexRef - Texture reference to destroy
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuTexRefCreate*/
fn cuTexRefDestroy(hTexRef: cuda_types::CUtexref) -> cuda_types::CUresult;
/** \brief Sets the CUDA array for a surface reference.
\deprecated
Sets the CUDA array \p hArray to be read and written by the surface reference
\p hSurfRef. Any previous CUDA array state associated with the surface
reference is superseded by this function. \p Flags must be set to 0.
The ::CUDA_ARRAY3D_SURFACE_LDST flag must have been set for the CUDA array.
Any CUDA array previously bound to \p hSurfRef is unbound.
\param hSurfRef - Surface reference handle
\param hArray - CUDA array handle
\param Flags - set to 0
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuModuleGetSurfRef,
::cuSurfRefGetArray*/
fn cuSurfRefSetArray(
hSurfRef: cuda_types::CUsurfref,
hArray: cuda_types::CUarray,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Passes back the CUDA array bound to a surface reference.
\deprecated
Returns in \p *phArray the CUDA array bound to the surface reference
\p hSurfRef, or returns ::CUDA_ERROR_INVALID_VALUE if the surface reference
is not bound to any CUDA array.
\param phArray - Surface reference handle
\param hSurfRef - Surface reference handle
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa ::cuModuleGetSurfRef, ::cuSurfRefSetArray*/
fn cuSurfRefGetArray(
phArray: *mut cuda_types::CUarray,
hSurfRef: cuda_types::CUsurfref,
) -> cuda_types::CUresult;
/** \brief Creates a texture object
Creates a texture object and returns it in \p pTexObject. \p pResDesc describes
the data to texture from. \p pTexDesc describes how the data should be sampled.
\p pResViewDesc is an optional argument that specifies an alternate format for
the data described by \p pResDesc, and also describes the subresource region
to restrict access to when texturing. \p pResViewDesc can only be specified if
the type of resource is a CUDA array or a CUDA mipmapped array.
Texture objects are only supported on devices of compute capability 3.0 or higher.
Additionally, a texture object is an opaque value, and, as such, should only be
accessed through CUDA API calls.
The ::CUDA_RESOURCE_DESC structure is defined as:
\code
typedef struct CUDA_RESOURCE_DESC_st
{
CUresourcetype resType;
union {
struct {
CUarray hArray;
} array;
struct {
CUmipmappedArray hMipmappedArray;
} mipmap;
struct {
CUdeviceptr devPtr;
CUarray_format format;
unsigned int numChannels;
size_t sizeInBytes;
} linear;
struct {
CUdeviceptr devPtr;
CUarray_format format;
unsigned int numChannels;
size_t width;
size_t height;
size_t pitchInBytes;
} pitch2D;
} res;
unsigned int flags;
} CUDA_RESOURCE_DESC;
\endcode
where:
- ::CUDA_RESOURCE_DESC::resType specifies the type of resource to texture from.
CUresourceType is defined as:
\code
typedef enum CUresourcetype_enum {
CU_RESOURCE_TYPE_ARRAY = 0x00,
CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01,
CU_RESOURCE_TYPE_LINEAR = 0x02,
CU_RESOURCE_TYPE_PITCH2D = 0x03
} CUresourcetype;
\endcode
\par
If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_ARRAY, ::CUDA_RESOURCE_DESC::res::array::hArray
must be set to a valid CUDA array handle.
\par
If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, ::CUDA_RESOURCE_DESC::res::mipmap::hMipmappedArray
must be set to a valid CUDA mipmapped array handle.
\par
If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_LINEAR, ::CUDA_RESOURCE_DESC::res::linear::devPtr
must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT.
::CUDA_RESOURCE_DESC::res::linear::format and ::CUDA_RESOURCE_DESC::res::linear::numChannels
describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::linear::sizeInBytes
specifies the size of the array in bytes. The total number of elements in the linear address range cannot exceed
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. The number of elements is computed as (sizeInBytes / (sizeof(format) * numChannels)).
\par
If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_PITCH2D, ::CUDA_RESOURCE_DESC::res::pitch2D::devPtr
must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT.
::CUDA_RESOURCE_DESC::res::pitch2D::format and ::CUDA_RESOURCE_DESC::res::pitch2D::numChannels
describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::pitch2D::width
and ::CUDA_RESOURCE_DESC::res::pitch2D::height specify the width and height of the array in elements, and cannot exceed
::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively.
::CUDA_RESOURCE_DESC::res::pitch2D::pitchInBytes specifies the pitch between two rows in bytes and has to be aligned to
::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. Pitch cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH.
- ::flags must be set to zero.
The ::CUDA_TEXTURE_DESC struct is defined as
\code
typedef struct CUDA_TEXTURE_DESC_st {
CUaddress_mode addressMode[3];
CUfilter_mode filterMode;
unsigned int flags;
unsigned int maxAnisotropy;
CUfilter_mode mipmapFilterMode;
float mipmapLevelBias;
float minMipmapLevelClamp;
float maxMipmapLevelClamp;
} CUDA_TEXTURE_DESC;
\endcode
where
- ::CUDA_TEXTURE_DESC::addressMode specifies the addressing mode for each dimension of the texture data. ::CUaddress_mode is defined as:
\code
typedef enum CUaddress_mode_enum {
CU_TR_ADDRESS_MODE_WRAP = 0,
CU_TR_ADDRESS_MODE_CLAMP = 1,
CU_TR_ADDRESS_MODE_MIRROR = 2,
CU_TR_ADDRESS_MODE_BORDER = 3
} CUaddress_mode;
\endcode
This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR. Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES
is not set, the only supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP.
- ::CUDA_TEXTURE_DESC::filterMode specifies the filtering mode to be used when fetching from the texture. CUfilter_mode is defined as:
\code
typedef enum CUfilter_mode_enum {
CU_TR_FILTER_MODE_POINT = 0,
CU_TR_FILTER_MODE_LINEAR = 1
} CUfilter_mode;
\endcode
This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR.
- ::CUDA_TEXTURE_DESC::flags can be any combination of the following:
- ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of
having the texture promote integer data to floating point data in the
range [0, 1]. Note that texture with 32-bit integer format would not be
promoted, regardless of whether or not this flag is specified.
- ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the default behavior
of having the texture coordinates range from [0, Dim) where Dim is the
width or height of the CUDA array. Instead, the texture coordinates
[0, 1.0) reference the entire breadth of the array dimension; Note that
for CUDA mipmapped arrays, this flag has to be set.
- ::CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION, which disables any trilinear
filtering optimizations. Trilinear optimizations improve texture filtering
performance by allowing bilinear filtering on textures in scenarios where
it can closely approximate the expected results.
- ::CU_TRSF_SEAMLESS_CUBEMAP, which enables seamless cube map filtering.
This flag can only be specified if the underlying resource is a CUDA array
or a CUDA mipmapped array that was created with the flag ::CUDA_ARRAY3D_CUBEMAP.
When seamless cube map filtering is enabled, texture address modes specified
by ::CUDA_TEXTURE_DESC::addressMode are ignored. Instead, if the ::CUDA_TEXTURE_DESC::filterMode
is set to ::CU_TR_FILTER_MODE_POINT the address mode ::CU_TR_ADDRESS_MODE_CLAMP
will be applied for all dimensions. If the ::CUDA_TEXTURE_DESC::filterMode is
set to ::CU_TR_FILTER_MODE_LINEAR seamless cube map filtering will be performed
when sampling along the cube face borders.
- ::CUDA_TEXTURE_DESC::maxAnisotropy specifies the maximum anisotropy ratio to be used when doing anisotropic filtering. This value will be
clamped to the range [1,16].
- ::CUDA_TEXTURE_DESC::mipmapFilterMode specifies the filter mode when the calculated mipmap level lies between two defined mipmap levels.
- ::CUDA_TEXTURE_DESC::mipmapLevelBias specifies the offset to be applied to the calculated mipmap level.
- ::CUDA_TEXTURE_DESC::minMipmapLevelClamp specifies the lower end of the mipmap level range to clamp access to.
- ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp specifies the upper end of the mipmap level range to clamp access to.
The ::CUDA_RESOURCE_VIEW_DESC struct is defined as
\code
typedef struct CUDA_RESOURCE_VIEW_DESC_st
{
CUresourceViewFormat format;
size_t width;
size_t height;
size_t depth;
unsigned int firstMipmapLevel;
unsigned int lastMipmapLevel;
unsigned int firstLayer;
unsigned int lastLayer;
} CUDA_RESOURCE_VIEW_DESC;
\endcode
where:
- ::CUDA_RESOURCE_VIEW_DESC::format specifies how the data contained in the CUDA array or CUDA mipmapped array should
be interpreted. Note that this can incur a change in size of the texture data. If the resource view format is a block
compressed format, then the underlying CUDA array or CUDA mipmapped array has to have a base of format ::CU_AD_FORMAT_UNSIGNED_INT32.
with 2 or 4 channels, depending on the block compressed format. For ex., BC1 and BC4 require the underlying CUDA array to have
a format of ::CU_AD_FORMAT_UNSIGNED_INT32 with 2 channels. The other BC formats require the underlying resource to have the same base
format but with 4 channels.
- ::CUDA_RESOURCE_VIEW_DESC::width specifies the new width of the texture data. If the resource view format is a block
compressed format, this value has to be 4 times the original width of the resource. For non block compressed formats,
this value has to be equal to that of the original resource.
- ::CUDA_RESOURCE_VIEW_DESC::height specifies the new height of the texture data. If the resource view format is a block
compressed format, this value has to be 4 times the original height of the resource. For non block compressed formats,
this value has to be equal to that of the original resource.
- ::CUDA_RESOURCE_VIEW_DESC::depth specifies the new depth of the texture data. This value has to be equal to that of the
original resource.
- ::CUDA_RESOURCE_VIEW_DESC::firstMipmapLevel specifies the most detailed mipmap level. This will be the new mipmap level zero.
For non-mipmapped resources, this value has to be zero.::CUDA_TEXTURE_DESC::minMipmapLevelClamp and ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp
will be relative to this value. For ex., if the firstMipmapLevel is set to 2, and a minMipmapLevelClamp of 1.2 is specified,
then the actual minimum mipmap level clamp will be 3.2.
- ::CUDA_RESOURCE_VIEW_DESC::lastMipmapLevel specifies the least detailed mipmap level. For non-mipmapped resources, this value
has to be zero.
- ::CUDA_RESOURCE_VIEW_DESC::firstLayer specifies the first layer index for layered textures. This will be the new layer zero.
For non-layered resources, this value has to be zero.
- ::CUDA_RESOURCE_VIEW_DESC::lastLayer specifies the last layer index for layered textures. For non-layered resources,
this value has to be zero.
\param pTexObject - Texture object to create
\param pResDesc - Resource descriptor
\param pTexDesc - Texture descriptor
\param pResViewDesc - Resource view descriptor
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexObjectDestroy,
::cudaCreateTextureObject*/
fn cuTexObjectCreate(
pTexObject: *mut cuda_types::CUtexObject,
pResDesc: *const cuda_types::CUDA_RESOURCE_DESC,
pTexDesc: *const cuda_types::CUDA_TEXTURE_DESC,
pResViewDesc: *const cuda_types::CUDA_RESOURCE_VIEW_DESC,
) -> cuda_types::CUresult;
/** \brief Destroys a texture object
Destroys the texture object specified by \p texObject.
\param texObject - Texture object to destroy
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexObjectCreate,
::cudaDestroyTextureObject*/
fn cuTexObjectDestroy(texObject: cuda_types::CUtexObject) -> cuda_types::CUresult;
/** \brief Returns a texture object's resource descriptor
Returns the resource descriptor for the texture object specified by \p texObject.
\param pResDesc - Resource descriptor
\param texObject - Texture object
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexObjectCreate,
::cudaGetTextureObjectResourceDesc,*/
fn cuTexObjectGetResourceDesc(
pResDesc: *mut cuda_types::CUDA_RESOURCE_DESC,
texObject: cuda_types::CUtexObject,
) -> cuda_types::CUresult;
/** \brief Returns a texture object's texture descriptor
Returns the texture descriptor for the texture object specified by \p texObject.
\param pTexDesc - Texture descriptor
\param texObject - Texture object
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexObjectCreate,
::cudaGetTextureObjectTextureDesc*/
fn cuTexObjectGetTextureDesc(
pTexDesc: *mut cuda_types::CUDA_TEXTURE_DESC,
texObject: cuda_types::CUtexObject,
) -> cuda_types::CUresult;
/** \brief Returns a texture object's resource view descriptor
Returns the resource view descriptor for the texture object specified by \p texObject.
If no resource view was set for \p texObject, the ::CUDA_ERROR_INVALID_VALUE is returned.
\param pResViewDesc - Resource view descriptor
\param texObject - Texture object
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTexObjectCreate,
::cudaGetTextureObjectResourceViewDesc*/
fn cuTexObjectGetResourceViewDesc(
pResViewDesc: *mut cuda_types::CUDA_RESOURCE_VIEW_DESC,
texObject: cuda_types::CUtexObject,
) -> cuda_types::CUresult;
/** \brief Creates a surface object
Creates a surface object and returns it in \p pSurfObject. \p pResDesc describes
the data to perform surface load/stores on. ::CUDA_RESOURCE_DESC::resType must be
::CU_RESOURCE_TYPE_ARRAY and ::CUDA_RESOURCE_DESC::res::array::hArray
must be set to a valid CUDA array handle. ::CUDA_RESOURCE_DESC::flags must be set to zero.
Surface objects are only supported on devices of compute capability 3.0 or higher.
Additionally, a surface object is an opaque value, and, as such, should only be
accessed through CUDA API calls.
\param pSurfObject - Surface object to create
\param pResDesc - Resource descriptor
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuSurfObjectDestroy,
::cudaCreateSurfaceObject*/
fn cuSurfObjectCreate(
pSurfObject: *mut cuda_types::CUsurfObject,
pResDesc: *const cuda_types::CUDA_RESOURCE_DESC,
) -> cuda_types::CUresult;
/** \brief Destroys a surface object
Destroys the surface object specified by \p surfObject.
\param surfObject - Surface object to destroy
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuSurfObjectCreate,
::cudaDestroySurfaceObject*/
fn cuSurfObjectDestroy(surfObject: cuda_types::CUsurfObject) -> cuda_types::CUresult;
/** \brief Returns a surface object's resource descriptor
Returns the resource descriptor for the surface object specified by \p surfObject.
\param pResDesc - Resource descriptor
\param surfObject - Surface object
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuSurfObjectCreate,
::cudaGetSurfaceObjectResourceDesc*/
fn cuSurfObjectGetResourceDesc(
pResDesc: *mut cuda_types::CUDA_RESOURCE_DESC,
surfObject: cuda_types::CUsurfObject,
) -> cuda_types::CUresult;
/** \brief Create a tensor map descriptor object representing tiled memory region
Creates a descriptor for Tensor Memory Access (TMA) object specified
by the parameters describing a tiled region and returns it in \p tensorMap.
Tensor map objects are only supported on devices of compute capability 9.0 or higher.
Additionally, a tensor map object is an opaque value, and, as such, should only be
accessed through CUDA API calls.
The parameters passed are bound to the following requirements:
- \p tensorMap address must be aligned to 64 bytes.
- \p tensorDataType has to be an enum from ::CUtensorMapDataType which is defined as:
\code
typedef enum CUtensorMapDataType_enum {
CU_TENSOR_MAP_DATA_TYPE_UINT8 = 0, // 1 byte
CU_TENSOR_MAP_DATA_TYPE_UINT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_UINT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_INT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_UINT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_INT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_BFLOAT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT32_FTZ, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32_FTZ // 4 bytes
} CUtensorMapDataType;
\endcode
- \p tensorRank must be non-zero and less than or equal to the maximum supported dimensionality of 5. If \p interleave is not
::CU_TENSOR_MAP_INTERLEAVE_NONE, then \p tensorRank must additionally be greater than or equal to 3.
- \p globalAddress, which specifies the starting address of the memory region described, must be 32 byte aligned when \p interleave is
::CU_TENSOR_MAP_INTERLEAVE_32B and 16 byte aligned otherwise.
- \p globalDim array, which specifies tensor size of each of the \p tensorRank dimensions, must be non-zero and less than or
equal to 2^32.
- \p globalStrides array, which specifies tensor stride of each of the lower \p tensorRank - 1 dimensions in bytes, must be a
multiple of 16 and less than 2^40. Additionally, the stride must be a multiple of 32 when \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_32B.
Each following dimension specified includes previous dimension stride:
\code
globalStrides[0] = globalDim[0] * elementSizeInBytes(tensorDataType) + padding[0];
for (i = 1; i < tensorRank - 1; i++)
globalStrides[i] = globalStrides[i – 1] * (globalDim[i] + padding[i]);
assert(globalStrides[i] >= globalDim[i]);
\endcode
- \p boxDim array, which specifies number of elements to be traversed along each of the \p tensorRank dimensions, must be non-zero
and less than or equal to 256.
When \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_NONE, { \p boxDim[0] * elementSizeInBytes( \p tensorDataType ) } must be a multiple
of 16 bytes.
- \p elementStrides array, which specifies the iteration step along each of the \p tensorRank dimensions, must be non-zero and less
than or equal to 8. Note that when \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_NONE, the first element of this array is ignored since
TMA doesn’t support the stride for dimension zero.
When all elements of \p elementStrides array is one, \p boxDim specifies the number of elements to load. However, if the \p elementStrides[i]
is not equal to one, then TMA loads ceil( \p boxDim[i] / \p elementStrides[i]) number of elements along i-th dimension. To load N elements along
i-th dimension, \p boxDim[i] must be set to N * \p elementStrides[i].
- \p interleave specifies the interleaved layout of type ::CUtensorMapInterleave, which is defined as:
\code
typedef enum CUtensorMapInterleave_enum {
CU_TENSOR_MAP_INTERLEAVE_NONE = 0,
CU_TENSOR_MAP_INTERLEAVE_16B,
CU_TENSOR_MAP_INTERLEAVE_32B
} CUtensorMapInterleave;
\endcode
TMA supports interleaved layouts like NC/8HWC8 where C8 utilizes 16 bytes in memory assuming 2 byte per channel or NC/16HWC16 where C16
uses 32 bytes.
When \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_NONE and \p swizzle is not ::CU_TENSOR_MAP_SWIZZLE_NONE, the bounding box inner dimension
(computed as \p boxDim[0] multiplied by element size derived from \p tensorDataType) must be less than or equal to the swizzle size.
- CU_TENSOR_MAP_SWIZZLE_32B implies the bounding box inner dimension will be <= 32.
- CU_TENSOR_MAP_SWIZZLE_64B implies the bounding box inner dimension will be <= 64.
- CU_TENSOR_MAP_SWIZZLE_128B implies the bounding box inner dimension will be <= 128.
- \p swizzle, which specifies the shared memory bank swizzling pattern, has to be of type ::CUtensorMapSwizzle which is defined as:
\code
typedef enum CUtensorMapSwizzle_enum {
CU_TENSOR_MAP_SWIZZLE_NONE = 0,
CU_TENSOR_MAP_SWIZZLE_32B,
CU_TENSOR_MAP_SWIZZLE_64B,
CU_TENSOR_MAP_SWIZZLE_128B
} CUtensorMapSwizzle;
\endcode
Data are organized in a specific order in global memory; however, this may not match the order in which the application accesses data
in shared memory. This difference in data organization may cause bank conflicts when shared memory is accessed. In order to avoid this
problem, data can be loaded to shared memory with shuffling across shared memory banks.
When \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_32B, \p swizzle must be ::CU_TENSOR_MAP_SWIZZLE_32B.
Other interleave modes can have any swizzling pattern.
- \p l2Promotion specifies L2 fetch size which indicates the byte granurality at which L2 requests is filled from DRAM. It must be of
type ::CUtensorMapL2promotion, which is defined as:
\code
typedef enum CUtensorMapL2promotion_enum {
CU_TENSOR_MAP_L2_PROMOTION_NONE = 0,
CU_TENSOR_MAP_L2_PROMOTION_L2_64B,
CU_TENSOR_MAP_L2_PROMOTION_L2_128B,
CU_TENSOR_MAP_L2_PROMOTION_L2_256B
} CUtensorMapL2promotion;
\endcode
- \p oobFill, which indicates whether zero or a special NaN constant should be used to fill out-of-bound elements, must be of type
::CUtensorMapFloatOOBfill which is defined as:
\code
typedef enum CUtensorMapFloatOOBfill_enum {
CU_TENSOR_MAP_FLOAT_OOB_FILL_NONE = 0,
CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA
} CUtensorMapFloatOOBfill;
\endcode
Note that ::CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA can only be used when \p tensorDataType represents a floating-point data type.
\param tensorMap - Tensor map object to create
\param tensorDataType - Tensor data type
\param tensorRank - Dimensionality of tensor
\param globalAddress - Starting address of memory region described by tensor
\param globalDim - Array containing tensor size (number of elements) along each of the \p tensorRank dimensions
\param globalStrides - Array containing stride size (in bytes) along each of the \p tensorRank - 1 dimensions
\param boxDim - Array containing traversal box size (number of elments) along each of the \p tensorRank dimensions. Specifies how many elements to be traversed along each tensor dimension.
\param elementStrides - Array containing traversal stride in each of the \p tensorRank dimensions
\param interleave - Type of interleaved layout the tensor addresses
\param swizzle - Bank swizzling pattern inside shared memory
\param l2Promotion - L2 promotion size
\param oobFill - Indicate whether zero or special NaN constant must be used to fill out-of-bound elements
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTensorMapEncodeIm2col,
::cuTensorMapReplaceAddress*/
fn cuTensorMapEncodeTiled(
tensorMap: *mut cuda_types::CUtensorMap,
tensorDataType: cuda_types::CUtensorMapDataType,
tensorRank: cuda_types::cuuint32_t,
globalAddress: *mut ::core::ffi::c_void,
globalDim: *const cuda_types::cuuint64_t,
globalStrides: *const cuda_types::cuuint64_t,
boxDim: *const cuda_types::cuuint32_t,
elementStrides: *const cuda_types::cuuint32_t,
interleave: cuda_types::CUtensorMapInterleave,
swizzle: cuda_types::CUtensorMapSwizzle,
l2Promotion: cuda_types::CUtensorMapL2promotion,
oobFill: cuda_types::CUtensorMapFloatOOBfill,
) -> cuda_types::CUresult;
/** \brief Create a tensor map descriptor object representing im2col memory region
Creates a descriptor for Tensor Memory Access (TMA) object specified
by the parameters describing a im2col memory layout and returns it in \p tensorMap.
Tensor map objects are only supported on devices of compute capability 9.0 or higher.
Additionally, a tensor map object is an opaque value, and, as such, should only be
accessed through CUDA API calls.
The parameters passed are bound to the following requirements:
- \p tensorMap address must be aligned to 64 bytes.
- \p tensorDataType has to be an enum from ::CUtensorMapDataType which is defined as:
\code
typedef enum CUtensorMapDataType_enum {
CU_TENSOR_MAP_DATA_TYPE_UINT8 = 0, // 1 byte
CU_TENSOR_MAP_DATA_TYPE_UINT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_UINT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_INT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_UINT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_INT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT64, // 8 bytes
CU_TENSOR_MAP_DATA_TYPE_BFLOAT16, // 2 bytes
CU_TENSOR_MAP_DATA_TYPE_FLOAT32_FTZ, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32, // 4 bytes
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32_FTZ // 4 bytes
} CUtensorMapDataType;
\endcode
- \p tensorRank, which specifies the number of tensor dimensions, must be 3, 4, or 5.
- \p globalAddress, which specifies the starting address of the memory region described, must be 32 byte aligned when \p interleave is
::CU_TENSOR_MAP_INTERLEAVE_32B and 16 byte aligned otherwise.
- \p globalDim array, which specifies tensor size of each of the \p tensorRank dimensions, must be non-zero and less than or
equal to 2^32.
- \p globalStrides array, which specifies tensor stride of each of the lower \p tensorRank - 1 dimensions in bytes, must be a
multiple of 16 and less than 2^40. Additionally, the stride must be a multiple of 32 when \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_32B.
Each following dimension specified includes previous dimension stride:
\code
globalStrides[0] = globalDim[0] * elementSizeInBytes(tensorDataType) + padding[0];
for (i = 1; i < tensorRank - 1; i++)
globalStrides[i] = globalStrides[i – 1] * (globalDim[i] + padding[i]);
assert(globalStrides[i] >= globalDim[i]);
\endcode
- \p pixelBoxLowerCorner array specifies the coordinate offsets {D, H, W} of the bounding box from top/left/front corner. The number of
offsets and their precision depend on the tensor dimensionality:
- When \p tensorRank is 3, one signed offset within range [-32768, 32767] is supported.
- When \p tensorRank is 4, two signed offsets each within range [-128, 127] are supported.
- When \p tensorRank is 5, three offsets each within range [-16, 15] are supported.
- \p pixelBoxUpperCorner array specifies the coordinate offsets {D, H, W} of the bounding box from bottom/right/back corner. The number of
offsets and their precision depend on the tensor dimensionality:
- When \p tensorRank is 3, one signed offset within range [-32768, 32767] is supported.
- When \p tensorRank is 4, two signed offsets each within range [-128, 127] are supported.
- When \p tensorRank is 5, three offsets each within range [-16, 15] are supported.
The bounding box specified by \p pixelBoxLowerCorner and \p pixelBoxUpperCorner must have non-zero area.
- \p channelsPerPixel, which specifies the number of elements which must be accessed along C dimension, must be less than or equal to 256.
- \p pixelsPerColumn, which specifies the number of elements that must be accessed along the {N, D, H, W} dimensions, must be less than or
equal to 1024.
- \p elementStrides array, which specifies the iteration step along each of the \p tensorRank dimensions, must be non-zero and less
than or equal to 8. Note that when \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_NONE, the first element of this array is ignored since
TMA doesn’t support the stride for dimension zero.
When all elements of the \p elementStrides array are one, \p boxDim specifies the number of elements to load. However, if \p elementStrides[i]
is not equal to one for some \p i, then TMA loads ceil( \p boxDim[i] / \p elementStrides[i]) number of elements along i-th dimension.
To load N elements along i-th dimension, \p boxDim[i] must be set to N * \p elementStrides[i].
- \p interleave specifies the interleaved layout of type ::CUtensorMapInterleave, which is defined as:
\code
typedef enum CUtensorMapInterleave_enum {
CU_TENSOR_MAP_INTERLEAVE_NONE = 0,
CU_TENSOR_MAP_INTERLEAVE_16B,
CU_TENSOR_MAP_INTERLEAVE_32B
} CUtensorMapInterleave;
\endcode
TMA supports interleaved layouts like NC/8HWC8 where C8 utilizes 16 bytes in memory assuming 2 byte per channel or NC/16HWC16 where C16
uses 32 bytes.
When \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_NONE and \p swizzle is not ::CU_TENSOR_MAP_SWIZZLE_NONE, the bounding box inner dimension
(computed as \p boxDim[0] multiplied by element size derived from \p tensorDataType) must be less than or equal to the swizzle size.
- CU_TENSOR_MAP_SWIZZLE_32B implies the bounding box inner dimension will be <= 32.
- CU_TENSOR_MAP_SWIZZLE_64B implies the bounding box inner dimension will be <= 64.
- CU_TENSOR_MAP_SWIZZLE_128B implies the bounding box inner dimension will be <= 128.
- \p swizzle, which specifies the shared memory bank swizzling pattern, has to be of type ::CUtensorMapSwizzle which is defined as:
\code
typedef enum CUtensorMapSwizzle_enum {
CU_TENSOR_MAP_SWIZZLE_NONE = 0,
CU_TENSOR_MAP_SWIZZLE_32B,
CU_TENSOR_MAP_SWIZZLE_64B,
CU_TENSOR_MAP_SWIZZLE_128B
} CUtensorMapSwizzle;
\endcode
Data are organized in a specific order in global memory; however, this may not match the order in which the application accesses data
in shared memory. This difference in data organization may cause bank conflicts when shared memory is accessed. In order to avoid this
problem, data can be loaded to shared memory with shuffling across shared memory banks.
When \p interleave is ::CU_TENSOR_MAP_INTERLEAVE_32B, \p swizzle must be ::CU_TENSOR_MAP_SWIZZLE_32B.
Other interleave modes can have any swizzling pattern.
- \p l2Promotion specifies L2 fetch size which indicates the byte granularity at which L2 requests are filled from DRAM. It must be of
type ::CUtensorMapL2promotion, which is defined as:
\code
typedef enum CUtensorMapL2promotion_enum {
CU_TENSOR_MAP_L2_PROMOTION_NONE = 0,
CU_TENSOR_MAP_L2_PROMOTION_L2_64B,
CU_TENSOR_MAP_L2_PROMOTION_L2_128B,
CU_TENSOR_MAP_L2_PROMOTION_L2_256B
} CUtensorMapL2promotion;
\endcode
- \p oobFill, which indicates whether zero or a special NaN constant should be used to fill out-of-bound elements, must be of type
::CUtensorMapFloatOOBfill which is defined as:
\code
typedef enum CUtensorMapFloatOOBfill_enum {
CU_TENSOR_MAP_FLOAT_OOB_FILL_NONE = 0,
CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA
} CUtensorMapFloatOOBfill;
\endcode
Note that ::CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA can only be used when \p tensorDataType represents a floating-point data type.
\param tensorMap - Tensor map object to create
\param tensorDataType - Tensor data type
\param tensorRank - Dimensionality of tensor; must be at least 3
\param globalAddress - Starting address of memory region described by tensor
\param globalDim - Array containing tensor size (number of elements) along each of the \p tensorRank dimensions
\param globalStrides - Array containing stride size (in bytes) along each of the \p tensorRank - 1 dimensions
\param pixelBoxLowerCorner - Array containing DHW dimensions of lower box corner
\param pixelBoxUpperCorner - Array containing DHW dimensions of upper box corner
\param channelsPerPixel - Number of channels per pixel
\param pixelsPerColumn - Number of pixels per column
\param elementStrides - Array containing traversal stride in each of the \p tensorRank dimensions
\param interleave - Type of interleaved layout the tensor addresses
\param swizzle - Bank swizzling pattern inside shared memory
\param l2Promotion - L2 promotion size
\param oobFill - Indicate whether zero or special NaN constant will be used to fill out-of-bound elements
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTensorMapEncodeTiled,
::cuTensorMapReplaceAddress*/
fn cuTensorMapEncodeIm2col(
tensorMap: *mut cuda_types::CUtensorMap,
tensorDataType: cuda_types::CUtensorMapDataType,
tensorRank: cuda_types::cuuint32_t,
globalAddress: *mut ::core::ffi::c_void,
globalDim: *const cuda_types::cuuint64_t,
globalStrides: *const cuda_types::cuuint64_t,
pixelBoxLowerCorner: *const ::core::ffi::c_int,
pixelBoxUpperCorner: *const ::core::ffi::c_int,
channelsPerPixel: cuda_types::cuuint32_t,
pixelsPerColumn: cuda_types::cuuint32_t,
elementStrides: *const cuda_types::cuuint32_t,
interleave: cuda_types::CUtensorMapInterleave,
swizzle: cuda_types::CUtensorMapSwizzle,
l2Promotion: cuda_types::CUtensorMapL2promotion,
oobFill: cuda_types::CUtensorMapFloatOOBfill,
) -> cuda_types::CUresult;
/** \brief Modify an existing tensor map descriptor with an updated global address
Modifies the descriptor for Tensor Memory Access (TMA) object passed in \p tensorMap with
an updated \p globalAddress.
Tensor map objects are only supported on devices of compute capability 9.0 or higher.
Additionally, a tensor map object is an opaque value, and, as such, should only be
accessed through CUDA API calls.
\param tensorMap - Tensor map object to modify
\param globalAddress - Starting address of memory region described by tensor, must follow previous alignment requirements
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuTensorMapEncodeTiled,
::cuTensorMapEncodeIm2col*/
fn cuTensorMapReplaceAddress(
tensorMap: *mut cuda_types::CUtensorMap,
globalAddress: *mut ::core::ffi::c_void,
) -> cuda_types::CUresult;
/** \brief Queries if a device may directly access a peer device's memory.
Returns in \p *canAccessPeer a value of 1 if contexts on \p dev are capable of
directly accessing memory from contexts on \p peerDev and 0 otherwise.
If direct access of \p peerDev from \p dev is possible, then access may be
enabled on two specific contexts by calling ::cuCtxEnablePeerAccess().
\param canAccessPeer - Returned access capability
\param dev - Device from which allocations on \p peerDev are to
be directly accessed.
\param peerDev - Device on which the allocations to be directly accessed
by \p dev reside.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_DEVICE
\notefnerr
\sa
::cuCtxEnablePeerAccess,
::cuCtxDisablePeerAccess,
::cudaDeviceCanAccessPeer*/
fn cuDeviceCanAccessPeer(
canAccessPeer: *mut ::core::ffi::c_int,
dev: cuda_types::CUdevice,
peerDev: cuda_types::CUdevice,
) -> cuda_types::CUresult;
/** \brief Enables direct access to memory allocations in a peer context.
If both the current context and \p peerContext are on devices which support unified
addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING) and same
major compute capability, then on success all allocations from \p peerContext will
immediately be accessible by the current context. See \ref CUDA_UNIFIED for additional
details.
Note that access granted by this call is unidirectional and that in order to access
memory from the current context in \p peerContext, a separate symmetric call
to ::cuCtxEnablePeerAccess() is required.
Note that there are both device-wide and system-wide limitations per system
configuration, as noted in the CUDA Programming Guide under the section
"Peer-to-Peer Memory Access".
Returns ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED if ::cuDeviceCanAccessPeer() indicates
that the ::CUdevice of the current context cannot directly access memory
from the ::CUdevice of \p peerContext.
Returns ::CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED if direct access of
\p peerContext from the current context has already been enabled.
Returns ::CUDA_ERROR_TOO_MANY_PEERS if direct peer access is not possible
because hardware resources required for peer access have been exhausted.
Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, \p peerContext
is not a valid context, or if the current context is \p peerContext.
Returns ::CUDA_ERROR_INVALID_VALUE if \p Flags is not 0.
\param peerContext - Peer context to enable direct access to from the current context
\param Flags - Reserved for future use and must be set to 0
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED,
::CUDA_ERROR_TOO_MANY_PEERS,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED,
::CUDA_ERROR_INVALID_VALUE
\notefnerr
\sa
::cuDeviceCanAccessPeer,
::cuCtxDisablePeerAccess,
::cudaDeviceEnablePeerAccess*/
fn cuCtxEnablePeerAccess(
peerContext: cuda_types::CUcontext,
Flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Disables direct access to memory allocations in a peer context and
unregisters any registered allocations.
Returns ::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED if direct peer access has
not yet been enabled from \p peerContext to the current context.
Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, or if
\p peerContext is not a valid context.
\param peerContext - Peer context to disable direct access to
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED,
::CUDA_ERROR_INVALID_CONTEXT,
\notefnerr
\sa
::cuDeviceCanAccessPeer,
::cuCtxEnablePeerAccess,
::cudaDeviceDisablePeerAccess*/
fn cuCtxDisablePeerAccess(
peerContext: cuda_types::CUcontext,
) -> cuda_types::CUresult;
/** \brief Queries attributes of the link between two devices.
Returns in \p *value the value of the requested attribute \p attrib of the
link between \p srcDevice and \p dstDevice. The supported attributes are:
- ::CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: A relative value indicating the
performance of the link between two devices.
- ::CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED P2P: 1 if P2P Access is enable.
- ::CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: 1 if Atomic operations over
the link are supported.
- ::CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: 1 if cudaArray can
be accessed over the link.
Returns ::CUDA_ERROR_INVALID_DEVICE if \p srcDevice or \p dstDevice are not valid
or if they represent the same device.
Returns ::CUDA_ERROR_INVALID_VALUE if \p attrib is not valid or if \p value is
a null pointer.
\param value - Returned value of the requested attribute
\param attrib - The requested attribute of the link between \p srcDevice and \p dstDevice.
\param srcDevice - The source device of the target link.
\param dstDevice - The destination device of the target link.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_INVALID_VALUE
\notefnerr
\sa
::cuCtxEnablePeerAccess,
::cuCtxDisablePeerAccess,
::cuDeviceCanAccessPeer,
::cudaDeviceGetP2PAttribute*/
fn cuDeviceGetP2PAttribute(
value: *mut ::core::ffi::c_int,
attrib: cuda_types::CUdevice_P2PAttribute,
srcDevice: cuda_types::CUdevice,
dstDevice: cuda_types::CUdevice,
) -> cuda_types::CUresult;
/** \brief Unregisters a graphics resource for access by CUDA
Unregisters the graphics resource \p resource so it is not accessible by
CUDA unless registered again.
If \p resource is invalid then ::CUDA_ERROR_INVALID_HANDLE is
returned.
\param resource - Resource to unregister
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_UNKNOWN
\notefnerr
\sa
::cuGraphicsD3D9RegisterResource,
::cuGraphicsD3D10RegisterResource,
::cuGraphicsD3D11RegisterResource,
::cuGraphicsGLRegisterBuffer,
::cuGraphicsGLRegisterImage,
::cudaGraphicsUnregisterResource*/
fn cuGraphicsUnregisterResource(
resource: cuda_types::CUgraphicsResource,
) -> cuda_types::CUresult;
/** \brief Get an array through which to access a subresource of a mapped graphics resource.
Returns in \p *pArray an array through which the subresource of the mapped
graphics resource \p resource which corresponds to array index \p arrayIndex
and mipmap level \p mipLevel may be accessed. The value set in \p *pArray may
change every time that \p resource is mapped.
If \p resource is not a texture then it cannot be accessed via an array and
::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned.
If \p arrayIndex is not a valid array index for \p resource then
::CUDA_ERROR_INVALID_VALUE is returned.
If \p mipLevel is not a valid mipmap level for \p resource then
::CUDA_ERROR_INVALID_VALUE is returned.
If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned.
\param pArray - Returned array through which a subresource of \p resource may be accessed
\param resource - Mapped resource to access
\param arrayIndex - Array index for array textures or cubemap face
index as defined by ::CUarray_cubemap_face for
cubemap textures for the subresource to access
\param mipLevel - Mipmap level for the subresource to access
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_NOT_MAPPED,
::CUDA_ERROR_NOT_MAPPED_AS_ARRAY
\notefnerr
\sa
::cuGraphicsResourceGetMappedPointer,
::cudaGraphicsSubResourceGetMappedArray*/
fn cuGraphicsSubResourceGetMappedArray(
pArray: *mut cuda_types::CUarray,
resource: cuda_types::CUgraphicsResource,
arrayIndex: ::core::ffi::c_uint,
mipLevel: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Get a mipmapped array through which to access a mapped graphics resource.
Returns in \p *pMipmappedArray a mipmapped array through which the mapped graphics
resource \p resource. The value set in \p *pMipmappedArray may change every time
that \p resource is mapped.
If \p resource is not a texture then it cannot be accessed via a mipmapped array and
::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned.
If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned.
\param pMipmappedArray - Returned mipmapped array through which \p resource may be accessed
\param resource - Mapped resource to access
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_NOT_MAPPED,
::CUDA_ERROR_NOT_MAPPED_AS_ARRAY
\notefnerr
\sa
::cuGraphicsResourceGetMappedPointer,
::cudaGraphicsResourceGetMappedMipmappedArray*/
fn cuGraphicsResourceGetMappedMipmappedArray(
pMipmappedArray: *mut cuda_types::CUmipmappedArray,
resource: cuda_types::CUgraphicsResource,
) -> cuda_types::CUresult;
/** \brief Get a device pointer through which to access a mapped graphics resource.
Returns in \p *pDevPtr a pointer through which the mapped graphics resource
\p resource may be accessed.
Returns in \p pSize the size of the memory in bytes which may be accessed from that pointer.
The value set in \p pPointer may change every time that \p resource is mapped.
If \p resource is not a buffer then it cannot be accessed via a pointer and
::CUDA_ERROR_NOT_MAPPED_AS_POINTER is returned.
If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned.
*
\param pDevPtr - Returned pointer through which \p resource may be accessed
\param pSize - Returned size of the buffer accessible starting at \p *pPointer
\param resource - Mapped resource to access
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_NOT_MAPPED,
::CUDA_ERROR_NOT_MAPPED_AS_POINTER
\notefnerr
\sa
::cuGraphicsMapResources,
::cuGraphicsSubResourceGetMappedArray,
::cudaGraphicsResourceGetMappedPointer*/
fn cuGraphicsResourceGetMappedPointer_v2(
pDevPtr: *mut cuda_types::CUdeviceptr,
pSize: *mut usize,
resource: cuda_types::CUgraphicsResource,
) -> cuda_types::CUresult;
/** \brief Set usage flags for mapping a graphics resource
Set \p flags for mapping the graphics resource \p resource.
Changes to \p flags will take effect the next time \p resource is mapped.
The \p flags argument may be any of the following:
- ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE: Specifies no hints about how this
resource will be used. It is therefore assumed that this resource will be
read from and written to by CUDA kernels. This is the default value.
- ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_READONLY: Specifies that CUDA kernels which
access this resource will not write to this resource.
- ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITEDISCARD: Specifies that CUDA kernels
which access this resource will not read from this resource and will
write over the entire contents of the resource, so none of the data
previously stored in the resource will be preserved.
If \p resource is presently mapped for access by CUDA then
::CUDA_ERROR_ALREADY_MAPPED is returned.
If \p flags is not one of the above values then ::CUDA_ERROR_INVALID_VALUE is returned.
\param resource - Registered resource to set flags for
\param flags - Parameters for resource mapping
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_ALREADY_MAPPED
\notefnerr
\sa
::cuGraphicsMapResources,
::cudaGraphicsResourceSetMapFlags*/
fn cuGraphicsResourceSetMapFlags_v2(
resource: cuda_types::CUgraphicsResource,
flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Map graphics resources for access by CUDA
Maps the \p count graphics resources in \p resources for access by CUDA.
The resources in \p resources may be accessed by CUDA until they
are unmapped. The graphics API from which \p resources were registered
should not access any resources while they are mapped by CUDA. If an
application does so, the results are undefined.
This function provides the synchronization guarantee that any graphics calls
issued before ::cuGraphicsMapResources() will complete before any subsequent CUDA
work issued in \p stream begins.
If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned.
If any of \p resources are presently mapped for access by CUDA then ::CUDA_ERROR_ALREADY_MAPPED is returned.
\param count - Number of resources to map
\param resources - Resources to map for CUDA usage
\param hStream - Stream with which to synchronize
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_ALREADY_MAPPED,
::CUDA_ERROR_UNKNOWN
\note_null_stream
\notefnerr
\sa
::cuGraphicsResourceGetMappedPointer,
::cuGraphicsSubResourceGetMappedArray,
::cuGraphicsUnmapResources,
::cudaGraphicsMapResources*/
fn cuGraphicsMapResources_ptsz(
count: ::core::ffi::c_uint,
resources: *mut cuda_types::CUgraphicsResource,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Unmap graphics resources.
Unmaps the \p count graphics resources in \p resources.
Once unmapped, the resources in \p resources may not be accessed by CUDA
until they are mapped again.
This function provides the synchronization guarantee that any CUDA work issued
in \p stream before ::cuGraphicsUnmapResources() will complete before any
subsequently issued graphics work begins.
If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned.
If any of \p resources are not presently mapped for access by CUDA then ::CUDA_ERROR_NOT_MAPPED is returned.
\param count - Number of resources to unmap
\param resources - Resources to unmap
\param hStream - Stream with which to synchronize
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE,
::CUDA_ERROR_NOT_MAPPED,
::CUDA_ERROR_UNKNOWN
\note_null_stream
\notefnerr
\sa
::cuGraphicsMapResources,
::cudaGraphicsUnmapResources*/
fn cuGraphicsUnmapResources_ptsz(
count: ::core::ffi::c_uint,
resources: *mut cuda_types::CUgraphicsResource,
hStream: cuda_types::CUstream,
) -> cuda_types::CUresult;
/** \brief Returns the requested driver API function pointer
Returns in \p **pfn the address of the CUDA driver function for the requested
CUDA version and flags.
The CUDA version is specified as (1000 * major + 10 * minor), so CUDA 11.2
should be specified as 11020. For a requested driver symbol, if the specified
CUDA version is greater than or equal to the CUDA version in which the driver symbol
was introduced, this API will return the function pointer to the corresponding
versioned function.
The pointer returned by the API should be cast to a function pointer matching the
requested driver function's definition in the API header file. The function pointer
typedef can be picked up from the corresponding typedefs header file. For example,
cudaTypedefs.h consists of function pointer typedefs for driver APIs defined in cuda.h.
The API will return ::CUDA_SUCCESS and set the returned \p pfn to NULL if the
requested driver function is not supported on the platform, no ABI
compatible driver function exists for the specified \p cudaVersion or if the
driver symbol is invalid.
It will also set the optional \p symbolStatus to one of the values in
::CUdriverProcAddressQueryResult with the following meanings:
- ::CU_GET_PROC_ADDRESS_SUCCESS - The requested symbol was succesfully found based
on input arguments and \p pfn is valid
- ::CU_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND - The requested symbol was not found
- ::CU_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT - The requested symbol was found but is
not supported by cudaVersion specified
The requested flags can be:
- ::CU_GET_PROC_ADDRESS_DEFAULT: This is the default mode. This is equivalent to
::CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM if the code is compiled with
--default-stream per-thread compilation flag or the macro CUDA_API_PER_THREAD_DEFAULT_STREAM
is defined; ::CU_GET_PROC_ADDRESS_LEGACY_STREAM otherwise.
- ::CU_GET_PROC_ADDRESS_LEGACY_STREAM: This will enable the search for all driver symbols
that match the requested driver symbol name except the corresponding per-thread versions.
- ::CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM: This will enable the search for all
driver symbols that match the requested driver symbol name including the per-thread
versions. If a per-thread version is not found, the API will return the legacy version
of the driver function.
\param symbol - The base name of the driver API function to look for. As an example,
for the driver API ::cuMemAlloc_v2, \p symbol would be cuMemAlloc and
\p cudaVersion would be the ABI compatible CUDA version for the _v2 variant.
\param pfn - Location to return the function pointer to the requested driver function
\param cudaVersion - The CUDA version to look for the requested driver symbol
\param flags - Flags to specify search options.
\param symbolStatus - Optional location to store the status of the search for
\p symbol based on \p cudaVersion. See ::CUdriverProcAddressQueryResult
for possible values.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_SUPPORTED
\note_version_mixing
\sa
::cudaGetDriverEntryPoint*/
fn cuGetProcAddress_v2(
symbol: *const ::core::ffi::c_char,
pfn: *mut *mut ::core::ffi::c_void,
cudaVersion: ::core::ffi::c_int,
flags: cuda_types::cuuint64_t,
symbolStatus: *mut cuda_types::CUdriverProcAddressQueryResult,
) -> cuda_types::CUresult;
/** \brief Allows caller to fetch a coredump attribute value for the current context
Returns in \p *value the requested value specified by \p attrib. It is up to the caller
to ensure that the data type and size of \p *value matches the request.
If the caller calls this function with \p *value equal to NULL, the size of the memory
region (in bytes) expected for \p attrib will be placed in \p size.
The supported attributes are:
- ::CU_COREDUMP_ENABLE_ON_EXCEPTION: Bool where ::true means that GPU exceptions from
this context will create a coredump at the location specified by ::CU_COREDUMP_FILE.
The default value is ::false unless set to ::true globally or locally, or the
CU_CTX_USER_COREDUMP_ENABLE flag was set during context creation.
- ::CU_COREDUMP_TRIGGER_HOST: Bool where ::true means that the host CPU will
also create a coredump. The default value is ::true unless set to ::false globally or
or locally.
- ::CU_COREDUMP_LIGHTWEIGHT: Bool where ::true means that any resulting coredumps
will not have a dump of GPU memory or non-reloc ELF images. The default value is
::false unless set to ::true globally or locally.
- ::CU_COREDUMP_ENABLE_USER_TRIGGER: Bool where ::true means that a coredump can be
created by writing to the system pipe specified by ::CU_COREDUMP_PIPE. The default
value is ::false unless set to ::true globally or locally.
- ::CU_COREDUMP_FILE: String of up to 1023 characters that defines the location where
any coredumps generated by this context will be written. The default value is
::core.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA applications and ::PID is the process ID of the CUDA application.
- ::CU_COREDUMP_PIPE: String of up to 1023 characters that defines the name of the pipe
that will be monitored if user-triggered coredumps are enabled. The default value is
::corepipe.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA application and ::PID is the process ID of the CUDA application.
\param attrib - The enum defining which value to fetch.
\param value - void* containing the requested data.
\param size - The size of the memory region \p value points to.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_CONTEXT_IS_DESTROYED
\sa
::cuCoredumpGetAttributeGlobal,
::cuCoredumpSetAttribute,
::cuCoredumpSetAttributeGlobal*/
fn cuCoredumpGetAttribute(
attrib: cuda_types::CUcoredumpSettings,
value: *mut ::core::ffi::c_void,
size: *mut usize,
) -> cuda_types::CUresult;
/** \brief Allows caller to fetch a coredump attribute value for the entire application
Returns in \p *value the requested value specified by \p attrib. It is up to the caller
to ensure that the data type and size of \p *value matches the request.
If the caller calls this function with \p *value equal to NULL, the size of the memory
region (in bytes) expected for \p attrib will be placed in \p size.
The supported attributes are:
- ::CU_COREDUMP_ENABLE_ON_EXCEPTION: Bool where ::true means that GPU exceptions from
this context will create a coredump at the location specified by ::CU_COREDUMP_FILE.
The default value is ::false.
- ::CU_COREDUMP_TRIGGER_HOST: Bool where ::true means that the host CPU will
also create a coredump. The default value is ::true.
- ::CU_COREDUMP_LIGHTWEIGHT: Bool where ::true means that any resulting coredumps
will not have a dump of GPU memory or non-reloc ELF images. The default value is
::false.
- ::CU_COREDUMP_ENABLE_USER_TRIGGER: Bool where ::true means that a coredump can be
created by writing to the system pipe specified by ::CU_COREDUMP_PIPE. The default
value is ::false.
- ::CU_COREDUMP_FILE: String of up to 1023 characters that defines the location where
any coredumps generated by this context will be written. The default value is
::core.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA applications and ::PID is the process ID of the CUDA application.
- ::CU_COREDUMP_PIPE: String of up to 1023 characters that defines the name of the pipe
that will be monitored if user-triggered coredumps are enabled. The default value is
::corepipe.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA application and ::PID is the process ID of the CUDA application.
\param attrib - The enum defining which value to fetch.
\param value - void* containing the requested data.
\param size - The size of the memory region \p value points to.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuCoredumpGetAttribute,
::cuCoredumpSetAttribute,
::cuCoredumpSetAttributeGlobal*/
fn cuCoredumpGetAttributeGlobal(
attrib: cuda_types::CUcoredumpSettings,
value: *mut ::core::ffi::c_void,
size: *mut usize,
) -> cuda_types::CUresult;
/** \brief Allows caller to set a coredump attribute value for the current context
This function should be considered an alternate interface to the CUDA-GDB environment
variables defined in this document: https://docs.nvidia.com/cuda/cuda-gdb/index.html#gpu-coredump
An important design decision to note is that any coredump environment variable values
set before CUDA initializes will take permanent precedence over any values set with this
this function. This decision was made to ensure no change in behavior for any users that
may be currently using these variables to get coredumps.
\p *value shall contain the requested value specified by \p set. It is up to the caller
to ensure that the data type and size of \p *value matches the request.
If the caller calls this function with \p *value equal to NULL, the size of the memory
region (in bytes) expected for \p set will be placed in \p size.
/note This function will return ::CUDA_ERROR_NOT_SUPPORTED if the caller attempts to set
::CU_COREDUMP_ENABLE_ON_EXCEPTION on a GPU of with Compute Capability < 6.0. ::cuCoredumpSetAttributeGlobal
works on those platforms as an alternative.
/note ::CU_COREDUMP_ENABLE_USER_TRIGGER and ::CU_COREDUMP_PIPE cannot be set on a per-context basis.
The supported attributes are:
- ::CU_COREDUMP_ENABLE_ON_EXCEPTION: Bool where ::true means that GPU exceptions from
this context will create a coredump at the location specified by ::CU_COREDUMP_FILE.
The default value is ::false.
- ::CU_COREDUMP_TRIGGER_HOST: Bool where ::true means that the host CPU will
also create a coredump. The default value is ::true.
- ::CU_COREDUMP_LIGHTWEIGHT: Bool where ::true means that any resulting coredumps
will not have a dump of GPU memory or non-reloc ELF images. The default value is
::false.
- ::CU_COREDUMP_FILE: String of up to 1023 characters that defines the location where
any coredumps generated by this context will be written. The default value is
::core.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA applications and ::PID is the process ID of the CUDA application.
\param attrib - The enum defining which value to set.
\param value - void* containing the requested data.
\param size - The size of the memory region \p value points to.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_PERMITTED,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_CONTEXT_IS_DESTROYED,
::CUDA_ERROR_NOT_SUPPORTED
\sa
::cuCoredumpGetAttributeGlobal,
::cuCoredumpGetAttribute,
::cuCoredumpSetAttributeGlobal*/
fn cuCoredumpSetAttribute(
attrib: cuda_types::CUcoredumpSettings,
value: *mut ::core::ffi::c_void,
size: *mut usize,
) -> cuda_types::CUresult;
/** \brief Allows caller to set a coredump attribute value globally
This function should be considered an alternate interface to the CUDA-GDB environment
variables defined in this document: https://docs.nvidia.com/cuda/cuda-gdb/index.html#gpu-coredump
An important design decision to note is that any coredump environment variable values
set before CUDA initializes will take permanent precedence over any values set with this
this function. This decision was made to ensure no change in behavior for any users that
may be currently using these variables to get coredumps.
\p *value shall contain the requested value specified by \p set. It is up to the caller
to ensure that the data type and size of \p *value matches the request.
If the caller calls this function with \p *value equal to NULL, the size of the memory
region (in bytes) expected for \p set will be placed in \p size.
The supported attributes are:
- ::CU_COREDUMP_ENABLE_ON_EXCEPTION: Bool where ::true means that GPU exceptions from
this context will create a coredump at the location specified by ::CU_COREDUMP_FILE.
The default value is ::false.
- ::CU_COREDUMP_TRIGGER_HOST: Bool where ::true means that the host CPU will
also create a coredump. The default value is ::true.
- ::CU_COREDUMP_LIGHTWEIGHT: Bool where ::true means that any resulting coredumps
will not have a dump of GPU memory or non-reloc ELF images. The default value is
::false.
- ::CU_COREDUMP_ENABLE_USER_TRIGGER: Bool where ::true means that a coredump can be
created by writing to the system pipe specified by ::CU_COREDUMP_PIPE. The default
value is ::false.
- ::CU_COREDUMP_FILE: String of up to 1023 characters that defines the location where
any coredumps generated by this context will be written. The default value is
::core.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine running
the CUDA applications and ::PID is the process ID of the CUDA application.
- ::CU_COREDUMP_PIPE: String of up to 1023 characters that defines the name of the pipe
that will be monitored if user-triggered coredumps are enabled. This value may not be
changed after ::CU_COREDUMP_ENABLE_USER_TRIGGER is set to ::true. The default
value is ::corepipe.cuda.HOSTNAME.PID where ::HOSTNAME is the host name of the machine
running the CUDA application and ::PID is the process ID of the CUDA application.
\param attrib - The enum defining which value to set.
\param value - void* containing the requested data.
\param size - The size of the memory region \p value points to.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_PERMITTED
\sa
::cuCoredumpGetAttribute,
::cuCoredumpGetAttributeGlobal,
::cuCoredumpSetAttribute*/
fn cuCoredumpSetAttributeGlobal(
attrib: cuda_types::CUcoredumpSettings,
value: *mut ::core::ffi::c_void,
size: *mut usize,
) -> cuda_types::CUresult;
/// @}
fn cuGetExportTable(
ppExportTable: *mut *const ::core::ffi::c_void,
pExportTableId: *const cuda_types::CUuuid,
) -> cuda_types::CUresult;
/** \brief Creates a green context with a specified set of resources.
This API creates a green context with the resources specified in the descriptor \p desc and
returns it in the handle represented by \p phCtx. This API will retain the primary context on device \p dev,
which will is released when the green context is destroyed. It is advised to have the primary context active
before calling this API to avoid the heavy cost of triggering primary context initialization and
deinitialization multiple times.
The API does not set the green context current. In order to set it current, you need to explicitly set it current
by first converting the green context to a CUcontext using ::cuCtxFromGreenCtx and subsequently calling
::cuCtxSetCurrent / ::cuCtxPushCurrent. It should be noted that a green context can be current to only one
thread at a time. There is no internal synchronization to make API calls accessing the same green context
from multiple threads work.
Note: The API is not supported on 32-bit platforms.
\param phCtx - Pointer for the output handle to the green context
\param desc - Descriptor generated via ::cuDevResourceGenerateDesc which contains the set of resources to be used
\param dev - Device on which to create the green context.
\param flags - One of the supported green context creation flags. \p CU_GREEN_CTX_DEFAULT_STREAM is required.
The supported flags are:
- \p CU_GREEN_CTX_DEFAULT_STREAM : Creates a default stream to use inside the green context. Required.
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_NOT_SUPPORTED,
::CUDA_ERROR_OUT_OF_MEMORY
\sa
::cuGreenCtxDestroy,
::cuCtxFromGreenCtx,
::cuCtxSetCurrent,
::cuCtxPushCurrent,
::cuDevResourceGenerateDesc,
::cuDevicePrimaryCtxRetain,
::cuCtxCreate,
::cuCtxCreate_v3*/
fn cuGreenCtxCreate(
phCtx: *mut cuda_types::CUgreenCtx,
desc: cuda_types::CUdevResourceDesc,
dev: cuda_types::CUdevice,
flags: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Destroys a green context
Destroys the green context, releasing the primary context of the device that this green context was created for.
Any resources provisioned for this green context (that were initially available via the resource descriptor)
are released as well.
\param hCtx - Green context to be destroyed
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_CONTEXT_IS_DESTROYED
\sa
::cuGreenCtxCreate,
::cuCtxDestroy*/
fn cuGreenCtxDestroy(hCtx: cuda_types::CUgreenCtx) -> cuda_types::CUresult;
/** \brief Converts a green context into the primary context
The API converts a green context into the primary context returned in \p pContext. It is important
to note that the converted context \p pContext is a normal primary context but with
the resources of the specified green context \p hCtx. Once converted, it can then
be used to set the context current with ::cuCtxSetCurrent or with any of the CUDA APIs
that accept a CUcontext parameter.
Users are expected to call this API before calling any CUDA APIs that accept a
CUcontext. Failing to do so will result in the APIs returning ::CUDA_ERROR_INVALID_CONTEXT.
\param pContext Returned primary context with green context resources
\param hCtx Green context to convert
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuGreenCtxCreate*/
fn cuCtxFromGreenCtx(
pContext: *mut cuda_types::CUcontext,
hCtx: cuda_types::CUgreenCtx,
) -> cuda_types::CUresult;
/** \brief Get device resources
Get the \p type resources available to the \p device.
This may often be the starting point for further partitioning or configuring of resources.
Note: The API is not supported on 32-bit platforms.
\param device - Device to get resource for
\param resource - Output pointer to a CUdevResource structure
\param type - Type of resource to retrieve
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_RESOURCE_TYPE,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_DEVICE
\sa
::cuDevResourceGenerateDesc*/
fn cuDeviceGetDevResource(
device: cuda_types::CUdevice,
resource: *mut cuda_types::CUdevResource,
type_: cuda_types::CUdevResourceType,
) -> cuda_types::CUresult;
/** \brief Get context resources
Get the \p type resources available to the context represented by \p hCtx
\param hCtx - Context to get resource for
Note: The API is not supported on 32-bit platforms.
\param resource - Output pointer to a CUdevResource structure
\param type - Type of resource to retrieve
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_RESOURCE_TYPE,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_CONTEXT
\sa
::cuDevResourceGenerateDesc*/
fn cuCtxGetDevResource(
hCtx: cuda_types::CUcontext,
resource: *mut cuda_types::CUdevResource,
type_: cuda_types::CUdevResourceType,
) -> cuda_types::CUresult;
/** \brief Get green context resources
Get the \p type resources available to the green context represented by \p hCtx
\param hCtx - Green context to get resource for
\param resource - Output pointer to a CUdevResource structure
\param type - Type of resource to retrieve
\return
::CUDA_SUCCESS
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_RESOURCE_TYPE,
::CUDA_ERROR_INVALID_VALUE
\sa
::cuDevResourceGenerateDesc*/
fn cuGreenCtxGetDevResource(
hCtx: cuda_types::CUgreenCtx,
resource: *mut cuda_types::CUdevResource,
type_: cuda_types::CUdevResourceType,
) -> cuda_types::CUresult;
/** \brief Splits \p CU_DEV_RESOURCE_TYPE_SM resources.
Splits \p CU_DEV_RESOURCE_TYPE_SM resources into \p nbGroups, adhering to the minimum SM count specified in \p minCount
and the usage flags in \p useFlags. If \p result is NULL, the API simulates a split and provides the amount of groups that
would be created in \p nbGroups. Otherwise, \p nbGroups must point to the amount of elements in \p result and on return,
the API will overwrite \p nbGroups with the amount actually created. The groups are written to the array in \p result.
\p nbGroups can be less than the total amount if a smaller number of groups is needed.
This API is used to spatially partition the input resource. The input resource needs to come from one of
::cuDeviceGetDevResource, ::cuCtxGetDevResource, or ::cuGreenCtxGetDevResource.
A limitation of the API is that the output results cannot be split again without
first creating a descriptor and a green context with that descriptor.
When creating the groups, the API will take into account the performance and functional characteristics of the
input resource, and guarantee a split that will create a disjoint set of symmetrical partitions. This may lead to less groups created
than purely dividing the total SM count by the \p minCount due to cluster requirements or
alignment and granularity requirements for the minCount.
The \p remainder set, might not have the same functional or performance guarantees as the groups in \p result.
Its use should be carefully planned and future partitions of the \p remainder set are discouraged.
A successful API call must either have:
- A valid array of \p result pointers of size passed in \p nbGroups, with \p Input of type \p CU_DEV_RESOURCE_TYPE_SM.
Value of \p minCount must be between 0 and the SM count specified in \p input. \p remaining and \p useFlags are optional.
- NULL passed in for \p result, with a valid integer pointer in \p nbGroups and \p Input of type \p CU_DEV_RESOURCE_TYPE_SM.
Value of \p minCount must be between 0 and the SM count specified in \p input.
This queries the number of groups that would be created by the API.
Note: The API is not supported on 32-bit platforms.
\param result - Output array of \p CUdevResource resources. Can be NULL to query the number of groups.
\param nbGroups - This is a pointer, specifying the number of groups that would be or should be created as described below.
\param input - Input SM resource to be split. Must be a valid \p CU_DEV_RESOURCE_TYPE_SM resource.
\param remaining - If the input resource cannot be cleanly split among \p nbGroups, the remaining is placed in here.
Can be ommitted (NULL) if the user does not need the remaining set.
\param useFlags - Flags specifying how these partitions are used or which constraints to abide by when splitting the input.
\param minCount - Minimum number of SMs required
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_DEVICE,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_RESOURCE_TYPE,
::CUDA_ERROR_INVALID_RESOURCE_CONFIGURATION
\sa
::cuGreenCtxGetDevResource,
::cuCtxGetDevResource,
::cuDeviceGetDevResource*/
fn cuDevSmResourceSplitByCount(
result: *mut cuda_types::CUdevResource,
nbGroups: *mut ::core::ffi::c_uint,
input: *const cuda_types::CUdevResource,
remaining: *mut cuda_types::CUdevResource,
useFlags: ::core::ffi::c_uint,
minCount: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Generate a resource descriptor
Generates a resource descriptor with the set of resources specified in \p resources.
The generated resource descriptor is necessary for the creation of green contexts via the ::cuGreenCtxCreate API.
The API expects \p nbResources == 1, as there is only one type of resource and merging the same
types of resource is currently not supported.
Note: The API is not supported on 32-bit platforms.
\param phDesc - Output descriptor
\param resources - Array of resources to be included in the descriptor
\param nbResources - Number of resources passed in \p resources
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_VALUE,
::CUDA_ERROR_INVALID_RESOURCE_TYPE,
::CUDA_ERROR_INVALID_RESOURCE_CONFIGURATION
\sa
::cuDevSmResourceSplitByCount*/
fn cuDevResourceGenerateDesc(
phDesc: *mut cuda_types::CUdevResourceDesc,
resources: *mut cuda_types::CUdevResource,
nbResources: ::core::ffi::c_uint,
) -> cuda_types::CUresult;
/** \brief Records an event.
Captures in \phEvent all the activities of the green context of \phCtx
at the time of this call. \phEvent and \phCtx must be from the same
CUDA context. Calls such as ::cuEventQuery() or ::cuGreenCtxWaitEvent() will
then examine or wait for completion of the work that was captured. Uses of
\p hCtx after this call do not modify \p hEvent.
\note The API will return an error if the specified green context \p hCtx
has a stream in the capture mode. In such a case, the call will invalidate
all the conflicting captures.
\param hCtx - Green context to record event for
\param hEvent - Event to record
\return
::CUDA_SUCCESS
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE
\sa
::cuGreenCtxWaitEvent,
::cuEventRecord*/
fn cuGreenCtxRecordEvent(
hCtx: cuda_types::CUgreenCtx,
hEvent: cuda_types::CUevent,
) -> cuda_types::CUresult;
/** \brief Make a green context wait on an event
Makes all future work submitted to green context \phCtx wait for all work
captured in \phEvent. The synchronization will be performed on the device
and will not block the calling CPU thread. See ::cuGreenCtxRecordEvent()
for details on what is captured by an event.
\note The API will return an error and invalidate the capture if the specified
event \p hEvent is part of an ongoing capture sequence.
\param hCtx - Green context to wait
\param hEvent - Event to wait on (may not be NULL)
\return
::CUDA_SUCCESS,
::CUDA_ERROR_DEINITIALIZED,
::CUDA_ERROR_NOT_INITIALIZED,
::CUDA_ERROR_INVALID_CONTEXT,
::CUDA_ERROR_INVALID_HANDLE
\sa
::cuGreenCtxRecordEvent,
::cuStreamWaitEvent*/
fn cuGreenCtxWaitEvent(
hCtx: cuda_types::CUgreenCtx,
hEvent: cuda_types::CUevent,
) -> cuda_types::CUresult;
/** \brief Query the green context associated with a stream
Returns the CUDA green context that the stream is associated with, or NULL if the stream
is not associated with any green context.
The stream handle \p hStream can refer to any of the following: