跳到主要内容

MUSA Driver API 参考


目录​

  1. Supported APIs
  2. API Function Reference

Supported APIs​

The following table lists the Driver APIs supported in MUSA SDK 5.1.0.

APIHeader
muArray3DCreatemuapi_memory.h
muArray3DCreate_v2muapi_memory.h
muArray3DGetDescriptormuapi_memory.h
muArray3DGetDescriptor_v2muapi_memory.h
muArrayCreatemuapi_memory.h
muArrayCreate_v2muapi_memory.h
muArrayDestroymuapi_memory.h
muArrayGetDescriptormuapi_memory.h
muArrayGetDescriptor_v2muapi_memory.h
muArrayGetMemoryRequirementsmuapi_memory.h
muCoredumpGetAttributemuapi.h
muCoredumpGetAttributeGlobalmuapi.h
muCoredumpSetAttributemuapi.h
muCoredumpSetAttributeGlobalmuapi.h
muCtxAttachmuapi_ctx.h
muCtxCreatemuapi_ctx.h
muCtxCreate_v2muapi_ctx.h
muCtxDestroymuapi_ctx.h
muCtxDestroy_v2muapi_ctx.h
muCtxDetachmuapi_ctx.h
muCtxDisablePeerAccessmuapi_ctx.h
muCtxEnablePeerAccessmuapi_ctx.h
muCtxFromGreenCtxmuapi_ctx.h
muCtxGetApiVersionmuapi_ctx.h
muCtxGetCacheConfigmuapi_ctx.h
muCtxGetCurrentmuapi_ctx.h
muCtxGetDevResourcemuapi_ctx.h
muCtxGetDevicemuapi_ctx.h
muCtxGetFlagsmuapi_ctx.h
muCtxGetIdmuapi_ctx.h
muCtxGetLimitmuapi_ctx.h
muCtxGetSharedMemConfigmuapi_ctx.h
muCtxGetStreamPriorityRangemuapi_ctx.h
muCtxPopCurrentmuapi_ctx.h
muCtxPopCurrent_v2muapi_ctx.h
muCtxPushCurrentmuapi_ctx.h
muCtxPushCurrent_v2muapi_ctx.h
muCtxRecordEventmuapi_ctx.h
muCtxResetPersistingL2Cachemuapi_ctx.h
muCtxSetCacheConfigmuapi_ctx.h
muCtxSetCurrentmuapi_ctx.h
muCtxSetFlagsmuapi_ctx.h
muCtxSetLimitmuapi_ctx.h
muCtxSetSharedMemConfigmuapi_ctx.h
muCtxSynchronizemuapi_ctx.h
muCtxWaitEventmuapi_ctx.h
muDebugFlagmuapi.h
muDebugInitmuapi.h
muDebugSendRunningKernelInfomuapi.h
muDebugSendTrapInfomuapi.h
muDestroyExternalMemorymuapi.h
muDestroyExternalSemaphoremuapi.h
muDevResourceGenerateDescmuapi.h
muDevSmResourceSplitByCountmuapi.h
muDeviceCanAccessPeermuapi_device.h
muDeviceComputeCapabilitymuapi_device.h
muDeviceGetmuapi_device.h
muDeviceGetAttributemuapi_device.h
muDeviceGetByPCIBusIdmuapi_device.h
muDeviceGetCountmuapi_device.h
muDeviceGetDefaultMemPoolmuapi_device.h
muDeviceGetDevResourcemuapi_device.h
muDeviceGetGraphMemAttributemuapi_device.h
muDeviceGetMemPoolmuapi_device.h
muDeviceGetNamemuapi_device.h
muDeviceGetP2PAttributemuapi_device.h
muDeviceGetPCIBusIdmuapi_device.h
muDeviceGetPropertiesmuapi_device.h
muDeviceGetTexture1DLinearMaxWidthmuapi_device.h
muDeviceGetUuidmuapi_device.h
muDeviceGetUuid_v2muapi_device.h
muDeviceGraphMemTrimmuapi_device.h
muDevicePrimaryCtxGetStatemuapi_device.h
muDevicePrimaryCtxReleasemuapi_device.h
muDevicePrimaryCtxRelease_v2muapi_device.h
muDevicePrimaryCtxResetmuapi_device.h
muDevicePrimaryCtxReset_v2muapi_device.h
muDevicePrimaryCtxRetainmuapi_device.h
muDevicePrimaryCtxSetFlagsmuapi_device.h
muDevicePrimaryCtxSetFlags_v2muapi_device.h
muDeviceSetGraphMemAttributemuapi_device.h
muDeviceSetMemPoolmuapi_device.h
muDeviceTotalMemmuapi_device.h
muDeviceTotalMem_v2muapi_device.h
muDriverGetVersionmuapi_device.h
muEventCreatemuapi_event.h
muEventDestroymuapi_event.h
muEventDestroy_v2muapi_event.h
muEventElapsedTimemuapi_event.h
muEventElapsedTime_v2muapi_event.h
muEventQuerymuapi_event.h
muEventRecordmuapi_event.h
muEventRecordWithFlagsmuapi_event.h
muEventRecordWithFlags_ptszmuapi_event.h
muEventRecord_ptszmuapi_event.h
muEventSynchronizemuapi_event.h
muExternalMemoryGetMappedBuffermuapi_external.h
muExternalMemoryGetMappedMipmappedArraymuapi_external.h
muFuncGetAttributemuapi_module.h
muFuncGetModulemuapi_module.h
muFuncGetNamemuapi_module.h
muFuncGetParamInfomuapi_module.h
muFuncIsLoadedmuapi_module.h
muFuncLoadmuapi_module.h
muFuncSetAttributemuapi_module.h
muFuncSetCacheConfigmuapi_module.h
muFuncSetSharedMemConfigmuapi_module.h
muGdbPidmuapi.h
muGdbSessionIdmuapi.h
muGetErrorNamemuapi_ctx.h
muGetErrorStringmuapi_ctx.h
muGetExportTablemuapi_ctx.h
muGetProcAddressmuapi_ctx.h
muGetProcAddress_v2muapi_ctx.h
muGetProcAddress_v2_ptszmuapi_ctx.h
muGraphAddBatchMemOpNodemuapi_graph.h
muGraphAddChildGraphNodemuapi_graph.h
muGraphAddDependenciesmuapi_graph.h
muGraphAddDependencies_v2muapi_graph.h
muGraphAddEmptyNodemuapi_graph.h
muGraphAddEventRecordNodemuapi_graph.h
muGraphAddEventWaitNodemuapi_graph.h
muGraphAddExternalSemaphoresSignalNodemuapi_graph.h
muGraphAddExternalSemaphoresWaitNodemuapi_graph.h
muGraphAddHostNodemuapi_graph.h
muGraphAddKernelNodemuapi_graph.h
muGraphAddKernelNode_v2muapi_graph.h
muGraphAddMemAllocNodemuapi_graph.h
muGraphAddMemAtomicNodemuapi_graph.h
muGraphAddMemAtomicValueNodemuapi_graph.h
muGraphAddMemFreeNodemuapi_graph.h
muGraphAddMemTransferNodemuapi_graph.h
muGraphAddMemWaitWriteNodemuapi_graph.h
muGraphAddMemcpyNodemuapi_graph.h
muGraphAddMemsetNodemuapi_graph.h
muGraphAddNodemuapi_graph.h
muGraphAddNode_v2muapi_graph.h
muGraphBatchMemOpNodeGetParamsmuapi_graph.h
muGraphBatchMemOpNodeSetParamsmuapi_graph.h
muGraphChildGraphNodeGetGraphmuapi_graph.h
muGraphClonemuapi_graph.h
muGraphConditionalHandleCreatemuapi_graph.h
muGraphCreatemuapi_graph.h
muGraphDebugDotPrintmuapi_graph.h
muGraphDestroymuapi_graph.h
muGraphDestroyNodemuapi_graph.h
muGraphEventRecordNodeGetEventmuapi_graph.h
muGraphEventRecordNodeSetEventmuapi_graph.h
muGraphEventWaitNodeGetEventmuapi_graph.h
muGraphEventWaitNodeSetEventmuapi_graph.h
muGraphExecChildGraphNodeSetParamsmuapi_graph.h
muGraphExecDestroymuapi_graph.h
muGraphExecEventRecordNodeSetEventmuapi_graph.h
muGraphExecEventWaitNodeSetEventmuapi_graph.h
muGraphExecExternalSemaphoresSignalNodeSetParamsmuapi_graph.h
muGraphExecExternalSemaphoresWaitNodeSetParamsmuapi_graph.h
muGraphExecGetFlagsmuapi_graph.h
muGraphExecHostNodeSetParamsmuapi_graph.h
muGraphExecKernelNodeSetParamsmuapi_graph.h
muGraphExecKernelNodeSetParams_v2muapi_graph.h
muGraphExecMemAtomicNodeSetParamsmuapi_graph.h
muGraphExecMemAtomicValueNodeSetParamsmuapi_graph.h
muGraphExecMemTransferNodeSetParamsmuapi_graph.h
muGraphExecMemWaitWriteNodeSetParamsmuapi_graph.h
muGraphExecMemcpyNodeSetParamsmuapi_graph.h
muGraphExecMemsetNodeSetParamsmuapi_graph.h
muGraphExecNodeSetParamsmuapi_graph.h
muGraphExecUpdatemuapi_graph.h
muGraphExecUpdate_v2muapi_graph.h
muGraphExternalSemaphoresSignalNodeGetParamsmuapi_graph.h
muGraphExternalSemaphoresSignalNodeSetParamsmuapi_graph.h
muGraphExternalSemaphoresWaitNodeGetParamsmuapi_graph.h
muGraphExternalSemaphoresWaitNodeSetParamsmuapi_graph.h
muGraphGetEdgesmuapi_graph.h
muGraphGetEdges_v2muapi_graph.h
muGraphGetNodesmuapi_graph.h
muGraphGetRootNodesmuapi_graph.h
muGraphHostNodeGetParamsmuapi_graph.h
muGraphHostNodeSetParamsmuapi_graph.h
muGraphInstantiatemuapi_graph.h
muGraphInstantiateWithFlagsmuapi_graph.h
muGraphInstantiateWithParamsmuapi_graph.h
muGraphInstantiate_v2muapi_graph.h
muGraphKernelNodeCopyAttributesmuapi_graph.h
muGraphKernelNodeGetAttributemuapi_graph.h
muGraphKernelNodeGetParamsmuapi_graph.h
muGraphKernelNodeGetParams_v2muapi_graph.h
muGraphKernelNodeSetAttributemuapi_graph.h
muGraphKernelNodeSetParamsmuapi_graph.h
muGraphKernelNodeSetParams_v2muapi_graph.h
muGraphLaunchmuapi_graph.h
muGraphMemAllocNodeGetParamsmuapi_graph.h
muGraphMemAtomicNodeGetParamsmuapi_graph.h
muGraphMemAtomicNodeSetParamsmuapi_graph.h
muGraphMemAtomicValueNodeGetParamsmuapi_graph.h
muGraphMemAtomicValueNodeSetParamsmuapi_graph.h
muGraphMemFreeNodeGetParamsmuapi_graph.h
muGraphMemTransferNodeGetParamsmuapi_graph.h
muGraphMemTransferNodeSetParamsmuapi_graph.h
muGraphMemWaitWriteNodeGetParamsmuapi_graph.h
muGraphMemWaitWriteNodeSetParamsmuapi_graph.h
muGraphMemcpyNodeGetParamsmuapi_graph.h
muGraphMemcpyNodeSetParamsmuapi_graph.h
muGraphMemsetNodeGetParamsmuapi_graph.h
muGraphMemsetNodeSetParamsmuapi_graph.h
muGraphNodeFindInClonemuapi_graph.h
muGraphNodeGetDependenciesmuapi_graph.h
muGraphNodeGetDependencies_v2muapi_graph.h
muGraphNodeGetDependentNodesmuapi_graph.h
muGraphNodeGetDependentNodes_v2muapi_graph.h
muGraphNodeGetEnabledmuapi_graph.h
muGraphNodeGetTypemuapi_graph.h
muGraphNodeSetEnabledmuapi_graph.h
muGraphNodeSetParamsmuapi_graph.h
muGraphReleaseUserObjectmuapi_graph.h
muGraphRemoveDependenciesmuapi_graph.h
muGraphRemoveDependencies_v2muapi_graph.h
muGraphRetainUserObjectmuapi_graph.h
muGraphUploadmuapi_graph.h
muGraphicsGLRegisterBuffermuapi_graph.h
muGraphicsGLRegisterImagemuapi_graph.h
muGraphicsMapResourcesmuapi_graph.h
muGraphicsMapResources_ptszmuapi_graph.h
muGraphicsResourceGetMappedMipmappedArraymuapi_graph.h
muGraphicsResourceGetMappedPointermuapi_graph.h
muGraphicsResourceGetMappedPointer_v2muapi_graph.h
muGraphicsResourceSetMapFlagsmuapi_graph.h
muGraphicsResourceSetMapFlags_v2muapi_graph.h
muGraphicsSubResourceGetMappedArraymuapi_graph.h
muGraphicsUnmapResourcesmuapi_graph.h
muGraphicsUnmapResources_ptszmuapi_graph.h
muGraphicsUnregisterResourcemuapi_graph.h
muGreenCtxCreatemuapi.h
muGreenCtxDestroymuapi.h
muGreenCtxGetDevResourcemuapi.h
muGreenCtxRecordEventmuapi.h
muGreenCtxStreamCreatemuapi.h
muGreenCtxWaitEventmuapi.h
muImportExternalMemorymuapi.h
muImportExternalSemaphoremuapi.h
muInitmuapi_ctx.h
muIpcCloseMemHandlemuapi_ipc.h
muIpcGetEventHandlemuapi_ipc.h
muIpcGetMemHandlemuapi_ipc.h
muIpcOpenEventHandlemuapi_ipc.h
muIpcOpenMemHandlemuapi_ipc.h
muIpcOpenMemHandle_v2muapi_ipc.h
muKernelGetAttributemuapi.h
muKernelGetFunctionmuapi.h
muKernelGetLibrarymuapi.h
muKernelGetNamemuapi.h
muKernelGetParamInfomuapi.h
muKernelSetAttributemuapi.h
muKernelSetCacheConfigmuapi.h
muLaunchCooperativeKernelmuapi_module.h
muLaunchHostFuncmuapi_module.h
muLaunchKernelmuapi_module.h
muLaunchKernelExmuapi_module.h
muLaunchKernel_ptszmuapi_module.h
muLibraryEnumerateKernelsmuapi_library.h
muLibraryGetGlobalmuapi_library.h
muLibraryGetKernelmuapi_library.h
muLibraryGetKernelCountmuapi_library.h
muLibraryGetManagedmuapi_library.h
muLibraryGetModulemuapi_library.h
muLibraryGetUnifiedFunctionmuapi_library.h
muLibraryLoadDatamuapi_library.h
muLibraryLoadFromFilemuapi_library.h
muLibraryUnloadmuapi_library.h
muMemAddressFreemuapi_memory.h
muMemAddressReservemuapi_memory.h
muMemAdvisemuapi_memory.h
muMemAdvise_v2muapi_memory.h
muMemAllocmuapi_memory.h
muMemAllocAsyncmuapi_memory.h
muMemAllocFromPoolAsyncmuapi_memory.h
muMemAllocHostmuapi_memory.h
muMemAllocHost_v2muapi_memory.h
muMemAllocManagedmuapi_memory.h
muMemAllocPitchmuapi_memory.h
muMemAllocPitch_v2muapi_memory.h
muMemAlloc_v2muapi_memory.h
muMemCreatemuapi_memory.h
muMemExportToShareableHandlemuapi_memory.h
muMemFreemuapi_memory.h
muMemFreeAsyncmuapi_memory.h
muMemFreeHostmuapi_memory.h
muMemFree_v2muapi_memory.h
muMemGetAccessmuapi_memory.h
muMemGetAddressRangemuapi_memory.h
muMemGetAddressRange_v2muapi_memory.h
muMemGetAllocationGranularitymuapi_memory.h
muMemGetAllocationPropertiesFromHandlemuapi_memory.h
muMemGetHandleForAddressRangemuapi_memory.h
muMemGetInfomuapi_memory.h
muMemGetInfo_v2muapi_memory.h
muMemHostAllocmuapi_memory.h
muMemHostGetDevicePointermuapi_memory.h
muMemHostGetDevicePointer_v2muapi_memory.h
muMemHostGetFlagsmuapi_memory.h
muMemHostRegistermuapi_memory.h
muMemHostRegister_v2muapi_memory.h
muMemHostUnregistermuapi_memory.h
muMemImportFromShareableHandlemuapi_memory.h
muMemMapmuapi_memory.h
muMemPoolCreatemuapi_memory.h
muMemPoolDestroymuapi_memory.h
muMemPoolExportPointermuapi_memory.h
muMemPoolExportToShareableHandlemuapi_memory.h
muMemPoolGetAccessmuapi_memory.h
muMemPoolGetAttributemuapi_memory.h
muMemPoolImportFromShareableHandlemuapi_memory.h
muMemPoolImportPointermuapi_memory.h
muMemPoolSetAccessmuapi_memory.h
muMemPoolSetAttributemuapi_memory.h
muMemPoolTrimTomuapi_memory.h
muMemPrefetchAsyncmuapi_memory.h
muMemPrefetchAsync_v2muapi_memory.h
muMemRangeGetAttributemuapi_memory.h
muMemRangeGetAttributesmuapi_memory.h
muMemReleasemuapi_memory.h
muMemRetainAllocationHandlemuapi_memory.h
muMemSetAccessmuapi_memory.h
muMemUnmapmuapi_memory.h
muMemcpymuapi_memory.h
muMemcpy2Dmuapi_memory.h
muMemcpy2DAsyncmuapi_memory.h
muMemcpy2DAsync_v2muapi_memory.h
muMemcpy2DAsync_v2_ptszmuapi_memory.h
muMemcpy2DUnaligned_v2muapi_memory.h
muMemcpy2DUnaligned_v2_ptdsmuapi_memory.h
muMemcpy2D_v2muapi_memory.h
muMemcpy2D_v2_ptdsmuapi_memory.h
muMemcpy3Dmuapi_memory.h
muMemcpy3DAsyncmuapi_memory.h
muMemcpy3DAsync_v2muapi_memory.h
muMemcpy3DAsync_v2_ptszmuapi_memory.h
muMemcpy3DBatchAsyncmuapi_memory.h
muMemcpy3DPeermuapi_memory.h
muMemcpy3DPeerAsyncmuapi_memory.h
muMemcpy3D_v2muapi_memory.h
muMemcpy3D_v2_ptdsmuapi_memory.h
muMemcpyAsyncmuapi_memory.h
muMemcpyAsync_ptszmuapi_memory.h
muMemcpyAtoAmuapi_memory.h
muMemcpyAtoA_v2muapi_memory.h
muMemcpyAtoA_v2_ptdsmuapi_memory.h
muMemcpyAtoDmuapi_memory.h
muMemcpyAtoD_v2muapi_memory.h
muMemcpyAtoD_v2_ptdsmuapi_memory.h
muMemcpyAtoHmuapi_memory.h
muMemcpyAtoHAsyncmuapi_memory.h
muMemcpyAtoHAsync_v2muapi_memory.h
muMemcpyAtoH_v2muapi_memory.h
muMemcpyBatchAsyncmuapi_memory.h
muMemcpyDtoAmuapi_memory.h
muMemcpyDtoA_v2muapi_memory.h
muMemcpyDtoA_v2_ptdsmuapi_memory.h
muMemcpyDtoDmuapi_memory.h
muMemcpyDtoDAsyncmuapi_memory.h
muMemcpyDtoDAsync_v2muapi_memory.h
muMemcpyDtoDAsync_v2_ptszmuapi_memory.h
muMemcpyDtoD_v2muapi_memory.h
muMemcpyDtoD_v2_ptdsmuapi_memory.h
muMemcpyDtoHmuapi_memory.h
muMemcpyDtoHAsyncmuapi_memory.h
muMemcpyDtoHAsync_v2muapi_memory.h
muMemcpyDtoHAsync_v2_ptszmuapi_memory.h
muMemcpyDtoH_v2muapi_memory.h
muMemcpyDtoH_v2_ptdsmuapi_memory.h
muMemcpyHtoAmuapi_memory.h
muMemcpyHtoAAsyncmuapi_memory.h
muMemcpyHtoAAsync_v2muapi_memory.h
muMemcpyHtoA_v2muapi_memory.h
muMemcpyHtoDmuapi_memory.h
muMemcpyHtoDAsyncmuapi_memory.h
muMemcpyHtoDAsync_v2muapi_memory.h
muMemcpyHtoDAsync_v2_ptszmuapi_memory.h
muMemcpyHtoD_v2muapi_memory.h
muMemcpyHtoD_v2_ptdsmuapi_memory.h
muMemcpyPeermuapi_memory.h
muMemcpyPeerAsyncmuapi_memory.h
muMemcpy_ptdsmuapi_memory.h
muMemoryAtomicAsyncmuapi_memory.h
muMemoryAtomicBatchAsyncmuapi_memory.h
muMemoryAtomicValueAsyncmuapi_memory.h
muMemoryTransfermuapi_memory.h
muMemoryTransferAsyncmuapi_memory.h
muMemoryTransferAsync_ptszmuapi_memory.h
muMemoryTransferBatchAsyncmuapi_memory.h
muMemoryTransfer_ptdsmuapi_memory.h
muMemsetD16muapi_memory.h
muMemsetD16Asyncmuapi_memory.h
muMemsetD16Async_ptszmuapi_memory.h
muMemsetD16_v2muapi_memory.h
muMemsetD16_v2_ptdsmuapi_memory.h
muMemsetD2D16muapi_memory.h
muMemsetD2D16Asyncmuapi_memory.h
muMemsetD2D16Async_ptszmuapi_memory.h
muMemsetD2D16_v2muapi_memory.h
muMemsetD2D16_v2_ptdsmuapi_memory.h
muMemsetD2D32muapi_memory.h
muMemsetD2D32Asyncmuapi_memory.h
muMemsetD2D32Async_ptszmuapi_memory.h
muMemsetD2D32_v2muapi_memory.h
muMemsetD2D32_v2_ptdsmuapi_memory.h
muMemsetD2D8muapi_memory.h
muMemsetD2D8Asyncmuapi_memory.h
muMemsetD2D8Async_ptszmuapi_memory.h
muMemsetD2D8_v2muapi_memory.h
muMemsetD2D8_v2_ptdsmuapi_memory.h
muMemsetD32muapi_memory.h
muMemsetD32Asyncmuapi_memory.h
muMemsetD32Async_ptszmuapi_memory.h
muMemsetD32_v2muapi_memory.h
muMemsetD32_v2_ptdsmuapi_memory.h
muMemsetD8muapi_memory.h
muMemsetD8Asyncmuapi_memory.h
muMemsetD8Async_ptszmuapi_memory.h
muMemsetD8_v2muapi_memory.h
muMemsetD8_v2_ptdsmuapi_memory.h
muMipmappedArrayCreatemuapi.h
muMipmappedArrayDestroymuapi.h
muMipmappedArrayGetLevelmuapi.h
muMipmappedArrayGetMemoryRequirementsmuapi.h
muModuleEnumerateFunctionsmuapi_module.h
muModuleGetFunctionmuapi_module.h
muModuleGetFunctionCountmuapi_module.h
muModuleGetGlobalmuapi_module.h
muModuleGetGlobal_v2muapi_module.h
muModuleGetLoadingModemuapi_module.h
muModuleGetSurfRefmuapi_module.h
muModuleGetTexRefmuapi_module.h
muModuleLoadmuapi_module.h
muModuleLoadDatamuapi_module.h
muModuleLoadDataExmuapi_module.h
muModuleLoadFatBinarymuapi_module.h
muModuleUnloadmuapi_module.h
muOccupancyAvailableDynamicSMemPerBlockmuapi_occupancy.h
muOccupancyMaxActiveBlocksPerMultiprocessormuapi_occupancy.h
muOccupancyMaxActiveBlocksPerMultiprocessorWithFlagsmuapi_occupancy.h
muOccupancyMaxActiveClustersmuapi_occupancy.h
muOccupancyMaxPotentialBlockSizemuapi_occupancy.h
muOccupancyMaxPotentialBlockSizeWithFlagsmuapi_occupancy.h
muOccupancyMaxPotentialClusterSizemuapi_occupancy.h
muPointerGetAttributemuapi.h
muPointerGetAttributesmuapi.h
muPointerSetAttributemuapi.h
muProfilerStartmuapi.h
muProfilerStopmuapi.h
muSignalExternalSemaphoresAsyncmuapi.h
muStreamAddCallbackmuapi_stream.h
muStreamAddCallback_ptszmuapi_stream.h
muStreamAttachMemAsyncmuapi_stream.h
muStreamAttachMemAsync_ptszmuapi_stream.h
muStreamBatchMemOp_v2muapi_stream.h
muStreamBeginCapturemuapi_stream.h
muStreamBeginCaptureToGraphmuapi_stream.h
muStreamBeginCapture_v2muapi_stream.h
muStreamCopyAttributesmuapi_stream.h
muStreamCreatemuapi_stream.h
muStreamCreateWithPrioritymuapi_stream.h
muStreamDestroymuapi_stream.h
muStreamDestroy_v2muapi_stream.h
muStreamEndCapturemuapi_stream.h
muStreamGetAttributemuapi_stream.h
muStreamGetCaptureInfomuapi_stream.h
muStreamGetCaptureInfo_v2muapi_stream.h
muStreamGetCaptureInfo_v3muapi_stream.h
muStreamGetCtxmuapi_stream.h
muStreamGetCtx_ptszmuapi_stream.h
muStreamGetCtx_v2muapi_stream.h
muStreamGetDevicemuapi_stream.h
muStreamGetDevice_ptszmuapi_stream.h
muStreamGetFlagsmuapi_stream.h
muStreamGetFlags_ptszmuapi_stream.h
muStreamGetGreenCtxmuapi_stream.h
muStreamGetIdmuapi_stream.h
muStreamGetId_ptszmuapi_stream.h
muStreamGetPrioritymuapi_stream.h
muStreamGetPriority_ptszmuapi_stream.h
muStreamIsCapturingmuapi_stream.h
muStreamQuerymuapi_stream.h
muStreamQuery_ptszmuapi_stream.h
muStreamSetAttributemuapi_stream.h
muStreamSynchronizemuapi_stream.h
muStreamSynchronize_ptszmuapi_stream.h
muStreamUpdateCaptureDependenciesmuapi_stream.h
muStreamUpdateCaptureDependencies_v2muapi_stream.h
muStreamWaitEventmuapi_stream.h
muStreamWaitEvent_ptszmuapi_stream.h
muStreamWaitValue32muapi_stream.h
muStreamWaitValue32_v2muapi_stream.h
muStreamWaitValue64muapi_stream.h
muStreamWaitValue64_v2muapi_stream.h
muStreamWriteValue32muapi_stream.h
muStreamWriteValue32_v2muapi_stream.h
muStreamWriteValue64muapi_stream.h
muStreamWriteValue64_v2muapi_stream.h
muSurfObjectCreatemuapi_object.h
muSurfObjectDestroymuapi_object.h
muSurfObjectGetResourceDescmuapi_object.h
muSurfRefGetArraymuapi_object.h
muSurfRefSetArraymuapi_object.h
muTensorDescriptorEncodemuapi.h
muTensorDescriptorReplaceAddressmuapi.h
muTensorDirectConvEncodemuapi.h
muTensorIm2colConvParamEncodemuapi.h
muTexObjectCreatemuapi_object.h
muTexObjectDestroymuapi_object.h
muTexObjectGetResourceDescmuapi_object.h
muTexObjectGetResourceViewDescmuapi_object.h
muTexObjectGetTextureDescmuapi_object.h
muTexRefCreatemuapi_object.h
muTexRefDestroymuapi_object.h
muTexRefGetAddressmuapi_object.h
muTexRefGetAddressModemuapi_object.h
muTexRefGetAddress_v2muapi_object.h
muTexRefGetArraymuapi_object.h
muTexRefGetBorderColormuapi_object.h
muTexRefGetFilterModemuapi_object.h
muTexRefGetFlagsmuapi_object.h
muTexRefGetFormatmuapi_object.h
muTexRefGetMaxAnisotropymuapi_object.h
muTexRefGetMipmapFilterModemuapi_object.h
muTexRefGetMipmapLevelBiasmuapi_object.h
muTexRefGetMipmapLevelClampmuapi_object.h
muTexRefGetMipmappedArraymuapi_object.h
muTexRefSetAddressmuapi_object.h
muTexRefSetAddress2Dmuapi_object.h
muTexRefSetAddress2D_v3muapi_object.h
muTexRefSetAddressModemuapi_object.h
muTexRefSetAddress_v2muapi_object.h
muTexRefSetArraymuapi_object.h
muTexRefSetBorderColormuapi_object.h
muTexRefSetFilterModemuapi_object.h
muTexRefSetFlagsmuapi_object.h
muTexRefSetFormatmuapi_object.h
muTexRefSetMaxAnisotropymuapi_object.h
muTexRefSetMipmapFilterModemuapi_object.h
muTexRefSetMipmapLevelBiasmuapi_object.h
muTexRefSetMipmapLevelClampmuapi_object.h
muTexRefSetMipmappedArraymuapi_object.h
muThreadExchangeStreamCaptureModemuapi.h
muUserObjectCreatemuapi_graph.h
muUserObjectReleasemuapi_graph.h
muUserObjectRetainmuapi_graph.h
muWaitExternalSemaphoresAsyncmuapi.h

API Function Reference​

Function muArray3DCreate​

Header: muapi_memory.h

MUresult MUSAAPI muArray3DCreate(MUarray *pHandle, const MUSA_ARRAY3D_DESCRIPTOR *pAllocateArray);

Function muArray3DCreate_v2​

Header: muapi_memory.h

MUresult MUSAAPI muArray3DCreate_v2(MUarray *pHandle, const MUSA_ARRAY3D_DESCRIPTOR *pAllocateArray);

Function muArray3DGetDescriptor​

Header: muapi_memory.h

MUresult MUSAAPI muArray3DGetDescriptor(MUSA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, MUarray hArray);

Function muArray3DGetDescriptor_v2​

Header: muapi_memory.h

MUresult MUSAAPI muArray3DGetDescriptor_v2(MUSA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, MUarray hArray);

Function muArrayCreate​

Header: muapi_memory.h

MUresult MUSAAPI muArrayCreate(MUarray *pHandle, const MUSA_ARRAY_DESCRIPTOR *pAllocateArray);

Function muArrayCreate_v2​

Header: muapi_memory.h

MUresult MUSAAPI muArrayCreate_v2(MUarray *pHandle, const MUSA_ARRAY_DESCRIPTOR *pAllocateArray);

Function muArrayDestroy​

Header: muapi_memory.h

MUresult MUSAAPI muArrayDestroy(MUarray hArray);

Function muArrayGetDescriptor​

Header: muapi_memory.h

MUresult MUSAAPI muArrayGetDescriptor(MUSA_ARRAY_DESCRIPTOR *pArrayDescriptor, MUarray hArray);

Function muArrayGetDescriptor_v2​

Header: muapi_memory.h

MUresult MUSAAPI muArrayGetDescriptor_v2(MUSA_ARRAY_DESCRIPTOR *pArrayDescriptor, MUarray hArray);

Function muArrayGetMemoryRequirements​

Header: muapi_memory.h

MUresult MUSAAPI muArrayGetMemoryRequirements(MUSA_ARRAY_MEMORY_REQUIREMENTS *memoryRequirements, MUarray array, MUdevice device);

Function muCoredumpGetAttribute​

Header: muapi.h

MUresult MUSAAPI muCoredumpGetAttribute(MUcoredumpSettings attrib, void* value, size_t *size);

Function muCoredumpGetAttributeGlobal​

Header: muapi.h

MUresult MUSAAPI muCoredumpGetAttributeGlobal(MUcoredumpSettings attrib, void *value, size_t *size);

Function muCoredumpSetAttribute​

Header: muapi.h

MUresult MUSAAPI muCoredumpSetAttribute(MUcoredumpSettings attrib, void* value, size_t *size);

Function muCoredumpSetAttributeGlobal​

Header: muapi.h

MUresult MUSAAPI muCoredumpSetAttributeGlobal(MUcoredumpSettings attrib, void *value, size_t *size);

Function muCtxAttach​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxAttach(MUcontext *pctx, unsigned int flags);

Function muCtxCreate​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxCreate(MUcontext *pctx, unsigned int flags, MUdevice dev);

Function muCtxCreate_v2​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxCreate_v2(MUcontext *pctx, unsigned int flags, MUdevice dev);

Function muCtxDestroy​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxDestroy(MUcontext ctx);

Function muCtxDestroy_v2​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxDestroy_v2(MUcontext ctx);

Function muCtxDetach​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxDetach(MUcontext ctx);

Function muCtxDisablePeerAccess​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxDisablePeerAccess(MUcontext peerContext);

Function muCtxEnablePeerAccess​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxEnablePeerAccess(MUcontext peerContext, unsigned int Flags);

Function muCtxFromGreenCtx​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxFromGreenCtx(MUcontext *pContext, MUgreenCtx hCtx);

Function muCtxGetApiVersion​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetApiVersion(MUcontext ctx, unsigned int *version);

Function muCtxGetCacheConfig​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetCacheConfig(MUfunc_cache *pconfig);

Function muCtxGetCurrent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetCurrent(MUcontext *pctx);

Function muCtxGetDevResource​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetDevResource(MUcontext hCtx, MUdevResource* resource, MUdevResourceType type);

Function muCtxGetDevice​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetDevice(MUdevice *device);

Function muCtxGetFlags​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetFlags(unsigned int *flags);

Function muCtxGetId​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetId(MUcontext ctx, unsigned long long *ctxId);

Function muCtxGetLimit​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetLimit(size_t *pvalue, MUlimit limit);

Function muCtxGetSharedMemConfig​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetSharedMemConfig(MUsharedconfig *pConfig);

Function muCtxGetStreamPriorityRange​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxGetStreamPriorityRange(int *leastPriority, int *greatestPriority);

Function muCtxPopCurrent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxPopCurrent(MUcontext *pctx);

Function muCtxPopCurrent_v2​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxPopCurrent_v2(MUcontext *pctx);

Function muCtxPushCurrent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxPushCurrent(MUcontext ctx);

Function muCtxPushCurrent_v2​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxPushCurrent_v2(MUcontext ctx);

Function muCtxRecordEvent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxRecordEvent(MUcontext hCtx, MUevent hEvent);

Function muCtxResetPersistingL2Cache​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxResetPersistingL2Cache(void);

Function muCtxSetCacheConfig​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSetCacheConfig(MUfunc_cache config);

Function muCtxSetCurrent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSetCurrent(MUcontext ctx);

Function muCtxSetFlags​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSetFlags(unsigned int flags);

Function muCtxSetLimit​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSetLimit(MUlimit limit, size_t value);

Function muCtxSetSharedMemConfig​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSetSharedMemConfig(MUsharedconfig config);

Function muCtxSynchronize​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxSynchronize(void);

Function muCtxWaitEvent​

Header: muapi_ctx.h

MUresult MUSAAPI muCtxWaitEvent(MUcontext hCtx, MUevent hEvent);

Function muDebugFlag​

Header: mugdb/tracepoints.h

bool muDebugFlag;

Function muDebugInit​

Header: mugdb/tracepoints.h

MUresult MUGDBAPI muDebugInit(void);

Function muDebugSendRunningKernelInfo​

Header: mugdb/tracepoints.h

MUresult MUGDBAPI muDebugSendRuningKernelInfo(void);

Function muDebugSendTrapInfo​

Header: mugdb/tracepoints.h

MUresult MUGDBAPI muDebugSendTrapInfo(void);

Function muDestroyExternalMemory​

Header: muapi.h

MUresult MUSAAPI muDestroyExternalMemory(MUexternalMemory extMem);

Function muDestroyExternalSemaphore​

Header: muapi.h

MUresult MUSAAPI muDestroyExternalSemaphore(MUexternalSemaphore extSem);

Function muDevResourceGenerateDesc​

Header: muapi.h

MUresult MUSAAPI muDevResourceGenerateDesc(MUdevResourceDesc *phDesc, MUdevResource *resources, unsigned int nbResources);

Function muDevSmResourceSplitByCount​

Header: muapi.h

MUresult MUSAAPI muDevSmResourceSplitByCount( MUdevResource* result, unsigned int* nbGroups, const MUdevResource* input, MUdevResource* remaining, unsigned int useFlags, unsigned int minCount);

Function muDeviceCanAccessPeer​

Header: muapi_device.h

MUresult MUSAAPI muDeviceCanAccessPeer(int *canAccessPeer, MUdevice dev, MUdevice peerDev);

Function muDeviceComputeCapability​

Header: muapi_device.h

MUresult MUSAAPI muDeviceComputeCapability(int *major, int *minor, MUdevice dev);

Function muDeviceGet​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGet(MUdevice *device, int ordinal);

Function muDeviceGetAttribute​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetAttribute(int *pi, MUdevice_attribute attrib, MUdevice dev);

Function muDeviceGetByPCIBusId​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetByPCIBusId(MUdevice *dev, const char *pciBusId);

Function muDeviceGetCount​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetCount(int *count);

Function muDeviceGetDefaultMemPool​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetDefaultMemPool(MUmemoryPool *pool_out, MUdevice dev);

Function muDeviceGetDevResource​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetDevResource(MUdevice device, MUdevResource* resource, MUdevResourceType type);

Function muDeviceGetGraphMemAttribute​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetGraphMemAttribute(MUdevice device, MUgraphMem_attribute attr, void* value);

Function muDeviceGetMemPool​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetMemPool(MUmemoryPool *pool, MUdevice dev);

Function muDeviceGetName​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetName(char *name, int len, MUdevice dev);

Function muDeviceGetP2PAttribute​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetP2PAttribute(int* value, MUdevice_P2PAttribute attrib, MUdevice srcDevice, MUdevice dstDevice);

Function muDeviceGetPCIBusId​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetPCIBusId(char *pciBusId, int len, MUdevice dev);

Function muDeviceGetProperties​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetProperties(MUdevprop *prop, MUdevice dev);

Function muDeviceGetTexture1DLinearMaxWidth​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, MUarray_format format, unsigned numChannels, MUdevice dev);

Function muDeviceGetUuid​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetUuid(MUuuid *uuid, MUdevice dev);

Function muDeviceGetUuid_v2​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGetUuid_v2(MUuuid *uuid, MUdevice dev);

Function muDeviceGraphMemTrim​

Header: muapi_device.h

MUresult MUSAAPI muDeviceGraphMemTrim(MUdevice device);

Function muDevicePrimaryCtxGetState​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxGetState(MUdevice dev, unsigned int *flags, int *active);

Function muDevicePrimaryCtxRelease​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxRelease(MUdevice dev);

Function muDevicePrimaryCtxRelease_v2​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxRelease_v2(MUdevice dev);

Function muDevicePrimaryCtxReset​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxReset(MUdevice dev);

Function muDevicePrimaryCtxReset_v2​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxReset_v2(MUdevice dev);

Function muDevicePrimaryCtxRetain​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxRetain(MUcontext *pctx, MUdevice dev);

Function muDevicePrimaryCtxSetFlags​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxSetFlags(MUdevice dev, unsigned int flags);

Function muDevicePrimaryCtxSetFlags_v2​

Header: muapi_device.h

MUresult MUSAAPI muDevicePrimaryCtxSetFlags_v2(MUdevice dev, unsigned int flags);

Function muDeviceSetGraphMemAttribute​

Header: muapi_device.h

MUresult MUSAAPI muDeviceSetGraphMemAttribute(MUdevice device, MUgraphMem_attribute attr, void* value);

Function muDeviceSetMemPool​

Header: muapi_device.h

MUresult MUSAAPI muDeviceSetMemPool(MUdevice dev, MUmemoryPool pool);

Function muDeviceTotalMem​

Header: muapi_device.h

MUresult MUSAAPI muDeviceTotalMem(size_t *bytes, MUdevice dev);

Function muDeviceTotalMem_v2​

Header: muapi_device.h

MUresult MUSAAPI muDeviceTotalMem_v2(size_t *bytes, MUdevice dev);

Function muDriverGetVersion​

Header: muapi_device.h

MUresult MUSAAPI muDriverGetVersion(int *driverVersion);

Function muEventCreate​

Header: muapi_event.h

MUresult MUSAAPI muEventCreate(MUevent *phEvent, unsigned int Flags);

Function muEventDestroy​

Header: muapi_event.h

MUresult MUSAAPI muEventDestroy(MUevent hEvent);

Function muEventDestroy_v2​

Header: muapi_event.h

MUresult MUSAAPI muEventDestroy_v2(MUevent hEvent);

Function muEventElapsedTime​

Header: muapi_event.h

MUresult MUSAAPI muEventElapsedTime(float *pMilliseconds, MUevent hStart, MUevent hEnd);

Function muEventElapsedTime_v2​

Header: muapi_event.h

MUresult MUSAAPI muEventElapsedTime_v2(float *pMilliseconds, MUevent hStart, MUevent hEnd);

Function muEventQuery​

Header: muapi_event.h

MUresult MUSAAPI muEventQuery(MUevent hEvent);

Function muEventRecord​

Header: muapi_event.h

MUresult MUSAAPI muEventRecord(MUevent hEvent, MUstream hStream);

Function muEventRecordWithFlags​

Header: muapi_event.h

MUresult MUSAAPI muEventRecordWithFlags(MUevent hEvent, MUstream hStream, unsigned int flags);

Function muEventRecordWithFlags_ptsz​

Header: muapi_event.h

MUresult MUSAAPI muEventRecordWithFlags_ptsz(MUevent hEvent, MUstream hStream, unsigned int flags);

Function muEventRecord_ptsz​

Header: muapi_event.h

MUresult MUSAAPI muEventRecord_ptsz(MUevent hEvent, MUstream hStream);

Function muEventSynchronize​

Header: muapi_event.h

MUresult MUSAAPI muEventSynchronize(MUevent hEvent);

Function muExternalMemoryGetMappedBuffer​

Header: muapi_external.h

MUresult MUSAAPI muExternalMemoryGetMappedBuffer(MUdeviceptr *devPtr, MUexternalMemory extMem, const MUSA_EXTERNAL_MEMORY_BUFFER_DESC *bufferDesc);

Function muExternalMemoryGetMappedMipmappedArray​

Header: muapi_external.h

MUresult MUSAAPI muExternalMemoryGetMappedMipmappedArray(MUmipmappedArray *mipmap, MUexternalMemory extMem, const MUSA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *mipmapDesc);

Function muFuncGetAttribute​

Header: muapi_module.h

MUresult MUSAAPI muFuncGetAttribute(int *pi, MUfunction_attribute attrib, MUfunction hfunc);

Function muFuncGetModule​

Header: muapi_module.h

MUresult MUSAAPI muFuncGetModule(MUmodule *hmod, MUfunction hfunc);

Function muFuncGetName​

Header: muapi_module.h

MUresult MUSAAPI muFuncGetName(const char **name, MUfunction hfunc);

Function muFuncGetParamInfo​

Header: muapi_module.h

MUresult MUSAAPI muFuncGetParamInfo(MUfunction func, size_t paramIndex, size_t *paramOffset, size_t *paramSize);

Function muFuncIsLoaded​

Header: muapi_module.h

MUresult MUSAAPI muFuncIsLoaded(MUfunctionLoadingState *state, MUfunction function);

Function muFuncLoad​

Header: muapi_module.h

MUresult MUSAAPI muFuncLoad(MUfunction function);

Function muFuncSetAttribute​

Header: muapi_module.h

MUresult MUSAAPI muFuncSetAttribute(MUfunction hfunc, MUfunction_attribute attrib, int value);

Function muFuncSetCacheConfig​

Header: muapi_module.h

MUresult MUSAAPI muFuncSetCacheConfig(MUfunction hfunc, MUfunc_cache config);

Function muFuncSetSharedMemConfig​

Header: muapi_module.h

MUresult MUSAAPI muFuncSetSharedMemConfig(MUfunction hfunc, MUsharedconfig config);

Function muGdbPid​

Header: mugdb/tracepoints.h

uint32_t muGdbPid;

Function muGdbSessionId​

Header: mugdb/tracepoints.h

uint32_t muGdbSessionId;

Function muGetErrorName​

Header: muapi_ctx.h

MUresult MUSAAPI muGetErrorName(MUresult error, const char **pStr);

Function muGetErrorString​

Header: muapi_ctx.h

MUresult MUSAAPI muGetErrorString(MUresult error, const char **pStr);

Function muGetExportTable​

Header: muapi_ctx.h

MUresult MUSAAPI muGetExportTable(const void **ppExportTable, const MUuuid *pExportTableId);

Function muGetProcAddress​

Header: muapi_ctx.h

MUresult MUSAAPI muGetProcAddress(const char *symbol, void **pfn, int musaVersion, muuint64_t flags, MUdriverProcAddressQueryResult *symbolStatus);

Function muGetProcAddress_v2​

Header: muapi_ctx.h

MUresult muGetProcAddress_v2(const char *symbol, void **funcPtr, int driverVersion, muuint64_t flags, MUdriverProcAddressQueryResult *symbolStatus) { const int procAddressMask = (MU_GET_PROC_ADDRESS_LEGACY_STREAM| MU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM);

Function muGetProcAddress_v2_ptsz​

Header: muapi_ctx.h

MUresult muGetProcAddress_v2_ptsz(const char *symbol, void **funcPtr, int driverVersion, muuint64_t flags, MUdriverProcAddressQueryResult *symbolStatus) { const int procAddressMask = (MU_GET_PROC_ADDRESS_LEGACY_STREAM| MU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM);

Function muGraphAddBatchMemOpNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddBatchMemOpNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_BATCH_MEM_OP_NODE_PARAMS *nodeParams);

Function muGraphAddChildGraphNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddChildGraphNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUgraph childGraph);

Function muGraphAddDependencies​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddDependencies(MUgraph hGraph, const MUgraphNode *from, const MUgraphNode *to, size_t numDependencies);

Function muGraphAddDependencies_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddDependencies_v2(MUgraph hGraph, const MUgraphNode *from, const MUgraphNode *to, const MUgraphEdgeData *edgeData, size_t numDependencies);

Function muGraphAddEmptyNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddEmptyNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies);

Function muGraphAddEventRecordNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddEventRecordNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUevent event);

Function muGraphAddEventWaitNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddEventWaitNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUevent event);

Function muGraphAddExternalSemaphoresSignalNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddExternalSemaphoresSignalNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);

Function muGraphAddExternalSemaphoresWaitNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddExternalSemaphoresWaitNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);

Function muGraphAddHostNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddHostNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_HOST_NODE_PARAMS *nodeParams);

Function muGraphAddKernelNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddKernelNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphAddKernelNode_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddKernelNode_v2(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphAddMemAllocNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemAllocNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUSA_MEM_ALLOC_NODE_PARAMS *nodeParams);

Function muGraphAddMemAtomicNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemAtomicNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEM_ATOMIC_NODE_PARAMS* memAtomicParams, MUcontext ctx);

Function muGraphAddMemAtomicValueNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemAtomicValueNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEM_ATOMIC_VALUE_NODE_PARAMS* memAtomicValueParams, MUcontext ctx);

Function muGraphAddMemFreeNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemFreeNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUdeviceptr dptr);

Function muGraphAddMemTransferNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemTransferNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEM_TRANSFER_NODE_PARAMS* memTransferParams, MUcontext ctx);

Function muGraphAddMemWaitWriteNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemWaitWriteNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEM_WAIT_WRITE_NODE_PARAMS* memWaitWriteParams, MUcontext ctx);

Function muGraphAddMemcpyNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemcpyNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEMCPY3D *copyParams, MUcontext ctx);

Function muGraphAddMemsetNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddMemsetNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, const MUSA_MEMSET_NODE_PARAMS *memsetParams, MUcontext ctx);

Function muGraphAddNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddNode(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, size_t numDependencies, MUgraphNodeParams *nodeParams);

Function muGraphAddNode_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphAddNode_v2(MUgraphNode *phGraphNode, MUgraph hGraph, const MUgraphNode *dependencies, const MUgraphEdgeData *dependencyData, size_t numDependencies, MUgraphNodeParams *nodeParams);

Function muGraphBatchMemOpNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphBatchMemOpNodeGetParams(MUgraphNode hNode, MUSA_BATCH_MEM_OP_NODE_PARAMS *nodeParams_out);

Function muGraphBatchMemOpNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphBatchMemOpNodeSetParams(MUgraphNode hNode, const MUSA_BATCH_MEM_OP_NODE_PARAMS *nodeParams);

Function muGraphChildGraphNodeGetGraph​

Header: muapi_graph.h

MUresult MUSAAPI muGraphChildGraphNodeGetGraph(MUgraphNode hNode, MUgraph *phGraph);

Function muGraphClone​

Header: muapi_graph.h

MUresult MUSAAPI muGraphClone(MUgraph *phGraphClone, MUgraph originalGraph);

Function muGraphConditionalHandleCreate​

Header: muapi_graph.h

MUresult MUSAAPI muGraphConditionalHandleCreate(MUgraphConditionalHandle *pHandle_out, MUgraph hGraph, MUcontext ctx, unsigned int defaultLaunchValue, unsigned int flags);

Function muGraphCreate​

Header: muapi_graph.h

MUresult MUSAAPI muGraphCreate(MUgraph *phGraph, unsigned int flags);

Function muGraphDebugDotPrint​

Header: muapi_graph.h

MUresult MUSAAPI muGraphDebugDotPrint(MUgraph hGraph, const char *path, unsigned int flags);

Function muGraphDestroy​

Header: muapi_graph.h

MUresult MUSAAPI muGraphDestroy(MUgraph hGraph);

Function muGraphDestroyNode​

Header: muapi_graph.h

MUresult MUSAAPI muGraphDestroyNode(MUgraphNode hNode);

Function muGraphEventRecordNodeGetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventRecordNodeGetEvent(MUgraphNode hNode, MUevent *event_out);

Function muGraphEventRecordNodeGetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventRecordNodeGetEvent(MUgraphNode hNode, MUevent *event_out);

Function muGraphEventRecordNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventRecordNodeSetEvent(MUgraphNode hNode, MUevent event);

Function muGraphEventRecordNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventRecordNodeSetEvent(MUgraphNode hNode, MUevent event);

Function muGraphEventWaitNodeGetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventWaitNodeGetEvent(MUgraphNode hNode, MUevent *event_out);

Function muGraphEventWaitNodeGetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventWaitNodeGetEvent(MUgraphNode hNode, MUevent *event_out);

Function muGraphEventWaitNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventWaitNodeSetEvent(MUgraphNode hNode, MUevent event);

Function muGraphEventWaitNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphEventWaitNodeSetEvent(MUgraphNode hNode, MUevent event);

Function muGraphExecChildGraphNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecChildGraphNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, MUgraph childGraph);

Function muGraphExecDestroy​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecDestroy(MUgraphExec hGraphExec);

Function muGraphExecEventRecordNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecEventRecordNodeSetEvent(MUgraphExec hGraphExec, MUgraphNode hNode, MUevent event);

Function muGraphExecEventWaitNodeSetEvent​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecEventWaitNodeSetEvent(MUgraphExec hGraphExec, MUgraphNode hNode, MUevent event);

Function muGraphExecExternalSemaphoresSignalNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecExternalSemaphoresSignalNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);

Function muGraphExecExternalSemaphoresWaitNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecExternalSemaphoresWaitNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);

Function muGraphExecGetFlags​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecGetFlags(MUgraphExec hGraphExec, muuint64_t *flags);

Function muGraphExecHostNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecHostNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_HOST_NODE_PARAMS *nodeParams);

Function muGraphExecKernelNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecKernelNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphExecKernelNodeSetParams_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecKernelNodeSetParams_v2(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphExecMemAtomicNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemAtomicNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEM_ATOMIC_NODE_PARAMS *nodeParams, MUcontext ctx);

Function muGraphExecMemAtomicValueNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemAtomicValueNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEM_ATOMIC_VALUE_NODE_PARAMS *nodeParams, MUcontext ctx);

Function muGraphExecMemTransferNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemTransferNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEM_TRANSFER_NODE_PARAMS *nodeParams, MUcontext ctx);

Function muGraphExecMemWaitWriteNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemWaitWriteNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEM_WAIT_WRITE_NODE_PARAMS *nodeParams, MUcontext ctx);

Function muGraphExecMemcpyNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemcpyNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEMCPY3D *copyParams, MUcontext ctx);

Function muGraphExecMemsetNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecMemsetNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, const MUSA_MEMSET_NODE_PARAMS *memsetParams, MUcontext ctx);

Function muGraphExecNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecNodeSetParams(MUgraphExec hGraphExec, MUgraphNode hNode, MUgraphNodeParams *nodeParams);

Function muGraphExecUpdate​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecUpdate(MUgraphExec hGraphExec, MUgraph hGraph, MUgraphExecUpdateResultInfo *resultInfo);

Function muGraphExecUpdate_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExecUpdate_v2(MUgraphExec hGraphExec, MUgraph hGraph, MUgraphExecUpdateResultInfo *resultInfo);

Function muGraphExternalSemaphoresSignalNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExternalSemaphoresSignalNodeGetParams(MUgraphNode hNode, MUSA_EXT_SEM_SIGNAL_NODE_PARAMS *params_out);

Function muGraphExternalSemaphoresSignalNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExternalSemaphoresSignalNodeSetParams(MUgraphNode hNode, const MUSA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);

Function muGraphExternalSemaphoresWaitNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExternalSemaphoresWaitNodeGetParams(MUgraphNode hNode, MUSA_EXT_SEM_WAIT_NODE_PARAMS *params_out);

Function muGraphExternalSemaphoresWaitNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphExternalSemaphoresWaitNodeSetParams(MUgraphNode hNode, const MUSA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);

Function muGraphGetEdges​

Header: muapi_graph.h

MUresult MUSAAPI muGraphGetEdges(MUgraph hGraph, MUgraphNode *from, MUgraphNode *to, size_t *numEdges);

Function muGraphGetEdges_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphGetEdges_v2(MUgraph hGraph, MUgraphNode *from, MUgraphNode *to, MUgraphEdgeData *edgeData, size_t *numEdges);

Function muGraphGetNodes​

Header: muapi_graph.h

MUresult MUSAAPI muGraphGetNodes(MUgraph hGraph, MUgraphNode *nodes, size_t *numNodes);

Function muGraphGetRootNodes​

Header: muapi_graph.h

MUresult MUSAAPI muGraphGetRootNodes(MUgraph hGraph, MUgraphNode *rootNodes, size_t *numRootNodes);

Function muGraphHostNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphHostNodeGetParams(MUgraphNode hNode, MUSA_HOST_NODE_PARAMS *nodeParams);

Function muGraphHostNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphHostNodeSetParams(MUgraphNode hNode, const MUSA_HOST_NODE_PARAMS *nodeParams);

Function muGraphInstantiate​

Header: muapi_graph.h

MUresult MUSAAPI muGraphInstantiate(MUgraphExec *phGraphExec, MUgraph hGraph, unsigned long long flags);

Function muGraphInstantiateWithFlags​

Header: muapi_graph.h

MUresult MUSAAPI muGraphInstantiateWithFlags(MUgraphExec *phGraphExec, MUgraph hGraph, unsigned long long flags);

Function muGraphInstantiateWithParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphInstantiateWithParams(MUgraphExec *phGraphExec, MUgraph hGraph, MUSA_GRAPH_INSTANTIATE_PARAMS *instantiateParams);

Function muGraphInstantiate_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphInstantiate_v2(MUgraphExec *phGraphExec, MUgraph hGraph, MUgraphNode *phErrorNode, char *logBuffer, size_t bufferSize);

Function muGraphKernelNodeCopyAttributes​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeCopyAttributes(MUgraphNode dst, MUgraphNode src);

Function muGraphKernelNodeGetAttribute​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeGetAttribute(MUgraphNode hNode, MUkernelNodeAttrID attr, MUkernelNodeAttrValue *value_out);

Function muGraphKernelNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeGetParams(MUgraphNode hNode, MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphKernelNodeGetParams_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeGetParams_v2(MUgraphNode hNode, MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphKernelNodeSetAttribute​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeSetAttribute(MUgraphNode hNode, MUkernelNodeAttrID attr, const MUkernelNodeAttrValue *value);

Function muGraphKernelNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeSetParams(MUgraphNode hNode, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphKernelNodeSetParams_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphKernelNodeSetParams_v2(MUgraphNode hNode, const MUSA_KERNEL_NODE_PARAMS *nodeParams);

Function muGraphLaunch​

Header: muapi_graph.h

MUresult MUSAAPI muGraphLaunch(MUgraphExec hGraphExec, MUstream hStream);

Function muGraphMemAllocNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemAllocNodeGetParams(MUgraphNode hNode, MUSA_MEM_ALLOC_NODE_PARAMS *params_out);

Function muGraphMemAtomicNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemAtomicNodeGetParams(MUgraphNode hNode, MUSA_MEM_ATOMIC_NODE_PARAMS *nodeParams);

Function muGraphMemAtomicNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemAtomicNodeSetParams(MUgraphNode hNode, const MUSA_MEM_ATOMIC_NODE_PARAMS *nodeParams);

Function muGraphMemAtomicValueNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemAtomicValueNodeGetParams(MUgraphNode hNode, MUSA_MEM_ATOMIC_VALUE_NODE_PARAMS *nodeParams);

Function muGraphMemAtomicValueNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemAtomicValueNodeSetParams(MUgraphNode hNode, const MUSA_MEM_ATOMIC_VALUE_NODE_PARAMS *nodeParams);

Function muGraphMemFreeNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemFreeNodeGetParams(MUgraphNode hNode, MUdeviceptr *dptr_out);

Function muGraphMemTransferNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemTransferNodeGetParams(MUgraphNode hNode, MUSA_MEM_TRANSFER_NODE_PARAMS* nodeParams);

Function muGraphMemTransferNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemTransferNodeSetParams(MUgraphNode hNode, const MUSA_MEM_TRANSFER_NODE_PARAMS* nodeParams);

Function muGraphMemWaitWriteNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemWaitWriteNodeGetParams(MUgraphNode hNode, MUSA_MEM_WAIT_WRITE_NODE_PARAMS *nodeParams);

Function muGraphMemWaitWriteNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemWaitWriteNodeSetParams(MUgraphNode hNode, const MUSA_MEM_WAIT_WRITE_NODE_PARAMS *nodeParams);

Function muGraphMemcpyNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemcpyNodeGetParams(MUgraphNode hNode, MUSA_MEMCPY3D *nodeParams);

Function muGraphMemcpyNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemcpyNodeSetParams(MUgraphNode hNode, const MUSA_MEMCPY3D *nodeParams);

Function muGraphMemsetNodeGetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemsetNodeGetParams(MUgraphNode hNode, MUSA_MEMSET_NODE_PARAMS *nodeParams);

Function muGraphMemsetNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphMemsetNodeSetParams(MUgraphNode hNode, const MUSA_MEMSET_NODE_PARAMS *nodeParams);

Function muGraphNodeFindInClone​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeFindInClone(MUgraphNode *phNode, MUgraphNode hOriginalNode, MUgraph hClonedGraph);

Function muGraphNodeGetDependencies​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetDependencies(MUgraphNode hNode, MUgraphNode *dependencies, size_t *numDependencies);

Function muGraphNodeGetDependencies_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetDependencies_v2(MUgraphNode hNode, MUgraphNode *dependencies, MUgraphEdgeData *edgeData, size_t *numDependencies);

Function muGraphNodeGetDependentNodes​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetDependentNodes(MUgraphNode hNode, MUgraphNode *dependentNodes, size_t *numDependentNodes);

Function muGraphNodeGetDependentNodes_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetDependentNodes_v2(MUgraphNode hNode, MUgraphNode *dependentNodes, MUgraphEdgeData *edgeData, size_t *numDependentNodes);

Function muGraphNodeGetEnabled​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetEnabled(MUgraphExec hGraphExec, MUgraphNode hNode, unsigned int *isEnabled);

Function muGraphNodeGetType​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeGetType(MUgraphNode hNode, MUgraphNodeType *type);

Function muGraphNodeSetEnabled​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeSetEnabled(MUgraphExec hGraphExec, MUgraphNode hNode, unsigned int isEnabled);

Function muGraphNodeSetParams​

Header: muapi_graph.h

MUresult MUSAAPI muGraphNodeSetParams(MUgraphNode hNode, MUgraphNodeParams *nodeParams);

Function muGraphReleaseUserObject​

Header: muapi_graph.h

MUresult MUSAAPI muGraphReleaseUserObject(MUgraph graph, MUuserObject object, unsigned int count);

Function muGraphRemoveDependencies​

Header: muapi_graph.h

MUresult MUSAAPI muGraphRemoveDependencies(MUgraph hGraph, const MUgraphNode *from, const MUgraphNode *to, size_t numDependencies);

Function muGraphRemoveDependencies_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphRemoveDependencies_v2(MUgraph hGraph, const MUgraphNode *from, const MUgraphNode *to, const MUgraphEdgeData *edgeData, size_t numDependencies);

Function muGraphRetainUserObject​

Header: muapi_graph.h

MUresult MUSAAPI muGraphRetainUserObject(MUgraph graph, MUuserObject object, unsigned int count, unsigned int flags);

Function muGraphUpload​

Header: muapi_graph.h

MUresult MUSAAPI muGraphUpload(MUgraphExec hGraphExec, MUstream hStream);

Function muGraphicsGLRegisterBuffer​

Header: musa_gl_interop.h (Runtime)

MUresult muGraphicsGLRegisterBuffer(...); // OpenGL interop API

Function muGraphicsGLRegisterImage​

Header: musa_gl_interop.h (Runtime)

MUresult muGraphicsGLRegisterImage(...); // OpenGL interop API

Function muGraphicsMapResources​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsMapResources(unsigned int count, MUgraphicsResource *resources, MUstream hStream);

Function muGraphicsMapResources_ptsz​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsMapResources_ptsz(unsigned int count, MUgraphicsResource *resources, MUstream hStream);

Function muGraphicsResourceGetMappedMipmappedArray​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsResourceGetMappedMipmappedArray(MUmipmappedArray *pMipmappedArray, MUgraphicsResource resource);

Function muGraphicsResourceGetMappedPointer​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsResourceGetMappedPointer(MUdeviceptr *pDevPtr, size_t *pSize, MUgraphicsResource resource);

Function muGraphicsResourceGetMappedPointer_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsResourceGetMappedPointer_v2(MUdeviceptr *pDevPtr, size_t *pSize, MUgraphicsResource resource);

Function muGraphicsResourceSetMapFlags​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsResourceSetMapFlags(MUgraphicsResource resource, unsigned int flags);

Function muGraphicsResourceSetMapFlags_v2​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsResourceSetMapFlags_v2(MUgraphicsResource resource, unsigned int flags);

Function muGraphicsSubResourceGetMappedArray​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsSubResourceGetMappedArray(MUarray *pArray, MUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel);

Function muGraphicsUnmapResources​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsUnmapResources(unsigned int count, MUgraphicsResource *resources, MUstream hStream);

Function muGraphicsUnmapResources_ptsz​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsUnmapResources_ptsz(unsigned int count, MUgraphicsResource *resources, MUstream hStream);

Function muGraphicsUnregisterResource​

Header: muapi_graph.h

MUresult MUSAAPI muGraphicsUnregisterResource(MUgraphicsResource resource);

Function muGreenCtxCreate​

Header: muapi.h

MUresult MUSAAPI muGreenCtxCreate(MUgreenCtx* phCtx, MUdevResourceDesc desc, MUdevice dev, unsigned int flags);

Function muGreenCtxDestroy​

Header: muapi.h

MUresult MUSAAPI muGreenCtxDestroy(MUgreenCtx hCtx);

Function muGreenCtxGetDevResource​

Header: muapi.h

MUresult MUSAAPI muGreenCtxGetDevResource(MUgreenCtx hCtx, MUdevResource* resource, MUdevResourceType type);

Function muGreenCtxRecordEvent​

Header: muapi.h

MUresult MUSAAPI muGreenCtxRecordEvent(MUgreenCtx hCtx, MUevent hEvent);

Function muGreenCtxStreamCreate​

Header: muapi.h

MUresult MUSAAPI muGreenCtxStreamCreate(MUstream* phStream, MUgreenCtx greenCtx, unsigned int flags, int priority);

Function muGreenCtxWaitEvent​

Header: muapi.h

MUresult MUSAAPI muGreenCtxWaitEvent(MUgreenCtx hCtx, MUevent hEvent);

Function muImportExternalMemory​

Header: muapi.h

MUresult MUSAAPI muImportExternalMemory(MUexternalMemory *extMem_out, const MUSA_EXTERNAL_MEMORY_HANDLE_DESC *memHandleDesc);

Function muImportExternalSemaphore​

Header: muapi.h

MUresult MUSAAPI muImportExternalSemaphore(MUexternalSemaphore *extSem_out, const MUSA_EXTERNAL_SEMAPHORE_HANDLE_DESC *semHandleDesc);

Function muInit​

Header: muapi_ctx.h

MUresult MUSAAPI muInit(unsigned int Flags);

Function muIpcCloseMemHandle​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcCloseMemHandle(MUdeviceptr dptr);

Function muIpcGetEventHandle​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcGetEventHandle(MUipcEventHandle *pHandle, MUevent event);

Function muIpcGetMemHandle​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcGetMemHandle(MUipcMemHandle *pHandle, MUdeviceptr dptr);

Function muIpcOpenEventHandle​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcOpenEventHandle(MUevent *phEvent, MUipcEventHandle handle);

Function muIpcOpenMemHandle​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcOpenMemHandle(MUdeviceptr *pdptr, MUipcMemHandle handle, unsigned int Flags);

Function muIpcOpenMemHandle_v2​

Header: muapi_ipc.h

MUresult MUSAAPI muIpcOpenMemHandle_v2(MUdeviceptr *pdptr, MUipcMemHandle handle, unsigned int Flags);

Function muKernelGetAttribute​

Header: muapi.h

MUresult MUSAAPI muKernelGetAttribute(int *pi, MUfunction_attribute attrib, MUkernel kernel, MUdevice dev);

Function muKernelGetFunction​

Header: muapi.h

MUresult MUSAAPI muKernelGetFunction(MUfunction *pFunc, MUkernel kernel);

Function muKernelGetLibrary​

Header: muapi.h

MUresult MUSAAPI muKernelGetLibrary(MUlibrary *pLib, MUkernel kernel);

Function muKernelGetName​

Header: muapi.h

MUresult MUSAAPI muKernelGetName(const char **name, MUkernel hfunc);

Function muKernelGetParamInfo​

Header: muapi.h

MUresult MUSAAPI muKernelGetParamInfo(MUkernel kernel, size_t paramIndex, size_t *paramOffset, size_t *paramSize);

Function muKernelSetAttribute​

Header: muapi.h

MUresult MUSAAPI muKernelSetAttribute(MUfunction_attribute attrib, int val, MUkernel kernel, MUdevice dev);

Function muKernelSetCacheConfig​

Header: muapi.h

MUresult MUSAAPI muKernelSetCacheConfig(MUkernel kernel, MUfunc_cache config, MUdevice dev);

Function muLaunchCooperativeKernel​

Header: muapi_module.h

MUresult MUSAAPI muLaunchCooperativeKernel(MUfunction f, // unsigned int gridDimX, // unsigned int gridDimY, // unsigned int gridDimZ, // unsigned int blockDimX, // unsigned int blockDimY, // unsigned int blockDimZ, // unsigned int sharedMemBytes, // MUstream hStream, // void **kernelParams);

Function muLaunchHostFunc​

Header: muapi_module.h

MUresult MUSAAPI muLaunchHostFunc(MUstream hStream, MUhostFn fn, void *userData);

Function muLaunchKernel​

Header: muapi_module.h

MUresult MUSAAPI muLaunchKernel(MUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, MUstream hStream, void **kernelParams, void **extra);

Function muLaunchKernelEx​

Header: muapi_module.h

MUresult MUSAAPI muLaunchKernelEx(const MUlaunchConfig *config, MUfunction f, void **kernelParams, void **extra);

Function muLaunchKernel_ptsz​

Header: muapi_module.h

MUresult MUSAAPI muLaunchKernel_ptsz(MUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, MUstream hStream, void **kernelParams, void **extra);

Function muLibraryEnumerateKernels​

Header: muapi_library.h

MUresult MUSAAPI muLibraryEnumerateKernels(MUkernel *kernels, unsigned int numKernels, MUlibrary lib);

Function muLibraryGetGlobal​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetGlobal(MUdeviceptr *dptr, size_t *bytes, MUlibrary library, const char *name);

Function muLibraryGetKernel​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetKernel(MUkernel *pKernel, MUlibrary library, const char *name);

Function muLibraryGetKernelCount​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetKernelCount(unsigned int *count, MUlibrary lib);

Function muLibraryGetManaged​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetManaged(MUdeviceptr *dptr, size_t *bytes, MUlibrary library, const char *name);

Function muLibraryGetModule​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetModule(MUmodule *pMod, MUlibrary library);

Function muLibraryGetUnifiedFunction​

Header: muapi_library.h

MUresult MUSAAPI muLibraryGetUnifiedFunction(void **fptr, MUlibrary library, const char *symbol);

Function muLibraryLoadData​

Header: muapi_library.h

MUresult MUSAAPI muLibraryLoadData(MUlibrary *library, const void *code, MUjit_option *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, MUlibraryOption *libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions);

Function muLibraryLoadFromFile​

Header: muapi_library.h

MUresult MUSAAPI muLibraryLoadFromFile(MUlibrary *library, const char *fileName, MUjit_option *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, MUlibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions);

Function muLibraryUnload​

Header: muapi_library.h

MUresult MUSAAPI muLibraryUnload(MUlibrary library);

Function muMemAddressFree​

Header: muapi_memory.h

MUresult MUSAAPI muMemAddressFree(MUdeviceptr ptr, size_t size);

Function muMemAddressReserve​

Header: muapi_memory.h

MUresult MUSAAPI muMemAddressReserve(MUdeviceptr *ptr, size_t size, size_t alignment, MUdeviceptr addr, unsigned long long flags);

Function muMemAdvise​

Header: muapi_memory.h

MUresult MUSAAPI muMemAdvise(MUdeviceptr devPtr, size_t count, MUmem_advise advice, MUdevice device);

Function muMemAdvise_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemAdvise_v2(MUdeviceptr devPtr, size_t count, MUmem_advise advice, MUmemLocation location);

Function muMemAlloc​

Header: muapi_memory.h

MUresult MUSAAPI muMemAlloc(MUdeviceptr *dptr, size_t bytesize);

Function muMemAllocAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocAsync(MUdeviceptr *dptr, size_t bytesize, MUstream hStream);

Function muMemAllocFromPoolAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocFromPoolAsync(MUdeviceptr *dptr, size_t bytesize, MUmemoryPool pool, MUstream hStream);

Function muMemAllocHost​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocHost(void **pp, size_t bytesize);

Function muMemAllocHost_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocHost_v2(void **pp, size_t bytesize);

Function muMemAllocManaged​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocManaged(MUdeviceptr *dptr, size_t bytesize, unsigned int flags);

Function muMemAllocPitch​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocPitch(MUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes);

Function muMemAllocPitch_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemAllocPitch_v2(MUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes);

Function muMemAlloc_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemAlloc_v2(MUdeviceptr *dptr, size_t bytesize);

Function muMemCreate​

Header: muapi_memory.h

MUresult MUSAAPI muMemCreate(MUmemGenericAllocationHandle *handle, size_t size, const MUmemAllocationProp *prop, unsigned long long flags);

Function muMemExportToShareableHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemExportToShareableHandle(void *shareableHandle, MUmemGenericAllocationHandle handle, MUmemAllocationHandleType handleType, unsigned long long flags);

Function muMemFree​

Header: muapi_memory.h

MUresult MUSAAPI muMemFree(MUdeviceptr dptr);

Function muMemFreeAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemFreeAsync(MUdeviceptr dptr, MUstream hStream);

Function muMemFreeHost​

Header: muapi_memory.h

MUresult MUSAAPI muMemFreeHost(void *p);

Function muMemFree_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemFree_v2(MUdeviceptr dptr);

Function muMemGetAccess​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetAccess(unsigned long long *flags, const MUmemLocation *location, MUdeviceptr ptr);

Function muMemGetAddressRange​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetAddressRange(MUdeviceptr *pbase, size_t *psize, MUdeviceptr dptr);

Function muMemGetAddressRange_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetAddressRange_v2(MUdeviceptr *pbase, size_t *psize, MUdeviceptr dptr);

Function muMemGetAllocationGranularity​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetAllocationGranularity(size_t *granularity, const MUmemAllocationProp *prop, MUmemAllocationGranularity_flags option);

Function muMemGetAllocationPropertiesFromHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetAllocationPropertiesFromHandle(MUmemAllocationProp *prop, MUmemGenericAllocationHandle handle);

Function muMemGetHandleForAddressRange​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetHandleForAddressRange(void *handle, MUdeviceptr dptr, size_t size, MUmemRangeHandleType handleType, unsigned long long flags);

Function muMemGetInfo​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetInfo(size_t *free, size_t *total);

Function muMemGetInfo_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemGetInfo_v2(size_t *free, size_t *total);

Function muMemHostAlloc​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags);

Function muMemHostGetDevicePointer​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostGetDevicePointer(MUdeviceptr *pdptr, void *p, unsigned int Flags);

Function muMemHostGetDevicePointer_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostGetDevicePointer_v2(MUdeviceptr *pdptr, void *p, unsigned int Flags);

Function muMemHostGetFlags​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostGetFlags(unsigned int *pFlags, void *p);

Function muMemHostRegister​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostRegister(void *p, size_t bytesize, unsigned int Flags);

Function muMemHostRegister_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostRegister_v2(void *p, size_t bytesize, unsigned int Flags);

Function muMemHostUnregister​

Header: muapi_memory.h

MUresult MUSAAPI muMemHostUnregister(void *p);

Function muMemImportFromShareableHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemImportFromShareableHandle(MUmemGenericAllocationHandle *handle, void *osHandle, MUmemAllocationHandleType shHandleType);

Function muMemMap​

Header: muapi_memory.h

MUresult MUSAAPI muMemMap(MUdeviceptr ptr, size_t size, size_t offset, MUmemGenericAllocationHandle handle, unsigned long long flags);

Function muMemPoolCreate​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolCreate(MUmemoryPool *pool, const MUmemPoolProps *poolProps);

Function muMemPoolDestroy​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolDestroy(MUmemoryPool pool);

Function muMemPoolExportPointer​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolExportPointer(MUmemPoolPtrExportData *shareData_out, MUdeviceptr ptr);

Function muMemPoolExportToShareableHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolExportToShareableHandle(void *handle_out, MUmemoryPool pool, MUmemAllocationHandleType handleType, unsigned long long flags);

Function muMemPoolGetAccess​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolGetAccess(MUmemAccess_flags *flags, MUmemoryPool memPool, MUmemLocation *location);

Function muMemPoolGetAttribute​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolGetAttribute(MUmemoryPool pool, MUmemPool_attribute attr, void *value);

Function muMemPoolImportFromShareableHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolImportFromShareableHandle( MUmemoryPool *pool_out, void *handle, MUmemAllocationHandleType handleType, unsigned long long flags);

Function muMemPoolImportPointer​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolImportPointer(MUdeviceptr *ptr_out, MUmemoryPool pool, MUmemPoolPtrExportData *shareData);

Function muMemPoolSetAccess​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolSetAccess(MUmemoryPool pool, const MUmemAccessDesc *map, size_t count);

Function muMemPoolSetAttribute​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolSetAttribute(MUmemoryPool pool, MUmemPool_attribute attr, void *value);

Function muMemPoolTrimTo​

Header: muapi_memory.h

MUresult MUSAAPI muMemPoolTrimTo(MUmemoryPool pool, size_t minBytesToKeep);

Function muMemPrefetchAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemPrefetchAsync(MUdeviceptr devPtr, size_t count, MUdevice dstDevice, MUstream hStream);

Function muMemPrefetchAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemPrefetchAsync_v2(MUdeviceptr devPtr, size_t count, MUmemLocation location, unsigned int flags, MUstream hStream);

Function muMemRangeGetAttribute​

Header: muapi_memory.h

MUresult MUSAAPI muMemRangeGetAttribute(void *data, size_t dataSize, MUmem_range_attribute attribute, MUdeviceptr devPtr, size_t count);

Function muMemRangeGetAttributes​

Header: muapi_memory.h

MUresult MUSAAPI muMemRangeGetAttributes(void **data, size_t *dataSizes, MUmem_range_attribute *attributes, size_t numAttributes, MUdeviceptr devPtr, size_t count);

Function muMemRelease​

Header: muapi_memory.h

MUresult MUSAAPI muMemRelease(MUmemGenericAllocationHandle handle);

Function muMemRetainAllocationHandle​

Header: muapi_memory.h

MUresult MUSAAPI muMemRetainAllocationHandle(MUmemGenericAllocationHandle *handle, void *addr);

Function muMemSetAccess​

Header: muapi_memory.h

MUresult MUSAAPI muMemSetAccess(MUdeviceptr ptr, size_t size, const MUmemAccessDesc *desc, size_t count);

Function muMemUnmap​

Header: muapi_memory.h

MUresult MUSAAPI muMemUnmap(MUdeviceptr ptr, size_t size);

Function muMemcpy​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount);

Function muMemcpy2D​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2D(const MUSA_MEMCPY2D *pCopy);

Function muMemcpy2DAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2DAsync(const MUSA_MEMCPY2D *pCopy, MUstream hStream);

Function muMemcpy2DAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2DAsync_v2(const MUSA_MEMCPY2D *pCopy, MUstream hStream);

Function muMemcpy2DAsync_v2_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2DAsync_v2_ptsz(const MUSA_MEMCPY2D *pCopy, MUstream hStream);

Function muMemcpy2DUnaligned_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2DUnaligned_v2(const MUSA_MEMCPY2D *pCopy);

Function muMemcpy2DUnaligned_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2DUnaligned_v2_ptds(const MUSA_MEMCPY2D *pCopy);

Function muMemcpy2D_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2D_v2(const MUSA_MEMCPY2D *pCopy);

Function muMemcpy2D_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy2D_v2_ptds(const MUSA_MEMCPY2D *pCopy);

Function muMemcpy3D​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3D(const MUSA_MEMCPY3D *pCopy);

Function muMemcpy3DAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DAsync(const MUSA_MEMCPY3D *pCopy, MUstream hStream);

Function muMemcpy3DAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DAsync_v2(const MUSA_MEMCPY3D *pCopy, MUstream hStream);

Function muMemcpy3DAsync_v2_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DAsync_v2_ptsz(const MUSA_MEMCPY3D *pCopy, MUstream hStream);

Function muMemcpy3DBatchAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DBatchAsync(size_t numOps, MUSA_MEMCPY3D_BATCH_OP *opList, size_t *failIdx, unsigned long long flags, MUstream hStream);

Function muMemcpy3DPeer​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DPeer(const MUSA_MEMCPY3D_PEER *pCopy);

Function muMemcpy3DPeerAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3DPeerAsync(const MUSA_MEMCPY3D_PEER *pCopy, MUstream hStream);

Function muMemcpy3D_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3D_v2(const MUSA_MEMCPY3D *pCopy);

Function muMemcpy3D_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy3D_v2_ptds(const MUSA_MEMCPY3D *pCopy);

Function muMemcpyAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAsync(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount, MUstream hStream);

Function muMemcpyAsync_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAsync_ptsz(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount, MUstream hStream);

Function muMemcpyAtoA​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoA(MUarray dstArray, size_t dstOffset, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoA_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoA_v2(MUarray dstArray, size_t dstOffset, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoA_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoA_v2_ptds(MUarray dstArray, size_t dstOffset, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoD​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoD(MUdeviceptr dstDevice, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoD_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoD_v2(MUdeviceptr dstDevice, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoD_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoD_v2_ptds(MUdeviceptr dstDevice, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoH​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoH(void *dstHost, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyAtoHAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoHAsync(void *dstHost, MUarray srcArray, size_t srcOffset, size_t ByteCount, MUstream hStream);

Function muMemcpyAtoHAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoHAsync_v2(void *dstHost, MUarray srcArray, size_t srcOffset, size_t ByteCount, MUstream hStream);

Function muMemcpyAtoH_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyAtoH_v2(void *dstHost, MUarray srcArray, size_t srcOffset, size_t ByteCount);

Function muMemcpyBatchAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyBatchAsync(MUdeviceptr *dsts, MUdeviceptr *srcs, size_t *sizes, size_t count, MUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, MUstream hStream);

Function muMemcpyDtoA​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoA(MUarray dstArray, size_t dstOffset, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoA_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoA_v2(MUarray dstArray, size_t dstOffset, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoA_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoA_v2_ptds(MUarray dstArray, size_t dstOffset, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoD​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoD(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoDAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoDAsync(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoDAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoDAsync_v2(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoDAsync_v2_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoDAsync_v2_ptsz(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoD_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoD_v2(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoD_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoD_v2_ptds(MUdeviceptr dstDevice, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoH​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoH(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoHAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoHAsync(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoHAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoHAsync_v2(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoHAsync_v2_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoHAsync_v2_ptsz(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount, MUstream hStream);

Function muMemcpyDtoH_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoH_v2(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyDtoH_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyDtoH_v2_ptds(void *dstHost, MUdeviceptr srcDevice, size_t ByteCount);

Function muMemcpyHtoA​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoA(MUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount);

Function muMemcpyHtoAAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoAAsync(MUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, MUstream hStream);

Function muMemcpyHtoAAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoAAsync_v2(MUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, MUstream hStream);

Function muMemcpyHtoA_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoA_v2(MUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount);

Function muMemcpyHtoD​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoD(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);

Function muMemcpyHtoDAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoDAsync(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, MUstream hStream);

Function muMemcpyHtoDAsync_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoDAsync_v2(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, MUstream hStream);

Function muMemcpyHtoDAsync_v2_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoDAsync_v2_ptsz(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, MUstream hStream);

Function muMemcpyHtoD_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoD_v2(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);

Function muMemcpyHtoD_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyHtoD_v2_ptds(MUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);

Function muMemcpyPeer​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyPeer(MUdeviceptr dstDevice, MUcontext dstContext, MUdeviceptr srcDevice, MUcontext srcContext, size_t ByteCount);

Function muMemcpyPeerAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpyPeerAsync(MUdeviceptr dstDevice, MUcontext dstContext, MUdeviceptr srcDevice, MUcontext srcContext, size_t ByteCount, MUstream hStream);

Function muMemcpy_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemcpy_ptds(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount);

Function muMemoryAtomicAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryAtomicAsync(MUdeviceptr dst, MUdeviceptr src, size_t elementCount, MUatomicType operation, MUstream hStream);

Function muMemoryAtomicBatchAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryAtomicBatchAsync(MUdeviceptr *dsts, MUdeviceptr *srcs, size_t *elements, MUatomicType *operation, size_t count, MUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, MUstream hStream);

Function muMemoryAtomicValueAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryAtomicValueAsync(MUdeviceptr dst, muuint64_t value, MUatomicValueType operation, MUstream hStream);

Function muMemoryTransfer​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryTransfer(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount);

Function muMemoryTransferAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryTransferAsync(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount, MUstream hStream);

Function muMemoryTransferAsync_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryTransferAsync_ptsz(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount, MUstream hStream);

Function muMemoryTransferBatchAsync​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryTransferBatchAsync(MUdeviceptr *dsts, MUdeviceptr *srcs, size_t *sizes, size_t count, MUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, MUstream hStream);

Function muMemoryTransfer_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemoryTransfer_ptds(MUdeviceptr dst, MUdeviceptr src, size_t ByteCount);

Function muMemsetD16​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD16(MUdeviceptr dstDevice, unsigned short us, size_t N);

Function muMemsetD16Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD16Async(MUdeviceptr dstDevice, unsigned short us, size_t N, MUstream hStream);

Function muMemsetD16Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD16Async_ptsz(MUdeviceptr dstDevice, unsigned short us, size_t N, MUstream hStream);

Function muMemsetD16_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD16_v2(MUdeviceptr dstDevice, unsigned short us, size_t N);

Function muMemsetD16_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD16_v2_ptds(MUdeviceptr dstDevice, unsigned short us, size_t N);

Function muMemsetD2D16​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D16(MUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height);

Function muMemsetD2D16Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D16Async(MUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D16Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D16Async_ptsz(MUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D16_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D16_v2(MUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height);

Function muMemsetD2D16_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D16_v2_ptds(MUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height);

Function muMemsetD2D32​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D32(MUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height);

Function muMemsetD2D32Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D32Async(MUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D32Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D32Async_ptsz(MUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D32_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D32_v2(MUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height);

Function muMemsetD2D32_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D32_v2_ptds(MUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height);

Function muMemsetD2D8​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D8(MUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height);

Function muMemsetD2D8Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D8Async(MUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D8Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D8Async_ptsz(MUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, MUstream hStream);

Function muMemsetD2D8_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D8_v2(MUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height);

Function muMemsetD2D8_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD2D8_v2_ptds(MUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height);

Function muMemsetD32​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD32(MUdeviceptr dstDevice, unsigned int ui, size_t N);

Function muMemsetD32Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD32Async(MUdeviceptr dstDevice, unsigned int ui, size_t N, MUstream hStream);

Function muMemsetD32Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD32Async_ptsz(MUdeviceptr dstDevice, unsigned int ui, size_t N, MUstream hStream);

Function muMemsetD32_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD32_v2(MUdeviceptr dstDevice, unsigned int ui, size_t N);

Function muMemsetD32_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD32_v2_ptds(MUdeviceptr dstDevice, unsigned int ui, size_t N);

Function muMemsetD8​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD8(MUdeviceptr dstDevice, unsigned char uc, size_t N);

Function muMemsetD8Async​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD8Async(MUdeviceptr dstDevice, unsigned char uc, size_t N, MUstream hStream);

Function muMemsetD8Async_ptsz​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD8Async_ptsz(MUdeviceptr dstDevice, unsigned char uc, size_t N, MUstream hStream);

Function muMemsetD8_v2​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD8_v2(MUdeviceptr dstDevice, unsigned char uc, size_t N);

Function muMemsetD8_v2_ptds​

Header: muapi_memory.h

MUresult MUSAAPI muMemsetD8_v2_ptds(MUdeviceptr dstDevice, unsigned char uc, size_t N);

Function muMipmappedArrayCreate​

Header: muapi.h

MUresult MUSAAPI muMipmappedArrayCreate(MUmipmappedArray *pHandle, const MUSA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels);

Function muMipmappedArrayDestroy​

Header: muapi.h

MUresult MUSAAPI muMipmappedArrayDestroy(MUmipmappedArray hMipmappedArray);

Function muMipmappedArrayGetLevel​

Header: muapi.h

MUresult MUSAAPI muMipmappedArrayGetLevel(MUarray *pLevelArray, MUmipmappedArray hMipmappedArray, unsigned int level);

Function muMipmappedArrayGetMemoryRequirements​

Header: muapi.h

MUresult MUSAAPI muMipmappedArrayGetMemoryRequirements(MUSA_ARRAY_MEMORY_REQUIREMENTS *memoryRequirements, MUmipmappedArray mipmap, MUdevice device);

Function muModuleEnumerateFunctions​

Header: muapi_module.h

MUresult MUSAAPI muModuleEnumerateFunctions(MUfunction *functions, unsigned int numFunctions, MUmodule mod);

Function muModuleGetFunction​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetFunction(MUfunction *hfunc, MUmodule hmod, const char *name);

Function muModuleGetFunctionCount​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetFunctionCount(unsigned int *count, MUmodule mod);

Function muModuleGetGlobal​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetGlobal(MUdeviceptr *dptr, size_t *bytes, MUmodule hmod, const char *name);

Function muModuleGetGlobal_v2​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetGlobal_v2(MUdeviceptr *dptr, size_t *bytes, MUmodule hmod, const char *name);

Function muModuleGetLoadingMode​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetLoadingMode(MUmoduleLoadingMode *mode);

Function muModuleGetSurfRef​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetSurfRef(MUsurfref *pSurfRef, MUmodule hmod, const char *name);

Function muModuleGetTexRef​

Header: muapi_module.h

MUresult MUSAAPI muModuleGetTexRef(MUtexref *pTexRef, MUmodule hmod, const char *name);

Function muModuleLoad​

Header: muapi_module.h

MUresult MUSAAPI muModuleLoad(MUmodule *module, const char *fname);

Function muModuleLoadData​

Header: muapi_module.h

MUresult MUSAAPI muModuleLoadData(MUmodule *module, const void *image);

Function muModuleLoadDataEx​

Header: muapi_module.h

MUresult MUSAAPI muModuleLoadDataEx(MUmodule *module, const void *image, unsigned int numOptions, MUjit_option *options, void **optionValues);

Function muModuleLoadFatBinary​

Header: muapi_module.h

MUresult MUSAAPI muModuleLoadFatBinary(MUmodule *module, const void *fatMubin);

Function muModuleUnload​

Header: muapi_module.h

MUresult MUSAAPI muModuleUnload(MUmodule hmod);

Function muOccupancyAvailableDynamicSMemPerBlock​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, MUfunction func, int numBlocks, int blockSize);

Function muOccupancyMaxActiveBlocksPerMultiprocessor​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, MUfunction func, int blockSize, size_t dynamicSMemSize);

Function muOccupancyMaxActiveBlocksPerMultiprocessorWithFlags​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, MUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags);

Function muOccupancyMaxActiveClusters​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxActiveClusters(int *numClusters, MUfunction func, const MUlaunchConfig *config);

Function muOccupancyMaxPotentialBlockSize​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSize, MUfunction func, MUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit);

Function muOccupancyMaxPotentialBlockSizeWithFlags​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int *blockSize, MUfunction func, MUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags);

Function muOccupancyMaxPotentialClusterSize​

Header: muapi_occupancy.h

MUresult MUSAAPI muOccupancyMaxPotentialClusterSize(int *clusterSize, MUfunction func, const MUlaunchConfig *config);

Function muPointerGetAttribute​

Header: muapi.h

MUresult MUSAAPI muPointerGetAttribute(void *data, MUpointer_attribute attribute, MUdeviceptr ptr);

Function muPointerGetAttributes​

Header: muapi.h

MUresult MUSAAPI muPointerGetAttributes(unsigned int numAttributes, MUpointer_attribute *attributes, void **data, MUdeviceptr ptr);

Function muPointerSetAttribute​

Header: muapi.h

MUresult MUSAAPI muPointerSetAttribute(const void *value, MUpointer_attribute attribute, MUdeviceptr ptr);

Function muProfilerStart​

Header: musa_profiler_api.h (Runtime)

MUresult musaProfilerStart(void); // Runtime API

Function muProfilerStop​

Header: musa_profiler_api.h (Runtime)

MUresult musaProfilerStop(void); // Runtime API

Function muSignalExternalSemaphoresAsync​

Header: muapi.h

MUresult MUSAAPI muSignalExternalSemaphoresAsync(const MUexternalSemaphore *extSemArray, const MUSA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *paramsArray, unsigned int numExtSems, MUstream stream);

Function muStreamAddCallback​

Header: muapi_stream.h

MUresult MUSAAPI muStreamAddCallback(MUstream hStream, MUstreamCallback callback, void *userData, unsigned int flags);

Function muStreamAddCallback_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamAddCallback_ptsz(MUstream hStream, MUstreamCallback callback, void *userData, unsigned int flags);

Function muStreamAttachMemAsync​

Header: muapi_stream.h

MUresult MUSAAPI muStreamAttachMemAsync(MUstream hStream, MUdeviceptr dptr, size_t length, unsigned int flags);

Function muStreamAttachMemAsync_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamAttachMemAsync_ptsz(MUstream hStream, MUdeviceptr dptr, size_t length, unsigned int flags);

Function muStreamBatchMemOp_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamBatchMemOp_v2(MUstream stream, unsigned int count, MUstreamBatchMemOpParams *paramArray, unsigned int flags);

Function muStreamBeginCapture​

Header: muapi_stream.h

MUresult MUSAAPI muStreamBeginCapture(MUstream hStream, MUstreamCaptureMode mode);

Function muStreamBeginCaptureToGraph​

Header: muapi_stream.h

MUresult MUSAAPI muStreamBeginCaptureToGraph(MUstream hStream, MUgraph hGraph, const MUgraphNode *dependencies, const MUgraphEdgeData *dependencyData, size_t numDependencies, MUstreamCaptureMode mode);

Function muStreamBeginCapture_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamBeginCapture_v2(MUstream hStream, MUstreamCaptureMode mode);

Function muStreamCopyAttributes​

Header: muapi_stream.h

MUresult MUSAAPI muStreamCopyAttributes(MUstream dst, MUstream src);

Function muStreamCreate​

Header: muapi_stream.h

MUresult MUSAAPI muStreamCreate(MUstream *phStream, unsigned int Flags);

Function muStreamCreateWithPriority​

Header: muapi_stream.h

MUresult MUSAAPI muStreamCreateWithPriority(MUstream *phStream, unsigned int flags, int priority);

Function muStreamDestroy​

Header: muapi_stream.h

MUresult MUSAAPI muStreamDestroy(MUstream hStream);

Function muStreamDestroy_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamDestroy_v2(MUstream hStream);

Function muStreamEndCapture​

Header: muapi_stream.h

MUresult MUSAAPI muStreamEndCapture(MUstream hStream, MUgraph *phGraph);

Function muStreamGetAttribute​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetAttribute(MUstream hStream, MUstreamAttrID attr, MUstreamAttrValue *value_out);

Function muStreamGetCaptureInfo​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCaptureInfo(MUstream hStream, MUstreamCaptureStatus *captureStatus_out, muuint64_t *id_out, MUgraph *graph_out, const MUgraphNode **dependencies_out, size_t *numDependencies_out);

Function muStreamGetCaptureInfo_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCaptureInfo_v2(MUstream hStream, MUstreamCaptureStatus *captureStatus_out, muuint64_t *id_out, MUgraph *graph_out, const MUgraphNode **dependencies_out, size_t *numDependencies_out);

Function muStreamGetCaptureInfo_v3​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCaptureInfo_v3(MUstream hStream, MUstreamCaptureStatus *captureStatus_out, muuint64_t *id_out, MUgraph *graph_out, const MUgraphNode **dependencies_out, const MUgraphEdgeData **edgeData_out, size_t *numDependencies_out);

Function muStreamGetCtx​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCtx(MUstream hStream, MUcontext *pctx);

Function muStreamGetCtx_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCtx_ptsz(MUstream hStream, MUcontext *pctx);

Function muStreamGetCtx_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetCtx_v2(MUstream hStream, MUcontext *pCtx, MUgreenCtx *pGreenCtx);

Function muStreamGetDevice​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetDevice(MUstream hStream, MUdevice *device);

Function muStreamGetDevice_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetDevice_ptsz(MUstream hStream, MUdevice *device);

Function muStreamGetFlags​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetFlags(MUstream hStream, unsigned int *flags);

Function muStreamGetFlags_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetFlags_ptsz(MUstream hStream, unsigned int *flags);

Function muStreamGetGreenCtx​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetGreenCtx(MUstream hStream, MUgreenCtx *phCtx);

Function muStreamGetId​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetId(MUstream hStream, unsigned long long *streamId);

Function muStreamGetId_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetId_ptsz(MUstream hStream, unsigned long long *streamId);

Function muStreamGetPriority​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetPriority(MUstream hStream, int *priority);

Function muStreamGetPriority_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamGetPriority_ptsz(MUstream hStream, int *priority);

Function muStreamIsCapturing​

Header: muapi_stream.h

MUresult MUSAAPI muStreamIsCapturing(MUstream hStream, MUstreamCaptureStatus *captureStatus);

Function muStreamQuery​

Header: muapi_stream.h

MUresult MUSAAPI muStreamQuery(MUstream hStream);

Function muStreamQuery_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamQuery_ptsz(MUstream hStream);

Function muStreamSetAttribute​

Header: muapi_stream.h

MUresult MUSAAPI muStreamSetAttribute(MUstream hStream, MUstreamAttrID attr, const MUstreamAttrValue *value);

Function muStreamSynchronize​

Header: muapi_stream.h

MUresult MUSAAPI muStreamSynchronize(MUstream hStream);

Function muStreamSynchronize_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamSynchronize_ptsz(MUstream hStream);

Function muStreamUpdateCaptureDependencies​

Header: muapi_stream.h

MUresult MUSAAPI muStreamUpdateCaptureDependencies(MUstream hStream, MUgraphNode *dependencies, size_t numDependencies, unsigned int flags);

Function muStreamUpdateCaptureDependencies_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamUpdateCaptureDependencies_v2(MUstream hStream, MUgraphNode *dependencies, const MUgraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags);

Function muStreamWaitEvent​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitEvent(MUstream hStream, MUevent hEvent, unsigned int Flags);

Function muStreamWaitEvent_ptsz​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitEvent_ptsz(MUstream hStream, MUevent hEvent, unsigned int Flags);

Function muStreamWaitValue32​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitValue32(MUstream stream, MUdeviceptr addr, muuint32_t value, unsigned int flags);

Function muStreamWaitValue32_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitValue32_v2(MUstream stream, MUdeviceptr addr, muuint32_t value, unsigned int flags);

Function muStreamWaitValue64​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitValue64(MUstream stream, MUdeviceptr addr, muuint64_t value, unsigned int flags);

Function muStreamWaitValue64_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWaitValue64_v2(MUstream stream, MUdeviceptr addr, muuint64_t value, unsigned int flags);

Function muStreamWriteValue32​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWriteValue32(MUstream stream, MUdeviceptr addr, muuint32_t value, unsigned int flags);

Function muStreamWriteValue32_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWriteValue32_v2(MUstream stream, MUdeviceptr addr, muuint32_t value, unsigned int flags);

Function muStreamWriteValue64​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWriteValue64(MUstream stream, MUdeviceptr addr, muuint64_t value, unsigned int flags);

Function muStreamWriteValue64_v2​

Header: muapi_stream.h

MUresult MUSAAPI muStreamWriteValue64_v2(MUstream stream, MUdeviceptr addr, muuint64_t value, unsigned int flags);

Function muSurfObjectCreate​

Header: muapi_object.h

MUresult MUSAAPI muSurfObjectCreate(MUsurfObject *pSurfObject, const MUSA_RESOURCE_DESC *pResDesc);

Function muSurfObjectDestroy​

Header: muapi_object.h

MUresult MUSAAPI muSurfObjectDestroy(MUsurfObject surfObject);

Function muSurfObjectGetResourceDesc​

Header: muapi_object.h

MUresult MUSAAPI muSurfObjectGetResourceDesc(MUSA_RESOURCE_DESC *pResDesc, MUsurfObject surfObject);

Function muSurfRefGetArray​

Header: muapi_object.h

MUresult MUSAAPI muSurfRefGetArray(MUarray *phArray, MUsurfref hSurfRef);

Function muSurfRefSetArray​

Header: muapi_object.h

MUresult MUSAAPI muSurfRefSetArray(MUsurfref hSurfRef, MUarray hArray, unsigned int Flags);

Function muTensorDescriptorEncode​

Header: muapi.h

MUresult MUSAAPI muTensorDescriptorEncode(MUtensorDescriptor* tensorDesc, MUtensorDescriptorDataType tensorDataType, muuint32_t tensorRank, void* globalAddress, const muuint64_t* globalDim, const muuint64_t* globalStrides, MUtensorDescriptorInterleave interleave, muuint64_t oobConstantFill);

Function muTensorDescriptorReplaceAddress​

Header: muapi.h

MUresult MUSAAPI muTensorDescriptorReplaceAddress(MUtensorDescriptor* tensorDesc, void* globalAddress);

Function muTensorDirectConvEncode​

Header: muapi.h

MUresult MUSAAPI muTensorDirectConvEncode(MUdirectConvParamer *param, muuint32_t convRank, const muuint32_t* inputImageDim, const muuint32_t* inputImageStrides, const muuint32_t* weightDim, const muuint32_t* weightStrides, const muuint32_t* paddings, const muuint32_t* strides, MUdirectConvInterleave inputImageInterelave, MUdirectConvInterleave weightInterelave, muuint32_t imageSwizzle, muuint32_t weightSwizzle, muuint32_t constantFillValue, MUdirectConvBasicShape shape);

Function muTensorIm2colConvParamEncode​

Header: muapi.h

MUresult MUSAAPI muTensorIm2colConvParamEncode(MUconvParamer* convParam, muuint32_t convRank, const muuint32_t* padding, const muuint32_t* stride, const muuint32_t* dilation);

Function muTexObjectCreate​

Header: muapi_object.h

MUresult MUSAAPI muTexObjectCreate(MUtexObject *pTexObject, const MUSA_RESOURCE_DESC *pResDesc, const MUSA_TEXTURE_DESC *pTexDesc, const MUSA_RESOURCE_VIEW_DESC *pResViewDesc);

Function muTexObjectDestroy​

Header: muapi_object.h

MUresult MUSAAPI muTexObjectDestroy(MUtexObject texObject);

Function muTexObjectGetResourceDesc​

Header: muapi_object.h

MUresult MUSAAPI muTexObjectGetResourceDesc(MUSA_RESOURCE_DESC *pResDesc, MUtexObject texObject);

Function muTexObjectGetResourceViewDesc​

Header: muapi_object.h

MUresult MUSAAPI muTexObjectGetResourceViewDesc(MUSA_RESOURCE_VIEW_DESC *pResViewDesc, MUtexObject texObject);

Function muTexObjectGetTextureDesc​

Header: muapi_object.h

MUresult MUSAAPI muTexObjectGetTextureDesc(MUSA_TEXTURE_DESC *pTexDesc, MUtexObject texObject);

Function muTexRefCreate​

Header: muapi_object.h

MUresult MUSAAPI muTexRefCreate(MUtexref *pTexRef);

Function muTexRefDestroy​

Header: muapi_object.h

MUresult MUSAAPI muTexRefDestroy(MUtexref hTexRef);

Function muTexRefGetAddress​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetAddress(MUdeviceptr *pdptr, MUtexref hTexRef);

Function muTexRefGetAddressMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetAddressMode(MUaddress_mode *pam, MUtexref hTexRef, int dim);

Function muTexRefGetAddress_v2​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetAddress_v2(MUdeviceptr *pdptr, MUtexref hTexRef);

Function muTexRefGetArray​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetArray(MUarray *phArray, MUtexref hTexRef);

Function muTexRefGetBorderColor​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetBorderColor(float *pBorderColor, MUtexref hTexRef);

Function muTexRefGetFilterMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetFilterMode(MUfilter_mode *pfm, MUtexref hTexRef);

Function muTexRefGetFlags​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetFlags(unsigned int *pFlags, MUtexref hTexRef);

Function muTexRefGetFormat​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetFormat(MUarray_format *pFormat, int *pNumChannels, MUtexref hTexRef);

Function muTexRefGetMaxAnisotropy​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetMaxAnisotropy(int *pmaxAniso, MUtexref hTexRef);

Function muTexRefGetMipmapFilterMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetMipmapFilterMode(MUfilter_mode *pfm, MUtexref hTexRef);

Function muTexRefGetMipmapLevelBias​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetMipmapLevelBias(float *pbias, MUtexref hTexRef);

Function muTexRefGetMipmapLevelClamp​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, MUtexref hTexRef);

Function muTexRefGetMipmappedArray​

Header: muapi_object.h

MUresult MUSAAPI muTexRefGetMipmappedArray(MUmipmappedArray *phMipmappedArray, MUtexref hTexRef);

Function muTexRefSetAddress​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetAddress(size_t *ByteOffset, MUtexref hTexRef, MUdeviceptr dptr, size_t bytes);

Function muTexRefSetAddress2D​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetAddress2D(MUtexref hTexRef, const MUSA_ARRAY_DESCRIPTOR *desc, MUdeviceptr dptr, size_t Pitch);

Function muTexRefSetAddress2D_v3​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetAddress2D_v3(MUtexref hTexRef, const MUSA_ARRAY_DESCRIPTOR *desc, MUdeviceptr dptr, size_t Pitch);

Function muTexRefSetAddressMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetAddressMode(MUtexref hTexRef, int dim, MUaddress_mode am);

Function muTexRefSetAddress_v2​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetAddress_v2(size_t *ByteOffset, MUtexref hTexRef, MUdeviceptr dptr, size_t bytes);

Function muTexRefSetArray​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetArray(MUtexref hTexRef, MUarray hArray, unsigned int Flags);

Function muTexRefSetBorderColor​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetBorderColor(MUtexref hTexRef, float *pBorderColor);

Function muTexRefSetFilterMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetFilterMode(MUtexref hTexRef, MUfilter_mode fm);

Function muTexRefSetFlags​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetFlags(MUtexref hTexRef, unsigned int Flags);

Function muTexRefSetFormat​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetFormat(MUtexref hTexRef, MUarray_format fmt, int NumPackedComponents);

Function muTexRefSetMaxAnisotropy​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetMaxAnisotropy(MUtexref hTexRef, unsigned int maxAniso);

Function muTexRefSetMipmapFilterMode​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetMipmapFilterMode(MUtexref hTexRef, MUfilter_mode fm);

Function muTexRefSetMipmapLevelBias​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetMipmapLevelBias(MUtexref hTexRef, float bias);

Function muTexRefSetMipmapLevelClamp​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetMipmapLevelClamp(MUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp);

Function muTexRefSetMipmappedArray​

Header: muapi_object.h

MUresult MUSAAPI muTexRefSetMipmappedArray(MUtexref hTexRef, MUmipmappedArray hMipmappedArray, unsigned int Flags);

Function muThreadExchangeStreamCaptureMode​

Header: muapi.h

MUresult MUSAAPI muThreadExchangeStreamCaptureMode(MUstreamCaptureMode *mode);

Function muUserObjectCreate​

Header: muapi_graph.h

MUresult MUSAAPI muUserObjectCreate(MUuserObject *object_out, void *ptr, MUhostFn destroy, unsigned int initialRefcount, unsigned int flags);

Function muUserObjectRelease​

Header: muapi_graph.h

MUresult MUSAAPI muUserObjectRelease(MUuserObject object, unsigned int count);

Function muUserObjectRetain​

Header: muapi_graph.h

MUresult MUSAAPI muUserObjectRetain(MUuserObject object, unsigned int count);

Function muWaitExternalSemaphoresAsync​

Header: muapi.h

MUresult MUSAAPI muWaitExternalSemaphoresAsync(const MUexternalSemaphore *extSemArray, const MUSA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *paramsArray, unsigned int numExtSems, MUstream stream);