-->
Sanitizer Api - v2023.3.0 (older) - Last updated August 23, 2023 - Send Feedback

## 2. Data Structures

Here are the data structures with brief descriptions:

Sanitizer_BatchMemopData
  Data passed into a batch memop callback function
Sanitizer_CallbackData
  Data passed into a runtime or driver API callback function
Sanitizer_EventData
  Data passed into an event callback function
Sanitizer_ExternalMemoryData
  Data passed into an external memory callback function
Sanitizer_GraphExecData
  Data passed into a graphexec creation callback function
Sanitizer_GraphLaunchData
  Data passed into a graph launch callback function
Sanitizer_GraphNodeLaunchData
  Data passed into a graph node launch callback function
Sanitizer_LaunchData
  Data passed into a launch callback function
Sanitizer_MemcpyData
  Data passed into a memcpy callback function
Sanitizer_MemsetData
  Data passed into a memset callback function
Sanitizer_ResourceArrayData
  Data passed into a CUDA array callback function
Sanitizer_ResourceContextData
  Data passed into a context resource callback function
Sanitizer_ResourceFunctionsLazyLoadedData
  Data passed into a CUDA function callback function
Sanitizer_ResourceMemoryData
  Data passed into a memory resource callback function
Sanitizer_ResourceMempoolData
  Data passed into a mempool resource callback function
Sanitizer_ResourceModuleData
  Data passed into a module resource callback function
Sanitizer_ResourceStreamData
  Data passed into a stream resource callback function
Sanitizer_ResourceVirtualRange
  Data passed into a VA reservation callback function
Sanitizer_SynchronizeData
  Data passed into a synchronization callback function
Sanitizer_UvmData
  Data passed into a managed memory callback function

### 2.1. Sanitizer_BatchMemopData Struct Reference

### [Sanitizer Callback API]

Data passed into a batch memop callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_BATCH_MEMOP. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint64_t address
CUcontext context
Sanitizer_StreamHandle hStream
CUstream stream
Sanitizer_BatchMemopType type
uint64_t value

#### Variables

uint64_t Sanitizer_BatchMemopData::address [inherited]

  The address to be written.

CUcontext Sanitizer_BatchMemopData::context [inherited]

  The context where the allocation is located

Sanitizer_StreamHandle Sanitizer_BatchMemopData::hStream [inherited]

  Unique handle for the stream.

CUstream Sanitizer_BatchMemopData::stream [inherited]

  The stream where the batch memop is executed.

Sanitizer_BatchMemopType Sanitizer_BatchMemopData::type [inherited]

  Type of batch memory operation.

uint64_t Sanitizer_BatchMemopData::value [inherited]

  The value to be written.

### 2.2. Sanitizer_CallbackData Struct Reference

### [Sanitizer Callback API]

Data passed into a runtime or driver API callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_DRIVER_API or SANITIZER_CB_DOMAIN_RUNTIME_API. The callback data is valid only within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make of a copy of that data. For example, if you make a shallow copy of Sanitizer_CallbackData within a callback, you cannot dereference `functionParams` outside of that callback to access the function parameters. `functionName` is an exception: the string pointed to by `functionName` is a global constant and so may be accessed outside of the callback.

#### Public Variables

Sanitizer_ApiCallbackSite callbackSite
CUcontext context
const char * functionName
const void * functionParams
const void * functionReturnValue
const char * symbolName

#### Variables

Sanitizer_ApiCallbackSite Sanitizer_CallbackData::callbackSite [inherited]

  Point in the runtime or driver function from where the callback was issued.

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.

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`.

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.

### 2.3. Sanitizer_EventData Struct Reference

### [Sanitizer Callback API]

Data passed into an event callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal tp SANITIZER_CB_DOMAIN_EVENTS. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
CUevent event
Sanitizer_StreamHandle hStream
CUstream stream

#### Variables

CUcontext Sanitizer_EventData::context [inherited]

  For SANITIZER_CBID_EVENTS_CREATED, SANITIZER_CBID_EVENTS_DESTROYED, and SANITIZER_CBID_EVENTS_SYNCHNONIZED, this is the context containing the event. For SANITIZER_CBID_EVENTS_RECORD and SANITIZER_CBID_EVENTS_STREAM_WAIT, this is the context containing the stream being recorded or waiting.

CUevent Sanitizer_EventData::event [inherited]

  The event recording or being waited.

Sanitizer_StreamHandle Sanitizer_EventData::hStream [inherited]

  Unique handle for the stream.

CUstream Sanitizer_EventData::stream [inherited]

  The stream being recorded or waiting. Available if cbid is SANITIZER_CBID_EVENTS_RECORD or SANITIZER_CBID_EVENTS_STREAM_WAIT.

### 2.4. Sanitizer_ExternalMemoryData Struct Reference

### [Sanitizer Callback API]

Data passed into an event callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal tp SANITIZER_CB_DOMAIN_EXTERNAL_MEMORY. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint64_t address
CUcontext context
CUdevice device
CUexternalMemory extMemory
uint64_t size

#### Variables

uint64_t Sanitizer_ExternalMemoryData::address [inherited]

  Address of the mapped memory. This field is only valid for SANITIZER_CBID_EXTERNAL_MEMORY_MAPPED

CUcontext Sanitizer_ExternalMemoryData::context [inherited]

  Context containing the external memory.

CUdevice Sanitizer_ExternalMemoryData::device [inherited]

  Device containing the external memory.

CUexternalMemory Sanitizer_ExternalMemoryData::extMemory [inherited]

  External memory object.

uint64_t Sanitizer_ExternalMemoryData::size [inherited]

  Size of the memory imported or mapped. This field is only valid for SANITIZER_CBID_EXTERNAL_MEMORY_IMPORT and SANITIZER_CBID_EXTERNAL_MEMORY_MAPPED.

### 2.5. Sanitizer_GraphExecData Struct Reference

### [Sanitizer Callback API]

Data passed into a graphs callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_GRAPHS and `cbid` equal to SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATING. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint32_t containsDeviceGraphLaunches
CUcontext deviceGraphLaunchesContext
CUgraph graph
CUgraphExec graphExec
uint32_t isDeviceLaunch

#### Variables

uint32_t Sanitizer_GraphExecData::containsDeviceGraphLaunches [inherited]

  Boolean value indicating if the graphexec may launch device graphs. Only valid in the SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATED callback with driver version of 535 or newer.

CUcontext Sanitizer_GraphExecData::deviceGraphLaunchesContext [inherited]

  Context where the graphexec can launch device graphs. NULL if the graphExec doesn't launch device graphs. Only valid in the SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATED callback with driver version of 535 or newer.

CUgraph Sanitizer_GraphExecData::graph [inherited]

  CUDA graph being instantiated.

CUgraphExec Sanitizer_GraphExecData::graphExec [inherited]

  Instance of the CUDA graph. Can be NULL for device graph launches in the SANITIZER_CBID_GRAPHS_GRAPHEXEC_CREATING callback.

uint32_t Sanitizer_GraphExecData::isDeviceLaunch [inherited]

  Boolean value indicating if the graphexec is for a device graph launch

### 2.6. Sanitizer_GraphLaunchData Struct Reference

### [Sanitizer Callback API]

Data passed into a graphs callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_GRAPHS and `cbid` equal to SANITIZER_CBID_GRAPHS_LAUNCH_BEGIN or SANITIZER_CBID_GRAPHS_LAUNCH_END. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
CUgraphExec graphExec
Sanitizer_StreamHandle hStream
uint32_t isGraphUpload
CUstream stream

#### Variables

CUcontext Sanitizer_GraphLaunchData::context [inherited]

  The context where the graph is launched.

CUgraphExec Sanitizer_GraphLaunchData::graphExec [inherited]

  Instance of the CUDA graph being launched.

Sanitizer_StreamHandle Sanitizer_GraphLaunchData::hStream [inherited]

  Unique handle for the stream.

uint32_t Sanitizer_GraphLaunchData::isGraphUpload [inherited]

  Boolean value indicating if the launch callback is part of a graph upload. This field is only valid if the driver version is 510 or newer.

CUstream Sanitizer_GraphLaunchData::stream [inherited]

  The stream where the graph is launched.

### 2.7. Sanitizer_GraphNodeLaunchData Struct Reference

### [Sanitizer Callback API]

Data passed into a graphs callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_GRAPHS and `cbid` equal to SANITIZER_CBID_GRAPHS_LAUNCH_NODE_BEGIN or SANITIZER_CBID_GRAPHS_LAUNCH_NODE_END. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUgraphExec graphExec
uint32_t isGraphUpload
struct Sanitizer_LaunchData launchData
uint32_t launchId
struct Sanitizer_ResourceMemoryData memAllocData
uint64_t memFreeAddress
struct Sanitizer_MemcpyData memcpyData
struct Sanitizer_MemsetData memsetData
CUgraphNode node
CUgraphNodeType nodeType

#### Variables

CUgraphExec Sanitizer_GraphNodeLaunchData::graphExec [inherited]

  Instance of the CUDA graph being launched.

uint32_t Sanitizer_GraphNodeLaunchData::isGraphUpload [inherited]

  Boolean value indicating if the node launch callback is part of a graph upload.

struct Sanitizer_LaunchData Sanitizer_GraphNodeLaunchData::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

struct Sanitizer_ResourceMemoryData Sanitizer_GraphNodeLaunchData::memAllocData [inherited]

  This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEM_ALLOC.

uint64_t Sanitizer_GraphNodeLaunchData::memFreeAddress [inherited]

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

struct Sanitizer_MemcpyData Sanitizer_GraphNodeLaunchData::memcpyData [inherited]

  This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEMCPY.

struct Sanitizer_MemsetData Sanitizer_GraphNodeLaunchData::memsetData [inherited]

  This is only valid if nodeType is CU_GRAPH_NODE_TYPE_MEMSET.

CUgraphNode Sanitizer_GraphNodeLaunchData::node [inherited]

  CUDA graphs node being launched.

CUgraphNodeType Sanitizer_GraphNodeLaunchData::nodeType [inherited]

  CUDA graphs node type.

### 2.8. Sanitizer_LaunchData Struct Reference

### [Sanitizer Callback API]

Data passed into a launch callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_LAUNCH. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext apiContext
CUstream apiStream
CUcontext context
CUdevice device
CUfunction function
const char * functionName
uint64_t gridId
Sanitizer_StreamHandle hApiStream
Sanitizer_LaunchHandle hLaunch
Sanitizer_StreamHandle hStream
CUmodule module
CUstream stream

#####

uint32_t blockDim_x
uint32_t blockDim_y
uint32_t blockDim_z
uint32_t clusterDim_x
uint32_t clusterDim_y
uint32_t clusterDim_z
uint32_t gridDim_x
uint32_t gridDim_y
uint32_t gridDim_z

#### Variables

CUcontext Sanitizer_LaunchData::apiContext [inherited]

  Only valid for graph node launches. This is the context of the stream used in the graph launch API call.

CUstream Sanitizer_LaunchData::apiStream [inherited]

  Only valid for graph node launches. This is the stream used in the graph launch API call.

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

uint32_t Sanitizer_LaunchData::clusterDim_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::clusterDim_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::clusterDim_z [inherited]

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

CUcontext Sanitizer_LaunchData::context [inherited]

  The context where the grid is launched. For graph node launches, this is the context in which the kernel will run.

CUdevice Sanitizer_LaunchData::device [inherited]

  The device where the grid is launched

CUfunction Sanitizer_LaunchData::function [inherited]

  The function of the grid launch.

const char * Sanitizer_LaunchData::functionName [inherited]

  The name of the launched function.

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.

Sanitizer_StreamHandle Sanitizer_LaunchData::hApiStream [inherited]

  Unique handle for the API 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_LaunchData::hStream [inherited]

  Unique handle for the stream.

CUmodule Sanitizer_LaunchData::module [inherited]

  The module containing the grid code.

CUstream Sanitizer_LaunchData::stream [inherited]

  The stream where the grid is launched.

### 2.9. Sanitizer_MemcpyData Struct Reference

### [Sanitizer Callback API]

Data passed into a launch callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_MEMCPY. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

Sanitizer_MemcpyDirection direction
uint64_t dstAddress
CUcontext dstContext
uint64_t dstPitch
CUstream dstStream
Sanitizer_StreamHandle hDstStream
Sanitizer_StreamHandle hSrcStream
uint32_t isAsync
uint64_t size
uint64_t srcAddress
CUcontext srcContext
uint64_t srcPitch
CUstream srcStream
uint64_t width

#### Variables

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

Sanitizer_StreamHandle Sanitizer_MemcpyData::hDstStream [inherited]

  Unique handle for the destination context stream.

Sanitizer_StreamHandle Sanitizer_MemcpyData::hSrcStream [inherited]

  Unique handle for the source context stream.

uint32_t Sanitizer_MemcpyData::isAsync [inherited]

  Boolean value indicating if the transfer is asynchronous.

uint64_t Sanitizer_MemcpyData::size [inherited]

  Size of the transfer in bytes.

uint64_t Sanitizer_MemcpyData::srcAddress [inherited]

  The source allocation address.

CUcontext Sanitizer_MemcpyData::srcContext [inherited]

  The context where the source allocation is located

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

uint64_t Sanitizer_MemcpyData::width [inherited]

  Memcpy size configuration.

### 2.10. Sanitizer_MemsetData Struct Reference

### [Sanitizer Callback API]

Data passed into a launch callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_MEMSET. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint64_t address
CUcontext context
Sanitizer_StreamHandle hStream
uint32_t isAsync
CUstream stream
uint32_t value
uint64_t width

#### Variables

uint64_t Sanitizer_MemsetData::address [inherited]

  The address of the memset start.

CUcontext Sanitizer_MemsetData::context [inherited]

  The context where the allocation is located.

Sanitizer_StreamHandle Sanitizer_MemsetData::hStream [inherited]

  Unique handle for the stream.

uint32_t Sanitizer_MemsetData::isAsync [inherited]

  Boolean value indicating if the transfer is asynchronous.

CUstream Sanitizer_MemsetData::stream [inherited]

  The stream where the memset is executed.

uint32_t Sanitizer_MemsetData::value [inherited]

  Value to be written.

uint64_t Sanitizer_MemsetData::width [inherited]

  Memset size configuration.

### 2.11. Sanitizer_ResourceArrayData Struct Reference

### [Sanitizer Callback API]

Data passed into a CUDA array callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal tp SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_ARRAY_CREATED or SANITIZER_CBID_RESOURCE_ARRAY_DESTROYED. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
CUarray hArray
uint64_t width

#### Variables

CUcontext Sanitizer_ResourceArrayData::context [inherited]

  The context containing the array being created or destroyed.

CUarray Sanitizer_ResourceArrayData::hArray [inherited]

  The CUDA array being created or destroyed.

uint64_t Sanitizer_ResourceArrayData::width [inherited]

  The CUDA array size.

### 2.12. Sanitizer_ResourceContextData Struct Reference

### [Sanitizer Callback API]

Data passed into a context resource callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_STARTING, SANITIZER_CBID_RESOURCE_CONTEXT_CREATION_FINISHED, SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_STARTING or SANITIZER_CBID_RESOURCE_CONTEXT_DESTROY_FINISHED. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
CUdevice device

#### Variables

CUcontext Sanitizer_ResourceContextData::context [inherited]

  The context being created or destroyed.

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

### 2.13. Sanitizer_ResourceFunctionsLazyLoadedData Struct Reference

### [Sanitizer Callback API]

Data passed into a CUDA function callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal tp SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_FUNCTIONS_LAZY_LOADED or SANITIZER_CBID_RESOURCE_FUNCTIONS_LAZY_PATCHED. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
const CUfunction * functions
CUmodule module
uint32_t numFunctions

#### Variables

CUcontext Sanitizer_ResourceFunctionsLazyLoadedData::context [inherited]

  The context containing the functions.

const CUfunction * Sanitizer_ResourceFunctionsLazyLoadedData::functions [inherited]

  An array containing the functions.

CUmodule Sanitizer_ResourceFunctionsLazyLoadedData::module [inherited]

  The module containing the functions.

uint32_t Sanitizer_ResourceFunctionsLazyLoadedData::numFunctions [inherited]

  The size of the function array.

### 2.14. Sanitizer_ResourceMemoryData Struct Reference

### [Sanitizer Callback API]

Data passed into a memory resource callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_ALLOC, SANITIZER_CBID_RESOURCE_DEVICE_MEMORY_FREE, SANITIZER_CBID_RESOURCE_HOST_MEMORY_ALLOC, SANITIZER_CBID_RESOURCE_HOST_MEMORY_FREE, SANITIZER_CBID_RESOURCE_MEMORY_ALLOC_ASYNC, SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC or SANITIZER_CBID_RESOURCE_MEMORY_FREE_ASYNC_DONE. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint64_t address
CUcontext context
CUdevice device
uint32_t flags
Sanitizer_StreamHandle hStream
CUmemoryPool memoryPool
uint32_t permissions
uint64_t size
CUdevice sourceDevice
CUstream stream
Sanitizer_MemoryVisibility visibility

#### Variables

uint64_t Sanitizer_ResourceMemoryData::address [inherited]

  Address of the allocation being created or destroyed.

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.

CUdevice Sanitizer_ResourceMemoryData::device [inherited]

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

uint32_t Sanitizer_ResourceMemoryData::flags [inherited]

  Allocation details: use Sanitizer_ResourceMemoryFlags to interpret this field.

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.

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.

uint32_t Sanitizer_ResourceMemoryData::permissions [inherited]

  Allocation permissions: use Sanitizer_ResourceMemoryPermissions to interpret this field.

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).

CUstream Sanitizer_ResourceMemoryData::stream [inherited]

  Public handle for the stream.

Sanitizer_MemoryVisibility Sanitizer_ResourceMemoryData::visibility [inherited]

  Visibility of the allocation.

### 2.15. Sanitizer_ResourceMempoolData Struct Reference

### [Sanitizer Callback API]

Data passed into a mempool resource callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_MEMPOOL_CREATED, SANITIZER_CBID_RESOURCE_MEMPOOL_DESTROYING, SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_ENABLED or SANITIZER_CBID_RESOURCE_MEMPOOL_PEER_ACCESS_DISABLING. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUdevice device
CUmemoryPool memoryPool
CUdevice peerDevice

#### Variables

CUdevice Sanitizer_ResourceMempoolData::device [inherited]

  Device that owns the memory pool.

CUmemoryPool Sanitizer_ResourceMempoolData::memoryPool [inherited]

  Memory pool being created or destroyed.

CUdevice Sanitizer_ResourceMempoolData::peerDevice [inherited]

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

### 2.16. Sanitizer_ResourceModuleData Struct Reference

### [Sanitizer Callback API]

Data passed into a module resource callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_MODULE_LOADED or SANITIZER_CBID_RESOURCE_MODULE_UNLOAD_STARTING. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
size_t cubinSize
CUlibrary library
CUmodule module
const char * pCubin

#### Variables

CUcontext Sanitizer_ResourceModuleData::context [inherited]

  The context containing the module being loaded or unloaded.

size_t Sanitizer_ResourceModuleData::cubinSize [inherited]

  The size of the cubin.

CUlibrary Sanitizer_ResourceModuleData::library [inherited]

  Library associated with the module.

CUmodule Sanitizer_ResourceModuleData::module [inherited]

  The module being loaded or unloaded.

const char * Sanitizer_ResourceModuleData::pCubin [inherited]

  Pointer to the associated cubin.

### 2.17. Sanitizer_ResourceStreamData Struct Reference

### [Sanitizer Callback API]

Data passed into a stream resource callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_STREAM_CREATED, SANITIZER_CBID_RESOURCE_STREAM_DESTROY_STARTING or SANITIZER_CBID_RESOURCE_STREAM_DESTROY_FINISHED. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
Sanitizer_StreamHandle hStream
CUstream stream

#### Variables

CUcontext Sanitizer_ResourceStreamData::context [inherited]

  The context containing the stream being created or destroyed.

Sanitizer_StreamHandle Sanitizer_ResourceStreamData::hStream [inherited]

  Unique handle for the stream.

CUstream Sanitizer_ResourceStreamData::stream [inherited]

  The stream being created or destroyed. This handle will be NULL for the STREAM_DESTROY_FINISHED cbid.

### 2.18. Sanitizer_ResourceVirtualRange Struct Reference

### [Sanitizer Callback API]

Data passed into a VA reservation callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal tp SANITIZER_CB_DOMAIN_RESOURCE and `cbid` equal to SANITIZER_CBID_RESOURCE_VIRTUAL_RESERVE. or SANITIZER_CBID_RESOURCE_VIRTUAL_RELEASE. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it. Available with a driver version of 535 or newer.

#### Public Variables

uint64_t address
uint64_t size

#### Variables

uint64_t Sanitizer_ResourceVirtualRange::address [inherited]

  Address of the VA range being reserved or released.

uint64_t Sanitizer_ResourceVirtualRange::size [inherited]

  Size of the VA range being reserved or released.

### 2.19. Sanitizer_SynchronizeData Struct Reference

### [Sanitizer Callback API]

Data passed into a synchronization callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_SYNCHRONIZE. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

CUcontext context
Sanitizer_StreamHandle hStream
CUstream stream

#### Variables

CUcontext Sanitizer_SynchronizeData::context [inherited]

  For SANITIZER_CBID_SYNCHRONIZE_CONTEXT_SYNCHRONIZED, this is the context being synchronized. For SANITIZER_CBID_SYNCHRONIZE_STREAM_SYNCHRONIZED, this is the context of the stream being synchronized.

Sanitizer_StreamHandle Sanitizer_SynchronizeData::hStream [inherited]

  Unique handle for the stream.

CUstream Sanitizer_SynchronizeData::stream [inherited]

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

### 2.20. Sanitizer_UvmData Struct Reference

### [Sanitizer Callback API]

Data passed into a managed memory callback function as the `cbdata` argument to Sanitizer_CallbackFunc. The `cbdata` will be this type for `domain` equal to SANITIZER_CB_DOMAIN_UVM. The callback data is only valid within the invocation of the callback function that is passed the data. If you need to retain some data for use outside of the callback, you must make a copy of it.

#### Public Variables

uint64_t address
CUcontext context
Sanitizer_StreamHandle hStream
CUstream stream
Sanitizer_MemoryVisibility visibility

#### Variables

uint64_t Sanitizer_UvmData::address [inherited]

  The address of the allocation.

CUcontext Sanitizer_UvmData::context [inherited]

  The context where the allocation is located.

Sanitizer_StreamHandle Sanitizer_UvmData::hStream [inherited]

  Unique handle for the stream.

CUstream Sanitizer_UvmData::stream [inherited]

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

Sanitizer_MemoryVisibility Sanitizer_UvmData::visibility [inherited]

  New visibility for the allocation.