# Copyright 2021-2024 NVIDIA Corporation. All rights reserved. # # Please refer to the NVIDIA end user license agreement (EULA) associated # with this source code for terms and conditions that govern your use of # this software. Any use, reproduction, disclosure, or distribution of # this software and related documentation outside the terms of the EULA # is strictly prohibited. cimport cuda.ccudart as ccudart cimport cuda._lib.utils as utils cimport cuda.cuda as cuda {{if 'cudaArray_t' in found_types}} cdef class cudaArray_t: """ CUDA array Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaArray_t __val cdef ccudart.cudaArray_t* _ptr {{endif}} {{if 'cudaArray_const_t' in found_types}} cdef class cudaArray_const_t: """ CUDA array (as source copy argument) Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaArray_const_t __val cdef ccudart.cudaArray_const_t* _ptr {{endif}} {{if 'cudaMipmappedArray_t' in found_types}} cdef class cudaMipmappedArray_t: """ CUDA mipmapped array Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMipmappedArray_t __val cdef ccudart.cudaMipmappedArray_t* _ptr {{endif}} {{if 'cudaMipmappedArray_const_t' in found_types}} cdef class cudaMipmappedArray_const_t: """ CUDA mipmapped array (as source argument) Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMipmappedArray_const_t __val cdef ccudart.cudaMipmappedArray_const_t* _ptr {{endif}} {{if 'cudaGraphicsResource_t' in found_types}} cdef class cudaGraphicsResource_t: """ CUDA graphics resource types Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphicsResource_t __val cdef ccudart.cudaGraphicsResource_t* _ptr {{endif}} {{if 'cudaExternalMemory_t' in found_types}} cdef class cudaExternalMemory_t: """ CUDA external memory Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemory_t __val cdef ccudart.cudaExternalMemory_t* _ptr {{endif}} {{if 'cudaExternalSemaphore_t' in found_types}} cdef class cudaExternalSemaphore_t: """ CUDA external semaphore Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphore_t __val cdef ccudart.cudaExternalSemaphore_t* _ptr {{endif}} {{if 'cudaKernel_t' in found_types}} cdef class cudaKernel_t: """ CUDA kernel Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaKernel_t __val cdef ccudart.cudaKernel_t* _ptr {{endif}} {{if 'cudaGraphDeviceNode_t' in found_types}} cdef class cudaGraphDeviceNode_t: """ CUDA device node handle for device-side node update Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphDeviceNode_t __val cdef ccudart.cudaGraphDeviceNode_t* _ptr {{endif}} {{if 'cudaAsyncCallbackHandle_t' in found_types}} cdef class cudaAsyncCallbackHandle_t: """ CUDA async callback handle Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAsyncCallbackHandle_t __val cdef ccudart.cudaAsyncCallbackHandle_t* _ptr {{endif}} {{if True}} cdef class EGLImageKHR: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.EGLImageKHR __val cdef ccudart.EGLImageKHR* _ptr {{endif}} {{if True}} cdef class EGLStreamKHR: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.EGLStreamKHR __val cdef ccudart.EGLStreamKHR* _ptr {{endif}} {{if True}} cdef class EGLSyncKHR: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.EGLSyncKHR __val cdef ccudart.EGLSyncKHR* _ptr {{endif}} {{if 'cudaHostFn_t' in found_types}} cdef class cudaHostFn_t: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaHostFn_t __val cdef ccudart.cudaHostFn_t* _ptr {{endif}} {{if 'cudaAsyncCallback' in found_types}} cdef class cudaAsyncCallback: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAsyncCallback __val cdef ccudart.cudaAsyncCallback* _ptr {{endif}} {{if 'cudaStreamCallback_t' in found_types}} cdef class cudaStreamCallback_t: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaStreamCallback_t __val cdef ccudart.cudaStreamCallback_t* _ptr {{endif}} {{if 'struct dim3' in found_types}} cdef class dim3: """ Attributes ---------- x : unsigned int y : unsigned int z : unsigned int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.dim3 __val cdef ccudart.dim3* _ptr {{endif}} {{if 'struct cudaChannelFormatDesc' in found_types}} cdef class cudaChannelFormatDesc: """ CUDA Channel format descriptor Attributes ---------- x : int x y : int y z : int z w : int w f : cudaChannelFormatKind Channel format kind Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaChannelFormatDesc __val cdef ccudart.cudaChannelFormatDesc* _ptr {{endif}} {{if 'struct cudaArraySparseProperties' in found_types}} cdef class anon_struct0: """ Attributes ---------- width : unsigned int height : unsigned int depth : unsigned int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaArraySparseProperties* _ptr {{endif}} {{if 'struct cudaArraySparseProperties' in found_types}} cdef class cudaArraySparseProperties: """ Sparse CUDA array and CUDA mipmapped array properties Attributes ---------- tileExtent : anon_struct0 miptailFirstLevel : unsigned int First mip level at which the mip tail begins miptailSize : unsigned long long Total size of the mip tail. flags : unsigned int Flags will either be zero or cudaArraySparsePropertiesSingleMipTail reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaArraySparseProperties __val cdef ccudart.cudaArraySparseProperties* _ptr cdef anon_struct0 _tileExtent {{endif}} {{if 'struct cudaArrayMemoryRequirements' in found_types}} cdef class cudaArrayMemoryRequirements: """ CUDA array and CUDA mipmapped array memory requirements Attributes ---------- size : size_t Total size of the array. alignment : size_t Alignment necessary for mapping the array. reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaArrayMemoryRequirements __val cdef ccudart.cudaArrayMemoryRequirements* _ptr {{endif}} {{if 'struct cudaPitchedPtr' in found_types}} cdef class cudaPitchedPtr: """ CUDA Pitched memory pointer ::make_cudaPitchedPtr Attributes ---------- ptr : Any Pointer to allocated memory pitch : size_t Pitch of allocated memory in bytes xsize : size_t Logical width of allocation in elements ysize : size_t Logical height of allocation in elements Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaPitchedPtr __val cdef ccudart.cudaPitchedPtr* _ptr {{endif}} {{if 'struct cudaExtent' in found_types}} cdef class cudaExtent: """ CUDA extent ::make_cudaExtent Attributes ---------- width : size_t Width in elements when referring to array memory, in bytes when referring to linear memory height : size_t Height in elements depth : size_t Depth in elements Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExtent __val cdef ccudart.cudaExtent* _ptr {{endif}} {{if 'struct cudaPos' in found_types}} cdef class cudaPos: """ CUDA 3D position ::make_cudaPos Attributes ---------- x : size_t x y : size_t y z : size_t z Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaPos __val cdef ccudart.cudaPos* _ptr {{endif}} {{if 'struct cudaMemcpy3DParms' in found_types}} cdef class cudaMemcpy3DParms: """ CUDA 3D memory copying parameters Attributes ---------- srcArray : cudaArray_t Source memory address srcPos : cudaPos Source position offset srcPtr : cudaPitchedPtr Pitched source memory address dstArray : cudaArray_t Destination memory address dstPos : cudaPos Destination position offset dstPtr : cudaPitchedPtr Pitched destination memory address extent : cudaExtent Requested memory copy size kind : cudaMemcpyKind Type of transfer Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemcpy3DParms __val cdef ccudart.cudaMemcpy3DParms* _ptr cdef cudaArray_t _srcArray cdef cudaPos _srcPos cdef cudaPitchedPtr _srcPtr cdef cudaArray_t _dstArray cdef cudaPos _dstPos cdef cudaPitchedPtr _dstPtr cdef cudaExtent _extent {{endif}} {{if 'struct cudaMemcpyNodeParams' in found_types}} cdef class cudaMemcpyNodeParams: """ Memcpy node parameters Attributes ---------- flags : int Must be zero reserved : List[int] Must be zero copyParams : cudaMemcpy3DParms Parameters for the memory copy Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemcpyNodeParams __val cdef ccudart.cudaMemcpyNodeParams* _ptr cdef cudaMemcpy3DParms _copyParams {{endif}} {{if 'struct cudaMemcpy3DPeerParms' in found_types}} cdef class cudaMemcpy3DPeerParms: """ CUDA 3D cross-device memory copying parameters Attributes ---------- srcArray : cudaArray_t Source memory address srcPos : cudaPos Source position offset srcPtr : cudaPitchedPtr Pitched source memory address srcDevice : int Source device dstArray : cudaArray_t Destination memory address dstPos : cudaPos Destination position offset dstPtr : cudaPitchedPtr Pitched destination memory address dstDevice : int Destination device extent : cudaExtent Requested memory copy size Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemcpy3DPeerParms __val cdef ccudart.cudaMemcpy3DPeerParms* _ptr cdef cudaArray_t _srcArray cdef cudaPos _srcPos cdef cudaPitchedPtr _srcPtr cdef cudaArray_t _dstArray cdef cudaPos _dstPos cdef cudaPitchedPtr _dstPtr cdef cudaExtent _extent {{endif}} {{if 'struct cudaMemsetParams' in found_types}} cdef class cudaMemsetParams: """ CUDA Memset node parameters Attributes ---------- dst : Any Destination device pointer pitch : size_t Pitch of destination device pointer. Unused if height is 1 value : unsigned int Value to be set elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. width : size_t Width of the row in elements height : size_t Number of rows Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemsetParams __val cdef ccudart.cudaMemsetParams* _ptr {{endif}} {{if 'struct cudaMemsetParamsV2' in found_types}} cdef class cudaMemsetParamsV2: """ CUDA Memset node parameters Attributes ---------- dst : Any Destination device pointer pitch : size_t Pitch of destination device pointer. Unused if height is 1 value : unsigned int Value to be set elementSize : unsigned int Size of each element in bytes. Must be 1, 2, or 4. width : size_t Width of the row in elements height : size_t Number of rows Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemsetParamsV2 __val cdef ccudart.cudaMemsetParamsV2* _ptr {{endif}} {{if 'struct cudaAccessPolicyWindow' in found_types}} cdef class cudaAccessPolicyWindow: """ Specifies an access policy for a window, a contiguous extent of memory beginning at base_ptr and ending at base_ptr + num_bytes. Partition into many segments and assign segments such that. sum of "hit segments" / window == approx. ratio. sum of "miss segments" / window == approx 1-ratio. Segments and ratio specifications are fitted to the capabilities of the architecture. Accesses in a hit segment apply the hitProp access policy. Accesses in a miss segment apply the missProp access policy. Attributes ---------- base_ptr : Any Starting address of the access policy window. CUDA driver may align it. num_bytes : size_t Size in bytes of the window policy. CUDA driver may restrict the maximum size and alignment. hitRatio : float hitRatio specifies percentage of lines assigned hitProp, rest are assigned missProp. hitProp : cudaAccessProperty ::CUaccessProperty set for hit. missProp : cudaAccessProperty ::CUaccessProperty set for miss. Must be either NORMAL or STREAMING. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAccessPolicyWindow __val cdef ccudart.cudaAccessPolicyWindow* _ptr {{endif}} {{if 'struct cudaHostNodeParams' in found_types}} cdef class cudaHostNodeParams: """ CUDA host node parameters Attributes ---------- fn : cudaHostFn_t The function to call when the node executes userData : Any Argument to pass to the function Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaHostNodeParams __val cdef ccudart.cudaHostNodeParams* _ptr cdef cudaHostFn_t _fn {{endif}} {{if 'struct cudaHostNodeParamsV2' in found_types}} cdef class cudaHostNodeParamsV2: """ CUDA host node parameters Attributes ---------- fn : cudaHostFn_t The function to call when the node executes userData : Any Argument to pass to the function Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaHostNodeParamsV2 __val cdef ccudart.cudaHostNodeParamsV2* _ptr cdef cudaHostFn_t _fn {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class anon_struct1: """ Attributes ---------- array : cudaArray_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _ptr cdef cudaArray_t _array {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class anon_struct2: """ Attributes ---------- mipmap : cudaMipmappedArray_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _ptr cdef cudaMipmappedArray_t _mipmap {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class anon_struct3: """ Attributes ---------- devPtr : Any desc : cudaChannelFormatDesc sizeInBytes : size_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _ptr cdef cudaChannelFormatDesc _desc {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class anon_struct4: """ Attributes ---------- devPtr : Any desc : cudaChannelFormatDesc width : size_t height : size_t pitchInBytes : size_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _ptr cdef cudaChannelFormatDesc _desc {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class anon_union0: """ Attributes ---------- array : anon_struct1 mipmap : anon_struct2 linear : anon_struct3 pitch2D : anon_struct4 Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _ptr cdef anon_struct1 _array cdef anon_struct2 _mipmap cdef anon_struct3 _linear cdef anon_struct4 _pitch2D {{endif}} {{if 'struct cudaResourceDesc' in found_types}} cdef class cudaResourceDesc: """ CUDA resource descriptor Attributes ---------- resType : cudaResourceType Resource type res : anon_union0 Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceDesc* _val_ptr cdef ccudart.cudaResourceDesc* _ptr cdef anon_union0 _res {{endif}} {{if 'struct cudaResourceViewDesc' in found_types}} cdef class cudaResourceViewDesc: """ CUDA resource view descriptor Attributes ---------- format : cudaResourceViewFormat Resource view format width : size_t Width of the resource view height : size_t Height of the resource view depth : size_t Depth of the resource view firstMipmapLevel : unsigned int First defined mipmap level lastMipmapLevel : unsigned int Last defined mipmap level firstLayer : unsigned int First layer index lastLayer : unsigned int Last layer index Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaResourceViewDesc __val cdef ccudart.cudaResourceViewDesc* _ptr {{endif}} {{if 'struct cudaPointerAttributes' in found_types}} cdef class cudaPointerAttributes: """ CUDA pointer attributes Attributes ---------- type : cudaMemoryType The type of memory - cudaMemoryTypeUnregistered, cudaMemoryTypeHost, cudaMemoryTypeDevice or cudaMemoryTypeManaged. device : int The device against which the memory was allocated or registered. If the memory type is cudaMemoryTypeDevice then this identifies the device on which the memory referred physically resides. If the memory type is cudaMemoryTypeHost or::cudaMemoryTypeManaged then this identifies the device which was current when the memory was allocated or registered (and if that device is deinitialized then this allocation will vanish with that device's state). devicePointer : Any The address which may be dereferenced on the current device to access the memory or NULL if no such address exists. hostPointer : Any The address which may be dereferenced on the host to access the memory or NULL if no such address exists. CUDA doesn't check if unregistered memory is allocated so this field may contain invalid pointer if an invalid pointer has been passed to CUDA. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaPointerAttributes __val cdef ccudart.cudaPointerAttributes* _ptr {{endif}} {{if 'struct cudaFuncAttributes' in found_types}} cdef class cudaFuncAttributes: """ CUDA function attributes Attributes ---------- sharedSizeBytes : size_t The size in bytes of statically-allocated shared memory per block required by this function. This does not include dynamically- allocated shared memory requested by the user at runtime. constSizeBytes : size_t The size in bytes of user-allocated constant memory required by this function. localSizeBytes : size_t The size in bytes of local memory used by each thread of this function. maxThreadsPerBlock : int 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. numRegs : int The number of registers used by each thread of this function. ptxVersion : int 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. binaryVersion : int 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. cacheModeCA : int The attribute to indicate whether the function has been compiled with user specified option "-Xptxas --dlcm=ca" set. maxDynamicSharedSizeBytes : int The maximum size in bytes of dynamic shared memory per block for this function. Any launch must have a dynamic shared memory size smaller than this value. preferredShmemCarveout : int 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 maximum shared memory. Refer to cudaDevAttrMaxSharedMemoryPerMultiprocessor. This is only a hint, and the driver can choose a different ratio if required to execute the function. See cudaFuncSetAttribute clusterDimMustBeSet : int If this attribute is set, the kernel must launch with a valid cluster dimension specified. requiredClusterWidth : int The required cluster width/height/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 cudaErrorNotPermitted. See cudaFuncSetAttribute requiredClusterHeight : int requiredClusterDepth : int clusterSchedulingPolicyPreference : int The block scheduling policy of a function. See cudaFuncSetAttribute nonPortableClusterSizeAllowed : int 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. CUDA API provides cudaOccupancyMaxActiveClusters to assist with checking whether the desired size can be launched on the current device. Portable Cluster Size A portable cluster size is guaranteed to be functional on all compute capabilities higher than the target compute capability. The portable cluster size for sm_90 is 8 blocks per cluster. This value may increase for future compute capabilities. The specific hardware unit may support higher cluster sizes that’s not guaranteed to be portable. See cudaFuncSetAttribute reserved : List[int] Reserved for future use. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaFuncAttributes __val cdef ccudart.cudaFuncAttributes* _ptr {{endif}} {{if 'struct cudaMemLocation' in found_types}} cdef class cudaMemLocation: """ Specifies a memory location. To specify a gpu, set type = cudaMemLocationTypeDevice and set id = the gpu's device ordinal. To specify a cpu NUMA node, set type = cudaMemLocationTypeHostNuma and set id = host NUMA node id. Attributes ---------- type : cudaMemLocationType Specifies the location type, which modifies the meaning of id. id : int identifier for a given this location's ::CUmemLocationType. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemLocation __val cdef ccudart.cudaMemLocation* _ptr {{endif}} {{if 'struct cudaMemAccessDesc' in found_types}} cdef class cudaMemAccessDesc: """ Memory access descriptor Attributes ---------- location : cudaMemLocation Location on which the request is to change it's accessibility flags : cudaMemAccessFlags ::CUmemProt accessibility flags to set on the request Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemAccessDesc __val cdef ccudart.cudaMemAccessDesc* _ptr cdef cudaMemLocation _location {{endif}} {{if 'struct cudaMemPoolProps' in found_types}} cdef class cudaMemPoolProps: """ Specifies the properties of allocations made from the pool. Attributes ---------- allocType : cudaMemAllocationType Allocation type. Currently must be specified as cudaMemAllocationTypePinned handleTypes : cudaMemAllocationHandleType Handle types that will be supported by allocations from the pool. location : cudaMemLocation Location allocations should reside. win32SecurityAttributes : Any Windows-specific LPSECURITYATTRIBUTES required when cudaMemHandleTypeWin32 is specified. This security attribute defines the scope of which exported allocations may be tranferred to other processes. In all other cases, this field is required to be zero. maxSize : size_t Maximum pool size. When set to 0, defaults to a system dependent value. usage : unsigned short Bitmask indicating intended usage for the pool. reserved : bytes reserved for future use, must be 0 Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemPoolProps __val cdef ccudart.cudaMemPoolProps* _ptr cdef cudaMemLocation _location {{endif}} {{if 'struct cudaMemPoolPtrExportData' in found_types}} cdef class cudaMemPoolPtrExportData: """ Opaque data for exporting a pool allocation Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemPoolPtrExportData __val cdef ccudart.cudaMemPoolPtrExportData* _ptr {{endif}} {{if 'struct cudaMemAllocNodeParams' in found_types}} cdef class cudaMemAllocNodeParams: """ Memory allocation node parameters Attributes ---------- poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. accessDescCount : size_t in: Number of `accessDescs`s bytesize : size_t in: size in bytes of the requested allocation dptr : Any out: address of the allocation returned by CUDA Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemAllocNodeParams __val cdef ccudart.cudaMemAllocNodeParams* _ptr cdef cudaMemPoolProps _poolProps cdef size_t _accessDescs_length cdef ccudart.cudaMemAccessDesc* _accessDescs {{endif}} {{if 'struct cudaMemAllocNodeParamsV2' in found_types}} cdef class cudaMemAllocNodeParamsV2: """ Memory allocation node parameters Attributes ---------- poolProps : cudaMemPoolProps in: location where the allocation should reside (specified in ::location). ::handleTypes must be cudaMemHandleTypeNone. IPC is not supported. in: array of memory access descriptors. Used to describe peer GPU access accessDescs : cudaMemAccessDesc in: number of memory access descriptors. Must not exceed the number of GPUs. accessDescCount : size_t in: Number of `accessDescs`s bytesize : size_t in: size in bytes of the requested allocation dptr : Any out: address of the allocation returned by CUDA Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemAllocNodeParamsV2 __val cdef ccudart.cudaMemAllocNodeParamsV2* _ptr cdef cudaMemPoolProps _poolProps cdef size_t _accessDescs_length cdef ccudart.cudaMemAccessDesc* _accessDescs {{endif}} {{if 'struct cudaMemFreeNodeParams' in found_types}} cdef class cudaMemFreeNodeParams: """ Memory free node parameters Attributes ---------- dptr : Any in: the pointer to free Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemFreeNodeParams __val cdef ccudart.cudaMemFreeNodeParams* _ptr {{endif}} {{if 'struct CUuuid_st' in found_types}} cdef class CUuuid_st: """ Attributes ---------- bytes : bytes < CUDA definition of UUID Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.CUuuid_st __val cdef ccudart.CUuuid_st* _ptr {{endif}} {{if 'struct cudaDeviceProp' in found_types}} cdef class cudaDeviceProp: """ CUDA device properties Attributes ---------- name : bytes ASCII string identifying device uuid : cudaUUID_t 16-byte unique identifier luid : bytes 8-byte locally unique identifier. Value is undefined on TCC and non-Windows platforms luidDeviceNodeMask : unsigned int LUID device node mask. Value is undefined on TCC and non-Windows platforms totalGlobalMem : size_t Global memory available on device in bytes sharedMemPerBlock : size_t Shared memory available per block in bytes regsPerBlock : int 32-bit registers available per block warpSize : int Warp size in threads memPitch : size_t Maximum pitch in bytes allowed by memory copies maxThreadsPerBlock : int Maximum number of threads per block maxThreadsDim : List[int] Maximum size of each dimension of a block maxGridSize : List[int] Maximum size of each dimension of a grid clockRate : int Deprecated, Clock frequency in kilohertz totalConstMem : size_t Constant memory available on device in bytes major : int Major compute capability minor : int Minor compute capability textureAlignment : size_t Alignment requirement for textures texturePitchAlignment : size_t Pitch alignment requirement for texture references bound to pitched memory deviceOverlap : int Device can concurrently copy memory and execute a kernel. Deprecated. Use instead asyncEngineCount. multiProcessorCount : int Number of multiprocessors on device kernelExecTimeoutEnabled : int Deprecated, Specified whether there is a run time limit on kernels integrated : int Device is integrated as opposed to discrete canMapHostMemory : int Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer computeMode : int Deprecated, Compute mode (See cudaComputeMode) maxTexture1D : int Maximum 1D texture size maxTexture1DMipmap : int Maximum 1D mipmapped texture size maxTexture1DLinear : int Deprecated, do not use. Use cudaDeviceGetTexture1DLinearMaxWidth() or cuDeviceGetTexture1DLinearMaxWidth() instead. maxTexture2D : List[int] Maximum 2D texture dimensions maxTexture2DMipmap : List[int] Maximum 2D mipmapped texture dimensions maxTexture2DLinear : List[int] Maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory maxTexture2DGather : List[int] Maximum 2D texture dimensions if texture gather operations have to be performed maxTexture3D : List[int] Maximum 3D texture dimensions maxTexture3DAlt : List[int] Maximum alternate 3D texture dimensions maxTextureCubemap : int Maximum Cubemap texture dimensions maxTexture1DLayered : List[int] Maximum 1D layered texture dimensions maxTexture2DLayered : List[int] Maximum 2D layered texture dimensions maxTextureCubemapLayered : List[int] Maximum Cubemap layered texture dimensions maxSurface1D : int Maximum 1D surface size maxSurface2D : List[int] Maximum 2D surface dimensions maxSurface3D : List[int] Maximum 3D surface dimensions maxSurface1DLayered : List[int] Maximum 1D layered surface dimensions maxSurface2DLayered : List[int] Maximum 2D layered surface dimensions maxSurfaceCubemap : int Maximum Cubemap surface dimensions maxSurfaceCubemapLayered : List[int] Maximum Cubemap layered surface dimensions surfaceAlignment : size_t Alignment requirements for surfaces concurrentKernels : int Device can possibly execute multiple kernels concurrently ECCEnabled : int Device has ECC support enabled pciBusID : int PCI bus ID of the device pciDeviceID : int PCI device ID of the device pciDomainID : int PCI domain ID of the device tccDriver : int 1 if device is a Tesla device using TCC driver, 0 otherwise asyncEngineCount : int Number of asynchronous engines unifiedAddressing : int Device shares a unified address space with the host memoryClockRate : int Deprecated, Peak memory clock frequency in kilohertz memoryBusWidth : int Global memory bus width in bits l2CacheSize : int Size of L2 cache in bytes persistingL2CacheMaxSize : int Device's maximum l2 persisting lines capacity setting in bytes maxThreadsPerMultiProcessor : int Maximum resident threads per multiprocessor streamPrioritiesSupported : int Device supports stream priorities globalL1CacheSupported : int Device supports caching globals in L1 localL1CacheSupported : int Device supports caching locals in L1 sharedMemPerMultiprocessor : size_t Shared memory available per multiprocessor in bytes regsPerMultiprocessor : int 32-bit registers available per multiprocessor managedMemory : int Device supports allocating managed memory on this system isMultiGpuBoard : int Device is on a multi-GPU board multiGpuBoardGroupID : int Unique identifier for a group of devices on the same multi-GPU board hostNativeAtomicSupported : int Link between the device and the host supports native atomic operations singleToDoublePrecisionPerfRatio : int Deprecated, Ratio of single precision performance (in floating- point operations per second) to double precision performance pageableMemoryAccess : int Device supports coherently accessing pageable memory without calling cudaHostRegister on it concurrentManagedAccess : int Device can coherently access managed memory concurrently with the CPU computePreemptionSupported : int Device supports Compute Preemption canUseHostPointerForRegisteredMem : int Device can access host registered memory at the same virtual address as the CPU cooperativeLaunch : int Device supports launching cooperative kernels via cudaLaunchCooperativeKernel cooperativeMultiDeviceLaunch : int Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated. sharedMemPerBlockOptin : size_t Per device maximum shared memory per block usable by special opt in pageableMemoryAccessUsesHostPageTables : int Device accesses pageable memory via the host's page tables directManagedMemAccessFromHost : int Host can directly access managed memory on the device without migration. maxBlocksPerMultiProcessor : int Maximum number of resident blocks per multiprocessor accessPolicyMaxWindowSize : int The maximum value of cudaAccessPolicyWindow::num_bytes. reservedSharedMemPerBlock : size_t Shared memory reserved by CUDA driver per block in bytes hostRegisterSupported : int Device supports host memory registration via cudaHostRegister. sparseCudaArraySupported : int 1 if the device supports sparse CUDA arrays and sparse CUDA mipmapped arrays, 0 otherwise hostRegisterReadOnlySupported : int Device supports using the cudaHostRegister flag cudaHostRegisterReadOnly to register memory that must be mapped as read-only to the GPU timelineSemaphoreInteropSupported : int External timeline semaphore interop is supported on the device memoryPoolsSupported : int 1 if the device supports using the cudaMallocAsync and cudaMemPool family of APIs, 0 otherwise gpuDirectRDMASupported : int 1 if the device supports GPUDirect RDMA APIs, 0 otherwise gpuDirectRDMAFlushWritesOptions : unsigned int Bitmask to be interpreted according to the cudaFlushGPUDirectRDMAWritesOptions enum gpuDirectRDMAWritesOrdering : int See the cudaGPUDirectRDMAWritesOrdering enum for numerical values memoryPoolSupportedHandleTypes : unsigned int Bitmask of handle types supported with mempool-based IPC deferredMappingCudaArraySupported : int 1 if the device supports deferred mapping CUDA arrays and CUDA mipmapped arrays ipcEventSupported : int Device supports IPC Events. clusterLaunch : int Indicates device supports cluster launch unifiedFunctionPointers : int Indicates device supports unified pointers reserved2 : List[int] reserved1 : List[int] Reserved for future use reserved : List[int] Reserved for future use Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaDeviceProp __val cdef ccudart.cudaDeviceProp* _ptr cdef cudaUUID_t _uuid {{endif}} {{if 'struct cudaIpcEventHandle_st' in found_types}} cdef class cudaIpcEventHandle_st: """ CUDA IPC event handle Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaIpcEventHandle_st __val cdef ccudart.cudaIpcEventHandle_st* _ptr {{endif}} {{if 'struct cudaIpcMemHandle_st' in found_types}} cdef class cudaIpcMemHandle_st: """ CUDA IPC memory handle Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaIpcMemHandle_st __val cdef ccudart.cudaIpcMemHandle_st* _ptr {{endif}} {{if 'struct cudaMemFabricHandle_st' in found_types}} cdef class cudaMemFabricHandle_st: """ Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaMemFabricHandle_st __val cdef ccudart.cudaMemFabricHandle_st* _ptr {{endif}} {{if 'struct cudaExternalMemoryHandleDesc' in found_types}} cdef class anon_struct5: """ Attributes ---------- handle : Any name : Any Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemoryHandleDesc* _ptr {{endif}} {{if 'struct cudaExternalMemoryHandleDesc' in found_types}} cdef class anon_union1: """ Attributes ---------- fd : int win32 : anon_struct5 nvSciBufObject : Any Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemoryHandleDesc* _ptr cdef anon_struct5 _win32 {{endif}} {{if 'struct cudaExternalMemoryHandleDesc' in found_types}} cdef class cudaExternalMemoryHandleDesc: """ External memory handle descriptor Attributes ---------- type : cudaExternalMemoryHandleType Type of the handle handle : anon_union1 size : unsigned long long Size of the memory allocation flags : unsigned int Flags must either be zero or cudaExternalMemoryDedicated Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemoryHandleDesc* _val_ptr cdef ccudart.cudaExternalMemoryHandleDesc* _ptr cdef anon_union1 _handle {{endif}} {{if 'struct cudaExternalMemoryBufferDesc' in found_types}} cdef class cudaExternalMemoryBufferDesc: """ External memory buffer descriptor Attributes ---------- offset : unsigned long long Offset into the memory object where the buffer's base is size : unsigned long long Size of the buffer flags : unsigned int Flags reserved for future use. Must be zero. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemoryBufferDesc __val cdef ccudart.cudaExternalMemoryBufferDesc* _ptr {{endif}} {{if 'struct cudaExternalMemoryMipmappedArrayDesc' in found_types}} cdef class cudaExternalMemoryMipmappedArrayDesc: """ External memory mipmap descriptor Attributes ---------- offset : unsigned long long Offset into the memory object where the base level of the mipmap chain is. formatDesc : cudaChannelFormatDesc Format of base level of the mipmap chain extent : cudaExtent Dimensions of base level of the mipmap chain flags : unsigned int Flags associated with CUDA mipmapped arrays. See cudaMallocMipmappedArray numLevels : unsigned int Total number of levels in the mipmap chain Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalMemoryMipmappedArrayDesc __val cdef ccudart.cudaExternalMemoryMipmappedArrayDesc* _ptr cdef cudaChannelFormatDesc _formatDesc cdef cudaExtent _extent {{endif}} {{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}} cdef class anon_struct6: """ Attributes ---------- handle : Any name : Any Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}} cdef class anon_union2: """ Attributes ---------- fd : int win32 : anon_struct6 nvSciSyncObj : Any Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr cdef anon_struct6 _win32 {{endif}} {{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}} cdef class cudaExternalSemaphoreHandleDesc: """ External semaphore handle descriptor Attributes ---------- type : cudaExternalSemaphoreHandleType Type of the handle handle : anon_union2 flags : unsigned int Flags reserved for the future. Must be zero. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreHandleDesc* _val_ptr cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr cdef anon_union2 _handle {{endif}} {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}} cdef class anon_struct13: """ Attributes ---------- value : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}} cdef class anon_union5: """ Attributes ---------- fence : Any reserved : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}} cdef class anon_struct14: """ Attributes ---------- key : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}} cdef class anon_struct15: """ Attributes ---------- fence : anon_struct13 nvSciSync : anon_union5 keyedMutex : anon_struct14 reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr cdef anon_struct13 _fence cdef anon_union5 _nvSciSync cdef anon_struct14 _keyedMutex {{endif}} {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}} cdef class cudaExternalSemaphoreSignalParams: """ External semaphore signal parameters, compatible with driver type Attributes ---------- params : anon_struct15 flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type cudaExternalSemaphoreHandleTypeNvSciSync, the valid flag is cudaExternalSemaphoreSignalSkipNvSciBufMemSync: which indicates that while signaling the cudaExternalSemaphore_t, no memory synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalParams __val cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr cdef anon_struct15 _params {{endif}} {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}} cdef class anon_struct16: """ Attributes ---------- value : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}} cdef class anon_union6: """ Attributes ---------- fence : Any reserved : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}} cdef class anon_struct17: """ Attributes ---------- key : unsigned long long timeoutMs : unsigned int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr {{endif}} {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}} cdef class anon_struct18: """ Attributes ---------- fence : anon_struct16 nvSciSync : anon_union6 keyedMutex : anon_struct17 reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr cdef anon_struct16 _fence cdef anon_union6 _nvSciSync cdef anon_struct17 _keyedMutex {{endif}} {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}} cdef class cudaExternalSemaphoreWaitParams: """ External semaphore wait parameters, compatible with driver type Attributes ---------- params : anon_struct18 flags : unsigned int Only when cudaExternalSemaphoreSignalParams is used to signal a cudaExternalSemaphore_t of type cudaExternalSemaphoreHandleTypeNvSciSync, the valid flag is cudaExternalSemaphoreSignalSkipNvSciBufMemSync: which indicates that while waiting for the cudaExternalSemaphore_t, no memory synchronization operations should be performed for any external memory object imported as cudaExternalMemoryHandleTypeNvSciBuf. For all other types of cudaExternalSemaphore_t, flags must be zero. reserved : List[unsigned int] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitParams __val cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr cdef anon_struct18 _params {{endif}} {{if 'struct cudaKernelNodeParams' in found_types}} cdef class cudaKernelNodeParams: """ CUDA GPU kernel node parameters Attributes ---------- func : Any Kernel to launch gridDim : dim3 Grid dimensions blockDim : dim3 Block dimensions sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes kernelParams : Any Array of pointers to individual kernel arguments extra : Any Pointer to kernel arguments in the "extra" format Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaKernelNodeParams __val cdef ccudart.cudaKernelNodeParams* _ptr cdef dim3 _gridDim cdef dim3 _blockDim cdef utils.HelperKernelParams _ckernelParams {{endif}} {{if 'struct cudaKernelNodeParamsV2' in found_types}} cdef class cudaKernelNodeParamsV2: """ CUDA GPU kernel node parameters Attributes ---------- func : Any Kernel to launch gridDim : dim3 Grid dimensions blockDim : dim3 Block dimensions sharedMemBytes : unsigned int Dynamic shared-memory size per thread block in bytes kernelParams : Any Array of pointers to individual kernel arguments extra : Any Pointer to kernel arguments in the "extra" format Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaKernelNodeParamsV2 __val cdef ccudart.cudaKernelNodeParamsV2* _ptr cdef dim3 _gridDim cdef dim3 _blockDim cdef utils.HelperKernelParams _ckernelParams {{endif}} {{if 'struct cudaExternalSemaphoreSignalNodeParams' in found_types}} cdef class cudaExternalSemaphoreSignalNodeParams: """ External semaphore signal node parameters Attributes ---------- extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalNodeParams __val cdef ccudart.cudaExternalSemaphoreSignalNodeParams* _ptr cdef size_t _extSemArray_length cdef ccudart.cudaExternalSemaphore_t* _extSemArray cdef size_t _paramsArray_length cdef ccudart.cudaExternalSemaphoreSignalParams* _paramsArray {{endif}} {{if 'struct cudaExternalSemaphoreSignalNodeParamsV2' in found_types}} cdef class cudaExternalSemaphoreSignalNodeParamsV2: """ External semaphore signal node parameters Attributes ---------- extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. paramsArray : cudaExternalSemaphoreSignalParams Array of external semaphore signal parameters. numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreSignalNodeParamsV2 __val cdef ccudart.cudaExternalSemaphoreSignalNodeParamsV2* _ptr cdef size_t _extSemArray_length cdef ccudart.cudaExternalSemaphore_t* _extSemArray cdef size_t _paramsArray_length cdef ccudart.cudaExternalSemaphoreSignalParams* _paramsArray {{endif}} {{if 'struct cudaExternalSemaphoreWaitNodeParams' in found_types}} cdef class cudaExternalSemaphoreWaitNodeParams: """ External semaphore wait node parameters Attributes ---------- extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitNodeParams __val cdef ccudart.cudaExternalSemaphoreWaitNodeParams* _ptr cdef size_t _extSemArray_length cdef ccudart.cudaExternalSemaphore_t* _extSemArray cdef size_t _paramsArray_length cdef ccudart.cudaExternalSemaphoreWaitParams* _paramsArray {{endif}} {{if 'struct cudaExternalSemaphoreWaitNodeParamsV2' in found_types}} cdef class cudaExternalSemaphoreWaitNodeParamsV2: """ External semaphore wait node parameters Attributes ---------- extSemArray : cudaExternalSemaphore_t Array of external semaphore handles. paramsArray : cudaExternalSemaphoreWaitParams Array of external semaphore wait parameters. numExtSems : unsigned int Number of handles and parameters supplied in extSemArray and paramsArray. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaExternalSemaphoreWaitNodeParamsV2 __val cdef ccudart.cudaExternalSemaphoreWaitNodeParamsV2* _ptr cdef size_t _extSemArray_length cdef ccudart.cudaExternalSemaphore_t* _extSemArray cdef size_t _paramsArray_length cdef ccudart.cudaExternalSemaphoreWaitParams* _paramsArray {{endif}} {{if 'struct cudaConditionalNodeParams' in found_types}} cdef class cudaConditionalNodeParams: """ CUDA conditional node parameters Attributes ---------- handle : cudaGraphConditionalHandle Conditional node handle. Handles must be created in advance of creating the node using cudaGraphConditionalHandleCreate. type : cudaGraphConditionalNodeType Type of conditional node. size : unsigned int Size of graph output array. Must be 1. phGraph_out : cudaGraph_t CUDA-owned array populated with conditional node child graphs during creation of the node. Valid for the lifetime of the conditional node. The contents of the graph(s) are subject to the following constraints: - Allowed node types are kernel nodes, empty nodes, child graphs, memsets, memcopies, and conditionals. This applies recursively to child graphs and conditional bodies. - All kernels, including kernels in nested conditionals or child graphs at any level, must belong to the same CUDA context. These graphs may be populated using graph node creation APIs or cudaStreamBeginCaptureToGraph. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaConditionalNodeParams __val cdef ccudart.cudaConditionalNodeParams* _ptr cdef cudaGraphConditionalHandle _handle cdef size_t _phGraph_out_length cdef ccudart.cudaGraph_t* _phGraph_out {{endif}} {{if 'struct cudaChildGraphNodeParams' in found_types}} cdef class cudaChildGraphNodeParams: """ Child graph node parameters Attributes ---------- graph : cudaGraph_t The child graph to clone into the node for node creation, or a handle to the graph owned by the node for node query Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaChildGraphNodeParams __val cdef ccudart.cudaChildGraphNodeParams* _ptr cdef cudaGraph_t _graph {{endif}} {{if 'struct cudaEventRecordNodeParams' in found_types}} cdef class cudaEventRecordNodeParams: """ Event record node parameters Attributes ---------- event : cudaEvent_t The event to record when the node executes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaEventRecordNodeParams __val cdef ccudart.cudaEventRecordNodeParams* _ptr cdef cudaEvent_t _event {{endif}} {{if 'struct cudaEventWaitNodeParams' in found_types}} cdef class cudaEventWaitNodeParams: """ Event wait node parameters Attributes ---------- event : cudaEvent_t The event to wait on from the node Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaEventWaitNodeParams __val cdef ccudart.cudaEventWaitNodeParams* _ptr cdef cudaEvent_t _event {{endif}} {{if 'struct cudaGraphNodeParams' in found_types}} cdef class cudaGraphNodeParams: """ Graph node parameters. See cudaGraphAddNode. Attributes ---------- type : cudaGraphNodeType Type of the node reserved0 : List[int] Reserved. Must be zero. reserved1 : List[long long] Padding. Unused bytes must be zero. kernel : cudaKernelNodeParamsV2 Kernel node parameters. memcpy : cudaMemcpyNodeParams Memcpy node parameters. memset : cudaMemsetParamsV2 Memset node parameters. host : cudaHostNodeParamsV2 Host node parameters. graph : cudaChildGraphNodeParams Child graph node parameters. eventWait : cudaEventWaitNodeParams Event wait node parameters. eventRecord : cudaEventRecordNodeParams Event record node parameters. extSemSignal : cudaExternalSemaphoreSignalNodeParamsV2 External semaphore signal node parameters. extSemWait : cudaExternalSemaphoreWaitNodeParamsV2 External semaphore wait node parameters. alloc : cudaMemAllocNodeParamsV2 Memory allocation node parameters. free : cudaMemFreeNodeParams Memory free node parameters. conditional : cudaConditionalNodeParams Conditional node parameters. reserved2 : long long Reserved bytes. Must be zero. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphNodeParams* _val_ptr cdef ccudart.cudaGraphNodeParams* _ptr cdef cudaKernelNodeParamsV2 _kernel cdef cudaMemcpyNodeParams _memcpy cdef cudaMemsetParamsV2 _memset cdef cudaHostNodeParamsV2 _host cdef cudaChildGraphNodeParams _graph cdef cudaEventWaitNodeParams _eventWait cdef cudaEventRecordNodeParams _eventRecord cdef cudaExternalSemaphoreSignalNodeParamsV2 _extSemSignal cdef cudaExternalSemaphoreWaitNodeParamsV2 _extSemWait cdef cudaMemAllocNodeParamsV2 _alloc cdef cudaMemFreeNodeParams _free cdef cudaConditionalNodeParams _conditional {{endif}} {{if 'struct cudaGraphEdgeData_st' in found_types}} cdef class cudaGraphEdgeData_st: """ Optional annotation for edges in a CUDA graph. Note, all edges implicitly have annotations and default to a zero-initialized value if not specified. A zero-initialized struct indicates a standard full serialization of two nodes with memory visibility. Attributes ---------- from_port : bytes This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value of 0 in all cases means full completion of the upstream node, with memory visibility to the downstream node or portion thereof (indicated by `to_port`). Only kernel nodes define non-zero ports. A kernel node can use the following output port types: cudaGraphKernelNodePortDefault, cudaGraphKernelNodePortProgrammatic, or cudaGraphKernelNodePortLaunchCompletion. to_port : bytes This indicates what portion of the downstream node is dependent on the upstream node or portion thereof (indicated by `from_port`). The meaning is specific to the node type. A value of 0 in all cases means the entirety of the downstream node is dependent on the upstream work. Currently no node types define non-zero ports. Accordingly, this field must be set to zero. type : bytes This should be populated with a value from ::cudaGraphDependencyType. (It is typed as char due to compiler- specific layout of bitfields.) See ::cudaGraphDependencyType. reserved : bytes These bytes are unused and must be zeroed. This ensures compatibility if additional fields are added in the future. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphEdgeData_st __val cdef ccudart.cudaGraphEdgeData_st* _ptr {{endif}} {{if 'struct cudaGraphInstantiateParams_st' in found_types}} cdef class cudaGraphInstantiateParams_st: """ Graph instantiation parameters Attributes ---------- flags : unsigned long long Instantiation flags uploadStream : cudaStream_t Upload stream errNode_out : cudaGraphNode_t The node which caused instantiation to fail, if any result_out : cudaGraphInstantiateResult Whether instantiation was successful. If it failed, the reason why Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphInstantiateParams_st __val cdef ccudart.cudaGraphInstantiateParams_st* _ptr cdef cudaStream_t _uploadStream cdef cudaGraphNode_t _errNode_out {{endif}} {{if 'struct cudaGraphExecUpdateResultInfo_st' in found_types}} cdef class cudaGraphExecUpdateResultInfo_st: """ Result information returned by cudaGraphExecUpdate Attributes ---------- result : cudaGraphExecUpdateResult Gives more specific detail when a cuda graph update fails. errorNode : cudaGraphNode_t The "to node" of the error edge when the topologies do not match. The error node when the error is associated with a specific node. NULL when the error is generic. errorFromNode : cudaGraphNode_t The from node of error edge when the topologies do not match. Otherwise NULL. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphExecUpdateResultInfo_st __val cdef ccudart.cudaGraphExecUpdateResultInfo_st* _ptr cdef cudaGraphNode_t _errorNode cdef cudaGraphNode_t _errorFromNode {{endif}} {{if 'struct cudaGraphKernelNodeUpdate' in found_types}} cdef class anon_struct19: """ Attributes ---------- pValue : Any offset : size_t size : size_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphKernelNodeUpdate* _ptr {{endif}} {{if 'struct cudaGraphKernelNodeUpdate' in found_types}} cdef class anon_union8: """ Attributes ---------- gridDim : dim3 param : anon_struct19 isEnabled : unsigned int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphKernelNodeUpdate* _ptr cdef dim3 _gridDim cdef anon_struct19 _param {{endif}} {{if 'struct cudaGraphKernelNodeUpdate' in found_types}} cdef class cudaGraphKernelNodeUpdate: """ Struct to specify a single node update to pass as part of a larger array to ::cudaGraphKernelNodeUpdatesApply Attributes ---------- node : cudaGraphDeviceNode_t Node to update field : cudaGraphKernelNodeField Which type of update to apply. Determines how updateData is interpreted updateData : anon_union8 Update data to apply. Which field is used depends on field's value Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphKernelNodeUpdate* _val_ptr cdef ccudart.cudaGraphKernelNodeUpdate* _ptr cdef cudaGraphDeviceNode_t _node cdef anon_union8 _updateData {{endif}} {{if 'struct cudaLaunchMemSyncDomainMap_st' in found_types}} cdef class cudaLaunchMemSyncDomainMap_st: """ Memory Synchronization Domain map See cudaLaunchMemSyncDomain. By default, kernels are launched in domain 0. Kernel launched with cudaLaunchMemSyncDomainRemote will have a different domain ID. User may also alter the domain ID with ::cudaLaunchMemSyncDomainMap for a specific stream / graph node / kernel launch. See cudaLaunchAttributeMemSyncDomainMap. Domain ID range is available through cudaDevAttrMemSyncDomainCount. Attributes ---------- default_ : bytes The default domain ID to use for designated kernels remote : bytes The remote domain ID to use for designated kernels Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchMemSyncDomainMap_st __val cdef ccudart.cudaLaunchMemSyncDomainMap_st* _ptr {{endif}} {{if 'union cudaLaunchAttributeValue' in found_types}} cdef class anon_struct20: """ Attributes ---------- x : unsigned int y : unsigned int z : unsigned int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttributeValue* _ptr {{endif}} {{if 'union cudaLaunchAttributeValue' in found_types}} cdef class anon_struct21: """ Attributes ---------- event : cudaEvent_t flags : int triggerAtBlockStart : int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttributeValue* _ptr cdef cudaEvent_t _event {{endif}} {{if 'union cudaLaunchAttributeValue' in found_types}} cdef class anon_struct22: """ Attributes ---------- event : cudaEvent_t flags : int Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttributeValue* _ptr cdef cudaEvent_t _event {{endif}} {{if 'union cudaLaunchAttributeValue' in found_types}} cdef class anon_struct23: """ Attributes ---------- deviceUpdatable : int devNode : cudaGraphDeviceNode_t Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttributeValue* _ptr cdef cudaGraphDeviceNode_t _devNode {{endif}} {{if 'union cudaLaunchAttributeValue' in found_types}} cdef class cudaLaunchAttributeValue: """ Launch attributes union; used as value field of ::cudaLaunchAttribute Attributes ---------- pad : bytes accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. ::cudaSynchronizationPolicy for work queued up in this stream. clusterDim : anon_struct20 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque type with the following fields: - `x` - The X dimension of the cluster, in blocks. Must be a divisor of the grid X dimension. - `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. programmaticEvent : anon_struct21 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when all blocks trigger it. - `int` flags; - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See ::cudaLaunchMemSyncDomainMap. memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. launchCompletionEvent : anon_struct22 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. deviceUpdatableKernelNode : anon_struct23 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following fields: - `int` deviceUpdatable - Whether or not the resulting kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttributeValue __val cdef ccudart.cudaLaunchAttributeValue* _ptr cdef cudaAccessPolicyWindow _accessPolicyWindow cdef anon_struct20 _clusterDim cdef anon_struct21 _programmaticEvent cdef cudaLaunchMemSyncDomainMap _memSyncDomainMap cdef anon_struct22 _launchCompletionEvent cdef anon_struct23 _deviceUpdatableKernelNode {{endif}} {{if 'struct cudaLaunchAttribute_st' in found_types}} cdef class cudaLaunchAttribute_st: """ Launch attribute Attributes ---------- id : cudaLaunchAttributeID Attribute to set val : cudaLaunchAttributeValue Value of the attribute Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaLaunchAttribute_st __val cdef ccudart.cudaLaunchAttribute_st* _ptr cdef cudaLaunchAttributeValue _val {{endif}} {{if 'struct cudaAsyncNotificationInfo' in found_types}} cdef class anon_struct24: """ Attributes ---------- bytesOverBudget : unsigned long long Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAsyncNotificationInfo* _ptr {{endif}} {{if 'struct cudaAsyncNotificationInfo' in found_types}} cdef class anon_union9: """ Attributes ---------- overBudget : anon_struct24 Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAsyncNotificationInfo* _ptr cdef anon_struct24 _overBudget {{endif}} {{if 'struct cudaAsyncNotificationInfo' in found_types}} cdef class cudaAsyncNotificationInfo: """ Information describing an async notification event Attributes ---------- type : cudaAsyncNotificationType info : anon_union9 Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaAsyncNotificationInfo* _val_ptr cdef ccudart.cudaAsyncNotificationInfo* _ptr cdef anon_union9 _info {{endif}} {{if 'struct cudaTextureDesc' in found_types}} cdef class cudaTextureDesc: """ CUDA texture descriptor Attributes ---------- addressMode : List[cudaTextureAddressMode] Texture address mode for up to 3 dimensions filterMode : cudaTextureFilterMode Texture filter mode readMode : cudaTextureReadMode Texture read mode sRGB : int Perform sRGB->linear conversion during texture read borderColor : List[float] Texture Border Color normalizedCoords : int Indicates whether texture reads are normalized or not maxAnisotropy : unsigned int Limit to the anisotropy ratio mipmapFilterMode : cudaTextureFilterMode Mipmap filter mode mipmapLevelBias : float Offset applied to the supplied mipmap level minMipmapLevelClamp : float Lower end of the mipmap level range to clamp access to maxMipmapLevelClamp : float Upper end of the mipmap level range to clamp access to disableTrilinearOptimization : int Disable any trilinear filtering optimizations. seamlessCubemap : int Enable seamless cube map filtering. Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaTextureDesc __val cdef ccudart.cudaTextureDesc* _ptr {{endif}} {{if True}} cdef class cudaEglPlaneDesc_st: """ CUDA EGL Plane Descriptor - structure defining each plane of a CUDA EGLFrame Attributes ---------- width : unsigned int Width of plane height : unsigned int Height of plane depth : unsigned int Depth of plane pitch : unsigned int Pitch of plane numChannels : unsigned int Number of channels for the plane channelDesc : cudaChannelFormatDesc Channel Format Descriptor reserved : List[unsigned int] Reserved for future use Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaEglPlaneDesc_st __val cdef ccudart.cudaEglPlaneDesc_st* _ptr cdef cudaChannelFormatDesc _channelDesc {{endif}} {{if True}} cdef class anon_union10: """ Attributes ---------- pArray : List[cudaArray_t] pPitch : List[cudaPitchedPtr] Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaEglFrame_st* _ptr {{endif}} {{if True}} cdef class cudaEglFrame_st: """ CUDA EGLFrame Descriptor - structure defining one frame of EGL. Each frame may contain one or more planes depending on whether the surface is Multiplanar or not. Each plane of EGLFrame is represented by cudaEglPlaneDesc which is defined as: typedefstructcudaEglPlaneDesc_st unsignedintwidth; unsignedintheight; unsignedintdepth; unsignedintpitch; unsignedintnumChannels; structcudaChannelFormatDescchannelDesc; unsignedintreserved[4]; cudaEglPlaneDesc; Attributes ---------- frame : anon_union10 planeDesc : List[cudaEglPlaneDesc] CUDA EGL Plane Descriptor cudaEglPlaneDesc planeCount : unsigned int Number of planes frameType : cudaEglFrameType Array or Pitch eglColorFormat : cudaEglColorFormat CUDA EGL Color Format Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaEglFrame_st* _val_ptr cdef ccudart.cudaEglFrame_st* _ptr cdef anon_union10 _frame {{endif}} {{if 'CUuuid' in found_types}} cdef class CUuuid(CUuuid_st): """ Attributes ---------- bytes : bytes < CUDA definition of UUID Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaUUID_t' in found_types}} cdef class cudaUUID_t(CUuuid_st): """ Attributes ---------- bytes : bytes < CUDA definition of UUID Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaIpcEventHandle_t' in found_types}} cdef class cudaIpcEventHandle_t(cudaIpcEventHandle_st): """ CUDA IPC event handle Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaIpcMemHandle_t' in found_types}} cdef class cudaIpcMemHandle_t(cudaIpcMemHandle_st): """ CUDA IPC memory handle Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaMemFabricHandle_t' in found_types}} cdef class cudaMemFabricHandle_t(cudaMemFabricHandle_st): """ Attributes ---------- reserved : bytes Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphEdgeData' in found_types}} cdef class cudaGraphEdgeData(cudaGraphEdgeData_st): """ Optional annotation for edges in a CUDA graph. Note, all edges implicitly have annotations and default to a zero-initialized value if not specified. A zero-initialized struct indicates a standard full serialization of two nodes with memory visibility. Attributes ---------- from_port : bytes This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value of 0 in all cases means full completion of the upstream node, with memory visibility to the downstream node or portion thereof (indicated by `to_port`). Only kernel nodes define non-zero ports. A kernel node can use the following output port types: cudaGraphKernelNodePortDefault, cudaGraphKernelNodePortProgrammatic, or cudaGraphKernelNodePortLaunchCompletion. to_port : bytes This indicates what portion of the downstream node is dependent on the upstream node or portion thereof (indicated by `from_port`). The meaning is specific to the node type. A value of 0 in all cases means the entirety of the downstream node is dependent on the upstream work. Currently no node types define non-zero ports. Accordingly, this field must be set to zero. type : bytes This should be populated with a value from ::cudaGraphDependencyType. (It is typed as char due to compiler- specific layout of bitfields.) See ::cudaGraphDependencyType. reserved : bytes These bytes are unused and must be zeroed. This ensures compatibility if additional fields are added in the future. Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphInstantiateParams' in found_types}} cdef class cudaGraphInstantiateParams(cudaGraphInstantiateParams_st): """ Graph instantiation parameters Attributes ---------- flags : unsigned long long Instantiation flags uploadStream : cudaStream_t Upload stream errNode_out : cudaGraphNode_t The node which caused instantiation to fail, if any result_out : cudaGraphInstantiateResult Whether instantiation was successful. If it failed, the reason why Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphExecUpdateResultInfo' in found_types}} cdef class cudaGraphExecUpdateResultInfo(cudaGraphExecUpdateResultInfo_st): """ Result information returned by cudaGraphExecUpdate Attributes ---------- result : cudaGraphExecUpdateResult Gives more specific detail when a cuda graph update fails. errorNode : cudaGraphNode_t The "to node" of the error edge when the topologies do not match. The error node when the error is associated with a specific node. NULL when the error is generic. errorFromNode : cudaGraphNode_t The from node of error edge when the topologies do not match. Otherwise NULL. Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaLaunchMemSyncDomainMap' in found_types}} cdef class cudaLaunchMemSyncDomainMap(cudaLaunchMemSyncDomainMap_st): """ Memory Synchronization Domain map See cudaLaunchMemSyncDomain. By default, kernels are launched in domain 0. Kernel launched with cudaLaunchMemSyncDomainRemote will have a different domain ID. User may also alter the domain ID with ::cudaLaunchMemSyncDomainMap for a specific stream / graph node / kernel launch. See cudaLaunchAttributeMemSyncDomainMap. Domain ID range is available through cudaDevAttrMemSyncDomainCount. Attributes ---------- default_ : bytes The default domain ID to use for designated kernels remote : bytes The remote domain ID to use for designated kernels Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaLaunchAttribute' in found_types}} cdef class cudaLaunchAttribute(cudaLaunchAttribute_st): """ Launch attribute Attributes ---------- id : cudaLaunchAttributeID Attribute to set val : cudaLaunchAttributeValue Value of the attribute Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaAsyncNotificationInfo_t' in found_types}} cdef class cudaAsyncNotificationInfo_t(cudaAsyncNotificationInfo): """ Information describing an async notification event Attributes ---------- type : cudaAsyncNotificationType info : anon_union9 Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if True}} cdef class cudaStreamAttrValue(cudaLaunchAttributeValue): """ Launch attributes union; used as value field of ::cudaLaunchAttribute Attributes ---------- pad : bytes accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. ::cudaSynchronizationPolicy for work queued up in this stream. clusterDim : anon_struct20 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque type with the following fields: - `x` - The X dimension of the cluster, in blocks. Must be a divisor of the grid X dimension. - `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. programmaticEvent : anon_struct21 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when all blocks trigger it. - `int` flags; - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See ::cudaLaunchMemSyncDomainMap. memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. launchCompletionEvent : anon_struct22 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. deviceUpdatableKernelNode : anon_struct23 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following fields: - `int` deviceUpdatable - Whether or not the resulting kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if True}} cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue): """ Launch attributes union; used as value field of ::cudaLaunchAttribute Attributes ---------- pad : bytes accessPolicyWindow : cudaAccessPolicyWindow Value of launch attribute cudaLaunchAttributeAccessPolicyWindow. cooperative : int Value of launch attribute cudaLaunchAttributeCooperative. Nonzero indicates a cooperative kernel (see cudaLaunchCooperativeKernel). syncPolicy : cudaSynchronizationPolicy Value of launch attribute cudaLaunchAttributeSynchronizationPolicy. ::cudaSynchronizationPolicy for work queued up in this stream. clusterDim : anon_struct20 Value of launch attribute cudaLaunchAttributeClusterDimension that represents the desired cluster dimensions for the kernel. Opaque type with the following fields: - `x` - The X dimension of the cluster, in blocks. Must be a divisor of the grid X dimension. - `y` - The Y dimension of the cluster, in blocks. Must be a divisor of the grid Y dimension. - `z` - The Z dimension of the cluster, in blocks. Must be a divisor of the grid Z dimension. clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy Value of launch attribute cudaLaunchAttributeClusterSchedulingPolicyPreference. Cluster scheduling policy preference for the kernel. programmaticStreamSerializationAllowed : int Value of launch attribute cudaLaunchAttributeProgrammaticStreamSerialization. programmaticEvent : anon_struct21 Value of launch attribute cudaLaunchAttributeProgrammaticEvent with the following fields: - `cudaEvent_t` event - Event to fire when all blocks trigger it. - `int` flags; - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. - `int` triggerAtBlockStart - If this is set to non-0, each block launch will automatically trigger the event. priority : int Value of launch attribute cudaLaunchAttributePriority. Execution priority of the kernel. memSyncDomainMap : cudaLaunchMemSyncDomainMap Value of launch attribute cudaLaunchAttributeMemSyncDomainMap. See ::cudaLaunchMemSyncDomainMap. memSyncDomain : cudaLaunchMemSyncDomain Value of launch attribute cudaLaunchAttributeMemSyncDomain. See cudaLaunchMemSyncDomain. launchCompletionEvent : anon_struct22 Value of launch attribute cudaLaunchAttributeLaunchCompletionEvent with the following fields: - `cudaEvent_t` event - Event to fire when the last block launches. - `int` flags - Event record flags, see cudaEventRecordWithFlags. Does not accept cudaEventRecordExternal. deviceUpdatableKernelNode : anon_struct23 Value of launch attribute cudaLaunchAttributeDeviceUpdatableKernelNode with the following fields: - `int` deviceUpdatable - Whether or not the resulting kernel node should be device-updatable. - `cudaGraphDeviceNode_t` devNode - Returns a handle to pass to the various device-side update functions. sharedMemCarveout : unsigned int Value of launch attribute cudaLaunchAttributePreferredSharedMemoryCarveout. Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if True}} cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st): """ CUDA EGL Plane Descriptor - structure defining each plane of a CUDA EGLFrame Attributes ---------- width : unsigned int Width of plane height : unsigned int Height of plane depth : unsigned int Depth of plane pitch : unsigned int Pitch of plane numChannels : unsigned int Number of channels for the plane channelDesc : cudaChannelFormatDesc Channel Format Descriptor reserved : List[unsigned int] Reserved for future use Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if True}} cdef class cudaEglFrame(cudaEglFrame_st): """ CUDA EGLFrame Descriptor - structure defining one frame of EGL. Each frame may contain one or more planes depending on whether the surface is Multiplanar or not. Each plane of EGLFrame is represented by cudaEglPlaneDesc which is defined as: typedefstructcudaEglPlaneDesc_st unsignedintwidth; unsignedintheight; unsignedintdepth; unsignedintpitch; unsignedintnumChannels; structcudaChannelFormatDescchannelDesc; unsignedintreserved[4]; cudaEglPlaneDesc; Attributes ---------- frame : anon_union10 planeDesc : List[cudaEglPlaneDesc] CUDA EGL Plane Descriptor cudaEglPlaneDesc planeCount : unsigned int Number of planes frameType : cudaEglFrameType Array or Pitch eglColorFormat : cudaEglColorFormat CUDA EGL Color Format Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaStream_t' in found_types}} cdef class cudaStream_t(cuda.CUstream): """ CUDA stream Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaEvent_t' in found_types}} cdef class cudaEvent_t(cuda.CUevent): """ CUDA event types Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraph_t' in found_types}} cdef class cudaGraph_t(cuda.CUgraph): """ CUDA graph Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphNode_t' in found_types}} cdef class cudaGraphNode_t(cuda.CUgraphNode): """ CUDA graph node. Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaUserObject_t' in found_types}} cdef class cudaUserObject_t(cuda.CUuserObject): """ CUDA user object for graphs Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaFunction_t' in found_types}} cdef class cudaFunction_t(cuda.CUfunction): """ CUDA function Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaMemPool_t' in found_types}} cdef class cudaMemPool_t(cuda.CUmemoryPool): """ CUDA memory pool Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphExec_t' in found_types}} cdef class cudaGraphExec_t(cuda.CUgraphExec): """ CUDA executable (launchable) graph Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if True}} cdef class cudaEglStreamConnection(cuda.CUeglStreamConnection): """ CUDA EGLSream Connection Methods ------- getPtr() Get memory address of class instance """ pass {{endif}} {{if 'cudaGraphConditionalHandle' in found_types}} cdef class cudaGraphConditionalHandle: """ CUDA handle for conditional graph nodes Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaGraphConditionalHandle __val cdef ccudart.cudaGraphConditionalHandle* _ptr {{endif}} {{if 'cudaSurfaceObject_t' in found_types}} cdef class cudaSurfaceObject_t: """ An opaque value that represents a CUDA Surface object Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaSurfaceObject_t __val cdef ccudart.cudaSurfaceObject_t* _ptr {{endif}} {{if 'cudaTextureObject_t' in found_types}} cdef class cudaTextureObject_t: """ An opaque value that represents a CUDA texture object Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.cudaTextureObject_t __val cdef ccudart.cudaTextureObject_t* _ptr {{endif}} {{if True}} cdef class GLenum: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.GLenum __val cdef ccudart.GLenum* _ptr {{endif}} {{if True}} cdef class GLuint: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.GLuint __val cdef ccudart.GLuint* _ptr {{endif}} {{if True}} cdef class EGLint: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.EGLint __val cdef ccudart.EGLint* _ptr {{endif}} {{if True}} cdef class VdpDevice: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.VdpDevice __val cdef ccudart.VdpDevice* _ptr {{endif}} {{if True}} cdef class VdpGetProcAddress: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.VdpGetProcAddress __val cdef ccudart.VdpGetProcAddress* _ptr {{endif}} {{if True}} cdef class VdpVideoSurface: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.VdpVideoSurface __val cdef ccudart.VdpVideoSurface* _ptr {{endif}} {{if True}} cdef class VdpOutputSurface: """ Methods ------- getPtr() Get memory address of class instance """ cdef ccudart.VdpOutputSurface __val cdef ccudart.VdpOutputSurface* _ptr {{endif}}