German Andryeyev
eef47ca24a
Add memory allocation support in graph. Current implementation uses cache from mempool to hold the allocations which belong to the graph. Also the resource tracking is disabled at this moment because mempool operates with hip::Stream objects, but graph has execution with amd::HostQueue objects. Change-Id: I54fe3250126d24f5a26ada975f37d429bb4ef17b
9674 satır
571 KiB
C++
9674 satır
571 KiB
C++
// Generated file. DO NOT EDIT.
|
|
//
|
|
// This file is automatically generated by the hip_prof_gen.py script.
|
|
// If changes are required, run the script and commit the updated file.
|
|
|
|
#ifndef _HIP_PROF_STR_H
|
|
#define _HIP_PROF_STR_H
|
|
#define HIP_PROF_VER 1
|
|
|
|
// HIP API callbacks ID enumeration
|
|
enum hip_api_id_t {
|
|
HIP_API_ID_NONE = 0,
|
|
HIP_API_ID_FIRST = 1,
|
|
HIP_API_ID___hipPopCallConfiguration = 1,
|
|
HIP_API_ID___hipPushCallConfiguration = 2,
|
|
HIP_API_ID_hipArray3DCreate = 3,
|
|
HIP_API_ID_hipArrayCreate = 4,
|
|
HIP_API_ID_hipArrayDestroy = 5,
|
|
HIP_API_ID_hipChooseDevice = 6,
|
|
HIP_API_ID_hipConfigureCall = 7,
|
|
HIP_API_ID_hipCtxCreate = 8,
|
|
HIP_API_ID_hipCtxDestroy = 9,
|
|
HIP_API_ID_hipCtxDisablePeerAccess = 10,
|
|
HIP_API_ID_hipCtxEnablePeerAccess = 11,
|
|
HIP_API_ID_hipCtxGetApiVersion = 12,
|
|
HIP_API_ID_hipCtxGetCacheConfig = 13,
|
|
HIP_API_ID_hipCtxGetCurrent = 14,
|
|
HIP_API_ID_hipCtxGetDevice = 15,
|
|
HIP_API_ID_hipCtxGetFlags = 16,
|
|
HIP_API_ID_hipCtxGetSharedMemConfig = 17,
|
|
HIP_API_ID_hipCtxPopCurrent = 18,
|
|
HIP_API_ID_hipCtxPushCurrent = 19,
|
|
HIP_API_ID_hipCtxSetCacheConfig = 20,
|
|
HIP_API_ID_hipCtxSetCurrent = 21,
|
|
HIP_API_ID_hipCtxSetSharedMemConfig = 22,
|
|
HIP_API_ID_hipCtxSynchronize = 23,
|
|
HIP_API_ID_hipDestroyExternalMemory = 24,
|
|
HIP_API_ID_hipDestroyExternalSemaphore = 25,
|
|
HIP_API_ID_hipDeviceCanAccessPeer = 26,
|
|
HIP_API_ID_hipDeviceComputeCapability = 27,
|
|
HIP_API_ID_hipDeviceDisablePeerAccess = 28,
|
|
HIP_API_ID_hipDeviceEnablePeerAccess = 29,
|
|
HIP_API_ID_hipDeviceGet = 30,
|
|
HIP_API_ID_hipDeviceGetAttribute = 31,
|
|
HIP_API_ID_hipDeviceGetByPCIBusId = 32,
|
|
HIP_API_ID_hipDeviceGetCacheConfig = 33,
|
|
HIP_API_ID_hipDeviceGetLimit = 34,
|
|
HIP_API_ID_hipDeviceGetName = 35,
|
|
HIP_API_ID_hipDeviceGetP2PAttribute = 36,
|
|
HIP_API_ID_hipDeviceGetPCIBusId = 37,
|
|
HIP_API_ID_hipDeviceGetSharedMemConfig = 38,
|
|
HIP_API_ID_hipDeviceGetStreamPriorityRange = 39,
|
|
HIP_API_ID_hipDevicePrimaryCtxGetState = 40,
|
|
HIP_API_ID_hipDevicePrimaryCtxRelease = 41,
|
|
HIP_API_ID_hipDevicePrimaryCtxReset = 42,
|
|
HIP_API_ID_hipDevicePrimaryCtxRetain = 43,
|
|
HIP_API_ID_hipDevicePrimaryCtxSetFlags = 44,
|
|
HIP_API_ID_hipDeviceReset = 45,
|
|
HIP_API_ID_hipDeviceSetCacheConfig = 46,
|
|
HIP_API_ID_hipDeviceSetSharedMemConfig = 47,
|
|
HIP_API_ID_hipDeviceSynchronize = 48,
|
|
HIP_API_ID_hipDeviceTotalMem = 49,
|
|
HIP_API_ID_RESERVED_50 = 50,
|
|
HIP_API_ID_hipDrvMemcpy2DUnaligned = 51,
|
|
HIP_API_ID_hipDrvMemcpy3D = 52,
|
|
HIP_API_ID_hipDrvMemcpy3DAsync = 53,
|
|
HIP_API_ID_hipEventCreate = 54,
|
|
HIP_API_ID_hipEventCreateWithFlags = 55,
|
|
HIP_API_ID_hipEventDestroy = 56,
|
|
HIP_API_ID_hipEventElapsedTime = 57,
|
|
HIP_API_ID_hipEventQuery = 58,
|
|
HIP_API_ID_hipEventRecord = 59,
|
|
HIP_API_ID_hipEventSynchronize = 60,
|
|
HIP_API_ID_hipExtGetLinkTypeAndHopCount = 61,
|
|
HIP_API_ID_hipExtLaunchKernel = 62,
|
|
HIP_API_ID_hipExtLaunchMultiKernelMultiDevice = 63,
|
|
HIP_API_ID_hipExtMallocWithFlags = 64,
|
|
HIP_API_ID_hipExtModuleLaunchKernel = 65,
|
|
HIP_API_ID_hipExtStreamCreateWithCUMask = 66,
|
|
HIP_API_ID_hipExtStreamGetCUMask = 67,
|
|
HIP_API_ID_hipExternalMemoryGetMappedBuffer = 68,
|
|
HIP_API_ID_hipFree = 69,
|
|
HIP_API_ID_hipFreeArray = 70,
|
|
HIP_API_ID_hipFreeHost = 71,
|
|
HIP_API_ID_hipFreeMipmappedArray = 72,
|
|
HIP_API_ID_hipFuncGetAttribute = 73,
|
|
HIP_API_ID_hipFuncGetAttributes = 74,
|
|
HIP_API_ID_hipFuncSetAttribute = 75,
|
|
HIP_API_ID_hipFuncSetCacheConfig = 76,
|
|
HIP_API_ID_hipFuncSetSharedMemConfig = 77,
|
|
HIP_API_ID_hipGetDevice = 78,
|
|
HIP_API_ID_hipGetDeviceCount = 79,
|
|
HIP_API_ID_hipGetDeviceFlags = 80,
|
|
HIP_API_ID_hipGetDeviceProperties = 81,
|
|
HIP_API_ID_RESERVED_82 = 82,
|
|
HIP_API_ID_hipGetErrorString = 83,
|
|
HIP_API_ID_hipGetLastError = 84,
|
|
HIP_API_ID_hipGetMipmappedArrayLevel = 85,
|
|
HIP_API_ID_hipGetSymbolAddress = 86,
|
|
HIP_API_ID_hipGetSymbolSize = 87,
|
|
HIP_API_ID_hipHccModuleLaunchKernel = 88,
|
|
HIP_API_ID_hipHostAlloc = 89,
|
|
HIP_API_ID_hipHostFree = 90,
|
|
HIP_API_ID_hipHostGetDevicePointer = 91,
|
|
HIP_API_ID_hipHostGetFlags = 92,
|
|
HIP_API_ID_hipHostMalloc = 93,
|
|
HIP_API_ID_hipHostRegister = 94,
|
|
HIP_API_ID_hipHostUnregister = 95,
|
|
HIP_API_ID_hipImportExternalMemory = 96,
|
|
HIP_API_ID_hipImportExternalSemaphore = 97,
|
|
HIP_API_ID_hipInit = 98,
|
|
HIP_API_ID_hipIpcCloseMemHandle = 99,
|
|
HIP_API_ID_hipIpcGetEventHandle = 100,
|
|
HIP_API_ID_hipIpcGetMemHandle = 101,
|
|
HIP_API_ID_hipIpcOpenEventHandle = 102,
|
|
HIP_API_ID_hipIpcOpenMemHandle = 103,
|
|
HIP_API_ID_hipLaunchByPtr = 104,
|
|
HIP_API_ID_hipLaunchCooperativeKernel = 105,
|
|
HIP_API_ID_hipLaunchCooperativeKernelMultiDevice = 106,
|
|
HIP_API_ID_hipLaunchKernel = 107,
|
|
HIP_API_ID_hipMalloc = 108,
|
|
HIP_API_ID_hipMalloc3D = 109,
|
|
HIP_API_ID_hipMalloc3DArray = 110,
|
|
HIP_API_ID_hipMallocArray = 111,
|
|
HIP_API_ID_hipMallocHost = 112,
|
|
HIP_API_ID_hipMallocManaged = 113,
|
|
HIP_API_ID_hipMallocMipmappedArray = 114,
|
|
HIP_API_ID_hipMallocPitch = 115,
|
|
HIP_API_ID_hipMemAdvise = 116,
|
|
HIP_API_ID_hipMemAllocHost = 117,
|
|
HIP_API_ID_hipMemAllocPitch = 118,
|
|
HIP_API_ID_hipMemGetAddressRange = 119,
|
|
HIP_API_ID_hipMemGetInfo = 120,
|
|
HIP_API_ID_hipMemPrefetchAsync = 121,
|
|
HIP_API_ID_hipMemPtrGetInfo = 122,
|
|
HIP_API_ID_hipMemRangeGetAttribute = 123,
|
|
HIP_API_ID_hipMemRangeGetAttributes = 124,
|
|
HIP_API_ID_hipMemcpy = 125,
|
|
HIP_API_ID_hipMemcpy2D = 126,
|
|
HIP_API_ID_hipMemcpy2DAsync = 127,
|
|
HIP_API_ID_hipMemcpy2DFromArray = 128,
|
|
HIP_API_ID_hipMemcpy2DFromArrayAsync = 129,
|
|
HIP_API_ID_hipMemcpy2DToArray = 130,
|
|
HIP_API_ID_hipMemcpy2DToArrayAsync = 131,
|
|
HIP_API_ID_hipMemcpy3D = 132,
|
|
HIP_API_ID_hipMemcpy3DAsync = 133,
|
|
HIP_API_ID_hipMemcpyAsync = 134,
|
|
HIP_API_ID_hipMemcpyAtoH = 135,
|
|
HIP_API_ID_hipMemcpyDtoD = 136,
|
|
HIP_API_ID_hipMemcpyDtoDAsync = 137,
|
|
HIP_API_ID_hipMemcpyDtoH = 138,
|
|
HIP_API_ID_hipMemcpyDtoHAsync = 139,
|
|
HIP_API_ID_hipMemcpyFromArray = 140,
|
|
HIP_API_ID_hipMemcpyFromSymbol = 141,
|
|
HIP_API_ID_hipMemcpyFromSymbolAsync = 142,
|
|
HIP_API_ID_hipMemcpyHtoA = 143,
|
|
HIP_API_ID_hipMemcpyHtoD = 144,
|
|
HIP_API_ID_hipMemcpyHtoDAsync = 145,
|
|
HIP_API_ID_hipMemcpyParam2D = 146,
|
|
HIP_API_ID_hipMemcpyParam2DAsync = 147,
|
|
HIP_API_ID_hipMemcpyPeer = 148,
|
|
HIP_API_ID_hipMemcpyPeerAsync = 149,
|
|
HIP_API_ID_hipMemcpyToArray = 150,
|
|
HIP_API_ID_hipMemcpyToSymbol = 151,
|
|
HIP_API_ID_hipMemcpyToSymbolAsync = 152,
|
|
HIP_API_ID_hipMemcpyWithStream = 153,
|
|
HIP_API_ID_hipMemset = 154,
|
|
HIP_API_ID_hipMemset2D = 155,
|
|
HIP_API_ID_hipMemset2DAsync = 156,
|
|
HIP_API_ID_hipMemset3D = 157,
|
|
HIP_API_ID_hipMemset3DAsync = 158,
|
|
HIP_API_ID_hipMemsetAsync = 159,
|
|
HIP_API_ID_hipMemsetD16 = 160,
|
|
HIP_API_ID_hipMemsetD16Async = 161,
|
|
HIP_API_ID_hipMemsetD32 = 162,
|
|
HIP_API_ID_hipMemsetD32Async = 163,
|
|
HIP_API_ID_hipMemsetD8 = 164,
|
|
HIP_API_ID_hipMemsetD8Async = 165,
|
|
HIP_API_ID_hipModuleGetFunction = 166,
|
|
HIP_API_ID_hipModuleGetGlobal = 167,
|
|
HIP_API_ID_hipModuleGetTexRef = 168,
|
|
HIP_API_ID_hipModuleLaunchKernel = 169,
|
|
HIP_API_ID_hipModuleLoad = 170,
|
|
HIP_API_ID_hipModuleLoadData = 171,
|
|
HIP_API_ID_hipModuleLoadDataEx = 172,
|
|
HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor = 173,
|
|
HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = 174,
|
|
HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSize = 175,
|
|
HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSizeWithFlags = 176,
|
|
HIP_API_ID_hipModuleUnload = 177,
|
|
HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor = 178,
|
|
HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = 179,
|
|
HIP_API_ID_hipOccupancyMaxPotentialBlockSize = 180,
|
|
HIP_API_ID_hipPeekAtLastError = 181,
|
|
HIP_API_ID_hipPointerGetAttributes = 182,
|
|
HIP_API_ID_hipProfilerStart = 183,
|
|
HIP_API_ID_hipProfilerStop = 184,
|
|
HIP_API_ID_RESERVED_185 = 185,
|
|
HIP_API_ID_hipSetDevice = 186,
|
|
HIP_API_ID_hipSetDeviceFlags = 187,
|
|
HIP_API_ID_hipSetupArgument = 188,
|
|
HIP_API_ID_hipSignalExternalSemaphoresAsync = 189,
|
|
HIP_API_ID_hipStreamAddCallback = 190,
|
|
HIP_API_ID_hipStreamAttachMemAsync = 191,
|
|
HIP_API_ID_hipStreamCreate = 192,
|
|
HIP_API_ID_hipStreamCreateWithFlags = 193,
|
|
HIP_API_ID_hipStreamCreateWithPriority = 194,
|
|
HIP_API_ID_hipStreamDestroy = 195,
|
|
HIP_API_ID_hipStreamGetFlags = 196,
|
|
HIP_API_ID_hipStreamGetPriority = 197,
|
|
HIP_API_ID_hipStreamQuery = 198,
|
|
HIP_API_ID_hipStreamSynchronize = 199,
|
|
HIP_API_ID_hipStreamWaitEvent = 200,
|
|
HIP_API_ID_hipStreamWaitValue32 = 201,
|
|
HIP_API_ID_hipStreamWaitValue64 = 202,
|
|
HIP_API_ID_hipStreamWriteValue32 = 203,
|
|
HIP_API_ID_hipStreamWriteValue64 = 204,
|
|
HIP_API_ID_hipWaitExternalSemaphoresAsync = 205,
|
|
HIP_API_ID_hipCreateSurfaceObject = 206,
|
|
HIP_API_ID_hipDestroySurfaceObject = 207,
|
|
HIP_API_ID_hipGraphAddKernelNode = 208,
|
|
HIP_API_ID_hipGraphAddMemcpyNode = 209,
|
|
HIP_API_ID_hipGraphAddMemsetNode = 210,
|
|
HIP_API_ID_hipGraphCreate = 211,
|
|
HIP_API_ID_hipGraphDestroy = 212,
|
|
HIP_API_ID_hipGraphExecDestroy = 213,
|
|
HIP_API_ID_hipGraphInstantiate = 214,
|
|
HIP_API_ID_hipGraphLaunch = 215,
|
|
HIP_API_ID_hipMipmappedArrayCreate = 216,
|
|
HIP_API_ID_hipMipmappedArrayDestroy = 217,
|
|
HIP_API_ID_hipMipmappedArrayGetLevel = 218,
|
|
HIP_API_ID_hipStreamBeginCapture = 219,
|
|
HIP_API_ID_hipStreamEndCapture = 220,
|
|
HIP_API_ID_hipTexRefGetAddress = 221,
|
|
HIP_API_ID_hipTexRefGetFlags = 222,
|
|
HIP_API_ID_hipTexRefGetFormat = 223,
|
|
HIP_API_ID_hipTexRefGetMaxAnisotropy = 224,
|
|
HIP_API_ID_hipTexRefGetMipMappedArray = 225,
|
|
HIP_API_ID_hipTexRefGetMipmapLevelBias = 226,
|
|
HIP_API_ID_hipTexRefGetMipmapLevelClamp = 227,
|
|
HIP_API_ID_hipTexRefSetAddress = 228,
|
|
HIP_API_ID_hipTexRefSetAddress2D = 229,
|
|
HIP_API_ID_hipTexRefSetBorderColor = 230,
|
|
HIP_API_ID_hipTexRefSetFormat = 231,
|
|
HIP_API_ID_hipTexRefSetMaxAnisotropy = 232,
|
|
HIP_API_ID_hipTexRefSetMipmapLevelClamp = 233,
|
|
HIP_API_ID_hipTexRefSetMipmappedArray = 234,
|
|
HIP_API_ID_hipGLGetDevices = 235,
|
|
HIP_API_ID_hipGraphAddDependencies = 236,
|
|
HIP_API_ID_hipGraphAddEmptyNode = 237,
|
|
HIP_API_ID_hipGraphExecKernelNodeSetParams = 238,
|
|
HIP_API_ID_hipGraphGetNodes = 239,
|
|
HIP_API_ID_hipGraphGetRootNodes = 240,
|
|
HIP_API_ID_hipGraphKernelNodeGetParams = 241,
|
|
HIP_API_ID_hipGraphKernelNodeSetParams = 242,
|
|
HIP_API_ID_hipGraphMemcpyNodeGetParams = 243,
|
|
HIP_API_ID_hipGraphMemcpyNodeSetParams = 244,
|
|
HIP_API_ID_hipGraphMemsetNodeGetParams = 245,
|
|
HIP_API_ID_hipGraphMemsetNodeSetParams = 246,
|
|
HIP_API_ID_hipGraphicsGLRegisterBuffer = 247,
|
|
HIP_API_ID_hipGraphicsMapResources = 248,
|
|
HIP_API_ID_hipGraphicsResourceGetMappedPointer = 249,
|
|
HIP_API_ID_hipGraphicsUnmapResources = 250,
|
|
HIP_API_ID_hipGraphicsUnregisterResource = 251,
|
|
HIP_API_ID_hipGraphAddChildGraphNode = 252,
|
|
HIP_API_ID_hipGraphAddEventRecordNode = 253,
|
|
HIP_API_ID_hipGraphAddEventWaitNode = 254,
|
|
HIP_API_ID_hipGraphAddHostNode = 255,
|
|
HIP_API_ID_hipGraphAddMemcpyNode1D = 256,
|
|
HIP_API_ID_hipGraphAddMemcpyNodeFromSymbol = 257,
|
|
HIP_API_ID_hipGraphAddMemcpyNodeToSymbol = 258,
|
|
HIP_API_ID_hipGraphChildGraphNodeGetGraph = 259,
|
|
HIP_API_ID_hipGraphClone = 260,
|
|
HIP_API_ID_hipGraphDestroyNode = 261,
|
|
HIP_API_ID_hipGraphEventRecordNodeGetEvent = 262,
|
|
HIP_API_ID_hipGraphEventRecordNodeSetEvent = 263,
|
|
HIP_API_ID_hipGraphEventWaitNodeGetEvent = 264,
|
|
HIP_API_ID_hipGraphEventWaitNodeSetEvent = 265,
|
|
HIP_API_ID_hipGraphExecChildGraphNodeSetParams = 266,
|
|
HIP_API_ID_hipGraphExecEventRecordNodeSetEvent = 267,
|
|
HIP_API_ID_hipGraphExecEventWaitNodeSetEvent = 268,
|
|
HIP_API_ID_hipGraphExecHostNodeSetParams = 269,
|
|
HIP_API_ID_hipGraphExecMemcpyNodeSetParams = 270,
|
|
HIP_API_ID_hipGraphExecMemcpyNodeSetParams1D = 271,
|
|
HIP_API_ID_hipGraphExecMemcpyNodeSetParamsFromSymbol = 272,
|
|
HIP_API_ID_hipGraphExecMemcpyNodeSetParamsToSymbol = 273,
|
|
HIP_API_ID_hipGraphExecMemsetNodeSetParams = 274,
|
|
HIP_API_ID_hipGraphExecUpdate = 275,
|
|
HIP_API_ID_hipGraphGetEdges = 276,
|
|
HIP_API_ID_hipGraphHostNodeGetParams = 277,
|
|
HIP_API_ID_hipGraphHostNodeSetParams = 278,
|
|
HIP_API_ID_hipGraphInstantiateWithFlags = 279,
|
|
HIP_API_ID_hipGraphMemcpyNodeSetParams1D = 280,
|
|
HIP_API_ID_hipGraphMemcpyNodeSetParamsFromSymbol = 281,
|
|
HIP_API_ID_hipGraphMemcpyNodeSetParamsToSymbol = 282,
|
|
HIP_API_ID_hipGraphNodeFindInClone = 283,
|
|
HIP_API_ID_hipGraphNodeGetDependencies = 284,
|
|
HIP_API_ID_hipGraphNodeGetDependentNodes = 285,
|
|
HIP_API_ID_hipGraphNodeGetType = 286,
|
|
HIP_API_ID_hipGraphRemoveDependencies = 287,
|
|
HIP_API_ID_hipStreamGetCaptureInfo = 288,
|
|
HIP_API_ID_hipStreamGetCaptureInfo_v2 = 289,
|
|
HIP_API_ID_hipStreamIsCapturing = 290,
|
|
HIP_API_ID_hipStreamUpdateCaptureDependencies = 291,
|
|
HIP_API_ID_hipDrvPointerGetAttributes = 292,
|
|
HIP_API_ID_hipGraphicsGLRegisterImage = 293,
|
|
HIP_API_ID_hipGraphicsSubResourceGetMappedArray = 294,
|
|
HIP_API_ID_hipPointerGetAttribute = 295,
|
|
HIP_API_ID_RESERVED_296 = 296,
|
|
HIP_API_ID_hipThreadExchangeStreamCaptureMode = 297,
|
|
HIP_API_ID_hipDeviceGetUuid = 298,
|
|
HIP_API_ID_hipGetChannelDesc = 299,
|
|
HIP_API_ID_hipGraphKernelNodeGetAttribute = 300,
|
|
HIP_API_ID_hipGraphKernelNodeSetAttribute = 301,
|
|
HIP_API_ID_hipLaunchHostFunc = 302,
|
|
HIP_API_ID_hipDeviceGetDefaultMemPool = 303,
|
|
HIP_API_ID_hipDeviceGetMemPool = 304,
|
|
HIP_API_ID_hipDeviceSetMemPool = 305,
|
|
HIP_API_ID_hipFreeAsync = 306,
|
|
HIP_API_ID_hipMallocAsync = 307,
|
|
HIP_API_ID_hipMallocFromPoolAsync = 308,
|
|
HIP_API_ID_hipMemPoolCreate = 309,
|
|
HIP_API_ID_hipMemPoolDestroy = 310,
|
|
HIP_API_ID_hipMemPoolExportPointer = 311,
|
|
HIP_API_ID_hipMemPoolExportToShareableHandle = 312,
|
|
HIP_API_ID_hipMemPoolGetAccess = 313,
|
|
HIP_API_ID_hipMemPoolGetAttribute = 314,
|
|
HIP_API_ID_hipMemPoolImportFromShareableHandle = 315,
|
|
HIP_API_ID_hipMemPoolImportPointer = 316,
|
|
HIP_API_ID_hipMemPoolSetAccess = 317,
|
|
HIP_API_ID_hipMemPoolSetAttribute = 318,
|
|
HIP_API_ID_hipMemPoolTrimTo = 319,
|
|
HIP_API_ID_hipMemAddressFree = 320,
|
|
HIP_API_ID_hipMemAddressReserve = 321,
|
|
HIP_API_ID_hipMemCreate = 322,
|
|
HIP_API_ID_hipMemExportToShareableHandle = 323,
|
|
HIP_API_ID_hipMemGetAccess = 324,
|
|
HIP_API_ID_hipMemGetAllocationGranularity = 325,
|
|
HIP_API_ID_hipMemGetAllocationPropertiesFromHandle = 326,
|
|
HIP_API_ID_hipMemImportFromShareableHandle = 327,
|
|
HIP_API_ID_hipMemMap = 328,
|
|
HIP_API_ID_hipMemMapArrayAsync = 329,
|
|
HIP_API_ID_hipMemRelease = 330,
|
|
HIP_API_ID_hipMemRetainAllocationHandle = 331,
|
|
HIP_API_ID_hipMemSetAccess = 332,
|
|
HIP_API_ID_hipMemUnmap = 333,
|
|
HIP_API_ID_hipDeviceSetGraphMemAttribute = 334,
|
|
HIP_API_ID_hipDeviceGetGraphMemAttribute = 335,
|
|
HIP_API_ID_hipDeviceGraphMemTrim = 336,
|
|
HIP_API_ID_hipDeviceSetLimit = 337,
|
|
HIP_API_ID_hipTexRefSetArray = 338,
|
|
HIP_API_ID_hipTexRefSetFlags = 339,
|
|
HIP_API_ID_hipTexRefSetMipmapLevelBias = 340,
|
|
HIP_API_ID_hipDriverGetVersion = 341,
|
|
HIP_API_ID_hipGraphUpload = 342,
|
|
HIP_API_ID_hipRuntimeGetVersion = 343,
|
|
HIP_API_ID_hipUserObjectCreate = 344,
|
|
HIP_API_ID_hipUserObjectRelease = 345,
|
|
HIP_API_ID_hipUserObjectRetain = 346,
|
|
HIP_API_ID_hipGraphRetainUserObject = 347,
|
|
HIP_API_ID_hipGraphReleaseUserObject = 348,
|
|
HIP_API_ID_hipGraphDebugDotPrint = 349,
|
|
HIP_API_ID_hipGraphKernelNodeCopyAttributes = 350,
|
|
HIP_API_ID_hipGraphNodeGetEnabled = 351,
|
|
HIP_API_ID_hipGraphNodeSetEnabled = 352,
|
|
HIP_API_ID_hipPointerSetAttribute = 353,
|
|
HIP_API_ID_hipGraphAddMemAllocNode = 354,
|
|
HIP_API_ID_hipGraphAddMemFreeNode = 355,
|
|
HIP_API_ID_hipGraphMemAllocNodeGetParams = 356,
|
|
HIP_API_ID_hipGraphMemFreeNodeGetParams = 357,
|
|
HIP_API_ID_hipModuleLaunchCooperativeKernel = 358,
|
|
HIP_API_ID_hipModuleLaunchCooperativeKernelMultiDevice = 359,
|
|
HIP_API_ID_LAST = 359,
|
|
|
|
HIP_API_ID_hipArray3DGetDescriptor = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipArrayGetDescriptor = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipBindTexture = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipBindTexture2D = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipBindTextureToArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipBindTextureToMipmappedArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipCreateTextureObject = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipDestroyTextureObject = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipDeviceGetCount = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipGetTextureAlignmentOffset = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipGetTextureObjectResourceDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipGetTextureObjectResourceViewDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipGetTextureObjectTextureDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipGetTextureReference = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpy2DArrayToArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyArrayToArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyAtoA = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyAtoD = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyAtoHAsync = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyDtoA = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyFromArrayAsync = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyHtoAAsync = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipMemcpyToArrayAsync = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipModuleLaunchKernelExt = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipSetValidDevices = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexObjectCreate = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexObjectDestroy = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexObjectGetResourceDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexObjectGetResourceViewDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexObjectGetTextureDesc = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetAddressMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetBorderColor = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetFilterMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetMipmapFilterMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetMipmappedArray = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefSetAddressMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefSetFilterMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefSetMipmapFilterMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipUnbindTexture = HIP_API_ID_NONE,
|
|
};
|
|
|
|
// Return the HIP API string for a given callback ID
|
|
static inline const char* hip_api_name(const uint32_t id) {
|
|
switch(id) {
|
|
case HIP_API_ID___hipPopCallConfiguration: return "__hipPopCallConfiguration";
|
|
case HIP_API_ID___hipPushCallConfiguration: return "__hipPushCallConfiguration";
|
|
case HIP_API_ID_hipArray3DCreate: return "hipArray3DCreate";
|
|
case HIP_API_ID_hipArrayCreate: return "hipArrayCreate";
|
|
case HIP_API_ID_hipArrayDestroy: return "hipArrayDestroy";
|
|
case HIP_API_ID_hipChooseDevice: return "hipChooseDevice";
|
|
case HIP_API_ID_hipConfigureCall: return "hipConfigureCall";
|
|
case HIP_API_ID_hipCreateSurfaceObject: return "hipCreateSurfaceObject";
|
|
case HIP_API_ID_hipCtxCreate: return "hipCtxCreate";
|
|
case HIP_API_ID_hipCtxDestroy: return "hipCtxDestroy";
|
|
case HIP_API_ID_hipCtxDisablePeerAccess: return "hipCtxDisablePeerAccess";
|
|
case HIP_API_ID_hipCtxEnablePeerAccess: return "hipCtxEnablePeerAccess";
|
|
case HIP_API_ID_hipCtxGetApiVersion: return "hipCtxGetApiVersion";
|
|
case HIP_API_ID_hipCtxGetCacheConfig: return "hipCtxGetCacheConfig";
|
|
case HIP_API_ID_hipCtxGetCurrent: return "hipCtxGetCurrent";
|
|
case HIP_API_ID_hipCtxGetDevice: return "hipCtxGetDevice";
|
|
case HIP_API_ID_hipCtxGetFlags: return "hipCtxGetFlags";
|
|
case HIP_API_ID_hipCtxGetSharedMemConfig: return "hipCtxGetSharedMemConfig";
|
|
case HIP_API_ID_hipCtxPopCurrent: return "hipCtxPopCurrent";
|
|
case HIP_API_ID_hipCtxPushCurrent: return "hipCtxPushCurrent";
|
|
case HIP_API_ID_hipCtxSetCacheConfig: return "hipCtxSetCacheConfig";
|
|
case HIP_API_ID_hipCtxSetCurrent: return "hipCtxSetCurrent";
|
|
case HIP_API_ID_hipCtxSetSharedMemConfig: return "hipCtxSetSharedMemConfig";
|
|
case HIP_API_ID_hipCtxSynchronize: return "hipCtxSynchronize";
|
|
case HIP_API_ID_hipDestroyExternalMemory: return "hipDestroyExternalMemory";
|
|
case HIP_API_ID_hipDestroyExternalSemaphore: return "hipDestroyExternalSemaphore";
|
|
case HIP_API_ID_hipDestroySurfaceObject: return "hipDestroySurfaceObject";
|
|
case HIP_API_ID_hipDeviceCanAccessPeer: return "hipDeviceCanAccessPeer";
|
|
case HIP_API_ID_hipDeviceComputeCapability: return "hipDeviceComputeCapability";
|
|
case HIP_API_ID_hipDeviceDisablePeerAccess: return "hipDeviceDisablePeerAccess";
|
|
case HIP_API_ID_hipDeviceEnablePeerAccess: return "hipDeviceEnablePeerAccess";
|
|
case HIP_API_ID_hipDeviceGet: return "hipDeviceGet";
|
|
case HIP_API_ID_hipDeviceGetAttribute: return "hipDeviceGetAttribute";
|
|
case HIP_API_ID_hipDeviceGetByPCIBusId: return "hipDeviceGetByPCIBusId";
|
|
case HIP_API_ID_hipDeviceGetCacheConfig: return "hipDeviceGetCacheConfig";
|
|
case HIP_API_ID_hipDeviceGetDefaultMemPool: return "hipDeviceGetDefaultMemPool";
|
|
case HIP_API_ID_hipDeviceGetGraphMemAttribute: return "hipDeviceGetGraphMemAttribute";
|
|
case HIP_API_ID_hipDeviceGetLimit: return "hipDeviceGetLimit";
|
|
case HIP_API_ID_hipDeviceGetMemPool: return "hipDeviceGetMemPool";
|
|
case HIP_API_ID_hipDeviceGetName: return "hipDeviceGetName";
|
|
case HIP_API_ID_hipDeviceGetP2PAttribute: return "hipDeviceGetP2PAttribute";
|
|
case HIP_API_ID_hipDeviceGetPCIBusId: return "hipDeviceGetPCIBusId";
|
|
case HIP_API_ID_hipDeviceGetSharedMemConfig: return "hipDeviceGetSharedMemConfig";
|
|
case HIP_API_ID_hipDeviceGetStreamPriorityRange: return "hipDeviceGetStreamPriorityRange";
|
|
case HIP_API_ID_hipDeviceGetUuid: return "hipDeviceGetUuid";
|
|
case HIP_API_ID_hipDeviceGraphMemTrim: return "hipDeviceGraphMemTrim";
|
|
case HIP_API_ID_hipDevicePrimaryCtxGetState: return "hipDevicePrimaryCtxGetState";
|
|
case HIP_API_ID_hipDevicePrimaryCtxRelease: return "hipDevicePrimaryCtxRelease";
|
|
case HIP_API_ID_hipDevicePrimaryCtxReset: return "hipDevicePrimaryCtxReset";
|
|
case HIP_API_ID_hipDevicePrimaryCtxRetain: return "hipDevicePrimaryCtxRetain";
|
|
case HIP_API_ID_hipDevicePrimaryCtxSetFlags: return "hipDevicePrimaryCtxSetFlags";
|
|
case HIP_API_ID_hipDeviceReset: return "hipDeviceReset";
|
|
case HIP_API_ID_hipDeviceSetCacheConfig: return "hipDeviceSetCacheConfig";
|
|
case HIP_API_ID_hipDeviceSetGraphMemAttribute: return "hipDeviceSetGraphMemAttribute";
|
|
case HIP_API_ID_hipDeviceSetLimit: return "hipDeviceSetLimit";
|
|
case HIP_API_ID_hipDeviceSetMemPool: return "hipDeviceSetMemPool";
|
|
case HIP_API_ID_hipDeviceSetSharedMemConfig: return "hipDeviceSetSharedMemConfig";
|
|
case HIP_API_ID_hipDeviceSynchronize: return "hipDeviceSynchronize";
|
|
case HIP_API_ID_hipDeviceTotalMem: return "hipDeviceTotalMem";
|
|
case HIP_API_ID_hipDriverGetVersion: return "hipDriverGetVersion";
|
|
case HIP_API_ID_hipDrvMemcpy2DUnaligned: return "hipDrvMemcpy2DUnaligned";
|
|
case HIP_API_ID_hipDrvMemcpy3D: return "hipDrvMemcpy3D";
|
|
case HIP_API_ID_hipDrvMemcpy3DAsync: return "hipDrvMemcpy3DAsync";
|
|
case HIP_API_ID_hipDrvPointerGetAttributes: return "hipDrvPointerGetAttributes";
|
|
case HIP_API_ID_hipEventCreate: return "hipEventCreate";
|
|
case HIP_API_ID_hipEventCreateWithFlags: return "hipEventCreateWithFlags";
|
|
case HIP_API_ID_hipEventDestroy: return "hipEventDestroy";
|
|
case HIP_API_ID_hipEventElapsedTime: return "hipEventElapsedTime";
|
|
case HIP_API_ID_hipEventQuery: return "hipEventQuery";
|
|
case HIP_API_ID_hipEventRecord: return "hipEventRecord";
|
|
case HIP_API_ID_hipEventSynchronize: return "hipEventSynchronize";
|
|
case HIP_API_ID_hipExtGetLinkTypeAndHopCount: return "hipExtGetLinkTypeAndHopCount";
|
|
case HIP_API_ID_hipExtLaunchKernel: return "hipExtLaunchKernel";
|
|
case HIP_API_ID_hipExtLaunchMultiKernelMultiDevice: return "hipExtLaunchMultiKernelMultiDevice";
|
|
case HIP_API_ID_hipExtMallocWithFlags: return "hipExtMallocWithFlags";
|
|
case HIP_API_ID_hipExtModuleLaunchKernel: return "hipExtModuleLaunchKernel";
|
|
case HIP_API_ID_hipExtStreamCreateWithCUMask: return "hipExtStreamCreateWithCUMask";
|
|
case HIP_API_ID_hipExtStreamGetCUMask: return "hipExtStreamGetCUMask";
|
|
case HIP_API_ID_hipExternalMemoryGetMappedBuffer: return "hipExternalMemoryGetMappedBuffer";
|
|
case HIP_API_ID_hipFree: return "hipFree";
|
|
case HIP_API_ID_hipFreeArray: return "hipFreeArray";
|
|
case HIP_API_ID_hipFreeAsync: return "hipFreeAsync";
|
|
case HIP_API_ID_hipFreeHost: return "hipFreeHost";
|
|
case HIP_API_ID_hipFreeMipmappedArray: return "hipFreeMipmappedArray";
|
|
case HIP_API_ID_hipFuncGetAttribute: return "hipFuncGetAttribute";
|
|
case HIP_API_ID_hipFuncGetAttributes: return "hipFuncGetAttributes";
|
|
case HIP_API_ID_hipFuncSetAttribute: return "hipFuncSetAttribute";
|
|
case HIP_API_ID_hipFuncSetCacheConfig: return "hipFuncSetCacheConfig";
|
|
case HIP_API_ID_hipFuncSetSharedMemConfig: return "hipFuncSetSharedMemConfig";
|
|
case HIP_API_ID_hipGLGetDevices: return "hipGLGetDevices";
|
|
case HIP_API_ID_hipGetChannelDesc: return "hipGetChannelDesc";
|
|
case HIP_API_ID_hipGetDevice: return "hipGetDevice";
|
|
case HIP_API_ID_hipGetDeviceCount: return "hipGetDeviceCount";
|
|
case HIP_API_ID_hipGetDeviceFlags: return "hipGetDeviceFlags";
|
|
case HIP_API_ID_hipGetDeviceProperties: return "hipGetDeviceProperties";
|
|
case HIP_API_ID_hipGetErrorString: return "hipGetErrorString";
|
|
case HIP_API_ID_hipGetLastError: return "hipGetLastError";
|
|
case HIP_API_ID_hipGetMipmappedArrayLevel: return "hipGetMipmappedArrayLevel";
|
|
case HIP_API_ID_hipGetSymbolAddress: return "hipGetSymbolAddress";
|
|
case HIP_API_ID_hipGetSymbolSize: return "hipGetSymbolSize";
|
|
case HIP_API_ID_hipGraphAddChildGraphNode: return "hipGraphAddChildGraphNode";
|
|
case HIP_API_ID_hipGraphAddDependencies: return "hipGraphAddDependencies";
|
|
case HIP_API_ID_hipGraphAddEmptyNode: return "hipGraphAddEmptyNode";
|
|
case HIP_API_ID_hipGraphAddEventRecordNode: return "hipGraphAddEventRecordNode";
|
|
case HIP_API_ID_hipGraphAddEventWaitNode: return "hipGraphAddEventWaitNode";
|
|
case HIP_API_ID_hipGraphAddHostNode: return "hipGraphAddHostNode";
|
|
case HIP_API_ID_hipGraphAddKernelNode: return "hipGraphAddKernelNode";
|
|
case HIP_API_ID_hipGraphAddMemAllocNode: return "hipGraphAddMemAllocNode";
|
|
case HIP_API_ID_hipGraphAddMemFreeNode: return "hipGraphAddMemFreeNode";
|
|
case HIP_API_ID_hipGraphAddMemcpyNode: return "hipGraphAddMemcpyNode";
|
|
case HIP_API_ID_hipGraphAddMemcpyNode1D: return "hipGraphAddMemcpyNode1D";
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeFromSymbol: return "hipGraphAddMemcpyNodeFromSymbol";
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeToSymbol: return "hipGraphAddMemcpyNodeToSymbol";
|
|
case HIP_API_ID_hipGraphAddMemsetNode: return "hipGraphAddMemsetNode";
|
|
case HIP_API_ID_hipGraphChildGraphNodeGetGraph: return "hipGraphChildGraphNodeGetGraph";
|
|
case HIP_API_ID_hipGraphClone: return "hipGraphClone";
|
|
case HIP_API_ID_hipGraphCreate: return "hipGraphCreate";
|
|
case HIP_API_ID_hipGraphDebugDotPrint: return "hipGraphDebugDotPrint";
|
|
case HIP_API_ID_hipGraphDestroy: return "hipGraphDestroy";
|
|
case HIP_API_ID_hipGraphDestroyNode: return "hipGraphDestroyNode";
|
|
case HIP_API_ID_hipGraphEventRecordNodeGetEvent: return "hipGraphEventRecordNodeGetEvent";
|
|
case HIP_API_ID_hipGraphEventRecordNodeSetEvent: return "hipGraphEventRecordNodeSetEvent";
|
|
case HIP_API_ID_hipGraphEventWaitNodeGetEvent: return "hipGraphEventWaitNodeGetEvent";
|
|
case HIP_API_ID_hipGraphEventWaitNodeSetEvent: return "hipGraphEventWaitNodeSetEvent";
|
|
case HIP_API_ID_hipGraphExecChildGraphNodeSetParams: return "hipGraphExecChildGraphNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecDestroy: return "hipGraphExecDestroy";
|
|
case HIP_API_ID_hipGraphExecEventRecordNodeSetEvent: return "hipGraphExecEventRecordNodeSetEvent";
|
|
case HIP_API_ID_hipGraphExecEventWaitNodeSetEvent: return "hipGraphExecEventWaitNodeSetEvent";
|
|
case HIP_API_ID_hipGraphExecHostNodeSetParams: return "hipGraphExecHostNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecKernelNodeSetParams: return "hipGraphExecKernelNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams: return "hipGraphExecMemcpyNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams1D: return "hipGraphExecMemcpyNodeSetParams1D";
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsFromSymbol: return "hipGraphExecMemcpyNodeSetParamsFromSymbol";
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsToSymbol: return "hipGraphExecMemcpyNodeSetParamsToSymbol";
|
|
case HIP_API_ID_hipGraphExecMemsetNodeSetParams: return "hipGraphExecMemsetNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecUpdate: return "hipGraphExecUpdate";
|
|
case HIP_API_ID_hipGraphGetEdges: return "hipGraphGetEdges";
|
|
case HIP_API_ID_hipGraphGetNodes: return "hipGraphGetNodes";
|
|
case HIP_API_ID_hipGraphGetRootNodes: return "hipGraphGetRootNodes";
|
|
case HIP_API_ID_hipGraphHostNodeGetParams: return "hipGraphHostNodeGetParams";
|
|
case HIP_API_ID_hipGraphHostNodeSetParams: return "hipGraphHostNodeSetParams";
|
|
case HIP_API_ID_hipGraphInstantiate: return "hipGraphInstantiate";
|
|
case HIP_API_ID_hipGraphInstantiateWithFlags: return "hipGraphInstantiateWithFlags";
|
|
case HIP_API_ID_hipGraphKernelNodeCopyAttributes: return "hipGraphKernelNodeCopyAttributes";
|
|
case HIP_API_ID_hipGraphKernelNodeGetAttribute: return "hipGraphKernelNodeGetAttribute";
|
|
case HIP_API_ID_hipGraphKernelNodeGetParams: return "hipGraphKernelNodeGetParams";
|
|
case HIP_API_ID_hipGraphKernelNodeSetAttribute: return "hipGraphKernelNodeSetAttribute";
|
|
case HIP_API_ID_hipGraphKernelNodeSetParams: return "hipGraphKernelNodeSetParams";
|
|
case HIP_API_ID_hipGraphLaunch: return "hipGraphLaunch";
|
|
case HIP_API_ID_hipGraphMemAllocNodeGetParams: return "hipGraphMemAllocNodeGetParams";
|
|
case HIP_API_ID_hipGraphMemFreeNodeGetParams: return "hipGraphMemFreeNodeGetParams";
|
|
case HIP_API_ID_hipGraphMemcpyNodeGetParams: return "hipGraphMemcpyNodeGetParams";
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams: return "hipGraphMemcpyNodeSetParams";
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams1D: return "hipGraphMemcpyNodeSetParams1D";
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsFromSymbol: return "hipGraphMemcpyNodeSetParamsFromSymbol";
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsToSymbol: return "hipGraphMemcpyNodeSetParamsToSymbol";
|
|
case HIP_API_ID_hipGraphMemsetNodeGetParams: return "hipGraphMemsetNodeGetParams";
|
|
case HIP_API_ID_hipGraphMemsetNodeSetParams: return "hipGraphMemsetNodeSetParams";
|
|
case HIP_API_ID_hipGraphNodeFindInClone: return "hipGraphNodeFindInClone";
|
|
case HIP_API_ID_hipGraphNodeGetDependencies: return "hipGraphNodeGetDependencies";
|
|
case HIP_API_ID_hipGraphNodeGetDependentNodes: return "hipGraphNodeGetDependentNodes";
|
|
case HIP_API_ID_hipGraphNodeGetEnabled: return "hipGraphNodeGetEnabled";
|
|
case HIP_API_ID_hipGraphNodeGetType: return "hipGraphNodeGetType";
|
|
case HIP_API_ID_hipGraphNodeSetEnabled: return "hipGraphNodeSetEnabled";
|
|
case HIP_API_ID_hipGraphReleaseUserObject: return "hipGraphReleaseUserObject";
|
|
case HIP_API_ID_hipGraphRemoveDependencies: return "hipGraphRemoveDependencies";
|
|
case HIP_API_ID_hipGraphRetainUserObject: return "hipGraphRetainUserObject";
|
|
case HIP_API_ID_hipGraphUpload: return "hipGraphUpload";
|
|
case HIP_API_ID_hipGraphicsGLRegisterBuffer: return "hipGraphicsGLRegisterBuffer";
|
|
case HIP_API_ID_hipGraphicsGLRegisterImage: return "hipGraphicsGLRegisterImage";
|
|
case HIP_API_ID_hipGraphicsMapResources: return "hipGraphicsMapResources";
|
|
case HIP_API_ID_hipGraphicsResourceGetMappedPointer: return "hipGraphicsResourceGetMappedPointer";
|
|
case HIP_API_ID_hipGraphicsSubResourceGetMappedArray: return "hipGraphicsSubResourceGetMappedArray";
|
|
case HIP_API_ID_hipGraphicsUnmapResources: return "hipGraphicsUnmapResources";
|
|
case HIP_API_ID_hipGraphicsUnregisterResource: return "hipGraphicsUnregisterResource";
|
|
case HIP_API_ID_hipHccModuleLaunchKernel: return "hipHccModuleLaunchKernel";
|
|
case HIP_API_ID_hipHostAlloc: return "hipHostAlloc";
|
|
case HIP_API_ID_hipHostFree: return "hipHostFree";
|
|
case HIP_API_ID_hipHostGetDevicePointer: return "hipHostGetDevicePointer";
|
|
case HIP_API_ID_hipHostGetFlags: return "hipHostGetFlags";
|
|
case HIP_API_ID_hipHostMalloc: return "hipHostMalloc";
|
|
case HIP_API_ID_hipHostRegister: return "hipHostRegister";
|
|
case HIP_API_ID_hipHostUnregister: return "hipHostUnregister";
|
|
case HIP_API_ID_hipImportExternalMemory: return "hipImportExternalMemory";
|
|
case HIP_API_ID_hipImportExternalSemaphore: return "hipImportExternalSemaphore";
|
|
case HIP_API_ID_hipInit: return "hipInit";
|
|
case HIP_API_ID_hipIpcCloseMemHandle: return "hipIpcCloseMemHandle";
|
|
case HIP_API_ID_hipIpcGetEventHandle: return "hipIpcGetEventHandle";
|
|
case HIP_API_ID_hipIpcGetMemHandle: return "hipIpcGetMemHandle";
|
|
case HIP_API_ID_hipIpcOpenEventHandle: return "hipIpcOpenEventHandle";
|
|
case HIP_API_ID_hipIpcOpenMemHandle: return "hipIpcOpenMemHandle";
|
|
case HIP_API_ID_hipLaunchByPtr: return "hipLaunchByPtr";
|
|
case HIP_API_ID_hipLaunchCooperativeKernel: return "hipLaunchCooperativeKernel";
|
|
case HIP_API_ID_hipLaunchCooperativeKernelMultiDevice: return "hipLaunchCooperativeKernelMultiDevice";
|
|
case HIP_API_ID_hipLaunchHostFunc: return "hipLaunchHostFunc";
|
|
case HIP_API_ID_hipLaunchKernel: return "hipLaunchKernel";
|
|
case HIP_API_ID_hipMalloc: return "hipMalloc";
|
|
case HIP_API_ID_hipMalloc3D: return "hipMalloc3D";
|
|
case HIP_API_ID_hipMalloc3DArray: return "hipMalloc3DArray";
|
|
case HIP_API_ID_hipMallocArray: return "hipMallocArray";
|
|
case HIP_API_ID_hipMallocAsync: return "hipMallocAsync";
|
|
case HIP_API_ID_hipMallocFromPoolAsync: return "hipMallocFromPoolAsync";
|
|
case HIP_API_ID_hipMallocHost: return "hipMallocHost";
|
|
case HIP_API_ID_hipMallocManaged: return "hipMallocManaged";
|
|
case HIP_API_ID_hipMallocMipmappedArray: return "hipMallocMipmappedArray";
|
|
case HIP_API_ID_hipMallocPitch: return "hipMallocPitch";
|
|
case HIP_API_ID_hipMemAddressFree: return "hipMemAddressFree";
|
|
case HIP_API_ID_hipMemAddressReserve: return "hipMemAddressReserve";
|
|
case HIP_API_ID_hipMemAdvise: return "hipMemAdvise";
|
|
case HIP_API_ID_hipMemAllocHost: return "hipMemAllocHost";
|
|
case HIP_API_ID_hipMemAllocPitch: return "hipMemAllocPitch";
|
|
case HIP_API_ID_hipMemCreate: return "hipMemCreate";
|
|
case HIP_API_ID_hipMemExportToShareableHandle: return "hipMemExportToShareableHandle";
|
|
case HIP_API_ID_hipMemGetAccess: return "hipMemGetAccess";
|
|
case HIP_API_ID_hipMemGetAddressRange: return "hipMemGetAddressRange";
|
|
case HIP_API_ID_hipMemGetAllocationGranularity: return "hipMemGetAllocationGranularity";
|
|
case HIP_API_ID_hipMemGetAllocationPropertiesFromHandle: return "hipMemGetAllocationPropertiesFromHandle";
|
|
case HIP_API_ID_hipMemGetInfo: return "hipMemGetInfo";
|
|
case HIP_API_ID_hipMemImportFromShareableHandle: return "hipMemImportFromShareableHandle";
|
|
case HIP_API_ID_hipMemMap: return "hipMemMap";
|
|
case HIP_API_ID_hipMemMapArrayAsync: return "hipMemMapArrayAsync";
|
|
case HIP_API_ID_hipMemPoolCreate: return "hipMemPoolCreate";
|
|
case HIP_API_ID_hipMemPoolDestroy: return "hipMemPoolDestroy";
|
|
case HIP_API_ID_hipMemPoolExportPointer: return "hipMemPoolExportPointer";
|
|
case HIP_API_ID_hipMemPoolExportToShareableHandle: return "hipMemPoolExportToShareableHandle";
|
|
case HIP_API_ID_hipMemPoolGetAccess: return "hipMemPoolGetAccess";
|
|
case HIP_API_ID_hipMemPoolGetAttribute: return "hipMemPoolGetAttribute";
|
|
case HIP_API_ID_hipMemPoolImportFromShareableHandle: return "hipMemPoolImportFromShareableHandle";
|
|
case HIP_API_ID_hipMemPoolImportPointer: return "hipMemPoolImportPointer";
|
|
case HIP_API_ID_hipMemPoolSetAccess: return "hipMemPoolSetAccess";
|
|
case HIP_API_ID_hipMemPoolSetAttribute: return "hipMemPoolSetAttribute";
|
|
case HIP_API_ID_hipMemPoolTrimTo: return "hipMemPoolTrimTo";
|
|
case HIP_API_ID_hipMemPrefetchAsync: return "hipMemPrefetchAsync";
|
|
case HIP_API_ID_hipMemPtrGetInfo: return "hipMemPtrGetInfo";
|
|
case HIP_API_ID_hipMemRangeGetAttribute: return "hipMemRangeGetAttribute";
|
|
case HIP_API_ID_hipMemRangeGetAttributes: return "hipMemRangeGetAttributes";
|
|
case HIP_API_ID_hipMemRelease: return "hipMemRelease";
|
|
case HIP_API_ID_hipMemRetainAllocationHandle: return "hipMemRetainAllocationHandle";
|
|
case HIP_API_ID_hipMemSetAccess: return "hipMemSetAccess";
|
|
case HIP_API_ID_hipMemUnmap: return "hipMemUnmap";
|
|
case HIP_API_ID_hipMemcpy: return "hipMemcpy";
|
|
case HIP_API_ID_hipMemcpy2D: return "hipMemcpy2D";
|
|
case HIP_API_ID_hipMemcpy2DAsync: return "hipMemcpy2DAsync";
|
|
case HIP_API_ID_hipMemcpy2DFromArray: return "hipMemcpy2DFromArray";
|
|
case HIP_API_ID_hipMemcpy2DFromArrayAsync: return "hipMemcpy2DFromArrayAsync";
|
|
case HIP_API_ID_hipMemcpy2DToArray: return "hipMemcpy2DToArray";
|
|
case HIP_API_ID_hipMemcpy2DToArrayAsync: return "hipMemcpy2DToArrayAsync";
|
|
case HIP_API_ID_hipMemcpy3D: return "hipMemcpy3D";
|
|
case HIP_API_ID_hipMemcpy3DAsync: return "hipMemcpy3DAsync";
|
|
case HIP_API_ID_hipMemcpyAsync: return "hipMemcpyAsync";
|
|
case HIP_API_ID_hipMemcpyAtoH: return "hipMemcpyAtoH";
|
|
case HIP_API_ID_hipMemcpyDtoD: return "hipMemcpyDtoD";
|
|
case HIP_API_ID_hipMemcpyDtoDAsync: return "hipMemcpyDtoDAsync";
|
|
case HIP_API_ID_hipMemcpyDtoH: return "hipMemcpyDtoH";
|
|
case HIP_API_ID_hipMemcpyDtoHAsync: return "hipMemcpyDtoHAsync";
|
|
case HIP_API_ID_hipMemcpyFromArray: return "hipMemcpyFromArray";
|
|
case HIP_API_ID_hipMemcpyFromSymbol: return "hipMemcpyFromSymbol";
|
|
case HIP_API_ID_hipMemcpyFromSymbolAsync: return "hipMemcpyFromSymbolAsync";
|
|
case HIP_API_ID_hipMemcpyHtoA: return "hipMemcpyHtoA";
|
|
case HIP_API_ID_hipMemcpyHtoD: return "hipMemcpyHtoD";
|
|
case HIP_API_ID_hipMemcpyHtoDAsync: return "hipMemcpyHtoDAsync";
|
|
case HIP_API_ID_hipMemcpyParam2D: return "hipMemcpyParam2D";
|
|
case HIP_API_ID_hipMemcpyParam2DAsync: return "hipMemcpyParam2DAsync";
|
|
case HIP_API_ID_hipMemcpyPeer: return "hipMemcpyPeer";
|
|
case HIP_API_ID_hipMemcpyPeerAsync: return "hipMemcpyPeerAsync";
|
|
case HIP_API_ID_hipMemcpyToArray: return "hipMemcpyToArray";
|
|
case HIP_API_ID_hipMemcpyToSymbol: return "hipMemcpyToSymbol";
|
|
case HIP_API_ID_hipMemcpyToSymbolAsync: return "hipMemcpyToSymbolAsync";
|
|
case HIP_API_ID_hipMemcpyWithStream: return "hipMemcpyWithStream";
|
|
case HIP_API_ID_hipMemset: return "hipMemset";
|
|
case HIP_API_ID_hipMemset2D: return "hipMemset2D";
|
|
case HIP_API_ID_hipMemset2DAsync: return "hipMemset2DAsync";
|
|
case HIP_API_ID_hipMemset3D: return "hipMemset3D";
|
|
case HIP_API_ID_hipMemset3DAsync: return "hipMemset3DAsync";
|
|
case HIP_API_ID_hipMemsetAsync: return "hipMemsetAsync";
|
|
case HIP_API_ID_hipMemsetD16: return "hipMemsetD16";
|
|
case HIP_API_ID_hipMemsetD16Async: return "hipMemsetD16Async";
|
|
case HIP_API_ID_hipMemsetD32: return "hipMemsetD32";
|
|
case HIP_API_ID_hipMemsetD32Async: return "hipMemsetD32Async";
|
|
case HIP_API_ID_hipMemsetD8: return "hipMemsetD8";
|
|
case HIP_API_ID_hipMemsetD8Async: return "hipMemsetD8Async";
|
|
case HIP_API_ID_hipMipmappedArrayCreate: return "hipMipmappedArrayCreate";
|
|
case HIP_API_ID_hipMipmappedArrayDestroy: return "hipMipmappedArrayDestroy";
|
|
case HIP_API_ID_hipMipmappedArrayGetLevel: return "hipMipmappedArrayGetLevel";
|
|
case HIP_API_ID_hipModuleGetFunction: return "hipModuleGetFunction";
|
|
case HIP_API_ID_hipModuleGetGlobal: return "hipModuleGetGlobal";
|
|
case HIP_API_ID_hipModuleGetTexRef: return "hipModuleGetTexRef";
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernel: return "hipModuleLaunchCooperativeKernel";
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernelMultiDevice: return "hipModuleLaunchCooperativeKernelMultiDevice";
|
|
case HIP_API_ID_hipModuleLaunchKernel: return "hipModuleLaunchKernel";
|
|
case HIP_API_ID_hipModuleLoad: return "hipModuleLoad";
|
|
case HIP_API_ID_hipModuleLoadData: return "hipModuleLoadData";
|
|
case HIP_API_ID_hipModuleLoadDataEx: return "hipModuleLoadDataEx";
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor: return "hipModuleOccupancyMaxActiveBlocksPerMultiprocessor";
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags: return "hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags";
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSize: return "hipModuleOccupancyMaxPotentialBlockSize";
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSizeWithFlags: return "hipModuleOccupancyMaxPotentialBlockSizeWithFlags";
|
|
case HIP_API_ID_hipModuleUnload: return "hipModuleUnload";
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor: return "hipOccupancyMaxActiveBlocksPerMultiprocessor";
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags: return "hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags";
|
|
case HIP_API_ID_hipOccupancyMaxPotentialBlockSize: return "hipOccupancyMaxPotentialBlockSize";
|
|
case HIP_API_ID_hipPeekAtLastError: return "hipPeekAtLastError";
|
|
case HIP_API_ID_hipPointerGetAttribute: return "hipPointerGetAttribute";
|
|
case HIP_API_ID_hipPointerGetAttributes: return "hipPointerGetAttributes";
|
|
case HIP_API_ID_hipPointerSetAttribute: return "hipPointerSetAttribute";
|
|
case HIP_API_ID_hipProfilerStart: return "hipProfilerStart";
|
|
case HIP_API_ID_hipProfilerStop: return "hipProfilerStop";
|
|
case HIP_API_ID_hipRuntimeGetVersion: return "hipRuntimeGetVersion";
|
|
case HIP_API_ID_hipSetDevice: return "hipSetDevice";
|
|
case HIP_API_ID_hipSetDeviceFlags: return "hipSetDeviceFlags";
|
|
case HIP_API_ID_hipSetupArgument: return "hipSetupArgument";
|
|
case HIP_API_ID_hipSignalExternalSemaphoresAsync: return "hipSignalExternalSemaphoresAsync";
|
|
case HIP_API_ID_hipStreamAddCallback: return "hipStreamAddCallback";
|
|
case HIP_API_ID_hipStreamAttachMemAsync: return "hipStreamAttachMemAsync";
|
|
case HIP_API_ID_hipStreamBeginCapture: return "hipStreamBeginCapture";
|
|
case HIP_API_ID_hipStreamCreate: return "hipStreamCreate";
|
|
case HIP_API_ID_hipStreamCreateWithFlags: return "hipStreamCreateWithFlags";
|
|
case HIP_API_ID_hipStreamCreateWithPriority: return "hipStreamCreateWithPriority";
|
|
case HIP_API_ID_hipStreamDestroy: return "hipStreamDestroy";
|
|
case HIP_API_ID_hipStreamEndCapture: return "hipStreamEndCapture";
|
|
case HIP_API_ID_hipStreamGetCaptureInfo: return "hipStreamGetCaptureInfo";
|
|
case HIP_API_ID_hipStreamGetCaptureInfo_v2: return "hipStreamGetCaptureInfo_v2";
|
|
case HIP_API_ID_hipStreamGetFlags: return "hipStreamGetFlags";
|
|
case HIP_API_ID_hipStreamGetPriority: return "hipStreamGetPriority";
|
|
case HIP_API_ID_hipStreamIsCapturing: return "hipStreamIsCapturing";
|
|
case HIP_API_ID_hipStreamQuery: return "hipStreamQuery";
|
|
case HIP_API_ID_hipStreamSynchronize: return "hipStreamSynchronize";
|
|
case HIP_API_ID_hipStreamUpdateCaptureDependencies: return "hipStreamUpdateCaptureDependencies";
|
|
case HIP_API_ID_hipStreamWaitEvent: return "hipStreamWaitEvent";
|
|
case HIP_API_ID_hipStreamWaitValue32: return "hipStreamWaitValue32";
|
|
case HIP_API_ID_hipStreamWaitValue64: return "hipStreamWaitValue64";
|
|
case HIP_API_ID_hipStreamWriteValue32: return "hipStreamWriteValue32";
|
|
case HIP_API_ID_hipStreamWriteValue64: return "hipStreamWriteValue64";
|
|
case HIP_API_ID_hipTexRefGetAddress: return "hipTexRefGetAddress";
|
|
case HIP_API_ID_hipTexRefGetFlags: return "hipTexRefGetFlags";
|
|
case HIP_API_ID_hipTexRefGetFormat: return "hipTexRefGetFormat";
|
|
case HIP_API_ID_hipTexRefGetMaxAnisotropy: return "hipTexRefGetMaxAnisotropy";
|
|
case HIP_API_ID_hipTexRefGetMipMappedArray: return "hipTexRefGetMipMappedArray";
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelBias: return "hipTexRefGetMipmapLevelBias";
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelClamp: return "hipTexRefGetMipmapLevelClamp";
|
|
case HIP_API_ID_hipTexRefSetAddress: return "hipTexRefSetAddress";
|
|
case HIP_API_ID_hipTexRefSetAddress2D: return "hipTexRefSetAddress2D";
|
|
case HIP_API_ID_hipTexRefSetArray: return "hipTexRefSetArray";
|
|
case HIP_API_ID_hipTexRefSetBorderColor: return "hipTexRefSetBorderColor";
|
|
case HIP_API_ID_hipTexRefSetFlags: return "hipTexRefSetFlags";
|
|
case HIP_API_ID_hipTexRefSetFormat: return "hipTexRefSetFormat";
|
|
case HIP_API_ID_hipTexRefSetMaxAnisotropy: return "hipTexRefSetMaxAnisotropy";
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelBias: return "hipTexRefSetMipmapLevelBias";
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelClamp: return "hipTexRefSetMipmapLevelClamp";
|
|
case HIP_API_ID_hipTexRefSetMipmappedArray: return "hipTexRefSetMipmappedArray";
|
|
case HIP_API_ID_hipThreadExchangeStreamCaptureMode: return "hipThreadExchangeStreamCaptureMode";
|
|
case HIP_API_ID_hipUserObjectCreate: return "hipUserObjectCreate";
|
|
case HIP_API_ID_hipUserObjectRelease: return "hipUserObjectRelease";
|
|
case HIP_API_ID_hipUserObjectRetain: return "hipUserObjectRetain";
|
|
case HIP_API_ID_hipWaitExternalSemaphoresAsync: return "hipWaitExternalSemaphoresAsync";
|
|
};
|
|
return "unknown";
|
|
};
|
|
|
|
#include <string.h>
|
|
// Return the HIP API callback ID for a given name
|
|
static inline uint32_t hipApiIdByName(const char* name) {
|
|
if (strcmp("__hipPopCallConfiguration", name) == 0) return HIP_API_ID___hipPopCallConfiguration;
|
|
if (strcmp("__hipPushCallConfiguration", name) == 0) return HIP_API_ID___hipPushCallConfiguration;
|
|
if (strcmp("hipArray3DCreate", name) == 0) return HIP_API_ID_hipArray3DCreate;
|
|
if (strcmp("hipArrayCreate", name) == 0) return HIP_API_ID_hipArrayCreate;
|
|
if (strcmp("hipArrayDestroy", name) == 0) return HIP_API_ID_hipArrayDestroy;
|
|
if (strcmp("hipChooseDevice", name) == 0) return HIP_API_ID_hipChooseDevice;
|
|
if (strcmp("hipConfigureCall", name) == 0) return HIP_API_ID_hipConfigureCall;
|
|
if (strcmp("hipCreateSurfaceObject", name) == 0) return HIP_API_ID_hipCreateSurfaceObject;
|
|
if (strcmp("hipCtxCreate", name) == 0) return HIP_API_ID_hipCtxCreate;
|
|
if (strcmp("hipCtxDestroy", name) == 0) return HIP_API_ID_hipCtxDestroy;
|
|
if (strcmp("hipCtxDisablePeerAccess", name) == 0) return HIP_API_ID_hipCtxDisablePeerAccess;
|
|
if (strcmp("hipCtxEnablePeerAccess", name) == 0) return HIP_API_ID_hipCtxEnablePeerAccess;
|
|
if (strcmp("hipCtxGetApiVersion", name) == 0) return HIP_API_ID_hipCtxGetApiVersion;
|
|
if (strcmp("hipCtxGetCacheConfig", name) == 0) return HIP_API_ID_hipCtxGetCacheConfig;
|
|
if (strcmp("hipCtxGetCurrent", name) == 0) return HIP_API_ID_hipCtxGetCurrent;
|
|
if (strcmp("hipCtxGetDevice", name) == 0) return HIP_API_ID_hipCtxGetDevice;
|
|
if (strcmp("hipCtxGetFlags", name) == 0) return HIP_API_ID_hipCtxGetFlags;
|
|
if (strcmp("hipCtxGetSharedMemConfig", name) == 0) return HIP_API_ID_hipCtxGetSharedMemConfig;
|
|
if (strcmp("hipCtxPopCurrent", name) == 0) return HIP_API_ID_hipCtxPopCurrent;
|
|
if (strcmp("hipCtxPushCurrent", name) == 0) return HIP_API_ID_hipCtxPushCurrent;
|
|
if (strcmp("hipCtxSetCacheConfig", name) == 0) return HIP_API_ID_hipCtxSetCacheConfig;
|
|
if (strcmp("hipCtxSetCurrent", name) == 0) return HIP_API_ID_hipCtxSetCurrent;
|
|
if (strcmp("hipCtxSetSharedMemConfig", name) == 0) return HIP_API_ID_hipCtxSetSharedMemConfig;
|
|
if (strcmp("hipCtxSynchronize", name) == 0) return HIP_API_ID_hipCtxSynchronize;
|
|
if (strcmp("hipDestroyExternalMemory", name) == 0) return HIP_API_ID_hipDestroyExternalMemory;
|
|
if (strcmp("hipDestroyExternalSemaphore", name) == 0) return HIP_API_ID_hipDestroyExternalSemaphore;
|
|
if (strcmp("hipDestroySurfaceObject", name) == 0) return HIP_API_ID_hipDestroySurfaceObject;
|
|
if (strcmp("hipDeviceCanAccessPeer", name) == 0) return HIP_API_ID_hipDeviceCanAccessPeer;
|
|
if (strcmp("hipDeviceComputeCapability", name) == 0) return HIP_API_ID_hipDeviceComputeCapability;
|
|
if (strcmp("hipDeviceDisablePeerAccess", name) == 0) return HIP_API_ID_hipDeviceDisablePeerAccess;
|
|
if (strcmp("hipDeviceEnablePeerAccess", name) == 0) return HIP_API_ID_hipDeviceEnablePeerAccess;
|
|
if (strcmp("hipDeviceGet", name) == 0) return HIP_API_ID_hipDeviceGet;
|
|
if (strcmp("hipDeviceGetAttribute", name) == 0) return HIP_API_ID_hipDeviceGetAttribute;
|
|
if (strcmp("hipDeviceGetByPCIBusId", name) == 0) return HIP_API_ID_hipDeviceGetByPCIBusId;
|
|
if (strcmp("hipDeviceGetCacheConfig", name) == 0) return HIP_API_ID_hipDeviceGetCacheConfig;
|
|
if (strcmp("hipDeviceGetDefaultMemPool", name) == 0) return HIP_API_ID_hipDeviceGetDefaultMemPool;
|
|
if (strcmp("hipDeviceGetGraphMemAttribute", name) == 0) return HIP_API_ID_hipDeviceGetGraphMemAttribute;
|
|
if (strcmp("hipDeviceGetLimit", name) == 0) return HIP_API_ID_hipDeviceGetLimit;
|
|
if (strcmp("hipDeviceGetMemPool", name) == 0) return HIP_API_ID_hipDeviceGetMemPool;
|
|
if (strcmp("hipDeviceGetName", name) == 0) return HIP_API_ID_hipDeviceGetName;
|
|
if (strcmp("hipDeviceGetP2PAttribute", name) == 0) return HIP_API_ID_hipDeviceGetP2PAttribute;
|
|
if (strcmp("hipDeviceGetPCIBusId", name) == 0) return HIP_API_ID_hipDeviceGetPCIBusId;
|
|
if (strcmp("hipDeviceGetSharedMemConfig", name) == 0) return HIP_API_ID_hipDeviceGetSharedMemConfig;
|
|
if (strcmp("hipDeviceGetStreamPriorityRange", name) == 0) return HIP_API_ID_hipDeviceGetStreamPriorityRange;
|
|
if (strcmp("hipDeviceGetUuid", name) == 0) return HIP_API_ID_hipDeviceGetUuid;
|
|
if (strcmp("hipDeviceGraphMemTrim", name) == 0) return HIP_API_ID_hipDeviceGraphMemTrim;
|
|
if (strcmp("hipDevicePrimaryCtxGetState", name) == 0) return HIP_API_ID_hipDevicePrimaryCtxGetState;
|
|
if (strcmp("hipDevicePrimaryCtxRelease", name) == 0) return HIP_API_ID_hipDevicePrimaryCtxRelease;
|
|
if (strcmp("hipDevicePrimaryCtxReset", name) == 0) return HIP_API_ID_hipDevicePrimaryCtxReset;
|
|
if (strcmp("hipDevicePrimaryCtxRetain", name) == 0) return HIP_API_ID_hipDevicePrimaryCtxRetain;
|
|
if (strcmp("hipDevicePrimaryCtxSetFlags", name) == 0) return HIP_API_ID_hipDevicePrimaryCtxSetFlags;
|
|
if (strcmp("hipDeviceReset", name) == 0) return HIP_API_ID_hipDeviceReset;
|
|
if (strcmp("hipDeviceSetCacheConfig", name) == 0) return HIP_API_ID_hipDeviceSetCacheConfig;
|
|
if (strcmp("hipDeviceSetGraphMemAttribute", name) == 0) return HIP_API_ID_hipDeviceSetGraphMemAttribute;
|
|
if (strcmp("hipDeviceSetLimit", name) == 0) return HIP_API_ID_hipDeviceSetLimit;
|
|
if (strcmp("hipDeviceSetMemPool", name) == 0) return HIP_API_ID_hipDeviceSetMemPool;
|
|
if (strcmp("hipDeviceSetSharedMemConfig", name) == 0) return HIP_API_ID_hipDeviceSetSharedMemConfig;
|
|
if (strcmp("hipDeviceSynchronize", name) == 0) return HIP_API_ID_hipDeviceSynchronize;
|
|
if (strcmp("hipDeviceTotalMem", name) == 0) return HIP_API_ID_hipDeviceTotalMem;
|
|
if (strcmp("hipDriverGetVersion", name) == 0) return HIP_API_ID_hipDriverGetVersion;
|
|
if (strcmp("hipDrvMemcpy2DUnaligned", name) == 0) return HIP_API_ID_hipDrvMemcpy2DUnaligned;
|
|
if (strcmp("hipDrvMemcpy3D", name) == 0) return HIP_API_ID_hipDrvMemcpy3D;
|
|
if (strcmp("hipDrvMemcpy3DAsync", name) == 0) return HIP_API_ID_hipDrvMemcpy3DAsync;
|
|
if (strcmp("hipDrvPointerGetAttributes", name) == 0) return HIP_API_ID_hipDrvPointerGetAttributes;
|
|
if (strcmp("hipEventCreate", name) == 0) return HIP_API_ID_hipEventCreate;
|
|
if (strcmp("hipEventCreateWithFlags", name) == 0) return HIP_API_ID_hipEventCreateWithFlags;
|
|
if (strcmp("hipEventDestroy", name) == 0) return HIP_API_ID_hipEventDestroy;
|
|
if (strcmp("hipEventElapsedTime", name) == 0) return HIP_API_ID_hipEventElapsedTime;
|
|
if (strcmp("hipEventQuery", name) == 0) return HIP_API_ID_hipEventQuery;
|
|
if (strcmp("hipEventRecord", name) == 0) return HIP_API_ID_hipEventRecord;
|
|
if (strcmp("hipEventSynchronize", name) == 0) return HIP_API_ID_hipEventSynchronize;
|
|
if (strcmp("hipExtGetLinkTypeAndHopCount", name) == 0) return HIP_API_ID_hipExtGetLinkTypeAndHopCount;
|
|
if (strcmp("hipExtLaunchKernel", name) == 0) return HIP_API_ID_hipExtLaunchKernel;
|
|
if (strcmp("hipExtLaunchMultiKernelMultiDevice", name) == 0) return HIP_API_ID_hipExtLaunchMultiKernelMultiDevice;
|
|
if (strcmp("hipExtMallocWithFlags", name) == 0) return HIP_API_ID_hipExtMallocWithFlags;
|
|
if (strcmp("hipExtModuleLaunchKernel", name) == 0) return HIP_API_ID_hipExtModuleLaunchKernel;
|
|
if (strcmp("hipExtStreamCreateWithCUMask", name) == 0) return HIP_API_ID_hipExtStreamCreateWithCUMask;
|
|
if (strcmp("hipExtStreamGetCUMask", name) == 0) return HIP_API_ID_hipExtStreamGetCUMask;
|
|
if (strcmp("hipExternalMemoryGetMappedBuffer", name) == 0) return HIP_API_ID_hipExternalMemoryGetMappedBuffer;
|
|
if (strcmp("hipFree", name) == 0) return HIP_API_ID_hipFree;
|
|
if (strcmp("hipFreeArray", name) == 0) return HIP_API_ID_hipFreeArray;
|
|
if (strcmp("hipFreeAsync", name) == 0) return HIP_API_ID_hipFreeAsync;
|
|
if (strcmp("hipFreeHost", name) == 0) return HIP_API_ID_hipFreeHost;
|
|
if (strcmp("hipFreeMipmappedArray", name) == 0) return HIP_API_ID_hipFreeMipmappedArray;
|
|
if (strcmp("hipFuncGetAttribute", name) == 0) return HIP_API_ID_hipFuncGetAttribute;
|
|
if (strcmp("hipFuncGetAttributes", name) == 0) return HIP_API_ID_hipFuncGetAttributes;
|
|
if (strcmp("hipFuncSetAttribute", name) == 0) return HIP_API_ID_hipFuncSetAttribute;
|
|
if (strcmp("hipFuncSetCacheConfig", name) == 0) return HIP_API_ID_hipFuncSetCacheConfig;
|
|
if (strcmp("hipFuncSetSharedMemConfig", name) == 0) return HIP_API_ID_hipFuncSetSharedMemConfig;
|
|
if (strcmp("hipGLGetDevices", name) == 0) return HIP_API_ID_hipGLGetDevices;
|
|
if (strcmp("hipGetChannelDesc", name) == 0) return HIP_API_ID_hipGetChannelDesc;
|
|
if (strcmp("hipGetDevice", name) == 0) return HIP_API_ID_hipGetDevice;
|
|
if (strcmp("hipGetDeviceCount", name) == 0) return HIP_API_ID_hipGetDeviceCount;
|
|
if (strcmp("hipGetDeviceFlags", name) == 0) return HIP_API_ID_hipGetDeviceFlags;
|
|
if (strcmp("hipGetDeviceProperties", name) == 0) return HIP_API_ID_hipGetDeviceProperties;
|
|
if (strcmp("hipGetErrorString", name) == 0) return HIP_API_ID_hipGetErrorString;
|
|
if (strcmp("hipGetLastError", name) == 0) return HIP_API_ID_hipGetLastError;
|
|
if (strcmp("hipGetMipmappedArrayLevel", name) == 0) return HIP_API_ID_hipGetMipmappedArrayLevel;
|
|
if (strcmp("hipGetSymbolAddress", name) == 0) return HIP_API_ID_hipGetSymbolAddress;
|
|
if (strcmp("hipGetSymbolSize", name) == 0) return HIP_API_ID_hipGetSymbolSize;
|
|
if (strcmp("hipGraphAddChildGraphNode", name) == 0) return HIP_API_ID_hipGraphAddChildGraphNode;
|
|
if (strcmp("hipGraphAddDependencies", name) == 0) return HIP_API_ID_hipGraphAddDependencies;
|
|
if (strcmp("hipGraphAddEmptyNode", name) == 0) return HIP_API_ID_hipGraphAddEmptyNode;
|
|
if (strcmp("hipGraphAddEventRecordNode", name) == 0) return HIP_API_ID_hipGraphAddEventRecordNode;
|
|
if (strcmp("hipGraphAddEventWaitNode", name) == 0) return HIP_API_ID_hipGraphAddEventWaitNode;
|
|
if (strcmp("hipGraphAddHostNode", name) == 0) return HIP_API_ID_hipGraphAddHostNode;
|
|
if (strcmp("hipGraphAddKernelNode", name) == 0) return HIP_API_ID_hipGraphAddKernelNode;
|
|
if (strcmp("hipGraphAddMemAllocNode", name) == 0) return HIP_API_ID_hipGraphAddMemAllocNode;
|
|
if (strcmp("hipGraphAddMemFreeNode", name) == 0) return HIP_API_ID_hipGraphAddMemFreeNode;
|
|
if (strcmp("hipGraphAddMemcpyNode", name) == 0) return HIP_API_ID_hipGraphAddMemcpyNode;
|
|
if (strcmp("hipGraphAddMemcpyNode1D", name) == 0) return HIP_API_ID_hipGraphAddMemcpyNode1D;
|
|
if (strcmp("hipGraphAddMemcpyNodeFromSymbol", name) == 0) return HIP_API_ID_hipGraphAddMemcpyNodeFromSymbol;
|
|
if (strcmp("hipGraphAddMemcpyNodeToSymbol", name) == 0) return HIP_API_ID_hipGraphAddMemcpyNodeToSymbol;
|
|
if (strcmp("hipGraphAddMemsetNode", name) == 0) return HIP_API_ID_hipGraphAddMemsetNode;
|
|
if (strcmp("hipGraphChildGraphNodeGetGraph", name) == 0) return HIP_API_ID_hipGraphChildGraphNodeGetGraph;
|
|
if (strcmp("hipGraphClone", name) == 0) return HIP_API_ID_hipGraphClone;
|
|
if (strcmp("hipGraphCreate", name) == 0) return HIP_API_ID_hipGraphCreate;
|
|
if (strcmp("hipGraphDebugDotPrint", name) == 0) return HIP_API_ID_hipGraphDebugDotPrint;
|
|
if (strcmp("hipGraphDestroy", name) == 0) return HIP_API_ID_hipGraphDestroy;
|
|
if (strcmp("hipGraphDestroyNode", name) == 0) return HIP_API_ID_hipGraphDestroyNode;
|
|
if (strcmp("hipGraphEventRecordNodeGetEvent", name) == 0) return HIP_API_ID_hipGraphEventRecordNodeGetEvent;
|
|
if (strcmp("hipGraphEventRecordNodeSetEvent", name) == 0) return HIP_API_ID_hipGraphEventRecordNodeSetEvent;
|
|
if (strcmp("hipGraphEventWaitNodeGetEvent", name) == 0) return HIP_API_ID_hipGraphEventWaitNodeGetEvent;
|
|
if (strcmp("hipGraphEventWaitNodeSetEvent", name) == 0) return HIP_API_ID_hipGraphEventWaitNodeSetEvent;
|
|
if (strcmp("hipGraphExecChildGraphNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecChildGraphNodeSetParams;
|
|
if (strcmp("hipGraphExecDestroy", name) == 0) return HIP_API_ID_hipGraphExecDestroy;
|
|
if (strcmp("hipGraphExecEventRecordNodeSetEvent", name) == 0) return HIP_API_ID_hipGraphExecEventRecordNodeSetEvent;
|
|
if (strcmp("hipGraphExecEventWaitNodeSetEvent", name) == 0) return HIP_API_ID_hipGraphExecEventWaitNodeSetEvent;
|
|
if (strcmp("hipGraphExecHostNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecHostNodeSetParams;
|
|
if (strcmp("hipGraphExecKernelNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecKernelNodeSetParams;
|
|
if (strcmp("hipGraphExecMemcpyNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecMemcpyNodeSetParams;
|
|
if (strcmp("hipGraphExecMemcpyNodeSetParams1D", name) == 0) return HIP_API_ID_hipGraphExecMemcpyNodeSetParams1D;
|
|
if (strcmp("hipGraphExecMemcpyNodeSetParamsFromSymbol", name) == 0) return HIP_API_ID_hipGraphExecMemcpyNodeSetParamsFromSymbol;
|
|
if (strcmp("hipGraphExecMemcpyNodeSetParamsToSymbol", name) == 0) return HIP_API_ID_hipGraphExecMemcpyNodeSetParamsToSymbol;
|
|
if (strcmp("hipGraphExecMemsetNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecMemsetNodeSetParams;
|
|
if (strcmp("hipGraphExecUpdate", name) == 0) return HIP_API_ID_hipGraphExecUpdate;
|
|
if (strcmp("hipGraphGetEdges", name) == 0) return HIP_API_ID_hipGraphGetEdges;
|
|
if (strcmp("hipGraphGetNodes", name) == 0) return HIP_API_ID_hipGraphGetNodes;
|
|
if (strcmp("hipGraphGetRootNodes", name) == 0) return HIP_API_ID_hipGraphGetRootNodes;
|
|
if (strcmp("hipGraphHostNodeGetParams", name) == 0) return HIP_API_ID_hipGraphHostNodeGetParams;
|
|
if (strcmp("hipGraphHostNodeSetParams", name) == 0) return HIP_API_ID_hipGraphHostNodeSetParams;
|
|
if (strcmp("hipGraphInstantiate", name) == 0) return HIP_API_ID_hipGraphInstantiate;
|
|
if (strcmp("hipGraphInstantiateWithFlags", name) == 0) return HIP_API_ID_hipGraphInstantiateWithFlags;
|
|
if (strcmp("hipGraphKernelNodeCopyAttributes", name) == 0) return HIP_API_ID_hipGraphKernelNodeCopyAttributes;
|
|
if (strcmp("hipGraphKernelNodeGetAttribute", name) == 0) return HIP_API_ID_hipGraphKernelNodeGetAttribute;
|
|
if (strcmp("hipGraphKernelNodeGetParams", name) == 0) return HIP_API_ID_hipGraphKernelNodeGetParams;
|
|
if (strcmp("hipGraphKernelNodeSetAttribute", name) == 0) return HIP_API_ID_hipGraphKernelNodeSetAttribute;
|
|
if (strcmp("hipGraphKernelNodeSetParams", name) == 0) return HIP_API_ID_hipGraphKernelNodeSetParams;
|
|
if (strcmp("hipGraphLaunch", name) == 0) return HIP_API_ID_hipGraphLaunch;
|
|
if (strcmp("hipGraphMemAllocNodeGetParams", name) == 0) return HIP_API_ID_hipGraphMemAllocNodeGetParams;
|
|
if (strcmp("hipGraphMemFreeNodeGetParams", name) == 0) return HIP_API_ID_hipGraphMemFreeNodeGetParams;
|
|
if (strcmp("hipGraphMemcpyNodeGetParams", name) == 0) return HIP_API_ID_hipGraphMemcpyNodeGetParams;
|
|
if (strcmp("hipGraphMemcpyNodeSetParams", name) == 0) return HIP_API_ID_hipGraphMemcpyNodeSetParams;
|
|
if (strcmp("hipGraphMemcpyNodeSetParams1D", name) == 0) return HIP_API_ID_hipGraphMemcpyNodeSetParams1D;
|
|
if (strcmp("hipGraphMemcpyNodeSetParamsFromSymbol", name) == 0) return HIP_API_ID_hipGraphMemcpyNodeSetParamsFromSymbol;
|
|
if (strcmp("hipGraphMemcpyNodeSetParamsToSymbol", name) == 0) return HIP_API_ID_hipGraphMemcpyNodeSetParamsToSymbol;
|
|
if (strcmp("hipGraphMemsetNodeGetParams", name) == 0) return HIP_API_ID_hipGraphMemsetNodeGetParams;
|
|
if (strcmp("hipGraphMemsetNodeSetParams", name) == 0) return HIP_API_ID_hipGraphMemsetNodeSetParams;
|
|
if (strcmp("hipGraphNodeFindInClone", name) == 0) return HIP_API_ID_hipGraphNodeFindInClone;
|
|
if (strcmp("hipGraphNodeGetDependencies", name) == 0) return HIP_API_ID_hipGraphNodeGetDependencies;
|
|
if (strcmp("hipGraphNodeGetDependentNodes", name) == 0) return HIP_API_ID_hipGraphNodeGetDependentNodes;
|
|
if (strcmp("hipGraphNodeGetEnabled", name) == 0) return HIP_API_ID_hipGraphNodeGetEnabled;
|
|
if (strcmp("hipGraphNodeGetType", name) == 0) return HIP_API_ID_hipGraphNodeGetType;
|
|
if (strcmp("hipGraphNodeSetEnabled", name) == 0) return HIP_API_ID_hipGraphNodeSetEnabled;
|
|
if (strcmp("hipGraphReleaseUserObject", name) == 0) return HIP_API_ID_hipGraphReleaseUserObject;
|
|
if (strcmp("hipGraphRemoveDependencies", name) == 0) return HIP_API_ID_hipGraphRemoveDependencies;
|
|
if (strcmp("hipGraphRetainUserObject", name) == 0) return HIP_API_ID_hipGraphRetainUserObject;
|
|
if (strcmp("hipGraphUpload", name) == 0) return HIP_API_ID_hipGraphUpload;
|
|
if (strcmp("hipGraphicsGLRegisterBuffer", name) == 0) return HIP_API_ID_hipGraphicsGLRegisterBuffer;
|
|
if (strcmp("hipGraphicsGLRegisterImage", name) == 0) return HIP_API_ID_hipGraphicsGLRegisterImage;
|
|
if (strcmp("hipGraphicsMapResources", name) == 0) return HIP_API_ID_hipGraphicsMapResources;
|
|
if (strcmp("hipGraphicsResourceGetMappedPointer", name) == 0) return HIP_API_ID_hipGraphicsResourceGetMappedPointer;
|
|
if (strcmp("hipGraphicsSubResourceGetMappedArray", name) == 0) return HIP_API_ID_hipGraphicsSubResourceGetMappedArray;
|
|
if (strcmp("hipGraphicsUnmapResources", name) == 0) return HIP_API_ID_hipGraphicsUnmapResources;
|
|
if (strcmp("hipGraphicsUnregisterResource", name) == 0) return HIP_API_ID_hipGraphicsUnregisterResource;
|
|
if (strcmp("hipHccModuleLaunchKernel", name) == 0) return HIP_API_ID_hipHccModuleLaunchKernel;
|
|
if (strcmp("hipHostAlloc", name) == 0) return HIP_API_ID_hipHostAlloc;
|
|
if (strcmp("hipHostFree", name) == 0) return HIP_API_ID_hipHostFree;
|
|
if (strcmp("hipHostGetDevicePointer", name) == 0) return HIP_API_ID_hipHostGetDevicePointer;
|
|
if (strcmp("hipHostGetFlags", name) == 0) return HIP_API_ID_hipHostGetFlags;
|
|
if (strcmp("hipHostMalloc", name) == 0) return HIP_API_ID_hipHostMalloc;
|
|
if (strcmp("hipHostRegister", name) == 0) return HIP_API_ID_hipHostRegister;
|
|
if (strcmp("hipHostUnregister", name) == 0) return HIP_API_ID_hipHostUnregister;
|
|
if (strcmp("hipImportExternalMemory", name) == 0) return HIP_API_ID_hipImportExternalMemory;
|
|
if (strcmp("hipImportExternalSemaphore", name) == 0) return HIP_API_ID_hipImportExternalSemaphore;
|
|
if (strcmp("hipInit", name) == 0) return HIP_API_ID_hipInit;
|
|
if (strcmp("hipIpcCloseMemHandle", name) == 0) return HIP_API_ID_hipIpcCloseMemHandle;
|
|
if (strcmp("hipIpcGetEventHandle", name) == 0) return HIP_API_ID_hipIpcGetEventHandle;
|
|
if (strcmp("hipIpcGetMemHandle", name) == 0) return HIP_API_ID_hipIpcGetMemHandle;
|
|
if (strcmp("hipIpcOpenEventHandle", name) == 0) return HIP_API_ID_hipIpcOpenEventHandle;
|
|
if (strcmp("hipIpcOpenMemHandle", name) == 0) return HIP_API_ID_hipIpcOpenMemHandle;
|
|
if (strcmp("hipLaunchByPtr", name) == 0) return HIP_API_ID_hipLaunchByPtr;
|
|
if (strcmp("hipLaunchCooperativeKernel", name) == 0) return HIP_API_ID_hipLaunchCooperativeKernel;
|
|
if (strcmp("hipLaunchCooperativeKernelMultiDevice", name) == 0) return HIP_API_ID_hipLaunchCooperativeKernelMultiDevice;
|
|
if (strcmp("hipLaunchHostFunc", name) == 0) return HIP_API_ID_hipLaunchHostFunc;
|
|
if (strcmp("hipLaunchKernel", name) == 0) return HIP_API_ID_hipLaunchKernel;
|
|
if (strcmp("hipMalloc", name) == 0) return HIP_API_ID_hipMalloc;
|
|
if (strcmp("hipMalloc3D", name) == 0) return HIP_API_ID_hipMalloc3D;
|
|
if (strcmp("hipMalloc3DArray", name) == 0) return HIP_API_ID_hipMalloc3DArray;
|
|
if (strcmp("hipMallocArray", name) == 0) return HIP_API_ID_hipMallocArray;
|
|
if (strcmp("hipMallocAsync", name) == 0) return HIP_API_ID_hipMallocAsync;
|
|
if (strcmp("hipMallocFromPoolAsync", name) == 0) return HIP_API_ID_hipMallocFromPoolAsync;
|
|
if (strcmp("hipMallocHost", name) == 0) return HIP_API_ID_hipMallocHost;
|
|
if (strcmp("hipMallocManaged", name) == 0) return HIP_API_ID_hipMallocManaged;
|
|
if (strcmp("hipMallocMipmappedArray", name) == 0) return HIP_API_ID_hipMallocMipmappedArray;
|
|
if (strcmp("hipMallocPitch", name) == 0) return HIP_API_ID_hipMallocPitch;
|
|
if (strcmp("hipMemAddressFree", name) == 0) return HIP_API_ID_hipMemAddressFree;
|
|
if (strcmp("hipMemAddressReserve", name) == 0) return HIP_API_ID_hipMemAddressReserve;
|
|
if (strcmp("hipMemAdvise", name) == 0) return HIP_API_ID_hipMemAdvise;
|
|
if (strcmp("hipMemAllocHost", name) == 0) return HIP_API_ID_hipMemAllocHost;
|
|
if (strcmp("hipMemAllocPitch", name) == 0) return HIP_API_ID_hipMemAllocPitch;
|
|
if (strcmp("hipMemCreate", name) == 0) return HIP_API_ID_hipMemCreate;
|
|
if (strcmp("hipMemExportToShareableHandle", name) == 0) return HIP_API_ID_hipMemExportToShareableHandle;
|
|
if (strcmp("hipMemGetAccess", name) == 0) return HIP_API_ID_hipMemGetAccess;
|
|
if (strcmp("hipMemGetAddressRange", name) == 0) return HIP_API_ID_hipMemGetAddressRange;
|
|
if (strcmp("hipMemGetAllocationGranularity", name) == 0) return HIP_API_ID_hipMemGetAllocationGranularity;
|
|
if (strcmp("hipMemGetAllocationPropertiesFromHandle", name) == 0) return HIP_API_ID_hipMemGetAllocationPropertiesFromHandle;
|
|
if (strcmp("hipMemGetInfo", name) == 0) return HIP_API_ID_hipMemGetInfo;
|
|
if (strcmp("hipMemImportFromShareableHandle", name) == 0) return HIP_API_ID_hipMemImportFromShareableHandle;
|
|
if (strcmp("hipMemMap", name) == 0) return HIP_API_ID_hipMemMap;
|
|
if (strcmp("hipMemMapArrayAsync", name) == 0) return HIP_API_ID_hipMemMapArrayAsync;
|
|
if (strcmp("hipMemPoolCreate", name) == 0) return HIP_API_ID_hipMemPoolCreate;
|
|
if (strcmp("hipMemPoolDestroy", name) == 0) return HIP_API_ID_hipMemPoolDestroy;
|
|
if (strcmp("hipMemPoolExportPointer", name) == 0) return HIP_API_ID_hipMemPoolExportPointer;
|
|
if (strcmp("hipMemPoolExportToShareableHandle", name) == 0) return HIP_API_ID_hipMemPoolExportToShareableHandle;
|
|
if (strcmp("hipMemPoolGetAccess", name) == 0) return HIP_API_ID_hipMemPoolGetAccess;
|
|
if (strcmp("hipMemPoolGetAttribute", name) == 0) return HIP_API_ID_hipMemPoolGetAttribute;
|
|
if (strcmp("hipMemPoolImportFromShareableHandle", name) == 0) return HIP_API_ID_hipMemPoolImportFromShareableHandle;
|
|
if (strcmp("hipMemPoolImportPointer", name) == 0) return HIP_API_ID_hipMemPoolImportPointer;
|
|
if (strcmp("hipMemPoolSetAccess", name) == 0) return HIP_API_ID_hipMemPoolSetAccess;
|
|
if (strcmp("hipMemPoolSetAttribute", name) == 0) return HIP_API_ID_hipMemPoolSetAttribute;
|
|
if (strcmp("hipMemPoolTrimTo", name) == 0) return HIP_API_ID_hipMemPoolTrimTo;
|
|
if (strcmp("hipMemPrefetchAsync", name) == 0) return HIP_API_ID_hipMemPrefetchAsync;
|
|
if (strcmp("hipMemPtrGetInfo", name) == 0) return HIP_API_ID_hipMemPtrGetInfo;
|
|
if (strcmp("hipMemRangeGetAttribute", name) == 0) return HIP_API_ID_hipMemRangeGetAttribute;
|
|
if (strcmp("hipMemRangeGetAttributes", name) == 0) return HIP_API_ID_hipMemRangeGetAttributes;
|
|
if (strcmp("hipMemRelease", name) == 0) return HIP_API_ID_hipMemRelease;
|
|
if (strcmp("hipMemRetainAllocationHandle", name) == 0) return HIP_API_ID_hipMemRetainAllocationHandle;
|
|
if (strcmp("hipMemSetAccess", name) == 0) return HIP_API_ID_hipMemSetAccess;
|
|
if (strcmp("hipMemUnmap", name) == 0) return HIP_API_ID_hipMemUnmap;
|
|
if (strcmp("hipMemcpy", name) == 0) return HIP_API_ID_hipMemcpy;
|
|
if (strcmp("hipMemcpy2D", name) == 0) return HIP_API_ID_hipMemcpy2D;
|
|
if (strcmp("hipMemcpy2DAsync", name) == 0) return HIP_API_ID_hipMemcpy2DAsync;
|
|
if (strcmp("hipMemcpy2DFromArray", name) == 0) return HIP_API_ID_hipMemcpy2DFromArray;
|
|
if (strcmp("hipMemcpy2DFromArrayAsync", name) == 0) return HIP_API_ID_hipMemcpy2DFromArrayAsync;
|
|
if (strcmp("hipMemcpy2DToArray", name) == 0) return HIP_API_ID_hipMemcpy2DToArray;
|
|
if (strcmp("hipMemcpy2DToArrayAsync", name) == 0) return HIP_API_ID_hipMemcpy2DToArrayAsync;
|
|
if (strcmp("hipMemcpy3D", name) == 0) return HIP_API_ID_hipMemcpy3D;
|
|
if (strcmp("hipMemcpy3DAsync", name) == 0) return HIP_API_ID_hipMemcpy3DAsync;
|
|
if (strcmp("hipMemcpyAsync", name) == 0) return HIP_API_ID_hipMemcpyAsync;
|
|
if (strcmp("hipMemcpyAtoH", name) == 0) return HIP_API_ID_hipMemcpyAtoH;
|
|
if (strcmp("hipMemcpyDtoD", name) == 0) return HIP_API_ID_hipMemcpyDtoD;
|
|
if (strcmp("hipMemcpyDtoDAsync", name) == 0) return HIP_API_ID_hipMemcpyDtoDAsync;
|
|
if (strcmp("hipMemcpyDtoH", name) == 0) return HIP_API_ID_hipMemcpyDtoH;
|
|
if (strcmp("hipMemcpyDtoHAsync", name) == 0) return HIP_API_ID_hipMemcpyDtoHAsync;
|
|
if (strcmp("hipMemcpyFromArray", name) == 0) return HIP_API_ID_hipMemcpyFromArray;
|
|
if (strcmp("hipMemcpyFromSymbol", name) == 0) return HIP_API_ID_hipMemcpyFromSymbol;
|
|
if (strcmp("hipMemcpyFromSymbolAsync", name) == 0) return HIP_API_ID_hipMemcpyFromSymbolAsync;
|
|
if (strcmp("hipMemcpyHtoA", name) == 0) return HIP_API_ID_hipMemcpyHtoA;
|
|
if (strcmp("hipMemcpyHtoD", name) == 0) return HIP_API_ID_hipMemcpyHtoD;
|
|
if (strcmp("hipMemcpyHtoDAsync", name) == 0) return HIP_API_ID_hipMemcpyHtoDAsync;
|
|
if (strcmp("hipMemcpyParam2D", name) == 0) return HIP_API_ID_hipMemcpyParam2D;
|
|
if (strcmp("hipMemcpyParam2DAsync", name) == 0) return HIP_API_ID_hipMemcpyParam2DAsync;
|
|
if (strcmp("hipMemcpyPeer", name) == 0) return HIP_API_ID_hipMemcpyPeer;
|
|
if (strcmp("hipMemcpyPeerAsync", name) == 0) return HIP_API_ID_hipMemcpyPeerAsync;
|
|
if (strcmp("hipMemcpyToArray", name) == 0) return HIP_API_ID_hipMemcpyToArray;
|
|
if (strcmp("hipMemcpyToSymbol", name) == 0) return HIP_API_ID_hipMemcpyToSymbol;
|
|
if (strcmp("hipMemcpyToSymbolAsync", name) == 0) return HIP_API_ID_hipMemcpyToSymbolAsync;
|
|
if (strcmp("hipMemcpyWithStream", name) == 0) return HIP_API_ID_hipMemcpyWithStream;
|
|
if (strcmp("hipMemset", name) == 0) return HIP_API_ID_hipMemset;
|
|
if (strcmp("hipMemset2D", name) == 0) return HIP_API_ID_hipMemset2D;
|
|
if (strcmp("hipMemset2DAsync", name) == 0) return HIP_API_ID_hipMemset2DAsync;
|
|
if (strcmp("hipMemset3D", name) == 0) return HIP_API_ID_hipMemset3D;
|
|
if (strcmp("hipMemset3DAsync", name) == 0) return HIP_API_ID_hipMemset3DAsync;
|
|
if (strcmp("hipMemsetAsync", name) == 0) return HIP_API_ID_hipMemsetAsync;
|
|
if (strcmp("hipMemsetD16", name) == 0) return HIP_API_ID_hipMemsetD16;
|
|
if (strcmp("hipMemsetD16Async", name) == 0) return HIP_API_ID_hipMemsetD16Async;
|
|
if (strcmp("hipMemsetD32", name) == 0) return HIP_API_ID_hipMemsetD32;
|
|
if (strcmp("hipMemsetD32Async", name) == 0) return HIP_API_ID_hipMemsetD32Async;
|
|
if (strcmp("hipMemsetD8", name) == 0) return HIP_API_ID_hipMemsetD8;
|
|
if (strcmp("hipMemsetD8Async", name) == 0) return HIP_API_ID_hipMemsetD8Async;
|
|
if (strcmp("hipMipmappedArrayCreate", name) == 0) return HIP_API_ID_hipMipmappedArrayCreate;
|
|
if (strcmp("hipMipmappedArrayDestroy", name) == 0) return HIP_API_ID_hipMipmappedArrayDestroy;
|
|
if (strcmp("hipMipmappedArrayGetLevel", name) == 0) return HIP_API_ID_hipMipmappedArrayGetLevel;
|
|
if (strcmp("hipModuleGetFunction", name) == 0) return HIP_API_ID_hipModuleGetFunction;
|
|
if (strcmp("hipModuleGetGlobal", name) == 0) return HIP_API_ID_hipModuleGetGlobal;
|
|
if (strcmp("hipModuleGetTexRef", name) == 0) return HIP_API_ID_hipModuleGetTexRef;
|
|
if (strcmp("hipModuleLaunchCooperativeKernel", name) == 0) return HIP_API_ID_hipModuleLaunchCooperativeKernel;
|
|
if (strcmp("hipModuleLaunchCooperativeKernelMultiDevice", name) == 0) return HIP_API_ID_hipModuleLaunchCooperativeKernelMultiDevice;
|
|
if (strcmp("hipModuleLaunchKernel", name) == 0) return HIP_API_ID_hipModuleLaunchKernel;
|
|
if (strcmp("hipModuleLoad", name) == 0) return HIP_API_ID_hipModuleLoad;
|
|
if (strcmp("hipModuleLoadData", name) == 0) return HIP_API_ID_hipModuleLoadData;
|
|
if (strcmp("hipModuleLoadDataEx", name) == 0) return HIP_API_ID_hipModuleLoadDataEx;
|
|
if (strcmp("hipModuleOccupancyMaxActiveBlocksPerMultiprocessor", name) == 0) return HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor;
|
|
if (strcmp("hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", name) == 0) return HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
|
|
if (strcmp("hipModuleOccupancyMaxPotentialBlockSize", name) == 0) return HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSize;
|
|
if (strcmp("hipModuleOccupancyMaxPotentialBlockSizeWithFlags", name) == 0) return HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSizeWithFlags;
|
|
if (strcmp("hipModuleUnload", name) == 0) return HIP_API_ID_hipModuleUnload;
|
|
if (strcmp("hipOccupancyMaxActiveBlocksPerMultiprocessor", name) == 0) return HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor;
|
|
if (strcmp("hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", name) == 0) return HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
|
|
if (strcmp("hipOccupancyMaxPotentialBlockSize", name) == 0) return HIP_API_ID_hipOccupancyMaxPotentialBlockSize;
|
|
if (strcmp("hipPeekAtLastError", name) == 0) return HIP_API_ID_hipPeekAtLastError;
|
|
if (strcmp("hipPointerGetAttribute", name) == 0) return HIP_API_ID_hipPointerGetAttribute;
|
|
if (strcmp("hipPointerGetAttributes", name) == 0) return HIP_API_ID_hipPointerGetAttributes;
|
|
if (strcmp("hipPointerSetAttribute", name) == 0) return HIP_API_ID_hipPointerSetAttribute;
|
|
if (strcmp("hipProfilerStart", name) == 0) return HIP_API_ID_hipProfilerStart;
|
|
if (strcmp("hipProfilerStop", name) == 0) return HIP_API_ID_hipProfilerStop;
|
|
if (strcmp("hipRuntimeGetVersion", name) == 0) return HIP_API_ID_hipRuntimeGetVersion;
|
|
if (strcmp("hipSetDevice", name) == 0) return HIP_API_ID_hipSetDevice;
|
|
if (strcmp("hipSetDeviceFlags", name) == 0) return HIP_API_ID_hipSetDeviceFlags;
|
|
if (strcmp("hipSetupArgument", name) == 0) return HIP_API_ID_hipSetupArgument;
|
|
if (strcmp("hipSignalExternalSemaphoresAsync", name) == 0) return HIP_API_ID_hipSignalExternalSemaphoresAsync;
|
|
if (strcmp("hipStreamAddCallback", name) == 0) return HIP_API_ID_hipStreamAddCallback;
|
|
if (strcmp("hipStreamAttachMemAsync", name) == 0) return HIP_API_ID_hipStreamAttachMemAsync;
|
|
if (strcmp("hipStreamBeginCapture", name) == 0) return HIP_API_ID_hipStreamBeginCapture;
|
|
if (strcmp("hipStreamCreate", name) == 0) return HIP_API_ID_hipStreamCreate;
|
|
if (strcmp("hipStreamCreateWithFlags", name) == 0) return HIP_API_ID_hipStreamCreateWithFlags;
|
|
if (strcmp("hipStreamCreateWithPriority", name) == 0) return HIP_API_ID_hipStreamCreateWithPriority;
|
|
if (strcmp("hipStreamDestroy", name) == 0) return HIP_API_ID_hipStreamDestroy;
|
|
if (strcmp("hipStreamEndCapture", name) == 0) return HIP_API_ID_hipStreamEndCapture;
|
|
if (strcmp("hipStreamGetCaptureInfo", name) == 0) return HIP_API_ID_hipStreamGetCaptureInfo;
|
|
if (strcmp("hipStreamGetCaptureInfo_v2", name) == 0) return HIP_API_ID_hipStreamGetCaptureInfo_v2;
|
|
if (strcmp("hipStreamGetFlags", name) == 0) return HIP_API_ID_hipStreamGetFlags;
|
|
if (strcmp("hipStreamGetPriority", name) == 0) return HIP_API_ID_hipStreamGetPriority;
|
|
if (strcmp("hipStreamIsCapturing", name) == 0) return HIP_API_ID_hipStreamIsCapturing;
|
|
if (strcmp("hipStreamQuery", name) == 0) return HIP_API_ID_hipStreamQuery;
|
|
if (strcmp("hipStreamSynchronize", name) == 0) return HIP_API_ID_hipStreamSynchronize;
|
|
if (strcmp("hipStreamUpdateCaptureDependencies", name) == 0) return HIP_API_ID_hipStreamUpdateCaptureDependencies;
|
|
if (strcmp("hipStreamWaitEvent", name) == 0) return HIP_API_ID_hipStreamWaitEvent;
|
|
if (strcmp("hipStreamWaitValue32", name) == 0) return HIP_API_ID_hipStreamWaitValue32;
|
|
if (strcmp("hipStreamWaitValue64", name) == 0) return HIP_API_ID_hipStreamWaitValue64;
|
|
if (strcmp("hipStreamWriteValue32", name) == 0) return HIP_API_ID_hipStreamWriteValue32;
|
|
if (strcmp("hipStreamWriteValue64", name) == 0) return HIP_API_ID_hipStreamWriteValue64;
|
|
if (strcmp("hipTexRefGetAddress", name) == 0) return HIP_API_ID_hipTexRefGetAddress;
|
|
if (strcmp("hipTexRefGetFlags", name) == 0) return HIP_API_ID_hipTexRefGetFlags;
|
|
if (strcmp("hipTexRefGetFormat", name) == 0) return HIP_API_ID_hipTexRefGetFormat;
|
|
if (strcmp("hipTexRefGetMaxAnisotropy", name) == 0) return HIP_API_ID_hipTexRefGetMaxAnisotropy;
|
|
if (strcmp("hipTexRefGetMipMappedArray", name) == 0) return HIP_API_ID_hipTexRefGetMipMappedArray;
|
|
if (strcmp("hipTexRefGetMipmapLevelBias", name) == 0) return HIP_API_ID_hipTexRefGetMipmapLevelBias;
|
|
if (strcmp("hipTexRefGetMipmapLevelClamp", name) == 0) return HIP_API_ID_hipTexRefGetMipmapLevelClamp;
|
|
if (strcmp("hipTexRefSetAddress", name) == 0) return HIP_API_ID_hipTexRefSetAddress;
|
|
if (strcmp("hipTexRefSetAddress2D", name) == 0) return HIP_API_ID_hipTexRefSetAddress2D;
|
|
if (strcmp("hipTexRefSetArray", name) == 0) return HIP_API_ID_hipTexRefSetArray;
|
|
if (strcmp("hipTexRefSetBorderColor", name) == 0) return HIP_API_ID_hipTexRefSetBorderColor;
|
|
if (strcmp("hipTexRefSetFlags", name) == 0) return HIP_API_ID_hipTexRefSetFlags;
|
|
if (strcmp("hipTexRefSetFormat", name) == 0) return HIP_API_ID_hipTexRefSetFormat;
|
|
if (strcmp("hipTexRefSetMaxAnisotropy", name) == 0) return HIP_API_ID_hipTexRefSetMaxAnisotropy;
|
|
if (strcmp("hipTexRefSetMipmapLevelBias", name) == 0) return HIP_API_ID_hipTexRefSetMipmapLevelBias;
|
|
if (strcmp("hipTexRefSetMipmapLevelClamp", name) == 0) return HIP_API_ID_hipTexRefSetMipmapLevelClamp;
|
|
if (strcmp("hipTexRefSetMipmappedArray", name) == 0) return HIP_API_ID_hipTexRefSetMipmappedArray;
|
|
if (strcmp("hipThreadExchangeStreamCaptureMode", name) == 0) return HIP_API_ID_hipThreadExchangeStreamCaptureMode;
|
|
if (strcmp("hipUserObjectCreate", name) == 0) return HIP_API_ID_hipUserObjectCreate;
|
|
if (strcmp("hipUserObjectRelease", name) == 0) return HIP_API_ID_hipUserObjectRelease;
|
|
if (strcmp("hipUserObjectRetain", name) == 0) return HIP_API_ID_hipUserObjectRetain;
|
|
if (strcmp("hipWaitExternalSemaphoresAsync", name) == 0) return HIP_API_ID_hipWaitExternalSemaphoresAsync;
|
|
return HIP_API_ID_NONE;
|
|
}
|
|
|
|
// HIP API callbacks data structures
|
|
typedef struct hip_api_data_s {
|
|
uint64_t correlation_id;
|
|
uint32_t phase;
|
|
union {
|
|
struct {
|
|
dim3* gridDim;
|
|
dim3 gridDim__val;
|
|
dim3* blockDim;
|
|
dim3 blockDim__val;
|
|
size_t* sharedMem;
|
|
size_t sharedMem__val;
|
|
hipStream_t* stream;
|
|
hipStream_t stream__val;
|
|
} __hipPopCallConfiguration;
|
|
struct {
|
|
dim3 gridDim;
|
|
dim3 blockDim;
|
|
size_t sharedMem;
|
|
hipStream_t stream;
|
|
} __hipPushCallConfiguration;
|
|
struct {
|
|
hipArray** array;
|
|
hipArray* array__val;
|
|
const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray;
|
|
HIP_ARRAY3D_DESCRIPTOR pAllocateArray__val;
|
|
} hipArray3DCreate;
|
|
struct {
|
|
hipArray** pHandle;
|
|
hipArray* pHandle__val;
|
|
const HIP_ARRAY_DESCRIPTOR* pAllocateArray;
|
|
HIP_ARRAY_DESCRIPTOR pAllocateArray__val;
|
|
} hipArrayCreate;
|
|
struct {
|
|
hipArray* array;
|
|
hipArray array__val;
|
|
} hipArrayDestroy;
|
|
struct {
|
|
int* device;
|
|
int device__val;
|
|
const hipDeviceProp_t* prop;
|
|
hipDeviceProp_t prop__val;
|
|
} hipChooseDevice;
|
|
struct {
|
|
dim3 gridDim;
|
|
dim3 blockDim;
|
|
size_t sharedMem;
|
|
hipStream_t stream;
|
|
} hipConfigureCall;
|
|
struct {
|
|
hipSurfaceObject_t* pSurfObject;
|
|
hipSurfaceObject_t pSurfObject__val;
|
|
const hipResourceDesc* pResDesc;
|
|
hipResourceDesc pResDesc__val;
|
|
} hipCreateSurfaceObject;
|
|
struct {
|
|
hipCtx_t* ctx;
|
|
hipCtx_t ctx__val;
|
|
unsigned int flags;
|
|
hipDevice_t device;
|
|
} hipCtxCreate;
|
|
struct {
|
|
hipCtx_t ctx;
|
|
} hipCtxDestroy;
|
|
struct {
|
|
hipCtx_t peerCtx;
|
|
} hipCtxDisablePeerAccess;
|
|
struct {
|
|
hipCtx_t peerCtx;
|
|
unsigned int flags;
|
|
} hipCtxEnablePeerAccess;
|
|
struct {
|
|
hipCtx_t ctx;
|
|
int* apiVersion;
|
|
int apiVersion__val;
|
|
} hipCtxGetApiVersion;
|
|
struct {
|
|
hipFuncCache_t* cacheConfig;
|
|
hipFuncCache_t cacheConfig__val;
|
|
} hipCtxGetCacheConfig;
|
|
struct {
|
|
hipCtx_t* ctx;
|
|
hipCtx_t ctx__val;
|
|
} hipCtxGetCurrent;
|
|
struct {
|
|
hipDevice_t* device;
|
|
hipDevice_t device__val;
|
|
} hipCtxGetDevice;
|
|
struct {
|
|
unsigned int* flags;
|
|
unsigned int flags__val;
|
|
} hipCtxGetFlags;
|
|
struct {
|
|
hipSharedMemConfig* pConfig;
|
|
hipSharedMemConfig pConfig__val;
|
|
} hipCtxGetSharedMemConfig;
|
|
struct {
|
|
hipCtx_t* ctx;
|
|
hipCtx_t ctx__val;
|
|
} hipCtxPopCurrent;
|
|
struct {
|
|
hipCtx_t ctx;
|
|
} hipCtxPushCurrent;
|
|
struct {
|
|
hipFuncCache_t cacheConfig;
|
|
} hipCtxSetCacheConfig;
|
|
struct {
|
|
hipCtx_t ctx;
|
|
} hipCtxSetCurrent;
|
|
struct {
|
|
hipSharedMemConfig config;
|
|
} hipCtxSetSharedMemConfig;
|
|
struct {
|
|
hipExternalMemory_t extMem;
|
|
} hipDestroyExternalMemory;
|
|
struct {
|
|
hipExternalSemaphore_t extSem;
|
|
} hipDestroyExternalSemaphore;
|
|
struct {
|
|
hipSurfaceObject_t surfaceObject;
|
|
} hipDestroySurfaceObject;
|
|
struct {
|
|
int* canAccessPeer;
|
|
int canAccessPeer__val;
|
|
int deviceId;
|
|
int peerDeviceId;
|
|
} hipDeviceCanAccessPeer;
|
|
struct {
|
|
int* major;
|
|
int major__val;
|
|
int* minor;
|
|
int minor__val;
|
|
hipDevice_t device;
|
|
} hipDeviceComputeCapability;
|
|
struct {
|
|
int peerDeviceId;
|
|
} hipDeviceDisablePeerAccess;
|
|
struct {
|
|
int peerDeviceId;
|
|
unsigned int flags;
|
|
} hipDeviceEnablePeerAccess;
|
|
struct {
|
|
hipDevice_t* device;
|
|
hipDevice_t device__val;
|
|
int ordinal;
|
|
} hipDeviceGet;
|
|
struct {
|
|
int* pi;
|
|
int pi__val;
|
|
hipDeviceAttribute_t attr;
|
|
int deviceId;
|
|
} hipDeviceGetAttribute;
|
|
struct {
|
|
int* device;
|
|
int device__val;
|
|
const char* pciBusId;
|
|
char pciBusId__val;
|
|
} hipDeviceGetByPCIBusId;
|
|
struct {
|
|
hipFuncCache_t* cacheConfig;
|
|
hipFuncCache_t cacheConfig__val;
|
|
} hipDeviceGetCacheConfig;
|
|
struct {
|
|
hipMemPool_t* mem_pool;
|
|
hipMemPool_t mem_pool__val;
|
|
int device;
|
|
} hipDeviceGetDefaultMemPool;
|
|
struct {
|
|
int device;
|
|
hipGraphMemAttributeType attr;
|
|
void* value;
|
|
} hipDeviceGetGraphMemAttribute;
|
|
struct {
|
|
size_t* pValue;
|
|
size_t pValue__val;
|
|
enum hipLimit_t limit;
|
|
} hipDeviceGetLimit;
|
|
struct {
|
|
hipMemPool_t* mem_pool;
|
|
hipMemPool_t mem_pool__val;
|
|
int device;
|
|
} hipDeviceGetMemPool;
|
|
struct {
|
|
char* name;
|
|
char name__val;
|
|
int len;
|
|
hipDevice_t device;
|
|
} hipDeviceGetName;
|
|
struct {
|
|
int* value;
|
|
int value__val;
|
|
hipDeviceP2PAttr attr;
|
|
int srcDevice;
|
|
int dstDevice;
|
|
} hipDeviceGetP2PAttribute;
|
|
struct {
|
|
char* pciBusId;
|
|
char pciBusId__val;
|
|
int len;
|
|
int device;
|
|
} hipDeviceGetPCIBusId;
|
|
struct {
|
|
hipSharedMemConfig* pConfig;
|
|
hipSharedMemConfig pConfig__val;
|
|
} hipDeviceGetSharedMemConfig;
|
|
struct {
|
|
int* leastPriority;
|
|
int leastPriority__val;
|
|
int* greatestPriority;
|
|
int greatestPriority__val;
|
|
} hipDeviceGetStreamPriorityRange;
|
|
struct {
|
|
hipUUID* uuid;
|
|
hipUUID uuid__val;
|
|
hipDevice_t device;
|
|
} hipDeviceGetUuid;
|
|
struct {
|
|
int device;
|
|
} hipDeviceGraphMemTrim;
|
|
struct {
|
|
hipDevice_t dev;
|
|
unsigned int* flags;
|
|
unsigned int flags__val;
|
|
int* active;
|
|
int active__val;
|
|
} hipDevicePrimaryCtxGetState;
|
|
struct {
|
|
hipDevice_t dev;
|
|
} hipDevicePrimaryCtxRelease;
|
|
struct {
|
|
hipDevice_t dev;
|
|
} hipDevicePrimaryCtxReset;
|
|
struct {
|
|
hipCtx_t* pctx;
|
|
hipCtx_t pctx__val;
|
|
hipDevice_t dev;
|
|
} hipDevicePrimaryCtxRetain;
|
|
struct {
|
|
hipDevice_t dev;
|
|
unsigned int flags;
|
|
} hipDevicePrimaryCtxSetFlags;
|
|
struct {
|
|
hipFuncCache_t cacheConfig;
|
|
} hipDeviceSetCacheConfig;
|
|
struct {
|
|
int device;
|
|
hipGraphMemAttributeType attr;
|
|
void* value;
|
|
} hipDeviceSetGraphMemAttribute;
|
|
struct {
|
|
enum hipLimit_t limit;
|
|
size_t value;
|
|
} hipDeviceSetLimit;
|
|
struct {
|
|
int device;
|
|
hipMemPool_t mem_pool;
|
|
} hipDeviceSetMemPool;
|
|
struct {
|
|
hipSharedMemConfig config;
|
|
} hipDeviceSetSharedMemConfig;
|
|
struct {
|
|
size_t* bytes;
|
|
size_t bytes__val;
|
|
hipDevice_t device;
|
|
} hipDeviceTotalMem;
|
|
struct {
|
|
int* driverVersion;
|
|
int driverVersion__val;
|
|
} hipDriverGetVersion;
|
|
struct {
|
|
const hip_Memcpy2D* pCopy;
|
|
hip_Memcpy2D pCopy__val;
|
|
} hipDrvMemcpy2DUnaligned;
|
|
struct {
|
|
const HIP_MEMCPY3D* pCopy;
|
|
HIP_MEMCPY3D pCopy__val;
|
|
} hipDrvMemcpy3D;
|
|
struct {
|
|
const HIP_MEMCPY3D* pCopy;
|
|
HIP_MEMCPY3D pCopy__val;
|
|
hipStream_t stream;
|
|
} hipDrvMemcpy3DAsync;
|
|
struct {
|
|
unsigned int numAttributes;
|
|
hipPointer_attribute* attributes;
|
|
hipPointer_attribute attributes__val;
|
|
void** data;
|
|
void* data__val;
|
|
hipDeviceptr_t ptr;
|
|
} hipDrvPointerGetAttributes;
|
|
struct {
|
|
hipEvent_t* event;
|
|
hipEvent_t event__val;
|
|
} hipEventCreate;
|
|
struct {
|
|
hipEvent_t* event;
|
|
hipEvent_t event__val;
|
|
unsigned int flags;
|
|
} hipEventCreateWithFlags;
|
|
struct {
|
|
hipEvent_t event;
|
|
} hipEventDestroy;
|
|
struct {
|
|
float* ms;
|
|
float ms__val;
|
|
hipEvent_t start;
|
|
hipEvent_t stop;
|
|
} hipEventElapsedTime;
|
|
struct {
|
|
hipEvent_t event;
|
|
} hipEventQuery;
|
|
struct {
|
|
hipEvent_t event;
|
|
hipStream_t stream;
|
|
} hipEventRecord;
|
|
struct {
|
|
hipEvent_t event;
|
|
} hipEventSynchronize;
|
|
struct {
|
|
int device1;
|
|
int device2;
|
|
unsigned int* linktype;
|
|
unsigned int linktype__val;
|
|
unsigned int* hopcount;
|
|
unsigned int hopcount__val;
|
|
} hipExtGetLinkTypeAndHopCount;
|
|
struct {
|
|
const void* function_address;
|
|
dim3 numBlocks;
|
|
dim3 dimBlocks;
|
|
void** args;
|
|
void* args__val;
|
|
size_t sharedMemBytes;
|
|
hipStream_t stream;
|
|
hipEvent_t startEvent;
|
|
hipEvent_t stopEvent;
|
|
int flags;
|
|
} hipExtLaunchKernel;
|
|
struct {
|
|
hipLaunchParams* launchParamsList;
|
|
hipLaunchParams launchParamsList__val;
|
|
int numDevices;
|
|
unsigned int flags;
|
|
} hipExtLaunchMultiKernelMultiDevice;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t sizeBytes;
|
|
unsigned int flags;
|
|
} hipExtMallocWithFlags;
|
|
struct {
|
|
hipFunction_t f;
|
|
unsigned int globalWorkSizeX;
|
|
unsigned int globalWorkSizeY;
|
|
unsigned int globalWorkSizeZ;
|
|
unsigned int localWorkSizeX;
|
|
unsigned int localWorkSizeY;
|
|
unsigned int localWorkSizeZ;
|
|
size_t sharedMemBytes;
|
|
hipStream_t hStream;
|
|
void** kernelParams;
|
|
void* kernelParams__val;
|
|
void** extra;
|
|
void* extra__val;
|
|
hipEvent_t startEvent;
|
|
hipEvent_t stopEvent;
|
|
unsigned int flags;
|
|
} hipExtModuleLaunchKernel;
|
|
struct {
|
|
hipStream_t* stream;
|
|
hipStream_t stream__val;
|
|
unsigned int cuMaskSize;
|
|
const unsigned int* cuMask;
|
|
unsigned int cuMask__val;
|
|
} hipExtStreamCreateWithCUMask;
|
|
struct {
|
|
hipStream_t stream;
|
|
unsigned int cuMaskSize;
|
|
unsigned int* cuMask;
|
|
unsigned int cuMask__val;
|
|
} hipExtStreamGetCUMask;
|
|
struct {
|
|
void** devPtr;
|
|
void* devPtr__val;
|
|
hipExternalMemory_t extMem;
|
|
const hipExternalMemoryBufferDesc* bufferDesc;
|
|
hipExternalMemoryBufferDesc bufferDesc__val;
|
|
} hipExternalMemoryGetMappedBuffer;
|
|
struct {
|
|
void* ptr;
|
|
} hipFree;
|
|
struct {
|
|
hipArray* array;
|
|
hipArray array__val;
|
|
} hipFreeArray;
|
|
struct {
|
|
void* dev_ptr;
|
|
hipStream_t stream;
|
|
} hipFreeAsync;
|
|
struct {
|
|
void* ptr;
|
|
} hipFreeHost;
|
|
struct {
|
|
hipMipmappedArray_t mipmappedArray;
|
|
} hipFreeMipmappedArray;
|
|
struct {
|
|
int* value;
|
|
int value__val;
|
|
hipFunction_attribute attrib;
|
|
hipFunction_t hfunc;
|
|
} hipFuncGetAttribute;
|
|
struct {
|
|
hipFuncAttributes* attr;
|
|
hipFuncAttributes attr__val;
|
|
const void* func;
|
|
} hipFuncGetAttributes;
|
|
struct {
|
|
const void* func;
|
|
hipFuncAttribute attr;
|
|
int value;
|
|
} hipFuncSetAttribute;
|
|
struct {
|
|
const void* func;
|
|
hipFuncCache_t config;
|
|
} hipFuncSetCacheConfig;
|
|
struct {
|
|
const void* func;
|
|
hipSharedMemConfig config;
|
|
} hipFuncSetSharedMemConfig;
|
|
struct {
|
|
unsigned int* pHipDeviceCount;
|
|
unsigned int pHipDeviceCount__val;
|
|
int* pHipDevices;
|
|
int pHipDevices__val;
|
|
unsigned int hipDeviceCount;
|
|
hipGLDeviceList deviceList;
|
|
} hipGLGetDevices;
|
|
struct {
|
|
hipChannelFormatDesc* desc;
|
|
hipChannelFormatDesc desc__val;
|
|
hipArray_const_t array;
|
|
} hipGetChannelDesc;
|
|
struct {
|
|
int* deviceId;
|
|
int deviceId__val;
|
|
} hipGetDevice;
|
|
struct {
|
|
int* count;
|
|
int count__val;
|
|
} hipGetDeviceCount;
|
|
struct {
|
|
unsigned int* flags;
|
|
unsigned int flags__val;
|
|
} hipGetDeviceFlags;
|
|
struct {
|
|
hipDeviceProp_t* props;
|
|
hipDeviceProp_t props__val;
|
|
hipDevice_t device;
|
|
} hipGetDeviceProperties;
|
|
struct {
|
|
hipArray_t* levelArray;
|
|
hipArray_t levelArray__val;
|
|
hipMipmappedArray_const_t mipmappedArray;
|
|
unsigned int level;
|
|
} hipGetMipmappedArrayLevel;
|
|
struct {
|
|
void** devPtr;
|
|
void* devPtr__val;
|
|
const void* symbol;
|
|
} hipGetSymbolAddress;
|
|
struct {
|
|
size_t* size;
|
|
size_t size__val;
|
|
const void* symbol;
|
|
} hipGetSymbolSize;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
hipGraph_t childGraph;
|
|
} hipGraphAddChildGraphNode;
|
|
struct {
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* from;
|
|
hipGraphNode_t from__val;
|
|
const hipGraphNode_t* to;
|
|
hipGraphNode_t to__val;
|
|
size_t numDependencies;
|
|
} hipGraphAddDependencies;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
} hipGraphAddEmptyNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
hipEvent_t event;
|
|
} hipGraphAddEventRecordNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
hipEvent_t event;
|
|
} hipGraphAddEventWaitNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const hipHostNodeParams* pNodeParams;
|
|
hipHostNodeParams pNodeParams__val;
|
|
} hipGraphAddHostNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const hipKernelNodeParams* pNodeParams;
|
|
hipKernelNodeParams pNodeParams__val;
|
|
} hipGraphAddKernelNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
hipMemAllocNodeParams* pNodeParams;
|
|
hipMemAllocNodeParams pNodeParams__val;
|
|
} hipGraphAddMemAllocNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
void* dev_ptr;
|
|
} hipGraphAddMemFreeNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const hipMemcpy3DParms* pCopyParams;
|
|
hipMemcpy3DParms pCopyParams__val;
|
|
} hipGraphAddMemcpyNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
void* dst;
|
|
const void* src;
|
|
size_t count;
|
|
hipMemcpyKind kind;
|
|
} hipGraphAddMemcpyNode1D;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
void* dst;
|
|
const void* symbol;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphAddMemcpyNodeFromSymbol;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const void* symbol;
|
|
const void* src;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphAddMemcpyNodeToSymbol;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const hipMemsetParams* pMemsetParams;
|
|
hipMemsetParams pMemsetParams__val;
|
|
} hipGraphAddMemsetNode;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipGraph_t* pGraph;
|
|
hipGraph_t pGraph__val;
|
|
} hipGraphChildGraphNodeGetGraph;
|
|
struct {
|
|
hipGraph_t* pGraphClone;
|
|
hipGraph_t pGraphClone__val;
|
|
hipGraph_t originalGraph;
|
|
} hipGraphClone;
|
|
struct {
|
|
hipGraph_t* pGraph;
|
|
hipGraph_t pGraph__val;
|
|
unsigned int flags;
|
|
} hipGraphCreate;
|
|
struct {
|
|
hipGraph_t graph;
|
|
const char* path;
|
|
char path__val;
|
|
unsigned int flags;
|
|
} hipGraphDebugDotPrint;
|
|
struct {
|
|
hipGraph_t graph;
|
|
} hipGraphDestroy;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
} hipGraphDestroyNode;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipEvent_t* event_out;
|
|
hipEvent_t event_out__val;
|
|
} hipGraphEventRecordNodeGetEvent;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipEvent_t event;
|
|
} hipGraphEventRecordNodeSetEvent;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipEvent_t* event_out;
|
|
hipEvent_t event_out__val;
|
|
} hipGraphEventWaitNodeGetEvent;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipEvent_t event;
|
|
} hipGraphEventWaitNodeSetEvent;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
hipGraph_t childGraph;
|
|
} hipGraphExecChildGraphNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t graphExec;
|
|
} hipGraphExecDestroy;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
hipEvent_t event;
|
|
} hipGraphExecEventRecordNodeSetEvent;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
hipEvent_t event;
|
|
} hipGraphExecEventWaitNodeSetEvent;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
const hipHostNodeParams* pNodeParams;
|
|
hipHostNodeParams pNodeParams__val;
|
|
} hipGraphExecHostNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
const hipKernelNodeParams* pNodeParams;
|
|
hipKernelNodeParams pNodeParams__val;
|
|
} hipGraphExecKernelNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
hipMemcpy3DParms* pNodeParams;
|
|
hipMemcpy3DParms pNodeParams__val;
|
|
} hipGraphExecMemcpyNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
void* dst;
|
|
const void* src;
|
|
size_t count;
|
|
hipMemcpyKind kind;
|
|
} hipGraphExecMemcpyNodeSetParams1D;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
void* dst;
|
|
const void* symbol;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphExecMemcpyNodeSetParamsFromSymbol;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
const void* symbol;
|
|
const void* src;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphExecMemcpyNodeSetParamsToSymbol;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t node;
|
|
const hipMemsetParams* pNodeParams;
|
|
hipMemsetParams pNodeParams__val;
|
|
} hipGraphExecMemsetNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraph_t hGraph;
|
|
hipGraphNode_t* hErrorNode_out;
|
|
hipGraphNode_t hErrorNode_out__val;
|
|
hipGraphExecUpdateResult* updateResult_out;
|
|
hipGraphExecUpdateResult updateResult_out__val;
|
|
} hipGraphExecUpdate;
|
|
struct {
|
|
hipGraph_t graph;
|
|
hipGraphNode_t* from;
|
|
hipGraphNode_t from__val;
|
|
hipGraphNode_t* to;
|
|
hipGraphNode_t to__val;
|
|
size_t* numEdges;
|
|
size_t numEdges__val;
|
|
} hipGraphGetEdges;
|
|
struct {
|
|
hipGraph_t graph;
|
|
hipGraphNode_t* nodes;
|
|
hipGraphNode_t nodes__val;
|
|
size_t* numNodes;
|
|
size_t numNodes__val;
|
|
} hipGraphGetNodes;
|
|
struct {
|
|
hipGraph_t graph;
|
|
hipGraphNode_t* pRootNodes;
|
|
hipGraphNode_t pRootNodes__val;
|
|
size_t* pNumRootNodes;
|
|
size_t pNumRootNodes__val;
|
|
} hipGraphGetRootNodes;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipHostNodeParams* pNodeParams;
|
|
hipHostNodeParams pNodeParams__val;
|
|
} hipGraphHostNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
const hipHostNodeParams* pNodeParams;
|
|
hipHostNodeParams pNodeParams__val;
|
|
} hipGraphHostNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t* pGraphExec;
|
|
hipGraphExec_t pGraphExec__val;
|
|
hipGraph_t graph;
|
|
hipGraphNode_t* pErrorNode;
|
|
hipGraphNode_t pErrorNode__val;
|
|
char* pLogBuffer;
|
|
char pLogBuffer__val;
|
|
size_t bufferSize;
|
|
} hipGraphInstantiate;
|
|
struct {
|
|
hipGraphExec_t* pGraphExec;
|
|
hipGraphExec_t pGraphExec__val;
|
|
hipGraph_t graph;
|
|
unsigned long long flags;
|
|
} hipGraphInstantiateWithFlags;
|
|
struct {
|
|
hipGraphNode_t hSrc;
|
|
hipGraphNode_t hDst;
|
|
} hipGraphKernelNodeCopyAttributes;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipKernelNodeAttrID attr;
|
|
hipKernelNodeAttrValue* value;
|
|
hipKernelNodeAttrValue value__val;
|
|
} hipGraphKernelNodeGetAttribute;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipKernelNodeParams* pNodeParams;
|
|
hipKernelNodeParams pNodeParams__val;
|
|
} hipGraphKernelNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipKernelNodeAttrID attr;
|
|
const hipKernelNodeAttrValue* value;
|
|
hipKernelNodeAttrValue value__val;
|
|
} hipGraphKernelNodeSetAttribute;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
const hipKernelNodeParams* pNodeParams;
|
|
hipKernelNodeParams pNodeParams__val;
|
|
} hipGraphKernelNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t graphExec;
|
|
hipStream_t stream;
|
|
} hipGraphLaunch;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipMemAllocNodeParams* pNodeParams;
|
|
hipMemAllocNodeParams pNodeParams__val;
|
|
} hipGraphMemAllocNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
void* dev_ptr;
|
|
} hipGraphMemFreeNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipMemcpy3DParms* pNodeParams;
|
|
hipMemcpy3DParms pNodeParams__val;
|
|
} hipGraphMemcpyNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
const hipMemcpy3DParms* pNodeParams;
|
|
hipMemcpy3DParms pNodeParams__val;
|
|
} hipGraphMemcpyNodeSetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
void* dst;
|
|
const void* src;
|
|
size_t count;
|
|
hipMemcpyKind kind;
|
|
} hipGraphMemcpyNodeSetParams1D;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
void* dst;
|
|
const void* symbol;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphMemcpyNodeSetParamsFromSymbol;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
const void* symbol;
|
|
const void* src;
|
|
size_t count;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipGraphMemcpyNodeSetParamsToSymbol;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipMemsetParams* pNodeParams;
|
|
hipMemsetParams pNodeParams__val;
|
|
} hipGraphMemsetNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
const hipMemsetParams* pNodeParams;
|
|
hipMemsetParams pNodeParams__val;
|
|
} hipGraphMemsetNodeSetParams;
|
|
struct {
|
|
hipGraphNode_t* pNode;
|
|
hipGraphNode_t pNode__val;
|
|
hipGraphNode_t originalNode;
|
|
hipGraph_t clonedGraph;
|
|
} hipGraphNodeFindInClone;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t* pNumDependencies;
|
|
size_t pNumDependencies__val;
|
|
} hipGraphNodeGetDependencies;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipGraphNode_t* pDependentNodes;
|
|
hipGraphNode_t pDependentNodes__val;
|
|
size_t* pNumDependentNodes;
|
|
size_t pNumDependentNodes__val;
|
|
} hipGraphNodeGetDependentNodes;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
unsigned int* isEnabled;
|
|
unsigned int isEnabled__val;
|
|
} hipGraphNodeGetEnabled;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipGraphNodeType* pType;
|
|
hipGraphNodeType pType__val;
|
|
} hipGraphNodeGetType;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
unsigned int isEnabled;
|
|
} hipGraphNodeSetEnabled;
|
|
struct {
|
|
hipGraph_t graph;
|
|
hipUserObject_t object;
|
|
unsigned int count;
|
|
} hipGraphReleaseUserObject;
|
|
struct {
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* from;
|
|
hipGraphNode_t from__val;
|
|
const hipGraphNode_t* to;
|
|
hipGraphNode_t to__val;
|
|
size_t numDependencies;
|
|
} hipGraphRemoveDependencies;
|
|
struct {
|
|
hipGraph_t graph;
|
|
hipUserObject_t object;
|
|
unsigned int count;
|
|
unsigned int flags;
|
|
} hipGraphRetainUserObject;
|
|
struct {
|
|
hipGraphExec_t graphExec;
|
|
hipStream_t stream;
|
|
} hipGraphUpload;
|
|
struct {
|
|
hipGraphicsResource** resource;
|
|
hipGraphicsResource* resource__val;
|
|
GLuint buffer;
|
|
unsigned int flags;
|
|
} hipGraphicsGLRegisterBuffer;
|
|
struct {
|
|
hipGraphicsResource** resource;
|
|
hipGraphicsResource* resource__val;
|
|
GLuint image;
|
|
GLenum target;
|
|
unsigned int flags;
|
|
} hipGraphicsGLRegisterImage;
|
|
struct {
|
|
int count;
|
|
hipGraphicsResource_t* resources;
|
|
hipGraphicsResource_t resources__val;
|
|
hipStream_t stream;
|
|
} hipGraphicsMapResources;
|
|
struct {
|
|
void** devPtr;
|
|
void* devPtr__val;
|
|
size_t* size;
|
|
size_t size__val;
|
|
hipGraphicsResource_t resource;
|
|
} hipGraphicsResourceGetMappedPointer;
|
|
struct {
|
|
hipArray_t* array;
|
|
hipArray_t array__val;
|
|
hipGraphicsResource_t resource;
|
|
unsigned int arrayIndex;
|
|
unsigned int mipLevel;
|
|
} hipGraphicsSubResourceGetMappedArray;
|
|
struct {
|
|
int count;
|
|
hipGraphicsResource_t* resources;
|
|
hipGraphicsResource_t resources__val;
|
|
hipStream_t stream;
|
|
} hipGraphicsUnmapResources;
|
|
struct {
|
|
hipGraphicsResource_t resource;
|
|
} hipGraphicsUnregisterResource;
|
|
struct {
|
|
hipFunction_t f;
|
|
unsigned int globalWorkSizeX;
|
|
unsigned int globalWorkSizeY;
|
|
unsigned int globalWorkSizeZ;
|
|
unsigned int blockDimX;
|
|
unsigned int blockDimY;
|
|
unsigned int blockDimZ;
|
|
size_t sharedMemBytes;
|
|
hipStream_t hStream;
|
|
void** kernelParams;
|
|
void* kernelParams__val;
|
|
void** extra;
|
|
void* extra__val;
|
|
hipEvent_t startEvent;
|
|
hipEvent_t stopEvent;
|
|
} hipHccModuleLaunchKernel;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
unsigned int flags;
|
|
} hipHostAlloc;
|
|
struct {
|
|
void* ptr;
|
|
} hipHostFree;
|
|
struct {
|
|
void** devPtr;
|
|
void* devPtr__val;
|
|
void* hstPtr;
|
|
unsigned int flags;
|
|
} hipHostGetDevicePointer;
|
|
struct {
|
|
unsigned int* flagsPtr;
|
|
unsigned int flagsPtr__val;
|
|
void* hostPtr;
|
|
} hipHostGetFlags;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
unsigned int flags;
|
|
} hipHostMalloc;
|
|
struct {
|
|
void* hostPtr;
|
|
size_t sizeBytes;
|
|
unsigned int flags;
|
|
} hipHostRegister;
|
|
struct {
|
|
void* hostPtr;
|
|
} hipHostUnregister;
|
|
struct {
|
|
hipExternalMemory_t* extMem_out;
|
|
hipExternalMemory_t extMem_out__val;
|
|
const hipExternalMemoryHandleDesc* memHandleDesc;
|
|
hipExternalMemoryHandleDesc memHandleDesc__val;
|
|
} hipImportExternalMemory;
|
|
struct {
|
|
hipExternalSemaphore_t* extSem_out;
|
|
hipExternalSemaphore_t extSem_out__val;
|
|
const hipExternalSemaphoreHandleDesc* semHandleDesc;
|
|
hipExternalSemaphoreHandleDesc semHandleDesc__val;
|
|
} hipImportExternalSemaphore;
|
|
struct {
|
|
unsigned int flags;
|
|
} hipInit;
|
|
struct {
|
|
void* devPtr;
|
|
} hipIpcCloseMemHandle;
|
|
struct {
|
|
hipIpcEventHandle_t* handle;
|
|
hipIpcEventHandle_t handle__val;
|
|
hipEvent_t event;
|
|
} hipIpcGetEventHandle;
|
|
struct {
|
|
hipIpcMemHandle_t* handle;
|
|
hipIpcMemHandle_t handle__val;
|
|
void* devPtr;
|
|
} hipIpcGetMemHandle;
|
|
struct {
|
|
hipEvent_t* event;
|
|
hipEvent_t event__val;
|
|
hipIpcEventHandle_t handle;
|
|
} hipIpcOpenEventHandle;
|
|
struct {
|
|
void** devPtr;
|
|
void* devPtr__val;
|
|
hipIpcMemHandle_t handle;
|
|
unsigned int flags;
|
|
} hipIpcOpenMemHandle;
|
|
struct {
|
|
const void* hostFunction;
|
|
} hipLaunchByPtr;
|
|
struct {
|
|
const void* f;
|
|
dim3 gridDim;
|
|
dim3 blockDimX;
|
|
void** kernelParams;
|
|
void* kernelParams__val;
|
|
unsigned int sharedMemBytes;
|
|
hipStream_t stream;
|
|
} hipLaunchCooperativeKernel;
|
|
struct {
|
|
hipLaunchParams* launchParamsList;
|
|
hipLaunchParams launchParamsList__val;
|
|
int numDevices;
|
|
unsigned int flags;
|
|
} hipLaunchCooperativeKernelMultiDevice;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipHostFn_t fn;
|
|
void* userData;
|
|
} hipLaunchHostFunc;
|
|
struct {
|
|
const void* function_address;
|
|
dim3 numBlocks;
|
|
dim3 dimBlocks;
|
|
void** args;
|
|
void* args__val;
|
|
size_t sharedMemBytes;
|
|
hipStream_t stream;
|
|
} hipLaunchKernel;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
} hipMalloc;
|
|
struct {
|
|
hipPitchedPtr* pitchedDevPtr;
|
|
hipPitchedPtr pitchedDevPtr__val;
|
|
hipExtent extent;
|
|
} hipMalloc3D;
|
|
struct {
|
|
hipArray_t* array;
|
|
hipArray_t array__val;
|
|
const hipChannelFormatDesc* desc;
|
|
hipChannelFormatDesc desc__val;
|
|
hipExtent extent;
|
|
unsigned int flags;
|
|
} hipMalloc3DArray;
|
|
struct {
|
|
hipArray** array;
|
|
hipArray* array__val;
|
|
const hipChannelFormatDesc* desc;
|
|
hipChannelFormatDesc desc__val;
|
|
size_t width;
|
|
size_t height;
|
|
unsigned int flags;
|
|
} hipMallocArray;
|
|
struct {
|
|
void** dev_ptr;
|
|
void* dev_ptr__val;
|
|
size_t size;
|
|
hipStream_t stream;
|
|
} hipMallocAsync;
|
|
struct {
|
|
void** dev_ptr;
|
|
void* dev_ptr__val;
|
|
size_t size;
|
|
hipMemPool_t mem_pool;
|
|
hipStream_t stream;
|
|
} hipMallocFromPoolAsync;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
} hipMallocHost;
|
|
struct {
|
|
void** dev_ptr;
|
|
void* dev_ptr__val;
|
|
size_t size;
|
|
unsigned int flags;
|
|
} hipMallocManaged;
|
|
struct {
|
|
hipMipmappedArray_t* mipmappedArray;
|
|
hipMipmappedArray_t mipmappedArray__val;
|
|
const hipChannelFormatDesc* desc;
|
|
hipChannelFormatDesc desc__val;
|
|
hipExtent extent;
|
|
unsigned int numLevels;
|
|
unsigned int flags;
|
|
} hipMallocMipmappedArray;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t* pitch;
|
|
size_t pitch__val;
|
|
size_t width;
|
|
size_t height;
|
|
} hipMallocPitch;
|
|
struct {
|
|
void* devPtr;
|
|
size_t size;
|
|
} hipMemAddressFree;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
size_t alignment;
|
|
void* addr;
|
|
unsigned long long flags;
|
|
} hipMemAddressReserve;
|
|
struct {
|
|
const void* dev_ptr;
|
|
size_t count;
|
|
hipMemoryAdvise advice;
|
|
int device;
|
|
} hipMemAdvise;
|
|
struct {
|
|
void** ptr;
|
|
void* ptr__val;
|
|
size_t size;
|
|
} hipMemAllocHost;
|
|
struct {
|
|
hipDeviceptr_t* dptr;
|
|
hipDeviceptr_t dptr__val;
|
|
size_t* pitch;
|
|
size_t pitch__val;
|
|
size_t widthInBytes;
|
|
size_t height;
|
|
unsigned int elementSizeBytes;
|
|
} hipMemAllocPitch;
|
|
struct {
|
|
hipMemGenericAllocationHandle_t* handle;
|
|
hipMemGenericAllocationHandle_t handle__val;
|
|
size_t size;
|
|
const hipMemAllocationProp* prop;
|
|
hipMemAllocationProp prop__val;
|
|
unsigned long long flags;
|
|
} hipMemCreate;
|
|
struct {
|
|
void* shareableHandle;
|
|
hipMemGenericAllocationHandle_t handle;
|
|
hipMemAllocationHandleType handleType;
|
|
unsigned long long flags;
|
|
} hipMemExportToShareableHandle;
|
|
struct {
|
|
unsigned long long* flags;
|
|
unsigned long long flags__val;
|
|
const hipMemLocation* location;
|
|
hipMemLocation location__val;
|
|
void* ptr;
|
|
} hipMemGetAccess;
|
|
struct {
|
|
hipDeviceptr_t* pbase;
|
|
hipDeviceptr_t pbase__val;
|
|
size_t* psize;
|
|
size_t psize__val;
|
|
hipDeviceptr_t dptr;
|
|
} hipMemGetAddressRange;
|
|
struct {
|
|
size_t* granularity;
|
|
size_t granularity__val;
|
|
const hipMemAllocationProp* prop;
|
|
hipMemAllocationProp prop__val;
|
|
hipMemAllocationGranularity_flags option;
|
|
} hipMemGetAllocationGranularity;
|
|
struct {
|
|
hipMemAllocationProp* prop;
|
|
hipMemAllocationProp prop__val;
|
|
hipMemGenericAllocationHandle_t handle;
|
|
} hipMemGetAllocationPropertiesFromHandle;
|
|
struct {
|
|
size_t* free;
|
|
size_t free__val;
|
|
size_t* total;
|
|
size_t total__val;
|
|
} hipMemGetInfo;
|
|
struct {
|
|
hipMemGenericAllocationHandle_t* handle;
|
|
hipMemGenericAllocationHandle_t handle__val;
|
|
void* osHandle;
|
|
hipMemAllocationHandleType shHandleType;
|
|
} hipMemImportFromShareableHandle;
|
|
struct {
|
|
void* ptr;
|
|
size_t size;
|
|
size_t offset;
|
|
hipMemGenericAllocationHandle_t handle;
|
|
unsigned long long flags;
|
|
} hipMemMap;
|
|
struct {
|
|
hipArrayMapInfo* mapInfoList;
|
|
hipArrayMapInfo mapInfoList__val;
|
|
unsigned int count;
|
|
hipStream_t stream;
|
|
} hipMemMapArrayAsync;
|
|
struct {
|
|
hipMemPool_t* mem_pool;
|
|
hipMemPool_t mem_pool__val;
|
|
const hipMemPoolProps* pool_props;
|
|
hipMemPoolProps pool_props__val;
|
|
} hipMemPoolCreate;
|
|
struct {
|
|
hipMemPool_t mem_pool;
|
|
} hipMemPoolDestroy;
|
|
struct {
|
|
hipMemPoolPtrExportData* export_data;
|
|
hipMemPoolPtrExportData export_data__val;
|
|
void* dev_ptr;
|
|
} hipMemPoolExportPointer;
|
|
struct {
|
|
void* shared_handle;
|
|
hipMemPool_t mem_pool;
|
|
hipMemAllocationHandleType handle_type;
|
|
unsigned int flags;
|
|
} hipMemPoolExportToShareableHandle;
|
|
struct {
|
|
hipMemAccessFlags* flags;
|
|
hipMemAccessFlags flags__val;
|
|
hipMemPool_t mem_pool;
|
|
hipMemLocation* location;
|
|
hipMemLocation location__val;
|
|
} hipMemPoolGetAccess;
|
|
struct {
|
|
hipMemPool_t mem_pool;
|
|
hipMemPoolAttr attr;
|
|
void* value;
|
|
} hipMemPoolGetAttribute;
|
|
struct {
|
|
hipMemPool_t* mem_pool;
|
|
hipMemPool_t mem_pool__val;
|
|
void* shared_handle;
|
|
hipMemAllocationHandleType handle_type;
|
|
unsigned int flags;
|
|
} hipMemPoolImportFromShareableHandle;
|
|
struct {
|
|
void** dev_ptr;
|
|
void* dev_ptr__val;
|
|
hipMemPool_t mem_pool;
|
|
hipMemPoolPtrExportData* export_data;
|
|
hipMemPoolPtrExportData export_data__val;
|
|
} hipMemPoolImportPointer;
|
|
struct {
|
|
hipMemPool_t mem_pool;
|
|
const hipMemAccessDesc* desc_list;
|
|
hipMemAccessDesc desc_list__val;
|
|
size_t count;
|
|
} hipMemPoolSetAccess;
|
|
struct {
|
|
hipMemPool_t mem_pool;
|
|
hipMemPoolAttr attr;
|
|
void* value;
|
|
} hipMemPoolSetAttribute;
|
|
struct {
|
|
hipMemPool_t mem_pool;
|
|
size_t min_bytes_to_hold;
|
|
} hipMemPoolTrimTo;
|
|
struct {
|
|
const void* dev_ptr;
|
|
size_t count;
|
|
int device;
|
|
hipStream_t stream;
|
|
} hipMemPrefetchAsync;
|
|
struct {
|
|
void* ptr;
|
|
size_t* size;
|
|
size_t size__val;
|
|
} hipMemPtrGetInfo;
|
|
struct {
|
|
void* data;
|
|
size_t data_size;
|
|
hipMemRangeAttribute attribute;
|
|
const void* dev_ptr;
|
|
size_t count;
|
|
} hipMemRangeGetAttribute;
|
|
struct {
|
|
void** data;
|
|
void* data__val;
|
|
size_t* data_sizes;
|
|
size_t data_sizes__val;
|
|
hipMemRangeAttribute* attributes;
|
|
hipMemRangeAttribute attributes__val;
|
|
size_t num_attributes;
|
|
const void* dev_ptr;
|
|
size_t count;
|
|
} hipMemRangeGetAttributes;
|
|
struct {
|
|
hipMemGenericAllocationHandle_t handle;
|
|
} hipMemRelease;
|
|
struct {
|
|
hipMemGenericAllocationHandle_t* handle;
|
|
hipMemGenericAllocationHandle_t handle__val;
|
|
void* addr;
|
|
} hipMemRetainAllocationHandle;
|
|
struct {
|
|
void* ptr;
|
|
size_t size;
|
|
const hipMemAccessDesc* desc;
|
|
hipMemAccessDesc desc__val;
|
|
size_t count;
|
|
} hipMemSetAccess;
|
|
struct {
|
|
void* ptr;
|
|
size_t size;
|
|
} hipMemUnmap;
|
|
struct {
|
|
void* dst;
|
|
const void* src;
|
|
size_t sizeBytes;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy;
|
|
struct {
|
|
void* dst;
|
|
size_t dpitch;
|
|
const void* src;
|
|
size_t spitch;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy2D;
|
|
struct {
|
|
void* dst;
|
|
size_t dpitch;
|
|
const void* src;
|
|
size_t spitch;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpy2DAsync;
|
|
struct {
|
|
void* dst;
|
|
size_t dpitch;
|
|
hipArray_const_t src;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy2DFromArray;
|
|
struct {
|
|
void* dst;
|
|
size_t dpitch;
|
|
hipArray_const_t src;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpy2DFromArrayAsync;
|
|
struct {
|
|
hipArray* dst;
|
|
hipArray dst__val;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
const void* src;
|
|
size_t spitch;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy2DToArray;
|
|
struct {
|
|
hipArray* dst;
|
|
hipArray dst__val;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
const void* src;
|
|
size_t spitch;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpy2DToArrayAsync;
|
|
struct {
|
|
const hipMemcpy3DParms* p;
|
|
hipMemcpy3DParms p__val;
|
|
} hipMemcpy3D;
|
|
struct {
|
|
const hipMemcpy3DParms* p;
|
|
hipMemcpy3DParms p__val;
|
|
hipStream_t stream;
|
|
} hipMemcpy3DAsync;
|
|
struct {
|
|
void* dst;
|
|
const void* src;
|
|
size_t sizeBytes;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpyAsync;
|
|
struct {
|
|
void* dst;
|
|
hipArray* srcArray;
|
|
hipArray srcArray__val;
|
|
size_t srcOffset;
|
|
size_t count;
|
|
} hipMemcpyAtoH;
|
|
struct {
|
|
hipDeviceptr_t dst;
|
|
hipDeviceptr_t src;
|
|
size_t sizeBytes;
|
|
} hipMemcpyDtoD;
|
|
struct {
|
|
hipDeviceptr_t dst;
|
|
hipDeviceptr_t src;
|
|
size_t sizeBytes;
|
|
hipStream_t stream;
|
|
} hipMemcpyDtoDAsync;
|
|
struct {
|
|
void* dst;
|
|
hipDeviceptr_t src;
|
|
size_t sizeBytes;
|
|
} hipMemcpyDtoH;
|
|
struct {
|
|
void* dst;
|
|
hipDeviceptr_t src;
|
|
size_t sizeBytes;
|
|
hipStream_t stream;
|
|
} hipMemcpyDtoHAsync;
|
|
struct {
|
|
void* dst;
|
|
hipArray_const_t srcArray;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
size_t count;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpyFromArray;
|
|
struct {
|
|
void* dst;
|
|
const void* symbol;
|
|
size_t sizeBytes;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpyFromSymbol;
|
|
struct {
|
|
void* dst;
|
|
const void* symbol;
|
|
size_t sizeBytes;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpyFromSymbolAsync;
|
|
struct {
|
|
hipArray* dstArray;
|
|
hipArray dstArray__val;
|
|
size_t dstOffset;
|
|
const void* srcHost;
|
|
size_t count;
|
|
} hipMemcpyHtoA;
|
|
struct {
|
|
hipDeviceptr_t dst;
|
|
void* src;
|
|
size_t sizeBytes;
|
|
} hipMemcpyHtoD;
|
|
struct {
|
|
hipDeviceptr_t dst;
|
|
void* src;
|
|
size_t sizeBytes;
|
|
hipStream_t stream;
|
|
} hipMemcpyHtoDAsync;
|
|
struct {
|
|
const hip_Memcpy2D* pCopy;
|
|
hip_Memcpy2D pCopy__val;
|
|
} hipMemcpyParam2D;
|
|
struct {
|
|
const hip_Memcpy2D* pCopy;
|
|
hip_Memcpy2D pCopy__val;
|
|
hipStream_t stream;
|
|
} hipMemcpyParam2DAsync;
|
|
struct {
|
|
void* dst;
|
|
int dstDeviceId;
|
|
const void* src;
|
|
int srcDeviceId;
|
|
size_t sizeBytes;
|
|
} hipMemcpyPeer;
|
|
struct {
|
|
void* dst;
|
|
int dstDeviceId;
|
|
const void* src;
|
|
int srcDevice;
|
|
size_t sizeBytes;
|
|
hipStream_t stream;
|
|
} hipMemcpyPeerAsync;
|
|
struct {
|
|
hipArray* dst;
|
|
hipArray dst__val;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
const void* src;
|
|
size_t count;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpyToArray;
|
|
struct {
|
|
const void* symbol;
|
|
const void* src;
|
|
size_t sizeBytes;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpyToSymbol;
|
|
struct {
|
|
const void* symbol;
|
|
const void* src;
|
|
size_t sizeBytes;
|
|
size_t offset;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpyToSymbolAsync;
|
|
struct {
|
|
void* dst;
|
|
const void* src;
|
|
size_t sizeBytes;
|
|
hipMemcpyKind kind;
|
|
hipStream_t stream;
|
|
} hipMemcpyWithStream;
|
|
struct {
|
|
void* dst;
|
|
int value;
|
|
size_t sizeBytes;
|
|
} hipMemset;
|
|
struct {
|
|
void* dst;
|
|
size_t pitch;
|
|
int value;
|
|
size_t width;
|
|
size_t height;
|
|
} hipMemset2D;
|
|
struct {
|
|
void* dst;
|
|
size_t pitch;
|
|
int value;
|
|
size_t width;
|
|
size_t height;
|
|
hipStream_t stream;
|
|
} hipMemset2DAsync;
|
|
struct {
|
|
hipPitchedPtr pitchedDevPtr;
|
|
int value;
|
|
hipExtent extent;
|
|
} hipMemset3D;
|
|
struct {
|
|
hipPitchedPtr pitchedDevPtr;
|
|
int value;
|
|
hipExtent extent;
|
|
hipStream_t stream;
|
|
} hipMemset3DAsync;
|
|
struct {
|
|
void* dst;
|
|
int value;
|
|
size_t sizeBytes;
|
|
hipStream_t stream;
|
|
} hipMemsetAsync;
|
|
struct {
|
|
hipDeviceptr_t dest;
|
|
unsigned short value;
|
|
size_t count;
|
|
} hipMemsetD16;
|
|
struct {
|
|
hipDeviceptr_t dest;
|
|
unsigned short value;
|
|
size_t count;
|
|
hipStream_t stream;
|
|
} hipMemsetD16Async;
|
|
struct {
|
|
hipDeviceptr_t dest;
|
|
int value;
|
|
size_t count;
|
|
} hipMemsetD32;
|
|
struct {
|
|
hipDeviceptr_t dst;
|
|
int value;
|
|
size_t count;
|
|
hipStream_t stream;
|
|
} hipMemsetD32Async;
|
|
struct {
|
|
hipDeviceptr_t dest;
|
|
unsigned char value;
|
|
size_t count;
|
|
} hipMemsetD8;
|
|
struct {
|
|
hipDeviceptr_t dest;
|
|
unsigned char value;
|
|
size_t count;
|
|
hipStream_t stream;
|
|
} hipMemsetD8Async;
|
|
struct {
|
|
hipMipmappedArray_t* pHandle;
|
|
hipMipmappedArray_t pHandle__val;
|
|
HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc;
|
|
HIP_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc__val;
|
|
unsigned int numMipmapLevels;
|
|
} hipMipmappedArrayCreate;
|
|
struct {
|
|
hipMipmappedArray_t hMipmappedArray;
|
|
} hipMipmappedArrayDestroy;
|
|
struct {
|
|
hipArray_t* pLevelArray;
|
|
hipArray_t pLevelArray__val;
|
|
hipMipmappedArray_t hMipMappedArray;
|
|
unsigned int level;
|
|
} hipMipmappedArrayGetLevel;
|
|
struct {
|
|
hipFunction_t* function;
|
|
hipFunction_t function__val;
|
|
hipModule_t module;
|
|
const char* kname;
|
|
char kname__val;
|
|
} hipModuleGetFunction;
|
|
struct {
|
|
hipDeviceptr_t* dptr;
|
|
hipDeviceptr_t dptr__val;
|
|
size_t* bytes;
|
|
size_t bytes__val;
|
|
hipModule_t hmod;
|
|
const char* name;
|
|
char name__val;
|
|
} hipModuleGetGlobal;
|
|
struct {
|
|
textureReference** texRef;
|
|
textureReference* texRef__val;
|
|
hipModule_t hmod;
|
|
const char* name;
|
|
char name__val;
|
|
} hipModuleGetTexRef;
|
|
struct {
|
|
hipFunction_t f;
|
|
unsigned int gridDimX;
|
|
unsigned int gridDimY;
|
|
unsigned int gridDimZ;
|
|
unsigned int blockDimX;
|
|
unsigned int blockDimY;
|
|
unsigned int blockDimZ;
|
|
unsigned int sharedMemBytes;
|
|
hipStream_t stream;
|
|
void** kernelParams;
|
|
void* kernelParams__val;
|
|
} hipModuleLaunchCooperativeKernel;
|
|
struct {
|
|
hipFunctionLaunchParams* launchParamsList;
|
|
hipFunctionLaunchParams launchParamsList__val;
|
|
unsigned int numDevices;
|
|
unsigned int flags;
|
|
} hipModuleLaunchCooperativeKernelMultiDevice;
|
|
struct {
|
|
hipFunction_t f;
|
|
unsigned int gridDimX;
|
|
unsigned int gridDimY;
|
|
unsigned int gridDimZ;
|
|
unsigned int blockDimX;
|
|
unsigned int blockDimY;
|
|
unsigned int blockDimZ;
|
|
unsigned int sharedMemBytes;
|
|
hipStream_t stream;
|
|
void** kernelParams;
|
|
void* kernelParams__val;
|
|
void** extra;
|
|
void* extra__val;
|
|
} hipModuleLaunchKernel;
|
|
struct {
|
|
hipModule_t* module;
|
|
hipModule_t module__val;
|
|
const char* fname;
|
|
char fname__val;
|
|
} hipModuleLoad;
|
|
struct {
|
|
hipModule_t* module;
|
|
hipModule_t module__val;
|
|
const void* image;
|
|
} hipModuleLoadData;
|
|
struct {
|
|
hipModule_t* module;
|
|
hipModule_t module__val;
|
|
const void* image;
|
|
unsigned int numOptions;
|
|
hipJitOption* options;
|
|
hipJitOption options__val;
|
|
void** optionsValues;
|
|
void* optionsValues__val;
|
|
} hipModuleLoadDataEx;
|
|
struct {
|
|
int* numBlocks;
|
|
int numBlocks__val;
|
|
hipFunction_t f;
|
|
int blockSize;
|
|
size_t dynSharedMemPerBlk;
|
|
} hipModuleOccupancyMaxActiveBlocksPerMultiprocessor;
|
|
struct {
|
|
int* numBlocks;
|
|
int numBlocks__val;
|
|
hipFunction_t f;
|
|
int blockSize;
|
|
size_t dynSharedMemPerBlk;
|
|
unsigned int flags;
|
|
} hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
|
|
struct {
|
|
int* gridSize;
|
|
int gridSize__val;
|
|
int* blockSize;
|
|
int blockSize__val;
|
|
hipFunction_t f;
|
|
size_t dynSharedMemPerBlk;
|
|
int blockSizeLimit;
|
|
} hipModuleOccupancyMaxPotentialBlockSize;
|
|
struct {
|
|
int* gridSize;
|
|
int gridSize__val;
|
|
int* blockSize;
|
|
int blockSize__val;
|
|
hipFunction_t f;
|
|
size_t dynSharedMemPerBlk;
|
|
int blockSizeLimit;
|
|
unsigned int flags;
|
|
} hipModuleOccupancyMaxPotentialBlockSizeWithFlags;
|
|
struct {
|
|
hipModule_t module;
|
|
} hipModuleUnload;
|
|
struct {
|
|
int* numBlocks;
|
|
int numBlocks__val;
|
|
const void* f;
|
|
int blockSize;
|
|
size_t dynamicSMemSize;
|
|
} hipOccupancyMaxActiveBlocksPerMultiprocessor;
|
|
struct {
|
|
int* numBlocks;
|
|
int numBlocks__val;
|
|
const void* f;
|
|
int blockSize;
|
|
size_t dynamicSMemSize;
|
|
unsigned int flags;
|
|
} hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
|
|
struct {
|
|
int* gridSize;
|
|
int gridSize__val;
|
|
int* blockSize;
|
|
int blockSize__val;
|
|
const void* f;
|
|
size_t dynSharedMemPerBlk;
|
|
int blockSizeLimit;
|
|
} hipOccupancyMaxPotentialBlockSize;
|
|
struct {
|
|
void* data;
|
|
hipPointer_attribute attribute;
|
|
hipDeviceptr_t ptr;
|
|
} hipPointerGetAttribute;
|
|
struct {
|
|
hipPointerAttribute_t* attributes;
|
|
hipPointerAttribute_t attributes__val;
|
|
const void* ptr;
|
|
} hipPointerGetAttributes;
|
|
struct {
|
|
const void* value;
|
|
hipPointer_attribute attribute;
|
|
hipDeviceptr_t ptr;
|
|
} hipPointerSetAttribute;
|
|
struct {
|
|
int* runtimeVersion;
|
|
int runtimeVersion__val;
|
|
} hipRuntimeGetVersion;
|
|
struct {
|
|
int deviceId;
|
|
} hipSetDevice;
|
|
struct {
|
|
unsigned int flags;
|
|
} hipSetDeviceFlags;
|
|
struct {
|
|
const void* arg;
|
|
size_t size;
|
|
size_t offset;
|
|
} hipSetupArgument;
|
|
struct {
|
|
const hipExternalSemaphore_t* extSemArray;
|
|
hipExternalSemaphore_t extSemArray__val;
|
|
const hipExternalSemaphoreSignalParams* paramsArray;
|
|
hipExternalSemaphoreSignalParams paramsArray__val;
|
|
unsigned int numExtSems;
|
|
hipStream_t stream;
|
|
} hipSignalExternalSemaphoresAsync;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCallback_t callback;
|
|
void* userData;
|
|
unsigned int flags;
|
|
} hipStreamAddCallback;
|
|
struct {
|
|
hipStream_t stream;
|
|
void* dev_ptr;
|
|
size_t length;
|
|
unsigned int flags;
|
|
} hipStreamAttachMemAsync;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCaptureMode mode;
|
|
} hipStreamBeginCapture;
|
|
struct {
|
|
hipStream_t* stream;
|
|
hipStream_t stream__val;
|
|
} hipStreamCreate;
|
|
struct {
|
|
hipStream_t* stream;
|
|
hipStream_t stream__val;
|
|
unsigned int flags;
|
|
} hipStreamCreateWithFlags;
|
|
struct {
|
|
hipStream_t* stream;
|
|
hipStream_t stream__val;
|
|
unsigned int flags;
|
|
int priority;
|
|
} hipStreamCreateWithPriority;
|
|
struct {
|
|
hipStream_t stream;
|
|
} hipStreamDestroy;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipGraph_t* pGraph;
|
|
hipGraph_t pGraph__val;
|
|
} hipStreamEndCapture;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCaptureStatus* pCaptureStatus;
|
|
hipStreamCaptureStatus pCaptureStatus__val;
|
|
unsigned long long* pId;
|
|
unsigned long long pId__val;
|
|
} hipStreamGetCaptureInfo;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCaptureStatus* captureStatus_out;
|
|
hipStreamCaptureStatus captureStatus_out__val;
|
|
unsigned long long* id_out;
|
|
unsigned long long id_out__val;
|
|
hipGraph_t* graph_out;
|
|
hipGraph_t graph_out__val;
|
|
const hipGraphNode_t** dependencies_out;
|
|
const hipGraphNode_t* dependencies_out__val;
|
|
size_t* numDependencies_out;
|
|
size_t numDependencies_out__val;
|
|
} hipStreamGetCaptureInfo_v2;
|
|
struct {
|
|
hipStream_t stream;
|
|
unsigned int* flags;
|
|
unsigned int flags__val;
|
|
} hipStreamGetFlags;
|
|
struct {
|
|
hipStream_t stream;
|
|
int* priority;
|
|
int priority__val;
|
|
} hipStreamGetPriority;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCaptureStatus* pCaptureStatus;
|
|
hipStreamCaptureStatus pCaptureStatus__val;
|
|
} hipStreamIsCapturing;
|
|
struct {
|
|
hipStream_t stream;
|
|
} hipStreamQuery;
|
|
struct {
|
|
hipStream_t stream;
|
|
} hipStreamSynchronize;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
size_t numDependencies;
|
|
unsigned int flags;
|
|
} hipStreamUpdateCaptureDependencies;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipEvent_t event;
|
|
unsigned int flags;
|
|
} hipStreamWaitEvent;
|
|
struct {
|
|
hipStream_t stream;
|
|
void* ptr;
|
|
unsigned int value;
|
|
unsigned int flags;
|
|
unsigned int mask;
|
|
} hipStreamWaitValue32;
|
|
struct {
|
|
hipStream_t stream;
|
|
void* ptr;
|
|
uint64_t value;
|
|
unsigned int flags;
|
|
uint64_t mask;
|
|
} hipStreamWaitValue64;
|
|
struct {
|
|
hipStream_t stream;
|
|
void* ptr;
|
|
unsigned int value;
|
|
unsigned int flags;
|
|
} hipStreamWriteValue32;
|
|
struct {
|
|
hipStream_t stream;
|
|
void* ptr;
|
|
uint64_t value;
|
|
unsigned int flags;
|
|
} hipStreamWriteValue64;
|
|
struct {
|
|
hipDeviceptr_t* dev_ptr;
|
|
hipDeviceptr_t dev_ptr__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetAddress;
|
|
struct {
|
|
unsigned int* pFlags;
|
|
unsigned int pFlags__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetFlags;
|
|
struct {
|
|
hipArray_Format* pFormat;
|
|
hipArray_Format pFormat__val;
|
|
int* pNumChannels;
|
|
int pNumChannels__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetFormat;
|
|
struct {
|
|
int* pmaxAnsio;
|
|
int pmaxAnsio__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetMaxAnisotropy;
|
|
struct {
|
|
hipMipmappedArray_t* pArray;
|
|
hipMipmappedArray_t pArray__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetMipMappedArray;
|
|
struct {
|
|
float* pbias;
|
|
float pbias__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetMipmapLevelBias;
|
|
struct {
|
|
float* pminMipmapLevelClamp;
|
|
float pminMipmapLevelClamp__val;
|
|
float* pmaxMipmapLevelClamp;
|
|
float pmaxMipmapLevelClamp__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetMipmapLevelClamp;
|
|
struct {
|
|
size_t* ByteOffset;
|
|
size_t ByteOffset__val;
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
hipDeviceptr_t dptr;
|
|
size_t bytes;
|
|
} hipTexRefSetAddress;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
const HIP_ARRAY_DESCRIPTOR* desc;
|
|
HIP_ARRAY_DESCRIPTOR desc__val;
|
|
hipDeviceptr_t dptr;
|
|
size_t Pitch;
|
|
} hipTexRefSetAddress2D;
|
|
struct {
|
|
textureReference* tex;
|
|
textureReference tex__val;
|
|
hipArray_const_t array;
|
|
unsigned int flags;
|
|
} hipTexRefSetArray;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
float* pBorderColor;
|
|
float pBorderColor__val;
|
|
} hipTexRefSetBorderColor;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
unsigned int Flags;
|
|
} hipTexRefSetFlags;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
hipArray_Format fmt;
|
|
int NumPackedComponents;
|
|
} hipTexRefSetFormat;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
unsigned int maxAniso;
|
|
} hipTexRefSetMaxAnisotropy;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
float bias;
|
|
} hipTexRefSetMipmapLevelBias;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
float minMipMapLevelClamp;
|
|
float maxMipMapLevelClamp;
|
|
} hipTexRefSetMipmapLevelClamp;
|
|
struct {
|
|
textureReference* texRef;
|
|
textureReference texRef__val;
|
|
hipMipmappedArray* mipmappedArray;
|
|
hipMipmappedArray mipmappedArray__val;
|
|
unsigned int Flags;
|
|
} hipTexRefSetMipmappedArray;
|
|
struct {
|
|
hipStreamCaptureMode* mode;
|
|
hipStreamCaptureMode mode__val;
|
|
} hipThreadExchangeStreamCaptureMode;
|
|
struct {
|
|
hipUserObject_t* object_out;
|
|
hipUserObject_t object_out__val;
|
|
void* ptr;
|
|
hipHostFn_t destroy;
|
|
unsigned int initialRefcount;
|
|
unsigned int flags;
|
|
} hipUserObjectCreate;
|
|
struct {
|
|
hipUserObject_t object;
|
|
unsigned int count;
|
|
} hipUserObjectRelease;
|
|
struct {
|
|
hipUserObject_t object;
|
|
unsigned int count;
|
|
} hipUserObjectRetain;
|
|
struct {
|
|
const hipExternalSemaphore_t* extSemArray;
|
|
hipExternalSemaphore_t extSemArray__val;
|
|
const hipExternalSemaphoreWaitParams* paramsArray;
|
|
hipExternalSemaphoreWaitParams paramsArray__val;
|
|
unsigned int numExtSems;
|
|
hipStream_t stream;
|
|
} hipWaitExternalSemaphoresAsync;
|
|
} args;
|
|
uint64_t *phase_data;
|
|
} hip_api_data_t;
|
|
|
|
// HIP API callbacks args data filling macros
|
|
// __hipPopCallConfiguration[('dim3*', 'gridDim'), ('dim3*', 'blockDim'), ('size_t*', 'sharedMem'), ('hipStream_t*', 'stream')]
|
|
#define INIT___hipPopCallConfiguration_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.__hipPopCallConfiguration.gridDim = (dim3*)gridDim; \
|
|
cb_data.args.__hipPopCallConfiguration.blockDim = (dim3*)blockDim; \
|
|
cb_data.args.__hipPopCallConfiguration.sharedMem = (size_t*)sharedMem; \
|
|
cb_data.args.__hipPopCallConfiguration.stream = (hipStream_t*)stream; \
|
|
};
|
|
// __hipPushCallConfiguration[('dim3', 'gridDim'), ('dim3', 'blockDim'), ('size_t', 'sharedMem'), ('hipStream_t', 'stream')]
|
|
#define INIT___hipPushCallConfiguration_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.__hipPushCallConfiguration.gridDim = (dim3)gridDim; \
|
|
cb_data.args.__hipPushCallConfiguration.blockDim = (dim3)blockDim; \
|
|
cb_data.args.__hipPushCallConfiguration.sharedMem = (size_t)sharedMem; \
|
|
cb_data.args.__hipPushCallConfiguration.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipArray3DCreate[('hipArray**', 'array'), ('const HIP_ARRAY3D_DESCRIPTOR*', 'pAllocateArray')]
|
|
#define INIT_hipArray3DCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArray3DCreate.array = (hipArray**)array; \
|
|
cb_data.args.hipArray3DCreate.pAllocateArray = (const HIP_ARRAY3D_DESCRIPTOR*)pAllocateArray; \
|
|
};
|
|
// hipArrayCreate[('hipArray**', 'pHandle'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
|
|
#define INIT_hipArrayCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayCreate.pHandle = (hipArray**)array; \
|
|
cb_data.args.hipArrayCreate.pAllocateArray = (const HIP_ARRAY_DESCRIPTOR*)pAllocateArray; \
|
|
};
|
|
// hipArrayDestroy[('hipArray*', 'array')]
|
|
#define INIT_hipArrayDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayDestroy.array = (hipArray*)array; \
|
|
};
|
|
// hipChooseDevice[('int*', 'device'), ('const hipDeviceProp_t*', 'prop')]
|
|
#define INIT_hipChooseDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipChooseDevice.device = (int*)device; \
|
|
cb_data.args.hipChooseDevice.prop = (const hipDeviceProp_t*)properties; \
|
|
};
|
|
// hipConfigureCall[('dim3', 'gridDim'), ('dim3', 'blockDim'), ('size_t', 'sharedMem'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipConfigureCall_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipConfigureCall.gridDim = (dim3)gridDim; \
|
|
cb_data.args.hipConfigureCall.blockDim = (dim3)blockDim; \
|
|
cb_data.args.hipConfigureCall.sharedMem = (size_t)sharedMem; \
|
|
cb_data.args.hipConfigureCall.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipCreateSurfaceObject[('hipSurfaceObject_t*', 'pSurfObject'), ('const hipResourceDesc*', 'pResDesc')]
|
|
#define INIT_hipCreateSurfaceObject_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCreateSurfaceObject.pSurfObject = (hipSurfaceObject_t*)pSurfObject; \
|
|
cb_data.args.hipCreateSurfaceObject.pResDesc = (const hipResourceDesc*)pResDesc; \
|
|
};
|
|
// hipCtxCreate[('hipCtx_t*', 'ctx'), ('unsigned int', 'flags'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipCtxCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxCreate.ctx = (hipCtx_t*)ctx; \
|
|
cb_data.args.hipCtxCreate.flags = (unsigned int)flags; \
|
|
cb_data.args.hipCtxCreate.device = (hipDevice_t)device; \
|
|
};
|
|
// hipCtxDestroy[('hipCtx_t', 'ctx')]
|
|
#define INIT_hipCtxDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxDestroy.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipCtxDisablePeerAccess[('hipCtx_t', 'peerCtx')]
|
|
#define INIT_hipCtxDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxDisablePeerAccess.peerCtx = (hipCtx_t)peerCtx; \
|
|
};
|
|
// hipCtxEnablePeerAccess[('hipCtx_t', 'peerCtx'), ('unsigned int', 'flags')]
|
|
#define INIT_hipCtxEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxEnablePeerAccess.peerCtx = (hipCtx_t)peerCtx; \
|
|
cb_data.args.hipCtxEnablePeerAccess.flags = (unsigned int)flags; \
|
|
};
|
|
// hipCtxGetApiVersion[('hipCtx_t', 'ctx'), ('int*', 'apiVersion')]
|
|
#define INIT_hipCtxGetApiVersion_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetApiVersion.ctx = (hipCtx_t)ctx; \
|
|
cb_data.args.hipCtxGetApiVersion.apiVersion = (int*)apiVersion; \
|
|
};
|
|
// hipCtxGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
|
|
#define INIT_hipCtxGetCacheConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetCacheConfig.cacheConfig = (hipFuncCache_t*)cacheConfig; \
|
|
};
|
|
// hipCtxGetCurrent[('hipCtx_t*', 'ctx')]
|
|
#define INIT_hipCtxGetCurrent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetCurrent.ctx = (hipCtx_t*)ctx; \
|
|
};
|
|
// hipCtxGetDevice[('hipDevice_t*', 'device')]
|
|
#define INIT_hipCtxGetDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetDevice.device = (hipDevice_t*)device; \
|
|
};
|
|
// hipCtxGetFlags[('unsigned int*', 'flags')]
|
|
#define INIT_hipCtxGetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetFlags.flags = (unsigned int*)flags; \
|
|
};
|
|
// hipCtxGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
|
|
#define INIT_hipCtxGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxGetSharedMemConfig.pConfig = (hipSharedMemConfig*)pConfig; \
|
|
};
|
|
// hipCtxPopCurrent[('hipCtx_t*', 'ctx')]
|
|
#define INIT_hipCtxPopCurrent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxPopCurrent.ctx = (hipCtx_t*)ctx; \
|
|
};
|
|
// hipCtxPushCurrent[('hipCtx_t', 'ctx')]
|
|
#define INIT_hipCtxPushCurrent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxPushCurrent.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipCtxSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
|
|
#define INIT_hipCtxSetCacheConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxSetCacheConfig.cacheConfig = (hipFuncCache_t)cacheConfig; \
|
|
};
|
|
// hipCtxSetCurrent[('hipCtx_t', 'ctx')]
|
|
#define INIT_hipCtxSetCurrent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxSetCurrent.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipCtxSetSharedMemConfig[('hipSharedMemConfig', 'config')]
|
|
#define INIT_hipCtxSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipCtxSetSharedMemConfig.config = (hipSharedMemConfig)config; \
|
|
};
|
|
// hipCtxSynchronize[]
|
|
#define INIT_hipCtxSynchronize_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipDestroyExternalMemory[('hipExternalMemory_t', 'extMem')]
|
|
#define INIT_hipDestroyExternalMemory_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDestroyExternalMemory.extMem = (hipExternalMemory_t)extMem; \
|
|
};
|
|
// hipDestroyExternalSemaphore[('hipExternalSemaphore_t', 'extSem')]
|
|
#define INIT_hipDestroyExternalSemaphore_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDestroyExternalSemaphore.extSem = (hipExternalSemaphore_t)extSem; \
|
|
};
|
|
// hipDestroySurfaceObject[('hipSurfaceObject_t', 'surfaceObject')]
|
|
#define INIT_hipDestroySurfaceObject_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDestroySurfaceObject.surfaceObject = (hipSurfaceObject_t)surfaceObject; \
|
|
};
|
|
// hipDeviceCanAccessPeer[('int*', 'canAccessPeer'), ('int', 'deviceId'), ('int', 'peerDeviceId')]
|
|
#define INIT_hipDeviceCanAccessPeer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceCanAccessPeer.canAccessPeer = (int*)canAccess; \
|
|
cb_data.args.hipDeviceCanAccessPeer.deviceId = (int)deviceId; \
|
|
cb_data.args.hipDeviceCanAccessPeer.peerDeviceId = (int)peerDeviceId; \
|
|
};
|
|
// hipDeviceComputeCapability[('int*', 'major'), ('int*', 'minor'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipDeviceComputeCapability_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceComputeCapability.major = (int*)major; \
|
|
cb_data.args.hipDeviceComputeCapability.minor = (int*)minor; \
|
|
cb_data.args.hipDeviceComputeCapability.device = (hipDevice_t)device; \
|
|
};
|
|
// hipDeviceDisablePeerAccess[('int', 'peerDeviceId')]
|
|
#define INIT_hipDeviceDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceDisablePeerAccess.peerDeviceId = (int)peerDeviceId; \
|
|
};
|
|
// hipDeviceEnablePeerAccess[('int', 'peerDeviceId'), ('unsigned int', 'flags')]
|
|
#define INIT_hipDeviceEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceEnablePeerAccess.peerDeviceId = (int)peerDeviceId; \
|
|
cb_data.args.hipDeviceEnablePeerAccess.flags = (unsigned int)flags; \
|
|
};
|
|
// hipDeviceGet[('hipDevice_t*', 'device'), ('int', 'ordinal')]
|
|
#define INIT_hipDeviceGet_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGet.device = (hipDevice_t*)device; \
|
|
cb_data.args.hipDeviceGet.ordinal = (int)deviceId; \
|
|
};
|
|
// hipDeviceGetAttribute[('int*', 'pi'), ('hipDeviceAttribute_t', 'attr'), ('int', 'deviceId')]
|
|
#define INIT_hipDeviceGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetAttribute.pi = (int*)pi; \
|
|
cb_data.args.hipDeviceGetAttribute.attr = (hipDeviceAttribute_t)attr; \
|
|
cb_data.args.hipDeviceGetAttribute.deviceId = (int)device; \
|
|
};
|
|
// hipDeviceGetByPCIBusId[('int*', 'device'), ('const char*', 'pciBusId')]
|
|
#define INIT_hipDeviceGetByPCIBusId_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetByPCIBusId.device = (int*)device; \
|
|
cb_data.args.hipDeviceGetByPCIBusId.pciBusId = (pciBusIdstr) ? strdup(pciBusIdstr) : NULL; \
|
|
};
|
|
// hipDeviceGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
|
|
#define INIT_hipDeviceGetCacheConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetCacheConfig.cacheConfig = (hipFuncCache_t*)cacheConfig; \
|
|
};
|
|
// hipDeviceGetDefaultMemPool[('hipMemPool_t*', 'mem_pool'), ('int', 'device')]
|
|
#define INIT_hipDeviceGetDefaultMemPool_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetDefaultMemPool.mem_pool = (hipMemPool_t*)mem_pool; \
|
|
cb_data.args.hipDeviceGetDefaultMemPool.device = (int)device; \
|
|
};
|
|
// hipDeviceGetGraphMemAttribute[('int', 'device'), ('hipGraphMemAttributeType', 'attr'), ('void*', 'value')]
|
|
#define INIT_hipDeviceGetGraphMemAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetGraphMemAttribute.device = (int)device; \
|
|
cb_data.args.hipDeviceGetGraphMemAttribute.attr = (hipGraphMemAttributeType)attr; \
|
|
cb_data.args.hipDeviceGetGraphMemAttribute.value = (void*)value; \
|
|
};
|
|
// hipDeviceGetLimit[('size_t*', 'pValue'), ('hipLimit_t', 'limit')]
|
|
#define INIT_hipDeviceGetLimit_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetLimit.pValue = (size_t*)pValue; \
|
|
cb_data.args.hipDeviceGetLimit.limit = (hipLimit_t)limit; \
|
|
};
|
|
// hipDeviceGetMemPool[('hipMemPool_t*', 'mem_pool'), ('int', 'device')]
|
|
#define INIT_hipDeviceGetMemPool_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetMemPool.mem_pool = (hipMemPool_t*)mem_pool; \
|
|
cb_data.args.hipDeviceGetMemPool.device = (int)device; \
|
|
};
|
|
// hipDeviceGetName[('char*', 'name'), ('int', 'len'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipDeviceGetName_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetName.name = (char*)name; \
|
|
cb_data.args.hipDeviceGetName.len = (int)len; \
|
|
cb_data.args.hipDeviceGetName.device = (hipDevice_t)device; \
|
|
};
|
|
// hipDeviceGetP2PAttribute[('int*', 'value'), ('hipDeviceP2PAttr', 'attr'), ('int', 'srcDevice'), ('int', 'dstDevice')]
|
|
#define INIT_hipDeviceGetP2PAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetP2PAttribute.value = (int*)value; \
|
|
cb_data.args.hipDeviceGetP2PAttribute.attr = (hipDeviceP2PAttr)attr; \
|
|
cb_data.args.hipDeviceGetP2PAttribute.srcDevice = (int)srcDevice; \
|
|
cb_data.args.hipDeviceGetP2PAttribute.dstDevice = (int)dstDevice; \
|
|
};
|
|
// hipDeviceGetPCIBusId[('char*', 'pciBusId'), ('int', 'len'), ('int', 'device')]
|
|
#define INIT_hipDeviceGetPCIBusId_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetPCIBusId.pciBusId = (char*)pciBusId; \
|
|
cb_data.args.hipDeviceGetPCIBusId.len = (int)len; \
|
|
cb_data.args.hipDeviceGetPCIBusId.device = (int)device; \
|
|
};
|
|
// hipDeviceGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
|
|
#define INIT_hipDeviceGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetSharedMemConfig.pConfig = (hipSharedMemConfig*)pConfig; \
|
|
};
|
|
// hipDeviceGetStreamPriorityRange[('int*', 'leastPriority'), ('int*', 'greatestPriority')]
|
|
#define INIT_hipDeviceGetStreamPriorityRange_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetStreamPriorityRange.leastPriority = (int*)leastPriority; \
|
|
cb_data.args.hipDeviceGetStreamPriorityRange.greatestPriority = (int*)greatestPriority; \
|
|
};
|
|
// hipDeviceGetUuid[('hipUUID*', 'uuid'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipDeviceGetUuid_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGetUuid.uuid = (hipUUID*)uuid; \
|
|
cb_data.args.hipDeviceGetUuid.device = (hipDevice_t)device; \
|
|
};
|
|
// hipDeviceGraphMemTrim[('int', 'device')]
|
|
#define INIT_hipDeviceGraphMemTrim_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceGraphMemTrim.device = (int)device; \
|
|
};
|
|
// hipDevicePrimaryCtxGetState[('hipDevice_t', 'dev'), ('unsigned int*', 'flags'), ('int*', 'active')]
|
|
#define INIT_hipDevicePrimaryCtxGetState_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDevicePrimaryCtxGetState.dev = (hipDevice_t)dev; \
|
|
cb_data.args.hipDevicePrimaryCtxGetState.flags = (unsigned int*)flags; \
|
|
cb_data.args.hipDevicePrimaryCtxGetState.active = (int*)active; \
|
|
};
|
|
// hipDevicePrimaryCtxRelease[('hipDevice_t', 'dev')]
|
|
#define INIT_hipDevicePrimaryCtxRelease_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDevicePrimaryCtxRelease.dev = (hipDevice_t)dev; \
|
|
};
|
|
// hipDevicePrimaryCtxReset[('hipDevice_t', 'dev')]
|
|
#define INIT_hipDevicePrimaryCtxReset_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDevicePrimaryCtxReset.dev = (hipDevice_t)dev; \
|
|
};
|
|
// hipDevicePrimaryCtxRetain[('hipCtx_t*', 'pctx'), ('hipDevice_t', 'dev')]
|
|
#define INIT_hipDevicePrimaryCtxRetain_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDevicePrimaryCtxRetain.pctx = (hipCtx_t*)pctx; \
|
|
cb_data.args.hipDevicePrimaryCtxRetain.dev = (hipDevice_t)dev; \
|
|
};
|
|
// hipDevicePrimaryCtxSetFlags[('hipDevice_t', 'dev'), ('unsigned int', 'flags')]
|
|
#define INIT_hipDevicePrimaryCtxSetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDevicePrimaryCtxSetFlags.dev = (hipDevice_t)dev; \
|
|
cb_data.args.hipDevicePrimaryCtxSetFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipDeviceReset[]
|
|
#define INIT_hipDeviceReset_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipDeviceSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
|
|
#define INIT_hipDeviceSetCacheConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceSetCacheConfig.cacheConfig = (hipFuncCache_t)cacheConfig; \
|
|
};
|
|
// hipDeviceSetGraphMemAttribute[('int', 'device'), ('hipGraphMemAttributeType', 'attr'), ('void*', 'value')]
|
|
#define INIT_hipDeviceSetGraphMemAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceSetGraphMemAttribute.device = (int)device; \
|
|
cb_data.args.hipDeviceSetGraphMemAttribute.attr = (hipGraphMemAttributeType)attr; \
|
|
cb_data.args.hipDeviceSetGraphMemAttribute.value = (void*)value; \
|
|
};
|
|
// hipDeviceSetLimit[('hipLimit_t', 'limit'), ('size_t', 'value')]
|
|
#define INIT_hipDeviceSetLimit_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceSetLimit.limit = (hipLimit_t)limit; \
|
|
cb_data.args.hipDeviceSetLimit.value = (size_t)value; \
|
|
};
|
|
// hipDeviceSetMemPool[('int', 'device'), ('hipMemPool_t', 'mem_pool')]
|
|
#define INIT_hipDeviceSetMemPool_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceSetMemPool.device = (int)device; \
|
|
cb_data.args.hipDeviceSetMemPool.mem_pool = (hipMemPool_t)mem_pool; \
|
|
};
|
|
// hipDeviceSetSharedMemConfig[('hipSharedMemConfig', 'config')]
|
|
#define INIT_hipDeviceSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceSetSharedMemConfig.config = (hipSharedMemConfig)config; \
|
|
};
|
|
// hipDeviceSynchronize[]
|
|
#define INIT_hipDeviceSynchronize_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipDeviceTotalMem[('size_t*', 'bytes'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipDeviceTotalMem_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDeviceTotalMem.bytes = (size_t*)bytes; \
|
|
cb_data.args.hipDeviceTotalMem.device = (hipDevice_t)device; \
|
|
};
|
|
// hipDriverGetVersion[('int*', 'driverVersion')]
|
|
#define INIT_hipDriverGetVersion_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDriverGetVersion.driverVersion = (int*)driverVersion; \
|
|
};
|
|
// hipDrvMemcpy2DUnaligned[('const hip_Memcpy2D*', 'pCopy')]
|
|
#define INIT_hipDrvMemcpy2DUnaligned_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvMemcpy2DUnaligned.pCopy = (const hip_Memcpy2D*)pCopy; \
|
|
};
|
|
// hipDrvMemcpy3D[('const HIP_MEMCPY3D*', 'pCopy')]
|
|
#define INIT_hipDrvMemcpy3D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvMemcpy3D.pCopy = (const HIP_MEMCPY3D*)pCopy; \
|
|
};
|
|
// hipDrvMemcpy3DAsync[('const HIP_MEMCPY3D*', 'pCopy'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipDrvMemcpy3DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvMemcpy3DAsync.pCopy = (const HIP_MEMCPY3D*)pCopy; \
|
|
cb_data.args.hipDrvMemcpy3DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipDrvPointerGetAttributes[('unsigned int', 'numAttributes'), ('hipPointer_attribute*', 'attributes'), ('void**', 'data'), ('hipDeviceptr_t', 'ptr')]
|
|
#define INIT_hipDrvPointerGetAttributes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvPointerGetAttributes.numAttributes = (unsigned int)numAttributes; \
|
|
cb_data.args.hipDrvPointerGetAttributes.attributes = (hipPointer_attribute*)attributes; \
|
|
cb_data.args.hipDrvPointerGetAttributes.data = (void**)data; \
|
|
cb_data.args.hipDrvPointerGetAttributes.ptr = (hipDeviceptr_t)ptr; \
|
|
};
|
|
// hipEventCreate[('hipEvent_t*', 'event')]
|
|
#define INIT_hipEventCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventCreate.event = (hipEvent_t*)event; \
|
|
};
|
|
// hipEventCreateWithFlags[('hipEvent_t*', 'event'), ('unsigned int', 'flags')]
|
|
#define INIT_hipEventCreateWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventCreateWithFlags.event = (hipEvent_t*)event; \
|
|
cb_data.args.hipEventCreateWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipEventDestroy[('hipEvent_t', 'event')]
|
|
#define INIT_hipEventDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventDestroy.event = (hipEvent_t)event; \
|
|
};
|
|
// hipEventElapsedTime[('float*', 'ms'), ('hipEvent_t', 'start'), ('hipEvent_t', 'stop')]
|
|
#define INIT_hipEventElapsedTime_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventElapsedTime.ms = (float*)ms; \
|
|
cb_data.args.hipEventElapsedTime.start = (hipEvent_t)start; \
|
|
cb_data.args.hipEventElapsedTime.stop = (hipEvent_t)stop; \
|
|
};
|
|
// hipEventQuery[('hipEvent_t', 'event')]
|
|
#define INIT_hipEventQuery_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventQuery.event = (hipEvent_t)event; \
|
|
};
|
|
// hipEventRecord[('hipEvent_t', 'event'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipEventRecord_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventRecord.event = (hipEvent_t)event; \
|
|
cb_data.args.hipEventRecord.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipEventSynchronize[('hipEvent_t', 'event')]
|
|
#define INIT_hipEventSynchronize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventSynchronize.event = (hipEvent_t)event; \
|
|
};
|
|
// hipExtGetLinkTypeAndHopCount[('int', 'device1'), ('int', 'device2'), ('unsigned int*', 'linktype'), ('unsigned int*', 'hopcount')]
|
|
#define INIT_hipExtGetLinkTypeAndHopCount_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtGetLinkTypeAndHopCount.device1 = (int)device1; \
|
|
cb_data.args.hipExtGetLinkTypeAndHopCount.device2 = (int)device2; \
|
|
cb_data.args.hipExtGetLinkTypeAndHopCount.linktype = (unsigned int*)linktype; \
|
|
cb_data.args.hipExtGetLinkTypeAndHopCount.hopcount = (unsigned int*)hopcount; \
|
|
};
|
|
// hipExtLaunchKernel[('const void*', 'function_address'), ('dim3', 'numBlocks'), ('dim3', 'dimBlocks'), ('void**', 'args'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent'), ('int', 'flags')]
|
|
#define INIT_hipExtLaunchKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtLaunchKernel.function_address = (const void*)hostFunction; \
|
|
cb_data.args.hipExtLaunchKernel.numBlocks = (dim3)gridDim; \
|
|
cb_data.args.hipExtLaunchKernel.dimBlocks = (dim3)blockDim; \
|
|
cb_data.args.hipExtLaunchKernel.args = (void**)args; \
|
|
cb_data.args.hipExtLaunchKernel.sharedMemBytes = (size_t)sharedMemBytes; \
|
|
cb_data.args.hipExtLaunchKernel.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipExtLaunchKernel.startEvent = (hipEvent_t)startEvent; \
|
|
cb_data.args.hipExtLaunchKernel.stopEvent = (hipEvent_t)stopEvent; \
|
|
cb_data.args.hipExtLaunchKernel.flags = (int)flags; \
|
|
};
|
|
// hipExtLaunchMultiKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
|
|
#define INIT_hipExtLaunchMultiKernelMultiDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtLaunchMultiKernelMultiDevice.launchParamsList = (hipLaunchParams*)launchParamsList; \
|
|
cb_data.args.hipExtLaunchMultiKernelMultiDevice.numDevices = (int)numDevices; \
|
|
cb_data.args.hipExtLaunchMultiKernelMultiDevice.flags = (unsigned int)flags; \
|
|
};
|
|
// hipExtMallocWithFlags[('void**', 'ptr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
|
|
#define INIT_hipExtMallocWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtMallocWithFlags.ptr = (void**)ptr; \
|
|
cb_data.args.hipExtMallocWithFlags.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipExtMallocWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipExtModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'localWorkSizeX'), ('unsigned int', 'localWorkSizeY'), ('unsigned int', 'localWorkSizeZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent'), ('unsigned int', 'flags')]
|
|
#define INIT_hipExtModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtModuleLaunchKernel.f = (hipFunction_t)f; \
|
|
cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeX = (unsigned int)globalWorkSizeX; \
|
|
cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeY = (unsigned int)globalWorkSizeY; \
|
|
cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeZ = (unsigned int)globalWorkSizeZ; \
|
|
cb_data.args.hipExtModuleLaunchKernel.localWorkSizeX = (unsigned int)localWorkSizeX; \
|
|
cb_data.args.hipExtModuleLaunchKernel.localWorkSizeY = (unsigned int)localWorkSizeY; \
|
|
cb_data.args.hipExtModuleLaunchKernel.localWorkSizeZ = (unsigned int)localWorkSizeZ; \
|
|
cb_data.args.hipExtModuleLaunchKernel.sharedMemBytes = (size_t)sharedMemBytes; \
|
|
cb_data.args.hipExtModuleLaunchKernel.hStream = (hipStream_t)hStream; \
|
|
cb_data.args.hipExtModuleLaunchKernel.kernelParams = (void**)kernelParams; \
|
|
cb_data.args.hipExtModuleLaunchKernel.extra = (void**)extra; \
|
|
cb_data.args.hipExtModuleLaunchKernel.startEvent = (hipEvent_t)startEvent; \
|
|
cb_data.args.hipExtModuleLaunchKernel.stopEvent = (hipEvent_t)stopEvent; \
|
|
cb_data.args.hipExtModuleLaunchKernel.flags = (unsigned int)flags; \
|
|
};
|
|
// hipExtStreamCreateWithCUMask[('hipStream_t*', 'stream'), ('unsigned int', 'cuMaskSize'), ('const unsigned int*', 'cuMask')]
|
|
#define INIT_hipExtStreamCreateWithCUMask_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtStreamCreateWithCUMask.stream = (hipStream_t*)stream; \
|
|
cb_data.args.hipExtStreamCreateWithCUMask.cuMaskSize = (unsigned int)cuMaskSize; \
|
|
cb_data.args.hipExtStreamCreateWithCUMask.cuMask = (const unsigned int*)cuMask; \
|
|
};
|
|
// hipExtStreamGetCUMask[('hipStream_t', 'stream'), ('unsigned int', 'cuMaskSize'), ('unsigned int*', 'cuMask')]
|
|
#define INIT_hipExtStreamGetCUMask_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExtStreamGetCUMask.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipExtStreamGetCUMask.cuMaskSize = (unsigned int)cuMaskSize; \
|
|
cb_data.args.hipExtStreamGetCUMask.cuMask = (unsigned int*)cuMask; \
|
|
};
|
|
// hipExternalMemoryGetMappedBuffer[('void**', 'devPtr'), ('hipExternalMemory_t', 'extMem'), ('const hipExternalMemoryBufferDesc*', 'bufferDesc')]
|
|
#define INIT_hipExternalMemoryGetMappedBuffer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExternalMemoryGetMappedBuffer.devPtr = (void**)devPtr; \
|
|
cb_data.args.hipExternalMemoryGetMappedBuffer.extMem = (hipExternalMemory_t)extMem; \
|
|
cb_data.args.hipExternalMemoryGetMappedBuffer.bufferDesc = (const hipExternalMemoryBufferDesc*)bufferDesc; \
|
|
};
|
|
// hipFree[('void*', 'ptr')]
|
|
#define INIT_hipFree_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFree.ptr = (void*)ptr; \
|
|
};
|
|
// hipFreeArray[('hipArray*', 'array')]
|
|
#define INIT_hipFreeArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFreeArray.array = (hipArray*)array; \
|
|
};
|
|
// hipFreeAsync[('void*', 'dev_ptr'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipFreeAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFreeAsync.dev_ptr = (void*)dev_ptr; \
|
|
cb_data.args.hipFreeAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipFreeHost[('void*', 'ptr')]
|
|
#define INIT_hipFreeHost_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFreeHost.ptr = (void*)ptr; \
|
|
};
|
|
// hipFreeMipmappedArray[('hipMipmappedArray_t', 'mipmappedArray')]
|
|
#define INIT_hipFreeMipmappedArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFreeMipmappedArray.mipmappedArray = (hipMipmappedArray_t)mipmappedArray; \
|
|
};
|
|
// hipFuncGetAttribute[('int*', 'value'), ('hipFunction_attribute', 'attrib'), ('hipFunction_t', 'hfunc')]
|
|
#define INIT_hipFuncGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFuncGetAttribute.value = (int*)value; \
|
|
cb_data.args.hipFuncGetAttribute.attrib = (hipFunction_attribute)attrib; \
|
|
cb_data.args.hipFuncGetAttribute.hfunc = (hipFunction_t)hfunc; \
|
|
};
|
|
// hipFuncGetAttributes[('hipFuncAttributes*', 'attr'), ('const void*', 'func')]
|
|
#define INIT_hipFuncGetAttributes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFuncGetAttributes.attr = (hipFuncAttributes*)attr; \
|
|
cb_data.args.hipFuncGetAttributes.func = (const void*)func; \
|
|
};
|
|
// hipFuncSetAttribute[('const void*', 'func'), ('hipFuncAttribute', 'attr'), ('int', 'value')]
|
|
#define INIT_hipFuncSetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFuncSetAttribute.func = (const void*)func; \
|
|
cb_data.args.hipFuncSetAttribute.attr = (hipFuncAttribute)attr; \
|
|
cb_data.args.hipFuncSetAttribute.value = (int)value; \
|
|
};
|
|
// hipFuncSetCacheConfig[('const void*', 'func'), ('hipFuncCache_t', 'config')]
|
|
#define INIT_hipFuncSetCacheConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFuncSetCacheConfig.func = (const void*)func; \
|
|
cb_data.args.hipFuncSetCacheConfig.config = (hipFuncCache_t)cacheConfig; \
|
|
};
|
|
// hipFuncSetSharedMemConfig[('const void*', 'func'), ('hipSharedMemConfig', 'config')]
|
|
#define INIT_hipFuncSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFuncSetSharedMemConfig.func = (const void*)func; \
|
|
cb_data.args.hipFuncSetSharedMemConfig.config = (hipSharedMemConfig)config; \
|
|
};
|
|
// hipGLGetDevices[('unsigned int*', 'pHipDeviceCount'), ('int*', 'pHipDevices'), ('unsigned int', 'hipDeviceCount'), ('hipGLDeviceList', 'deviceList')]
|
|
#define INIT_hipGLGetDevices_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGLGetDevices.pHipDeviceCount = (unsigned int*)pHipDeviceCount; \
|
|
cb_data.args.hipGLGetDevices.pHipDevices = (int*)pHipDevices; \
|
|
cb_data.args.hipGLGetDevices.hipDeviceCount = (unsigned int)hipDeviceCount; \
|
|
cb_data.args.hipGLGetDevices.deviceList = (hipGLDeviceList)deviceList; \
|
|
};
|
|
// hipGetChannelDesc[('hipChannelFormatDesc*', 'desc'), ('hipArray_const_t', 'array')]
|
|
#define INIT_hipGetChannelDesc_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetChannelDesc.desc = (hipChannelFormatDesc*)desc; \
|
|
cb_data.args.hipGetChannelDesc.array = (hipArray_const_t)array; \
|
|
};
|
|
// hipGetDevice[('int*', 'deviceId')]
|
|
#define INIT_hipGetDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDevice.deviceId = (int*)deviceId; \
|
|
};
|
|
// hipGetDeviceCount[('int*', 'count')]
|
|
#define INIT_hipGetDeviceCount_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDeviceCount.count = (int*)count; \
|
|
};
|
|
// hipGetDeviceFlags[('unsigned int*', 'flags')]
|
|
#define INIT_hipGetDeviceFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDeviceFlags.flags = (unsigned int*)flags; \
|
|
};
|
|
// hipGetDeviceProperties[('hipDeviceProp_t*', 'props'), ('hipDevice_t', 'device')]
|
|
#define INIT_hipGetDeviceProperties_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDeviceProperties.props = (hipDeviceProp_t*)props; \
|
|
cb_data.args.hipGetDeviceProperties.device = (hipDevice_t)device; \
|
|
};
|
|
// hipGetErrorString[]
|
|
#define INIT_hipGetErrorString_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipGetLastError[]
|
|
#define INIT_hipGetLastError_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipGetMipmappedArrayLevel[('hipArray_t*', 'levelArray'), ('hipMipmappedArray_const_t', 'mipmappedArray'), ('unsigned int', 'level')]
|
|
#define INIT_hipGetMipmappedArrayLevel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetMipmappedArrayLevel.levelArray = (hipArray_t*)levelArray; \
|
|
cb_data.args.hipGetMipmappedArrayLevel.mipmappedArray = (hipMipmappedArray_const_t)mipmappedArray; \
|
|
cb_data.args.hipGetMipmappedArrayLevel.level = (unsigned int)level; \
|
|
};
|
|
// hipGetSymbolAddress[('void**', 'devPtr'), ('const void*', 'symbol')]
|
|
#define INIT_hipGetSymbolAddress_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetSymbolAddress.devPtr = (void**)devPtr; \
|
|
cb_data.args.hipGetSymbolAddress.symbol = (const void*)symbol; \
|
|
};
|
|
// hipGetSymbolSize[('size_t*', 'size'), ('const void*', 'symbol')]
|
|
#define INIT_hipGetSymbolSize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetSymbolSize.size = (size_t*)sizePtr; \
|
|
cb_data.args.hipGetSymbolSize.symbol = (const void*)symbol; \
|
|
};
|
|
// hipGraphAddChildGraphNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipGraph_t', 'childGraph')]
|
|
#define INIT_hipGraphAddChildGraphNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddChildGraphNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddChildGraphNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddChildGraphNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddChildGraphNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddChildGraphNode.childGraph = (hipGraph_t)childGraph; \
|
|
};
|
|
// hipGraphAddDependencies[('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'from'), ('const hipGraphNode_t*', 'to'), ('size_t', 'numDependencies')]
|
|
#define INIT_hipGraphAddDependencies_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddDependencies.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddDependencies.from = (const hipGraphNode_t*)from; \
|
|
cb_data.args.hipGraphAddDependencies.to = (const hipGraphNode_t*)to; \
|
|
cb_data.args.hipGraphAddDependencies.numDependencies = (size_t)numDependencies; \
|
|
};
|
|
// hipGraphAddEmptyNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies')]
|
|
#define INIT_hipGraphAddEmptyNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddEmptyNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddEmptyNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddEmptyNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddEmptyNode.numDependencies = (size_t)numDependencies; \
|
|
};
|
|
// hipGraphAddEventRecordNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphAddEventRecordNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddEventRecordNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddEventRecordNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddEventRecordNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddEventRecordNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddEventRecordNode.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphAddEventWaitNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphAddEventWaitNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddEventWaitNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddEventWaitNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddEventWaitNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddEventWaitNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddEventWaitNode.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphAddHostNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphAddHostNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddHostNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddHostNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddHostNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddHostNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddHostNode.pNodeParams = (const hipHostNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphAddKernelNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphAddKernelNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddKernelNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddKernelNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddKernelNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddKernelNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddKernelNode.pNodeParams = (const hipKernelNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphAddMemAllocNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipMemAllocNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphAddMemAllocNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemAllocNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemAllocNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemAllocNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemAllocNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemAllocNode.pNodeParams = (hipMemAllocNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphAddMemFreeNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dev_ptr')]
|
|
#define INIT_hipGraphAddMemFreeNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemFreeNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemFreeNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemFreeNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemFreeNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemFreeNode.dev_ptr = (void*)dev_ptr; \
|
|
};
|
|
// hipGraphAddMemcpyNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipMemcpy3DParms*', 'pCopyParams')]
|
|
#define INIT_hipGraphAddMemcpyNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemcpyNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemcpyNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemcpyNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNode.pCopyParams = (const hipMemcpy3DParms*)pCopyParams; \
|
|
};
|
|
// hipGraphAddMemcpyNode1D[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphAddMemcpyNode1D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.dst = (void*)dst; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.src = (const void*)src; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.count = (size_t)count; \
|
|
cb_data.args.hipGraphAddMemcpyNode1D.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphAddMemcpyNodeFromSymbol[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphAddMemcpyNodeFromSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.dst = (void*)dst; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphAddMemcpyNodeFromSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphAddMemcpyNodeToSymbol[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphAddMemcpyNodeToSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.src = (const void*)src; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphAddMemcpyNodeToSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphAddMemsetNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipMemsetParams*', 'pMemsetParams')]
|
|
#define INIT_hipGraphAddMemsetNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddMemsetNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddMemsetNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddMemsetNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddMemsetNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddMemsetNode.pMemsetParams = (const hipMemsetParams*)pMemsetParams; \
|
|
};
|
|
// hipGraphChildGraphNodeGetGraph[('hipGraphNode_t', 'node'), ('hipGraph_t*', 'pGraph')]
|
|
#define INIT_hipGraphChildGraphNodeGetGraph_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphChildGraphNodeGetGraph.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphChildGraphNodeGetGraph.pGraph = (hipGraph_t*)pGraph; \
|
|
};
|
|
// hipGraphClone[('hipGraph_t*', 'pGraphClone'), ('hipGraph_t', 'originalGraph')]
|
|
#define INIT_hipGraphClone_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphClone.pGraphClone = (hipGraph_t*)pGraphClone; \
|
|
cb_data.args.hipGraphClone.originalGraph = (hipGraph_t)originalGraph; \
|
|
};
|
|
// hipGraphCreate[('hipGraph_t*', 'pGraph'), ('unsigned int', 'flags')]
|
|
#define INIT_hipGraphCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphCreate.pGraph = (hipGraph_t*)pGraph; \
|
|
cb_data.args.hipGraphCreate.flags = (unsigned int)flags; \
|
|
};
|
|
// hipGraphDebugDotPrint[('hipGraph_t', 'graph'), ('const char*', 'path'), ('unsigned int', 'flags')]
|
|
#define INIT_hipGraphDebugDotPrint_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphDebugDotPrint.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphDebugDotPrint.path = (path) ? strdup(path) : NULL; \
|
|
cb_data.args.hipGraphDebugDotPrint.flags = (unsigned int)flags; \
|
|
};
|
|
// hipGraphDestroy[('hipGraph_t', 'graph')]
|
|
#define INIT_hipGraphDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphDestroy.graph = (hipGraph_t)graph; \
|
|
};
|
|
// hipGraphDestroyNode[('hipGraphNode_t', 'node')]
|
|
#define INIT_hipGraphDestroyNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphDestroyNode.node = (hipGraphNode_t)node; \
|
|
};
|
|
// hipGraphEventRecordNodeGetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t*', 'event_out')]
|
|
#define INIT_hipGraphEventRecordNodeGetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphEventRecordNodeGetEvent.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphEventRecordNodeGetEvent.event_out = (hipEvent_t*)event_out; \
|
|
};
|
|
// hipGraphEventRecordNodeSetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphEventRecordNodeSetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphEventRecordNodeSetEvent.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphEventRecordNodeSetEvent.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphEventWaitNodeGetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t*', 'event_out')]
|
|
#define INIT_hipGraphEventWaitNodeGetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphEventWaitNodeGetEvent.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphEventWaitNodeGetEvent.event_out = (hipEvent_t*)event_out; \
|
|
};
|
|
// hipGraphEventWaitNodeSetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphEventWaitNodeSetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphEventWaitNodeSetEvent.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphEventWaitNodeSetEvent.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphExecChildGraphNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('hipGraph_t', 'childGraph')]
|
|
#define INIT_hipGraphExecChildGraphNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecChildGraphNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecChildGraphNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecChildGraphNodeSetParams.childGraph = (hipGraph_t)childGraph; \
|
|
};
|
|
// hipGraphExecDestroy[('hipGraphExec_t', 'graphExec')]
|
|
#define INIT_hipGraphExecDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecDestroy.graphExec = (hipGraphExec_t)pGraphExec; \
|
|
};
|
|
// hipGraphExecEventRecordNodeSetEvent[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphExecEventRecordNodeSetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecEventRecordNodeSetEvent.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecEventRecordNodeSetEvent.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExecEventRecordNodeSetEvent.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphExecEventWaitNodeSetEvent[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipGraphExecEventWaitNodeSetEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecEventWaitNodeSetEvent.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecEventWaitNodeSetEvent.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExecEventWaitNodeSetEvent.event = (hipEvent_t)event; \
|
|
};
|
|
// hipGraphExecHostNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphExecHostNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecHostNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecHostNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecHostNodeSetParams.pNodeParams = (const hipHostNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphExecKernelNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphExecKernelNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecKernelNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecKernelNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecKernelNodeSetParams.pNodeParams = (const hipKernelNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphExecMemcpyNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('hipMemcpy3DParms*', 'pNodeParams')]
|
|
#define INIT_hipGraphExecMemcpyNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams.pNodeParams = (hipMemcpy3DParms*)pNodeParams; \
|
|
};
|
|
// hipGraphExecMemcpyNodeSetParams1D[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphExecMemcpyNodeSetParams1D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.dst = (void*)dst; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.src = (const void*)src; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.count = (size_t)count; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParams1D.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphExecMemcpyNodeSetParamsFromSymbol[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphExecMemcpyNodeSetParamsFromSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.dst = (void*)dst; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsFromSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphExecMemcpyNodeSetParamsToSymbol[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphExecMemcpyNodeSetParamsToSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.src = (const void*)src; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphExecMemcpyNodeSetParamsToSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphExecMemsetNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipMemsetParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphExecMemsetNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecMemsetNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecMemsetNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecMemsetNodeSetParams.pNodeParams = (const hipMemsetParams*)pNodeParams; \
|
|
};
|
|
// hipGraphExecUpdate[('hipGraphExec_t', 'hGraphExec'), ('hipGraph_t', 'hGraph'), ('hipGraphNode_t*', 'hErrorNode_out'), ('hipGraphExecUpdateResult*', 'updateResult_out')]
|
|
#define INIT_hipGraphExecUpdate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecUpdate.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecUpdate.hGraph = (hipGraph_t)hGraph; \
|
|
cb_data.args.hipGraphExecUpdate.hErrorNode_out = (hipGraphNode_t*)hErrorNode_out; \
|
|
cb_data.args.hipGraphExecUpdate.updateResult_out = (hipGraphExecUpdateResult*)updateResult_out; \
|
|
};
|
|
// hipGraphGetEdges[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'from'), ('hipGraphNode_t*', 'to'), ('size_t*', 'numEdges')]
|
|
#define INIT_hipGraphGetEdges_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphGetEdges.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphGetEdges.from = (hipGraphNode_t*)from; \
|
|
cb_data.args.hipGraphGetEdges.to = (hipGraphNode_t*)to; \
|
|
cb_data.args.hipGraphGetEdges.numEdges = (size_t*)numEdges; \
|
|
};
|
|
// hipGraphGetNodes[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'nodes'), ('size_t*', 'numNodes')]
|
|
#define INIT_hipGraphGetNodes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphGetNodes.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphGetNodes.nodes = (hipGraphNode_t*)nodes; \
|
|
cb_data.args.hipGraphGetNodes.numNodes = (size_t*)numNodes; \
|
|
};
|
|
// hipGraphGetRootNodes[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'pRootNodes'), ('size_t*', 'pNumRootNodes')]
|
|
#define INIT_hipGraphGetRootNodes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphGetRootNodes.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphGetRootNodes.pRootNodes = (hipGraphNode_t*)pRootNodes; \
|
|
cb_data.args.hipGraphGetRootNodes.pNumRootNodes = (size_t*)pNumRootNodes; \
|
|
};
|
|
// hipGraphHostNodeGetParams[('hipGraphNode_t', 'node'), ('hipHostNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphHostNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphHostNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphHostNodeGetParams.pNodeParams = (hipHostNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphHostNodeSetParams[('hipGraphNode_t', 'node'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphHostNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphHostNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphHostNodeSetParams.pNodeParams = (const hipHostNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphInstantiate[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'pErrorNode'), ('char*', 'pLogBuffer'), ('size_t', 'bufferSize')]
|
|
#define INIT_hipGraphInstantiate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphInstantiate.pGraphExec = (hipGraphExec_t*)pGraphExec; \
|
|
cb_data.args.hipGraphInstantiate.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphInstantiate.pErrorNode = (hipGraphNode_t*)pErrorNode; \
|
|
cb_data.args.hipGraphInstantiate.pLogBuffer = (char*)pLogBuffer; \
|
|
cb_data.args.hipGraphInstantiate.bufferSize = (size_t)bufferSize; \
|
|
};
|
|
// hipGraphInstantiateWithFlags[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('unsigned long long', 'flags')]
|
|
#define INIT_hipGraphInstantiateWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphInstantiateWithFlags.pGraphExec = (hipGraphExec_t*)pGraphExec; \
|
|
cb_data.args.hipGraphInstantiateWithFlags.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphInstantiateWithFlags.flags = (unsigned long long)flags; \
|
|
};
|
|
// hipGraphKernelNodeCopyAttributes[('hipGraphNode_t', 'hSrc'), ('hipGraphNode_t', 'hDst')]
|
|
#define INIT_hipGraphKernelNodeCopyAttributes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphKernelNodeCopyAttributes.hSrc = (hipGraphNode_t)hSrc; \
|
|
cb_data.args.hipGraphKernelNodeCopyAttributes.hDst = (hipGraphNode_t)hDst; \
|
|
};
|
|
// hipGraphKernelNodeGetAttribute[('hipGraphNode_t', 'hNode'), ('hipKernelNodeAttrID', 'attr'), ('hipKernelNodeAttrValue*', 'value')]
|
|
#define INIT_hipGraphKernelNodeGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphKernelNodeGetAttribute.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphKernelNodeGetAttribute.attr = (hipKernelNodeAttrID)attr; \
|
|
cb_data.args.hipGraphKernelNodeGetAttribute.value = (hipKernelNodeAttrValue*)value; \
|
|
};
|
|
// hipGraphKernelNodeGetParams[('hipGraphNode_t', 'node'), ('hipKernelNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphKernelNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphKernelNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphKernelNodeGetParams.pNodeParams = (hipKernelNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphKernelNodeSetAttribute[('hipGraphNode_t', 'hNode'), ('hipKernelNodeAttrID', 'attr'), ('const hipKernelNodeAttrValue*', 'value')]
|
|
#define INIT_hipGraphKernelNodeSetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphKernelNodeSetAttribute.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphKernelNodeSetAttribute.attr = (hipKernelNodeAttrID)attr; \
|
|
cb_data.args.hipGraphKernelNodeSetAttribute.value = (const hipKernelNodeAttrValue*)value; \
|
|
};
|
|
// hipGraphKernelNodeSetParams[('hipGraphNode_t', 'node'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphKernelNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphKernelNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphKernelNodeSetParams.pNodeParams = (const hipKernelNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphLaunch[('hipGraphExec_t', 'graphExec'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipGraphLaunch_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphLaunch.graphExec = (hipGraphExec_t)graphExec; \
|
|
cb_data.args.hipGraphLaunch.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipGraphMemAllocNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemAllocNodeParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphMemAllocNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemAllocNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemAllocNodeGetParams.pNodeParams = (hipMemAllocNodeParams*)pNodeParams; \
|
|
};
|
|
// hipGraphMemFreeNodeGetParams[('hipGraphNode_t', 'node'), ('void*', 'dev_ptr')]
|
|
#define INIT_hipGraphMemFreeNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemFreeNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemFreeNodeGetParams.dev_ptr = (void*)dev_ptr; \
|
|
};
|
|
// hipGraphMemcpyNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemcpy3DParms*', 'pNodeParams')]
|
|
#define INIT_hipGraphMemcpyNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemcpyNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemcpyNodeGetParams.pNodeParams = (hipMemcpy3DParms*)pNodeParams; \
|
|
};
|
|
// hipGraphMemcpyNodeSetParams[('hipGraphNode_t', 'node'), ('const hipMemcpy3DParms*', 'pNodeParams')]
|
|
#define INIT_hipGraphMemcpyNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams.pNodeParams = (const hipMemcpy3DParms*)pNodeParams; \
|
|
};
|
|
// hipGraphMemcpyNodeSetParams1D[('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphMemcpyNodeSetParams1D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams1D.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams1D.dst = (void*)dst; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams1D.src = (const void*)src; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams1D.count = (size_t)count; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParams1D.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphMemcpyNodeSetParamsFromSymbol[('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphMemcpyNodeSetParamsFromSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.dst = (void*)dst; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsFromSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphMemcpyNodeSetParamsToSymbol[('hipGraphNode_t', 'node'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipGraphMemcpyNodeSetParamsToSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.src = (const void*)src; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.count = (size_t)count; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipGraphMemcpyNodeSetParamsToSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipGraphMemsetNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemsetParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphMemsetNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemsetNodeGetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemsetNodeGetParams.pNodeParams = (hipMemsetParams*)pNodeParams; \
|
|
};
|
|
// hipGraphMemsetNodeSetParams[('hipGraphNode_t', 'node'), ('const hipMemsetParams*', 'pNodeParams')]
|
|
#define INIT_hipGraphMemsetNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphMemsetNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphMemsetNodeSetParams.pNodeParams = (const hipMemsetParams*)pNodeParams; \
|
|
};
|
|
// hipGraphNodeFindInClone[('hipGraphNode_t*', 'pNode'), ('hipGraphNode_t', 'originalNode'), ('hipGraph_t', 'clonedGraph')]
|
|
#define INIT_hipGraphNodeFindInClone_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeFindInClone.pNode = (hipGraphNode_t*)pNode; \
|
|
cb_data.args.hipGraphNodeFindInClone.originalNode = (hipGraphNode_t)originalNode; \
|
|
cb_data.args.hipGraphNodeFindInClone.clonedGraph = (hipGraph_t)clonedGraph; \
|
|
};
|
|
// hipGraphNodeGetDependencies[('hipGraphNode_t', 'node'), ('hipGraphNode_t*', 'pDependencies'), ('size_t*', 'pNumDependencies')]
|
|
#define INIT_hipGraphNodeGetDependencies_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeGetDependencies.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphNodeGetDependencies.pDependencies = (hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphNodeGetDependencies.pNumDependencies = (size_t*)pNumDependencies; \
|
|
};
|
|
// hipGraphNodeGetDependentNodes[('hipGraphNode_t', 'node'), ('hipGraphNode_t*', 'pDependentNodes'), ('size_t*', 'pNumDependentNodes')]
|
|
#define INIT_hipGraphNodeGetDependentNodes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeGetDependentNodes.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphNodeGetDependentNodes.pDependentNodes = (hipGraphNode_t*)pDependentNodes; \
|
|
cb_data.args.hipGraphNodeGetDependentNodes.pNumDependentNodes = (size_t*)pNumDependentNodes; \
|
|
};
|
|
// hipGraphNodeGetEnabled[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('unsigned int*', 'isEnabled')]
|
|
#define INIT_hipGraphNodeGetEnabled_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeGetEnabled.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphNodeGetEnabled.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphNodeGetEnabled.isEnabled = (unsigned int*)isEnabled; \
|
|
};
|
|
// hipGraphNodeGetType[('hipGraphNode_t', 'node'), ('hipGraphNodeType*', 'pType')]
|
|
#define INIT_hipGraphNodeGetType_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeGetType.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphNodeGetType.pType = (hipGraphNodeType*)pType; \
|
|
};
|
|
// hipGraphNodeSetEnabled[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('unsigned int', 'isEnabled')]
|
|
#define INIT_hipGraphNodeSetEnabled_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeSetEnabled.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphNodeSetEnabled.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphNodeSetEnabled.isEnabled = (unsigned int)isEnabled; \
|
|
};
|
|
// hipGraphReleaseUserObject[('hipGraph_t', 'graph'), ('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
#define INIT_hipGraphReleaseUserObject_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphReleaseUserObject.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphReleaseUserObject.object = (hipUserObject_t)object; \
|
|
cb_data.args.hipGraphReleaseUserObject.count = (unsigned int)count; \
|
|
};
|
|
// hipGraphRemoveDependencies[('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'from'), ('const hipGraphNode_t*', 'to'), ('size_t', 'numDependencies')]
|
|
#define INIT_hipGraphRemoveDependencies_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphRemoveDependencies.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphRemoveDependencies.from = (const hipGraphNode_t*)from; \
|
|
cb_data.args.hipGraphRemoveDependencies.to = (const hipGraphNode_t*)to; \
|
|
cb_data.args.hipGraphRemoveDependencies.numDependencies = (size_t)numDependencies; \
|
|
};
|
|
// hipGraphRetainUserObject[('hipGraph_t', 'graph'), ('hipUserObject_t', 'object'), ('unsigned int', 'count'), ('unsigned int', 'flags')]
|
|
#define INIT_hipGraphRetainUserObject_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphRetainUserObject.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphRetainUserObject.object = (hipUserObject_t)object; \
|
|
cb_data.args.hipGraphRetainUserObject.count = (unsigned int)count; \
|
|
cb_data.args.hipGraphRetainUserObject.flags = (unsigned int)flags; \
|
|
};
|
|
// hipGraphUpload[('hipGraphExec_t', 'graphExec'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipGraphUpload_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphUpload.graphExec = (hipGraphExec_t)graphExec; \
|
|
cb_data.args.hipGraphUpload.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipGraphicsGLRegisterBuffer[('hipGraphicsResource**', 'resource'), ('GLuint', 'buffer'), ('unsigned int', 'flags')]
|
|
#define INIT_hipGraphicsGLRegisterBuffer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsGLRegisterBuffer.resource = (hipGraphicsResource**)resource; \
|
|
cb_data.args.hipGraphicsGLRegisterBuffer.buffer = (GLuint)buffer; \
|
|
cb_data.args.hipGraphicsGLRegisterBuffer.flags = (unsigned int)flags; \
|
|
};
|
|
// hipGraphicsGLRegisterImage[('hipGraphicsResource**', 'resource'), ('GLuint', 'image'), ('GLenum', 'target'), ('unsigned int', 'flags')]
|
|
#define INIT_hipGraphicsGLRegisterImage_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsGLRegisterImage.resource = (hipGraphicsResource**)resource; \
|
|
cb_data.args.hipGraphicsGLRegisterImage.image = (GLuint)image; \
|
|
cb_data.args.hipGraphicsGLRegisterImage.target = (GLenum)target; \
|
|
cb_data.args.hipGraphicsGLRegisterImage.flags = (unsigned int)flags; \
|
|
};
|
|
// hipGraphicsMapResources[('int', 'count'), ('hipGraphicsResource_t*', 'resources'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipGraphicsMapResources_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsMapResources.count = (int)count; \
|
|
cb_data.args.hipGraphicsMapResources.resources = (hipGraphicsResource_t*)resources; \
|
|
cb_data.args.hipGraphicsMapResources.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipGraphicsResourceGetMappedPointer[('void**', 'devPtr'), ('size_t*', 'size'), ('hipGraphicsResource_t', 'resource')]
|
|
#define INIT_hipGraphicsResourceGetMappedPointer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsResourceGetMappedPointer.devPtr = (void**)devPtr; \
|
|
cb_data.args.hipGraphicsResourceGetMappedPointer.size = (size_t*)size; \
|
|
cb_data.args.hipGraphicsResourceGetMappedPointer.resource = (hipGraphicsResource_t)resource; \
|
|
};
|
|
// hipGraphicsSubResourceGetMappedArray[('hipArray_t*', 'array'), ('hipGraphicsResource_t', 'resource'), ('unsigned int', 'arrayIndex'), ('unsigned int', 'mipLevel')]
|
|
#define INIT_hipGraphicsSubResourceGetMappedArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsSubResourceGetMappedArray.array = (hipArray_t*)array; \
|
|
cb_data.args.hipGraphicsSubResourceGetMappedArray.resource = (hipGraphicsResource_t)resource; \
|
|
cb_data.args.hipGraphicsSubResourceGetMappedArray.arrayIndex = (unsigned int)arrayIndex; \
|
|
cb_data.args.hipGraphicsSubResourceGetMappedArray.mipLevel = (unsigned int)mipLevel; \
|
|
};
|
|
// hipGraphicsUnmapResources[('int', 'count'), ('hipGraphicsResource_t*', 'resources'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipGraphicsUnmapResources_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsUnmapResources.count = (int)count; \
|
|
cb_data.args.hipGraphicsUnmapResources.resources = (hipGraphicsResource_t*)resources; \
|
|
cb_data.args.hipGraphicsUnmapResources.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipGraphicsUnregisterResource[('hipGraphicsResource_t', 'resource')]
|
|
#define INIT_hipGraphicsUnregisterResource_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphicsUnregisterResource.resource = (hipGraphicsResource_t)resource; \
|
|
};
|
|
// hipHccModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent')]
|
|
#define INIT_hipHccModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHccModuleLaunchKernel.f = (hipFunction_t)f; \
|
|
cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeX = (unsigned int)globalWorkSizeX; \
|
|
cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeY = (unsigned int)globalWorkSizeY; \
|
|
cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeZ = (unsigned int)globalWorkSizeZ; \
|
|
cb_data.args.hipHccModuleLaunchKernel.blockDimX = (unsigned int)blockDimX; \
|
|
cb_data.args.hipHccModuleLaunchKernel.blockDimY = (unsigned int)blockDimY; \
|
|
cb_data.args.hipHccModuleLaunchKernel.blockDimZ = (unsigned int)blockDimZ; \
|
|
cb_data.args.hipHccModuleLaunchKernel.sharedMemBytes = (size_t)sharedMemBytes; \
|
|
cb_data.args.hipHccModuleLaunchKernel.hStream = (hipStream_t)hStream; \
|
|
cb_data.args.hipHccModuleLaunchKernel.kernelParams = (void**)kernelParams; \
|
|
cb_data.args.hipHccModuleLaunchKernel.extra = (void**)extra; \
|
|
cb_data.args.hipHccModuleLaunchKernel.startEvent = (hipEvent_t)startEvent; \
|
|
cb_data.args.hipHccModuleLaunchKernel.stopEvent = (hipEvent_t)stopEvent; \
|
|
};
|
|
// hipHostAlloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
#define INIT_hipHostAlloc_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostAlloc.ptr = (void**)ptr; \
|
|
cb_data.args.hipHostAlloc.size = (size_t)sizeBytes; \
|
|
cb_data.args.hipHostAlloc.flags = (unsigned int)flags; \
|
|
};
|
|
// hipHostFree[('void*', 'ptr')]
|
|
#define INIT_hipHostFree_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostFree.ptr = (void*)ptr; \
|
|
};
|
|
// hipHostGetDevicePointer[('void**', 'devPtr'), ('void*', 'hstPtr'), ('unsigned int', 'flags')]
|
|
#define INIT_hipHostGetDevicePointer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostGetDevicePointer.devPtr = (void**)devicePointer; \
|
|
cb_data.args.hipHostGetDevicePointer.hstPtr = (void*)hostPointer; \
|
|
cb_data.args.hipHostGetDevicePointer.flags = (unsigned int)flags; \
|
|
};
|
|
// hipHostGetFlags[('unsigned int*', 'flagsPtr'), ('void*', 'hostPtr')]
|
|
#define INIT_hipHostGetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostGetFlags.flagsPtr = (unsigned int*)flagsPtr; \
|
|
cb_data.args.hipHostGetFlags.hostPtr = (void*)hostPtr; \
|
|
};
|
|
// hipHostMalloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
#define INIT_hipHostMalloc_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostMalloc.ptr = (void**)ptr; \
|
|
cb_data.args.hipHostMalloc.size = (size_t)sizeBytes; \
|
|
cb_data.args.hipHostMalloc.flags = (unsigned int)flags; \
|
|
};
|
|
// hipHostRegister[('void*', 'hostPtr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
|
|
#define INIT_hipHostRegister_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostRegister.hostPtr = (void*)hostPtr; \
|
|
cb_data.args.hipHostRegister.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipHostRegister.flags = (unsigned int)flags; \
|
|
};
|
|
// hipHostUnregister[('void*', 'hostPtr')]
|
|
#define INIT_hipHostUnregister_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipHostUnregister.hostPtr = (void*)hostPtr; \
|
|
};
|
|
// hipImportExternalMemory[('hipExternalMemory_t*', 'extMem_out'), ('const hipExternalMemoryHandleDesc*', 'memHandleDesc')]
|
|
#define INIT_hipImportExternalMemory_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipImportExternalMemory.extMem_out = (hipExternalMemory_t*)extMem_out; \
|
|
cb_data.args.hipImportExternalMemory.memHandleDesc = (const hipExternalMemoryHandleDesc*)memHandleDesc; \
|
|
};
|
|
// hipImportExternalSemaphore[('hipExternalSemaphore_t*', 'extSem_out'), ('const hipExternalSemaphoreHandleDesc*', 'semHandleDesc')]
|
|
#define INIT_hipImportExternalSemaphore_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipImportExternalSemaphore.extSem_out = (hipExternalSemaphore_t*)extSem_out; \
|
|
cb_data.args.hipImportExternalSemaphore.semHandleDesc = (const hipExternalSemaphoreHandleDesc*)semHandleDesc; \
|
|
};
|
|
// hipInit[('unsigned int', 'flags')]
|
|
#define INIT_hipInit_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipInit.flags = (unsigned int)flags; \
|
|
};
|
|
// hipIpcCloseMemHandle[('void*', 'devPtr')]
|
|
#define INIT_hipIpcCloseMemHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipIpcCloseMemHandle.devPtr = (void*)dev_ptr; \
|
|
};
|
|
// hipIpcGetEventHandle[('hipIpcEventHandle_t*', 'handle'), ('hipEvent_t', 'event')]
|
|
#define INIT_hipIpcGetEventHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipIpcGetEventHandle.handle = (hipIpcEventHandle_t*)handle; \
|
|
cb_data.args.hipIpcGetEventHandle.event = (hipEvent_t)event; \
|
|
};
|
|
// hipIpcGetMemHandle[('hipIpcMemHandle_t*', 'handle'), ('void*', 'devPtr')]
|
|
#define INIT_hipIpcGetMemHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipIpcGetMemHandle.handle = (hipIpcMemHandle_t*)handle; \
|
|
cb_data.args.hipIpcGetMemHandle.devPtr = (void*)dev_ptr; \
|
|
};
|
|
// hipIpcOpenEventHandle[('hipEvent_t*', 'event'), ('hipIpcEventHandle_t', 'handle')]
|
|
#define INIT_hipIpcOpenEventHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipIpcOpenEventHandle.event = (hipEvent_t*)event; \
|
|
cb_data.args.hipIpcOpenEventHandle.handle = (hipIpcEventHandle_t)handle; \
|
|
};
|
|
// hipIpcOpenMemHandle[('void**', 'devPtr'), ('hipIpcMemHandle_t', 'handle'), ('unsigned int', 'flags')]
|
|
#define INIT_hipIpcOpenMemHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipIpcOpenMemHandle.devPtr = (void**)dev_ptr; \
|
|
cb_data.args.hipIpcOpenMemHandle.handle = (hipIpcMemHandle_t)handle; \
|
|
cb_data.args.hipIpcOpenMemHandle.flags = (unsigned int)flags; \
|
|
};
|
|
// hipLaunchByPtr[('const void*', 'hostFunction')]
|
|
#define INIT_hipLaunchByPtr_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchByPtr.hostFunction = (const void*)hostFunction; \
|
|
};
|
|
// hipLaunchCooperativeKernel[('const void*', 'f'), ('dim3', 'gridDim'), ('dim3', 'blockDimX'), ('void**', 'kernelParams'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipLaunchCooperativeKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchCooperativeKernel.f = (const void*)f; \
|
|
cb_data.args.hipLaunchCooperativeKernel.gridDim = (dim3)gridDim; \
|
|
cb_data.args.hipLaunchCooperativeKernel.blockDimX = (dim3)blockDim; \
|
|
cb_data.args.hipLaunchCooperativeKernel.kernelParams = (void**)kernelParams; \
|
|
cb_data.args.hipLaunchCooperativeKernel.sharedMemBytes = (unsigned int)sharedMemBytes; \
|
|
cb_data.args.hipLaunchCooperativeKernel.stream = (hipStream_t)hStream; \
|
|
};
|
|
// hipLaunchCooperativeKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
|
|
#define INIT_hipLaunchCooperativeKernelMultiDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchCooperativeKernelMultiDevice.launchParamsList = (hipLaunchParams*)launchParamsList; \
|
|
cb_data.args.hipLaunchCooperativeKernelMultiDevice.numDevices = (int)numDevices; \
|
|
cb_data.args.hipLaunchCooperativeKernelMultiDevice.flags = (unsigned int)flags; \
|
|
};
|
|
// hipLaunchHostFunc[('hipStream_t', 'stream'), ('hipHostFn_t', 'fn'), ('void*', 'userData')]
|
|
#define INIT_hipLaunchHostFunc_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchHostFunc.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipLaunchHostFunc.fn = (hipHostFn_t)fn; \
|
|
cb_data.args.hipLaunchHostFunc.userData = (void*)userData; \
|
|
};
|
|
// hipLaunchKernel[('const void*', 'function_address'), ('dim3', 'numBlocks'), ('dim3', 'dimBlocks'), ('void**', 'args'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipLaunchKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchKernel.function_address = (const void*)hostFunction; \
|
|
cb_data.args.hipLaunchKernel.numBlocks = (dim3)gridDim; \
|
|
cb_data.args.hipLaunchKernel.dimBlocks = (dim3)blockDim; \
|
|
cb_data.args.hipLaunchKernel.args = (void**)args; \
|
|
cb_data.args.hipLaunchKernel.sharedMemBytes = (size_t)sharedMemBytes; \
|
|
cb_data.args.hipLaunchKernel.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMalloc[('void**', 'ptr'), ('size_t', 'size')]
|
|
#define INIT_hipMalloc_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMalloc.ptr = (void**)ptr; \
|
|
cb_data.args.hipMalloc.size = (size_t)sizeBytes; \
|
|
};
|
|
// hipMalloc3D[('hipPitchedPtr*', 'pitchedDevPtr'), ('hipExtent', 'extent')]
|
|
#define INIT_hipMalloc3D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMalloc3D.pitchedDevPtr = (hipPitchedPtr*)pitchedDevPtr; \
|
|
cb_data.args.hipMalloc3D.extent = (hipExtent)extent; \
|
|
};
|
|
// hipMalloc3DArray[('hipArray_t*', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMalloc3DArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMalloc3DArray.array = (hipArray_t*)array; \
|
|
cb_data.args.hipMalloc3DArray.desc = (const hipChannelFormatDesc*)desc; \
|
|
cb_data.args.hipMalloc3DArray.extent = (hipExtent)extent; \
|
|
cb_data.args.hipMalloc3DArray.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMallocArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('size_t', 'width'), ('size_t', 'height'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMallocArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocArray.array = (hipArray**)array; \
|
|
cb_data.args.hipMallocArray.desc = (const hipChannelFormatDesc*)desc; \
|
|
cb_data.args.hipMallocArray.width = (size_t)width; \
|
|
cb_data.args.hipMallocArray.height = (size_t)height; \
|
|
cb_data.args.hipMallocArray.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMallocAsync[('void**', 'dev_ptr'), ('size_t', 'size'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMallocAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocAsync.dev_ptr = (void**)dev_ptr; \
|
|
cb_data.args.hipMallocAsync.size = (size_t)size; \
|
|
cb_data.args.hipMallocAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMallocFromPoolAsync[('void**', 'dev_ptr'), ('size_t', 'size'), ('hipMemPool_t', 'mem_pool'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMallocFromPoolAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocFromPoolAsync.dev_ptr = (void**)dev_ptr; \
|
|
cb_data.args.hipMallocFromPoolAsync.size = (size_t)size; \
|
|
cb_data.args.hipMallocFromPoolAsync.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMallocFromPoolAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMallocHost[('void**', 'ptr'), ('size_t', 'size')]
|
|
#define INIT_hipMallocHost_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocHost.ptr = (void**)ptr; \
|
|
cb_data.args.hipMallocHost.size = (size_t)size; \
|
|
};
|
|
// hipMallocManaged[('void**', 'dev_ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMallocManaged_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocManaged.dev_ptr = (void**)dev_ptr; \
|
|
cb_data.args.hipMallocManaged.size = (size_t)size; \
|
|
cb_data.args.hipMallocManaged.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMallocMipmappedArray[('hipMipmappedArray_t*', 'mipmappedArray'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'numLevels'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMallocMipmappedArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocMipmappedArray.mipmappedArray = (hipMipmappedArray_t*)mipmappedArray; \
|
|
cb_data.args.hipMallocMipmappedArray.desc = (const hipChannelFormatDesc*)desc; \
|
|
cb_data.args.hipMallocMipmappedArray.extent = (hipExtent)extent; \
|
|
cb_data.args.hipMallocMipmappedArray.numLevels = (unsigned int)numLevels; \
|
|
cb_data.args.hipMallocMipmappedArray.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMallocPitch[('void**', 'ptr'), ('size_t*', 'pitch'), ('size_t', 'width'), ('size_t', 'height')]
|
|
#define INIT_hipMallocPitch_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMallocPitch.ptr = (void**)ptr; \
|
|
cb_data.args.hipMallocPitch.pitch = (size_t*)pitch; \
|
|
cb_data.args.hipMallocPitch.width = (size_t)width; \
|
|
cb_data.args.hipMallocPitch.height = (size_t)height; \
|
|
};
|
|
// hipMemAddressFree[('void*', 'devPtr'), ('size_t', 'size')]
|
|
#define INIT_hipMemAddressFree_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemAddressFree.devPtr = (void*)devPtr; \
|
|
cb_data.args.hipMemAddressFree.size = (size_t)size; \
|
|
};
|
|
// hipMemAddressReserve[('void**', 'ptr'), ('size_t', 'size'), ('size_t', 'alignment'), ('void*', 'addr'), ('unsigned long long', 'flags')]
|
|
#define INIT_hipMemAddressReserve_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemAddressReserve.ptr = (void**)ptr; \
|
|
cb_data.args.hipMemAddressReserve.size = (size_t)size; \
|
|
cb_data.args.hipMemAddressReserve.alignment = (size_t)alignment; \
|
|
cb_data.args.hipMemAddressReserve.addr = (void*)addr; \
|
|
cb_data.args.hipMemAddressReserve.flags = (unsigned long long)flags; \
|
|
};
|
|
// hipMemAdvise[('const void*', 'dev_ptr'), ('size_t', 'count'), ('hipMemoryAdvise', 'advice'), ('int', 'device')]
|
|
#define INIT_hipMemAdvise_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemAdvise.dev_ptr = (const void*)dev_ptr; \
|
|
cb_data.args.hipMemAdvise.count = (size_t)count; \
|
|
cb_data.args.hipMemAdvise.advice = (hipMemoryAdvise)advice; \
|
|
cb_data.args.hipMemAdvise.device = (int)device; \
|
|
};
|
|
// hipMemAllocHost[('void**', 'ptr'), ('size_t', 'size')]
|
|
#define INIT_hipMemAllocHost_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemAllocHost.ptr = (void**)ptr; \
|
|
cb_data.args.hipMemAllocHost.size = (size_t)size; \
|
|
};
|
|
// hipMemAllocPitch[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'pitch'), ('size_t', 'widthInBytes'), ('size_t', 'height'), ('unsigned int', 'elementSizeBytes')]
|
|
#define INIT_hipMemAllocPitch_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemAllocPitch.dptr = (hipDeviceptr_t*)dptr; \
|
|
cb_data.args.hipMemAllocPitch.pitch = (size_t*)pitch; \
|
|
cb_data.args.hipMemAllocPitch.widthInBytes = (size_t)widthInBytes; \
|
|
cb_data.args.hipMemAllocPitch.height = (size_t)height; \
|
|
cb_data.args.hipMemAllocPitch.elementSizeBytes = (unsigned int)elementSizeBytes; \
|
|
};
|
|
// hipMemCreate[('hipMemGenericAllocationHandle_t*', 'handle'), ('size_t', 'size'), ('const hipMemAllocationProp*', 'prop'), ('unsigned long long', 'flags')]
|
|
#define INIT_hipMemCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemCreate.handle = (hipMemGenericAllocationHandle_t*)handle; \
|
|
cb_data.args.hipMemCreate.size = (size_t)size; \
|
|
cb_data.args.hipMemCreate.prop = (const hipMemAllocationProp*)prop; \
|
|
cb_data.args.hipMemCreate.flags = (unsigned long long)flags; \
|
|
};
|
|
// hipMemExportToShareableHandle[('void*', 'shareableHandle'), ('hipMemGenericAllocationHandle_t', 'handle'), ('hipMemAllocationHandleType', 'handleType'), ('unsigned long long', 'flags')]
|
|
#define INIT_hipMemExportToShareableHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemExportToShareableHandle.shareableHandle = (void*)shareableHandle; \
|
|
cb_data.args.hipMemExportToShareableHandle.handle = (hipMemGenericAllocationHandle_t)handle; \
|
|
cb_data.args.hipMemExportToShareableHandle.handleType = (hipMemAllocationHandleType)handleType; \
|
|
cb_data.args.hipMemExportToShareableHandle.flags = (unsigned long long)flags; \
|
|
};
|
|
// hipMemGetAccess[('unsigned long long*', 'flags'), ('const hipMemLocation*', 'location'), ('void*', 'ptr')]
|
|
#define INIT_hipMemGetAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemGetAccess.flags = (unsigned long long*)flags; \
|
|
cb_data.args.hipMemGetAccess.location = (const hipMemLocation*)location; \
|
|
cb_data.args.hipMemGetAccess.ptr = (void*)ptr; \
|
|
};
|
|
// hipMemGetAddressRange[('hipDeviceptr_t*', 'pbase'), ('size_t*', 'psize'), ('hipDeviceptr_t', 'dptr')]
|
|
#define INIT_hipMemGetAddressRange_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemGetAddressRange.pbase = (hipDeviceptr_t*)pbase; \
|
|
cb_data.args.hipMemGetAddressRange.psize = (size_t*)psize; \
|
|
cb_data.args.hipMemGetAddressRange.dptr = (hipDeviceptr_t)dptr; \
|
|
};
|
|
// hipMemGetAllocationGranularity[('size_t*', 'granularity'), ('const hipMemAllocationProp*', 'prop'), ('hipMemAllocationGranularity_flags', 'option')]
|
|
#define INIT_hipMemGetAllocationGranularity_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemGetAllocationGranularity.granularity = (size_t*)granularity; \
|
|
cb_data.args.hipMemGetAllocationGranularity.prop = (const hipMemAllocationProp*)prop; \
|
|
cb_data.args.hipMemGetAllocationGranularity.option = (hipMemAllocationGranularity_flags)option; \
|
|
};
|
|
// hipMemGetAllocationPropertiesFromHandle[('hipMemAllocationProp*', 'prop'), ('hipMemGenericAllocationHandle_t', 'handle')]
|
|
#define INIT_hipMemGetAllocationPropertiesFromHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemGetAllocationPropertiesFromHandle.prop = (hipMemAllocationProp*)prop; \
|
|
cb_data.args.hipMemGetAllocationPropertiesFromHandle.handle = (hipMemGenericAllocationHandle_t)handle; \
|
|
};
|
|
// hipMemGetInfo[('size_t*', 'free'), ('size_t*', 'total')]
|
|
#define INIT_hipMemGetInfo_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemGetInfo.free = (size_t*)free; \
|
|
cb_data.args.hipMemGetInfo.total = (size_t*)total; \
|
|
};
|
|
// hipMemImportFromShareableHandle[('hipMemGenericAllocationHandle_t*', 'handle'), ('void*', 'osHandle'), ('hipMemAllocationHandleType', 'shHandleType')]
|
|
#define INIT_hipMemImportFromShareableHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemImportFromShareableHandle.handle = (hipMemGenericAllocationHandle_t*)handle; \
|
|
cb_data.args.hipMemImportFromShareableHandle.osHandle = (void*)osHandle; \
|
|
cb_data.args.hipMemImportFromShareableHandle.shHandleType = (hipMemAllocationHandleType)shHandleType; \
|
|
};
|
|
// hipMemMap[('void*', 'ptr'), ('size_t', 'size'), ('size_t', 'offset'), ('hipMemGenericAllocationHandle_t', 'handle'), ('unsigned long long', 'flags')]
|
|
#define INIT_hipMemMap_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemMap.ptr = (void*)ptr; \
|
|
cb_data.args.hipMemMap.size = (size_t)size; \
|
|
cb_data.args.hipMemMap.offset = (size_t)offset; \
|
|
cb_data.args.hipMemMap.handle = (hipMemGenericAllocationHandle_t)handle; \
|
|
cb_data.args.hipMemMap.flags = (unsigned long long)flags; \
|
|
};
|
|
// hipMemMapArrayAsync[('hipArrayMapInfo*', 'mapInfoList'), ('unsigned int', 'count'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemMapArrayAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemMapArrayAsync.mapInfoList = (hipArrayMapInfo*)mapInfoList; \
|
|
cb_data.args.hipMemMapArrayAsync.count = (unsigned int)count; \
|
|
cb_data.args.hipMemMapArrayAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemPoolCreate[('hipMemPool_t*', 'mem_pool'), ('const hipMemPoolProps*', 'pool_props')]
|
|
#define INIT_hipMemPoolCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolCreate.mem_pool = (hipMemPool_t*)mem_pool; \
|
|
cb_data.args.hipMemPoolCreate.pool_props = (const hipMemPoolProps*)pool_props; \
|
|
};
|
|
// hipMemPoolDestroy[('hipMemPool_t', 'mem_pool')]
|
|
#define INIT_hipMemPoolDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolDestroy.mem_pool = (hipMemPool_t)mem_pool; \
|
|
};
|
|
// hipMemPoolExportPointer[('hipMemPoolPtrExportData*', 'export_data'), ('void*', 'dev_ptr')]
|
|
#define INIT_hipMemPoolExportPointer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolExportPointer.export_data = (hipMemPoolPtrExportData*)export_data; \
|
|
cb_data.args.hipMemPoolExportPointer.dev_ptr = (void*)ptr; \
|
|
};
|
|
// hipMemPoolExportToShareableHandle[('void*', 'shared_handle'), ('hipMemPool_t', 'mem_pool'), ('hipMemAllocationHandleType', 'handle_type'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMemPoolExportToShareableHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolExportToShareableHandle.shared_handle = (void*)shared_handle; \
|
|
cb_data.args.hipMemPoolExportToShareableHandle.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolExportToShareableHandle.handle_type = (hipMemAllocationHandleType)handle_type; \
|
|
cb_data.args.hipMemPoolExportToShareableHandle.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMemPoolGetAccess[('hipMemAccessFlags*', 'flags'), ('hipMemPool_t', 'mem_pool'), ('hipMemLocation*', 'location')]
|
|
#define INIT_hipMemPoolGetAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolGetAccess.flags = (hipMemAccessFlags*)flags; \
|
|
cb_data.args.hipMemPoolGetAccess.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolGetAccess.location = (hipMemLocation*)location; \
|
|
};
|
|
// hipMemPoolGetAttribute[('hipMemPool_t', 'mem_pool'), ('hipMemPoolAttr', 'attr'), ('void*', 'value')]
|
|
#define INIT_hipMemPoolGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolGetAttribute.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolGetAttribute.attr = (hipMemPoolAttr)attr; \
|
|
cb_data.args.hipMemPoolGetAttribute.value = (void*)value; \
|
|
};
|
|
// hipMemPoolImportFromShareableHandle[('hipMemPool_t*', 'mem_pool'), ('void*', 'shared_handle'), ('hipMemAllocationHandleType', 'handle_type'), ('unsigned int', 'flags')]
|
|
#define INIT_hipMemPoolImportFromShareableHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolImportFromShareableHandle.mem_pool = (hipMemPool_t*)mem_pool; \
|
|
cb_data.args.hipMemPoolImportFromShareableHandle.shared_handle = (void*)shared_handle; \
|
|
cb_data.args.hipMemPoolImportFromShareableHandle.handle_type = (hipMemAllocationHandleType)handle_type; \
|
|
cb_data.args.hipMemPoolImportFromShareableHandle.flags = (unsigned int)flags; \
|
|
};
|
|
// hipMemPoolImportPointer[('void**', 'dev_ptr'), ('hipMemPool_t', 'mem_pool'), ('hipMemPoolPtrExportData*', 'export_data')]
|
|
#define INIT_hipMemPoolImportPointer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolImportPointer.dev_ptr = (void**)ptr; \
|
|
cb_data.args.hipMemPoolImportPointer.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolImportPointer.export_data = (hipMemPoolPtrExportData*)export_data; \
|
|
};
|
|
// hipMemPoolSetAccess[('hipMemPool_t', 'mem_pool'), ('const hipMemAccessDesc*', 'desc_list'), ('size_t', 'count')]
|
|
#define INIT_hipMemPoolSetAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolSetAccess.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolSetAccess.desc_list = (const hipMemAccessDesc*)desc_list; \
|
|
cb_data.args.hipMemPoolSetAccess.count = (size_t)count; \
|
|
};
|
|
// hipMemPoolSetAttribute[('hipMemPool_t', 'mem_pool'), ('hipMemPoolAttr', 'attr'), ('void*', 'value')]
|
|
#define INIT_hipMemPoolSetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolSetAttribute.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolSetAttribute.attr = (hipMemPoolAttr)attr; \
|
|
cb_data.args.hipMemPoolSetAttribute.value = (void*)value; \
|
|
};
|
|
// hipMemPoolTrimTo[('hipMemPool_t', 'mem_pool'), ('size_t', 'min_bytes_to_hold')]
|
|
#define INIT_hipMemPoolTrimTo_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPoolTrimTo.mem_pool = (hipMemPool_t)mem_pool; \
|
|
cb_data.args.hipMemPoolTrimTo.min_bytes_to_hold = (size_t)min_bytes_to_hold; \
|
|
};
|
|
// hipMemPrefetchAsync[('const void*', 'dev_ptr'), ('size_t', 'count'), ('int', 'device'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemPrefetchAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPrefetchAsync.dev_ptr = (const void*)dev_ptr; \
|
|
cb_data.args.hipMemPrefetchAsync.count = (size_t)count; \
|
|
cb_data.args.hipMemPrefetchAsync.device = (int)device; \
|
|
cb_data.args.hipMemPrefetchAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemPtrGetInfo[('void*', 'ptr'), ('size_t*', 'size')]
|
|
#define INIT_hipMemPtrGetInfo_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemPtrGetInfo.ptr = (void*)ptr; \
|
|
cb_data.args.hipMemPtrGetInfo.size = (size_t*)size; \
|
|
};
|
|
// hipMemRangeGetAttribute[('void*', 'data'), ('size_t', 'data_size'), ('hipMemRangeAttribute', 'attribute'), ('const void*', 'dev_ptr'), ('size_t', 'count')]
|
|
#define INIT_hipMemRangeGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemRangeGetAttribute.data = (void*)data; \
|
|
cb_data.args.hipMemRangeGetAttribute.data_size = (size_t)data_size; \
|
|
cb_data.args.hipMemRangeGetAttribute.attribute = (hipMemRangeAttribute)attribute; \
|
|
cb_data.args.hipMemRangeGetAttribute.dev_ptr = (const void*)dev_ptr; \
|
|
cb_data.args.hipMemRangeGetAttribute.count = (size_t)count; \
|
|
};
|
|
// hipMemRangeGetAttributes[('void**', 'data'), ('size_t*', 'data_sizes'), ('hipMemRangeAttribute*', 'attributes'), ('size_t', 'num_attributes'), ('const void*', 'dev_ptr'), ('size_t', 'count')]
|
|
#define INIT_hipMemRangeGetAttributes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemRangeGetAttributes.data = (void**)data; \
|
|
cb_data.args.hipMemRangeGetAttributes.data_sizes = (size_t*)data_sizes; \
|
|
cb_data.args.hipMemRangeGetAttributes.attributes = (hipMemRangeAttribute*)attributes; \
|
|
cb_data.args.hipMemRangeGetAttributes.num_attributes = (size_t)num_attributes; \
|
|
cb_data.args.hipMemRangeGetAttributes.dev_ptr = (const void*)dev_ptr; \
|
|
cb_data.args.hipMemRangeGetAttributes.count = (size_t)count; \
|
|
};
|
|
// hipMemRelease[('hipMemGenericAllocationHandle_t', 'handle')]
|
|
#define INIT_hipMemRelease_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemRelease.handle = (hipMemGenericAllocationHandle_t)handle; \
|
|
};
|
|
// hipMemRetainAllocationHandle[('hipMemGenericAllocationHandle_t*', 'handle'), ('void*', 'addr')]
|
|
#define INIT_hipMemRetainAllocationHandle_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemRetainAllocationHandle.handle = (hipMemGenericAllocationHandle_t*)handle; \
|
|
cb_data.args.hipMemRetainAllocationHandle.addr = (void*)addr; \
|
|
};
|
|
// hipMemSetAccess[('void*', 'ptr'), ('size_t', 'size'), ('const hipMemAccessDesc*', 'desc'), ('size_t', 'count')]
|
|
#define INIT_hipMemSetAccess_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemSetAccess.ptr = (void*)ptr; \
|
|
cb_data.args.hipMemSetAccess.size = (size_t)size; \
|
|
cb_data.args.hipMemSetAccess.desc = (const hipMemAccessDesc*)desc; \
|
|
cb_data.args.hipMemSetAccess.count = (size_t)count; \
|
|
};
|
|
// hipMemUnmap[('void*', 'ptr'), ('size_t', 'size')]
|
|
#define INIT_hipMemUnmap_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemUnmap.ptr = (void*)ptr; \
|
|
cb_data.args.hipMemUnmap.size = (size_t)size; \
|
|
};
|
|
// hipMemcpy[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpy.src = (const void*)src; \
|
|
cb_data.args.hipMemcpy.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpy.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpy2D[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpy2D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2D.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpy2D.dpitch = (size_t)dpitch; \
|
|
cb_data.args.hipMemcpy2D.src = (const void*)src; \
|
|
cb_data.args.hipMemcpy2D.spitch = (size_t)spitch; \
|
|
cb_data.args.hipMemcpy2D.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2D.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2D.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpy2DAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpy2DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpy2DAsync.dpitch = (size_t)dpitch; \
|
|
cb_data.args.hipMemcpy2DAsync.src = (const void*)src; \
|
|
cb_data.args.hipMemcpy2DAsync.spitch = (size_t)spitch; \
|
|
cb_data.args.hipMemcpy2DAsync.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DAsync.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpy2DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpy2DFromArray[('void*', 'dst'), ('size_t', 'dpitch'), ('hipArray_const_t', 'src'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpy2DFromArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DFromArray.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpy2DFromArray.dpitch = (size_t)dpitch; \
|
|
cb_data.args.hipMemcpy2DFromArray.src = (hipArray_const_t)src; \
|
|
cb_data.args.hipMemcpy2DFromArray.wOffset = (size_t)wOffsetSrc; \
|
|
cb_data.args.hipMemcpy2DFromArray.hOffset = (size_t)hOffset; \
|
|
cb_data.args.hipMemcpy2DFromArray.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DFromArray.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DFromArray.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpy2DFromArrayAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('hipArray_const_t', 'src'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpy2DFromArrayAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.dpitch = (size_t)dpitch; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.src = (hipArray_const_t)src; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.wOffset = (size_t)wOffsetSrc; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.hOffset = (size_t)hOffsetSrc; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpy2DFromArrayAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpy2DToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpy2DToArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DToArray.dst = (hipArray*)dst; \
|
|
cb_data.args.hipMemcpy2DToArray.wOffset = (size_t)wOffset; \
|
|
cb_data.args.hipMemcpy2DToArray.hOffset = (size_t)hOffset; \
|
|
cb_data.args.hipMemcpy2DToArray.src = (const void*)src; \
|
|
cb_data.args.hipMemcpy2DToArray.spitch = (size_t)spitch; \
|
|
cb_data.args.hipMemcpy2DToArray.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DToArray.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DToArray.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpy2DToArrayAsync[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpy2DToArrayAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.dst = (hipArray*)dst; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.wOffset = (size_t)wOffset; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.hOffset = (size_t)hOffset; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.src = (const void*)src; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.spitch = (size_t)spitch; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpy2DToArrayAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpy3D[('const hipMemcpy3DParms*', 'p')]
|
|
#define INIT_hipMemcpy3D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy3D.p = (const hipMemcpy3DParms*)p; \
|
|
};
|
|
// hipMemcpy3DAsync[('const hipMemcpy3DParms*', 'p'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpy3DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy3DAsync.p = (const hipMemcpy3DParms*)p; \
|
|
cb_data.args.hipMemcpy3DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyAsync[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyAsync.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyAsync.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpyAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyAtoH[('void*', 'dst'), ('hipArray*', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'count')]
|
|
#define INIT_hipMemcpyAtoH_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyAtoH.dst = (void*)dstHost; \
|
|
cb_data.args.hipMemcpyAtoH.srcArray = (hipArray*)srcArray; \
|
|
cb_data.args.hipMemcpyAtoH.srcOffset = (size_t)srcOffset; \
|
|
cb_data.args.hipMemcpyAtoH.count = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyDtoD[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
|
|
#define INIT_hipMemcpyDtoD_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyDtoD.dst = (hipDeviceptr_t)dstDevice; \
|
|
cb_data.args.hipMemcpyDtoD.src = (hipDeviceptr_t)srcDevice; \
|
|
cb_data.args.hipMemcpyDtoD.sizeBytes = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyDtoDAsync[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyDtoDAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyDtoDAsync.dst = (hipDeviceptr_t)dstDevice; \
|
|
cb_data.args.hipMemcpyDtoDAsync.src = (hipDeviceptr_t)srcDevice; \
|
|
cb_data.args.hipMemcpyDtoDAsync.sizeBytes = (size_t)ByteCount; \
|
|
cb_data.args.hipMemcpyDtoDAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyDtoH[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
|
|
#define INIT_hipMemcpyDtoH_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyDtoH.dst = (void*)dstHost; \
|
|
cb_data.args.hipMemcpyDtoH.src = (hipDeviceptr_t)srcDevice; \
|
|
cb_data.args.hipMemcpyDtoH.sizeBytes = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyDtoHAsync[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyDtoHAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyDtoHAsync.dst = (void*)dstHost; \
|
|
cb_data.args.hipMemcpyDtoHAsync.src = (hipDeviceptr_t)srcDevice; \
|
|
cb_data.args.hipMemcpyDtoHAsync.sizeBytes = (size_t)ByteCount; \
|
|
cb_data.args.hipMemcpyDtoHAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyFromArray[('void*', 'dst'), ('hipArray_const_t', 'srcArray'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpyFromArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyFromArray.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyFromArray.srcArray = (hipArray_const_t)src; \
|
|
cb_data.args.hipMemcpyFromArray.wOffset = (size_t)wOffsetSrc; \
|
|
cb_data.args.hipMemcpyFromArray.hOffset = (size_t)hOffset; \
|
|
cb_data.args.hipMemcpyFromArray.count = (size_t)count; \
|
|
cb_data.args.hipMemcpyFromArray.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpyFromSymbol[('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpyFromSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyFromSymbol.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyFromSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipMemcpyFromSymbol.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyFromSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipMemcpyFromSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpyFromSymbolAsync[('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyFromSymbolAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.symbol = (const void*)symbol; \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.offset = (size_t)offset; \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpyFromSymbolAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyHtoA[('hipArray*', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
|
|
#define INIT_hipMemcpyHtoA_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyHtoA.dstArray = (hipArray*)dstArray; \
|
|
cb_data.args.hipMemcpyHtoA.dstOffset = (size_t)dstOffset; \
|
|
cb_data.args.hipMemcpyHtoA.srcHost = (const void*)srcHost; \
|
|
cb_data.args.hipMemcpyHtoA.count = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyHtoD[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes')]
|
|
#define INIT_hipMemcpyHtoD_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyHtoD.dst = (hipDeviceptr_t)dstDevice; \
|
|
cb_data.args.hipMemcpyHtoD.src = (void*)srcHost; \
|
|
cb_data.args.hipMemcpyHtoD.sizeBytes = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyHtoDAsync[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyHtoDAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyHtoDAsync.dst = (hipDeviceptr_t)dstDevice; \
|
|
cb_data.args.hipMemcpyHtoDAsync.src = (void*)srcHost; \
|
|
cb_data.args.hipMemcpyHtoDAsync.sizeBytes = (size_t)ByteCount; \
|
|
cb_data.args.hipMemcpyHtoDAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyParam2D[('const hip_Memcpy2D*', 'pCopy')]
|
|
#define INIT_hipMemcpyParam2D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyParam2D.pCopy = (const hip_Memcpy2D*)pCopy; \
|
|
};
|
|
// hipMemcpyParam2DAsync[('const hip_Memcpy2D*', 'pCopy'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyParam2DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyParam2DAsync.pCopy = (const hip_Memcpy2D*)pCopy; \
|
|
cb_data.args.hipMemcpyParam2DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyPeer[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDeviceId'), ('size_t', 'sizeBytes')]
|
|
#define INIT_hipMemcpyPeer_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyPeer.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyPeer.dstDeviceId = (int)dstDevice; \
|
|
cb_data.args.hipMemcpyPeer.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyPeer.srcDeviceId = (int)srcDevice; \
|
|
cb_data.args.hipMemcpyPeer.sizeBytes = (size_t)sizeBytes; \
|
|
};
|
|
// hipMemcpyPeerAsync[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDevice'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyPeerAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyPeerAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyPeerAsync.dstDeviceId = (int)dstDevice; \
|
|
cb_data.args.hipMemcpyPeerAsync.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyPeerAsync.srcDevice = (int)srcDevice; \
|
|
cb_data.args.hipMemcpyPeerAsync.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyPeerAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpyToArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyToArray.dst = (hipArray*)dst; \
|
|
cb_data.args.hipMemcpyToArray.wOffset = (size_t)wOffset; \
|
|
cb_data.args.hipMemcpyToArray.hOffset = (size_t)hOffset; \
|
|
cb_data.args.hipMemcpyToArray.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyToArray.count = (size_t)count; \
|
|
cb_data.args.hipMemcpyToArray.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpyToSymbol[('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpyToSymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyToSymbol.symbol = (const void*)symbol; \
|
|
cb_data.args.hipMemcpyToSymbol.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyToSymbol.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyToSymbol.offset = (size_t)offset; \
|
|
cb_data.args.hipMemcpyToSymbol.kind = (hipMemcpyKind)kind; \
|
|
};
|
|
// hipMemcpyToSymbolAsync[('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyToSymbolAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyToSymbolAsync.symbol = (const void*)symbol; \
|
|
cb_data.args.hipMemcpyToSymbolAsync.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyToSymbolAsync.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyToSymbolAsync.offset = (size_t)offset; \
|
|
cb_data.args.hipMemcpyToSymbolAsync.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpyToSymbolAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyWithStream[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyWithStream_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyWithStream.dst = (void*)dst; \
|
|
cb_data.args.hipMemcpyWithStream.src = (const void*)src; \
|
|
cb_data.args.hipMemcpyWithStream.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemcpyWithStream.kind = (hipMemcpyKind)kind; \
|
|
cb_data.args.hipMemcpyWithStream.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemset[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes')]
|
|
#define INIT_hipMemset_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemset.dst = (void*)dst; \
|
|
cb_data.args.hipMemset.value = (int)value; \
|
|
cb_data.args.hipMemset.sizeBytes = (size_t)sizeBytes; \
|
|
};
|
|
// hipMemset2D[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height')]
|
|
#define INIT_hipMemset2D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemset2D.dst = (void*)dst; \
|
|
cb_data.args.hipMemset2D.pitch = (size_t)pitch; \
|
|
cb_data.args.hipMemset2D.value = (int)value; \
|
|
cb_data.args.hipMemset2D.width = (size_t)width; \
|
|
cb_data.args.hipMemset2D.height = (size_t)height; \
|
|
};
|
|
// hipMemset2DAsync[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemset2DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemset2DAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemset2DAsync.pitch = (size_t)pitch; \
|
|
cb_data.args.hipMemset2DAsync.value = (int)value; \
|
|
cb_data.args.hipMemset2DAsync.width = (size_t)width; \
|
|
cb_data.args.hipMemset2DAsync.height = (size_t)height; \
|
|
cb_data.args.hipMemset2DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemset3D[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent')]
|
|
#define INIT_hipMemset3D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemset3D.pitchedDevPtr = (hipPitchedPtr)pitchedDevPtr; \
|
|
cb_data.args.hipMemset3D.value = (int)value; \
|
|
cb_data.args.hipMemset3D.extent = (hipExtent)extent; \
|
|
};
|
|
// hipMemset3DAsync[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemset3DAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemset3DAsync.pitchedDevPtr = (hipPitchedPtr)pitchedDevPtr; \
|
|
cb_data.args.hipMemset3DAsync.value = (int)value; \
|
|
cb_data.args.hipMemset3DAsync.extent = (hipExtent)extent; \
|
|
cb_data.args.hipMemset3DAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemsetAsync[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemsetAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetAsync.dst = (void*)dst; \
|
|
cb_data.args.hipMemsetAsync.value = (int)value; \
|
|
cb_data.args.hipMemsetAsync.sizeBytes = (size_t)sizeBytes; \
|
|
cb_data.args.hipMemsetAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemsetD16[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count')]
|
|
#define INIT_hipMemsetD16_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD16.dest = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD16.value = (unsigned short)value; \
|
|
cb_data.args.hipMemsetD16.count = (size_t)count; \
|
|
};
|
|
// hipMemsetD16Async[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemsetD16Async_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD16Async.dest = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD16Async.value = (unsigned short)value; \
|
|
cb_data.args.hipMemsetD16Async.count = (size_t)count; \
|
|
cb_data.args.hipMemsetD16Async.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemsetD32[('hipDeviceptr_t', 'dest'), ('int', 'value'), ('size_t', 'count')]
|
|
#define INIT_hipMemsetD32_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD32.dest = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD32.value = (int)value; \
|
|
cb_data.args.hipMemsetD32.count = (size_t)count; \
|
|
};
|
|
// hipMemsetD32Async[('hipDeviceptr_t', 'dst'), ('int', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemsetD32Async_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD32Async.dst = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD32Async.value = (int)value; \
|
|
cb_data.args.hipMemsetD32Async.count = (size_t)count; \
|
|
cb_data.args.hipMemsetD32Async.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemsetD8[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count')]
|
|
#define INIT_hipMemsetD8_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD8.dest = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD8.value = (unsigned char)value; \
|
|
cb_data.args.hipMemsetD8.count = (size_t)count; \
|
|
};
|
|
// hipMemsetD8Async[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemsetD8Async_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemsetD8Async.dest = (hipDeviceptr_t)dst; \
|
|
cb_data.args.hipMemsetD8Async.value = (unsigned char)value; \
|
|
cb_data.args.hipMemsetD8Async.count = (size_t)count; \
|
|
cb_data.args.hipMemsetD8Async.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMipmappedArrayCreate[('hipMipmappedArray_t*', 'pHandle'), ('HIP_ARRAY3D_DESCRIPTOR*', 'pMipmappedArrayDesc'), ('unsigned int', 'numMipmapLevels')]
|
|
#define INIT_hipMipmappedArrayCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMipmappedArrayCreate.pHandle = (hipMipmappedArray_t*)mipmapped_array_pptr; \
|
|
cb_data.args.hipMipmappedArrayCreate.pMipmappedArrayDesc = (HIP_ARRAY3D_DESCRIPTOR*)mipmapped_array_desc_ptr; \
|
|
cb_data.args.hipMipmappedArrayCreate.numMipmapLevels = (unsigned int)num_mipmap_levels; \
|
|
};
|
|
// hipMipmappedArrayDestroy[('hipMipmappedArray_t', 'hMipmappedArray')]
|
|
#define INIT_hipMipmappedArrayDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMipmappedArrayDestroy.hMipmappedArray = (hipMipmappedArray_t)mipmapped_array_ptr; \
|
|
};
|
|
// hipMipmappedArrayGetLevel[('hipArray_t*', 'pLevelArray'), ('hipMipmappedArray_t', 'hMipMappedArray'), ('unsigned int', 'level')]
|
|
#define INIT_hipMipmappedArrayGetLevel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMipmappedArrayGetLevel.pLevelArray = (hipArray_t*)level_array_pptr; \
|
|
cb_data.args.hipMipmappedArrayGetLevel.hMipMappedArray = (hipMipmappedArray_t)mipmapped_array_ptr; \
|
|
cb_data.args.hipMipmappedArrayGetLevel.level = (unsigned int)mip_level; \
|
|
};
|
|
// hipModuleGetFunction[('hipFunction_t*', 'function'), ('hipModule_t', 'module'), ('const char*', 'kname')]
|
|
#define INIT_hipModuleGetFunction_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleGetFunction.function = (hipFunction_t*)hfunc; \
|
|
cb_data.args.hipModuleGetFunction.module = (hipModule_t)hmod; \
|
|
cb_data.args.hipModuleGetFunction.kname = (name) ? strdup(name) : NULL; \
|
|
};
|
|
// hipModuleGetGlobal[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'bytes'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
|
|
#define INIT_hipModuleGetGlobal_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleGetGlobal.dptr = (hipDeviceptr_t*)dptr; \
|
|
cb_data.args.hipModuleGetGlobal.bytes = (size_t*)bytes; \
|
|
cb_data.args.hipModuleGetGlobal.hmod = (hipModule_t)hmod; \
|
|
cb_data.args.hipModuleGetGlobal.name = (name) ? strdup(name) : NULL; \
|
|
};
|
|
// hipModuleGetTexRef[('textureReference**', 'texRef'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
|
|
#define INIT_hipModuleGetTexRef_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleGetTexRef.texRef = (textureReference**)texRef; \
|
|
cb_data.args.hipModuleGetTexRef.hmod = (hipModule_t)hmod; \
|
|
cb_data.args.hipModuleGetTexRef.name = (name) ? strdup(name) : NULL; \
|
|
};
|
|
// hipModuleLaunchCooperativeKernel[('hipFunction_t', 'f'), ('unsigned int', 'gridDimX'), ('unsigned int', 'gridDimY'), ('unsigned int', 'gridDimZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('void**', 'kernelParams')]
|
|
#define INIT_hipModuleLaunchCooperativeKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.gridDimX = (unsigned int)gridDimX; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.gridDimY = (unsigned int)gridDimY; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.gridDimZ = (unsigned int)gridDimZ; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.blockDimX = (unsigned int)blockDimX; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.blockDimY = (unsigned int)blockDimY; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.blockDimZ = (unsigned int)blockDimZ; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.sharedMemBytes = (unsigned int)sharedMemBytes; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernel.kernelParams = (void**)kernelParams; \
|
|
};
|
|
// hipModuleLaunchCooperativeKernelMultiDevice[('hipFunctionLaunchParams*', 'launchParamsList'), ('unsigned int', 'numDevices'), ('unsigned int', 'flags')]
|
|
#define INIT_hipModuleLaunchCooperativeKernelMultiDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList = (hipFunctionLaunchParams*)launchParamsList; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernelMultiDevice.numDevices = (unsigned int)numDevices; \
|
|
cb_data.args.hipModuleLaunchCooperativeKernelMultiDevice.flags = (unsigned int)flags; \
|
|
};
|
|
// hipModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'gridDimX'), ('unsigned int', 'gridDimY'), ('unsigned int', 'gridDimZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('void**', 'kernelParams'), ('void**', 'extra')]
|
|
#define INIT_hipModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLaunchKernel.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleLaunchKernel.gridDimX = (unsigned int)gridDimX; \
|
|
cb_data.args.hipModuleLaunchKernel.gridDimY = (unsigned int)gridDimY; \
|
|
cb_data.args.hipModuleLaunchKernel.gridDimZ = (unsigned int)gridDimZ; \
|
|
cb_data.args.hipModuleLaunchKernel.blockDimX = (unsigned int)blockDimX; \
|
|
cb_data.args.hipModuleLaunchKernel.blockDimY = (unsigned int)blockDimY; \
|
|
cb_data.args.hipModuleLaunchKernel.blockDimZ = (unsigned int)blockDimZ; \
|
|
cb_data.args.hipModuleLaunchKernel.sharedMemBytes = (unsigned int)sharedMemBytes; \
|
|
cb_data.args.hipModuleLaunchKernel.stream = (hipStream_t)hStream; \
|
|
cb_data.args.hipModuleLaunchKernel.kernelParams = (void**)kernelParams; \
|
|
cb_data.args.hipModuleLaunchKernel.extra = (void**)extra; \
|
|
};
|
|
// hipModuleLoad[('hipModule_t*', 'module'), ('const char*', 'fname')]
|
|
#define INIT_hipModuleLoad_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLoad.module = (hipModule_t*)module; \
|
|
cb_data.args.hipModuleLoad.fname = (fname) ? strdup(fname) : NULL; \
|
|
};
|
|
// hipModuleLoadData[('hipModule_t*', 'module'), ('const void*', 'image')]
|
|
#define INIT_hipModuleLoadData_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLoadData.module = (hipModule_t*)module; \
|
|
cb_data.args.hipModuleLoadData.image = (const void*)image; \
|
|
};
|
|
// hipModuleLoadDataEx[('hipModule_t*', 'module'), ('const void*', 'image'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionsValues')]
|
|
#define INIT_hipModuleLoadDataEx_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleLoadDataEx.module = (hipModule_t*)module; \
|
|
cb_data.args.hipModuleLoadDataEx.image = (const void*)image; \
|
|
cb_data.args.hipModuleLoadDataEx.numOptions = (unsigned int)numOptions; \
|
|
cb_data.args.hipModuleLoadDataEx.options = (hipJitOption*)options; \
|
|
cb_data.args.hipModuleLoadDataEx.optionsValues = (void**)optionsValues; \
|
|
};
|
|
// hipModuleOccupancyMaxActiveBlocksPerMultiprocessor[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk')]
|
|
#define INIT_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks = (int*)numBlocks; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.blockSize = (int)blockSize; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.dynSharedMemPerBlk = (size_t)dynSharedMemPerBlk; \
|
|
};
|
|
// hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk'), ('unsigned int', 'flags')]
|
|
#define INIT_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks = (int*)numBlocks; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize = (int)blockSize; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynSharedMemPerBlk = (size_t)dynSharedMemPerBlk; \
|
|
cb_data.args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipModuleOccupancyMaxPotentialBlockSize[('int*', 'gridSize'), ('int*', 'blockSize'), ('hipFunction_t', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit')]
|
|
#define INIT_hipModuleOccupancyMaxPotentialBlockSize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSize.gridSize = (int*)gridSize; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSize.blockSize = (int*)blockSize; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSize.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSize.dynSharedMemPerBlk = (size_t)dynSharedMemPerBlk; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSize.blockSizeLimit = (int)blockSizeLimit; \
|
|
};
|
|
// hipModuleOccupancyMaxPotentialBlockSizeWithFlags[('int*', 'gridSize'), ('int*', 'blockSize'), ('hipFunction_t', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit'), ('unsigned int', 'flags')]
|
|
#define INIT_hipModuleOccupancyMaxPotentialBlockSizeWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize = (int*)gridSize; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize = (int*)blockSize; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.f = (hipFunction_t)f; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.dynSharedMemPerBlk = (size_t)dynSharedMemPerBlk; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSizeLimit = (int)blockSizeLimit; \
|
|
cb_data.args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipModuleUnload[('hipModule_t', 'module')]
|
|
#define INIT_hipModuleUnload_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipModuleUnload.module = (hipModule_t)hmod; \
|
|
};
|
|
// hipOccupancyMaxActiveBlocksPerMultiprocessor[('int*', 'numBlocks'), ('const void*', 'f'), ('int', 'blockSize'), ('size_t', 'dynamicSMemSize')]
|
|
#define INIT_hipOccupancyMaxActiveBlocksPerMultiprocessor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks = (int*)numBlocks; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.f = (const void*)f; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.blockSize = (int)blockSize; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.dynamicSMemSize = (size_t)dynamicSMemSize; \
|
|
};
|
|
// hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('int*', 'numBlocks'), ('const void*', 'f'), ('int', 'blockSize'), ('size_t', 'dynamicSMemSize'), ('unsigned int', 'flags')]
|
|
#define INIT_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks = (int*)numBlocks; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f = (const void*)f; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize = (int)blockSize; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynamicSMemSize = (size_t)dynamicSMemSize; \
|
|
cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipOccupancyMaxPotentialBlockSize[('int*', 'gridSize'), ('int*', 'blockSize'), ('const void*', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit')]
|
|
#define INIT_hipOccupancyMaxPotentialBlockSize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipOccupancyMaxPotentialBlockSize.gridSize = (int*)gridSize; \
|
|
cb_data.args.hipOccupancyMaxPotentialBlockSize.blockSize = (int*)blockSize; \
|
|
cb_data.args.hipOccupancyMaxPotentialBlockSize.f = (const void*)f; \
|
|
cb_data.args.hipOccupancyMaxPotentialBlockSize.dynSharedMemPerBlk = (size_t)dynSharedMemPerBlk; \
|
|
cb_data.args.hipOccupancyMaxPotentialBlockSize.blockSizeLimit = (int)blockSizeLimit; \
|
|
};
|
|
// hipPeekAtLastError[]
|
|
#define INIT_hipPeekAtLastError_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipPointerGetAttribute[('void*', 'data'), ('hipPointer_attribute', 'attribute'), ('hipDeviceptr_t', 'ptr')]
|
|
#define INIT_hipPointerGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipPointerGetAttribute.data = (void*)data; \
|
|
cb_data.args.hipPointerGetAttribute.attribute = (hipPointer_attribute)attribute; \
|
|
cb_data.args.hipPointerGetAttribute.ptr = (hipDeviceptr_t)ptr; \
|
|
};
|
|
// hipPointerGetAttributes[('hipPointerAttribute_t*', 'attributes'), ('const void*', 'ptr')]
|
|
#define INIT_hipPointerGetAttributes_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipPointerGetAttributes.attributes = (hipPointerAttribute_t*)attributes; \
|
|
cb_data.args.hipPointerGetAttributes.ptr = (const void*)ptr; \
|
|
};
|
|
// hipPointerSetAttribute[('const void*', 'value'), ('hipPointer_attribute', 'attribute'), ('hipDeviceptr_t', 'ptr')]
|
|
#define INIT_hipPointerSetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipPointerSetAttribute.value = (const void*)value; \
|
|
cb_data.args.hipPointerSetAttribute.attribute = (hipPointer_attribute)attribute; \
|
|
cb_data.args.hipPointerSetAttribute.ptr = (hipDeviceptr_t)ptr; \
|
|
};
|
|
// hipProfilerStart[]
|
|
#define INIT_hipProfilerStart_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipProfilerStop[]
|
|
#define INIT_hipProfilerStop_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipRuntimeGetVersion[('int*', 'runtimeVersion')]
|
|
#define INIT_hipRuntimeGetVersion_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipRuntimeGetVersion.runtimeVersion = (int*)runtimeVersion; \
|
|
};
|
|
// hipSetDevice[('int', 'deviceId')]
|
|
#define INIT_hipSetDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipSetDevice.deviceId = (int)device; \
|
|
};
|
|
// hipSetDeviceFlags[('unsigned int', 'flags')]
|
|
#define INIT_hipSetDeviceFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipSetDeviceFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipSetupArgument[('const void*', 'arg'), ('size_t', 'size'), ('size_t', 'offset')]
|
|
#define INIT_hipSetupArgument_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipSetupArgument.arg = (const void*)arg; \
|
|
cb_data.args.hipSetupArgument.size = (size_t)size; \
|
|
cb_data.args.hipSetupArgument.offset = (size_t)offset; \
|
|
};
|
|
// hipSignalExternalSemaphoresAsync[('const hipExternalSemaphore_t*', 'extSemArray'), ('const hipExternalSemaphoreSignalParams*', 'paramsArray'), ('unsigned int', 'numExtSems'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipSignalExternalSemaphoresAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipSignalExternalSemaphoresAsync.extSemArray = (const hipExternalSemaphore_t*)extSemArray; \
|
|
cb_data.args.hipSignalExternalSemaphoresAsync.paramsArray = (const hipExternalSemaphoreSignalParams*)paramsArray; \
|
|
cb_data.args.hipSignalExternalSemaphoresAsync.numExtSems = (unsigned int)numExtSems; \
|
|
cb_data.args.hipSignalExternalSemaphoresAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipStreamAddCallback[('hipStream_t', 'stream'), ('hipStreamCallback_t', 'callback'), ('void*', 'userData'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamAddCallback_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamAddCallback.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamAddCallback.callback = (hipStreamCallback_t)callback; \
|
|
cb_data.args.hipStreamAddCallback.userData = (void*)userData; \
|
|
cb_data.args.hipStreamAddCallback.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamAttachMemAsync[('hipStream_t', 'stream'), ('void*', 'dev_ptr'), ('size_t', 'length'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamAttachMemAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamAttachMemAsync.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamAttachMemAsync.dev_ptr = (void*)dev_ptr; \
|
|
cb_data.args.hipStreamAttachMemAsync.length = (size_t)length; \
|
|
cb_data.args.hipStreamAttachMemAsync.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamBeginCapture[('hipStream_t', 'stream'), ('hipStreamCaptureMode', 'mode')]
|
|
#define INIT_hipStreamBeginCapture_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamBeginCapture.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamBeginCapture.mode = (hipStreamCaptureMode)mode; \
|
|
};
|
|
// hipStreamCreate[('hipStream_t*', 'stream')]
|
|
#define INIT_hipStreamCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamCreate.stream = (hipStream_t*)stream; \
|
|
};
|
|
// hipStreamCreateWithFlags[('hipStream_t*', 'stream'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamCreateWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamCreateWithFlags.stream = (hipStream_t*)stream; \
|
|
cb_data.args.hipStreamCreateWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamCreateWithPriority[('hipStream_t*', 'stream'), ('unsigned int', 'flags'), ('int', 'priority')]
|
|
#define INIT_hipStreamCreateWithPriority_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamCreateWithPriority.stream = (hipStream_t*)stream; \
|
|
cb_data.args.hipStreamCreateWithPriority.flags = (unsigned int)flags; \
|
|
cb_data.args.hipStreamCreateWithPriority.priority = (int)priority; \
|
|
};
|
|
// hipStreamDestroy[('hipStream_t', 'stream')]
|
|
#define INIT_hipStreamDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamDestroy.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipStreamEndCapture[('hipStream_t', 'stream'), ('hipGraph_t*', 'pGraph')]
|
|
#define INIT_hipStreamEndCapture_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamEndCapture.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamEndCapture.pGraph = (hipGraph_t*)pGraph; \
|
|
};
|
|
// hipStreamGetCaptureInfo[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'pCaptureStatus'), ('unsigned long long*', 'pId')]
|
|
#define INIT_hipStreamGetCaptureInfo_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamGetCaptureInfo.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamGetCaptureInfo.pCaptureStatus = (hipStreamCaptureStatus*)pCaptureStatus; \
|
|
cb_data.args.hipStreamGetCaptureInfo.pId = (unsigned long long*)pId; \
|
|
};
|
|
// hipStreamGetCaptureInfo_v2[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'captureStatus_out'), ('unsigned long long*', 'id_out'), ('hipGraph_t*', 'graph_out'), ('const hipGraphNode_t**', 'dependencies_out'), ('size_t*', 'numDependencies_out')]
|
|
#define INIT_hipStreamGetCaptureInfo_v2_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.captureStatus_out = (hipStreamCaptureStatus*)captureStatus_out; \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.id_out = (unsigned long long*)id_out; \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.graph_out = (hipGraph_t*)graph_out; \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.dependencies_out = (const hipGraphNode_t**)dependencies_out; \
|
|
cb_data.args.hipStreamGetCaptureInfo_v2.numDependencies_out = (size_t*)numDependencies_out; \
|
|
};
|
|
// hipStreamGetFlags[('hipStream_t', 'stream'), ('unsigned int*', 'flags')]
|
|
#define INIT_hipStreamGetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamGetFlags.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamGetFlags.flags = (unsigned int*)flags; \
|
|
};
|
|
// hipStreamGetPriority[('hipStream_t', 'stream'), ('int*', 'priority')]
|
|
#define INIT_hipStreamGetPriority_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamGetPriority.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamGetPriority.priority = (int*)priority; \
|
|
};
|
|
// hipStreamIsCapturing[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'pCaptureStatus')]
|
|
#define INIT_hipStreamIsCapturing_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamIsCapturing.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamIsCapturing.pCaptureStatus = (hipStreamCaptureStatus*)pCaptureStatus; \
|
|
};
|
|
// hipStreamQuery[('hipStream_t', 'stream')]
|
|
#define INIT_hipStreamQuery_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamQuery.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipStreamSynchronize[('hipStream_t', 'stream')]
|
|
#define INIT_hipStreamSynchronize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamSynchronize.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipStreamUpdateCaptureDependencies[('hipStream_t', 'stream'), ('hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamUpdateCaptureDependencies_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamUpdateCaptureDependencies.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamUpdateCaptureDependencies.dependencies = (hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipStreamUpdateCaptureDependencies.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipStreamUpdateCaptureDependencies.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamWaitEvent[('hipStream_t', 'stream'), ('hipEvent_t', 'event'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamWaitEvent_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamWaitEvent.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamWaitEvent.event = (hipEvent_t)event; \
|
|
cb_data.args.hipStreamWaitEvent.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamWaitValue32[('hipStream_t', 'stream'), ('void*', 'ptr'), ('unsigned int', 'value'), ('unsigned int', 'flags'), ('unsigned int', 'mask')]
|
|
#define INIT_hipStreamWaitValue32_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamWaitValue32.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamWaitValue32.ptr = (void*)ptr; \
|
|
cb_data.args.hipStreamWaitValue32.value = (unsigned int)value; \
|
|
cb_data.args.hipStreamWaitValue32.flags = (unsigned int)flags; \
|
|
cb_data.args.hipStreamWaitValue32.mask = (unsigned int)mask; \
|
|
};
|
|
// hipStreamWaitValue64[('hipStream_t', 'stream'), ('void*', 'ptr'), ('uint64_t', 'value'), ('unsigned int', 'flags'), ('uint64_t', 'mask')]
|
|
#define INIT_hipStreamWaitValue64_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamWaitValue64.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamWaitValue64.ptr = (void*)ptr; \
|
|
cb_data.args.hipStreamWaitValue64.value = (uint64_t)value; \
|
|
cb_data.args.hipStreamWaitValue64.flags = (unsigned int)flags; \
|
|
cb_data.args.hipStreamWaitValue64.mask = (uint64_t)mask; \
|
|
};
|
|
// hipStreamWriteValue32[('hipStream_t', 'stream'), ('void*', 'ptr'), ('unsigned int', 'value'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamWriteValue32_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamWriteValue32.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamWriteValue32.ptr = (void*)ptr; \
|
|
cb_data.args.hipStreamWriteValue32.value = (unsigned int)value; \
|
|
cb_data.args.hipStreamWriteValue32.flags = (unsigned int)flags; \
|
|
};
|
|
// hipStreamWriteValue64[('hipStream_t', 'stream'), ('void*', 'ptr'), ('uint64_t', 'value'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamWriteValue64_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamWriteValue64.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamWriteValue64.ptr = (void*)ptr; \
|
|
cb_data.args.hipStreamWriteValue64.value = (uint64_t)value; \
|
|
cb_data.args.hipStreamWriteValue64.flags = (unsigned int)flags; \
|
|
};
|
|
// hipTexRefGetAddress[('hipDeviceptr_t*', 'dev_ptr'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetAddress_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetAddress.dev_ptr = (hipDeviceptr_t*)dptr; \
|
|
cb_data.args.hipTexRefGetAddress.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetFlags[('unsigned int*', 'pFlags'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetFlags.pFlags = (unsigned int*)pFlags; \
|
|
cb_data.args.hipTexRefGetFlags.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetFormat[('hipArray_Format*', 'pFormat'), ('int*', 'pNumChannels'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetFormat_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetFormat.pFormat = (hipArray_Format*)pFormat; \
|
|
cb_data.args.hipTexRefGetFormat.pNumChannels = (int*)pNumChannels; \
|
|
cb_data.args.hipTexRefGetFormat.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetMaxAnisotropy[('int*', 'pmaxAnsio'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetMaxAnisotropy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetMaxAnisotropy.pmaxAnsio = (int*)pmaxAnsio; \
|
|
cb_data.args.hipTexRefGetMaxAnisotropy.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetMipMappedArray[('hipMipmappedArray_t*', 'pArray'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetMipMappedArray_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipTexRefGetMipmapLevelBias[('float*', 'pbias'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetMipmapLevelBias_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetMipmapLevelBias.pbias = (float*)pbias; \
|
|
cb_data.args.hipTexRefGetMipmapLevelBias.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetMipmapLevelClamp[('float*', 'pminMipmapLevelClamp'), ('float*', 'pmaxMipmapLevelClamp'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetMipmapLevelClamp_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp = (float*)pminMipmapLevelClamp; \
|
|
cb_data.args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp = (float*)pmaxMipmapLevelClamp; \
|
|
cb_data.args.hipTexRefGetMipmapLevelClamp.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefSetAddress[('size_t*', 'ByteOffset'), ('textureReference*', 'texRef'), ('hipDeviceptr_t', 'dptr'), ('size_t', 'bytes')]
|
|
#define INIT_hipTexRefSetAddress_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetAddress.ByteOffset = (size_t*)ByteOffset; \
|
|
cb_data.args.hipTexRefSetAddress.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetAddress.dptr = (hipDeviceptr_t)dptr; \
|
|
cb_data.args.hipTexRefSetAddress.bytes = (size_t)bytes; \
|
|
};
|
|
// hipTexRefSetAddress2D[('textureReference*', 'texRef'), ('const HIP_ARRAY_DESCRIPTOR*', 'desc'), ('hipDeviceptr_t', 'dptr'), ('size_t', 'Pitch')]
|
|
#define INIT_hipTexRefSetAddress2D_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetAddress2D.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetAddress2D.desc = (const HIP_ARRAY_DESCRIPTOR*)desc; \
|
|
cb_data.args.hipTexRefSetAddress2D.dptr = (hipDeviceptr_t)dptr; \
|
|
cb_data.args.hipTexRefSetAddress2D.Pitch = (size_t)Pitch; \
|
|
};
|
|
// hipTexRefSetArray[('textureReference*', 'tex'), ('hipArray_const_t', 'array'), ('unsigned int', 'flags')]
|
|
#define INIT_hipTexRefSetArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetArray.tex = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetArray.array = (hipArray_const_t)array; \
|
|
cb_data.args.hipTexRefSetArray.flags = (unsigned int)flags; \
|
|
};
|
|
// hipTexRefSetBorderColor[('textureReference*', 'texRef'), ('float*', 'pBorderColor')]
|
|
#define INIT_hipTexRefSetBorderColor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetBorderColor.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetBorderColor.pBorderColor = (float*)pBorderColor; \
|
|
};
|
|
// hipTexRefSetFlags[('textureReference*', 'texRef'), ('unsigned int', 'Flags')]
|
|
#define INIT_hipTexRefSetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetFlags.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetFlags.Flags = (unsigned int)Flags; \
|
|
};
|
|
// hipTexRefSetFormat[('textureReference*', 'texRef'), ('hipArray_Format', 'fmt'), ('int', 'NumPackedComponents')]
|
|
#define INIT_hipTexRefSetFormat_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetFormat.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetFormat.fmt = (hipArray_Format)fmt; \
|
|
cb_data.args.hipTexRefSetFormat.NumPackedComponents = (int)NumPackedComponents; \
|
|
};
|
|
// hipTexRefSetMaxAnisotropy[('textureReference*', 'texRef'), ('unsigned int', 'maxAniso')]
|
|
#define INIT_hipTexRefSetMaxAnisotropy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetMaxAnisotropy.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetMaxAnisotropy.maxAniso = (unsigned int)maxAniso; \
|
|
};
|
|
// hipTexRefSetMipmapLevelBias[('textureReference*', 'texRef'), ('float', 'bias')]
|
|
#define INIT_hipTexRefSetMipmapLevelBias_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetMipmapLevelBias.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetMipmapLevelBias.bias = (float)bias; \
|
|
};
|
|
// hipTexRefSetMipmapLevelClamp[('textureReference*', 'texRef'), ('float', 'minMipMapLevelClamp'), ('float', 'maxMipMapLevelClamp')]
|
|
#define INIT_hipTexRefSetMipmapLevelClamp_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetMipmapLevelClamp.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetMipmapLevelClamp.minMipMapLevelClamp = (float)minMipMapLevelClamp; \
|
|
cb_data.args.hipTexRefSetMipmapLevelClamp.maxMipMapLevelClamp = (float)maxMipMapLevelClamp; \
|
|
};
|
|
// hipTexRefSetMipmappedArray[('textureReference*', 'texRef'), ('hipMipmappedArray*', 'mipmappedArray'), ('unsigned int', 'Flags')]
|
|
#define INIT_hipTexRefSetMipmappedArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefSetMipmappedArray.texRef = (textureReference*)texRef; \
|
|
cb_data.args.hipTexRefSetMipmappedArray.mipmappedArray = (hipMipmappedArray*)mipmappedArray; \
|
|
cb_data.args.hipTexRefSetMipmappedArray.Flags = (unsigned int)Flags; \
|
|
};
|
|
// hipThreadExchangeStreamCaptureMode[('hipStreamCaptureMode*', 'mode')]
|
|
#define INIT_hipThreadExchangeStreamCaptureMode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipThreadExchangeStreamCaptureMode.mode = (hipStreamCaptureMode*)mode; \
|
|
};
|
|
// hipUserObjectCreate[('hipUserObject_t*', 'object_out'), ('void*', 'ptr'), ('hipHostFn_t', 'destroy'), ('unsigned int', 'initialRefcount'), ('unsigned int', 'flags')]
|
|
#define INIT_hipUserObjectCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipUserObjectCreate.object_out = (hipUserObject_t*)object_out; \
|
|
cb_data.args.hipUserObjectCreate.ptr = (void*)ptr; \
|
|
cb_data.args.hipUserObjectCreate.destroy = (hipHostFn_t)destroy; \
|
|
cb_data.args.hipUserObjectCreate.initialRefcount = (unsigned int)initialRefcount; \
|
|
cb_data.args.hipUserObjectCreate.flags = (unsigned int)flags; \
|
|
};
|
|
// hipUserObjectRelease[('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
#define INIT_hipUserObjectRelease_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipUserObjectRelease.object = (hipUserObject_t)object; \
|
|
cb_data.args.hipUserObjectRelease.count = (unsigned int)count; \
|
|
};
|
|
// hipUserObjectRetain[('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
#define INIT_hipUserObjectRetain_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipUserObjectRetain.object = (hipUserObject_t)object; \
|
|
cb_data.args.hipUserObjectRetain.count = (unsigned int)count; \
|
|
};
|
|
// hipWaitExternalSemaphoresAsync[('const hipExternalSemaphore_t*', 'extSemArray'), ('const hipExternalSemaphoreWaitParams*', 'paramsArray'), ('unsigned int', 'numExtSems'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipWaitExternalSemaphoresAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipWaitExternalSemaphoresAsync.extSemArray = (const hipExternalSemaphore_t*)extSemArray; \
|
|
cb_data.args.hipWaitExternalSemaphoresAsync.paramsArray = (const hipExternalSemaphoreWaitParams*)paramsArray; \
|
|
cb_data.args.hipWaitExternalSemaphoresAsync.numExtSems = (unsigned int)numExtSems; \
|
|
cb_data.args.hipWaitExternalSemaphoresAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
#define INIT_CB_ARGS_DATA(cb_id, cb_data) INIT_##cb_id##_CB_ARGS_DATA(cb_data)
|
|
|
|
// Macros for non-public API primitives
|
|
// hipArray3DGetDescriptor()
|
|
#define INIT_hipArray3DGetDescriptor_CB_ARGS_DATA(cb_data) {};
|
|
// hipArrayGetDescriptor()
|
|
#define INIT_hipArrayGetDescriptor_CB_ARGS_DATA(cb_data) {};
|
|
// hipBindTexture()
|
|
#define INIT_hipBindTexture_CB_ARGS_DATA(cb_data) {};
|
|
// hipBindTexture2D()
|
|
#define INIT_hipBindTexture2D_CB_ARGS_DATA(cb_data) {};
|
|
// hipBindTextureToArray()
|
|
#define INIT_hipBindTextureToArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipBindTextureToMipmappedArray()
|
|
#define INIT_hipBindTextureToMipmappedArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipCreateTextureObject()
|
|
#define INIT_hipCreateTextureObject_CB_ARGS_DATA(cb_data) {};
|
|
// hipDestroyTextureObject()
|
|
#define INIT_hipDestroyTextureObject_CB_ARGS_DATA(cb_data) {};
|
|
// hipDeviceGetCount()
|
|
#define INIT_hipDeviceGetCount_CB_ARGS_DATA(cb_data) {};
|
|
// hipGetTextureAlignmentOffset()
|
|
#define INIT_hipGetTextureAlignmentOffset_CB_ARGS_DATA(cb_data) {};
|
|
// hipGetTextureObjectResourceDesc()
|
|
#define INIT_hipGetTextureObjectResourceDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipGetTextureObjectResourceViewDesc()
|
|
#define INIT_hipGetTextureObjectResourceViewDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipGetTextureObjectTextureDesc()
|
|
#define INIT_hipGetTextureObjectTextureDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipGetTextureReference()
|
|
#define INIT_hipGetTextureReference_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpy2DArrayToArray()
|
|
#define INIT_hipMemcpy2DArrayToArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyArrayToArray()
|
|
#define INIT_hipMemcpyArrayToArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyAtoA()
|
|
#define INIT_hipMemcpyAtoA_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyAtoD()
|
|
#define INIT_hipMemcpyAtoD_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyAtoHAsync()
|
|
#define INIT_hipMemcpyAtoHAsync_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyDtoA()
|
|
#define INIT_hipMemcpyDtoA_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyFromArrayAsync()
|
|
#define INIT_hipMemcpyFromArrayAsync_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyHtoAAsync()
|
|
#define INIT_hipMemcpyHtoAAsync_CB_ARGS_DATA(cb_data) {};
|
|
// hipMemcpyToArrayAsync()
|
|
#define INIT_hipMemcpyToArrayAsync_CB_ARGS_DATA(cb_data) {};
|
|
// hipModuleLaunchKernelExt()
|
|
#define INIT_hipModuleLaunchKernelExt_CB_ARGS_DATA(cb_data) {};
|
|
// hipSetValidDevices()
|
|
#define INIT_hipSetValidDevices_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexObjectCreate()
|
|
#define INIT_hipTexObjectCreate_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexObjectDestroy()
|
|
#define INIT_hipTexObjectDestroy_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexObjectGetResourceDesc()
|
|
#define INIT_hipTexObjectGetResourceDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexObjectGetResourceViewDesc()
|
|
#define INIT_hipTexObjectGetResourceViewDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexObjectGetTextureDesc()
|
|
#define INIT_hipTexObjectGetTextureDesc_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetAddressMode()
|
|
#define INIT_hipTexRefGetAddressMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetArray()
|
|
#define INIT_hipTexRefGetArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetBorderColor()
|
|
#define INIT_hipTexRefGetBorderColor_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetFilterMode()
|
|
#define INIT_hipTexRefGetFilterMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetMipmapFilterMode()
|
|
#define INIT_hipTexRefGetMipmapFilterMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetMipmappedArray()
|
|
#define INIT_hipTexRefGetMipmappedArray_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefSetAddressMode()
|
|
#define INIT_hipTexRefSetAddressMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefSetFilterMode()
|
|
#define INIT_hipTexRefSetFilterMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefSetMipmapFilterMode()
|
|
#define INIT_hipTexRefSetMipmapFilterMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipUnbindTexture()
|
|
#define INIT_hipUnbindTexture_CB_ARGS_DATA(cb_data) {};
|
|
|
|
#define INIT_NONE_CB_ARGS_DATA(cb_data) {};
|
|
|
|
#if HIP_PROF_HIP_API_STRING
|
|
// HIP API args filling helper
|
|
static inline void hipApiArgsInit(hip_api_id_t id, hip_api_data_t* data) {
|
|
switch (id) {
|
|
// __hipPopCallConfiguration[('dim3*', 'gridDim'), ('dim3*', 'blockDim'), ('size_t*', 'sharedMem'), ('hipStream_t*', 'stream')]
|
|
case HIP_API_ID___hipPopCallConfiguration:
|
|
if (data->args.__hipPopCallConfiguration.gridDim) data->args.__hipPopCallConfiguration.gridDim__val = *(data->args.__hipPopCallConfiguration.gridDim);
|
|
if (data->args.__hipPopCallConfiguration.blockDim) data->args.__hipPopCallConfiguration.blockDim__val = *(data->args.__hipPopCallConfiguration.blockDim);
|
|
if (data->args.__hipPopCallConfiguration.sharedMem) data->args.__hipPopCallConfiguration.sharedMem__val = *(data->args.__hipPopCallConfiguration.sharedMem);
|
|
if (data->args.__hipPopCallConfiguration.stream) data->args.__hipPopCallConfiguration.stream__val = *(data->args.__hipPopCallConfiguration.stream);
|
|
break;
|
|
// __hipPushCallConfiguration[('dim3', 'gridDim'), ('dim3', 'blockDim'), ('size_t', 'sharedMem'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID___hipPushCallConfiguration:
|
|
break;
|
|
// hipArray3DCreate[('hipArray**', 'array'), ('const HIP_ARRAY3D_DESCRIPTOR*', 'pAllocateArray')]
|
|
case HIP_API_ID_hipArray3DCreate:
|
|
if (data->args.hipArray3DCreate.array) data->args.hipArray3DCreate.array__val = *(data->args.hipArray3DCreate.array);
|
|
if (data->args.hipArray3DCreate.pAllocateArray) data->args.hipArray3DCreate.pAllocateArray__val = *(data->args.hipArray3DCreate.pAllocateArray);
|
|
break;
|
|
// hipArrayCreate[('hipArray**', 'pHandle'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
|
|
case HIP_API_ID_hipArrayCreate:
|
|
if (data->args.hipArrayCreate.pHandle) data->args.hipArrayCreate.pHandle__val = *(data->args.hipArrayCreate.pHandle);
|
|
if (data->args.hipArrayCreate.pAllocateArray) data->args.hipArrayCreate.pAllocateArray__val = *(data->args.hipArrayCreate.pAllocateArray);
|
|
break;
|
|
// hipArrayDestroy[('hipArray*', 'array')]
|
|
case HIP_API_ID_hipArrayDestroy:
|
|
if (data->args.hipArrayDestroy.array) data->args.hipArrayDestroy.array__val = *(data->args.hipArrayDestroy.array);
|
|
break;
|
|
// hipChooseDevice[('int*', 'device'), ('const hipDeviceProp_t*', 'prop')]
|
|
case HIP_API_ID_hipChooseDevice:
|
|
if (data->args.hipChooseDevice.device) data->args.hipChooseDevice.device__val = *(data->args.hipChooseDevice.device);
|
|
if (data->args.hipChooseDevice.prop) data->args.hipChooseDevice.prop__val = *(data->args.hipChooseDevice.prop);
|
|
break;
|
|
// hipConfigureCall[('dim3', 'gridDim'), ('dim3', 'blockDim'), ('size_t', 'sharedMem'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipConfigureCall:
|
|
break;
|
|
// hipCreateSurfaceObject[('hipSurfaceObject_t*', 'pSurfObject'), ('const hipResourceDesc*', 'pResDesc')]
|
|
case HIP_API_ID_hipCreateSurfaceObject:
|
|
if (data->args.hipCreateSurfaceObject.pSurfObject) data->args.hipCreateSurfaceObject.pSurfObject__val = *(data->args.hipCreateSurfaceObject.pSurfObject);
|
|
if (data->args.hipCreateSurfaceObject.pResDesc) data->args.hipCreateSurfaceObject.pResDesc__val = *(data->args.hipCreateSurfaceObject.pResDesc);
|
|
break;
|
|
// hipCtxCreate[('hipCtx_t*', 'ctx'), ('unsigned int', 'flags'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipCtxCreate:
|
|
if (data->args.hipCtxCreate.ctx) data->args.hipCtxCreate.ctx__val = *(data->args.hipCtxCreate.ctx);
|
|
break;
|
|
// hipCtxDestroy[('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipCtxDestroy:
|
|
break;
|
|
// hipCtxDisablePeerAccess[('hipCtx_t', 'peerCtx')]
|
|
case HIP_API_ID_hipCtxDisablePeerAccess:
|
|
break;
|
|
// hipCtxEnablePeerAccess[('hipCtx_t', 'peerCtx'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipCtxEnablePeerAccess:
|
|
break;
|
|
// hipCtxGetApiVersion[('hipCtx_t', 'ctx'), ('int*', 'apiVersion')]
|
|
case HIP_API_ID_hipCtxGetApiVersion:
|
|
if (data->args.hipCtxGetApiVersion.apiVersion) data->args.hipCtxGetApiVersion.apiVersion__val = *(data->args.hipCtxGetApiVersion.apiVersion);
|
|
break;
|
|
// hipCtxGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
|
|
case HIP_API_ID_hipCtxGetCacheConfig:
|
|
if (data->args.hipCtxGetCacheConfig.cacheConfig) data->args.hipCtxGetCacheConfig.cacheConfig__val = *(data->args.hipCtxGetCacheConfig.cacheConfig);
|
|
break;
|
|
// hipCtxGetCurrent[('hipCtx_t*', 'ctx')]
|
|
case HIP_API_ID_hipCtxGetCurrent:
|
|
if (data->args.hipCtxGetCurrent.ctx) data->args.hipCtxGetCurrent.ctx__val = *(data->args.hipCtxGetCurrent.ctx);
|
|
break;
|
|
// hipCtxGetDevice[('hipDevice_t*', 'device')]
|
|
case HIP_API_ID_hipCtxGetDevice:
|
|
if (data->args.hipCtxGetDevice.device) data->args.hipCtxGetDevice.device__val = *(data->args.hipCtxGetDevice.device);
|
|
break;
|
|
// hipCtxGetFlags[('unsigned int*', 'flags')]
|
|
case HIP_API_ID_hipCtxGetFlags:
|
|
if (data->args.hipCtxGetFlags.flags) data->args.hipCtxGetFlags.flags__val = *(data->args.hipCtxGetFlags.flags);
|
|
break;
|
|
// hipCtxGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
|
|
case HIP_API_ID_hipCtxGetSharedMemConfig:
|
|
if (data->args.hipCtxGetSharedMemConfig.pConfig) data->args.hipCtxGetSharedMemConfig.pConfig__val = *(data->args.hipCtxGetSharedMemConfig.pConfig);
|
|
break;
|
|
// hipCtxPopCurrent[('hipCtx_t*', 'ctx')]
|
|
case HIP_API_ID_hipCtxPopCurrent:
|
|
if (data->args.hipCtxPopCurrent.ctx) data->args.hipCtxPopCurrent.ctx__val = *(data->args.hipCtxPopCurrent.ctx);
|
|
break;
|
|
// hipCtxPushCurrent[('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipCtxPushCurrent:
|
|
break;
|
|
// hipCtxSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
|
|
case HIP_API_ID_hipCtxSetCacheConfig:
|
|
break;
|
|
// hipCtxSetCurrent[('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipCtxSetCurrent:
|
|
break;
|
|
// hipCtxSetSharedMemConfig[('hipSharedMemConfig', 'config')]
|
|
case HIP_API_ID_hipCtxSetSharedMemConfig:
|
|
break;
|
|
// hipCtxSynchronize[]
|
|
case HIP_API_ID_hipCtxSynchronize:
|
|
break;
|
|
// hipDestroyExternalMemory[('hipExternalMemory_t', 'extMem')]
|
|
case HIP_API_ID_hipDestroyExternalMemory:
|
|
break;
|
|
// hipDestroyExternalSemaphore[('hipExternalSemaphore_t', 'extSem')]
|
|
case HIP_API_ID_hipDestroyExternalSemaphore:
|
|
break;
|
|
// hipDestroySurfaceObject[('hipSurfaceObject_t', 'surfaceObject')]
|
|
case HIP_API_ID_hipDestroySurfaceObject:
|
|
break;
|
|
// hipDeviceCanAccessPeer[('int*', 'canAccessPeer'), ('int', 'deviceId'), ('int', 'peerDeviceId')]
|
|
case HIP_API_ID_hipDeviceCanAccessPeer:
|
|
if (data->args.hipDeviceCanAccessPeer.canAccessPeer) data->args.hipDeviceCanAccessPeer.canAccessPeer__val = *(data->args.hipDeviceCanAccessPeer.canAccessPeer);
|
|
break;
|
|
// hipDeviceComputeCapability[('int*', 'major'), ('int*', 'minor'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipDeviceComputeCapability:
|
|
if (data->args.hipDeviceComputeCapability.major) data->args.hipDeviceComputeCapability.major__val = *(data->args.hipDeviceComputeCapability.major);
|
|
if (data->args.hipDeviceComputeCapability.minor) data->args.hipDeviceComputeCapability.minor__val = *(data->args.hipDeviceComputeCapability.minor);
|
|
break;
|
|
// hipDeviceDisablePeerAccess[('int', 'peerDeviceId')]
|
|
case HIP_API_ID_hipDeviceDisablePeerAccess:
|
|
break;
|
|
// hipDeviceEnablePeerAccess[('int', 'peerDeviceId'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipDeviceEnablePeerAccess:
|
|
break;
|
|
// hipDeviceGet[('hipDevice_t*', 'device'), ('int', 'ordinal')]
|
|
case HIP_API_ID_hipDeviceGet:
|
|
if (data->args.hipDeviceGet.device) data->args.hipDeviceGet.device__val = *(data->args.hipDeviceGet.device);
|
|
break;
|
|
// hipDeviceGetAttribute[('int*', 'pi'), ('hipDeviceAttribute_t', 'attr'), ('int', 'deviceId')]
|
|
case HIP_API_ID_hipDeviceGetAttribute:
|
|
if (data->args.hipDeviceGetAttribute.pi) data->args.hipDeviceGetAttribute.pi__val = *(data->args.hipDeviceGetAttribute.pi);
|
|
break;
|
|
// hipDeviceGetByPCIBusId[('int*', 'device'), ('const char*', 'pciBusId')]
|
|
case HIP_API_ID_hipDeviceGetByPCIBusId:
|
|
if (data->args.hipDeviceGetByPCIBusId.device) data->args.hipDeviceGetByPCIBusId.device__val = *(data->args.hipDeviceGetByPCIBusId.device);
|
|
if (data->args.hipDeviceGetByPCIBusId.pciBusId) data->args.hipDeviceGetByPCIBusId.pciBusId__val = *(data->args.hipDeviceGetByPCIBusId.pciBusId);
|
|
break;
|
|
// hipDeviceGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
|
|
case HIP_API_ID_hipDeviceGetCacheConfig:
|
|
if (data->args.hipDeviceGetCacheConfig.cacheConfig) data->args.hipDeviceGetCacheConfig.cacheConfig__val = *(data->args.hipDeviceGetCacheConfig.cacheConfig);
|
|
break;
|
|
// hipDeviceGetDefaultMemPool[('hipMemPool_t*', 'mem_pool'), ('int', 'device')]
|
|
case HIP_API_ID_hipDeviceGetDefaultMemPool:
|
|
if (data->args.hipDeviceGetDefaultMemPool.mem_pool) data->args.hipDeviceGetDefaultMemPool.mem_pool__val = *(data->args.hipDeviceGetDefaultMemPool.mem_pool);
|
|
break;
|
|
// hipDeviceGetGraphMemAttribute[('int', 'device'), ('hipGraphMemAttributeType', 'attr'), ('void*', 'value')]
|
|
case HIP_API_ID_hipDeviceGetGraphMemAttribute:
|
|
break;
|
|
// hipDeviceGetLimit[('size_t*', 'pValue'), ('hipLimit_t', 'limit')]
|
|
case HIP_API_ID_hipDeviceGetLimit:
|
|
if (data->args.hipDeviceGetLimit.pValue) data->args.hipDeviceGetLimit.pValue__val = *(data->args.hipDeviceGetLimit.pValue);
|
|
break;
|
|
// hipDeviceGetMemPool[('hipMemPool_t*', 'mem_pool'), ('int', 'device')]
|
|
case HIP_API_ID_hipDeviceGetMemPool:
|
|
if (data->args.hipDeviceGetMemPool.mem_pool) data->args.hipDeviceGetMemPool.mem_pool__val = *(data->args.hipDeviceGetMemPool.mem_pool);
|
|
break;
|
|
// hipDeviceGetName[('char*', 'name'), ('int', 'len'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipDeviceGetName:
|
|
data->args.hipDeviceGetName.name = (data->args.hipDeviceGetName.name) ? strdup(data->args.hipDeviceGetName.name) : NULL;
|
|
break;
|
|
// hipDeviceGetP2PAttribute[('int*', 'value'), ('hipDeviceP2PAttr', 'attr'), ('int', 'srcDevice'), ('int', 'dstDevice')]
|
|
case HIP_API_ID_hipDeviceGetP2PAttribute:
|
|
if (data->args.hipDeviceGetP2PAttribute.value) data->args.hipDeviceGetP2PAttribute.value__val = *(data->args.hipDeviceGetP2PAttribute.value);
|
|
break;
|
|
// hipDeviceGetPCIBusId[('char*', 'pciBusId'), ('int', 'len'), ('int', 'device')]
|
|
case HIP_API_ID_hipDeviceGetPCIBusId:
|
|
data->args.hipDeviceGetPCIBusId.pciBusId = (data->args.hipDeviceGetPCIBusId.pciBusId) ? strdup(data->args.hipDeviceGetPCIBusId.pciBusId) : NULL;
|
|
break;
|
|
// hipDeviceGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
|
|
case HIP_API_ID_hipDeviceGetSharedMemConfig:
|
|
if (data->args.hipDeviceGetSharedMemConfig.pConfig) data->args.hipDeviceGetSharedMemConfig.pConfig__val = *(data->args.hipDeviceGetSharedMemConfig.pConfig);
|
|
break;
|
|
// hipDeviceGetStreamPriorityRange[('int*', 'leastPriority'), ('int*', 'greatestPriority')]
|
|
case HIP_API_ID_hipDeviceGetStreamPriorityRange:
|
|
if (data->args.hipDeviceGetStreamPriorityRange.leastPriority) data->args.hipDeviceGetStreamPriorityRange.leastPriority__val = *(data->args.hipDeviceGetStreamPriorityRange.leastPriority);
|
|
if (data->args.hipDeviceGetStreamPriorityRange.greatestPriority) data->args.hipDeviceGetStreamPriorityRange.greatestPriority__val = *(data->args.hipDeviceGetStreamPriorityRange.greatestPriority);
|
|
break;
|
|
// hipDeviceGetUuid[('hipUUID*', 'uuid'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipDeviceGetUuid:
|
|
if (data->args.hipDeviceGetUuid.uuid) data->args.hipDeviceGetUuid.uuid__val = *(data->args.hipDeviceGetUuid.uuid);
|
|
break;
|
|
// hipDeviceGraphMemTrim[('int', 'device')]
|
|
case HIP_API_ID_hipDeviceGraphMemTrim:
|
|
break;
|
|
// hipDevicePrimaryCtxGetState[('hipDevice_t', 'dev'), ('unsigned int*', 'flags'), ('int*', 'active')]
|
|
case HIP_API_ID_hipDevicePrimaryCtxGetState:
|
|
if (data->args.hipDevicePrimaryCtxGetState.flags) data->args.hipDevicePrimaryCtxGetState.flags__val = *(data->args.hipDevicePrimaryCtxGetState.flags);
|
|
if (data->args.hipDevicePrimaryCtxGetState.active) data->args.hipDevicePrimaryCtxGetState.active__val = *(data->args.hipDevicePrimaryCtxGetState.active);
|
|
break;
|
|
// hipDevicePrimaryCtxRelease[('hipDevice_t', 'dev')]
|
|
case HIP_API_ID_hipDevicePrimaryCtxRelease:
|
|
break;
|
|
// hipDevicePrimaryCtxReset[('hipDevice_t', 'dev')]
|
|
case HIP_API_ID_hipDevicePrimaryCtxReset:
|
|
break;
|
|
// hipDevicePrimaryCtxRetain[('hipCtx_t*', 'pctx'), ('hipDevice_t', 'dev')]
|
|
case HIP_API_ID_hipDevicePrimaryCtxRetain:
|
|
if (data->args.hipDevicePrimaryCtxRetain.pctx) data->args.hipDevicePrimaryCtxRetain.pctx__val = *(data->args.hipDevicePrimaryCtxRetain.pctx);
|
|
break;
|
|
// hipDevicePrimaryCtxSetFlags[('hipDevice_t', 'dev'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipDevicePrimaryCtxSetFlags:
|
|
break;
|
|
// hipDeviceReset[]
|
|
case HIP_API_ID_hipDeviceReset:
|
|
break;
|
|
// hipDeviceSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
|
|
case HIP_API_ID_hipDeviceSetCacheConfig:
|
|
break;
|
|
// hipDeviceSetGraphMemAttribute[('int', 'device'), ('hipGraphMemAttributeType', 'attr'), ('void*', 'value')]
|
|
case HIP_API_ID_hipDeviceSetGraphMemAttribute:
|
|
break;
|
|
// hipDeviceSetLimit[('hipLimit_t', 'limit'), ('size_t', 'value')]
|
|
case HIP_API_ID_hipDeviceSetLimit:
|
|
break;
|
|
// hipDeviceSetMemPool[('int', 'device'), ('hipMemPool_t', 'mem_pool')]
|
|
case HIP_API_ID_hipDeviceSetMemPool:
|
|
break;
|
|
// hipDeviceSetSharedMemConfig[('hipSharedMemConfig', 'config')]
|
|
case HIP_API_ID_hipDeviceSetSharedMemConfig:
|
|
break;
|
|
// hipDeviceSynchronize[]
|
|
case HIP_API_ID_hipDeviceSynchronize:
|
|
break;
|
|
// hipDeviceTotalMem[('size_t*', 'bytes'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipDeviceTotalMem:
|
|
if (data->args.hipDeviceTotalMem.bytes) data->args.hipDeviceTotalMem.bytes__val = *(data->args.hipDeviceTotalMem.bytes);
|
|
break;
|
|
// hipDriverGetVersion[('int*', 'driverVersion')]
|
|
case HIP_API_ID_hipDriverGetVersion:
|
|
if (data->args.hipDriverGetVersion.driverVersion) data->args.hipDriverGetVersion.driverVersion__val = *(data->args.hipDriverGetVersion.driverVersion);
|
|
break;
|
|
// hipDrvMemcpy2DUnaligned[('const hip_Memcpy2D*', 'pCopy')]
|
|
case HIP_API_ID_hipDrvMemcpy2DUnaligned:
|
|
if (data->args.hipDrvMemcpy2DUnaligned.pCopy) data->args.hipDrvMemcpy2DUnaligned.pCopy__val = *(data->args.hipDrvMemcpy2DUnaligned.pCopy);
|
|
break;
|
|
// hipDrvMemcpy3D[('const HIP_MEMCPY3D*', 'pCopy')]
|
|
case HIP_API_ID_hipDrvMemcpy3D:
|
|
if (data->args.hipDrvMemcpy3D.pCopy) data->args.hipDrvMemcpy3D.pCopy__val = *(data->args.hipDrvMemcpy3D.pCopy);
|
|
break;
|
|
// hipDrvMemcpy3DAsync[('const HIP_MEMCPY3D*', 'pCopy'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipDrvMemcpy3DAsync:
|
|
if (data->args.hipDrvMemcpy3DAsync.pCopy) data->args.hipDrvMemcpy3DAsync.pCopy__val = *(data->args.hipDrvMemcpy3DAsync.pCopy);
|
|
break;
|
|
// hipDrvPointerGetAttributes[('unsigned int', 'numAttributes'), ('hipPointer_attribute*', 'attributes'), ('void**', 'data'), ('hipDeviceptr_t', 'ptr')]
|
|
case HIP_API_ID_hipDrvPointerGetAttributes:
|
|
if (data->args.hipDrvPointerGetAttributes.attributes) data->args.hipDrvPointerGetAttributes.attributes__val = *(data->args.hipDrvPointerGetAttributes.attributes);
|
|
if (data->args.hipDrvPointerGetAttributes.data) data->args.hipDrvPointerGetAttributes.data__val = *(data->args.hipDrvPointerGetAttributes.data);
|
|
break;
|
|
// hipEventCreate[('hipEvent_t*', 'event')]
|
|
case HIP_API_ID_hipEventCreate:
|
|
if (data->args.hipEventCreate.event) data->args.hipEventCreate.event__val = *(data->args.hipEventCreate.event);
|
|
break;
|
|
// hipEventCreateWithFlags[('hipEvent_t*', 'event'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipEventCreateWithFlags:
|
|
if (data->args.hipEventCreateWithFlags.event) data->args.hipEventCreateWithFlags.event__val = *(data->args.hipEventCreateWithFlags.event);
|
|
break;
|
|
// hipEventDestroy[('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipEventDestroy:
|
|
break;
|
|
// hipEventElapsedTime[('float*', 'ms'), ('hipEvent_t', 'start'), ('hipEvent_t', 'stop')]
|
|
case HIP_API_ID_hipEventElapsedTime:
|
|
if (data->args.hipEventElapsedTime.ms) data->args.hipEventElapsedTime.ms__val = *(data->args.hipEventElapsedTime.ms);
|
|
break;
|
|
// hipEventQuery[('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipEventQuery:
|
|
break;
|
|
// hipEventRecord[('hipEvent_t', 'event'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipEventRecord:
|
|
break;
|
|
// hipEventSynchronize[('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipEventSynchronize:
|
|
break;
|
|
// hipExtGetLinkTypeAndHopCount[('int', 'device1'), ('int', 'device2'), ('unsigned int*', 'linktype'), ('unsigned int*', 'hopcount')]
|
|
case HIP_API_ID_hipExtGetLinkTypeAndHopCount:
|
|
if (data->args.hipExtGetLinkTypeAndHopCount.linktype) data->args.hipExtGetLinkTypeAndHopCount.linktype__val = *(data->args.hipExtGetLinkTypeAndHopCount.linktype);
|
|
if (data->args.hipExtGetLinkTypeAndHopCount.hopcount) data->args.hipExtGetLinkTypeAndHopCount.hopcount__val = *(data->args.hipExtGetLinkTypeAndHopCount.hopcount);
|
|
break;
|
|
// hipExtLaunchKernel[('const void*', 'function_address'), ('dim3', 'numBlocks'), ('dim3', 'dimBlocks'), ('void**', 'args'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent'), ('int', 'flags')]
|
|
case HIP_API_ID_hipExtLaunchKernel:
|
|
if (data->args.hipExtLaunchKernel.args) data->args.hipExtLaunchKernel.args__val = *(data->args.hipExtLaunchKernel.args);
|
|
break;
|
|
// hipExtLaunchMultiKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipExtLaunchMultiKernelMultiDevice:
|
|
if (data->args.hipExtLaunchMultiKernelMultiDevice.launchParamsList) data->args.hipExtLaunchMultiKernelMultiDevice.launchParamsList__val = *(data->args.hipExtLaunchMultiKernelMultiDevice.launchParamsList);
|
|
break;
|
|
// hipExtMallocWithFlags[('void**', 'ptr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipExtMallocWithFlags:
|
|
if (data->args.hipExtMallocWithFlags.ptr) data->args.hipExtMallocWithFlags.ptr__val = *(data->args.hipExtMallocWithFlags.ptr);
|
|
break;
|
|
// hipExtModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'localWorkSizeX'), ('unsigned int', 'localWorkSizeY'), ('unsigned int', 'localWorkSizeZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipExtModuleLaunchKernel:
|
|
if (data->args.hipExtModuleLaunchKernel.kernelParams) data->args.hipExtModuleLaunchKernel.kernelParams__val = *(data->args.hipExtModuleLaunchKernel.kernelParams);
|
|
if (data->args.hipExtModuleLaunchKernel.extra) data->args.hipExtModuleLaunchKernel.extra__val = *(data->args.hipExtModuleLaunchKernel.extra);
|
|
break;
|
|
// hipExtStreamCreateWithCUMask[('hipStream_t*', 'stream'), ('unsigned int', 'cuMaskSize'), ('const unsigned int*', 'cuMask')]
|
|
case HIP_API_ID_hipExtStreamCreateWithCUMask:
|
|
if (data->args.hipExtStreamCreateWithCUMask.stream) data->args.hipExtStreamCreateWithCUMask.stream__val = *(data->args.hipExtStreamCreateWithCUMask.stream);
|
|
if (data->args.hipExtStreamCreateWithCUMask.cuMask) data->args.hipExtStreamCreateWithCUMask.cuMask__val = *(data->args.hipExtStreamCreateWithCUMask.cuMask);
|
|
break;
|
|
// hipExtStreamGetCUMask[('hipStream_t', 'stream'), ('unsigned int', 'cuMaskSize'), ('unsigned int*', 'cuMask')]
|
|
case HIP_API_ID_hipExtStreamGetCUMask:
|
|
if (data->args.hipExtStreamGetCUMask.cuMask) data->args.hipExtStreamGetCUMask.cuMask__val = *(data->args.hipExtStreamGetCUMask.cuMask);
|
|
break;
|
|
// hipExternalMemoryGetMappedBuffer[('void**', 'devPtr'), ('hipExternalMemory_t', 'extMem'), ('const hipExternalMemoryBufferDesc*', 'bufferDesc')]
|
|
case HIP_API_ID_hipExternalMemoryGetMappedBuffer:
|
|
if (data->args.hipExternalMemoryGetMappedBuffer.devPtr) data->args.hipExternalMemoryGetMappedBuffer.devPtr__val = *(data->args.hipExternalMemoryGetMappedBuffer.devPtr);
|
|
if (data->args.hipExternalMemoryGetMappedBuffer.bufferDesc) data->args.hipExternalMemoryGetMappedBuffer.bufferDesc__val = *(data->args.hipExternalMemoryGetMappedBuffer.bufferDesc);
|
|
break;
|
|
// hipFree[('void*', 'ptr')]
|
|
case HIP_API_ID_hipFree:
|
|
break;
|
|
// hipFreeArray[('hipArray*', 'array')]
|
|
case HIP_API_ID_hipFreeArray:
|
|
if (data->args.hipFreeArray.array) data->args.hipFreeArray.array__val = *(data->args.hipFreeArray.array);
|
|
break;
|
|
// hipFreeAsync[('void*', 'dev_ptr'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipFreeAsync:
|
|
break;
|
|
// hipFreeHost[('void*', 'ptr')]
|
|
case HIP_API_ID_hipFreeHost:
|
|
break;
|
|
// hipFreeMipmappedArray[('hipMipmappedArray_t', 'mipmappedArray')]
|
|
case HIP_API_ID_hipFreeMipmappedArray:
|
|
break;
|
|
// hipFuncGetAttribute[('int*', 'value'), ('hipFunction_attribute', 'attrib'), ('hipFunction_t', 'hfunc')]
|
|
case HIP_API_ID_hipFuncGetAttribute:
|
|
if (data->args.hipFuncGetAttribute.value) data->args.hipFuncGetAttribute.value__val = *(data->args.hipFuncGetAttribute.value);
|
|
break;
|
|
// hipFuncGetAttributes[('hipFuncAttributes*', 'attr'), ('const void*', 'func')]
|
|
case HIP_API_ID_hipFuncGetAttributes:
|
|
if (data->args.hipFuncGetAttributes.attr) data->args.hipFuncGetAttributes.attr__val = *(data->args.hipFuncGetAttributes.attr);
|
|
break;
|
|
// hipFuncSetAttribute[('const void*', 'func'), ('hipFuncAttribute', 'attr'), ('int', 'value')]
|
|
case HIP_API_ID_hipFuncSetAttribute:
|
|
break;
|
|
// hipFuncSetCacheConfig[('const void*', 'func'), ('hipFuncCache_t', 'config')]
|
|
case HIP_API_ID_hipFuncSetCacheConfig:
|
|
break;
|
|
// hipFuncSetSharedMemConfig[('const void*', 'func'), ('hipSharedMemConfig', 'config')]
|
|
case HIP_API_ID_hipFuncSetSharedMemConfig:
|
|
break;
|
|
// hipGLGetDevices[('unsigned int*', 'pHipDeviceCount'), ('int*', 'pHipDevices'), ('unsigned int', 'hipDeviceCount'), ('hipGLDeviceList', 'deviceList')]
|
|
case HIP_API_ID_hipGLGetDevices:
|
|
if (data->args.hipGLGetDevices.pHipDeviceCount) data->args.hipGLGetDevices.pHipDeviceCount__val = *(data->args.hipGLGetDevices.pHipDeviceCount);
|
|
if (data->args.hipGLGetDevices.pHipDevices) data->args.hipGLGetDevices.pHipDevices__val = *(data->args.hipGLGetDevices.pHipDevices);
|
|
break;
|
|
// hipGetChannelDesc[('hipChannelFormatDesc*', 'desc'), ('hipArray_const_t', 'array')]
|
|
case HIP_API_ID_hipGetChannelDesc:
|
|
if (data->args.hipGetChannelDesc.desc) data->args.hipGetChannelDesc.desc__val = *(data->args.hipGetChannelDesc.desc);
|
|
break;
|
|
// hipGetDevice[('int*', 'deviceId')]
|
|
case HIP_API_ID_hipGetDevice:
|
|
if (data->args.hipGetDevice.deviceId) data->args.hipGetDevice.deviceId__val = *(data->args.hipGetDevice.deviceId);
|
|
break;
|
|
// hipGetDeviceCount[('int*', 'count')]
|
|
case HIP_API_ID_hipGetDeviceCount:
|
|
if (data->args.hipGetDeviceCount.count) data->args.hipGetDeviceCount.count__val = *(data->args.hipGetDeviceCount.count);
|
|
break;
|
|
// hipGetDeviceFlags[('unsigned int*', 'flags')]
|
|
case HIP_API_ID_hipGetDeviceFlags:
|
|
if (data->args.hipGetDeviceFlags.flags) data->args.hipGetDeviceFlags.flags__val = *(data->args.hipGetDeviceFlags.flags);
|
|
break;
|
|
// hipGetDeviceProperties[('hipDeviceProp_t*', 'props'), ('hipDevice_t', 'device')]
|
|
case HIP_API_ID_hipGetDeviceProperties:
|
|
if (data->args.hipGetDeviceProperties.props) data->args.hipGetDeviceProperties.props__val = *(data->args.hipGetDeviceProperties.props);
|
|
break;
|
|
// hipGetErrorString[]
|
|
case HIP_API_ID_hipGetErrorString:
|
|
break;
|
|
// hipGetLastError[]
|
|
case HIP_API_ID_hipGetLastError:
|
|
break;
|
|
// hipGetMipmappedArrayLevel[('hipArray_t*', 'levelArray'), ('hipMipmappedArray_const_t', 'mipmappedArray'), ('unsigned int', 'level')]
|
|
case HIP_API_ID_hipGetMipmappedArrayLevel:
|
|
if (data->args.hipGetMipmappedArrayLevel.levelArray) data->args.hipGetMipmappedArrayLevel.levelArray__val = *(data->args.hipGetMipmappedArrayLevel.levelArray);
|
|
break;
|
|
// hipGetSymbolAddress[('void**', 'devPtr'), ('const void*', 'symbol')]
|
|
case HIP_API_ID_hipGetSymbolAddress:
|
|
if (data->args.hipGetSymbolAddress.devPtr) data->args.hipGetSymbolAddress.devPtr__val = *(data->args.hipGetSymbolAddress.devPtr);
|
|
break;
|
|
// hipGetSymbolSize[('size_t*', 'size'), ('const void*', 'symbol')]
|
|
case HIP_API_ID_hipGetSymbolSize:
|
|
if (data->args.hipGetSymbolSize.size) data->args.hipGetSymbolSize.size__val = *(data->args.hipGetSymbolSize.size);
|
|
break;
|
|
// hipGraphAddChildGraphNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipGraph_t', 'childGraph')]
|
|
case HIP_API_ID_hipGraphAddChildGraphNode:
|
|
if (data->args.hipGraphAddChildGraphNode.pGraphNode) data->args.hipGraphAddChildGraphNode.pGraphNode__val = *(data->args.hipGraphAddChildGraphNode.pGraphNode);
|
|
if (data->args.hipGraphAddChildGraphNode.pDependencies) data->args.hipGraphAddChildGraphNode.pDependencies__val = *(data->args.hipGraphAddChildGraphNode.pDependencies);
|
|
break;
|
|
// hipGraphAddDependencies[('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'from'), ('const hipGraphNode_t*', 'to'), ('size_t', 'numDependencies')]
|
|
case HIP_API_ID_hipGraphAddDependencies:
|
|
if (data->args.hipGraphAddDependencies.from) data->args.hipGraphAddDependencies.from__val = *(data->args.hipGraphAddDependencies.from);
|
|
if (data->args.hipGraphAddDependencies.to) data->args.hipGraphAddDependencies.to__val = *(data->args.hipGraphAddDependencies.to);
|
|
break;
|
|
// hipGraphAddEmptyNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies')]
|
|
case HIP_API_ID_hipGraphAddEmptyNode:
|
|
if (data->args.hipGraphAddEmptyNode.pGraphNode) data->args.hipGraphAddEmptyNode.pGraphNode__val = *(data->args.hipGraphAddEmptyNode.pGraphNode);
|
|
if (data->args.hipGraphAddEmptyNode.pDependencies) data->args.hipGraphAddEmptyNode.pDependencies__val = *(data->args.hipGraphAddEmptyNode.pDependencies);
|
|
break;
|
|
// hipGraphAddEventRecordNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphAddEventRecordNode:
|
|
if (data->args.hipGraphAddEventRecordNode.pGraphNode) data->args.hipGraphAddEventRecordNode.pGraphNode__val = *(data->args.hipGraphAddEventRecordNode.pGraphNode);
|
|
if (data->args.hipGraphAddEventRecordNode.pDependencies) data->args.hipGraphAddEventRecordNode.pDependencies__val = *(data->args.hipGraphAddEventRecordNode.pDependencies);
|
|
break;
|
|
// hipGraphAddEventWaitNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphAddEventWaitNode:
|
|
if (data->args.hipGraphAddEventWaitNode.pGraphNode) data->args.hipGraphAddEventWaitNode.pGraphNode__val = *(data->args.hipGraphAddEventWaitNode.pGraphNode);
|
|
if (data->args.hipGraphAddEventWaitNode.pDependencies) data->args.hipGraphAddEventWaitNode.pDependencies__val = *(data->args.hipGraphAddEventWaitNode.pDependencies);
|
|
break;
|
|
// hipGraphAddHostNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphAddHostNode:
|
|
if (data->args.hipGraphAddHostNode.pGraphNode) data->args.hipGraphAddHostNode.pGraphNode__val = *(data->args.hipGraphAddHostNode.pGraphNode);
|
|
if (data->args.hipGraphAddHostNode.pDependencies) data->args.hipGraphAddHostNode.pDependencies__val = *(data->args.hipGraphAddHostNode.pDependencies);
|
|
if (data->args.hipGraphAddHostNode.pNodeParams) data->args.hipGraphAddHostNode.pNodeParams__val = *(data->args.hipGraphAddHostNode.pNodeParams);
|
|
break;
|
|
// hipGraphAddKernelNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphAddKernelNode:
|
|
if (data->args.hipGraphAddKernelNode.pGraphNode) data->args.hipGraphAddKernelNode.pGraphNode__val = *(data->args.hipGraphAddKernelNode.pGraphNode);
|
|
if (data->args.hipGraphAddKernelNode.pDependencies) data->args.hipGraphAddKernelNode.pDependencies__val = *(data->args.hipGraphAddKernelNode.pDependencies);
|
|
if (data->args.hipGraphAddKernelNode.pNodeParams) data->args.hipGraphAddKernelNode.pNodeParams__val = *(data->args.hipGraphAddKernelNode.pNodeParams);
|
|
break;
|
|
// hipGraphAddMemAllocNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipMemAllocNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphAddMemAllocNode:
|
|
if (data->args.hipGraphAddMemAllocNode.pGraphNode) data->args.hipGraphAddMemAllocNode.pGraphNode__val = *(data->args.hipGraphAddMemAllocNode.pGraphNode);
|
|
if (data->args.hipGraphAddMemAllocNode.pDependencies) data->args.hipGraphAddMemAllocNode.pDependencies__val = *(data->args.hipGraphAddMemAllocNode.pDependencies);
|
|
if (data->args.hipGraphAddMemAllocNode.pNodeParams) data->args.hipGraphAddMemAllocNode.pNodeParams__val = *(data->args.hipGraphAddMemAllocNode.pNodeParams);
|
|
break;
|
|
// hipGraphAddMemFreeNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dev_ptr')]
|
|
case HIP_API_ID_hipGraphAddMemFreeNode:
|
|
if (data->args.hipGraphAddMemFreeNode.pGraphNode) data->args.hipGraphAddMemFreeNode.pGraphNode__val = *(data->args.hipGraphAddMemFreeNode.pGraphNode);
|
|
if (data->args.hipGraphAddMemFreeNode.pDependencies) data->args.hipGraphAddMemFreeNode.pDependencies__val = *(data->args.hipGraphAddMemFreeNode.pDependencies);
|
|
break;
|
|
// hipGraphAddMemcpyNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipMemcpy3DParms*', 'pCopyParams')]
|
|
case HIP_API_ID_hipGraphAddMemcpyNode:
|
|
if (data->args.hipGraphAddMemcpyNode.pGraphNode) data->args.hipGraphAddMemcpyNode.pGraphNode__val = *(data->args.hipGraphAddMemcpyNode.pGraphNode);
|
|
if (data->args.hipGraphAddMemcpyNode.pDependencies) data->args.hipGraphAddMemcpyNode.pDependencies__val = *(data->args.hipGraphAddMemcpyNode.pDependencies);
|
|
if (data->args.hipGraphAddMemcpyNode.pCopyParams) data->args.hipGraphAddMemcpyNode.pCopyParams__val = *(data->args.hipGraphAddMemcpyNode.pCopyParams);
|
|
break;
|
|
// hipGraphAddMemcpyNode1D[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphAddMemcpyNode1D:
|
|
if (data->args.hipGraphAddMemcpyNode1D.pGraphNode) data->args.hipGraphAddMemcpyNode1D.pGraphNode__val = *(data->args.hipGraphAddMemcpyNode1D.pGraphNode);
|
|
if (data->args.hipGraphAddMemcpyNode1D.pDependencies) data->args.hipGraphAddMemcpyNode1D.pDependencies__val = *(data->args.hipGraphAddMemcpyNode1D.pDependencies);
|
|
break;
|
|
// hipGraphAddMemcpyNodeFromSymbol[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeFromSymbol:
|
|
if (data->args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode) data->args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode__val = *(data->args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode);
|
|
if (data->args.hipGraphAddMemcpyNodeFromSymbol.pDependencies) data->args.hipGraphAddMemcpyNodeFromSymbol.pDependencies__val = *(data->args.hipGraphAddMemcpyNodeFromSymbol.pDependencies);
|
|
break;
|
|
// hipGraphAddMemcpyNodeToSymbol[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeToSymbol:
|
|
if (data->args.hipGraphAddMemcpyNodeToSymbol.pGraphNode) data->args.hipGraphAddMemcpyNodeToSymbol.pGraphNode__val = *(data->args.hipGraphAddMemcpyNodeToSymbol.pGraphNode);
|
|
if (data->args.hipGraphAddMemcpyNodeToSymbol.pDependencies) data->args.hipGraphAddMemcpyNodeToSymbol.pDependencies__val = *(data->args.hipGraphAddMemcpyNodeToSymbol.pDependencies);
|
|
break;
|
|
// hipGraphAddMemsetNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipMemsetParams*', 'pMemsetParams')]
|
|
case HIP_API_ID_hipGraphAddMemsetNode:
|
|
if (data->args.hipGraphAddMemsetNode.pGraphNode) data->args.hipGraphAddMemsetNode.pGraphNode__val = *(data->args.hipGraphAddMemsetNode.pGraphNode);
|
|
if (data->args.hipGraphAddMemsetNode.pDependencies) data->args.hipGraphAddMemsetNode.pDependencies__val = *(data->args.hipGraphAddMemsetNode.pDependencies);
|
|
if (data->args.hipGraphAddMemsetNode.pMemsetParams) data->args.hipGraphAddMemsetNode.pMemsetParams__val = *(data->args.hipGraphAddMemsetNode.pMemsetParams);
|
|
break;
|
|
// hipGraphChildGraphNodeGetGraph[('hipGraphNode_t', 'node'), ('hipGraph_t*', 'pGraph')]
|
|
case HIP_API_ID_hipGraphChildGraphNodeGetGraph:
|
|
if (data->args.hipGraphChildGraphNodeGetGraph.pGraph) data->args.hipGraphChildGraphNodeGetGraph.pGraph__val = *(data->args.hipGraphChildGraphNodeGetGraph.pGraph);
|
|
break;
|
|
// hipGraphClone[('hipGraph_t*', 'pGraphClone'), ('hipGraph_t', 'originalGraph')]
|
|
case HIP_API_ID_hipGraphClone:
|
|
if (data->args.hipGraphClone.pGraphClone) data->args.hipGraphClone.pGraphClone__val = *(data->args.hipGraphClone.pGraphClone);
|
|
break;
|
|
// hipGraphCreate[('hipGraph_t*', 'pGraph'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipGraphCreate:
|
|
if (data->args.hipGraphCreate.pGraph) data->args.hipGraphCreate.pGraph__val = *(data->args.hipGraphCreate.pGraph);
|
|
break;
|
|
// hipGraphDebugDotPrint[('hipGraph_t', 'graph'), ('const char*', 'path'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipGraphDebugDotPrint:
|
|
if (data->args.hipGraphDebugDotPrint.path) data->args.hipGraphDebugDotPrint.path__val = *(data->args.hipGraphDebugDotPrint.path);
|
|
break;
|
|
// hipGraphDestroy[('hipGraph_t', 'graph')]
|
|
case HIP_API_ID_hipGraphDestroy:
|
|
break;
|
|
// hipGraphDestroyNode[('hipGraphNode_t', 'node')]
|
|
case HIP_API_ID_hipGraphDestroyNode:
|
|
break;
|
|
// hipGraphEventRecordNodeGetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t*', 'event_out')]
|
|
case HIP_API_ID_hipGraphEventRecordNodeGetEvent:
|
|
if (data->args.hipGraphEventRecordNodeGetEvent.event_out) data->args.hipGraphEventRecordNodeGetEvent.event_out__val = *(data->args.hipGraphEventRecordNodeGetEvent.event_out);
|
|
break;
|
|
// hipGraphEventRecordNodeSetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphEventRecordNodeSetEvent:
|
|
break;
|
|
// hipGraphEventWaitNodeGetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t*', 'event_out')]
|
|
case HIP_API_ID_hipGraphEventWaitNodeGetEvent:
|
|
if (data->args.hipGraphEventWaitNodeGetEvent.event_out) data->args.hipGraphEventWaitNodeGetEvent.event_out__val = *(data->args.hipGraphEventWaitNodeGetEvent.event_out);
|
|
break;
|
|
// hipGraphEventWaitNodeSetEvent[('hipGraphNode_t', 'node'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphEventWaitNodeSetEvent:
|
|
break;
|
|
// hipGraphExecChildGraphNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('hipGraph_t', 'childGraph')]
|
|
case HIP_API_ID_hipGraphExecChildGraphNodeSetParams:
|
|
break;
|
|
// hipGraphExecDestroy[('hipGraphExec_t', 'graphExec')]
|
|
case HIP_API_ID_hipGraphExecDestroy:
|
|
break;
|
|
// hipGraphExecEventRecordNodeSetEvent[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphExecEventRecordNodeSetEvent:
|
|
break;
|
|
// hipGraphExecEventWaitNodeSetEvent[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipGraphExecEventWaitNodeSetEvent:
|
|
break;
|
|
// hipGraphExecHostNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphExecHostNodeSetParams:
|
|
if (data->args.hipGraphExecHostNodeSetParams.pNodeParams) data->args.hipGraphExecHostNodeSetParams.pNodeParams__val = *(data->args.hipGraphExecHostNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphExecKernelNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphExecKernelNodeSetParams:
|
|
if (data->args.hipGraphExecKernelNodeSetParams.pNodeParams) data->args.hipGraphExecKernelNodeSetParams.pNodeParams__val = *(data->args.hipGraphExecKernelNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphExecMemcpyNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('hipMemcpy3DParms*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams:
|
|
if (data->args.hipGraphExecMemcpyNodeSetParams.pNodeParams) data->args.hipGraphExecMemcpyNodeSetParams.pNodeParams__val = *(data->args.hipGraphExecMemcpyNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphExecMemcpyNodeSetParams1D[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams1D:
|
|
break;
|
|
// hipGraphExecMemcpyNodeSetParamsFromSymbol[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsFromSymbol:
|
|
break;
|
|
// hipGraphExecMemcpyNodeSetParamsToSymbol[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsToSymbol:
|
|
break;
|
|
// hipGraphExecMemsetNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'node'), ('const hipMemsetParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphExecMemsetNodeSetParams:
|
|
if (data->args.hipGraphExecMemsetNodeSetParams.pNodeParams) data->args.hipGraphExecMemsetNodeSetParams.pNodeParams__val = *(data->args.hipGraphExecMemsetNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphExecUpdate[('hipGraphExec_t', 'hGraphExec'), ('hipGraph_t', 'hGraph'), ('hipGraphNode_t*', 'hErrorNode_out'), ('hipGraphExecUpdateResult*', 'updateResult_out')]
|
|
case HIP_API_ID_hipGraphExecUpdate:
|
|
if (data->args.hipGraphExecUpdate.hErrorNode_out) data->args.hipGraphExecUpdate.hErrorNode_out__val = *(data->args.hipGraphExecUpdate.hErrorNode_out);
|
|
if (data->args.hipGraphExecUpdate.updateResult_out) data->args.hipGraphExecUpdate.updateResult_out__val = *(data->args.hipGraphExecUpdate.updateResult_out);
|
|
break;
|
|
// hipGraphGetEdges[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'from'), ('hipGraphNode_t*', 'to'), ('size_t*', 'numEdges')]
|
|
case HIP_API_ID_hipGraphGetEdges:
|
|
if (data->args.hipGraphGetEdges.from) data->args.hipGraphGetEdges.from__val = *(data->args.hipGraphGetEdges.from);
|
|
if (data->args.hipGraphGetEdges.to) data->args.hipGraphGetEdges.to__val = *(data->args.hipGraphGetEdges.to);
|
|
if (data->args.hipGraphGetEdges.numEdges) data->args.hipGraphGetEdges.numEdges__val = *(data->args.hipGraphGetEdges.numEdges);
|
|
break;
|
|
// hipGraphGetNodes[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'nodes'), ('size_t*', 'numNodes')]
|
|
case HIP_API_ID_hipGraphGetNodes:
|
|
if (data->args.hipGraphGetNodes.nodes) data->args.hipGraphGetNodes.nodes__val = *(data->args.hipGraphGetNodes.nodes);
|
|
if (data->args.hipGraphGetNodes.numNodes) data->args.hipGraphGetNodes.numNodes__val = *(data->args.hipGraphGetNodes.numNodes);
|
|
break;
|
|
// hipGraphGetRootNodes[('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'pRootNodes'), ('size_t*', 'pNumRootNodes')]
|
|
case HIP_API_ID_hipGraphGetRootNodes:
|
|
if (data->args.hipGraphGetRootNodes.pRootNodes) data->args.hipGraphGetRootNodes.pRootNodes__val = *(data->args.hipGraphGetRootNodes.pRootNodes);
|
|
if (data->args.hipGraphGetRootNodes.pNumRootNodes) data->args.hipGraphGetRootNodes.pNumRootNodes__val = *(data->args.hipGraphGetRootNodes.pNumRootNodes);
|
|
break;
|
|
// hipGraphHostNodeGetParams[('hipGraphNode_t', 'node'), ('hipHostNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphHostNodeGetParams:
|
|
if (data->args.hipGraphHostNodeGetParams.pNodeParams) data->args.hipGraphHostNodeGetParams.pNodeParams__val = *(data->args.hipGraphHostNodeGetParams.pNodeParams);
|
|
break;
|
|
// hipGraphHostNodeSetParams[('hipGraphNode_t', 'node'), ('const hipHostNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphHostNodeSetParams:
|
|
if (data->args.hipGraphHostNodeSetParams.pNodeParams) data->args.hipGraphHostNodeSetParams.pNodeParams__val = *(data->args.hipGraphHostNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphInstantiate[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('hipGraphNode_t*', 'pErrorNode'), ('char*', 'pLogBuffer'), ('size_t', 'bufferSize')]
|
|
case HIP_API_ID_hipGraphInstantiate:
|
|
if (data->args.hipGraphInstantiate.pGraphExec) data->args.hipGraphInstantiate.pGraphExec__val = *(data->args.hipGraphInstantiate.pGraphExec);
|
|
if (data->args.hipGraphInstantiate.pErrorNode) data->args.hipGraphInstantiate.pErrorNode__val = *(data->args.hipGraphInstantiate.pErrorNode);
|
|
data->args.hipGraphInstantiate.pLogBuffer = (data->args.hipGraphInstantiate.pLogBuffer) ? strdup(data->args.hipGraphInstantiate.pLogBuffer) : NULL;
|
|
break;
|
|
// hipGraphInstantiateWithFlags[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('unsigned long long', 'flags')]
|
|
case HIP_API_ID_hipGraphInstantiateWithFlags:
|
|
if (data->args.hipGraphInstantiateWithFlags.pGraphExec) data->args.hipGraphInstantiateWithFlags.pGraphExec__val = *(data->args.hipGraphInstantiateWithFlags.pGraphExec);
|
|
break;
|
|
// hipGraphKernelNodeCopyAttributes[('hipGraphNode_t', 'hSrc'), ('hipGraphNode_t', 'hDst')]
|
|
case HIP_API_ID_hipGraphKernelNodeCopyAttributes:
|
|
break;
|
|
// hipGraphKernelNodeGetAttribute[('hipGraphNode_t', 'hNode'), ('hipKernelNodeAttrID', 'attr'), ('hipKernelNodeAttrValue*', 'value')]
|
|
case HIP_API_ID_hipGraphKernelNodeGetAttribute:
|
|
if (data->args.hipGraphKernelNodeGetAttribute.value) data->args.hipGraphKernelNodeGetAttribute.value__val = *(data->args.hipGraphKernelNodeGetAttribute.value);
|
|
break;
|
|
// hipGraphKernelNodeGetParams[('hipGraphNode_t', 'node'), ('hipKernelNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphKernelNodeGetParams:
|
|
if (data->args.hipGraphKernelNodeGetParams.pNodeParams) data->args.hipGraphKernelNodeGetParams.pNodeParams__val = *(data->args.hipGraphKernelNodeGetParams.pNodeParams);
|
|
break;
|
|
// hipGraphKernelNodeSetAttribute[('hipGraphNode_t', 'hNode'), ('hipKernelNodeAttrID', 'attr'), ('const hipKernelNodeAttrValue*', 'value')]
|
|
case HIP_API_ID_hipGraphKernelNodeSetAttribute:
|
|
if (data->args.hipGraphKernelNodeSetAttribute.value) data->args.hipGraphKernelNodeSetAttribute.value__val = *(data->args.hipGraphKernelNodeSetAttribute.value);
|
|
break;
|
|
// hipGraphKernelNodeSetParams[('hipGraphNode_t', 'node'), ('const hipKernelNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphKernelNodeSetParams:
|
|
if (data->args.hipGraphKernelNodeSetParams.pNodeParams) data->args.hipGraphKernelNodeSetParams.pNodeParams__val = *(data->args.hipGraphKernelNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphLaunch[('hipGraphExec_t', 'graphExec'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipGraphLaunch:
|
|
break;
|
|
// hipGraphMemAllocNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemAllocNodeParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphMemAllocNodeGetParams:
|
|
if (data->args.hipGraphMemAllocNodeGetParams.pNodeParams) data->args.hipGraphMemAllocNodeGetParams.pNodeParams__val = *(data->args.hipGraphMemAllocNodeGetParams.pNodeParams);
|
|
break;
|
|
// hipGraphMemFreeNodeGetParams[('hipGraphNode_t', 'node'), ('void*', 'dev_ptr')]
|
|
case HIP_API_ID_hipGraphMemFreeNodeGetParams:
|
|
break;
|
|
// hipGraphMemcpyNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemcpy3DParms*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphMemcpyNodeGetParams:
|
|
if (data->args.hipGraphMemcpyNodeGetParams.pNodeParams) data->args.hipGraphMemcpyNodeGetParams.pNodeParams__val = *(data->args.hipGraphMemcpyNodeGetParams.pNodeParams);
|
|
break;
|
|
// hipGraphMemcpyNodeSetParams[('hipGraphNode_t', 'node'), ('const hipMemcpy3DParms*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams:
|
|
if (data->args.hipGraphMemcpyNodeSetParams.pNodeParams) data->args.hipGraphMemcpyNodeSetParams.pNodeParams__val = *(data->args.hipGraphMemcpyNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphMemcpyNodeSetParams1D[('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams1D:
|
|
break;
|
|
// hipGraphMemcpyNodeSetParamsFromSymbol[('hipGraphNode_t', 'node'), ('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsFromSymbol:
|
|
break;
|
|
// hipGraphMemcpyNodeSetParamsToSymbol[('hipGraphNode_t', 'node'), ('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'count'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsToSymbol:
|
|
break;
|
|
// hipGraphMemsetNodeGetParams[('hipGraphNode_t', 'node'), ('hipMemsetParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphMemsetNodeGetParams:
|
|
if (data->args.hipGraphMemsetNodeGetParams.pNodeParams) data->args.hipGraphMemsetNodeGetParams.pNodeParams__val = *(data->args.hipGraphMemsetNodeGetParams.pNodeParams);
|
|
break;
|
|
// hipGraphMemsetNodeSetParams[('hipGraphNode_t', 'node'), ('const hipMemsetParams*', 'pNodeParams')]
|
|
case HIP_API_ID_hipGraphMemsetNodeSetParams:
|
|
if (data->args.hipGraphMemsetNodeSetParams.pNodeParams) data->args.hipGraphMemsetNodeSetParams.pNodeParams__val = *(data->args.hipGraphMemsetNodeSetParams.pNodeParams);
|
|
break;
|
|
// hipGraphNodeFindInClone[('hipGraphNode_t*', 'pNode'), ('hipGraphNode_t', 'originalNode'), ('hipGraph_t', 'clonedGraph')]
|
|
case HIP_API_ID_hipGraphNodeFindInClone:
|
|
if (data->args.hipGraphNodeFindInClone.pNode) data->args.hipGraphNodeFindInClone.pNode__val = *(data->args.hipGraphNodeFindInClone.pNode);
|
|
break;
|
|
// hipGraphNodeGetDependencies[('hipGraphNode_t', 'node'), ('hipGraphNode_t*', 'pDependencies'), ('size_t*', 'pNumDependencies')]
|
|
case HIP_API_ID_hipGraphNodeGetDependencies:
|
|
if (data->args.hipGraphNodeGetDependencies.pDependencies) data->args.hipGraphNodeGetDependencies.pDependencies__val = *(data->args.hipGraphNodeGetDependencies.pDependencies);
|
|
if (data->args.hipGraphNodeGetDependencies.pNumDependencies) data->args.hipGraphNodeGetDependencies.pNumDependencies__val = *(data->args.hipGraphNodeGetDependencies.pNumDependencies);
|
|
break;
|
|
// hipGraphNodeGetDependentNodes[('hipGraphNode_t', 'node'), ('hipGraphNode_t*', 'pDependentNodes'), ('size_t*', 'pNumDependentNodes')]
|
|
case HIP_API_ID_hipGraphNodeGetDependentNodes:
|
|
if (data->args.hipGraphNodeGetDependentNodes.pDependentNodes) data->args.hipGraphNodeGetDependentNodes.pDependentNodes__val = *(data->args.hipGraphNodeGetDependentNodes.pDependentNodes);
|
|
if (data->args.hipGraphNodeGetDependentNodes.pNumDependentNodes) data->args.hipGraphNodeGetDependentNodes.pNumDependentNodes__val = *(data->args.hipGraphNodeGetDependentNodes.pNumDependentNodes);
|
|
break;
|
|
// hipGraphNodeGetEnabled[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('unsigned int*', 'isEnabled')]
|
|
case HIP_API_ID_hipGraphNodeGetEnabled:
|
|
if (data->args.hipGraphNodeGetEnabled.isEnabled) data->args.hipGraphNodeGetEnabled.isEnabled__val = *(data->args.hipGraphNodeGetEnabled.isEnabled);
|
|
break;
|
|
// hipGraphNodeGetType[('hipGraphNode_t', 'node'), ('hipGraphNodeType*', 'pType')]
|
|
case HIP_API_ID_hipGraphNodeGetType:
|
|
if (data->args.hipGraphNodeGetType.pType) data->args.hipGraphNodeGetType.pType__val = *(data->args.hipGraphNodeGetType.pType);
|
|
break;
|
|
// hipGraphNodeSetEnabled[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('unsigned int', 'isEnabled')]
|
|
case HIP_API_ID_hipGraphNodeSetEnabled:
|
|
break;
|
|
// hipGraphReleaseUserObject[('hipGraph_t', 'graph'), ('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
case HIP_API_ID_hipGraphReleaseUserObject:
|
|
break;
|
|
// hipGraphRemoveDependencies[('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'from'), ('const hipGraphNode_t*', 'to'), ('size_t', 'numDependencies')]
|
|
case HIP_API_ID_hipGraphRemoveDependencies:
|
|
if (data->args.hipGraphRemoveDependencies.from) data->args.hipGraphRemoveDependencies.from__val = *(data->args.hipGraphRemoveDependencies.from);
|
|
if (data->args.hipGraphRemoveDependencies.to) data->args.hipGraphRemoveDependencies.to__val = *(data->args.hipGraphRemoveDependencies.to);
|
|
break;
|
|
// hipGraphRetainUserObject[('hipGraph_t', 'graph'), ('hipUserObject_t', 'object'), ('unsigned int', 'count'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipGraphRetainUserObject:
|
|
break;
|
|
// hipGraphUpload[('hipGraphExec_t', 'graphExec'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipGraphUpload:
|
|
break;
|
|
// hipGraphicsGLRegisterBuffer[('hipGraphicsResource**', 'resource'), ('GLuint', 'buffer'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipGraphicsGLRegisterBuffer:
|
|
if (data->args.hipGraphicsGLRegisterBuffer.resource) data->args.hipGraphicsGLRegisterBuffer.resource__val = *(data->args.hipGraphicsGLRegisterBuffer.resource);
|
|
break;
|
|
// hipGraphicsGLRegisterImage[('hipGraphicsResource**', 'resource'), ('GLuint', 'image'), ('GLenum', 'target'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipGraphicsGLRegisterImage:
|
|
if (data->args.hipGraphicsGLRegisterImage.resource) data->args.hipGraphicsGLRegisterImage.resource__val = *(data->args.hipGraphicsGLRegisterImage.resource);
|
|
break;
|
|
// hipGraphicsMapResources[('int', 'count'), ('hipGraphicsResource_t*', 'resources'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipGraphicsMapResources:
|
|
if (data->args.hipGraphicsMapResources.resources) data->args.hipGraphicsMapResources.resources__val = *(data->args.hipGraphicsMapResources.resources);
|
|
break;
|
|
// hipGraphicsResourceGetMappedPointer[('void**', 'devPtr'), ('size_t*', 'size'), ('hipGraphicsResource_t', 'resource')]
|
|
case HIP_API_ID_hipGraphicsResourceGetMappedPointer:
|
|
if (data->args.hipGraphicsResourceGetMappedPointer.devPtr) data->args.hipGraphicsResourceGetMappedPointer.devPtr__val = *(data->args.hipGraphicsResourceGetMappedPointer.devPtr);
|
|
if (data->args.hipGraphicsResourceGetMappedPointer.size) data->args.hipGraphicsResourceGetMappedPointer.size__val = *(data->args.hipGraphicsResourceGetMappedPointer.size);
|
|
break;
|
|
// hipGraphicsSubResourceGetMappedArray[('hipArray_t*', 'array'), ('hipGraphicsResource_t', 'resource'), ('unsigned int', 'arrayIndex'), ('unsigned int', 'mipLevel')]
|
|
case HIP_API_ID_hipGraphicsSubResourceGetMappedArray:
|
|
if (data->args.hipGraphicsSubResourceGetMappedArray.array) data->args.hipGraphicsSubResourceGetMappedArray.array__val = *(data->args.hipGraphicsSubResourceGetMappedArray.array);
|
|
break;
|
|
// hipGraphicsUnmapResources[('int', 'count'), ('hipGraphicsResource_t*', 'resources'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipGraphicsUnmapResources:
|
|
if (data->args.hipGraphicsUnmapResources.resources) data->args.hipGraphicsUnmapResources.resources__val = *(data->args.hipGraphicsUnmapResources.resources);
|
|
break;
|
|
// hipGraphicsUnregisterResource[('hipGraphicsResource_t', 'resource')]
|
|
case HIP_API_ID_hipGraphicsUnregisterResource:
|
|
break;
|
|
// hipHccModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent')]
|
|
case HIP_API_ID_hipHccModuleLaunchKernel:
|
|
if (data->args.hipHccModuleLaunchKernel.kernelParams) data->args.hipHccModuleLaunchKernel.kernelParams__val = *(data->args.hipHccModuleLaunchKernel.kernelParams);
|
|
if (data->args.hipHccModuleLaunchKernel.extra) data->args.hipHccModuleLaunchKernel.extra__val = *(data->args.hipHccModuleLaunchKernel.extra);
|
|
break;
|
|
// hipHostAlloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipHostAlloc:
|
|
if (data->args.hipHostAlloc.ptr) data->args.hipHostAlloc.ptr__val = *(data->args.hipHostAlloc.ptr);
|
|
break;
|
|
// hipHostFree[('void*', 'ptr')]
|
|
case HIP_API_ID_hipHostFree:
|
|
break;
|
|
// hipHostGetDevicePointer[('void**', 'devPtr'), ('void*', 'hstPtr'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipHostGetDevicePointer:
|
|
if (data->args.hipHostGetDevicePointer.devPtr) data->args.hipHostGetDevicePointer.devPtr__val = *(data->args.hipHostGetDevicePointer.devPtr);
|
|
break;
|
|
// hipHostGetFlags[('unsigned int*', 'flagsPtr'), ('void*', 'hostPtr')]
|
|
case HIP_API_ID_hipHostGetFlags:
|
|
if (data->args.hipHostGetFlags.flagsPtr) data->args.hipHostGetFlags.flagsPtr__val = *(data->args.hipHostGetFlags.flagsPtr);
|
|
break;
|
|
// hipHostMalloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipHostMalloc:
|
|
if (data->args.hipHostMalloc.ptr) data->args.hipHostMalloc.ptr__val = *(data->args.hipHostMalloc.ptr);
|
|
break;
|
|
// hipHostRegister[('void*', 'hostPtr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipHostRegister:
|
|
break;
|
|
// hipHostUnregister[('void*', 'hostPtr')]
|
|
case HIP_API_ID_hipHostUnregister:
|
|
break;
|
|
// hipImportExternalMemory[('hipExternalMemory_t*', 'extMem_out'), ('const hipExternalMemoryHandleDesc*', 'memHandleDesc')]
|
|
case HIP_API_ID_hipImportExternalMemory:
|
|
if (data->args.hipImportExternalMemory.extMem_out) data->args.hipImportExternalMemory.extMem_out__val = *(data->args.hipImportExternalMemory.extMem_out);
|
|
if (data->args.hipImportExternalMemory.memHandleDesc) data->args.hipImportExternalMemory.memHandleDesc__val = *(data->args.hipImportExternalMemory.memHandleDesc);
|
|
break;
|
|
// hipImportExternalSemaphore[('hipExternalSemaphore_t*', 'extSem_out'), ('const hipExternalSemaphoreHandleDesc*', 'semHandleDesc')]
|
|
case HIP_API_ID_hipImportExternalSemaphore:
|
|
if (data->args.hipImportExternalSemaphore.extSem_out) data->args.hipImportExternalSemaphore.extSem_out__val = *(data->args.hipImportExternalSemaphore.extSem_out);
|
|
if (data->args.hipImportExternalSemaphore.semHandleDesc) data->args.hipImportExternalSemaphore.semHandleDesc__val = *(data->args.hipImportExternalSemaphore.semHandleDesc);
|
|
break;
|
|
// hipInit[('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipInit:
|
|
break;
|
|
// hipIpcCloseMemHandle[('void*', 'devPtr')]
|
|
case HIP_API_ID_hipIpcCloseMemHandle:
|
|
break;
|
|
// hipIpcGetEventHandle[('hipIpcEventHandle_t*', 'handle'), ('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipIpcGetEventHandle:
|
|
if (data->args.hipIpcGetEventHandle.handle) data->args.hipIpcGetEventHandle.handle__val = *(data->args.hipIpcGetEventHandle.handle);
|
|
break;
|
|
// hipIpcGetMemHandle[('hipIpcMemHandle_t*', 'handle'), ('void*', 'devPtr')]
|
|
case HIP_API_ID_hipIpcGetMemHandle:
|
|
if (data->args.hipIpcGetMemHandle.handle) data->args.hipIpcGetMemHandle.handle__val = *(data->args.hipIpcGetMemHandle.handle);
|
|
break;
|
|
// hipIpcOpenEventHandle[('hipEvent_t*', 'event'), ('hipIpcEventHandle_t', 'handle')]
|
|
case HIP_API_ID_hipIpcOpenEventHandle:
|
|
if (data->args.hipIpcOpenEventHandle.event) data->args.hipIpcOpenEventHandle.event__val = *(data->args.hipIpcOpenEventHandle.event);
|
|
break;
|
|
// hipIpcOpenMemHandle[('void**', 'devPtr'), ('hipIpcMemHandle_t', 'handle'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipIpcOpenMemHandle:
|
|
if (data->args.hipIpcOpenMemHandle.devPtr) data->args.hipIpcOpenMemHandle.devPtr__val = *(data->args.hipIpcOpenMemHandle.devPtr);
|
|
break;
|
|
// hipLaunchByPtr[('const void*', 'hostFunction')]
|
|
case HIP_API_ID_hipLaunchByPtr:
|
|
break;
|
|
// hipLaunchCooperativeKernel[('const void*', 'f'), ('dim3', 'gridDim'), ('dim3', 'blockDimX'), ('void**', 'kernelParams'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipLaunchCooperativeKernel:
|
|
if (data->args.hipLaunchCooperativeKernel.kernelParams) data->args.hipLaunchCooperativeKernel.kernelParams__val = *(data->args.hipLaunchCooperativeKernel.kernelParams);
|
|
break;
|
|
// hipLaunchCooperativeKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipLaunchCooperativeKernelMultiDevice:
|
|
if (data->args.hipLaunchCooperativeKernelMultiDevice.launchParamsList) data->args.hipLaunchCooperativeKernelMultiDevice.launchParamsList__val = *(data->args.hipLaunchCooperativeKernelMultiDevice.launchParamsList);
|
|
break;
|
|
// hipLaunchHostFunc[('hipStream_t', 'stream'), ('hipHostFn_t', 'fn'), ('void*', 'userData')]
|
|
case HIP_API_ID_hipLaunchHostFunc:
|
|
break;
|
|
// hipLaunchKernel[('const void*', 'function_address'), ('dim3', 'numBlocks'), ('dim3', 'dimBlocks'), ('void**', 'args'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipLaunchKernel:
|
|
if (data->args.hipLaunchKernel.args) data->args.hipLaunchKernel.args__val = *(data->args.hipLaunchKernel.args);
|
|
break;
|
|
// hipMalloc[('void**', 'ptr'), ('size_t', 'size')]
|
|
case HIP_API_ID_hipMalloc:
|
|
if (data->args.hipMalloc.ptr) data->args.hipMalloc.ptr__val = *(data->args.hipMalloc.ptr);
|
|
break;
|
|
// hipMalloc3D[('hipPitchedPtr*', 'pitchedDevPtr'), ('hipExtent', 'extent')]
|
|
case HIP_API_ID_hipMalloc3D:
|
|
if (data->args.hipMalloc3D.pitchedDevPtr) data->args.hipMalloc3D.pitchedDevPtr__val = *(data->args.hipMalloc3D.pitchedDevPtr);
|
|
break;
|
|
// hipMalloc3DArray[('hipArray_t*', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMalloc3DArray:
|
|
if (data->args.hipMalloc3DArray.array) data->args.hipMalloc3DArray.array__val = *(data->args.hipMalloc3DArray.array);
|
|
if (data->args.hipMalloc3DArray.desc) data->args.hipMalloc3DArray.desc__val = *(data->args.hipMalloc3DArray.desc);
|
|
break;
|
|
// hipMallocArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('size_t', 'width'), ('size_t', 'height'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMallocArray:
|
|
if (data->args.hipMallocArray.array) data->args.hipMallocArray.array__val = *(data->args.hipMallocArray.array);
|
|
if (data->args.hipMallocArray.desc) data->args.hipMallocArray.desc__val = *(data->args.hipMallocArray.desc);
|
|
break;
|
|
// hipMallocAsync[('void**', 'dev_ptr'), ('size_t', 'size'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMallocAsync:
|
|
if (data->args.hipMallocAsync.dev_ptr) data->args.hipMallocAsync.dev_ptr__val = *(data->args.hipMallocAsync.dev_ptr);
|
|
break;
|
|
// hipMallocFromPoolAsync[('void**', 'dev_ptr'), ('size_t', 'size'), ('hipMemPool_t', 'mem_pool'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMallocFromPoolAsync:
|
|
if (data->args.hipMallocFromPoolAsync.dev_ptr) data->args.hipMallocFromPoolAsync.dev_ptr__val = *(data->args.hipMallocFromPoolAsync.dev_ptr);
|
|
break;
|
|
// hipMallocHost[('void**', 'ptr'), ('size_t', 'size')]
|
|
case HIP_API_ID_hipMallocHost:
|
|
if (data->args.hipMallocHost.ptr) data->args.hipMallocHost.ptr__val = *(data->args.hipMallocHost.ptr);
|
|
break;
|
|
// hipMallocManaged[('void**', 'dev_ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMallocManaged:
|
|
if (data->args.hipMallocManaged.dev_ptr) data->args.hipMallocManaged.dev_ptr__val = *(data->args.hipMallocManaged.dev_ptr);
|
|
break;
|
|
// hipMallocMipmappedArray[('hipMipmappedArray_t*', 'mipmappedArray'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'numLevels'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMallocMipmappedArray:
|
|
if (data->args.hipMallocMipmappedArray.mipmappedArray) data->args.hipMallocMipmappedArray.mipmappedArray__val = *(data->args.hipMallocMipmappedArray.mipmappedArray);
|
|
if (data->args.hipMallocMipmappedArray.desc) data->args.hipMallocMipmappedArray.desc__val = *(data->args.hipMallocMipmappedArray.desc);
|
|
break;
|
|
// hipMallocPitch[('void**', 'ptr'), ('size_t*', 'pitch'), ('size_t', 'width'), ('size_t', 'height')]
|
|
case HIP_API_ID_hipMallocPitch:
|
|
if (data->args.hipMallocPitch.ptr) data->args.hipMallocPitch.ptr__val = *(data->args.hipMallocPitch.ptr);
|
|
if (data->args.hipMallocPitch.pitch) data->args.hipMallocPitch.pitch__val = *(data->args.hipMallocPitch.pitch);
|
|
break;
|
|
// hipMemAddressFree[('void*', 'devPtr'), ('size_t', 'size')]
|
|
case HIP_API_ID_hipMemAddressFree:
|
|
break;
|
|
// hipMemAddressReserve[('void**', 'ptr'), ('size_t', 'size'), ('size_t', 'alignment'), ('void*', 'addr'), ('unsigned long long', 'flags')]
|
|
case HIP_API_ID_hipMemAddressReserve:
|
|
if (data->args.hipMemAddressReserve.ptr) data->args.hipMemAddressReserve.ptr__val = *(data->args.hipMemAddressReserve.ptr);
|
|
break;
|
|
// hipMemAdvise[('const void*', 'dev_ptr'), ('size_t', 'count'), ('hipMemoryAdvise', 'advice'), ('int', 'device')]
|
|
case HIP_API_ID_hipMemAdvise:
|
|
break;
|
|
// hipMemAllocHost[('void**', 'ptr'), ('size_t', 'size')]
|
|
case HIP_API_ID_hipMemAllocHost:
|
|
if (data->args.hipMemAllocHost.ptr) data->args.hipMemAllocHost.ptr__val = *(data->args.hipMemAllocHost.ptr);
|
|
break;
|
|
// hipMemAllocPitch[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'pitch'), ('size_t', 'widthInBytes'), ('size_t', 'height'), ('unsigned int', 'elementSizeBytes')]
|
|
case HIP_API_ID_hipMemAllocPitch:
|
|
if (data->args.hipMemAllocPitch.dptr) data->args.hipMemAllocPitch.dptr__val = *(data->args.hipMemAllocPitch.dptr);
|
|
if (data->args.hipMemAllocPitch.pitch) data->args.hipMemAllocPitch.pitch__val = *(data->args.hipMemAllocPitch.pitch);
|
|
break;
|
|
// hipMemCreate[('hipMemGenericAllocationHandle_t*', 'handle'), ('size_t', 'size'), ('const hipMemAllocationProp*', 'prop'), ('unsigned long long', 'flags')]
|
|
case HIP_API_ID_hipMemCreate:
|
|
if (data->args.hipMemCreate.handle) data->args.hipMemCreate.handle__val = *(data->args.hipMemCreate.handle);
|
|
if (data->args.hipMemCreate.prop) data->args.hipMemCreate.prop__val = *(data->args.hipMemCreate.prop);
|
|
break;
|
|
// hipMemExportToShareableHandle[('void*', 'shareableHandle'), ('hipMemGenericAllocationHandle_t', 'handle'), ('hipMemAllocationHandleType', 'handleType'), ('unsigned long long', 'flags')]
|
|
case HIP_API_ID_hipMemExportToShareableHandle:
|
|
break;
|
|
// hipMemGetAccess[('unsigned long long*', 'flags'), ('const hipMemLocation*', 'location'), ('void*', 'ptr')]
|
|
case HIP_API_ID_hipMemGetAccess:
|
|
if (data->args.hipMemGetAccess.flags) data->args.hipMemGetAccess.flags__val = *(data->args.hipMemGetAccess.flags);
|
|
if (data->args.hipMemGetAccess.location) data->args.hipMemGetAccess.location__val = *(data->args.hipMemGetAccess.location);
|
|
break;
|
|
// hipMemGetAddressRange[('hipDeviceptr_t*', 'pbase'), ('size_t*', 'psize'), ('hipDeviceptr_t', 'dptr')]
|
|
case HIP_API_ID_hipMemGetAddressRange:
|
|
if (data->args.hipMemGetAddressRange.pbase) data->args.hipMemGetAddressRange.pbase__val = *(data->args.hipMemGetAddressRange.pbase);
|
|
if (data->args.hipMemGetAddressRange.psize) data->args.hipMemGetAddressRange.psize__val = *(data->args.hipMemGetAddressRange.psize);
|
|
break;
|
|
// hipMemGetAllocationGranularity[('size_t*', 'granularity'), ('const hipMemAllocationProp*', 'prop'), ('hipMemAllocationGranularity_flags', 'option')]
|
|
case HIP_API_ID_hipMemGetAllocationGranularity:
|
|
if (data->args.hipMemGetAllocationGranularity.granularity) data->args.hipMemGetAllocationGranularity.granularity__val = *(data->args.hipMemGetAllocationGranularity.granularity);
|
|
if (data->args.hipMemGetAllocationGranularity.prop) data->args.hipMemGetAllocationGranularity.prop__val = *(data->args.hipMemGetAllocationGranularity.prop);
|
|
break;
|
|
// hipMemGetAllocationPropertiesFromHandle[('hipMemAllocationProp*', 'prop'), ('hipMemGenericAllocationHandle_t', 'handle')]
|
|
case HIP_API_ID_hipMemGetAllocationPropertiesFromHandle:
|
|
if (data->args.hipMemGetAllocationPropertiesFromHandle.prop) data->args.hipMemGetAllocationPropertiesFromHandle.prop__val = *(data->args.hipMemGetAllocationPropertiesFromHandle.prop);
|
|
break;
|
|
// hipMemGetInfo[('size_t*', 'free'), ('size_t*', 'total')]
|
|
case HIP_API_ID_hipMemGetInfo:
|
|
if (data->args.hipMemGetInfo.free) data->args.hipMemGetInfo.free__val = *(data->args.hipMemGetInfo.free);
|
|
if (data->args.hipMemGetInfo.total) data->args.hipMemGetInfo.total__val = *(data->args.hipMemGetInfo.total);
|
|
break;
|
|
// hipMemImportFromShareableHandle[('hipMemGenericAllocationHandle_t*', 'handle'), ('void*', 'osHandle'), ('hipMemAllocationHandleType', 'shHandleType')]
|
|
case HIP_API_ID_hipMemImportFromShareableHandle:
|
|
if (data->args.hipMemImportFromShareableHandle.handle) data->args.hipMemImportFromShareableHandle.handle__val = *(data->args.hipMemImportFromShareableHandle.handle);
|
|
break;
|
|
// hipMemMap[('void*', 'ptr'), ('size_t', 'size'), ('size_t', 'offset'), ('hipMemGenericAllocationHandle_t', 'handle'), ('unsigned long long', 'flags')]
|
|
case HIP_API_ID_hipMemMap:
|
|
break;
|
|
// hipMemMapArrayAsync[('hipArrayMapInfo*', 'mapInfoList'), ('unsigned int', 'count'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemMapArrayAsync:
|
|
if (data->args.hipMemMapArrayAsync.mapInfoList) data->args.hipMemMapArrayAsync.mapInfoList__val = *(data->args.hipMemMapArrayAsync.mapInfoList);
|
|
break;
|
|
// hipMemPoolCreate[('hipMemPool_t*', 'mem_pool'), ('const hipMemPoolProps*', 'pool_props')]
|
|
case HIP_API_ID_hipMemPoolCreate:
|
|
if (data->args.hipMemPoolCreate.mem_pool) data->args.hipMemPoolCreate.mem_pool__val = *(data->args.hipMemPoolCreate.mem_pool);
|
|
if (data->args.hipMemPoolCreate.pool_props) data->args.hipMemPoolCreate.pool_props__val = *(data->args.hipMemPoolCreate.pool_props);
|
|
break;
|
|
// hipMemPoolDestroy[('hipMemPool_t', 'mem_pool')]
|
|
case HIP_API_ID_hipMemPoolDestroy:
|
|
break;
|
|
// hipMemPoolExportPointer[('hipMemPoolPtrExportData*', 'export_data'), ('void*', 'dev_ptr')]
|
|
case HIP_API_ID_hipMemPoolExportPointer:
|
|
if (data->args.hipMemPoolExportPointer.export_data) data->args.hipMemPoolExportPointer.export_data__val = *(data->args.hipMemPoolExportPointer.export_data);
|
|
break;
|
|
// hipMemPoolExportToShareableHandle[('void*', 'shared_handle'), ('hipMemPool_t', 'mem_pool'), ('hipMemAllocationHandleType', 'handle_type'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMemPoolExportToShareableHandle:
|
|
break;
|
|
// hipMemPoolGetAccess[('hipMemAccessFlags*', 'flags'), ('hipMemPool_t', 'mem_pool'), ('hipMemLocation*', 'location')]
|
|
case HIP_API_ID_hipMemPoolGetAccess:
|
|
if (data->args.hipMemPoolGetAccess.flags) data->args.hipMemPoolGetAccess.flags__val = *(data->args.hipMemPoolGetAccess.flags);
|
|
if (data->args.hipMemPoolGetAccess.location) data->args.hipMemPoolGetAccess.location__val = *(data->args.hipMemPoolGetAccess.location);
|
|
break;
|
|
// hipMemPoolGetAttribute[('hipMemPool_t', 'mem_pool'), ('hipMemPoolAttr', 'attr'), ('void*', 'value')]
|
|
case HIP_API_ID_hipMemPoolGetAttribute:
|
|
break;
|
|
// hipMemPoolImportFromShareableHandle[('hipMemPool_t*', 'mem_pool'), ('void*', 'shared_handle'), ('hipMemAllocationHandleType', 'handle_type'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipMemPoolImportFromShareableHandle:
|
|
if (data->args.hipMemPoolImportFromShareableHandle.mem_pool) data->args.hipMemPoolImportFromShareableHandle.mem_pool__val = *(data->args.hipMemPoolImportFromShareableHandle.mem_pool);
|
|
break;
|
|
// hipMemPoolImportPointer[('void**', 'dev_ptr'), ('hipMemPool_t', 'mem_pool'), ('hipMemPoolPtrExportData*', 'export_data')]
|
|
case HIP_API_ID_hipMemPoolImportPointer:
|
|
if (data->args.hipMemPoolImportPointer.dev_ptr) data->args.hipMemPoolImportPointer.dev_ptr__val = *(data->args.hipMemPoolImportPointer.dev_ptr);
|
|
if (data->args.hipMemPoolImportPointer.export_data) data->args.hipMemPoolImportPointer.export_data__val = *(data->args.hipMemPoolImportPointer.export_data);
|
|
break;
|
|
// hipMemPoolSetAccess[('hipMemPool_t', 'mem_pool'), ('const hipMemAccessDesc*', 'desc_list'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemPoolSetAccess:
|
|
if (data->args.hipMemPoolSetAccess.desc_list) data->args.hipMemPoolSetAccess.desc_list__val = *(data->args.hipMemPoolSetAccess.desc_list);
|
|
break;
|
|
// hipMemPoolSetAttribute[('hipMemPool_t', 'mem_pool'), ('hipMemPoolAttr', 'attr'), ('void*', 'value')]
|
|
case HIP_API_ID_hipMemPoolSetAttribute:
|
|
break;
|
|
// hipMemPoolTrimTo[('hipMemPool_t', 'mem_pool'), ('size_t', 'min_bytes_to_hold')]
|
|
case HIP_API_ID_hipMemPoolTrimTo:
|
|
break;
|
|
// hipMemPrefetchAsync[('const void*', 'dev_ptr'), ('size_t', 'count'), ('int', 'device'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemPrefetchAsync:
|
|
break;
|
|
// hipMemPtrGetInfo[('void*', 'ptr'), ('size_t*', 'size')]
|
|
case HIP_API_ID_hipMemPtrGetInfo:
|
|
if (data->args.hipMemPtrGetInfo.size) data->args.hipMemPtrGetInfo.size__val = *(data->args.hipMemPtrGetInfo.size);
|
|
break;
|
|
// hipMemRangeGetAttribute[('void*', 'data'), ('size_t', 'data_size'), ('hipMemRangeAttribute', 'attribute'), ('const void*', 'dev_ptr'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemRangeGetAttribute:
|
|
break;
|
|
// hipMemRangeGetAttributes[('void**', 'data'), ('size_t*', 'data_sizes'), ('hipMemRangeAttribute*', 'attributes'), ('size_t', 'num_attributes'), ('const void*', 'dev_ptr'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemRangeGetAttributes:
|
|
if (data->args.hipMemRangeGetAttributes.data) data->args.hipMemRangeGetAttributes.data__val = *(data->args.hipMemRangeGetAttributes.data);
|
|
if (data->args.hipMemRangeGetAttributes.data_sizes) data->args.hipMemRangeGetAttributes.data_sizes__val = *(data->args.hipMemRangeGetAttributes.data_sizes);
|
|
if (data->args.hipMemRangeGetAttributes.attributes) data->args.hipMemRangeGetAttributes.attributes__val = *(data->args.hipMemRangeGetAttributes.attributes);
|
|
break;
|
|
// hipMemRelease[('hipMemGenericAllocationHandle_t', 'handle')]
|
|
case HIP_API_ID_hipMemRelease:
|
|
break;
|
|
// hipMemRetainAllocationHandle[('hipMemGenericAllocationHandle_t*', 'handle'), ('void*', 'addr')]
|
|
case HIP_API_ID_hipMemRetainAllocationHandle:
|
|
if (data->args.hipMemRetainAllocationHandle.handle) data->args.hipMemRetainAllocationHandle.handle__val = *(data->args.hipMemRetainAllocationHandle.handle);
|
|
break;
|
|
// hipMemSetAccess[('void*', 'ptr'), ('size_t', 'size'), ('const hipMemAccessDesc*', 'desc'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemSetAccess:
|
|
if (data->args.hipMemSetAccess.desc) data->args.hipMemSetAccess.desc__val = *(data->args.hipMemSetAccess.desc);
|
|
break;
|
|
// hipMemUnmap[('void*', 'ptr'), ('size_t', 'size')]
|
|
case HIP_API_ID_hipMemUnmap:
|
|
break;
|
|
// hipMemcpy[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpy:
|
|
break;
|
|
// hipMemcpy2D[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpy2D:
|
|
break;
|
|
// hipMemcpy2DAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpy2DAsync:
|
|
break;
|
|
// hipMemcpy2DFromArray[('void*', 'dst'), ('size_t', 'dpitch'), ('hipArray_const_t', 'src'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpy2DFromArray:
|
|
break;
|
|
// hipMemcpy2DFromArrayAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('hipArray_const_t', 'src'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpy2DFromArrayAsync:
|
|
break;
|
|
// hipMemcpy2DToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpy2DToArray:
|
|
if (data->args.hipMemcpy2DToArray.dst) data->args.hipMemcpy2DToArray.dst__val = *(data->args.hipMemcpy2DToArray.dst);
|
|
break;
|
|
// hipMemcpy2DToArrayAsync[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpy2DToArrayAsync:
|
|
if (data->args.hipMemcpy2DToArrayAsync.dst) data->args.hipMemcpy2DToArrayAsync.dst__val = *(data->args.hipMemcpy2DToArrayAsync.dst);
|
|
break;
|
|
// hipMemcpy3D[('const hipMemcpy3DParms*', 'p')]
|
|
case HIP_API_ID_hipMemcpy3D:
|
|
if (data->args.hipMemcpy3D.p) data->args.hipMemcpy3D.p__val = *(data->args.hipMemcpy3D.p);
|
|
break;
|
|
// hipMemcpy3DAsync[('const hipMemcpy3DParms*', 'p'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpy3DAsync:
|
|
if (data->args.hipMemcpy3DAsync.p) data->args.hipMemcpy3DAsync.p__val = *(data->args.hipMemcpy3DAsync.p);
|
|
break;
|
|
// hipMemcpyAsync[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyAsync:
|
|
break;
|
|
// hipMemcpyAtoH[('void*', 'dst'), ('hipArray*', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemcpyAtoH:
|
|
if (data->args.hipMemcpyAtoH.srcArray) data->args.hipMemcpyAtoH.srcArray__val = *(data->args.hipMemcpyAtoH.srcArray);
|
|
break;
|
|
// hipMemcpyDtoD[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
|
|
case HIP_API_ID_hipMemcpyDtoD:
|
|
break;
|
|
// hipMemcpyDtoDAsync[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyDtoDAsync:
|
|
break;
|
|
// hipMemcpyDtoH[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
|
|
case HIP_API_ID_hipMemcpyDtoH:
|
|
break;
|
|
// hipMemcpyDtoHAsync[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyDtoHAsync:
|
|
break;
|
|
// hipMemcpyFromArray[('void*', 'dst'), ('hipArray_const_t', 'srcArray'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpyFromArray:
|
|
break;
|
|
// hipMemcpyFromSymbol[('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpyFromSymbol:
|
|
break;
|
|
// hipMemcpyFromSymbolAsync[('void*', 'dst'), ('const void*', 'symbol'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyFromSymbolAsync:
|
|
break;
|
|
// hipMemcpyHtoA[('hipArray*', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemcpyHtoA:
|
|
if (data->args.hipMemcpyHtoA.dstArray) data->args.hipMemcpyHtoA.dstArray__val = *(data->args.hipMemcpyHtoA.dstArray);
|
|
break;
|
|
// hipMemcpyHtoD[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes')]
|
|
case HIP_API_ID_hipMemcpyHtoD:
|
|
break;
|
|
// hipMemcpyHtoDAsync[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyHtoDAsync:
|
|
break;
|
|
// hipMemcpyParam2D[('const hip_Memcpy2D*', 'pCopy')]
|
|
case HIP_API_ID_hipMemcpyParam2D:
|
|
if (data->args.hipMemcpyParam2D.pCopy) data->args.hipMemcpyParam2D.pCopy__val = *(data->args.hipMemcpyParam2D.pCopy);
|
|
break;
|
|
// hipMemcpyParam2DAsync[('const hip_Memcpy2D*', 'pCopy'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyParam2DAsync:
|
|
if (data->args.hipMemcpyParam2DAsync.pCopy) data->args.hipMemcpyParam2DAsync.pCopy__val = *(data->args.hipMemcpyParam2DAsync.pCopy);
|
|
break;
|
|
// hipMemcpyPeer[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDeviceId'), ('size_t', 'sizeBytes')]
|
|
case HIP_API_ID_hipMemcpyPeer:
|
|
break;
|
|
// hipMemcpyPeerAsync[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDevice'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyPeerAsync:
|
|
break;
|
|
// hipMemcpyToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpyToArray:
|
|
if (data->args.hipMemcpyToArray.dst) data->args.hipMemcpyToArray.dst__val = *(data->args.hipMemcpyToArray.dst);
|
|
break;
|
|
// hipMemcpyToSymbol[('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpyToSymbol:
|
|
break;
|
|
// hipMemcpyToSymbolAsync[('const void*', 'symbol'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyToSymbolAsync:
|
|
break;
|
|
// hipMemcpyWithStream[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyWithStream:
|
|
break;
|
|
// hipMemset[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes')]
|
|
case HIP_API_ID_hipMemset:
|
|
break;
|
|
// hipMemset2D[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height')]
|
|
case HIP_API_ID_hipMemset2D:
|
|
break;
|
|
// hipMemset2DAsync[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemset2DAsync:
|
|
break;
|
|
// hipMemset3D[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent')]
|
|
case HIP_API_ID_hipMemset3D:
|
|
break;
|
|
// hipMemset3DAsync[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemset3DAsync:
|
|
break;
|
|
// hipMemsetAsync[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemsetAsync:
|
|
break;
|
|
// hipMemsetD16[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemsetD16:
|
|
break;
|
|
// hipMemsetD16Async[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemsetD16Async:
|
|
break;
|
|
// hipMemsetD32[('hipDeviceptr_t', 'dest'), ('int', 'value'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemsetD32:
|
|
break;
|
|
// hipMemsetD32Async[('hipDeviceptr_t', 'dst'), ('int', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemsetD32Async:
|
|
break;
|
|
// hipMemsetD8[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemsetD8:
|
|
break;
|
|
// hipMemsetD8Async[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemsetD8Async:
|
|
break;
|
|
// hipMipmappedArrayCreate[('hipMipmappedArray_t*', 'pHandle'), ('HIP_ARRAY3D_DESCRIPTOR*', 'pMipmappedArrayDesc'), ('unsigned int', 'numMipmapLevels')]
|
|
case HIP_API_ID_hipMipmappedArrayCreate:
|
|
if (data->args.hipMipmappedArrayCreate.pHandle) data->args.hipMipmappedArrayCreate.pHandle__val = *(data->args.hipMipmappedArrayCreate.pHandle);
|
|
if (data->args.hipMipmappedArrayCreate.pMipmappedArrayDesc) data->args.hipMipmappedArrayCreate.pMipmappedArrayDesc__val = *(data->args.hipMipmappedArrayCreate.pMipmappedArrayDesc);
|
|
break;
|
|
// hipMipmappedArrayDestroy[('hipMipmappedArray_t', 'hMipmappedArray')]
|
|
case HIP_API_ID_hipMipmappedArrayDestroy:
|
|
break;
|
|
// hipMipmappedArrayGetLevel[('hipArray_t*', 'pLevelArray'), ('hipMipmappedArray_t', 'hMipMappedArray'), ('unsigned int', 'level')]
|
|
case HIP_API_ID_hipMipmappedArrayGetLevel:
|
|
if (data->args.hipMipmappedArrayGetLevel.pLevelArray) data->args.hipMipmappedArrayGetLevel.pLevelArray__val = *(data->args.hipMipmappedArrayGetLevel.pLevelArray);
|
|
break;
|
|
// hipModuleGetFunction[('hipFunction_t*', 'function'), ('hipModule_t', 'module'), ('const char*', 'kname')]
|
|
case HIP_API_ID_hipModuleGetFunction:
|
|
if (data->args.hipModuleGetFunction.function) data->args.hipModuleGetFunction.function__val = *(data->args.hipModuleGetFunction.function);
|
|
if (data->args.hipModuleGetFunction.kname) data->args.hipModuleGetFunction.kname__val = *(data->args.hipModuleGetFunction.kname);
|
|
break;
|
|
// hipModuleGetGlobal[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'bytes'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
|
|
case HIP_API_ID_hipModuleGetGlobal:
|
|
if (data->args.hipModuleGetGlobal.dptr) data->args.hipModuleGetGlobal.dptr__val = *(data->args.hipModuleGetGlobal.dptr);
|
|
if (data->args.hipModuleGetGlobal.bytes) data->args.hipModuleGetGlobal.bytes__val = *(data->args.hipModuleGetGlobal.bytes);
|
|
if (data->args.hipModuleGetGlobal.name) data->args.hipModuleGetGlobal.name__val = *(data->args.hipModuleGetGlobal.name);
|
|
break;
|
|
// hipModuleGetTexRef[('textureReference**', 'texRef'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
|
|
case HIP_API_ID_hipModuleGetTexRef:
|
|
if (data->args.hipModuleGetTexRef.texRef) data->args.hipModuleGetTexRef.texRef__val = *(data->args.hipModuleGetTexRef.texRef);
|
|
if (data->args.hipModuleGetTexRef.name) data->args.hipModuleGetTexRef.name__val = *(data->args.hipModuleGetTexRef.name);
|
|
break;
|
|
// hipModuleLaunchCooperativeKernel[('hipFunction_t', 'f'), ('unsigned int', 'gridDimX'), ('unsigned int', 'gridDimY'), ('unsigned int', 'gridDimZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('void**', 'kernelParams')]
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernel:
|
|
if (data->args.hipModuleLaunchCooperativeKernel.kernelParams) data->args.hipModuleLaunchCooperativeKernel.kernelParams__val = *(data->args.hipModuleLaunchCooperativeKernel.kernelParams);
|
|
break;
|
|
// hipModuleLaunchCooperativeKernelMultiDevice[('hipFunctionLaunchParams*', 'launchParamsList'), ('unsigned int', 'numDevices'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernelMultiDevice:
|
|
if (data->args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList) data->args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList__val = *(data->args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList);
|
|
break;
|
|
// hipModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'gridDimX'), ('unsigned int', 'gridDimY'), ('unsigned int', 'gridDimZ'), ('unsigned int', 'blockDimX'), ('unsigned int', 'blockDimY'), ('unsigned int', 'blockDimZ'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream'), ('void**', 'kernelParams'), ('void**', 'extra')]
|
|
case HIP_API_ID_hipModuleLaunchKernel:
|
|
if (data->args.hipModuleLaunchKernel.kernelParams) data->args.hipModuleLaunchKernel.kernelParams__val = *(data->args.hipModuleLaunchKernel.kernelParams);
|
|
if (data->args.hipModuleLaunchKernel.extra) data->args.hipModuleLaunchKernel.extra__val = *(data->args.hipModuleLaunchKernel.extra);
|
|
break;
|
|
// hipModuleLoad[('hipModule_t*', 'module'), ('const char*', 'fname')]
|
|
case HIP_API_ID_hipModuleLoad:
|
|
if (data->args.hipModuleLoad.module) data->args.hipModuleLoad.module__val = *(data->args.hipModuleLoad.module);
|
|
if (data->args.hipModuleLoad.fname) data->args.hipModuleLoad.fname__val = *(data->args.hipModuleLoad.fname);
|
|
break;
|
|
// hipModuleLoadData[('hipModule_t*', 'module'), ('const void*', 'image')]
|
|
case HIP_API_ID_hipModuleLoadData:
|
|
if (data->args.hipModuleLoadData.module) data->args.hipModuleLoadData.module__val = *(data->args.hipModuleLoadData.module);
|
|
break;
|
|
// hipModuleLoadDataEx[('hipModule_t*', 'module'), ('const void*', 'image'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionsValues')]
|
|
case HIP_API_ID_hipModuleLoadDataEx:
|
|
if (data->args.hipModuleLoadDataEx.module) data->args.hipModuleLoadDataEx.module__val = *(data->args.hipModuleLoadDataEx.module);
|
|
if (data->args.hipModuleLoadDataEx.options) data->args.hipModuleLoadDataEx.options__val = *(data->args.hipModuleLoadDataEx.options);
|
|
if (data->args.hipModuleLoadDataEx.optionsValues) data->args.hipModuleLoadDataEx.optionsValues__val = *(data->args.hipModuleLoadDataEx.optionsValues);
|
|
break;
|
|
// hipModuleOccupancyMaxActiveBlocksPerMultiprocessor[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk')]
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor:
|
|
if (data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks) data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks__val = *(data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks);
|
|
break;
|
|
// hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags:
|
|
if (data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks) data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks__val = *(data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks);
|
|
break;
|
|
// hipModuleOccupancyMaxPotentialBlockSize[('int*', 'gridSize'), ('int*', 'blockSize'), ('hipFunction_t', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit')]
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSize:
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSize.gridSize) data->args.hipModuleOccupancyMaxPotentialBlockSize.gridSize__val = *(data->args.hipModuleOccupancyMaxPotentialBlockSize.gridSize);
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSize) data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSize__val = *(data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSize);
|
|
break;
|
|
// hipModuleOccupancyMaxPotentialBlockSizeWithFlags[('int*', 'gridSize'), ('int*', 'blockSize'), ('hipFunction_t', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSizeWithFlags:
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize) data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize__val = *(data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize);
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize) data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize__val = *(data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize);
|
|
break;
|
|
// hipModuleUnload[('hipModule_t', 'module')]
|
|
case HIP_API_ID_hipModuleUnload:
|
|
break;
|
|
// hipOccupancyMaxActiveBlocksPerMultiprocessor[('int*', 'numBlocks'), ('const void*', 'f'), ('int', 'blockSize'), ('size_t', 'dynamicSMemSize')]
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor:
|
|
if (data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks) data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks__val = *(data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks);
|
|
break;
|
|
// hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('int*', 'numBlocks'), ('const void*', 'f'), ('int', 'blockSize'), ('size_t', 'dynamicSMemSize'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags:
|
|
if (data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks) data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks__val = *(data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks);
|
|
break;
|
|
// hipOccupancyMaxPotentialBlockSize[('int*', 'gridSize'), ('int*', 'blockSize'), ('const void*', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('int', 'blockSizeLimit')]
|
|
case HIP_API_ID_hipOccupancyMaxPotentialBlockSize:
|
|
if (data->args.hipOccupancyMaxPotentialBlockSize.gridSize) data->args.hipOccupancyMaxPotentialBlockSize.gridSize__val = *(data->args.hipOccupancyMaxPotentialBlockSize.gridSize);
|
|
if (data->args.hipOccupancyMaxPotentialBlockSize.blockSize) data->args.hipOccupancyMaxPotentialBlockSize.blockSize__val = *(data->args.hipOccupancyMaxPotentialBlockSize.blockSize);
|
|
break;
|
|
// hipPeekAtLastError[]
|
|
case HIP_API_ID_hipPeekAtLastError:
|
|
break;
|
|
// hipPointerGetAttribute[('void*', 'data'), ('hipPointer_attribute', 'attribute'), ('hipDeviceptr_t', 'ptr')]
|
|
case HIP_API_ID_hipPointerGetAttribute:
|
|
break;
|
|
// hipPointerGetAttributes[('hipPointerAttribute_t*', 'attributes'), ('const void*', 'ptr')]
|
|
case HIP_API_ID_hipPointerGetAttributes:
|
|
if (data->args.hipPointerGetAttributes.attributes) data->args.hipPointerGetAttributes.attributes__val = *(data->args.hipPointerGetAttributes.attributes);
|
|
break;
|
|
// hipPointerSetAttribute[('const void*', 'value'), ('hipPointer_attribute', 'attribute'), ('hipDeviceptr_t', 'ptr')]
|
|
case HIP_API_ID_hipPointerSetAttribute:
|
|
break;
|
|
// hipProfilerStart[]
|
|
case HIP_API_ID_hipProfilerStart:
|
|
break;
|
|
// hipProfilerStop[]
|
|
case HIP_API_ID_hipProfilerStop:
|
|
break;
|
|
// hipRuntimeGetVersion[('int*', 'runtimeVersion')]
|
|
case HIP_API_ID_hipRuntimeGetVersion:
|
|
if (data->args.hipRuntimeGetVersion.runtimeVersion) data->args.hipRuntimeGetVersion.runtimeVersion__val = *(data->args.hipRuntimeGetVersion.runtimeVersion);
|
|
break;
|
|
// hipSetDevice[('int', 'deviceId')]
|
|
case HIP_API_ID_hipSetDevice:
|
|
break;
|
|
// hipSetDeviceFlags[('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipSetDeviceFlags:
|
|
break;
|
|
// hipSetupArgument[('const void*', 'arg'), ('size_t', 'size'), ('size_t', 'offset')]
|
|
case HIP_API_ID_hipSetupArgument:
|
|
break;
|
|
// hipSignalExternalSemaphoresAsync[('const hipExternalSemaphore_t*', 'extSemArray'), ('const hipExternalSemaphoreSignalParams*', 'paramsArray'), ('unsigned int', 'numExtSems'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipSignalExternalSemaphoresAsync:
|
|
if (data->args.hipSignalExternalSemaphoresAsync.extSemArray) data->args.hipSignalExternalSemaphoresAsync.extSemArray__val = *(data->args.hipSignalExternalSemaphoresAsync.extSemArray);
|
|
if (data->args.hipSignalExternalSemaphoresAsync.paramsArray) data->args.hipSignalExternalSemaphoresAsync.paramsArray__val = *(data->args.hipSignalExternalSemaphoresAsync.paramsArray);
|
|
break;
|
|
// hipStreamAddCallback[('hipStream_t', 'stream'), ('hipStreamCallback_t', 'callback'), ('void*', 'userData'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamAddCallback:
|
|
break;
|
|
// hipStreamAttachMemAsync[('hipStream_t', 'stream'), ('void*', 'dev_ptr'), ('size_t', 'length'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamAttachMemAsync:
|
|
break;
|
|
// hipStreamBeginCapture[('hipStream_t', 'stream'), ('hipStreamCaptureMode', 'mode')]
|
|
case HIP_API_ID_hipStreamBeginCapture:
|
|
break;
|
|
// hipStreamCreate[('hipStream_t*', 'stream')]
|
|
case HIP_API_ID_hipStreamCreate:
|
|
if (data->args.hipStreamCreate.stream) data->args.hipStreamCreate.stream__val = *(data->args.hipStreamCreate.stream);
|
|
break;
|
|
// hipStreamCreateWithFlags[('hipStream_t*', 'stream'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamCreateWithFlags:
|
|
if (data->args.hipStreamCreateWithFlags.stream) data->args.hipStreamCreateWithFlags.stream__val = *(data->args.hipStreamCreateWithFlags.stream);
|
|
break;
|
|
// hipStreamCreateWithPriority[('hipStream_t*', 'stream'), ('unsigned int', 'flags'), ('int', 'priority')]
|
|
case HIP_API_ID_hipStreamCreateWithPriority:
|
|
if (data->args.hipStreamCreateWithPriority.stream) data->args.hipStreamCreateWithPriority.stream__val = *(data->args.hipStreamCreateWithPriority.stream);
|
|
break;
|
|
// hipStreamDestroy[('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipStreamDestroy:
|
|
break;
|
|
// hipStreamEndCapture[('hipStream_t', 'stream'), ('hipGraph_t*', 'pGraph')]
|
|
case HIP_API_ID_hipStreamEndCapture:
|
|
if (data->args.hipStreamEndCapture.pGraph) data->args.hipStreamEndCapture.pGraph__val = *(data->args.hipStreamEndCapture.pGraph);
|
|
break;
|
|
// hipStreamGetCaptureInfo[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'pCaptureStatus'), ('unsigned long long*', 'pId')]
|
|
case HIP_API_ID_hipStreamGetCaptureInfo:
|
|
if (data->args.hipStreamGetCaptureInfo.pCaptureStatus) data->args.hipStreamGetCaptureInfo.pCaptureStatus__val = *(data->args.hipStreamGetCaptureInfo.pCaptureStatus);
|
|
if (data->args.hipStreamGetCaptureInfo.pId) data->args.hipStreamGetCaptureInfo.pId__val = *(data->args.hipStreamGetCaptureInfo.pId);
|
|
break;
|
|
// hipStreamGetCaptureInfo_v2[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'captureStatus_out'), ('unsigned long long*', 'id_out'), ('hipGraph_t*', 'graph_out'), ('const hipGraphNode_t**', 'dependencies_out'), ('size_t*', 'numDependencies_out')]
|
|
case HIP_API_ID_hipStreamGetCaptureInfo_v2:
|
|
if (data->args.hipStreamGetCaptureInfo_v2.captureStatus_out) data->args.hipStreamGetCaptureInfo_v2.captureStatus_out__val = *(data->args.hipStreamGetCaptureInfo_v2.captureStatus_out);
|
|
if (data->args.hipStreamGetCaptureInfo_v2.id_out) data->args.hipStreamGetCaptureInfo_v2.id_out__val = *(data->args.hipStreamGetCaptureInfo_v2.id_out);
|
|
if (data->args.hipStreamGetCaptureInfo_v2.graph_out) data->args.hipStreamGetCaptureInfo_v2.graph_out__val = *(data->args.hipStreamGetCaptureInfo_v2.graph_out);
|
|
if (data->args.hipStreamGetCaptureInfo_v2.dependencies_out) data->args.hipStreamGetCaptureInfo_v2.dependencies_out__val = *(data->args.hipStreamGetCaptureInfo_v2.dependencies_out);
|
|
if (data->args.hipStreamGetCaptureInfo_v2.numDependencies_out) data->args.hipStreamGetCaptureInfo_v2.numDependencies_out__val = *(data->args.hipStreamGetCaptureInfo_v2.numDependencies_out);
|
|
break;
|
|
// hipStreamGetFlags[('hipStream_t', 'stream'), ('unsigned int*', 'flags')]
|
|
case HIP_API_ID_hipStreamGetFlags:
|
|
if (data->args.hipStreamGetFlags.flags) data->args.hipStreamGetFlags.flags__val = *(data->args.hipStreamGetFlags.flags);
|
|
break;
|
|
// hipStreamGetPriority[('hipStream_t', 'stream'), ('int*', 'priority')]
|
|
case HIP_API_ID_hipStreamGetPriority:
|
|
if (data->args.hipStreamGetPriority.priority) data->args.hipStreamGetPriority.priority__val = *(data->args.hipStreamGetPriority.priority);
|
|
break;
|
|
// hipStreamIsCapturing[('hipStream_t', 'stream'), ('hipStreamCaptureStatus*', 'pCaptureStatus')]
|
|
case HIP_API_ID_hipStreamIsCapturing:
|
|
if (data->args.hipStreamIsCapturing.pCaptureStatus) data->args.hipStreamIsCapturing.pCaptureStatus__val = *(data->args.hipStreamIsCapturing.pCaptureStatus);
|
|
break;
|
|
// hipStreamQuery[('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipStreamQuery:
|
|
break;
|
|
// hipStreamSynchronize[('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipStreamSynchronize:
|
|
break;
|
|
// hipStreamUpdateCaptureDependencies[('hipStream_t', 'stream'), ('hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamUpdateCaptureDependencies:
|
|
if (data->args.hipStreamUpdateCaptureDependencies.dependencies) data->args.hipStreamUpdateCaptureDependencies.dependencies__val = *(data->args.hipStreamUpdateCaptureDependencies.dependencies);
|
|
break;
|
|
// hipStreamWaitEvent[('hipStream_t', 'stream'), ('hipEvent_t', 'event'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamWaitEvent:
|
|
break;
|
|
// hipStreamWaitValue32[('hipStream_t', 'stream'), ('void*', 'ptr'), ('unsigned int', 'value'), ('unsigned int', 'flags'), ('unsigned int', 'mask')]
|
|
case HIP_API_ID_hipStreamWaitValue32:
|
|
break;
|
|
// hipStreamWaitValue64[('hipStream_t', 'stream'), ('void*', 'ptr'), ('uint64_t', 'value'), ('unsigned int', 'flags'), ('uint64_t', 'mask')]
|
|
case HIP_API_ID_hipStreamWaitValue64:
|
|
break;
|
|
// hipStreamWriteValue32[('hipStream_t', 'stream'), ('void*', 'ptr'), ('unsigned int', 'value'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamWriteValue32:
|
|
break;
|
|
// hipStreamWriteValue64[('hipStream_t', 'stream'), ('void*', 'ptr'), ('uint64_t', 'value'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamWriteValue64:
|
|
break;
|
|
// hipTexRefGetAddress[('hipDeviceptr_t*', 'dev_ptr'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetAddress:
|
|
if (data->args.hipTexRefGetAddress.dev_ptr) data->args.hipTexRefGetAddress.dev_ptr__val = *(data->args.hipTexRefGetAddress.dev_ptr);
|
|
if (data->args.hipTexRefGetAddress.texRef) data->args.hipTexRefGetAddress.texRef__val = *(data->args.hipTexRefGetAddress.texRef);
|
|
break;
|
|
// hipTexRefGetFlags[('unsigned int*', 'pFlags'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetFlags:
|
|
if (data->args.hipTexRefGetFlags.pFlags) data->args.hipTexRefGetFlags.pFlags__val = *(data->args.hipTexRefGetFlags.pFlags);
|
|
if (data->args.hipTexRefGetFlags.texRef) data->args.hipTexRefGetFlags.texRef__val = *(data->args.hipTexRefGetFlags.texRef);
|
|
break;
|
|
// hipTexRefGetFormat[('hipArray_Format*', 'pFormat'), ('int*', 'pNumChannels'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetFormat:
|
|
if (data->args.hipTexRefGetFormat.pFormat) data->args.hipTexRefGetFormat.pFormat__val = *(data->args.hipTexRefGetFormat.pFormat);
|
|
if (data->args.hipTexRefGetFormat.pNumChannels) data->args.hipTexRefGetFormat.pNumChannels__val = *(data->args.hipTexRefGetFormat.pNumChannels);
|
|
if (data->args.hipTexRefGetFormat.texRef) data->args.hipTexRefGetFormat.texRef__val = *(data->args.hipTexRefGetFormat.texRef);
|
|
break;
|
|
// hipTexRefGetMaxAnisotropy[('int*', 'pmaxAnsio'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetMaxAnisotropy:
|
|
if (data->args.hipTexRefGetMaxAnisotropy.pmaxAnsio) data->args.hipTexRefGetMaxAnisotropy.pmaxAnsio__val = *(data->args.hipTexRefGetMaxAnisotropy.pmaxAnsio);
|
|
if (data->args.hipTexRefGetMaxAnisotropy.texRef) data->args.hipTexRefGetMaxAnisotropy.texRef__val = *(data->args.hipTexRefGetMaxAnisotropy.texRef);
|
|
break;
|
|
// hipTexRefGetMipMappedArray[('hipMipmappedArray_t*', 'pArray'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetMipMappedArray:
|
|
if (data->args.hipTexRefGetMipMappedArray.pArray) data->args.hipTexRefGetMipMappedArray.pArray__val = *(data->args.hipTexRefGetMipMappedArray.pArray);
|
|
if (data->args.hipTexRefGetMipMappedArray.texRef) data->args.hipTexRefGetMipMappedArray.texRef__val = *(data->args.hipTexRefGetMipMappedArray.texRef);
|
|
break;
|
|
// hipTexRefGetMipmapLevelBias[('float*', 'pbias'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelBias:
|
|
if (data->args.hipTexRefGetMipmapLevelBias.pbias) data->args.hipTexRefGetMipmapLevelBias.pbias__val = *(data->args.hipTexRefGetMipmapLevelBias.pbias);
|
|
if (data->args.hipTexRefGetMipmapLevelBias.texRef) data->args.hipTexRefGetMipmapLevelBias.texRef__val = *(data->args.hipTexRefGetMipmapLevelBias.texRef);
|
|
break;
|
|
// hipTexRefGetMipmapLevelClamp[('float*', 'pminMipmapLevelClamp'), ('float*', 'pmaxMipmapLevelClamp'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelClamp:
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp) data->args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp__val = *(data->args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp);
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp) data->args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp__val = *(data->args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp);
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.texRef) data->args.hipTexRefGetMipmapLevelClamp.texRef__val = *(data->args.hipTexRefGetMipmapLevelClamp.texRef);
|
|
break;
|
|
// hipTexRefSetAddress[('size_t*', 'ByteOffset'), ('textureReference*', 'texRef'), ('hipDeviceptr_t', 'dptr'), ('size_t', 'bytes')]
|
|
case HIP_API_ID_hipTexRefSetAddress:
|
|
if (data->args.hipTexRefSetAddress.ByteOffset) data->args.hipTexRefSetAddress.ByteOffset__val = *(data->args.hipTexRefSetAddress.ByteOffset);
|
|
if (data->args.hipTexRefSetAddress.texRef) data->args.hipTexRefSetAddress.texRef__val = *(data->args.hipTexRefSetAddress.texRef);
|
|
break;
|
|
// hipTexRefSetAddress2D[('textureReference*', 'texRef'), ('const HIP_ARRAY_DESCRIPTOR*', 'desc'), ('hipDeviceptr_t', 'dptr'), ('size_t', 'Pitch')]
|
|
case HIP_API_ID_hipTexRefSetAddress2D:
|
|
if (data->args.hipTexRefSetAddress2D.texRef) data->args.hipTexRefSetAddress2D.texRef__val = *(data->args.hipTexRefSetAddress2D.texRef);
|
|
if (data->args.hipTexRefSetAddress2D.desc) data->args.hipTexRefSetAddress2D.desc__val = *(data->args.hipTexRefSetAddress2D.desc);
|
|
break;
|
|
// hipTexRefSetArray[('textureReference*', 'tex'), ('hipArray_const_t', 'array'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipTexRefSetArray:
|
|
if (data->args.hipTexRefSetArray.tex) data->args.hipTexRefSetArray.tex__val = *(data->args.hipTexRefSetArray.tex);
|
|
break;
|
|
// hipTexRefSetBorderColor[('textureReference*', 'texRef'), ('float*', 'pBorderColor')]
|
|
case HIP_API_ID_hipTexRefSetBorderColor:
|
|
if (data->args.hipTexRefSetBorderColor.texRef) data->args.hipTexRefSetBorderColor.texRef__val = *(data->args.hipTexRefSetBorderColor.texRef);
|
|
if (data->args.hipTexRefSetBorderColor.pBorderColor) data->args.hipTexRefSetBorderColor.pBorderColor__val = *(data->args.hipTexRefSetBorderColor.pBorderColor);
|
|
break;
|
|
// hipTexRefSetFlags[('textureReference*', 'texRef'), ('unsigned int', 'Flags')]
|
|
case HIP_API_ID_hipTexRefSetFlags:
|
|
if (data->args.hipTexRefSetFlags.texRef) data->args.hipTexRefSetFlags.texRef__val = *(data->args.hipTexRefSetFlags.texRef);
|
|
break;
|
|
// hipTexRefSetFormat[('textureReference*', 'texRef'), ('hipArray_Format', 'fmt'), ('int', 'NumPackedComponents')]
|
|
case HIP_API_ID_hipTexRefSetFormat:
|
|
if (data->args.hipTexRefSetFormat.texRef) data->args.hipTexRefSetFormat.texRef__val = *(data->args.hipTexRefSetFormat.texRef);
|
|
break;
|
|
// hipTexRefSetMaxAnisotropy[('textureReference*', 'texRef'), ('unsigned int', 'maxAniso')]
|
|
case HIP_API_ID_hipTexRefSetMaxAnisotropy:
|
|
if (data->args.hipTexRefSetMaxAnisotropy.texRef) data->args.hipTexRefSetMaxAnisotropy.texRef__val = *(data->args.hipTexRefSetMaxAnisotropy.texRef);
|
|
break;
|
|
// hipTexRefSetMipmapLevelBias[('textureReference*', 'texRef'), ('float', 'bias')]
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelBias:
|
|
if (data->args.hipTexRefSetMipmapLevelBias.texRef) data->args.hipTexRefSetMipmapLevelBias.texRef__val = *(data->args.hipTexRefSetMipmapLevelBias.texRef);
|
|
break;
|
|
// hipTexRefSetMipmapLevelClamp[('textureReference*', 'texRef'), ('float', 'minMipMapLevelClamp'), ('float', 'maxMipMapLevelClamp')]
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelClamp:
|
|
if (data->args.hipTexRefSetMipmapLevelClamp.texRef) data->args.hipTexRefSetMipmapLevelClamp.texRef__val = *(data->args.hipTexRefSetMipmapLevelClamp.texRef);
|
|
break;
|
|
// hipTexRefSetMipmappedArray[('textureReference*', 'texRef'), ('hipMipmappedArray*', 'mipmappedArray'), ('unsigned int', 'Flags')]
|
|
case HIP_API_ID_hipTexRefSetMipmappedArray:
|
|
if (data->args.hipTexRefSetMipmappedArray.texRef) data->args.hipTexRefSetMipmappedArray.texRef__val = *(data->args.hipTexRefSetMipmappedArray.texRef);
|
|
if (data->args.hipTexRefSetMipmappedArray.mipmappedArray) data->args.hipTexRefSetMipmappedArray.mipmappedArray__val = *(data->args.hipTexRefSetMipmappedArray.mipmappedArray);
|
|
break;
|
|
// hipThreadExchangeStreamCaptureMode[('hipStreamCaptureMode*', 'mode')]
|
|
case HIP_API_ID_hipThreadExchangeStreamCaptureMode:
|
|
if (data->args.hipThreadExchangeStreamCaptureMode.mode) data->args.hipThreadExchangeStreamCaptureMode.mode__val = *(data->args.hipThreadExchangeStreamCaptureMode.mode);
|
|
break;
|
|
// hipUserObjectCreate[('hipUserObject_t*', 'object_out'), ('void*', 'ptr'), ('hipHostFn_t', 'destroy'), ('unsigned int', 'initialRefcount'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipUserObjectCreate:
|
|
if (data->args.hipUserObjectCreate.object_out) data->args.hipUserObjectCreate.object_out__val = *(data->args.hipUserObjectCreate.object_out);
|
|
break;
|
|
// hipUserObjectRelease[('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
case HIP_API_ID_hipUserObjectRelease:
|
|
break;
|
|
// hipUserObjectRetain[('hipUserObject_t', 'object'), ('unsigned int', 'count')]
|
|
case HIP_API_ID_hipUserObjectRetain:
|
|
break;
|
|
// hipWaitExternalSemaphoresAsync[('const hipExternalSemaphore_t*', 'extSemArray'), ('const hipExternalSemaphoreWaitParams*', 'paramsArray'), ('unsigned int', 'numExtSems'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipWaitExternalSemaphoresAsync:
|
|
if (data->args.hipWaitExternalSemaphoresAsync.extSemArray) data->args.hipWaitExternalSemaphoresAsync.extSemArray__val = *(data->args.hipWaitExternalSemaphoresAsync.extSemArray);
|
|
if (data->args.hipWaitExternalSemaphoresAsync.paramsArray) data->args.hipWaitExternalSemaphoresAsync.paramsArray__val = *(data->args.hipWaitExternalSemaphoresAsync.paramsArray);
|
|
break;
|
|
default: break;
|
|
};
|
|
}
|
|
|
|
#include <sstream>
|
|
#include <string>
|
|
// HIP API string method, method name and parameters
|
|
static inline const char* hipApiString(hip_api_id_t id, const hip_api_data_t* data) {
|
|
std::ostringstream oss;
|
|
switch (id) {
|
|
case HIP_API_ID___hipPopCallConfiguration:
|
|
oss << "__hipPopCallConfiguration(";
|
|
if (data->args.__hipPopCallConfiguration.gridDim == NULL) oss << "gridDim=NULL";
|
|
else { oss << "gridDim="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPopCallConfiguration.gridDim__val); }
|
|
if (data->args.__hipPopCallConfiguration.blockDim == NULL) oss << ", blockDim=NULL";
|
|
else { oss << ", blockDim="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPopCallConfiguration.blockDim__val); }
|
|
if (data->args.__hipPopCallConfiguration.sharedMem == NULL) oss << ", sharedMem=NULL";
|
|
else { oss << ", sharedMem="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPopCallConfiguration.sharedMem__val); }
|
|
if (data->args.__hipPopCallConfiguration.stream == NULL) oss << ", stream=NULL";
|
|
else { oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPopCallConfiguration.stream__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID___hipPushCallConfiguration:
|
|
oss << "__hipPushCallConfiguration(";
|
|
oss << "gridDim="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPushCallConfiguration.gridDim);
|
|
oss << ", blockDim="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPushCallConfiguration.blockDim);
|
|
oss << ", sharedMem="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPushCallConfiguration.sharedMem);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.__hipPushCallConfiguration.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipArray3DCreate:
|
|
oss << "hipArray3DCreate(";
|
|
if (data->args.hipArray3DCreate.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipArray3DCreate.array__val); }
|
|
if (data->args.hipArray3DCreate.pAllocateArray == NULL) oss << ", pAllocateArray=NULL";
|
|
else { oss << ", pAllocateArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArray3DCreate.pAllocateArray__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipArrayCreate:
|
|
oss << "hipArrayCreate(";
|
|
if (data->args.hipArrayCreate.pHandle == NULL) oss << "pHandle=NULL";
|
|
else { oss << "pHandle="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipArrayCreate.pHandle__val); }
|
|
if (data->args.hipArrayCreate.pAllocateArray == NULL) oss << ", pAllocateArray=NULL";
|
|
else { oss << ", pAllocateArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayCreate.pAllocateArray__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipArrayDestroy:
|
|
oss << "hipArrayDestroy(";
|
|
if (data->args.hipArrayDestroy.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayDestroy.array__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipChooseDevice:
|
|
oss << "hipChooseDevice(";
|
|
if (data->args.hipChooseDevice.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDevice.device__val); }
|
|
if (data->args.hipChooseDevice.prop == NULL) oss << ", prop=NULL";
|
|
else { oss << ", prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDevice.prop__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipConfigureCall:
|
|
oss << "hipConfigureCall(";
|
|
oss << "gridDim="; roctracer::hip_support::detail::operator<<(oss, data->args.hipConfigureCall.gridDim);
|
|
oss << ", blockDim="; roctracer::hip_support::detail::operator<<(oss, data->args.hipConfigureCall.blockDim);
|
|
oss << ", sharedMem="; roctracer::hip_support::detail::operator<<(oss, data->args.hipConfigureCall.sharedMem);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipConfigureCall.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCreateSurfaceObject:
|
|
oss << "hipCreateSurfaceObject(";
|
|
if (data->args.hipCreateSurfaceObject.pSurfObject == NULL) oss << "pSurfObject=NULL";
|
|
else { oss << "pSurfObject="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCreateSurfaceObject.pSurfObject__val); }
|
|
if (data->args.hipCreateSurfaceObject.pResDesc == NULL) oss << ", pResDesc=NULL";
|
|
else { oss << ", pResDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCreateSurfaceObject.pResDesc__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxCreate:
|
|
oss << "hipCtxCreate(";
|
|
if (data->args.hipCtxCreate.ctx == NULL) oss << "ctx=NULL";
|
|
else { oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxCreate.ctx__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxCreate.flags);
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxCreate.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxDestroy:
|
|
oss << "hipCtxDestroy(";
|
|
oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxDestroy.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxDisablePeerAccess:
|
|
oss << "hipCtxDisablePeerAccess(";
|
|
oss << "peerCtx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxDisablePeerAccess.peerCtx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxEnablePeerAccess:
|
|
oss << "hipCtxEnablePeerAccess(";
|
|
oss << "peerCtx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxEnablePeerAccess.peerCtx);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxEnablePeerAccess.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetApiVersion:
|
|
oss << "hipCtxGetApiVersion(";
|
|
oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetApiVersion.ctx);
|
|
if (data->args.hipCtxGetApiVersion.apiVersion == NULL) oss << ", apiVersion=NULL";
|
|
else { oss << ", apiVersion="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetApiVersion.apiVersion__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetCacheConfig:
|
|
oss << "hipCtxGetCacheConfig(";
|
|
if (data->args.hipCtxGetCacheConfig.cacheConfig == NULL) oss << "cacheConfig=NULL";
|
|
else { oss << "cacheConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetCacheConfig.cacheConfig__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetCurrent:
|
|
oss << "hipCtxGetCurrent(";
|
|
if (data->args.hipCtxGetCurrent.ctx == NULL) oss << "ctx=NULL";
|
|
else { oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetCurrent.ctx__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetDevice:
|
|
oss << "hipCtxGetDevice(";
|
|
if (data->args.hipCtxGetDevice.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetDevice.device__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetFlags:
|
|
oss << "hipCtxGetFlags(";
|
|
if (data->args.hipCtxGetFlags.flags == NULL) oss << "flags=NULL";
|
|
else { oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetFlags.flags__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxGetSharedMemConfig:
|
|
oss << "hipCtxGetSharedMemConfig(";
|
|
if (data->args.hipCtxGetSharedMemConfig.pConfig == NULL) oss << "pConfig=NULL";
|
|
else { oss << "pConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxGetSharedMemConfig.pConfig__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxPopCurrent:
|
|
oss << "hipCtxPopCurrent(";
|
|
if (data->args.hipCtxPopCurrent.ctx == NULL) oss << "ctx=NULL";
|
|
else { oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxPopCurrent.ctx__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxPushCurrent:
|
|
oss << "hipCtxPushCurrent(";
|
|
oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxPushCurrent.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxSetCacheConfig:
|
|
oss << "hipCtxSetCacheConfig(";
|
|
oss << "cacheConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxSetCacheConfig.cacheConfig);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxSetCurrent:
|
|
oss << "hipCtxSetCurrent(";
|
|
oss << "ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxSetCurrent.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxSetSharedMemConfig:
|
|
oss << "hipCtxSetSharedMemConfig(";
|
|
oss << "config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipCtxSetSharedMemConfig.config);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipCtxSynchronize:
|
|
oss << "hipCtxSynchronize(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDestroyExternalMemory:
|
|
oss << "hipDestroyExternalMemory(";
|
|
oss << "extMem="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDestroyExternalMemory.extMem);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDestroyExternalSemaphore:
|
|
oss << "hipDestroyExternalSemaphore(";
|
|
oss << "extSem="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDestroyExternalSemaphore.extSem);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDestroySurfaceObject:
|
|
oss << "hipDestroySurfaceObject(";
|
|
oss << "surfaceObject="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDestroySurfaceObject.surfaceObject);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceCanAccessPeer:
|
|
oss << "hipDeviceCanAccessPeer(";
|
|
if (data->args.hipDeviceCanAccessPeer.canAccessPeer == NULL) oss << "canAccessPeer=NULL";
|
|
else { oss << "canAccessPeer="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceCanAccessPeer.canAccessPeer__val); }
|
|
oss << ", deviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceCanAccessPeer.deviceId);
|
|
oss << ", peerDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceCanAccessPeer.peerDeviceId);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceComputeCapability:
|
|
oss << "hipDeviceComputeCapability(";
|
|
if (data->args.hipDeviceComputeCapability.major == NULL) oss << "major=NULL";
|
|
else { oss << "major="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceComputeCapability.major__val); }
|
|
if (data->args.hipDeviceComputeCapability.minor == NULL) oss << ", minor=NULL";
|
|
else { oss << ", minor="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceComputeCapability.minor__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceComputeCapability.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceDisablePeerAccess:
|
|
oss << "hipDeviceDisablePeerAccess(";
|
|
oss << "peerDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceDisablePeerAccess.peerDeviceId);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceEnablePeerAccess:
|
|
oss << "hipDeviceEnablePeerAccess(";
|
|
oss << "peerDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceEnablePeerAccess.peerDeviceId);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceEnablePeerAccess.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGet:
|
|
oss << "hipDeviceGet(";
|
|
if (data->args.hipDeviceGet.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGet.device__val); }
|
|
oss << ", ordinal="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGet.ordinal);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetAttribute:
|
|
oss << "hipDeviceGetAttribute(";
|
|
if (data->args.hipDeviceGetAttribute.pi == NULL) oss << "pi=NULL";
|
|
else { oss << "pi="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetAttribute.pi__val); }
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetAttribute.attr);
|
|
oss << ", deviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetAttribute.deviceId);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetByPCIBusId:
|
|
oss << "hipDeviceGetByPCIBusId(";
|
|
if (data->args.hipDeviceGetByPCIBusId.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetByPCIBusId.device__val); }
|
|
if (data->args.hipDeviceGetByPCIBusId.pciBusId == NULL) oss << ", pciBusId=NULL";
|
|
else { oss << ", pciBusId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetByPCIBusId.pciBusId__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetCacheConfig:
|
|
oss << "hipDeviceGetCacheConfig(";
|
|
if (data->args.hipDeviceGetCacheConfig.cacheConfig == NULL) oss << "cacheConfig=NULL";
|
|
else { oss << "cacheConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetCacheConfig.cacheConfig__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetDefaultMemPool:
|
|
oss << "hipDeviceGetDefaultMemPool(";
|
|
if (data->args.hipDeviceGetDefaultMemPool.mem_pool == NULL) oss << "mem_pool=NULL";
|
|
else { oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetDefaultMemPool.mem_pool__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetDefaultMemPool.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetGraphMemAttribute:
|
|
oss << "hipDeviceGetGraphMemAttribute(";
|
|
oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetGraphMemAttribute.device);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetGraphMemAttribute.attr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetGraphMemAttribute.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetLimit:
|
|
oss << "hipDeviceGetLimit(";
|
|
if (data->args.hipDeviceGetLimit.pValue == NULL) oss << "pValue=NULL";
|
|
else { oss << "pValue="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetLimit.pValue__val); }
|
|
oss << ", limit="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetLimit.limit);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetMemPool:
|
|
oss << "hipDeviceGetMemPool(";
|
|
if (data->args.hipDeviceGetMemPool.mem_pool == NULL) oss << "mem_pool=NULL";
|
|
else { oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetMemPool.mem_pool__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetMemPool.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetName:
|
|
oss << "hipDeviceGetName(";
|
|
if (data->args.hipDeviceGetName.name == NULL) oss << "name=NULL";
|
|
else { oss << "name="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetName.name__val); }
|
|
oss << ", len="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetName.len);
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetName.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetP2PAttribute:
|
|
oss << "hipDeviceGetP2PAttribute(";
|
|
if (data->args.hipDeviceGetP2PAttribute.value == NULL) oss << "value=NULL";
|
|
else { oss << "value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetP2PAttribute.value__val); }
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetP2PAttribute.attr);
|
|
oss << ", srcDevice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetP2PAttribute.srcDevice);
|
|
oss << ", dstDevice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetP2PAttribute.dstDevice);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetPCIBusId:
|
|
oss << "hipDeviceGetPCIBusId(";
|
|
if (data->args.hipDeviceGetPCIBusId.pciBusId == NULL) oss << "pciBusId=NULL";
|
|
else { oss << "pciBusId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetPCIBusId.pciBusId__val); }
|
|
oss << ", len="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetPCIBusId.len);
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetPCIBusId.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetSharedMemConfig:
|
|
oss << "hipDeviceGetSharedMemConfig(";
|
|
if (data->args.hipDeviceGetSharedMemConfig.pConfig == NULL) oss << "pConfig=NULL";
|
|
else { oss << "pConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetSharedMemConfig.pConfig__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetStreamPriorityRange:
|
|
oss << "hipDeviceGetStreamPriorityRange(";
|
|
if (data->args.hipDeviceGetStreamPriorityRange.leastPriority == NULL) oss << "leastPriority=NULL";
|
|
else { oss << "leastPriority="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetStreamPriorityRange.leastPriority__val); }
|
|
if (data->args.hipDeviceGetStreamPriorityRange.greatestPriority == NULL) oss << ", greatestPriority=NULL";
|
|
else { oss << ", greatestPriority="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetStreamPriorityRange.greatestPriority__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGetUuid:
|
|
oss << "hipDeviceGetUuid(";
|
|
if (data->args.hipDeviceGetUuid.uuid == NULL) oss << "uuid=NULL";
|
|
else { oss << "uuid="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetUuid.uuid__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGetUuid.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceGraphMemTrim:
|
|
oss << "hipDeviceGraphMemTrim(";
|
|
oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceGraphMemTrim.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDevicePrimaryCtxGetState:
|
|
oss << "hipDevicePrimaryCtxGetState(";
|
|
oss << "dev="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxGetState.dev);
|
|
if (data->args.hipDevicePrimaryCtxGetState.flags == NULL) oss << ", flags=NULL";
|
|
else { oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxGetState.flags__val); }
|
|
if (data->args.hipDevicePrimaryCtxGetState.active == NULL) oss << ", active=NULL";
|
|
else { oss << ", active="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxGetState.active__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDevicePrimaryCtxRelease:
|
|
oss << "hipDevicePrimaryCtxRelease(";
|
|
oss << "dev="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxRelease.dev);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDevicePrimaryCtxReset:
|
|
oss << "hipDevicePrimaryCtxReset(";
|
|
oss << "dev="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxReset.dev);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDevicePrimaryCtxRetain:
|
|
oss << "hipDevicePrimaryCtxRetain(";
|
|
if (data->args.hipDevicePrimaryCtxRetain.pctx == NULL) oss << "pctx=NULL";
|
|
else { oss << "pctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxRetain.pctx__val); }
|
|
oss << ", dev="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxRetain.dev);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDevicePrimaryCtxSetFlags:
|
|
oss << "hipDevicePrimaryCtxSetFlags(";
|
|
oss << "dev="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxSetFlags.dev);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDevicePrimaryCtxSetFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceReset:
|
|
oss << "hipDeviceReset(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSetCacheConfig:
|
|
oss << "hipDeviceSetCacheConfig(";
|
|
oss << "cacheConfig="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetCacheConfig.cacheConfig);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSetGraphMemAttribute:
|
|
oss << "hipDeviceSetGraphMemAttribute(";
|
|
oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetGraphMemAttribute.device);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetGraphMemAttribute.attr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetGraphMemAttribute.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSetLimit:
|
|
oss << "hipDeviceSetLimit(";
|
|
oss << "limit="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetLimit.limit);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetLimit.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSetMemPool:
|
|
oss << "hipDeviceSetMemPool(";
|
|
oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetMemPool.device);
|
|
oss << ", mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetMemPool.mem_pool);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSetSharedMemConfig:
|
|
oss << "hipDeviceSetSharedMemConfig(";
|
|
oss << "config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceSetSharedMemConfig.config);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceSynchronize:
|
|
oss << "hipDeviceSynchronize(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDeviceTotalMem:
|
|
oss << "hipDeviceTotalMem(";
|
|
if (data->args.hipDeviceTotalMem.bytes == NULL) oss << "bytes=NULL";
|
|
else { oss << "bytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceTotalMem.bytes__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDeviceTotalMem.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDriverGetVersion:
|
|
oss << "hipDriverGetVersion(";
|
|
if (data->args.hipDriverGetVersion.driverVersion == NULL) oss << "driverVersion=NULL";
|
|
else { oss << "driverVersion="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDriverGetVersion.driverVersion__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvMemcpy2DUnaligned:
|
|
oss << "hipDrvMemcpy2DUnaligned(";
|
|
if (data->args.hipDrvMemcpy2DUnaligned.pCopy == NULL) oss << "pCopy=NULL";
|
|
else { oss << "pCopy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvMemcpy2DUnaligned.pCopy__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvMemcpy3D:
|
|
oss << "hipDrvMemcpy3D(";
|
|
if (data->args.hipDrvMemcpy3D.pCopy == NULL) oss << "pCopy=NULL";
|
|
else { oss << "pCopy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvMemcpy3D.pCopy__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvMemcpy3DAsync:
|
|
oss << "hipDrvMemcpy3DAsync(";
|
|
if (data->args.hipDrvMemcpy3DAsync.pCopy == NULL) oss << "pCopy=NULL";
|
|
else { oss << "pCopy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvMemcpy3DAsync.pCopy__val); }
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvMemcpy3DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvPointerGetAttributes:
|
|
oss << "hipDrvPointerGetAttributes(";
|
|
oss << "numAttributes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvPointerGetAttributes.numAttributes);
|
|
if (data->args.hipDrvPointerGetAttributes.attributes == NULL) oss << ", attributes=NULL";
|
|
else { oss << ", attributes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvPointerGetAttributes.attributes__val); }
|
|
if (data->args.hipDrvPointerGetAttributes.data == NULL) oss << ", data=NULL";
|
|
else { oss << ", data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvPointerGetAttributes.data__val); }
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvPointerGetAttributes.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventCreate:
|
|
oss << "hipEventCreate(";
|
|
if (data->args.hipEventCreate.event == NULL) oss << "event=NULL";
|
|
else { oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventCreate.event__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventCreateWithFlags:
|
|
oss << "hipEventCreateWithFlags(";
|
|
if (data->args.hipEventCreateWithFlags.event == NULL) oss << "event=NULL";
|
|
else { oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventCreateWithFlags.event__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventCreateWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventDestroy:
|
|
oss << "hipEventDestroy(";
|
|
oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventDestroy.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventElapsedTime:
|
|
oss << "hipEventElapsedTime(";
|
|
if (data->args.hipEventElapsedTime.ms == NULL) oss << "ms=NULL";
|
|
else { oss << "ms="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventElapsedTime.ms__val); }
|
|
oss << ", start="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventElapsedTime.start);
|
|
oss << ", stop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventElapsedTime.stop);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventQuery:
|
|
oss << "hipEventQuery(";
|
|
oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventQuery.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventRecord:
|
|
oss << "hipEventRecord(";
|
|
oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventRecord.event);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventRecord.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipEventSynchronize:
|
|
oss << "hipEventSynchronize(";
|
|
oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventSynchronize.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtGetLinkTypeAndHopCount:
|
|
oss << "hipExtGetLinkTypeAndHopCount(";
|
|
oss << "device1="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtGetLinkTypeAndHopCount.device1);
|
|
oss << ", device2="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtGetLinkTypeAndHopCount.device2);
|
|
if (data->args.hipExtGetLinkTypeAndHopCount.linktype == NULL) oss << ", linktype=NULL";
|
|
else { oss << ", linktype="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtGetLinkTypeAndHopCount.linktype__val); }
|
|
if (data->args.hipExtGetLinkTypeAndHopCount.hopcount == NULL) oss << ", hopcount=NULL";
|
|
else { oss << ", hopcount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtGetLinkTypeAndHopCount.hopcount__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtLaunchKernel:
|
|
oss << "hipExtLaunchKernel(";
|
|
oss << "function_address="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.function_address);
|
|
oss << ", numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.numBlocks);
|
|
oss << ", dimBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.dimBlocks);
|
|
if (data->args.hipExtLaunchKernel.args == NULL) oss << ", args=NULL";
|
|
else { oss << ", args="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.args__val); }
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.sharedMemBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.stream);
|
|
oss << ", startEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.startEvent);
|
|
oss << ", stopEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.stopEvent);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchKernel.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtLaunchMultiKernelMultiDevice:
|
|
oss << "hipExtLaunchMultiKernelMultiDevice(";
|
|
if (data->args.hipExtLaunchMultiKernelMultiDevice.launchParamsList == NULL) oss << "launchParamsList=NULL";
|
|
else { oss << "launchParamsList="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchMultiKernelMultiDevice.launchParamsList__val); }
|
|
oss << ", numDevices="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchMultiKernelMultiDevice.numDevices);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtLaunchMultiKernelMultiDevice.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtMallocWithFlags:
|
|
oss << "hipExtMallocWithFlags(";
|
|
if (data->args.hipExtMallocWithFlags.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtMallocWithFlags.ptr__val); }
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtMallocWithFlags.sizeBytes);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtMallocWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtModuleLaunchKernel:
|
|
oss << "hipExtModuleLaunchKernel(";
|
|
oss << "f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.f);
|
|
oss << ", globalWorkSizeX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.globalWorkSizeX);
|
|
oss << ", globalWorkSizeY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.globalWorkSizeY);
|
|
oss << ", globalWorkSizeZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.globalWorkSizeZ);
|
|
oss << ", localWorkSizeX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.localWorkSizeX);
|
|
oss << ", localWorkSizeY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.localWorkSizeY);
|
|
oss << ", localWorkSizeZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.localWorkSizeZ);
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.sharedMemBytes);
|
|
oss << ", hStream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.hStream);
|
|
if (data->args.hipExtModuleLaunchKernel.kernelParams == NULL) oss << ", kernelParams=NULL";
|
|
else { oss << ", kernelParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.kernelParams__val); }
|
|
if (data->args.hipExtModuleLaunchKernel.extra == NULL) oss << ", extra=NULL";
|
|
else { oss << ", extra="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.extra__val); }
|
|
oss << ", startEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.startEvent);
|
|
oss << ", stopEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.stopEvent);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtModuleLaunchKernel.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtStreamCreateWithCUMask:
|
|
oss << "hipExtStreamCreateWithCUMask(";
|
|
if (data->args.hipExtStreamCreateWithCUMask.stream == NULL) oss << "stream=NULL";
|
|
else { oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamCreateWithCUMask.stream__val); }
|
|
oss << ", cuMaskSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamCreateWithCUMask.cuMaskSize);
|
|
if (data->args.hipExtStreamCreateWithCUMask.cuMask == NULL) oss << ", cuMask=NULL";
|
|
else { oss << ", cuMask="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamCreateWithCUMask.cuMask__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExtStreamGetCUMask:
|
|
oss << "hipExtStreamGetCUMask(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamGetCUMask.stream);
|
|
oss << ", cuMaskSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamGetCUMask.cuMaskSize);
|
|
if (data->args.hipExtStreamGetCUMask.cuMask == NULL) oss << ", cuMask=NULL";
|
|
else { oss << ", cuMask="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExtStreamGetCUMask.cuMask__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipExternalMemoryGetMappedBuffer:
|
|
oss << "hipExternalMemoryGetMappedBuffer(";
|
|
if (data->args.hipExternalMemoryGetMappedBuffer.devPtr == NULL) oss << "devPtr=NULL";
|
|
else { oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedBuffer.devPtr__val); }
|
|
oss << ", extMem="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedBuffer.extMem);
|
|
if (data->args.hipExternalMemoryGetMappedBuffer.bufferDesc == NULL) oss << ", bufferDesc=NULL";
|
|
else { oss << ", bufferDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedBuffer.bufferDesc__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFree:
|
|
oss << "hipFree(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFree.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFreeArray:
|
|
oss << "hipFreeArray(";
|
|
if (data->args.hipFreeArray.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeArray.array__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFreeAsync:
|
|
oss << "hipFreeAsync(";
|
|
oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeAsync.dev_ptr);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFreeHost:
|
|
oss << "hipFreeHost(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeHost.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFreeMipmappedArray:
|
|
oss << "hipFreeMipmappedArray(";
|
|
oss << "mipmappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeMipmappedArray.mipmappedArray);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFuncGetAttribute:
|
|
oss << "hipFuncGetAttribute(";
|
|
if (data->args.hipFuncGetAttribute.value == NULL) oss << "value=NULL";
|
|
else { oss << "value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncGetAttribute.value__val); }
|
|
oss << ", attrib="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncGetAttribute.attrib);
|
|
oss << ", hfunc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncGetAttribute.hfunc);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFuncGetAttributes:
|
|
oss << "hipFuncGetAttributes(";
|
|
if (data->args.hipFuncGetAttributes.attr == NULL) oss << "attr=NULL";
|
|
else { oss << "attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncGetAttributes.attr__val); }
|
|
oss << ", func="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncGetAttributes.func);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFuncSetAttribute:
|
|
oss << "hipFuncSetAttribute(";
|
|
oss << "func="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetAttribute.func);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetAttribute.attr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetAttribute.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFuncSetCacheConfig:
|
|
oss << "hipFuncSetCacheConfig(";
|
|
oss << "func="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetCacheConfig.func);
|
|
oss << ", config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetCacheConfig.config);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipFuncSetSharedMemConfig:
|
|
oss << "hipFuncSetSharedMemConfig(";
|
|
oss << "func="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetSharedMemConfig.func);
|
|
oss << ", config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFuncSetSharedMemConfig.config);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGLGetDevices:
|
|
oss << "hipGLGetDevices(";
|
|
if (data->args.hipGLGetDevices.pHipDeviceCount == NULL) oss << "pHipDeviceCount=NULL";
|
|
else { oss << "pHipDeviceCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGLGetDevices.pHipDeviceCount__val); }
|
|
if (data->args.hipGLGetDevices.pHipDevices == NULL) oss << ", pHipDevices=NULL";
|
|
else { oss << ", pHipDevices="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGLGetDevices.pHipDevices__val); }
|
|
oss << ", hipDeviceCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGLGetDevices.hipDeviceCount);
|
|
oss << ", deviceList="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGLGetDevices.deviceList);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetChannelDesc:
|
|
oss << "hipGetChannelDesc(";
|
|
if (data->args.hipGetChannelDesc.desc == NULL) oss << "desc=NULL";
|
|
else { oss << "desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetChannelDesc.desc__val); }
|
|
oss << ", array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetChannelDesc.array);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetDevice:
|
|
oss << "hipGetDevice(";
|
|
if (data->args.hipGetDevice.deviceId == NULL) oss << "deviceId=NULL";
|
|
else { oss << "deviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDevice.deviceId__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetDeviceCount:
|
|
oss << "hipGetDeviceCount(";
|
|
if (data->args.hipGetDeviceCount.count == NULL) oss << "count=NULL";
|
|
else { oss << "count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDeviceCount.count__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetDeviceFlags:
|
|
oss << "hipGetDeviceFlags(";
|
|
if (data->args.hipGetDeviceFlags.flags == NULL) oss << "flags=NULL";
|
|
else { oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDeviceFlags.flags__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetDeviceProperties:
|
|
oss << "hipGetDeviceProperties(";
|
|
if (data->args.hipGetDeviceProperties.props == NULL) oss << "props=NULL";
|
|
else { oss << "props="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDeviceProperties.props__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDeviceProperties.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetErrorString:
|
|
oss << "hipGetErrorString(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetLastError:
|
|
oss << "hipGetLastError(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetMipmappedArrayLevel:
|
|
oss << "hipGetMipmappedArrayLevel(";
|
|
if (data->args.hipGetMipmappedArrayLevel.levelArray == NULL) oss << "levelArray=NULL";
|
|
else { oss << "levelArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetMipmappedArrayLevel.levelArray__val); }
|
|
oss << ", mipmappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetMipmappedArrayLevel.mipmappedArray);
|
|
oss << ", level="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetMipmappedArrayLevel.level);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetSymbolAddress:
|
|
oss << "hipGetSymbolAddress(";
|
|
if (data->args.hipGetSymbolAddress.devPtr == NULL) oss << "devPtr=NULL";
|
|
else { oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetSymbolAddress.devPtr__val); }
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetSymbolAddress.symbol);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetSymbolSize:
|
|
oss << "hipGetSymbolSize(";
|
|
if (data->args.hipGetSymbolSize.size == NULL) oss << "size=NULL";
|
|
else { oss << "size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetSymbolSize.size__val); }
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetSymbolSize.symbol);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddChildGraphNode:
|
|
oss << "hipGraphAddChildGraphNode(";
|
|
if (data->args.hipGraphAddChildGraphNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddChildGraphNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddChildGraphNode.graph);
|
|
if (data->args.hipGraphAddChildGraphNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddChildGraphNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddChildGraphNode.numDependencies);
|
|
oss << ", childGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddChildGraphNode.childGraph);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddDependencies:
|
|
oss << "hipGraphAddDependencies(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddDependencies.graph);
|
|
if (data->args.hipGraphAddDependencies.from == NULL) oss << ", from=NULL";
|
|
else { oss << ", from="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddDependencies.from__val); }
|
|
if (data->args.hipGraphAddDependencies.to == NULL) oss << ", to=NULL";
|
|
else { oss << ", to="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddDependencies.to__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddDependencies.numDependencies);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddEmptyNode:
|
|
oss << "hipGraphAddEmptyNode(";
|
|
if (data->args.hipGraphAddEmptyNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEmptyNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEmptyNode.graph);
|
|
if (data->args.hipGraphAddEmptyNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEmptyNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEmptyNode.numDependencies);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddEventRecordNode:
|
|
oss << "hipGraphAddEventRecordNode(";
|
|
if (data->args.hipGraphAddEventRecordNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventRecordNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventRecordNode.graph);
|
|
if (data->args.hipGraphAddEventRecordNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventRecordNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventRecordNode.numDependencies);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventRecordNode.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddEventWaitNode:
|
|
oss << "hipGraphAddEventWaitNode(";
|
|
if (data->args.hipGraphAddEventWaitNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventWaitNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventWaitNode.graph);
|
|
if (data->args.hipGraphAddEventWaitNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventWaitNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventWaitNode.numDependencies);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddEventWaitNode.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddHostNode:
|
|
oss << "hipGraphAddHostNode(";
|
|
if (data->args.hipGraphAddHostNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddHostNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddHostNode.graph);
|
|
if (data->args.hipGraphAddHostNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddHostNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddHostNode.numDependencies);
|
|
if (data->args.hipGraphAddHostNode.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddHostNode.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddKernelNode:
|
|
oss << "hipGraphAddKernelNode(";
|
|
if (data->args.hipGraphAddKernelNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddKernelNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddKernelNode.graph);
|
|
if (data->args.hipGraphAddKernelNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddKernelNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddKernelNode.numDependencies);
|
|
if (data->args.hipGraphAddKernelNode.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddKernelNode.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemAllocNode:
|
|
oss << "hipGraphAddMemAllocNode(";
|
|
if (data->args.hipGraphAddMemAllocNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemAllocNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemAllocNode.graph);
|
|
if (data->args.hipGraphAddMemAllocNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemAllocNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemAllocNode.numDependencies);
|
|
if (data->args.hipGraphAddMemAllocNode.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemAllocNode.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemFreeNode:
|
|
oss << "hipGraphAddMemFreeNode(";
|
|
if (data->args.hipGraphAddMemFreeNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemFreeNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemFreeNode.graph);
|
|
if (data->args.hipGraphAddMemFreeNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemFreeNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemFreeNode.numDependencies);
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemFreeNode.dev_ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemcpyNode:
|
|
oss << "hipGraphAddMemcpyNode(";
|
|
if (data->args.hipGraphAddMemcpyNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode.graph);
|
|
if (data->args.hipGraphAddMemcpyNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode.numDependencies);
|
|
if (data->args.hipGraphAddMemcpyNode.pCopyParams == NULL) oss << ", pCopyParams=NULL";
|
|
else { oss << ", pCopyParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode.pCopyParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemcpyNode1D:
|
|
oss << "hipGraphAddMemcpyNode1D(";
|
|
if (data->args.hipGraphAddMemcpyNode1D.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.graph);
|
|
if (data->args.hipGraphAddMemcpyNode1D.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.numDependencies);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.count);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNode1D.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeFromSymbol:
|
|
oss << "hipGraphAddMemcpyNodeFromSymbol(";
|
|
if (data->args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.graph);
|
|
if (data->args.hipGraphAddMemcpyNodeFromSymbol.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.numDependencies);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.dst);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.symbol);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeFromSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemcpyNodeToSymbol:
|
|
oss << "hipGraphAddMemcpyNodeToSymbol(";
|
|
if (data->args.hipGraphAddMemcpyNodeToSymbol.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.graph);
|
|
if (data->args.hipGraphAddMemcpyNodeToSymbol.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.numDependencies);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.symbol);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemcpyNodeToSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddMemsetNode:
|
|
oss << "hipGraphAddMemsetNode(";
|
|
if (data->args.hipGraphAddMemsetNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemsetNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemsetNode.graph);
|
|
if (data->args.hipGraphAddMemsetNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemsetNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemsetNode.numDependencies);
|
|
if (data->args.hipGraphAddMemsetNode.pMemsetParams == NULL) oss << ", pMemsetParams=NULL";
|
|
else { oss << ", pMemsetParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddMemsetNode.pMemsetParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphChildGraphNodeGetGraph:
|
|
oss << "hipGraphChildGraphNodeGetGraph(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphChildGraphNodeGetGraph.node);
|
|
if (data->args.hipGraphChildGraphNodeGetGraph.pGraph == NULL) oss << ", pGraph=NULL";
|
|
else { oss << ", pGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphChildGraphNodeGetGraph.pGraph__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphClone:
|
|
oss << "hipGraphClone(";
|
|
if (data->args.hipGraphClone.pGraphClone == NULL) oss << "pGraphClone=NULL";
|
|
else { oss << "pGraphClone="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphClone.pGraphClone__val); }
|
|
oss << ", originalGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphClone.originalGraph);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphCreate:
|
|
oss << "hipGraphCreate(";
|
|
if (data->args.hipGraphCreate.pGraph == NULL) oss << "pGraph=NULL";
|
|
else { oss << "pGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphCreate.pGraph__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphCreate.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphDebugDotPrint:
|
|
oss << "hipGraphDebugDotPrint(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphDebugDotPrint.graph);
|
|
if (data->args.hipGraphDebugDotPrint.path == NULL) oss << ", path=NULL";
|
|
else { oss << ", path="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphDebugDotPrint.path__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphDebugDotPrint.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphDestroy:
|
|
oss << "hipGraphDestroy(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphDestroy.graph);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphDestroyNode:
|
|
oss << "hipGraphDestroyNode(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphDestroyNode.node);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphEventRecordNodeGetEvent:
|
|
oss << "hipGraphEventRecordNodeGetEvent(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventRecordNodeGetEvent.node);
|
|
if (data->args.hipGraphEventRecordNodeGetEvent.event_out == NULL) oss << ", event_out=NULL";
|
|
else { oss << ", event_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventRecordNodeGetEvent.event_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphEventRecordNodeSetEvent:
|
|
oss << "hipGraphEventRecordNodeSetEvent(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventRecordNodeSetEvent.node);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventRecordNodeSetEvent.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphEventWaitNodeGetEvent:
|
|
oss << "hipGraphEventWaitNodeGetEvent(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventWaitNodeGetEvent.node);
|
|
if (data->args.hipGraphEventWaitNodeGetEvent.event_out == NULL) oss << ", event_out=NULL";
|
|
else { oss << ", event_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventWaitNodeGetEvent.event_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphEventWaitNodeSetEvent:
|
|
oss << "hipGraphEventWaitNodeSetEvent(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventWaitNodeSetEvent.node);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphEventWaitNodeSetEvent.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecChildGraphNodeSetParams:
|
|
oss << "hipGraphExecChildGraphNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecChildGraphNodeSetParams.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecChildGraphNodeSetParams.node);
|
|
oss << ", childGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecChildGraphNodeSetParams.childGraph);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecDestroy:
|
|
oss << "hipGraphExecDestroy(";
|
|
oss << "graphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecDestroy.graphExec);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecEventRecordNodeSetEvent:
|
|
oss << "hipGraphExecEventRecordNodeSetEvent(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventRecordNodeSetEvent.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventRecordNodeSetEvent.hNode);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventRecordNodeSetEvent.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecEventWaitNodeSetEvent:
|
|
oss << "hipGraphExecEventWaitNodeSetEvent(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventWaitNodeSetEvent.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventWaitNodeSetEvent.hNode);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecEventWaitNodeSetEvent.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecHostNodeSetParams:
|
|
oss << "hipGraphExecHostNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecHostNodeSetParams.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecHostNodeSetParams.node);
|
|
if (data->args.hipGraphExecHostNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecHostNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecKernelNodeSetParams:
|
|
oss << "hipGraphExecKernelNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecKernelNodeSetParams.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecKernelNodeSetParams.node);
|
|
if (data->args.hipGraphExecKernelNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecKernelNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams:
|
|
oss << "hipGraphExecMemcpyNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams.node);
|
|
if (data->args.hipGraphExecMemcpyNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParams1D:
|
|
oss << "hipGraphExecMemcpyNodeSetParams1D(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.node);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.count);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParams1D.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsFromSymbol:
|
|
oss << "hipGraphExecMemcpyNodeSetParamsFromSymbol(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.node);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.dst);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.symbol);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsFromSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecMemcpyNodeSetParamsToSymbol:
|
|
oss << "hipGraphExecMemcpyNodeSetParamsToSymbol(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.node);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.symbol);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemcpyNodeSetParamsToSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecMemsetNodeSetParams:
|
|
oss << "hipGraphExecMemsetNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemsetNodeSetParams.hGraphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemsetNodeSetParams.node);
|
|
if (data->args.hipGraphExecMemsetNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecMemsetNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecUpdate:
|
|
oss << "hipGraphExecUpdate(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecUpdate.hGraphExec);
|
|
oss << ", hGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecUpdate.hGraph);
|
|
if (data->args.hipGraphExecUpdate.hErrorNode_out == NULL) oss << ", hErrorNode_out=NULL";
|
|
else { oss << ", hErrorNode_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecUpdate.hErrorNode_out__val); }
|
|
if (data->args.hipGraphExecUpdate.updateResult_out == NULL) oss << ", updateResult_out=NULL";
|
|
else { oss << ", updateResult_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecUpdate.updateResult_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphGetEdges:
|
|
oss << "hipGraphGetEdges(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetEdges.graph);
|
|
if (data->args.hipGraphGetEdges.from == NULL) oss << ", from=NULL";
|
|
else { oss << ", from="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetEdges.from__val); }
|
|
if (data->args.hipGraphGetEdges.to == NULL) oss << ", to=NULL";
|
|
else { oss << ", to="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetEdges.to__val); }
|
|
if (data->args.hipGraphGetEdges.numEdges == NULL) oss << ", numEdges=NULL";
|
|
else { oss << ", numEdges="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetEdges.numEdges__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphGetNodes:
|
|
oss << "hipGraphGetNodes(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetNodes.graph);
|
|
if (data->args.hipGraphGetNodes.nodes == NULL) oss << ", nodes=NULL";
|
|
else { oss << ", nodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetNodes.nodes__val); }
|
|
if (data->args.hipGraphGetNodes.numNodes == NULL) oss << ", numNodes=NULL";
|
|
else { oss << ", numNodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetNodes.numNodes__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphGetRootNodes:
|
|
oss << "hipGraphGetRootNodes(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetRootNodes.graph);
|
|
if (data->args.hipGraphGetRootNodes.pRootNodes == NULL) oss << ", pRootNodes=NULL";
|
|
else { oss << ", pRootNodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetRootNodes.pRootNodes__val); }
|
|
if (data->args.hipGraphGetRootNodes.pNumRootNodes == NULL) oss << ", pNumRootNodes=NULL";
|
|
else { oss << ", pNumRootNodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphGetRootNodes.pNumRootNodes__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphHostNodeGetParams:
|
|
oss << "hipGraphHostNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphHostNodeGetParams.node);
|
|
if (data->args.hipGraphHostNodeGetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphHostNodeGetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphHostNodeSetParams:
|
|
oss << "hipGraphHostNodeSetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphHostNodeSetParams.node);
|
|
if (data->args.hipGraphHostNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphHostNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphInstantiate:
|
|
oss << "hipGraphInstantiate(";
|
|
if (data->args.hipGraphInstantiate.pGraphExec == NULL) oss << "pGraphExec=NULL";
|
|
else { oss << "pGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiate.pGraphExec__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiate.graph);
|
|
if (data->args.hipGraphInstantiate.pErrorNode == NULL) oss << ", pErrorNode=NULL";
|
|
else { oss << ", pErrorNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiate.pErrorNode__val); }
|
|
if (data->args.hipGraphInstantiate.pLogBuffer == NULL) oss << ", pLogBuffer=NULL";
|
|
else { oss << ", pLogBuffer="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiate.pLogBuffer__val); }
|
|
oss << ", bufferSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiate.bufferSize);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphInstantiateWithFlags:
|
|
oss << "hipGraphInstantiateWithFlags(";
|
|
if (data->args.hipGraphInstantiateWithFlags.pGraphExec == NULL) oss << "pGraphExec=NULL";
|
|
else { oss << "pGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithFlags.pGraphExec__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithFlags.graph);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphKernelNodeCopyAttributes:
|
|
oss << "hipGraphKernelNodeCopyAttributes(";
|
|
oss << "hSrc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeCopyAttributes.hSrc);
|
|
oss << ", hDst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeCopyAttributes.hDst);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphKernelNodeGetAttribute:
|
|
oss << "hipGraphKernelNodeGetAttribute(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeGetAttribute.hNode);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeGetAttribute.attr);
|
|
if (data->args.hipGraphKernelNodeGetAttribute.value == NULL) oss << ", value=NULL";
|
|
else { oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeGetAttribute.value__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphKernelNodeGetParams:
|
|
oss << "hipGraphKernelNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeGetParams.node);
|
|
if (data->args.hipGraphKernelNodeGetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeGetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphKernelNodeSetAttribute:
|
|
oss << "hipGraphKernelNodeSetAttribute(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeSetAttribute.hNode);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeSetAttribute.attr);
|
|
if (data->args.hipGraphKernelNodeSetAttribute.value == NULL) oss << ", value=NULL";
|
|
else { oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeSetAttribute.value__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphKernelNodeSetParams:
|
|
oss << "hipGraphKernelNodeSetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeSetParams.node);
|
|
if (data->args.hipGraphKernelNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphKernelNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphLaunch:
|
|
oss << "hipGraphLaunch(";
|
|
oss << "graphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphLaunch.graphExec);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphLaunch.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemAllocNodeGetParams:
|
|
oss << "hipGraphMemAllocNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemAllocNodeGetParams.node);
|
|
if (data->args.hipGraphMemAllocNodeGetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemAllocNodeGetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemFreeNodeGetParams:
|
|
oss << "hipGraphMemFreeNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemFreeNodeGetParams.node);
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemFreeNodeGetParams.dev_ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemcpyNodeGetParams:
|
|
oss << "hipGraphMemcpyNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeGetParams.node);
|
|
if (data->args.hipGraphMemcpyNodeGetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeGetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams:
|
|
oss << "hipGraphMemcpyNodeSetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams.node);
|
|
if (data->args.hipGraphMemcpyNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParams1D:
|
|
oss << "hipGraphMemcpyNodeSetParams1D(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams1D.node);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams1D.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams1D.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams1D.count);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParams1D.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsFromSymbol:
|
|
oss << "hipGraphMemcpyNodeSetParamsFromSymbol(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.node);
|
|
oss << ", dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.dst);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.symbol);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsFromSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemcpyNodeSetParamsToSymbol:
|
|
oss << "hipGraphMemcpyNodeSetParamsToSymbol(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.node);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.symbol);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.count);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemcpyNodeSetParamsToSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemsetNodeGetParams:
|
|
oss << "hipGraphMemsetNodeGetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemsetNodeGetParams.node);
|
|
if (data->args.hipGraphMemsetNodeGetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemsetNodeGetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphMemsetNodeSetParams:
|
|
oss << "hipGraphMemsetNodeSetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemsetNodeSetParams.node);
|
|
if (data->args.hipGraphMemsetNodeSetParams.pNodeParams == NULL) oss << ", pNodeParams=NULL";
|
|
else { oss << ", pNodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphMemsetNodeSetParams.pNodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeFindInClone:
|
|
oss << "hipGraphNodeFindInClone(";
|
|
if (data->args.hipGraphNodeFindInClone.pNode == NULL) oss << "pNode=NULL";
|
|
else { oss << "pNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeFindInClone.pNode__val); }
|
|
oss << ", originalNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeFindInClone.originalNode);
|
|
oss << ", clonedGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeFindInClone.clonedGraph);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeGetDependencies:
|
|
oss << "hipGraphNodeGetDependencies(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependencies.node);
|
|
if (data->args.hipGraphNodeGetDependencies.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependencies.pDependencies__val); }
|
|
if (data->args.hipGraphNodeGetDependencies.pNumDependencies == NULL) oss << ", pNumDependencies=NULL";
|
|
else { oss << ", pNumDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependencies.pNumDependencies__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeGetDependentNodes:
|
|
oss << "hipGraphNodeGetDependentNodes(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependentNodes.node);
|
|
if (data->args.hipGraphNodeGetDependentNodes.pDependentNodes == NULL) oss << ", pDependentNodes=NULL";
|
|
else { oss << ", pDependentNodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependentNodes.pDependentNodes__val); }
|
|
if (data->args.hipGraphNodeGetDependentNodes.pNumDependentNodes == NULL) oss << ", pNumDependentNodes=NULL";
|
|
else { oss << ", pNumDependentNodes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetDependentNodes.pNumDependentNodes__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeGetEnabled:
|
|
oss << "hipGraphNodeGetEnabled(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetEnabled.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetEnabled.hNode);
|
|
if (data->args.hipGraphNodeGetEnabled.isEnabled == NULL) oss << ", isEnabled=NULL";
|
|
else { oss << ", isEnabled="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetEnabled.isEnabled__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeGetType:
|
|
oss << "hipGraphNodeGetType(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetType.node);
|
|
if (data->args.hipGraphNodeGetType.pType == NULL) oss << ", pType=NULL";
|
|
else { oss << ", pType="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeGetType.pType__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphNodeSetEnabled:
|
|
oss << "hipGraphNodeSetEnabled(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeSetEnabled.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeSetEnabled.hNode);
|
|
oss << ", isEnabled="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeSetEnabled.isEnabled);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphReleaseUserObject:
|
|
oss << "hipGraphReleaseUserObject(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphReleaseUserObject.graph);
|
|
oss << ", object="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphReleaseUserObject.object);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphReleaseUserObject.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphRemoveDependencies:
|
|
oss << "hipGraphRemoveDependencies(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRemoveDependencies.graph);
|
|
if (data->args.hipGraphRemoveDependencies.from == NULL) oss << ", from=NULL";
|
|
else { oss << ", from="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRemoveDependencies.from__val); }
|
|
if (data->args.hipGraphRemoveDependencies.to == NULL) oss << ", to=NULL";
|
|
else { oss << ", to="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRemoveDependencies.to__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRemoveDependencies.numDependencies);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphRetainUserObject:
|
|
oss << "hipGraphRetainUserObject(";
|
|
oss << "graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRetainUserObject.graph);
|
|
oss << ", object="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRetainUserObject.object);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRetainUserObject.count);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphRetainUserObject.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphUpload:
|
|
oss << "hipGraphUpload(";
|
|
oss << "graphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphUpload.graphExec);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphUpload.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsGLRegisterBuffer:
|
|
oss << "hipGraphicsGLRegisterBuffer(";
|
|
if (data->args.hipGraphicsGLRegisterBuffer.resource == NULL) oss << "resource=NULL";
|
|
else { oss << "resource="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipGraphicsGLRegisterBuffer.resource__val); }
|
|
oss << ", buffer="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsGLRegisterBuffer.buffer);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsGLRegisterBuffer.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsGLRegisterImage:
|
|
oss << "hipGraphicsGLRegisterImage(";
|
|
if (data->args.hipGraphicsGLRegisterImage.resource == NULL) oss << "resource=NULL";
|
|
else { oss << "resource="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipGraphicsGLRegisterImage.resource__val); }
|
|
oss << ", image="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsGLRegisterImage.image);
|
|
oss << ", target="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsGLRegisterImage.target);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsGLRegisterImage.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsMapResources:
|
|
oss << "hipGraphicsMapResources(";
|
|
oss << "count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsMapResources.count);
|
|
if (data->args.hipGraphicsMapResources.resources == NULL) oss << ", resources=NULL";
|
|
else { oss << ", resources="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsMapResources.resources__val); }
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsMapResources.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsResourceGetMappedPointer:
|
|
oss << "hipGraphicsResourceGetMappedPointer(";
|
|
if (data->args.hipGraphicsResourceGetMappedPointer.devPtr == NULL) oss << "devPtr=NULL";
|
|
else { oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsResourceGetMappedPointer.devPtr__val); }
|
|
if (data->args.hipGraphicsResourceGetMappedPointer.size == NULL) oss << ", size=NULL";
|
|
else { oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsResourceGetMappedPointer.size__val); }
|
|
oss << ", resource="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsResourceGetMappedPointer.resource);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsSubResourceGetMappedArray:
|
|
oss << "hipGraphicsSubResourceGetMappedArray(";
|
|
if (data->args.hipGraphicsSubResourceGetMappedArray.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsSubResourceGetMappedArray.array__val); }
|
|
oss << ", resource="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsSubResourceGetMappedArray.resource);
|
|
oss << ", arrayIndex="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsSubResourceGetMappedArray.arrayIndex);
|
|
oss << ", mipLevel="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsSubResourceGetMappedArray.mipLevel);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsUnmapResources:
|
|
oss << "hipGraphicsUnmapResources(";
|
|
oss << "count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsUnmapResources.count);
|
|
if (data->args.hipGraphicsUnmapResources.resources == NULL) oss << ", resources=NULL";
|
|
else { oss << ", resources="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsUnmapResources.resources__val); }
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsUnmapResources.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphicsUnregisterResource:
|
|
oss << "hipGraphicsUnregisterResource(";
|
|
oss << "resource="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphicsUnregisterResource.resource);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHccModuleLaunchKernel:
|
|
oss << "hipHccModuleLaunchKernel(";
|
|
oss << "f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.f);
|
|
oss << ", globalWorkSizeX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.globalWorkSizeX);
|
|
oss << ", globalWorkSizeY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.globalWorkSizeY);
|
|
oss << ", globalWorkSizeZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.globalWorkSizeZ);
|
|
oss << ", blockDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.blockDimX);
|
|
oss << ", blockDimY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.blockDimY);
|
|
oss << ", blockDimZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.blockDimZ);
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.sharedMemBytes);
|
|
oss << ", hStream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.hStream);
|
|
if (data->args.hipHccModuleLaunchKernel.kernelParams == NULL) oss << ", kernelParams=NULL";
|
|
else { oss << ", kernelParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.kernelParams__val); }
|
|
if (data->args.hipHccModuleLaunchKernel.extra == NULL) oss << ", extra=NULL";
|
|
else { oss << ", extra="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.extra__val); }
|
|
oss << ", startEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.startEvent);
|
|
oss << ", stopEvent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHccModuleLaunchKernel.stopEvent);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostAlloc:
|
|
oss << "hipHostAlloc(";
|
|
if (data->args.hipHostAlloc.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostAlloc.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostAlloc.size);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostAlloc.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostFree:
|
|
oss << "hipHostFree(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostFree.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostGetDevicePointer:
|
|
oss << "hipHostGetDevicePointer(";
|
|
if (data->args.hipHostGetDevicePointer.devPtr == NULL) oss << "devPtr=NULL";
|
|
else { oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostGetDevicePointer.devPtr__val); }
|
|
oss << ", hstPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostGetDevicePointer.hstPtr);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostGetDevicePointer.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostGetFlags:
|
|
oss << "hipHostGetFlags(";
|
|
if (data->args.hipHostGetFlags.flagsPtr == NULL) oss << "flagsPtr=NULL";
|
|
else { oss << "flagsPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostGetFlags.flagsPtr__val); }
|
|
oss << ", hostPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostGetFlags.hostPtr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostMalloc:
|
|
oss << "hipHostMalloc(";
|
|
if (data->args.hipHostMalloc.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostMalloc.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostMalloc.size);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostMalloc.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostRegister:
|
|
oss << "hipHostRegister(";
|
|
oss << "hostPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostRegister.hostPtr);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostRegister.sizeBytes);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostRegister.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipHostUnregister:
|
|
oss << "hipHostUnregister(";
|
|
oss << "hostPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipHostUnregister.hostPtr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipImportExternalMemory:
|
|
oss << "hipImportExternalMemory(";
|
|
if (data->args.hipImportExternalMemory.extMem_out == NULL) oss << "extMem_out=NULL";
|
|
else { oss << "extMem_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipImportExternalMemory.extMem_out__val); }
|
|
if (data->args.hipImportExternalMemory.memHandleDesc == NULL) oss << ", memHandleDesc=NULL";
|
|
else { oss << ", memHandleDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipImportExternalMemory.memHandleDesc__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipImportExternalSemaphore:
|
|
oss << "hipImportExternalSemaphore(";
|
|
if (data->args.hipImportExternalSemaphore.extSem_out == NULL) oss << "extSem_out=NULL";
|
|
else { oss << "extSem_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipImportExternalSemaphore.extSem_out__val); }
|
|
if (data->args.hipImportExternalSemaphore.semHandleDesc == NULL) oss << ", semHandleDesc=NULL";
|
|
else { oss << ", semHandleDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipImportExternalSemaphore.semHandleDesc__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipInit:
|
|
oss << "hipInit(";
|
|
oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipInit.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipIpcCloseMemHandle:
|
|
oss << "hipIpcCloseMemHandle(";
|
|
oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcCloseMemHandle.devPtr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipIpcGetEventHandle:
|
|
oss << "hipIpcGetEventHandle(";
|
|
if (data->args.hipIpcGetEventHandle.handle == NULL) oss << "handle=NULL";
|
|
else { oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcGetEventHandle.handle__val); }
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcGetEventHandle.event);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipIpcGetMemHandle:
|
|
oss << "hipIpcGetMemHandle(";
|
|
if (data->args.hipIpcGetMemHandle.handle == NULL) oss << "handle=NULL";
|
|
else { oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcGetMemHandle.handle__val); }
|
|
oss << ", devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcGetMemHandle.devPtr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipIpcOpenEventHandle:
|
|
oss << "hipIpcOpenEventHandle(";
|
|
if (data->args.hipIpcOpenEventHandle.event == NULL) oss << "event=NULL";
|
|
else { oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcOpenEventHandle.event__val); }
|
|
oss << ", handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcOpenEventHandle.handle);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipIpcOpenMemHandle:
|
|
oss << "hipIpcOpenMemHandle(";
|
|
if (data->args.hipIpcOpenMemHandle.devPtr == NULL) oss << "devPtr=NULL";
|
|
else { oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcOpenMemHandle.devPtr__val); }
|
|
oss << ", handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcOpenMemHandle.handle);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipIpcOpenMemHandle.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLaunchByPtr:
|
|
oss << "hipLaunchByPtr(";
|
|
oss << "hostFunction="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchByPtr.hostFunction);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLaunchCooperativeKernel:
|
|
oss << "hipLaunchCooperativeKernel(";
|
|
oss << "f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.f);
|
|
oss << ", gridDim="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.gridDim);
|
|
oss << ", blockDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.blockDimX);
|
|
if (data->args.hipLaunchCooperativeKernel.kernelParams == NULL) oss << ", kernelParams=NULL";
|
|
else { oss << ", kernelParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.kernelParams__val); }
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.sharedMemBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernel.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLaunchCooperativeKernelMultiDevice:
|
|
oss << "hipLaunchCooperativeKernelMultiDevice(";
|
|
if (data->args.hipLaunchCooperativeKernelMultiDevice.launchParamsList == NULL) oss << "launchParamsList=NULL";
|
|
else { oss << "launchParamsList="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernelMultiDevice.launchParamsList__val); }
|
|
oss << ", numDevices="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernelMultiDevice.numDevices);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchCooperativeKernelMultiDevice.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLaunchHostFunc:
|
|
oss << "hipLaunchHostFunc(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchHostFunc.stream);
|
|
oss << ", fn="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchHostFunc.fn);
|
|
oss << ", userData="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchHostFunc.userData);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLaunchKernel:
|
|
oss << "hipLaunchKernel(";
|
|
oss << "function_address="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.function_address);
|
|
oss << ", numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.numBlocks);
|
|
oss << ", dimBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.dimBlocks);
|
|
if (data->args.hipLaunchKernel.args == NULL) oss << ", args=NULL";
|
|
else { oss << ", args="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.args__val); }
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.sharedMemBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernel.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMalloc:
|
|
oss << "hipMalloc(";
|
|
if (data->args.hipMalloc.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc.size);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMalloc3D:
|
|
oss << "hipMalloc3D(";
|
|
if (data->args.hipMalloc3D.pitchedDevPtr == NULL) oss << "pitchedDevPtr=NULL";
|
|
else { oss << "pitchedDevPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3D.pitchedDevPtr__val); }
|
|
oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3D.extent);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMalloc3DArray:
|
|
oss << "hipMalloc3DArray(";
|
|
if (data->args.hipMalloc3DArray.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3DArray.array__val); }
|
|
if (data->args.hipMalloc3DArray.desc == NULL) oss << ", desc=NULL";
|
|
else { oss << ", desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3DArray.desc__val); }
|
|
oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3DArray.extent);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMalloc3DArray.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocArray:
|
|
oss << "hipMallocArray(";
|
|
if (data->args.hipMallocArray.array == NULL) oss << "array=NULL";
|
|
else { oss << "array="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipMallocArray.array__val); }
|
|
if (data->args.hipMallocArray.desc == NULL) oss << ", desc=NULL";
|
|
else { oss << ", desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocArray.desc__val); }
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocArray.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocArray.height);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocArray.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocAsync:
|
|
oss << "hipMallocAsync(";
|
|
if (data->args.hipMallocAsync.dev_ptr == NULL) oss << "dev_ptr=NULL";
|
|
else { oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocAsync.dev_ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocAsync.size);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocFromPoolAsync:
|
|
oss << "hipMallocFromPoolAsync(";
|
|
if (data->args.hipMallocFromPoolAsync.dev_ptr == NULL) oss << "dev_ptr=NULL";
|
|
else { oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocFromPoolAsync.dev_ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocFromPoolAsync.size);
|
|
oss << ", mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocFromPoolAsync.mem_pool);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocFromPoolAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocHost:
|
|
oss << "hipMallocHost(";
|
|
if (data->args.hipMallocHost.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocHost.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocHost.size);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocManaged:
|
|
oss << "hipMallocManaged(";
|
|
if (data->args.hipMallocManaged.dev_ptr == NULL) oss << "dev_ptr=NULL";
|
|
else { oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocManaged.dev_ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocManaged.size);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocManaged.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocMipmappedArray:
|
|
oss << "hipMallocMipmappedArray(";
|
|
if (data->args.hipMallocMipmappedArray.mipmappedArray == NULL) oss << "mipmappedArray=NULL";
|
|
else { oss << "mipmappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocMipmappedArray.mipmappedArray__val); }
|
|
if (data->args.hipMallocMipmappedArray.desc == NULL) oss << ", desc=NULL";
|
|
else { oss << ", desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocMipmappedArray.desc__val); }
|
|
oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocMipmappedArray.extent);
|
|
oss << ", numLevels="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocMipmappedArray.numLevels);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocMipmappedArray.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMallocPitch:
|
|
oss << "hipMallocPitch(";
|
|
if (data->args.hipMallocPitch.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocPitch.ptr__val); }
|
|
if (data->args.hipMallocPitch.pitch == NULL) oss << ", pitch=NULL";
|
|
else { oss << ", pitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocPitch.pitch__val); }
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocPitch.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMallocPitch.height);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemAddressFree:
|
|
oss << "hipMemAddressFree(";
|
|
oss << "devPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressFree.devPtr);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressFree.size);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemAddressReserve:
|
|
oss << "hipMemAddressReserve(";
|
|
if (data->args.hipMemAddressReserve.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressReserve.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressReserve.size);
|
|
oss << ", alignment="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressReserve.alignment);
|
|
oss << ", addr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressReserve.addr);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAddressReserve.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemAdvise:
|
|
oss << "hipMemAdvise(";
|
|
oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAdvise.dev_ptr);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAdvise.count);
|
|
oss << ", advice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAdvise.advice);
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAdvise.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemAllocHost:
|
|
oss << "hipMemAllocHost(";
|
|
if (data->args.hipMemAllocHost.ptr == NULL) oss << "ptr=NULL";
|
|
else { oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocHost.ptr__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocHost.size);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemAllocPitch:
|
|
oss << "hipMemAllocPitch(";
|
|
if (data->args.hipMemAllocPitch.dptr == NULL) oss << "dptr=NULL";
|
|
else { oss << "dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocPitch.dptr__val); }
|
|
if (data->args.hipMemAllocPitch.pitch == NULL) oss << ", pitch=NULL";
|
|
else { oss << ", pitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocPitch.pitch__val); }
|
|
oss << ", widthInBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocPitch.widthInBytes);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocPitch.height);
|
|
oss << ", elementSizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemAllocPitch.elementSizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemCreate:
|
|
oss << "hipMemCreate(";
|
|
if (data->args.hipMemCreate.handle == NULL) oss << "handle=NULL";
|
|
else { oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemCreate.handle__val); }
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemCreate.size);
|
|
if (data->args.hipMemCreate.prop == NULL) oss << ", prop=NULL";
|
|
else { oss << ", prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemCreate.prop__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemCreate.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemExportToShareableHandle:
|
|
oss << "hipMemExportToShareableHandle(";
|
|
oss << "shareableHandle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemExportToShareableHandle.shareableHandle);
|
|
oss << ", handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemExportToShareableHandle.handle);
|
|
oss << ", handleType="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemExportToShareableHandle.handleType);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemExportToShareableHandle.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemGetAccess:
|
|
oss << "hipMemGetAccess(";
|
|
if (data->args.hipMemGetAccess.flags == NULL) oss << "flags=NULL";
|
|
else { oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAccess.flags__val); }
|
|
if (data->args.hipMemGetAccess.location == NULL) oss << ", location=NULL";
|
|
else { oss << ", location="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAccess.location__val); }
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAccess.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemGetAddressRange:
|
|
oss << "hipMemGetAddressRange(";
|
|
if (data->args.hipMemGetAddressRange.pbase == NULL) oss << "pbase=NULL";
|
|
else { oss << "pbase="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAddressRange.pbase__val); }
|
|
if (data->args.hipMemGetAddressRange.psize == NULL) oss << ", psize=NULL";
|
|
else { oss << ", psize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAddressRange.psize__val); }
|
|
oss << ", dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAddressRange.dptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemGetAllocationGranularity:
|
|
oss << "hipMemGetAllocationGranularity(";
|
|
if (data->args.hipMemGetAllocationGranularity.granularity == NULL) oss << "granularity=NULL";
|
|
else { oss << "granularity="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAllocationGranularity.granularity__val); }
|
|
if (data->args.hipMemGetAllocationGranularity.prop == NULL) oss << ", prop=NULL";
|
|
else { oss << ", prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAllocationGranularity.prop__val); }
|
|
oss << ", option="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAllocationGranularity.option);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemGetAllocationPropertiesFromHandle:
|
|
oss << "hipMemGetAllocationPropertiesFromHandle(";
|
|
if (data->args.hipMemGetAllocationPropertiesFromHandle.prop == NULL) oss << "prop=NULL";
|
|
else { oss << "prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAllocationPropertiesFromHandle.prop__val); }
|
|
oss << ", handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetAllocationPropertiesFromHandle.handle);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemGetInfo:
|
|
oss << "hipMemGetInfo(";
|
|
if (data->args.hipMemGetInfo.free == NULL) oss << "free=NULL";
|
|
else { oss << "free="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetInfo.free__val); }
|
|
if (data->args.hipMemGetInfo.total == NULL) oss << ", total=NULL";
|
|
else { oss << ", total="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemGetInfo.total__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemImportFromShareableHandle:
|
|
oss << "hipMemImportFromShareableHandle(";
|
|
if (data->args.hipMemImportFromShareableHandle.handle == NULL) oss << "handle=NULL";
|
|
else { oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemImportFromShareableHandle.handle__val); }
|
|
oss << ", osHandle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemImportFromShareableHandle.osHandle);
|
|
oss << ", shHandleType="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemImportFromShareableHandle.shHandleType);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemMap:
|
|
oss << "hipMemMap(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMap.ptr);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMap.size);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMap.offset);
|
|
oss << ", handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMap.handle);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMap.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemMapArrayAsync:
|
|
oss << "hipMemMapArrayAsync(";
|
|
if (data->args.hipMemMapArrayAsync.mapInfoList == NULL) oss << "mapInfoList=NULL";
|
|
else { oss << "mapInfoList="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMapArrayAsync.mapInfoList__val); }
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMapArrayAsync.count);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemMapArrayAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolCreate:
|
|
oss << "hipMemPoolCreate(";
|
|
if (data->args.hipMemPoolCreate.mem_pool == NULL) oss << "mem_pool=NULL";
|
|
else { oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolCreate.mem_pool__val); }
|
|
if (data->args.hipMemPoolCreate.pool_props == NULL) oss << ", pool_props=NULL";
|
|
else { oss << ", pool_props="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolCreate.pool_props__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolDestroy:
|
|
oss << "hipMemPoolDestroy(";
|
|
oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolDestroy.mem_pool);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolExportPointer:
|
|
oss << "hipMemPoolExportPointer(";
|
|
if (data->args.hipMemPoolExportPointer.export_data == NULL) oss << "export_data=NULL";
|
|
else { oss << "export_data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportPointer.export_data__val); }
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportPointer.dev_ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolExportToShareableHandle:
|
|
oss << "hipMemPoolExportToShareableHandle(";
|
|
oss << "shared_handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportToShareableHandle.shared_handle);
|
|
oss << ", mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportToShareableHandle.mem_pool);
|
|
oss << ", handle_type="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportToShareableHandle.handle_type);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolExportToShareableHandle.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolGetAccess:
|
|
oss << "hipMemPoolGetAccess(";
|
|
if (data->args.hipMemPoolGetAccess.flags == NULL) oss << "flags=NULL";
|
|
else { oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAccess.flags__val); }
|
|
oss << ", mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAccess.mem_pool);
|
|
if (data->args.hipMemPoolGetAccess.location == NULL) oss << ", location=NULL";
|
|
else { oss << ", location="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAccess.location__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolGetAttribute:
|
|
oss << "hipMemPoolGetAttribute(";
|
|
oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAttribute.mem_pool);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAttribute.attr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolGetAttribute.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolImportFromShareableHandle:
|
|
oss << "hipMemPoolImportFromShareableHandle(";
|
|
if (data->args.hipMemPoolImportFromShareableHandle.mem_pool == NULL) oss << "mem_pool=NULL";
|
|
else { oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportFromShareableHandle.mem_pool__val); }
|
|
oss << ", shared_handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportFromShareableHandle.shared_handle);
|
|
oss << ", handle_type="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportFromShareableHandle.handle_type);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportFromShareableHandle.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolImportPointer:
|
|
oss << "hipMemPoolImportPointer(";
|
|
if (data->args.hipMemPoolImportPointer.dev_ptr == NULL) oss << "dev_ptr=NULL";
|
|
else { oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportPointer.dev_ptr__val); }
|
|
oss << ", mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportPointer.mem_pool);
|
|
if (data->args.hipMemPoolImportPointer.export_data == NULL) oss << ", export_data=NULL";
|
|
else { oss << ", export_data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolImportPointer.export_data__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolSetAccess:
|
|
oss << "hipMemPoolSetAccess(";
|
|
oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAccess.mem_pool);
|
|
if (data->args.hipMemPoolSetAccess.desc_list == NULL) oss << ", desc_list=NULL";
|
|
else { oss << ", desc_list="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAccess.desc_list__val); }
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAccess.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolSetAttribute:
|
|
oss << "hipMemPoolSetAttribute(";
|
|
oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAttribute.mem_pool);
|
|
oss << ", attr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAttribute.attr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolSetAttribute.value);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPoolTrimTo:
|
|
oss << "hipMemPoolTrimTo(";
|
|
oss << "mem_pool="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolTrimTo.mem_pool);
|
|
oss << ", min_bytes_to_hold="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPoolTrimTo.min_bytes_to_hold);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPrefetchAsync:
|
|
oss << "hipMemPrefetchAsync(";
|
|
oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPrefetchAsync.dev_ptr);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPrefetchAsync.count);
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPrefetchAsync.device);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPrefetchAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemPtrGetInfo:
|
|
oss << "hipMemPtrGetInfo(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPtrGetInfo.ptr);
|
|
if (data->args.hipMemPtrGetInfo.size == NULL) oss << ", size=NULL";
|
|
else { oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemPtrGetInfo.size__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemRangeGetAttribute:
|
|
oss << "hipMemRangeGetAttribute(";
|
|
oss << "data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttribute.data);
|
|
oss << ", data_size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttribute.data_size);
|
|
oss << ", attribute="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttribute.attribute);
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttribute.dev_ptr);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttribute.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemRangeGetAttributes:
|
|
oss << "hipMemRangeGetAttributes(";
|
|
if (data->args.hipMemRangeGetAttributes.data == NULL) oss << "data=NULL";
|
|
else { oss << "data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.data__val); }
|
|
if (data->args.hipMemRangeGetAttributes.data_sizes == NULL) oss << ", data_sizes=NULL";
|
|
else { oss << ", data_sizes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.data_sizes__val); }
|
|
if (data->args.hipMemRangeGetAttributes.attributes == NULL) oss << ", attributes=NULL";
|
|
else { oss << ", attributes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.attributes__val); }
|
|
oss << ", num_attributes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.num_attributes);
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.dev_ptr);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRangeGetAttributes.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemRelease:
|
|
oss << "hipMemRelease(";
|
|
oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRelease.handle);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemRetainAllocationHandle:
|
|
oss << "hipMemRetainAllocationHandle(";
|
|
if (data->args.hipMemRetainAllocationHandle.handle == NULL) oss << "handle=NULL";
|
|
else { oss << "handle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRetainAllocationHandle.handle__val); }
|
|
oss << ", addr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemRetainAllocationHandle.addr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemSetAccess:
|
|
oss << "hipMemSetAccess(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemSetAccess.ptr);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemSetAccess.size);
|
|
if (data->args.hipMemSetAccess.desc == NULL) oss << ", desc=NULL";
|
|
else { oss << ", desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemSetAccess.desc__val); }
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemSetAccess.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemUnmap:
|
|
oss << "hipMemUnmap(";
|
|
oss << "ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemUnmap.ptr);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemUnmap.size);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy:
|
|
oss << "hipMemcpy(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy.sizeBytes);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2D:
|
|
oss << "hipMemcpy2D(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.dst);
|
|
oss << ", dpitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.dpitch);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.src);
|
|
oss << ", spitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.spitch);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2D.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2DAsync:
|
|
oss << "hipMemcpy2DAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.dst);
|
|
oss << ", dpitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.dpitch);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.src);
|
|
oss << ", spitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.spitch);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2DFromArray:
|
|
oss << "hipMemcpy2DFromArray(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.dst);
|
|
oss << ", dpitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.dpitch);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.src);
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.hOffset);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArray.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2DFromArrayAsync:
|
|
oss << "hipMemcpy2DFromArrayAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.dst);
|
|
oss << ", dpitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.dpitch);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.src);
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.hOffset);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DFromArrayAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2DToArray:
|
|
oss << "hipMemcpy2DToArray(";
|
|
if (data->args.hipMemcpy2DToArray.dst == NULL) oss << "dst=NULL";
|
|
else { oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.dst__val); }
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.hOffset);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.src);
|
|
oss << ", spitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.spitch);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy2DToArrayAsync:
|
|
oss << "hipMemcpy2DToArrayAsync(";
|
|
if (data->args.hipMemcpy2DToArrayAsync.dst == NULL) oss << "dst=NULL";
|
|
else { oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.dst__val); }
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.hOffset);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.src);
|
|
oss << ", spitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.spitch);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy3D:
|
|
oss << "hipMemcpy3D(";
|
|
if (data->args.hipMemcpy3D.p == NULL) oss << "p=NULL";
|
|
else { oss << "p="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy3D.p__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpy3DAsync:
|
|
oss << "hipMemcpy3DAsync(";
|
|
if (data->args.hipMemcpy3DAsync.p == NULL) oss << "p=NULL";
|
|
else { oss << "p="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy3DAsync.p__val); }
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy3DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyAsync:
|
|
oss << "hipMemcpyAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAsync.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAsync.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAsync.sizeBytes);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyAtoH:
|
|
oss << "hipMemcpyAtoH(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.dst);
|
|
if (data->args.hipMemcpyAtoH.srcArray == NULL) oss << ", srcArray=NULL";
|
|
else { oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.srcArray__val); }
|
|
oss << ", srcOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.srcOffset);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyDtoD:
|
|
oss << "hipMemcpyDtoD(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoD.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoD.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoD.sizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyDtoDAsync:
|
|
oss << "hipMemcpyDtoDAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoDAsync.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoDAsync.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoDAsync.sizeBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoDAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyDtoH:
|
|
oss << "hipMemcpyDtoH(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoH.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoH.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoH.sizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyDtoHAsync:
|
|
oss << "hipMemcpyDtoHAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoHAsync.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoHAsync.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoHAsync.sizeBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoHAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyFromArray:
|
|
oss << "hipMemcpyFromArray(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.dst);
|
|
oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.srcArray);
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.hOffset);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.count);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromArray.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyFromSymbol:
|
|
oss << "hipMemcpyFromSymbol(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbol.dst);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbol.symbol);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbol.sizeBytes);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyFromSymbolAsync:
|
|
oss << "hipMemcpyFromSymbolAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.dst);
|
|
oss << ", symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.symbol);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.sizeBytes);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyFromSymbolAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyHtoA:
|
|
oss << "hipMemcpyHtoA(";
|
|
if (data->args.hipMemcpyHtoA.dstArray == NULL) oss << "dstArray=NULL";
|
|
else { oss << "dstArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoA.dstArray__val); }
|
|
oss << ", dstOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoA.dstOffset);
|
|
oss << ", srcHost="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoA.srcHost);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoA.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyHtoD:
|
|
oss << "hipMemcpyHtoD(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoD.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoD.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoD.sizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyHtoDAsync:
|
|
oss << "hipMemcpyHtoDAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoDAsync.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoDAsync.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoDAsync.sizeBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoDAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyParam2D:
|
|
oss << "hipMemcpyParam2D(";
|
|
if (data->args.hipMemcpyParam2D.pCopy == NULL) oss << "pCopy=NULL";
|
|
else { oss << "pCopy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyParam2D.pCopy__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyParam2DAsync:
|
|
oss << "hipMemcpyParam2DAsync(";
|
|
if (data->args.hipMemcpyParam2DAsync.pCopy == NULL) oss << "pCopy=NULL";
|
|
else { oss << "pCopy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyParam2DAsync.pCopy__val); }
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyParam2DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyPeer:
|
|
oss << "hipMemcpyPeer(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeer.dst);
|
|
oss << ", dstDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeer.dstDeviceId);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeer.src);
|
|
oss << ", srcDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeer.srcDeviceId);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeer.sizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyPeerAsync:
|
|
oss << "hipMemcpyPeerAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.dst);
|
|
oss << ", dstDeviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.dstDeviceId);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.src);
|
|
oss << ", srcDevice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.srcDevice);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.sizeBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyPeerAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyToArray:
|
|
oss << "hipMemcpyToArray(";
|
|
if (data->args.hipMemcpyToArray.dst == NULL) oss << "dst=NULL";
|
|
else { oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.dst__val); }
|
|
oss << ", wOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.wOffset);
|
|
oss << ", hOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.hOffset);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.src);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.count);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyToSymbol:
|
|
oss << "hipMemcpyToSymbol(";
|
|
oss << "symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbol.symbol);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbol.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbol.sizeBytes);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbol.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbol.kind);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyToSymbolAsync:
|
|
oss << "hipMemcpyToSymbolAsync(";
|
|
oss << "symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.symbol);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.sizeBytes);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.offset);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToSymbolAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyWithStream:
|
|
oss << "hipMemcpyWithStream(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyWithStream.dst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyWithStream.src);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyWithStream.sizeBytes);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyWithStream.kind);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyWithStream.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemset:
|
|
oss << "hipMemset(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset.dst);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset.value);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset.sizeBytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemset2D:
|
|
oss << "hipMemset2D(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2D.dst);
|
|
oss << ", pitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2D.pitch);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2D.value);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2D.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2D.height);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemset2DAsync:
|
|
oss << "hipMemset2DAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.dst);
|
|
oss << ", pitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.pitch);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.value);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.height);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset2DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemset3D:
|
|
oss << "hipMemset3D(";
|
|
oss << "pitchedDevPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3D.pitchedDevPtr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3D.value);
|
|
oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3D.extent);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemset3DAsync:
|
|
oss << "hipMemset3DAsync(";
|
|
oss << "pitchedDevPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3DAsync.pitchedDevPtr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3DAsync.value);
|
|
oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3DAsync.extent);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemset3DAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetAsync:
|
|
oss << "hipMemsetAsync(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetAsync.dst);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetAsync.value);
|
|
oss << ", sizeBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetAsync.sizeBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD16:
|
|
oss << "hipMemsetD16(";
|
|
oss << "dest="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16.dest);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD16Async:
|
|
oss << "hipMemsetD16Async(";
|
|
oss << "dest="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16Async.dest);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16Async.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16Async.count);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD16Async.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD32:
|
|
oss << "hipMemsetD32(";
|
|
oss << "dest="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32.dest);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD32Async:
|
|
oss << "hipMemsetD32Async(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32Async.dst);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32Async.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32Async.count);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD32Async.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD8:
|
|
oss << "hipMemsetD8(";
|
|
oss << "dest="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8.dest);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemsetD8Async:
|
|
oss << "hipMemsetD8Async(";
|
|
oss << "dest="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8Async.dest);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8Async.value);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8Async.count);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemsetD8Async.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMipmappedArrayCreate:
|
|
oss << "hipMipmappedArrayCreate(";
|
|
if (data->args.hipMipmappedArrayCreate.pHandle == NULL) oss << "pHandle=NULL";
|
|
else { oss << "pHandle="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayCreate.pHandle__val); }
|
|
if (data->args.hipMipmappedArrayCreate.pMipmappedArrayDesc == NULL) oss << ", pMipmappedArrayDesc=NULL";
|
|
else { oss << ", pMipmappedArrayDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayCreate.pMipmappedArrayDesc__val); }
|
|
oss << ", numMipmapLevels="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayCreate.numMipmapLevels);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMipmappedArrayDestroy:
|
|
oss << "hipMipmappedArrayDestroy(";
|
|
oss << "hMipmappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayDestroy.hMipmappedArray);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMipmappedArrayGetLevel:
|
|
oss << "hipMipmappedArrayGetLevel(";
|
|
if (data->args.hipMipmappedArrayGetLevel.pLevelArray == NULL) oss << "pLevelArray=NULL";
|
|
else { oss << "pLevelArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayGetLevel.pLevelArray__val); }
|
|
oss << ", hMipMappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayGetLevel.hMipMappedArray);
|
|
oss << ", level="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMipmappedArrayGetLevel.level);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleGetFunction:
|
|
oss << "hipModuleGetFunction(";
|
|
if (data->args.hipModuleGetFunction.function == NULL) oss << "function=NULL";
|
|
else { oss << "function="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetFunction.function__val); }
|
|
oss << ", module="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetFunction.module);
|
|
if (data->args.hipModuleGetFunction.kname == NULL) oss << ", kname=NULL";
|
|
else { oss << ", kname="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetFunction.kname__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleGetGlobal:
|
|
oss << "hipModuleGetGlobal(";
|
|
if (data->args.hipModuleGetGlobal.dptr == NULL) oss << "dptr=NULL";
|
|
else { oss << "dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetGlobal.dptr__val); }
|
|
if (data->args.hipModuleGetGlobal.bytes == NULL) oss << ", bytes=NULL";
|
|
else { oss << ", bytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetGlobal.bytes__val); }
|
|
oss << ", hmod="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetGlobal.hmod);
|
|
if (data->args.hipModuleGetGlobal.name == NULL) oss << ", name=NULL";
|
|
else { oss << ", name="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetGlobal.name__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleGetTexRef:
|
|
oss << "hipModuleGetTexRef(";
|
|
if (data->args.hipModuleGetTexRef.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipModuleGetTexRef.texRef__val); }
|
|
oss << ", hmod="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetTexRef.hmod);
|
|
if (data->args.hipModuleGetTexRef.name == NULL) oss << ", name=NULL";
|
|
else { oss << ", name="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleGetTexRef.name__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernel:
|
|
oss << "hipModuleLaunchCooperativeKernel(";
|
|
oss << "f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.f);
|
|
oss << ", gridDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.gridDimX);
|
|
oss << ", gridDimY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.gridDimY);
|
|
oss << ", gridDimZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.gridDimZ);
|
|
oss << ", blockDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.blockDimX);
|
|
oss << ", blockDimY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.blockDimY);
|
|
oss << ", blockDimZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.blockDimZ);
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.sharedMemBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.stream);
|
|
if (data->args.hipModuleLaunchCooperativeKernel.kernelParams == NULL) oss << ", kernelParams=NULL";
|
|
else { oss << ", kernelParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernel.kernelParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLaunchCooperativeKernelMultiDevice:
|
|
oss << "hipModuleLaunchCooperativeKernelMultiDevice(";
|
|
if (data->args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList == NULL) oss << "launchParamsList=NULL";
|
|
else { oss << "launchParamsList="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernelMultiDevice.launchParamsList__val); }
|
|
oss << ", numDevices="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernelMultiDevice.numDevices);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchCooperativeKernelMultiDevice.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLaunchKernel:
|
|
oss << "hipModuleLaunchKernel(";
|
|
oss << "f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.f);
|
|
oss << ", gridDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.gridDimX);
|
|
oss << ", gridDimY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.gridDimY);
|
|
oss << ", gridDimZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.gridDimZ);
|
|
oss << ", blockDimX="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.blockDimX);
|
|
oss << ", blockDimY="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.blockDimY);
|
|
oss << ", blockDimZ="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.blockDimZ);
|
|
oss << ", sharedMemBytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.sharedMemBytes);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.stream);
|
|
if (data->args.hipModuleLaunchKernel.kernelParams == NULL) oss << ", kernelParams=NULL";
|
|
else { oss << ", kernelParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.kernelParams__val); }
|
|
if (data->args.hipModuleLaunchKernel.extra == NULL) oss << ", extra=NULL";
|
|
else { oss << ", extra="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLaunchKernel.extra__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLoad:
|
|
oss << "hipModuleLoad(";
|
|
if (data->args.hipModuleLoad.module == NULL) oss << "module=NULL";
|
|
else { oss << "module="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoad.module__val); }
|
|
if (data->args.hipModuleLoad.fname == NULL) oss << ", fname=NULL";
|
|
else { oss << ", fname="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoad.fname__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLoadData:
|
|
oss << "hipModuleLoadData(";
|
|
if (data->args.hipModuleLoadData.module == NULL) oss << "module=NULL";
|
|
else { oss << "module="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadData.module__val); }
|
|
oss << ", image="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadData.image);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleLoadDataEx:
|
|
oss << "hipModuleLoadDataEx(";
|
|
if (data->args.hipModuleLoadDataEx.module == NULL) oss << "module=NULL";
|
|
else { oss << "module="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadDataEx.module__val); }
|
|
oss << ", image="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadDataEx.image);
|
|
oss << ", numOptions="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadDataEx.numOptions);
|
|
if (data->args.hipModuleLoadDataEx.options == NULL) oss << ", options=NULL";
|
|
else { oss << ", options="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadDataEx.options__val); }
|
|
if (data->args.hipModuleLoadDataEx.optionsValues == NULL) oss << ", optionsValues=NULL";
|
|
else { oss << ", optionsValues="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleLoadDataEx.optionsValues__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor:
|
|
oss << "hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(";
|
|
if (data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks == NULL) oss << "numBlocks=NULL";
|
|
else { oss << "numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.f);
|
|
oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.blockSize);
|
|
oss << ", dynSharedMemPerBlk="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.dynSharedMemPerBlk);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags:
|
|
oss << "hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(";
|
|
if (data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks == NULL) oss << "numBlocks=NULL";
|
|
else { oss << "numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f);
|
|
oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize);
|
|
oss << ", dynSharedMemPerBlk="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynSharedMemPerBlk);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSize:
|
|
oss << "hipModuleOccupancyMaxPotentialBlockSize(";
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSize.gridSize == NULL) oss << "gridSize=NULL";
|
|
else { oss << "gridSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSize.gridSize__val); }
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSize == NULL) oss << ", blockSize=NULL";
|
|
else { oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSize__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSize.f);
|
|
oss << ", dynSharedMemPerBlk="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSize.dynSharedMemPerBlk);
|
|
oss << ", blockSizeLimit="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSize.blockSizeLimit);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleOccupancyMaxPotentialBlockSizeWithFlags:
|
|
oss << "hipModuleOccupancyMaxPotentialBlockSizeWithFlags(";
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize == NULL) oss << "gridSize=NULL";
|
|
else { oss << "gridSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.gridSize__val); }
|
|
if (data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize == NULL) oss << ", blockSize=NULL";
|
|
else { oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSize__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.f);
|
|
oss << ", dynSharedMemPerBlk="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.dynSharedMemPerBlk);
|
|
oss << ", blockSizeLimit="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.blockSizeLimit);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleOccupancyMaxPotentialBlockSizeWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipModuleUnload:
|
|
oss << "hipModuleUnload(";
|
|
oss << "module="; roctracer::hip_support::detail::operator<<(oss, data->args.hipModuleUnload.module);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor:
|
|
oss << "hipOccupancyMaxActiveBlocksPerMultiprocessor(";
|
|
if (data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks == NULL) oss << "numBlocks=NULL";
|
|
else { oss << "numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.f);
|
|
oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.blockSize);
|
|
oss << ", dynamicSMemSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessor.dynamicSMemSize);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags:
|
|
oss << "hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(";
|
|
if (data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks == NULL) oss << "numBlocks=NULL";
|
|
else { oss << "numBlocks="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f);
|
|
oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize);
|
|
oss << ", dynamicSMemSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynamicSMemSize);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipOccupancyMaxPotentialBlockSize:
|
|
oss << "hipOccupancyMaxPotentialBlockSize(";
|
|
if (data->args.hipOccupancyMaxPotentialBlockSize.gridSize == NULL) oss << "gridSize=NULL";
|
|
else { oss << "gridSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxPotentialBlockSize.gridSize__val); }
|
|
if (data->args.hipOccupancyMaxPotentialBlockSize.blockSize == NULL) oss << ", blockSize=NULL";
|
|
else { oss << ", blockSize="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxPotentialBlockSize.blockSize__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxPotentialBlockSize.f);
|
|
oss << ", dynSharedMemPerBlk="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxPotentialBlockSize.dynSharedMemPerBlk);
|
|
oss << ", blockSizeLimit="; roctracer::hip_support::detail::operator<<(oss, data->args.hipOccupancyMaxPotentialBlockSize.blockSizeLimit);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipPeekAtLastError:
|
|
oss << "hipPeekAtLastError(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipPointerGetAttribute:
|
|
oss << "hipPointerGetAttribute(";
|
|
oss << "data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerGetAttribute.data);
|
|
oss << ", attribute="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerGetAttribute.attribute);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerGetAttribute.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipPointerGetAttributes:
|
|
oss << "hipPointerGetAttributes(";
|
|
if (data->args.hipPointerGetAttributes.attributes == NULL) oss << "attributes=NULL";
|
|
else { oss << "attributes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerGetAttributes.attributes__val); }
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerGetAttributes.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipPointerSetAttribute:
|
|
oss << "hipPointerSetAttribute(";
|
|
oss << "value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerSetAttribute.value);
|
|
oss << ", attribute="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerSetAttribute.attribute);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipPointerSetAttribute.ptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipProfilerStart:
|
|
oss << "hipProfilerStart(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipProfilerStop:
|
|
oss << "hipProfilerStop(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipRuntimeGetVersion:
|
|
oss << "hipRuntimeGetVersion(";
|
|
if (data->args.hipRuntimeGetVersion.runtimeVersion == NULL) oss << "runtimeVersion=NULL";
|
|
else { oss << "runtimeVersion="; roctracer::hip_support::detail::operator<<(oss, data->args.hipRuntimeGetVersion.runtimeVersion__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipSetDevice:
|
|
oss << "hipSetDevice(";
|
|
oss << "deviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetDevice.deviceId);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipSetDeviceFlags:
|
|
oss << "hipSetDeviceFlags(";
|
|
oss << "flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetDeviceFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipSetupArgument:
|
|
oss << "hipSetupArgument(";
|
|
oss << "arg="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetupArgument.arg);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetupArgument.size);
|
|
oss << ", offset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetupArgument.offset);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipSignalExternalSemaphoresAsync:
|
|
oss << "hipSignalExternalSemaphoresAsync(";
|
|
if (data->args.hipSignalExternalSemaphoresAsync.extSemArray == NULL) oss << "extSemArray=NULL";
|
|
else { oss << "extSemArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSignalExternalSemaphoresAsync.extSemArray__val); }
|
|
if (data->args.hipSignalExternalSemaphoresAsync.paramsArray == NULL) oss << ", paramsArray=NULL";
|
|
else { oss << ", paramsArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSignalExternalSemaphoresAsync.paramsArray__val); }
|
|
oss << ", numExtSems="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSignalExternalSemaphoresAsync.numExtSems);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSignalExternalSemaphoresAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamAddCallback:
|
|
oss << "hipStreamAddCallback(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAddCallback.stream);
|
|
oss << ", callback="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAddCallback.callback);
|
|
oss << ", userData="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAddCallback.userData);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAddCallback.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamAttachMemAsync:
|
|
oss << "hipStreamAttachMemAsync(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAttachMemAsync.stream);
|
|
oss << ", dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAttachMemAsync.dev_ptr);
|
|
oss << ", length="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAttachMemAsync.length);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamAttachMemAsync.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamBeginCapture:
|
|
oss << "hipStreamBeginCapture(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCapture.stream);
|
|
oss << ", mode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCapture.mode);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamCreate:
|
|
oss << "hipStreamCreate(";
|
|
if (data->args.hipStreamCreate.stream == NULL) oss << "stream=NULL";
|
|
else { oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreate.stream__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamCreateWithFlags:
|
|
oss << "hipStreamCreateWithFlags(";
|
|
if (data->args.hipStreamCreateWithFlags.stream == NULL) oss << "stream=NULL";
|
|
else { oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreateWithFlags.stream__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreateWithFlags.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamCreateWithPriority:
|
|
oss << "hipStreamCreateWithPriority(";
|
|
if (data->args.hipStreamCreateWithPriority.stream == NULL) oss << "stream=NULL";
|
|
else { oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreateWithPriority.stream__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreateWithPriority.flags);
|
|
oss << ", priority="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamCreateWithPriority.priority);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamDestroy:
|
|
oss << "hipStreamDestroy(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamDestroy.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamEndCapture:
|
|
oss << "hipStreamEndCapture(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamEndCapture.stream);
|
|
if (data->args.hipStreamEndCapture.pGraph == NULL) oss << ", pGraph=NULL";
|
|
else { oss << ", pGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamEndCapture.pGraph__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamGetCaptureInfo:
|
|
oss << "hipStreamGetCaptureInfo(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo.stream);
|
|
if (data->args.hipStreamGetCaptureInfo.pCaptureStatus == NULL) oss << ", pCaptureStatus=NULL";
|
|
else { oss << ", pCaptureStatus="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo.pCaptureStatus__val); }
|
|
if (data->args.hipStreamGetCaptureInfo.pId == NULL) oss << ", pId=NULL";
|
|
else { oss << ", pId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo.pId__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamGetCaptureInfo_v2:
|
|
oss << "hipStreamGetCaptureInfo_v2(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo_v2.stream);
|
|
if (data->args.hipStreamGetCaptureInfo_v2.captureStatus_out == NULL) oss << ", captureStatus_out=NULL";
|
|
else { oss << ", captureStatus_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo_v2.captureStatus_out__val); }
|
|
if (data->args.hipStreamGetCaptureInfo_v2.id_out == NULL) oss << ", id_out=NULL";
|
|
else { oss << ", id_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo_v2.id_out__val); }
|
|
if (data->args.hipStreamGetCaptureInfo_v2.graph_out == NULL) oss << ", graph_out=NULL";
|
|
else { oss << ", graph_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo_v2.graph_out__val); }
|
|
if (data->args.hipStreamGetCaptureInfo_v2.dependencies_out == NULL) oss << ", dependencies_out=NULL";
|
|
else { oss << ", dependencies_out="; roctracer::hip_support::detail::operator<<(oss, (void*)data->args.hipStreamGetCaptureInfo_v2.dependencies_out__val); }
|
|
if (data->args.hipStreamGetCaptureInfo_v2.numDependencies_out == NULL) oss << ", numDependencies_out=NULL";
|
|
else { oss << ", numDependencies_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetCaptureInfo_v2.numDependencies_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamGetFlags:
|
|
oss << "hipStreamGetFlags(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetFlags.stream);
|
|
if (data->args.hipStreamGetFlags.flags == NULL) oss << ", flags=NULL";
|
|
else { oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetFlags.flags__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamGetPriority:
|
|
oss << "hipStreamGetPriority(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetPriority.stream);
|
|
if (data->args.hipStreamGetPriority.priority == NULL) oss << ", priority=NULL";
|
|
else { oss << ", priority="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetPriority.priority__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamIsCapturing:
|
|
oss << "hipStreamIsCapturing(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamIsCapturing.stream);
|
|
if (data->args.hipStreamIsCapturing.pCaptureStatus == NULL) oss << ", pCaptureStatus=NULL";
|
|
else { oss << ", pCaptureStatus="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamIsCapturing.pCaptureStatus__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamQuery:
|
|
oss << "hipStreamQuery(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamQuery.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamSynchronize:
|
|
oss << "hipStreamSynchronize(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamSynchronize.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamUpdateCaptureDependencies:
|
|
oss << "hipStreamUpdateCaptureDependencies(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamUpdateCaptureDependencies.stream);
|
|
if (data->args.hipStreamUpdateCaptureDependencies.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamUpdateCaptureDependencies.dependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamUpdateCaptureDependencies.numDependencies);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamUpdateCaptureDependencies.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamWaitEvent:
|
|
oss << "hipStreamWaitEvent(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitEvent.stream);
|
|
oss << ", event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitEvent.event);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitEvent.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamWaitValue32:
|
|
oss << "hipStreamWaitValue32(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue32.stream);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue32.ptr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue32.value);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue32.flags);
|
|
oss << ", mask="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue32.mask);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamWaitValue64:
|
|
oss << "hipStreamWaitValue64(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue64.stream);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue64.ptr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue64.value);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue64.flags);
|
|
oss << ", mask="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWaitValue64.mask);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamWriteValue32:
|
|
oss << "hipStreamWriteValue32(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue32.stream);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue32.ptr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue32.value);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue32.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipStreamWriteValue64:
|
|
oss << "hipStreamWriteValue64(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue64.stream);
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue64.ptr);
|
|
oss << ", value="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue64.value);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamWriteValue64.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetAddress:
|
|
oss << "hipTexRefGetAddress(";
|
|
if (data->args.hipTexRefGetAddress.dev_ptr == NULL) oss << "dev_ptr=NULL";
|
|
else { oss << "dev_ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetAddress.dev_ptr__val); }
|
|
if (data->args.hipTexRefGetAddress.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetAddress.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetFlags:
|
|
oss << "hipTexRefGetFlags(";
|
|
if (data->args.hipTexRefGetFlags.pFlags == NULL) oss << "pFlags=NULL";
|
|
else { oss << "pFlags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetFlags.pFlags__val); }
|
|
if (data->args.hipTexRefGetFlags.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetFlags.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetFormat:
|
|
oss << "hipTexRefGetFormat(";
|
|
if (data->args.hipTexRefGetFormat.pFormat == NULL) oss << "pFormat=NULL";
|
|
else { oss << "pFormat="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetFormat.pFormat__val); }
|
|
if (data->args.hipTexRefGetFormat.pNumChannels == NULL) oss << ", pNumChannels=NULL";
|
|
else { oss << ", pNumChannels="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetFormat.pNumChannels__val); }
|
|
if (data->args.hipTexRefGetFormat.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetFormat.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetMaxAnisotropy:
|
|
oss << "hipTexRefGetMaxAnisotropy(";
|
|
if (data->args.hipTexRefGetMaxAnisotropy.pmaxAnsio == NULL) oss << "pmaxAnsio=NULL";
|
|
else { oss << "pmaxAnsio="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMaxAnisotropy.pmaxAnsio__val); }
|
|
if (data->args.hipTexRefGetMaxAnisotropy.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMaxAnisotropy.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetMipMappedArray:
|
|
oss << "hipTexRefGetMipMappedArray(";
|
|
if (data->args.hipTexRefGetMipMappedArray.pArray == NULL) oss << "pArray=NULL";
|
|
else { oss << "pArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipMappedArray.pArray__val); }
|
|
if (data->args.hipTexRefGetMipMappedArray.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipMappedArray.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelBias:
|
|
oss << "hipTexRefGetMipmapLevelBias(";
|
|
if (data->args.hipTexRefGetMipmapLevelBias.pbias == NULL) oss << "pbias=NULL";
|
|
else { oss << "pbias="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipmapLevelBias.pbias__val); }
|
|
if (data->args.hipTexRefGetMipmapLevelBias.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipmapLevelBias.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetMipmapLevelClamp:
|
|
oss << "hipTexRefGetMipmapLevelClamp(";
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp == NULL) oss << "pminMipmapLevelClamp=NULL";
|
|
else { oss << "pminMipmapLevelClamp="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipmapLevelClamp.pminMipmapLevelClamp__val); }
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp == NULL) oss << ", pmaxMipmapLevelClamp=NULL";
|
|
else { oss << ", pmaxMipmapLevelClamp="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipmapLevelClamp.pmaxMipmapLevelClamp__val); }
|
|
if (data->args.hipTexRefGetMipmapLevelClamp.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetMipmapLevelClamp.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetAddress:
|
|
oss << "hipTexRefSetAddress(";
|
|
if (data->args.hipTexRefSetAddress.ByteOffset == NULL) oss << "ByteOffset=NULL";
|
|
else { oss << "ByteOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress.ByteOffset__val); }
|
|
if (data->args.hipTexRefSetAddress.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress.texRef__val); }
|
|
oss << ", dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress.dptr);
|
|
oss << ", bytes="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress.bytes);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetAddress2D:
|
|
oss << "hipTexRefSetAddress2D(";
|
|
if (data->args.hipTexRefSetAddress2D.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress2D.texRef__val); }
|
|
if (data->args.hipTexRefSetAddress2D.desc == NULL) oss << ", desc=NULL";
|
|
else { oss << ", desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress2D.desc__val); }
|
|
oss << ", dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress2D.dptr);
|
|
oss << ", Pitch="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetAddress2D.Pitch);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetArray:
|
|
oss << "hipTexRefSetArray(";
|
|
if (data->args.hipTexRefSetArray.tex == NULL) oss << "tex=NULL";
|
|
else { oss << "tex="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetArray.tex__val); }
|
|
oss << ", array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetArray.array);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetArray.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetBorderColor:
|
|
oss << "hipTexRefSetBorderColor(";
|
|
if (data->args.hipTexRefSetBorderColor.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetBorderColor.texRef__val); }
|
|
if (data->args.hipTexRefSetBorderColor.pBorderColor == NULL) oss << ", pBorderColor=NULL";
|
|
else { oss << ", pBorderColor="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetBorderColor.pBorderColor__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetFlags:
|
|
oss << "hipTexRefSetFlags(";
|
|
if (data->args.hipTexRefSetFlags.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetFlags.texRef__val); }
|
|
oss << ", Flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetFlags.Flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetFormat:
|
|
oss << "hipTexRefSetFormat(";
|
|
if (data->args.hipTexRefSetFormat.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetFormat.texRef__val); }
|
|
oss << ", fmt="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetFormat.fmt);
|
|
oss << ", NumPackedComponents="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetFormat.NumPackedComponents);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetMaxAnisotropy:
|
|
oss << "hipTexRefSetMaxAnisotropy(";
|
|
if (data->args.hipTexRefSetMaxAnisotropy.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMaxAnisotropy.texRef__val); }
|
|
oss << ", maxAniso="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMaxAnisotropy.maxAniso);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelBias:
|
|
oss << "hipTexRefSetMipmapLevelBias(";
|
|
if (data->args.hipTexRefSetMipmapLevelBias.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmapLevelBias.texRef__val); }
|
|
oss << ", bias="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmapLevelBias.bias);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetMipmapLevelClamp:
|
|
oss << "hipTexRefSetMipmapLevelClamp(";
|
|
if (data->args.hipTexRefSetMipmapLevelClamp.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmapLevelClamp.texRef__val); }
|
|
oss << ", minMipMapLevelClamp="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmapLevelClamp.minMipMapLevelClamp);
|
|
oss << ", maxMipMapLevelClamp="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmapLevelClamp.maxMipMapLevelClamp);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefSetMipmappedArray:
|
|
oss << "hipTexRefSetMipmappedArray(";
|
|
if (data->args.hipTexRefSetMipmappedArray.texRef == NULL) oss << "texRef=NULL";
|
|
else { oss << "texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmappedArray.texRef__val); }
|
|
if (data->args.hipTexRefSetMipmappedArray.mipmappedArray == NULL) oss << ", mipmappedArray=NULL";
|
|
else { oss << ", mipmappedArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmappedArray.mipmappedArray__val); }
|
|
oss << ", Flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefSetMipmappedArray.Flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipThreadExchangeStreamCaptureMode:
|
|
oss << "hipThreadExchangeStreamCaptureMode(";
|
|
if (data->args.hipThreadExchangeStreamCaptureMode.mode == NULL) oss << "mode=NULL";
|
|
else { oss << "mode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipThreadExchangeStreamCaptureMode.mode__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipUserObjectCreate:
|
|
oss << "hipUserObjectCreate(";
|
|
if (data->args.hipUserObjectCreate.object_out == NULL) oss << "object_out=NULL";
|
|
else { oss << "object_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectCreate.object_out__val); }
|
|
oss << ", ptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectCreate.ptr);
|
|
oss << ", destroy="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectCreate.destroy);
|
|
oss << ", initialRefcount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectCreate.initialRefcount);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectCreate.flags);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipUserObjectRelease:
|
|
oss << "hipUserObjectRelease(";
|
|
oss << "object="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectRelease.object);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectRelease.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipUserObjectRetain:
|
|
oss << "hipUserObjectRetain(";
|
|
oss << "object="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectRetain.object);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipUserObjectRetain.count);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipWaitExternalSemaphoresAsync:
|
|
oss << "hipWaitExternalSemaphoresAsync(";
|
|
if (data->args.hipWaitExternalSemaphoresAsync.extSemArray == NULL) oss << "extSemArray=NULL";
|
|
else { oss << "extSemArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipWaitExternalSemaphoresAsync.extSemArray__val); }
|
|
if (data->args.hipWaitExternalSemaphoresAsync.paramsArray == NULL) oss << ", paramsArray=NULL";
|
|
else { oss << ", paramsArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipWaitExternalSemaphoresAsync.paramsArray__val); }
|
|
oss << ", numExtSems="; roctracer::hip_support::detail::operator<<(oss, data->args.hipWaitExternalSemaphoresAsync.numExtSems);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipWaitExternalSemaphoresAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
default: oss << "unknown";
|
|
};
|
|
return strdup(oss.str().c_str());
|
|
}
|
|
#endif // HIP_PROF_HIP_API_STRING
|
|
#endif // _HIP_PROF_STR_H
|