608 lines
23 KiB
Python
608 lines
23 KiB
Python
"""
|
|
Enum values for CUDA driver. Information about the values
|
|
can be found on the official NVIDIA documentation website.
|
|
ref: https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html
|
|
anchor: #group__CUDA__TYPES
|
|
"""
|
|
|
|
|
|
# Error codes
|
|
|
|
CUDA_SUCCESS = 0
|
|
CUDA_ERROR_INVALID_VALUE = 1
|
|
CUDA_ERROR_OUT_OF_MEMORY = 2
|
|
CUDA_ERROR_NOT_INITIALIZED = 3
|
|
CUDA_ERROR_DEINITIALIZED = 4
|
|
CUDA_ERROR_PROFILER_DISABLED = 5
|
|
CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6
|
|
CUDA_ERROR_PROFILER_ALREADY_STARTED = 7
|
|
CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8
|
|
CUDA_ERROR_STUB_LIBRARY = 34
|
|
CUDA_ERROR_DEVICE_UNAVAILABLE = 46
|
|
CUDA_ERROR_NO_DEVICE = 100
|
|
CUDA_ERROR_INVALID_DEVICE = 101
|
|
CUDA_ERROR_DEVICE_NOT_LICENSED = 102
|
|
CUDA_ERROR_INVALID_IMAGE = 200
|
|
CUDA_ERROR_INVALID_CONTEXT = 201
|
|
CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202
|
|
CUDA_ERROR_MAP_FAILED = 205
|
|
CUDA_ERROR_UNMAP_FAILED = 206
|
|
CUDA_ERROR_ARRAY_IS_MAPPED = 207
|
|
CUDA_ERROR_ALREADY_MAPPED = 208
|
|
CUDA_ERROR_NO_BINARY_FOR_GPU = 209
|
|
CUDA_ERROR_ALREADY_ACQUIRED = 210
|
|
CUDA_ERROR_NOT_MAPPED = 211
|
|
CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212
|
|
CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213
|
|
CUDA_ERROR_ECC_UNCORRECTABLE = 214
|
|
CUDA_ERROR_UNSUPPORTED_LIMIT = 215
|
|
CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216
|
|
CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217
|
|
CUDA_ERROR_INVALID_PTX = 218
|
|
CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219
|
|
CUDA_ERROR_NVLINK_UNCORRECTABLE = 220
|
|
CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221
|
|
CUDA_ERROR_UNSUPPORTED_PTX_VERSION = 222
|
|
CUDA_ERROR_JIT_COMPILATION_DISABLED = 223
|
|
CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY = 224
|
|
CUDA_ERROR_UNSUPPORTED_DEVSIDE_SYNC = 225
|
|
CUDA_ERROR_INVALID_SOURCE = 300
|
|
CUDA_ERROR_FILE_NOT_FOUND = 301
|
|
CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302
|
|
CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303
|
|
CUDA_ERROR_OPERATING_SYSTEM = 304
|
|
CUDA_ERROR_INVALID_HANDLE = 400
|
|
CUDA_ERROR_ILLEGAL_STATE = 401
|
|
CUDA_ERROR_NOT_FOUND = 500
|
|
CUDA_ERROR_NOT_READY = 600
|
|
CUDA_ERROR_LAUNCH_FAILED = 700
|
|
CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701
|
|
CUDA_ERROR_LAUNCH_TIMEOUT = 702
|
|
CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703
|
|
CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704
|
|
CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705
|
|
CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708
|
|
CUDA_ERROR_CONTEXT_IS_DESTROYED = 709
|
|
CUDA_ERROR_ASSERT = 710
|
|
CUDA_ERROR_TOO_MANY_PEERS = 711
|
|
CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712
|
|
CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713
|
|
CUDA_ERROR_HARDWARE_STACK_ERROR = 714
|
|
CUDA_ERROR_ILLEGAL_INSTRUCTION = 715
|
|
CUDA_ERROR_MISALIGNED_ADDRESS = 716
|
|
CUDA_ERROR_INVALID_ADDRESS_SPACE = 717
|
|
CUDA_ERROR_INVALID_PC = 718
|
|
CUDA_ERROR_LAUNCH_FAILED = 719
|
|
CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720
|
|
CUDA_ERROR_NOT_PERMITTED = 800
|
|
CUDA_ERROR_NOT_SUPPORTED = 801
|
|
CUDA_ERROR_SYSTEM_NOT_READY = 802
|
|
CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803
|
|
CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804
|
|
CUDA_ERROR_MPS_CONNECTION_FAILED = 805
|
|
CUDA_ERROR_MPS_RPC_FAILURE = 806
|
|
CUDA_ERROR_MPS_SERVER_NOT_READY = 807
|
|
CUDA_ERROR_MPS_MAX_CLIENTS_REACHED = 808
|
|
CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED = 809
|
|
CUDA_ERROR_MPS_CLIENT_TERMINATED = 810
|
|
CUDA_ERROR_CDP_NOT_SUPPORTED = 811
|
|
CUDA_ERROR_CDP_VERSION_MISMATCH = 812
|
|
CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900
|
|
CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901
|
|
CUDA_ERROR_STREAM_CAPTURE_MERGE = 902
|
|
CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903
|
|
CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904
|
|
CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905
|
|
CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906
|
|
CUDA_ERROR_CAPTURED_EVENT = 907
|
|
CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908
|
|
CUDA_ERROR_TIMEOUT = 909
|
|
CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = 910
|
|
CUDA_ERROR_EXTERNAL_DEVICE = 911
|
|
CUDA_ERROR_INVALID_CLUSTER_SIZE = 912
|
|
CUDA_ERROR_UNKNOWN = 999
|
|
|
|
|
|
# Function cache configurations
|
|
|
|
# no preference for shared memory or L1 (default)
|
|
CU_FUNC_CACHE_PREFER_NONE = 0x00
|
|
# prefer larger shared memory and smaller L1 cache
|
|
CU_FUNC_CACHE_PREFER_SHARED = 0x01
|
|
# prefer larger L1 cache and smaller shared memory
|
|
CU_FUNC_CACHE_PREFER_L1 = 0x02
|
|
# prefer equal sized L1 cache and shared memory
|
|
CU_FUNC_CACHE_PREFER_EQUAL = 0x03
|
|
|
|
|
|
# Context creation flags
|
|
|
|
# Automatic scheduling
|
|
CU_CTX_SCHED_AUTO = 0x00
|
|
# Set spin as default scheduling
|
|
CU_CTX_SCHED_SPIN = 0x01
|
|
# Set yield as default scheduling
|
|
CU_CTX_SCHED_YIELD = 0x02
|
|
# Set blocking synchronization as default scheduling
|
|
CU_CTX_SCHED_BLOCKING_SYNC = 0x04
|
|
|
|
CU_CTX_SCHED_MASK = 0x07
|
|
# Support mapped pinned allocations
|
|
# This flag was deprecated as of CUDA 11.0 and it no longer has effect.
|
|
# All contexts as of CUDA 3.2 behave as though the flag is enabled.
|
|
CU_CTX_MAP_HOST = 0x08
|
|
# Keep local memory allocation after launch
|
|
CU_CTX_LMEM_RESIZE_TO_MAX = 0x10
|
|
# Trigger coredumps from exceptions in this context
|
|
CU_CTX_COREDUMP_ENABLE = 0x20
|
|
# Enable user pipe to trigger coredumps in this context
|
|
CU_CTX_USER_COREDUMP_ENABLE = 0x40
|
|
# Force synchronous blocking on cudaMemcpy/cudaMemset
|
|
CU_CTX_SYNC_MEMOPS = 0x80
|
|
|
|
CU_CTX_FLAGS_MASK = 0xff
|
|
|
|
|
|
# DEFINES
|
|
|
|
# If set, host memory is portable between CUDA contexts.
|
|
# Flag for cuMemHostAlloc()
|
|
CU_MEMHOSTALLOC_PORTABLE = 0x01
|
|
|
|
# If set, host memory is mapped into CUDA address space and
|
|
# cuMemHostGetDevicePointer() may be called on the host pointer.
|
|
# Flag for cuMemHostAlloc()
|
|
CU_MEMHOSTALLOC_DEVICEMAP = 0x02
|
|
|
|
# If set, host memory is allocated as write-combined - fast to write,
|
|
# faster to DMA, slow to read except via SSE4 streaming load instruction
|
|
# (MOVNTDQA).
|
|
# Flag for cuMemHostAlloc()
|
|
CU_MEMHOSTALLOC_WRITECOMBINED = 0x04
|
|
|
|
|
|
# If set, host memory is portable between CUDA contexts.
|
|
# Flag for cuMemHostRegister()
|
|
CU_MEMHOSTREGISTER_PORTABLE = 0x01
|
|
|
|
# If set, host memory is mapped into CUDA address space and
|
|
# cuMemHostGetDevicePointer() may be called on the host pointer.
|
|
# Flag for cuMemHostRegister()
|
|
CU_MEMHOSTREGISTER_DEVICEMAP = 0x02
|
|
|
|
# If set, the passed memory pointer is treated as pointing to some
|
|
# memory-mapped I/O space, e.g. belonging to a third-party PCIe device.
|
|
# On Windows the flag is a no-op. On Linux that memory is marked
|
|
# as non cache-coherent for the GPU and is expected
|
|
# to be physically contiguous. It may return CUDA_ERROR_NOT_PERMITTED
|
|
# if run as an unprivileged user, CUDA_ERROR_NOT_SUPPORTED on older
|
|
# Linux kernel versions. On all other platforms, it is not supported
|
|
# and CUDA_ERROR_NOT_SUPPORTED is returned.
|
|
# Flag for cuMemHostRegister()
|
|
CU_MEMHOSTREGISTER_IOMEMORY = 0x04
|
|
|
|
# If set, the passed memory pointer is treated as pointing to memory
|
|
# that is considered read-only by the device. On platforms without
|
|
# CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES,
|
|
# this flag is required in order to register memory mapped
|
|
# to the CPU as read-only. Support for the use of this flag can be
|
|
# queried from the device attribute
|
|
# CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED.
|
|
# Using this flag with a current context associated with a device
|
|
# that does not have this attribute set will cause cuMemHostRegister
|
|
# to error with CUDA_ERROR_NOT_SUPPORTED.
|
|
CU_MEMHOSTREGISTER_READ_ONLY = 0x08
|
|
|
|
|
|
# CUDA Mem Attach Flags
|
|
|
|
# If set, managed memory is accessible from all streams on all devices.
|
|
CU_MEM_ATTACH_GLOBAL = 0x01
|
|
|
|
# If set on a platform where the device attribute
|
|
# cudaDevAttrConcurrentManagedAccess is zero, then managed memory is
|
|
# only accessible on the host (unless explicitly attached to a stream
|
|
# with cudaStreamAttachMemAsync, in which case it can be used in kernels
|
|
# launched on that stream).
|
|
CU_MEM_ATTACH_HOST = 0x02
|
|
|
|
# If set on a platform where the device attribute
|
|
# cudaDevAttrConcurrentManagedAccess is zero, then managed memory accesses
|
|
# on the associated device must only be from a single stream.
|
|
CU_MEM_ATTACH_SINGLE = 0x04
|
|
|
|
|
|
# Event creation flags
|
|
|
|
# Default event flag
|
|
CU_EVENT_DEFAULT = 0x0
|
|
# Event uses blocking synchronization
|
|
CU_EVENT_BLOCKING_SYNC = 0x1
|
|
# Event will not record timing data
|
|
CU_EVENT_DISABLE_TIMING = 0x2
|
|
# Event is suitable for interprocess use. CU_EVENT_DISABLE_TIMING must be set
|
|
CU_EVENT_INTERPROCESS = 0x4
|
|
|
|
|
|
# Pointer information
|
|
|
|
# The CUcontext on which a pointer was allocated or registered
|
|
CU_POINTER_ATTRIBUTE_CONTEXT = 1
|
|
# The CUmemorytype describing the physical location of a pointer
|
|
CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2
|
|
# The address at which a pointer's memory may be accessed on the device
|
|
CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3
|
|
# The address at which a pointer's memory may be accessed on the host
|
|
CU_POINTER_ATTRIBUTE_HOST_POINTER = 4
|
|
# A pair of tokens for use with the nv-p2p.h Linux kernel interface
|
|
CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5
|
|
# Synchronize every synchronous memory operation initiated on this region
|
|
CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6
|
|
# A process-wide unique ID for an allocated memory region
|
|
CU_POINTER_ATTRIBUTE_BUFFER_ID = 7
|
|
# Indicates if the pointer points to managed memory
|
|
CU_POINTER_ATTRIBUTE_IS_MANAGED = 8
|
|
# A device ordinal of a device on which a pointer was allocated or registered
|
|
CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9
|
|
# 1 if this pointer maps to an allocation
|
|
# that is suitable for cudaIpcGetMemHandle, 0 otherwise
|
|
CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = 10
|
|
# Starting address for this requested pointer
|
|
CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11
|
|
# Size of the address range for this requested pointer
|
|
CU_POINTER_ATTRIBUTE_RANGE_SIZE = 12
|
|
# 1 if this pointer is in a valid address range
|
|
# that is mapped to a backing allocation, 0 otherwise
|
|
CU_POINTER_ATTRIBUTE_MAPPED = 13
|
|
# Bitmask of allowed CUmemAllocationHandleType for this allocation
|
|
CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14
|
|
# 1 if the memory this pointer is referencing
|
|
# can be used with the GPUDirect RDMA API
|
|
CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15
|
|
# Returns the access flags the device associated
|
|
# with the current context has on the corresponding
|
|
# memory referenced by the pointer given
|
|
CU_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16
|
|
# Returns the mempool handle for the allocation
|
|
# if it was allocated from a mempool. Otherwise returns NULL
|
|
CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17
|
|
# Size of the actual underlying mapping that the pointer belongs to
|
|
CU_POINTER_ATTRIBUTE_MAPPING_SIZE = 18
|
|
# The start address of the mapping that the pointer belongs to
|
|
CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR = 19
|
|
# A process-wide unique id corresponding to the
|
|
# physical allocation the pointer belongs to
|
|
CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID = 20
|
|
|
|
|
|
# Memory types
|
|
|
|
# Host memory
|
|
CU_MEMORYTYPE_HOST = 0x01
|
|
# Device memory
|
|
CU_MEMORYTYPE_DEVICE = 0x02
|
|
# Array memory
|
|
CU_MEMORYTYPE_ARRAY = 0x03
|
|
# Unified device or host memory
|
|
CU_MEMORYTYPE_UNIFIED = 0x04
|
|
|
|
|
|
# Device code formats
|
|
|
|
# Compiled device-class-specific device code
|
|
# Applicable options: none
|
|
CU_JIT_INPUT_CUBIN = 0
|
|
|
|
# PTX source code
|
|
# Applicable options: PTX compiler options
|
|
CU_JIT_INPUT_PTX = 1
|
|
|
|
# Bundle of multiple cubins and/or PTX of some device code
|
|
# Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY
|
|
CU_JIT_INPUT_FATBINARY = 2
|
|
|
|
# Host object with embedded device code
|
|
# Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY
|
|
CU_JIT_INPUT_OBJECT = 3
|
|
|
|
# Archive of host objects with embedded device code
|
|
# Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY
|
|
CU_JIT_INPUT_LIBRARY = 4
|
|
|
|
CU_JIT_NUM_INPUT_TYPES = 6
|
|
|
|
|
|
# Online compiler and linker options
|
|
|
|
# Max number of registers that a thread may use.
|
|
# Option type: unsigned int
|
|
# Applies to: compiler only
|
|
CU_JIT_MAX_REGISTERS = 0
|
|
|
|
# IN: Specifies minimum number of threads per block to target compilation
|
|
# for
|
|
# OUT: Returns the number of threads the compiler actually targeted.
|
|
# This restricts the resource utilization fo the compiler (e.g. max
|
|
# registers) such that a block with the given number of threads should be
|
|
# able to launch based on register limitations. Note, this option does not
|
|
# currently take into account any other resource limitations, such as
|
|
# shared memory utilization.
|
|
# Cannot be combined with ::CU_JIT_TARGET.
|
|
# Option type: unsigned int
|
|
# Applies to: compiler only
|
|
CU_JIT_THREADS_PER_BLOCK = 1
|
|
|
|
# Overwrites the option value with the total wall clock time, in
|
|
# milliseconds, spent in the compiler and linker
|
|
# Option type: float
|
|
# Applies to: compiler and linker
|
|
CU_JIT_WALL_TIME = 2
|
|
|
|
# Pointer to a buffer in which to print any log messages
|
|
# that are informational in nature (the buffer size is specified via
|
|
# option ::CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES)
|
|
# Option type: char *
|
|
# Applies to: compiler and linker
|
|
CU_JIT_INFO_LOG_BUFFER = 3
|
|
|
|
# IN: Log buffer size in bytes. Log messages will be capped at this size
|
|
# (including null terminator)
|
|
# OUT: Amount of log buffer filled with messages
|
|
# Option type: unsigned int
|
|
# Applies to: compiler and linker
|
|
CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4
|
|
|
|
# Pointer to a buffer in which to print any log messages that
|
|
# reflect errors (the buffer size is specified via option
|
|
# ::CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES)
|
|
# Option type: char *
|
|
# Applies to: compiler and linker
|
|
CU_JIT_ERROR_LOG_BUFFER = 5
|
|
|
|
# IN: Log buffer size in bytes. Log messages will be capped at this size
|
|
# (including null terminator)
|
|
# OUT: Amount of log buffer filled with messages
|
|
# Option type: unsigned int
|
|
# Applies to: compiler and linker
|
|
CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6
|
|
|
|
# Level of optimizations to apply to generated code (0 - 4), with 4
|
|
# being the default and highest level of optimizations.
|
|
# Option type: unsigned int
|
|
# Applies to: compiler only
|
|
CU_JIT_OPTIMIZATION_LEVEL = 7
|
|
|
|
# No option value required. Determines the target based on the current
|
|
# attached context (default)
|
|
# Option type: No option value needed
|
|
# Applies to: compiler and linker
|
|
CU_JIT_TARGET_FROM_CUCONTEXT = 8
|
|
|
|
# Target is chosen based on supplied ::CUjit_target. Cannot be
|
|
# combined with ::CU_JIT_THREADS_PER_BLOCK.
|
|
# Option type: unsigned int for enumerated type ::CUjit_target
|
|
# Applies to: compiler and linker
|
|
CU_JIT_TARGET = 9
|
|
|
|
# Specifies choice of fallback strategy if matching cubin is not found.
|
|
# Choice is based on supplied ::CUjit_fallback.
|
|
# Option type: unsigned int for enumerated type ::CUjit_fallback
|
|
# Applies to: compiler only
|
|
CU_JIT_FALLBACK_STRATEGY = 10
|
|
|
|
# Specifies whether to create debug information in output (-g)
|
|
# (0: false, default)
|
|
# Option type: int
|
|
# Applies to: compiler and linker
|
|
CU_JIT_GENERATE_DEBUG_INFO = 11
|
|
|
|
# Generate verbose log messages (0: false, default)
|
|
# Option type: int
|
|
# Applies to: compiler and linker
|
|
CU_JIT_LOG_VERBOSE = 12
|
|
|
|
# Generate line number information (-lineinfo) (0: false, default)
|
|
# Option type: int
|
|
# Applies to: compiler only
|
|
CU_JIT_GENERATE_LINE_INFO = 13
|
|
|
|
# Specifies whether to enable caching explicitly (-dlcm)
|
|
# Choice is based on supplied ::CUjit_cacheMode_enum.
|
|
# Option type: unsigned int for enumerated type ::CUjit_cacheMode_enum
|
|
# Applies to: compiler only
|
|
CU_JIT_CACHE_MODE = 14
|
|
|
|
|
|
# CUfunction_attribute
|
|
|
|
# The maximum number of threads per block, beyond which a launch of the
|
|
# function would fail. This number depends on both the function and the
|
|
# device on which the function is currently loaded.
|
|
CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0
|
|
|
|
# The size in bytes of statically-allocated shared memory required by
|
|
# this function. This does not include dynamically-allocated shared
|
|
# memory requested by the user at runtime.
|
|
CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1
|
|
|
|
# The size in bytes of user-allocated constant memory required by this
|
|
# function.
|
|
CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2
|
|
|
|
# The size in bytes of local memory used by each thread of this function.
|
|
CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3
|
|
|
|
# The number of registers used by each thread of this function.
|
|
CU_FUNC_ATTRIBUTE_NUM_REGS = 4
|
|
|
|
# The PTX virtual architecture version for which the function was
|
|
# compiled. This value is the major PTX version * 10 + the minor PTX
|
|
# version, so a PTX version 1.3 function would return the value 13.
|
|
# Note that this may return the undefined value of 0 for cubins
|
|
# compiled prior to CUDA 3.0.
|
|
CU_FUNC_ATTRIBUTE_PTX_VERSION = 5
|
|
|
|
# The binary architecture version for which the function was compiled.
|
|
# This value is the major binary version * 10 + the minor binary version,
|
|
# so a binary version 1.3 function would return the value 13. Note that
|
|
# this will return a value of 10 for legacy cubins that do not have a
|
|
# properly-encoded binary architecture version.
|
|
CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6
|
|
|
|
# The attribute to indicate whether the function has been compiled
|
|
# with user specified option "-Xptxas --dlcm=ca" set
|
|
CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7
|
|
|
|
# The maximum size in bytes of dynamically-allocated shared memory
|
|
# that can be used by this function. If the user-specified
|
|
# dynamic shared memory size is larger than this value,
|
|
# the launch will fail. See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8
|
|
|
|
# On devices where the L1 cache and shared memory use the same
|
|
# hardware resources, this sets the shared memory carveout preference,
|
|
# in percent of the total shared memory. Refer to
|
|
# CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR.
|
|
# This is only a hint, and the driver can choose a different ratio
|
|
# if required to execute the function.
|
|
# See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9
|
|
|
|
# If this attribute is set, the kernel must launch with a valid cluster
|
|
# size specified. See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET = 10
|
|
|
|
# The required cluster width in blocks. The values must either all be 0
|
|
# or all be positive. The validity of the cluster dimensions
|
|
# is otherwise checked at launch time. If the value is set during
|
|
# compile time, it cannot be set at runtime.
|
|
# Setting it at runtime will return CUDA_ERROR_NOT_PERMITTED.
|
|
# See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH = 11
|
|
|
|
# The required cluster height in blocks. The values must either all be 0
|
|
# or all be positive. The validity of the cluster dimensions
|
|
# is otherwise checked at launch time.If the value is set during
|
|
# compile time, it cannot be set at runtime.
|
|
# Setting it at runtime should return CUDA_ERROR_NOT_PERMITTED.
|
|
# See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT = 12
|
|
|
|
# The required cluster depth in blocks. The values must either all be 0
|
|
# or all be positive. The validity of the cluster dimensions
|
|
# is otherwise checked at launch time.If the value is set during
|
|
# compile time, it cannot be set at runtime.
|
|
# Setting it at runtime should return CUDA_ERROR_NOT_PERMITTED.
|
|
# See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH = 13
|
|
|
|
# Whether the function can be launched with non-portable cluster size.
|
|
# 1 is allowed, 0 is disallowed. A non-portable cluster size may only
|
|
# function on the specific SKUs the program is tested on.
|
|
# The launch might fail if the program is run on a different hardware platform.
|
|
# For more details refer to link :
|
|
# https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TYPES.html#group__CUDA__TYPES
|
|
CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED = 14
|
|
|
|
# The block scheduling policy of a function.
|
|
# The value type is CUclusterSchedulingPolicy / cudaClusterSchedulingPolicy.
|
|
# See cuFuncSetAttribute, cuKernelSetAttribute
|
|
CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = 15
|
|
|
|
|
|
# Device attributes
|
|
|
|
CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1
|
|
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2
|
|
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3
|
|
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4
|
|
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5
|
|
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6
|
|
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7
|
|
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8
|
|
CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9
|
|
CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10
|
|
CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11
|
|
CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12
|
|
CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13
|
|
CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14
|
|
CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15
|
|
CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16
|
|
CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17
|
|
CU_DEVICE_ATTRIBUTE_INTEGRATED = 18
|
|
CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19
|
|
CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_1D_WIDTH = 21
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_WIDTH = 22
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_HEIGHT = 23
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_WIDTH = 24
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_HEIGHT = 25
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_DEPTH = 26
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LAYERED_WIDTH = 27
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LAYERED_HEIGHT = 28
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LAYERED_LAYERS = 29
|
|
CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30
|
|
CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31
|
|
CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32
|
|
CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33
|
|
CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34
|
|
CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35
|
|
CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36
|
|
CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37
|
|
CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38
|
|
CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTI_PROCESSOR = 39
|
|
CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40
|
|
CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_1D_LAYERED_WIDTH = 42
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_1D_LAYERED_LAYERS = 43
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_GATHER_WIDTH = 45
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_GATHER_HEIGHT = 46
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_WIDTH_ALT = 47
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_HEIGHT_ALT = 48
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_3D_DEPTH_ALT = 49
|
|
CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50
|
|
CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_CUBEMAP_WIDTH = 52
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_CUBEMAP_LAYERED_WIDTH = 53
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_CUBEMAP_LAYERED_LAYERS = 54
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_1D_WIDTH = 55
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_2D_WIDTH = 56
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_2D_HEIGHT = 57
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_3D_WIDTH = 58
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_3D_HEIGHT = 59
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_3D_DEPTH = 60
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_1D_LAYERED_WIDTH = 61
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_1D_LAYERED_LAYERS = 62
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_2D_LAYERED_WIDTH = 63
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_2D_LAYERED_HEIGHT = 64
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_2D_LAYERED_LAYERS = 65
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_CUBEMAP_WIDTH = 66
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_CUBEMAP_LAYERED_WIDTH = 67
|
|
CU_DEVICE_ATTRIBUTE_MAX_SURFACE_CUBEMAP_LAYERED_LAYERS = 68
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_1D_LINEAR_WIDTH = 69
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LINEAR_WIDTH = 70
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LINEAR_HEIGHT = 71
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_LINEAR_PITCH = 72
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_2D_MIPMAPPED_WIDTH = 73
|
|
CU_DEVICE_ATTRIBUTE_MAX_MAX_TEXTURE_2D_MIPMAPPED_HEIGHT = 74
|
|
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75
|
|
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76
|
|
CU_DEVICE_ATTRIBUTE_MAX_TEXTURE_1D_MIPMAPPED_WIDTH = 77
|
|
CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78
|
|
CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79
|
|
CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80
|
|
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81
|
|
CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82
|
|
CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83
|
|
CU_DEVICE_ATTRIBUTE_IS_MULTI_GPU_BOARD = 84
|
|
CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85
|
|
CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86
|
|
CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87
|
|
CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88
|
|
CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89
|
|
CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90
|
|
CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91
|
|
CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = 95
|
|
CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = 96
|
|
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = 97
|