Sanitizer Callback API


Data Structures
struct	Sanitizer_BatchMemopData
	Data passed into a batch memop callback function. More...
struct	Sanitizer_CallbackData
	Data passed into a runtime or driver API callback function. More...
struct	Sanitizer_GraphExecData
	Data passed into a graphexec creation callback function. More...
struct	Sanitizer_GraphNodeLaunchData
	Data passed into a graph node launch callback function. More...
struct	Sanitizer_LaunchData
	Data passed into a launch callback function. More...
struct	Sanitizer_MemcpyData
	Data passed into a memcpy callback function. More...
struct	Sanitizer_MemsetData
	Data passed into a memset callback function. More...
struct	Sanitizer_ResourceArrayData
	Data passed into a CUDA array callback function. More...
struct	Sanitizer_ResourceContextData
	Data passed into a context resource callback function. More...
struct	Sanitizer_ResourceMemoryData
	Data passed into a memory resource callback function. More...
struct	Sanitizer_ResourceMempoolData
	Data passed into a mempool resource callback function. More...
struct	Sanitizer_ResourceModuleData
	Data passed into a module resource callback function. More...
struct	Sanitizer_ResourceStreamData
	Data passed into a stream resource callback function. More...
struct	Sanitizer_SynchronizeData
	Data passed into a synchronization callback function. More...
struct	Sanitizer_UvmData
	Data passed into a managed memory callback function. More...
Typedefs
typedef void(SANITIZERAPI *	Sanitizer_CallbackFunc )(void userdata, Sanitizer_CallbackDomain domain, Sanitizer_CallbackId cbid, const void cbdata)
	Function type for a callback.
typedef uint32_t	Sanitizer_CallbackId
	Callback ID.
typedef struct Sanitizer_Subscriber_st *	Sanitizer_SubscriberHandle
	A callback subscriber.
Enumerations
enum	Sanitizer_ApiCallbackSite { SANITIZER_API_ENTER = 0, SANITIZER_API_EXIT = 1 }
	Specifies the point in an API call that a callback is issued. More...
enum	Sanitizer_BatchMemopType { SANITIZER_BATCH_MEMOP_TYPE_32B = 0, SANITIZER_BATCH_MEMOP_TYPE_64B = 1 }
	Specifies the type of batch memory operation. More...
enum	Sanitizer_CallackIdSync { SANITIZER_CBID_SYNCHRONIZE_INVALID = 0, SANITIZER_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED = 1, SANITIZER_CBID_SYNCHRONIZE_CONTEXT_SYNCHRONIZED = 2 }
	Callback IDs for synchronization domain. More...
enum	Sanitizer_CallbackDomain { SANITIZER_CB_DOMAIN_INVALID = 0, SANITIZER_CB_DOMAIN_DRIVER_API = 1, SANITIZER_CB_DOMAIN_RUNTIME_API = 2, SANITIZER_CB_DOMAIN_RESOURCE = 3, SANITIZER_CB_DOMAIN_SYNCHRONIZE = 4, SANITIZER_CB_DOMAIN_LAUNCH = 5, SANITIZER_CB_DOMAIN_MEMCPY = 6, SANITIZER_CB_DOMAIN_MEMSET = 7, SANITIZER_CB_DOMAIN_BATCH_MEMOP = 8, SANITIZER_CB_DOMAIN_UVM = 9, SANITIZER_CB_DOMAIN_GRAPHS = 10 }
	Callback domains. More...
enum	Sanitizer_CallbackIdBatchMemop { SANITIZER_CBID_BATCH_MEMOP_INVALID = 0, SANITIZER_CBID_BATCH_MEMOP_WRITE = 1 }
	Callback IDs for batch memop domain. More...
enum	Sanitizer_CallbackIdGraphs { SANITIZER_CBID_GRAPHS_INVALID = 0, SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATED = 1, SANITIZER_CBID_GRAPHS_NODE_LAUNCH_BEGIN = 2, SANITIZER_CBID_GRAPHS_NODE_LAUNCH_END = 3 }
	Callback IDs for graphs domain. More...
enum	Sanitizer_CallbackIdLaunch { SANITIZER_CBID_LAUNCH_INVALID = 0, SANITIZER_CBID_LAUNCH_BEGIN = 1, SANITIZER_CBID_LAUNCH_AFTER_SYSCALL_SETUP = 2, SANITIZER_CBID_LAUNCH_END = 3 }
	Callback IDs for launch domain. More...
enum	Sanitizer_CallbackIdMemcpy { SANITIZER_CBID_MEMCPY_INVALID = 0, SANITIZER_CBID_MEMCPY_STARTING = 1 }
	Callback IDs for memcpy domain. More...
enum	Sanitizer_CallbackIdMemset { SANITIZER_CBID_MEMSET_INVALID = 0, SANITIZER_CBID_MEMSET_STARTING = 1 }
	Callback IDs for memset domain. More...
enum	Sanitizer_CallbackIdResource { SANITIZER_CBID_RESOURCE_INVALID = 0, SANITIZER_CBID_RESOURCE_INIT_FINISHED = 1, SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_STARTING = 2, SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_FINISHED = 3, SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_STARTING = 4, SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_FINISHED = 5, SANITIZER_CBID_RESOURCE_STREAM_CREATED = 6, SANITIZER_CBID_RESOURCE_STREAM_DESTROY_STARTING = 7, SANITIZER_CBID_RESOURCE_MODULE_LOADED = 8, SANITIZER_CBID_RESOURCE_MODULE_UNLOAD_STARTING = 9, SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_ALLOC = 10, SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_FREE = 11, SANITIZER_CBID_RESOURCE_HOST_MEMORY_ALLOC = 12, SANITIZER_CBID_RESOURCE_HOST_MEMORY_FREE = 13, SANITIZER_CBID_RESOURCE_MEMORY_ALLOC_ASYNC = 14, SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC = 15, SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC_DONE = 16, SANITIZER_CBID_RESOURCE_MEMPOOL_CREATED = 17, SANITIZER_CBID_RESOURCE_MEMPOOL_DESTROYING = 18, SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_ENABLED = 19, SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_DISABLING = 20, SANITIZER_CBID_RESOURCE_ARRAY_CREATED = 21, SANITIZER_CBID_RESOURCE_ARRAY_DESTROYED = 22 }
	Callback IDs for resource domain. More...
enum	Sanitizer_CallbackIdUvm { SANITIZER_CBID_UVM_INVALID = 0, SANITIZER_CBID_UVM_ATTACH_MEM = 1 }
	Callback IDs for managed memory domain. More...
enum	Sanitizer_MemcpyDirection { SANITIZER_MEMCPY_DIRECTION_UNKNOWN = 0, SANITIZER_MEMCPY_DIRECTION_HOST_TO_HOST = 1, SANITIZER_MEMCPY_DIRECTION_HOST_TO_DEVICE = 2, SANITIZER_MEMCPY_DIRECTION_DEVICE_TO_HOST = 3, SANITIZER_MEMCPY_DIRECTION_DEVICE_TO_DEVICE = 4 }
	Memcpy direction. More...
enum	Sanitizer_MemoryVisibility { SANITIZER_MEMORY_VISIBILITY_INVALID = 0, SANITIZER_MEMORY_VISIBILITY_GLOBAL = 1, SANITIZER_MEMORY_VISIBILITY_HOST = 2, SANITIZER_MEMORY_VISIBILITY_STREAM = 3 }
	Specifies the visibility of an allocation. More...
enum	Sanitizer_ResourceMemoryFlags { SANITIZER_MEMORY_FLAG_NONE = 0, SANITIZER_MEMORY_FLAG_MODULE = 0x1, SANITIZER_MEMORY_FLAG_MANAGED = 0x2, SANITIZER_MEMORY_FLAG_HOST_MAPPED = 0x4, SANITIZER_MEMORY_FLAG_HOST_PINNED = 0x8, SANITIZER_MEMORY_FLAG_PEER = 0x10, SANITIZER_MEMORY_FLAG_PEER_ATOMIC = 0x20, SANITIZER_MEMORY_FLAG_CG_RUNTIME = 0x40 }
	Flags describing a memory allocation. More...
enum	Sanitizer_ResourceMemoryPermissions { SANITIZER_MEMORY_PERMISSION_NONE = 0, SANITIZER_MEMORY_PERMISSION_READ = 0x1, SANITIZER_MEMORY_PERMISSION_WRITE = 0x2, SANITIZER_MEMORY_PERMISSION_ATOMIC = 0x4, SANITIZER_MEMORY_PERMISSION_ALL = 0x7 }
	Permissions for a memory allocation. More...
Functions
SanitizerResult SANITIZERAPI	sanitizerEnableAllDomains (uint32_t enable, Sanitizer_SubscriberHandle subscriber)
	Enable or disable all callbacks in all domains.
SanitizerResult SANITIZERAPI	sanitizerEnableCallback (uint32_t enable, Sanitizer_SubscriberHandle subscriber, Sanitizer_CallbackDomain domain, Sanitizer_CallbackId cbid)
	Enable or disable callbacks for a specific domain and callback ID.
SanitizerResult SANITIZERAPI	sanitizerEnableDomain (uint32_t enable, Sanitizer_SubscriberHandle subscriber, Sanitizer_CallbackDomain domain)
	Enable or disable all callbacks for a specific domain.
SanitizerResult SANITIZERAPI	sanitizerGetCallbackState (uint32_t *enable, Sanitizer_SubscriberHandle subscriber, Sanitizer_CallbackDomain domain, Sanitizer_CallbackId cbid)
	Get the current enabled/disabled state of a callback for a specific domain and function ID.
SanitizerResult SANITIZERAPI	sanitizerSubscribe (Sanitizer_SubscriberHandle subscriber, Sanitizer_CallbackFunc callback, void userdata)
	Initialize a callback subscriber with a callback function and user data.
SanitizerResult SANITIZERAPI	sanitizerUnsubscribe (Sanitizer_SubscriberHandle subscriber)
	Unregister a callback subscriber.
Variables
union {
Sanitizer_LaunchData launchData
Sanitizer_ResourceMemoryData Sanitizer_GraphNodeLaunchData::memAllocData
uint64_t Sanitizer_GraphNodeLaunchData::memFreeAddress
};
uint64_t	Sanitizer_UvmData::address
uint64_t	Sanitizer_BatchMemopData::address
uint64_t	Sanitizer_MemsetData::address
CUcontext	Sanitizer_ResourceMemoryData::context
CUcontext	Sanitizer_CallbackData::context
size_t	Sanitizer_ResourceModuleData::cubinSize
CUdevice	Sanitizer_LaunchData::device
CUdevice	Sanitizer_ResourceMempoolData::device
CUdevice	Sanitizer_ResourceMemoryData::device
CUdevice	Sanitizer_ResourceContextData::device
Sanitizer_MemcpyDirection	Sanitizer_MemcpyData::direction
uint64_t	Sanitizer_MemcpyData::dstAddress
CUcontext	Sanitizer_MemcpyData::dstContext
uint64_t	Sanitizer_MemcpyData::dstPitch
CUstream	Sanitizer_MemcpyData::dstStream
uint32_t	Sanitizer_ResourceMemoryData::flags
CUfunction	Sanitizer_LaunchData::function
const char *	Sanitizer_LaunchData::functionName
const char *	Sanitizer_CallbackData::functionName
const void *	Sanitizer_CallbackData::functionParams
const void *	Sanitizer_CallbackData::functionReturnValue
CUgraphExec	Sanitizer_GraphExecData::graphExec
uint64_t	Sanitizer_LaunchData::gridId
CUarray	Sanitizer_ResourceArrayData::hArray
Sanitizer_StreamHandle	Sanitizer_MemcpyData::hDstStream
Sanitizer_LaunchHandle	Sanitizer_LaunchData::hLaunch
Sanitizer_StreamHandle	Sanitizer_MemcpyData::hSrcStream
Sanitizer_StreamHandle	Sanitizer_UvmData::hStream
Sanitizer_StreamHandle	Sanitizer_BatchMemopData::hStream
Sanitizer_StreamHandle	Sanitizer_MemsetData::hStream
Sanitizer_StreamHandle	Sanitizer_LaunchData::hStream
Sanitizer_StreamHandle	Sanitizer_SynchronizeData::hStream
Sanitizer_StreamHandle	Sanitizer_ResourceMemoryData::hStream
Sanitizer_StreamHandle	Sanitizer_ResourceStreamData::hStream
uint32_t	Sanitizer_MemsetData::isAsync
uint32_t	Sanitizer_MemcpyData::isAsync
uint32_t	Sanitizer_GraphNodeLaunchData::launchId
Sanitizer_ResourceMemoryData Sanitizer_GraphNodeLaunchData::memAllocData
uint64_t Sanitizer_GraphNodeLaunchData::memFreeAddress
CUmemoryPool	Sanitizer_ResourceMemoryData::memoryPool
CUmodule	Sanitizer_LaunchData::module
CUmodule	Sanitizer_ResourceModuleData::module
CUgraphNode	Sanitizer_GraphNodeLaunchData::node
CUgraphNodeType	Sanitizer_GraphNodeLaunchData::nodeType
const char *	Sanitizer_ResourceModuleData::pCubin
CUdevice	Sanitizer_ResourceMempoolData::peerDevice
uint32_t	Sanitizer_ResourceMemoryData::permissions
uint64_t	Sanitizer_MemcpyData::size
uint64_t	Sanitizer_ResourceMemoryData::size
CUdevice	Sanitizer_ResourceMemoryData::sourceDevice
uint64_t	Sanitizer_MemcpyData::srcAddress
uint64_t	Sanitizer_MemcpyData::srcPitch
CUstream	Sanitizer_MemcpyData::srcStream
CUstream	Sanitizer_UvmData::stream
CUstream	Sanitizer_BatchMemopData::stream
CUstream	Sanitizer_MemsetData::stream
CUstream	Sanitizer_LaunchData::stream
CUstream	Sanitizer_SynchronizeData::stream
CUstream	Sanitizer_ResourceMemoryData::stream
CUstream	Sanitizer_ResourceStreamData::stream
const char *	Sanitizer_CallbackData::symbolName
Sanitizer_BatchMemopType	Sanitizer_BatchMemopData::type
uint64_t	Sanitizer_BatchMemopData::value
uint32_t	Sanitizer_MemsetData::value
Sanitizer_MemoryVisibility	Sanitizer_UvmData::visibility
Sanitizer_MemoryVisibility	Sanitizer_ResourceMemoryData::visibility
uint64_t	Sanitizer_MemsetData::width
uint64_t	Sanitizer_MemcpyData::width
uint64_t	Sanitizer_ResourceArrayData::width
uint32_t	Sanitizer_LaunchData::blockDim_x
uint32_t	Sanitizer_LaunchData::blockDim_y
uint32_t	Sanitizer_LaunchData::blockDim_z
uint32_t	Sanitizer_LaunchData::gridDim_x
uint32_t	Sanitizer_LaunchData::gridDim_y
uint32_t	Sanitizer_LaunchData::gridDim_z

Detailed Description

Functions, types, and enums that implement the Sanitizer Callback API.

Typedef Documentation

typedef void(SANITIZERAPI * Sanitizer_CallbackFunc)(void *userdata, Sanitizer_CallbackDomain domain, Sanitizer_CallbackId cbid, const void *cbdata)

Function type for a callback. The type of the data passed to the callback in cbdata depends on the domain. If domain is SANITIZER_CB_DOMAIN_DRIVER_API or SANITIZER_CB_DOMAIN_RUNTIME_API the type of cbdata will be Sanitizer_CallbackData. If domain is SANITIZER_CB_DOMAIN_RESOURCE the type of cbdata will be dependent on cbid. Refer to Sanitizer_ResourceContextData, Sanitizer_ResourceStreamData, Sanitizer_ResourceModuleData and Sanitizer_ResourceMemoryFlags documentations. If domain is SANITIZER_CB_DOMAIN_SYNCHRONIZE the type of cbdata will be Sanitizer_SynchronizeData. If domain is SANITIZER_CB_DOMAIN_LAUNCH the type of cbdata will be Sanitizer_LaunchData. If domain is SANITIZER_CB_DOMAIN_MEMCPY the type of cbdata will be Sanitizer_MemcpyData. If domain is SANITIZER_CB_DOMAIN_MEMSET the type of cbdata will be Sanitizer_MemsetData. If domain is SANITIZER_CB_DOMAIN_BATCH_MEMOP the type of cbdata will be Sanitizer_BatchMemopData.

Enumeration Type Documentation

enum Sanitizer_ApiCallbackSite

Specifies the point in an API that a callback is issued. This value is communicated to the callback function via Sanitizer_CallbackData::CallbackSize.

Enumerator:

SANITIZER_API_ENTER	This callback is at API entry.
SANITIZER_API_EXIT	This callback is at API exit.

enum Sanitizer_BatchMemopType

Specifies the type of batch memory operation reported by a callback in domain SANITIZER_CB_DOMAIN_BATCH_MEMOP. This value is communicated to the callback function via Sanitizer_BatchMemopData::type.

Enumerator:

SANITIZER_BATCH_MEMOP_TYPE_32B	Batch memory operation size is 32 bits.
SANITIZER_BATCH_MEMOP_TYPE_64B	Batch memory operation size is 64 bits.

enum Sanitizer_CallackIdSync

Callback IDs for resource domain SANITIZER_CB_DOMAIN_SYNCHRONIZE. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_SYNCHRONIZE_INVALID	Invalid synchronize callback ID.
SANITIZER_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED	Stream synchronization has completed for a given stream.
SANITIZER_CBID_SYNCHRONIZE_CONTEXT_SYNCHRONIZED	Context synchronization has completed for a given context.

enum Sanitizer_CallbackDomain

Callback domain. Each domain represents callback points for a group of related API functions or CUDA driver activity.

Enumerator:

SANITIZER_CB_DOMAIN_INVALID	Invalid domain.
SANITIZER_CB_DOMAIN_DRIVER_API	Domain containing callback points for all driver API functions.
SANITIZER_CB_DOMAIN_RUNTIME_API	Domain containing callback points for all runtime API functions.
SANITIZER_CB_DOMAIN_RESOURCE	Domain containing callback points for CUDA resource tracking.
SANITIZER_CB_DOMAIN_SYNCHRONIZE	Domain containing callback points for CUDA synchronization.
SANITIZER_CB_DOMAIN_LAUNCH	Domain containing callback points for CUDA grid launches.
SANITIZER_CB_DOMAIN_MEMCPY	Domain containing callback points for CUDA memcpy operations.
SANITIZER_CB_DOMAIN_MEMSET	Domain containing callback points for CUDA memset operations.
SANITIZER_CB_DOMAIN_BATCH_MEMOP	Domain containing callback points for CUDA batch memop operations.
SANITIZER_CB_DOMAIN_UVM	Domain containing callback points for CUDA managed memory operations.
SANITIZER_CB_DOMAIN_GRAPHS	Domain containing callback points for CUDA graphs operations.

enum Sanitizer_CallbackIdBatchMemop

Callback IDs for resource domain SANITIZER_CB_DOMAIN_BATCH_MEMOP. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_BATCH_MEMOP_INVALID	Invalid batch memop callback ID.
SANITIZER_CBID_BATCH_MEMOP_WRITE	A batch memory operation was initiated.

enum Sanitizer_CallbackIdGraphs

Callback IDs for resource domain SANITIZER_CB_DOMAIN_GRAPHS. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_GRAPHS_INVALID	Invalid graphs callback ID.
SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATED	A new graphexec was created.
SANITIZER_CBID_GRAPHS_NODE_LAUNCH_BEGIN	A node launch was initiated.
SANITIZER_CBID_GRAPHS_NODE_LAUNCH_END	A node launch is complete.

enum Sanitizer_CallbackIdLaunch

Callback IDs for resource domain SANITIZER_CB_DOMAIN_LAUNCH. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_LAUNCH_INVALID	Invalid launch callback ID.
SANITIZER_CBID_LAUNCH_BEGIN	A grid launch was initiated.
SANITIZER_CBID_LAUNCH_AFTER_SYSCALL_SETUP	A grid launch has completed syscalls setup.
SANITIZER_CBID_LAUNCH_END	The grid launch is complete.

enum Sanitizer_CallbackIdMemcpy

Callback IDs for resource domain SANITIZER_CB_DOMAIN_MEMCPY. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_MEMCPY_INVALID	Invalid memcpy callback ID.
SANITIZER_CBID_MEMCPY_STARTING	A memcpy operation was initiated.

enum Sanitizer_CallbackIdMemset

Callback IDs for resource domain SANITIZER_CB_DOMAIN_MEMSET. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_MEMSET_INVALID	Invalid memset callback ID.
SANITIZER_CBID_MEMSET_STARTING	A memset operation was initiated.

enum Sanitizer_CallbackIdResource

Callback IDs for resource domain SANITIZER_CB_DOMAIN_RESOURCE. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_RESOURCE_INVALID	Invalid resource callback ID.
SANITIZER_CBID_RESOURCE_INIT_FINISHED	Driver initialization is finished.
SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_STARTING	A new context is about to be created.
SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_FINISHED	A new context was created.
SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_STARTING	A context is about to be destroyed.
SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_FINISHED	A context was destroyed.
SANITIZER_CBID_RESOURCE_STREAM_CREATED	A new stream was created.
SANITIZER_CBID_RESOURCE_STREAM_DESTROY_STARTING	A stream is about to be destroyed.
SANITIZER_CBID_RESOURCE_MODULE_LOADED	A module was loaded.
SANITIZER_CBID_RESOURCE_MODULE_UNLOAD_STARTING	A module is about to be unloaded.
SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_ALLOC	Device memory was allocated.
SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_FREE	Device memory was freed.
SANITIZER_CBID_RESOURCE_HOST_MEMORY_ALLOC	Pinned host memory was allocated.
SANITIZER_CBID_RESOURCE_HOST_MEMORY_FREE	Pinned host memory was freed.
SANITIZER_CBID_RESOURCE_MEMORY_ALLOC_ASYNC	Memory was allocated asynchronously.
SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC	Memory was freed asynchronously.
SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC_DONE	Memory freed asynchronously was released, only happens if a regular allocation (cudaMalloc) is free'd asynchronously (cudaFreeAsync). See CUDA runtime documentation for cudaFreeAsync
SANITIZER_CBID_RESOURCE_MEMPOOL_CREATED	A new mempool was created.
SANITIZER_CBID_RESOURCE_MEMPOOL_DESTROYING	A mempool is about to be destroyed.
SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_ENABLED	A mempool is now accessible from a peer device.
SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_DISABLING	A mempool is no longer accessible from a peer device.
SANITIZER_CBID_RESOURCE_ARRAY_CREATED	A CUDA array was created.
SANITIZER_CBID_RESOURCE_ARRAY_DESTROYED	A CUDA array was destroyed.

enum Sanitizer_CallbackIdUvm

Callback IDs for resource domain SANITIZER_CB_DOMAIN_UVM. This value is communicated to the callback function via the cbid parameter.

Enumerator:

SANITIZER_CBID_UVM_INVALID	Invalid managed memory callback ID.
SANITIZER_CBID_UVM_ATTACH_MEM	Modify the stream association of an allocation (see cudaStreamAttachMemAsync)

enum Sanitizer_MemcpyDirection

Indicates the direction of a memcpy, passed inside Sanitizer_Memcpydata.

Enumerator:

SANITIZER_MEMCPY_DIRECTION_UNKNOWN	Unknown memcpy direction
SANITIZER_MEMCPY_DIRECTION_HOST_TO_HOST	Memcpy from host to host.
SANITIZER_MEMCPY_DIRECTION_HOST_TO_DEVICE	Memcpy from host to device.
SANITIZER_MEMCPY_DIRECTION_DEVICE_TO_HOST	Memcpy from device to host.
SANITIZER_MEMCPY_DIRECTION_DEVICE_TO_DEVICE	Memcpy from device to device.

enum Sanitizer_MemoryVisibility

Specifies the visibility of an allocation. This is typically GLOBAL on allocations made via cudaMalloc, cudaHostAlloc and similar APIs. This can be GLOBAL or HOST for cudaMallocManaged allocations depending on the flags parameter. This can be changed after allocation time using cudaMemAttachSingle API (see SANITIZER_CBID_UVM_ATTACH_MEM for the corresponding callback).

Enumerator:

SANITIZER_MEMORY_VISIBILITY_INVALID	Invalid memory visibility
SANITIZER_MEMORY_VISIBILITY_GLOBAL	Memory can be accessed by any stream on any device (see cudaMemAttachGlobal)
SANITIZER_MEMORY_VISIBILITY_HOST	Memory cannot be accessed by any stream on any device (see cudaMemAttachHost)
SANITIZER_MEMORY_VISIBILITY_STREAM	Memory can only be accessed by a single stream on the associated device (see cudaMemAttachSingle)

enum Sanitizer_ResourceMemoryFlags

Flags describing a memory allocation. These values are to be used in order to interpret the value of Sanitizer_ResourceMemoryData::flags

Enumerator:

SANITIZER_MEMORY_FLAG_NONE	Empty flag.
SANITIZER_MEMORY_FLAG_MODULE	Specifies that the allocation is static scoped to a module.
SANITIZER_MEMORY_FLAG_MANAGED	Specifies that the allocation is managed memory.
SANITIZER_MEMORY_FLAG_HOST_MAPPED	Species that the allocation accessible from the host.
SANITIZER_MEMORY_FLAG_HOST_PINNED	Specifies that the allocation is pinned on the host.
SANITIZER_MEMORY_FLAG_PEER	Specifies that the allocation is located on a peer GPU.
SANITIZER_MEMORY_FLAG_PEER_ATOMIC	Specifies that the allocation is located on a peer GPU supporting native atomics. This implies that SANITIZER_MEMORY_FLAG_PEER is set as well.
SANITIZER_MEMORY_FLAG_CG_RUNTIME	Specifies that the allocation is used by the Cooperative Groups runtime functions.

enum Sanitizer_ResourceMemoryPermissions

Permissions for a memory allocation. These values are to be used in order to interpret the value of Sanitizer_ResourceMemoryData::permissions

Enumerator:

SANITIZER_MEMORY_PERMISSION_NONE	No permissions.
SANITIZER_MEMORY_PERMISSION_READ	Specifies that the allocation is readable.
SANITIZER_MEMORY_PERMISSION_WRITE	Specifies that the allocation is writable.
SANITIZER_MEMORY_PERMISSION_ATOMIC	Specifies that the allocation is readable/writable with atomic operations.
SANITIZER_MEMORY_PERMISSION_ALL	Specifies that the allocation has all permissions.

Function Documentation

SanitizerResult SANITIZERAPI sanitizerEnableAllDomains	(	uint32_t	enable,
		Sanitizer_SubscriberHandle	subscriber
	)

Enable or disable all callbacks in all domains.

Note:: Thread-safety: a subscriber must serialize access to sanitizerGetCallbackState, sanitizerEnableCallback, sanitizerEnableDomain, and sanitizerEnableAllDomains. For example, if sanitizerGetCallbackState(sub, d, *) and sanitizerEnableAllDomains(sub) are called concurrently, the results are undefined.

Parameters:

	enable	New enable state for all callbacks in all domains. Zero disables all callbacks, non-zero enables all callbacks.
	subscriber	- Handle of the initialized subscriber

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_INVALID_PARAMETER	if `subscriber` is invalid

SanitizerResult SANITIZERAPI sanitizerEnableCallback	(	uint32_t	enable,
		Sanitizer_SubscriberHandle	subscriber,
		Sanitizer_CallbackDomain	domain,
		Sanitizer_CallbackId	cbid
	)

Enable or disable callbacks for a subscriber for a specific domain and callback ID.

Note:: Thread-safety: a subscriber must serialize access to sanitizerGetCallbackState, sanitizerEnableCallback, sanitizerEnableDomain, and sanitizerEnableAllDomains. For example, if sanitizerGetCallbackState(sub, d, c) and sanitizerEnableCallback(sub, d, c) are called concurrently, the results are undefined.

Parameters:

	enable	New enable state for the callback. Zero disables the callback, non-zero enables the callback
	subscriber	- Handle of the initialized subscriber
	domain	The domain of the callback
	cbid	The ID of the callback

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_INVALID_PARAMETER	if `subscriber`, `domain` or `cbid` is invalid

SanitizerResult SANITIZERAPI sanitizerEnableDomain	(	uint32_t	enable,
		Sanitizer_SubscriberHandle	subscriber,
		Sanitizer_CallbackDomain	domain
	)

Enable or disable all callbacks for a specific domain.

Note:: Thread-safety: a subscriber must serialize access to sanitizerGetCallbackState, sanitizerEnableCallback, sanitizerEnableDomain, and sanitizerEnableAllDomains. For example, if sanitizerGetCallbackEnabled(sub, d, *) and sanitizerEnableDomain(sub, d) are called concurrently, the results are undefined.

Parameters:

	enable	New enable state for all callbacks in the domain. Zero disables all callbacks, non-zero enables all callbacks
	subscriber	- Handle of the initialized subscriber
	domain	The domain of the callback

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_INVALID_PARAMETER	if `subscriber` or `domain` is invalid

SanitizerResult SANITIZERAPI sanitizerGetCallbackState	(	uint32_t *	enable,
		Sanitizer_SubscriberHandle	subscriber,
		Sanitizer_CallbackDomain	domain,
		Sanitizer_CallbackId	cbid
	)

Returns non-zero in *enable if the callback for a domain and callback ID is enabled, and zero if not enabled.

Note:: Thread-safety: a subscriber must serialize access to sanitizerGetCallbackState, sanitizerEnableCallback, sanitizerEnableDomain, and sanitizerEnableAllDomains. For example, if sanitizerGetCallbackState(sub, d, c) and sanitizerEnableCallback(sub, d, c) are called concurrently, the results are undefined.

Parameters:

	enable	Returns non-zero if callback enabled, zero if not enabled
	subscriber	Handle to the initialized subscriber
	domain	The domain of the callback
	cbid	The ID of the callback

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_INVALID_PARAMETER	if `enabled` is NULL, or if `subscriber`, `domain` or `cbid` is invalid.

SanitizerResult SANITIZERAPI sanitizerSubscribe	(	Sanitizer_SubscriberHandle *	subscriber,
		Sanitizer_CallbackFunc	callback,
		void *	userdata
	)

Initialize a callback subscriber with a callback function and (optionally) a pointer to user data. The returned subscriber handle can be used to enable and disable the callback for specific domains and callback IDs.

Note:

Only one subscriber can be registered at a time.

This function does not enable any callbacks.

Thread-safety: this function is thread safe.

Parameters:

	subscriber	Returns handle to initialize subscriber
	callback	The callback function
	userdata	A pointer to user data. This data will be passed to the callback function via the `userdata` parameter

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_MAX_LIMIT_RACHED	if there is already a sanitizer subscriber
	SANITIZER_ERROR_INVALID_PARAMETER	if `subscriber` is NULL

SanitizerResult SANITIZERAPI sanitizerUnsubscribe ( Sanitizer_SubscriberHandle subscriber )

Removes a callback subscriber so that no future callback will be issued to that subscriber.

Note:: Thread-safety: this function is thread safe.

Parameters:

subscriber

Handle to the initialized subscriber

Return values:

	SANITIZER_SUCCESS	on success
	SANITIZER_ERROR_NOT_INITIALIZED	if unable to initialize the sanitizer
	SANITIZER_ERROR_INVALID_PARAMETER	if `subscriber` is NULL or not initialized

Variable Documentation

union { ... } [inherited]

Data for this node launch.

uint64_t Sanitizer_UvmData::address [inherited]

The address of the allocation.

uint64_t Sanitizer_BatchMemopData::address [inherited]

The address to be written.

uint64_t Sanitizer_MemsetData::address [inherited]

The address of the memset start.

uint32_t Sanitizer_LaunchData::blockDim_x [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

uint32_t Sanitizer_LaunchData::blockDim_y [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

uint32_t Sanitizer_LaunchData::blockDim_z [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

CUcontext Sanitizer_ResourceMemoryData::context [inherited]

Context containing the allocation being created or destroyed. Can be NULL if the allocation is not attached to a context.

CUcontext Sanitizer_CallbackData::context [inherited]

Driver context current to the thread, or null if no context is current. This value can change from the entry to exit callback of a runtime API function if the runtime initialized a context.

size_t Sanitizer_ResourceModuleData::cubinSize [inherited]

The size of the cubin.

CUdevice Sanitizer_LaunchData::device [inherited]

The device where the grid is launched

CUdevice Sanitizer_ResourceMempoolData::device [inherited]

Device that owns the memory pool.

CUdevice Sanitizer_ResourceMemoryData::device [inherited]

Device where the allocation is being created. Available for all cbid with a driver version of 455 or newer.

CUdevice Sanitizer_ResourceContextData::device [inherited]

The device on which the context is being created or destroyed. This field is only valid for SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_* callbacks

Sanitizer_MemcpyDirection Sanitizer_MemcpyData::direction [inherited]

The direction of the transfer

uint64_t Sanitizer_MemcpyData::dstAddress [inherited]

The destination allocation address.

CUcontext Sanitizer_MemcpyData::dstContext [inherited]

The context where the destination allocation is located

uint64_t Sanitizer_MemcpyData::dstPitch [inherited]

The destination allocation pitch.

CUstream Sanitizer_MemcpyData::dstStream [inherited]

The stream where the memcpy is executed on the destination context

uint32_t Sanitizer_ResourceMemoryData::flags [inherited]

Allocation details: use Sanitizer_ResourceMemoryFlags to interpret this field.

CUfunction Sanitizer_LaunchData::function [inherited]

The function of the grid launch.

const char* Sanitizer_LaunchData::functionName [inherited]

The name of the launched function.

const char* Sanitizer_CallbackData::functionName [inherited]

Name of the runtime or driver API function which issued the callback. This string is a global constant and so may be accessed outside of the callback.

const void* Sanitizer_CallbackData::functionParams [inherited]

Pointer to the arguments passed to the runtime or driver API call. See generated_cuda_runtime_api_meta.h and generated_cuda_meta.h for structure definitions for the parameters for each runtime and driver API function.

const void* Sanitizer_CallbackData::functionReturnValue [inherited]

Pointer to the return value of the runtime or driver API call. This field is only valid within the SANITIZER_API_EXIT callback. For a runtime API functionReturnValue points to a cudaError_t. For a driver API functionReturnValue points to a CUresult.

CUgraphExec Sanitizer_GraphExecData::graphExec [inherited]

Instance of the CUDA graph.

uint32_t Sanitizer_LaunchData::gridDim_x [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

uint32_t Sanitizer_LaunchData::gridDim_y [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

uint32_t Sanitizer_LaunchData::gridDim_z [inherited]

Launch properties of the grid. These values are only valid for SANITIZER_CBID_LAUNCH_BEGIN and graph node launch callbacks

uint64_t Sanitizer_LaunchData::gridId [inherited]

Unique identifier of the grid launch. For graph node launches, this is only unique within the graphexec launch.

CUarray Sanitizer_ResourceArrayData::hArray [inherited]

The CUDA array being created or destroyed.

Sanitizer_StreamHandle Sanitizer_MemcpyData::hDstStream [inherited]

Unique handle for the destination context stream.

Sanitizer_LaunchHandle Sanitizer_LaunchData::hLaunch [inherited]

Handle of the grid launch. This is only valid between the launch begin and end callbacks.

Sanitizer_StreamHandle Sanitizer_MemcpyData::hSrcStream [inherited]

Unique handle for the source context stream.

Sanitizer_StreamHandle Sanitizer_UvmData::hStream [inherited]

Unique handle for the stream.

Sanitizer_StreamHandle Sanitizer_BatchMemopData::hStream [inherited]

Unique handle for the stream.

Sanitizer_StreamHandle Sanitizer_MemsetData::hStream [inherited]

Unique handle for the stream.

Sanitizer_StreamHandle Sanitizer_LaunchData::hStream [inherited]

Unique handle for the stream.

Sanitizer_StreamHandle Sanitizer_SynchronizeData::hStream [inherited]

Unique handle for the stream.

Sanitizer_StreamHandle Sanitizer_ResourceMemoryData::hStream [inherited]

Stream containing the allocation being created or destroyed. Can be NULL if the allocation is not attached to a stream.

Sanitizer_StreamHandle Sanitizer_ResourceStreamData::hStream [inherited]

Unique handle for the stream.

uint32_t Sanitizer_MemsetData::isAsync [inherited]

Boolean value indicating if the transfer is asynchronous.

uint32_t Sanitizer_MemcpyData::isAsync [inherited]

Boolean value indicating if the transfer is asynchronous.

Sanitizer_LaunchData { ... } ::launchData [inherited]

This is only valid if nodeType is CU_GRAPH_NODE_TYPE_KERNEL.

uint32_t Sanitizer_GraphNodeLaunchData::launchId [inherited]

Launch ID for this CUDA graph instance

Sanitizer_ResourceMemoryData { ... } ::memAllocData [inherited]

This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEM_ALLOC.

Sanitizer_ResourceMemoryData Sanitizer_GraphNodeLaunchData::memAllocData [inherited]

This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEM_ALLOC.

uint64_t { ... } ::memFreeAddress [inherited]

The freed device pointer This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEM_FREE.

uint64_t Sanitizer_GraphNodeLaunchData::memFreeAddress [inherited]

The freed device pointer This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEM_FREE.

CUmemoryPool Sanitizer_ResourceMemoryData::memoryPool [inherited]

Memory pool containing the allocation being created or destroyed. Can be NULL if the allocation is not attached to a memory pool.

CUmodule Sanitizer_LaunchData::module [inherited]

The module containing the grid code.

CUmodule Sanitizer_ResourceModuleData::module [inherited]

The module being loaded or unloaded.

CUgraphNode Sanitizer_GraphNodeLaunchData::node [inherited]

CUDA graphs node being launched.

CUgraphNodeType Sanitizer_GraphNodeLaunchData::nodeType [inherited]

CUDA graphs node type.

const char* Sanitizer_ResourceModuleData::pCubin [inherited]

Pointer to the associated cubin.

CUdevice Sanitizer_ResourceMempoolData::peerDevice [inherited]

Device that access type changed. Avaialble if cbid is SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_ENABLED or SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_DISABLING.

uint32_t Sanitizer_ResourceMemoryData::permissions [inherited]

Allocation permissions: use Sanitizer_ResourceMemoryPermissions to interpret this field.

uint64_t Sanitizer_MemcpyData::size [inherited]

Size of the transfer in bytes.

uint64_t Sanitizer_ResourceMemoryData::size [inherited]

Size of the allocation being created or destroyed.

CUdevice Sanitizer_ResourceMemoryData::sourceDevice [inherited]

Source device of this allocation (different from device if SANITIZER_MEMORY_FLAG_PEER is set).

uint64_t Sanitizer_MemcpyData::srcAddress [inherited]

The source allocation address.

uint64_t Sanitizer_MemcpyData::srcPitch [inherited]

The source allocation pitch.

CUstream Sanitizer_MemcpyData::srcStream [inherited]

The stream where the memcpy is executed on the source context

CUstream Sanitizer_UvmData::stream [inherited]

The stream on which the memory is attached. This is only valid if visibility is SANITIZER_MEMORY_VISIBILITY_STREAM

CUstream Sanitizer_BatchMemopData::stream [inherited]

The stream where the batch memop is executed.

CUstream Sanitizer_MemsetData::stream [inherited]

The stream where the memset is executed.

CUstream Sanitizer_LaunchData::stream [inherited]

The stream where the grid is launched.

CUstream Sanitizer_SynchronizeData::stream [inherited]

This field is only valid for SANITIZER_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED. This is the stream being synchronized.

CUstream Sanitizer_ResourceMemoryData::stream [inherited]

Public handle for the stream.

CUstream Sanitizer_ResourceStreamData::stream [inherited]

The stream being created or destroyed.

const char* Sanitizer_CallbackData::symbolName [inherited]

Name of the symbol operated on by the runtime or driver API function which issued the callback. This entry is valid only for driver and runtime launch callbacks, where it returns the name of the kernel.

Sanitizer_BatchMemopType Sanitizer_BatchMemopData::type [inherited]

Type of batch memory operation.

uint64_t Sanitizer_BatchMemopData::value [inherited]

The value to be written.

uint32_t Sanitizer_MemsetData::value [inherited]

Value to be written.

Sanitizer_MemoryVisibility Sanitizer_UvmData::visibility [inherited]

New visibility for the allocation.

Sanitizer_MemoryVisibility Sanitizer_ResourceMemoryData::visibility [inherited]

Visibility of the allocation.

uint64_t Sanitizer_MemsetData::width [inherited]

Memset size configuration.