跳到主要内容

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