Betigeri, Sourabh
11201 lines
675 KiB
C++
11201 lines
675 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
|
|
|
|
#include <hip/hip_runtime_api.h>
|
|
#include <hip/hip_deprecated.h>
|
|
#include "amd_hip_gl_interop.h"
|
|
|
|
#define HIP_API_ID_CONCAT_HELPER(a,b) a##b
|
|
#define HIP_API_ID_CONCAT(a,b) HIP_API_ID_CONCAT_HELPER(a,b)
|
|
|
|
// 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_hipChooseDeviceR0000 = 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_hipGetDevicePropertiesR0000 = 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_hipArray3DGetDescriptor = 360,
|
|
HIP_API_ID_hipArrayGetDescriptor = 361,
|
|
HIP_API_ID_hipArrayGetInfo = 362,
|
|
HIP_API_ID_hipStreamGetDevice = 363,
|
|
HIP_API_ID_hipExternalMemoryGetMappedMipmappedArray = 364,
|
|
HIP_API_ID_hipChooseDeviceR0600 = 365,
|
|
HIP_API_ID_hipDrvGraphAddMemcpyNode = 366,
|
|
HIP_API_ID_hipDrvGraphAddMemsetNode = 367,
|
|
HIP_API_ID_hipDrvGraphMemcpyNodeGetParams = 368,
|
|
HIP_API_ID_hipDrvGraphMemcpyNodeSetParams = 369,
|
|
HIP_API_ID_hipGetDevicePropertiesR0600 = 370,
|
|
HIP_API_ID_hipGraphAddExternalSemaphoresSignalNode = 371,
|
|
HIP_API_ID_hipGraphAddExternalSemaphoresWaitNode = 372,
|
|
HIP_API_ID_hipGraphExecExternalSemaphoresSignalNodeSetParams = 373,
|
|
HIP_API_ID_hipGraphExecExternalSemaphoresWaitNodeSetParams = 374,
|
|
HIP_API_ID_hipGraphExternalSemaphoresSignalNodeGetParams = 375,
|
|
HIP_API_ID_hipGraphExternalSemaphoresSignalNodeSetParams = 376,
|
|
HIP_API_ID_hipGraphExternalSemaphoresWaitNodeGetParams = 377,
|
|
HIP_API_ID_hipGraphExternalSemaphoresWaitNodeSetParams = 378,
|
|
HIP_API_ID_hipExtGetLastError = 379,
|
|
HIP_API_ID_hipGraphAddNode = 380,
|
|
HIP_API_ID_hipGetProcAddress = 381,
|
|
HIP_API_ID_hipGraphExecGetFlags = 382,
|
|
HIP_API_ID_hipGraphExecNodeSetParams = 383,
|
|
HIP_API_ID_hipGraphInstantiateWithParams = 384,
|
|
HIP_API_ID_hipGraphNodeSetParams = 385,
|
|
HIP_API_ID_hipDrvGraphAddMemFreeNode = 386,
|
|
HIP_API_ID_hipDrvGraphExecMemcpyNodeSetParams = 387,
|
|
HIP_API_ID_hipDrvGraphExecMemsetNodeSetParams = 388,
|
|
HIP_API_ID_hipTexRefGetArray = 389,
|
|
HIP_API_ID_hipTexRefGetBorderColor = 390,
|
|
HIP_API_ID_hipStreamBeginCaptureToGraph = 391,
|
|
HIP_API_ID_hipGetFuncBySymbol = 392,
|
|
HIP_API_ID_RESERVED_393 = 393,
|
|
HIP_API_ID_RESERVED_394 = 394,
|
|
HIP_API_ID_RESERVED_395 = 395,
|
|
HIP_API_ID_RESERVED_396 = 396,
|
|
HIP_API_ID_RESERVED_397 = 397,
|
|
HIP_API_ID_RESERVED_398 = 398,
|
|
HIP_API_ID_RESERVED_399 = 399,
|
|
HIP_API_ID_hipMemcpy2DArrayToArray = 400,
|
|
HIP_API_ID_hipMemcpyAtoA = 401,
|
|
HIP_API_ID_hipMemcpyAtoD = 402,
|
|
HIP_API_ID_hipMemcpyAtoHAsync = 403,
|
|
HIP_API_ID_hipMemcpyDtoA = 404,
|
|
HIP_API_ID_hipMemcpyHtoAAsync = 405,
|
|
HIP_API_ID_hipSetValidDevices = 406,
|
|
HIP_API_ID_RESERVED_407 = 407,
|
|
HIP_API_ID_hipStreamBatchMemOp = 408,
|
|
HIP_API_ID_hipGraphAddBatchMemOpNode = 409,
|
|
HIP_API_ID_hipGraphBatchMemOpNodeGetParams = 410,
|
|
HIP_API_ID_hipGraphBatchMemOpNodeSetParams = 411,
|
|
HIP_API_ID_hipGraphExecBatchMemOpNodeSetParams = 412,
|
|
HIP_API_ID_hipEventRecordWithFlags = 413,
|
|
HIP_API_ID_hipLinkAddData = 414,
|
|
HIP_API_ID_hipLinkAddFile = 415,
|
|
HIP_API_ID_hipLinkComplete = 416,
|
|
HIP_API_ID_hipLinkCreate = 417,
|
|
HIP_API_ID_hipLinkDestroy = 418,
|
|
HIP_API_ID_hipLaunchKernelExC = 419,
|
|
HIP_API_ID_hipDrvLaunchKernelEx = 420,
|
|
HIP_API_ID_LAST = 420,
|
|
|
|
HIP_API_ID_hipChooseDevice = HIP_API_ID_CONCAT(HIP_API_ID_,hipChooseDevice),
|
|
HIP_API_ID_hipGetDeviceProperties = HIP_API_ID_CONCAT(HIP_API_ID_,hipGetDeviceProperties),
|
|
|
|
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_hipDeviceGetTexture1DLinearMaxWidth = 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_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_hipTexRefGetFilterMode = HIP_API_ID_NONE,
|
|
HIP_API_ID_hipTexRefGetMipmapFilterMode = 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,
|
|
};
|
|
|
|
#undef HIP_API_ID_CONCAT_HELPER
|
|
#undef HIP_API_ID_CONCAT
|
|
|
|
// 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_hipArray3DGetDescriptor: return "hipArray3DGetDescriptor";
|
|
case HIP_API_ID_hipArrayCreate: return "hipArrayCreate";
|
|
case HIP_API_ID_hipArrayDestroy: return "hipArrayDestroy";
|
|
case HIP_API_ID_hipArrayGetDescriptor: return "hipArrayGetDescriptor";
|
|
case HIP_API_ID_hipArrayGetInfo: return "hipArrayGetInfo";
|
|
case HIP_API_ID_hipChooseDeviceR0000: return "hipChooseDeviceR0000";
|
|
case HIP_API_ID_hipChooseDeviceR0600: return "hipChooseDeviceR0600";
|
|
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_hipDrvGraphAddMemFreeNode: return "hipDrvGraphAddMemFreeNode";
|
|
case HIP_API_ID_hipDrvGraphAddMemcpyNode: return "hipDrvGraphAddMemcpyNode";
|
|
case HIP_API_ID_hipDrvGraphAddMemsetNode: return "hipDrvGraphAddMemsetNode";
|
|
case HIP_API_ID_hipDrvGraphExecMemcpyNodeSetParams: return "hipDrvGraphExecMemcpyNodeSetParams";
|
|
case HIP_API_ID_hipDrvGraphExecMemsetNodeSetParams: return "hipDrvGraphExecMemsetNodeSetParams";
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeGetParams: return "hipDrvGraphMemcpyNodeGetParams";
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeSetParams: return "hipDrvGraphMemcpyNodeSetParams";
|
|
case HIP_API_ID_hipDrvLaunchKernelEx: return "hipDrvLaunchKernelEx";
|
|
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_hipEventRecordWithFlags: return "hipEventRecordWithFlags";
|
|
case HIP_API_ID_hipEventSynchronize: return "hipEventSynchronize";
|
|
case HIP_API_ID_hipExtGetLastError: return "hipExtGetLastError";
|
|
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_hipExternalMemoryGetMappedMipmappedArray: return "hipExternalMemoryGetMappedMipmappedArray";
|
|
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_hipGetDevicePropertiesR0000: return "hipGetDevicePropertiesR0000";
|
|
case HIP_API_ID_hipGetDevicePropertiesR0600: return "hipGetDevicePropertiesR0600";
|
|
case HIP_API_ID_hipGetErrorString: return "hipGetErrorString";
|
|
case HIP_API_ID_hipGetFuncBySymbol: return "hipGetFuncBySymbol";
|
|
case HIP_API_ID_hipGetLastError: return "hipGetLastError";
|
|
case HIP_API_ID_hipGetMipmappedArrayLevel: return "hipGetMipmappedArrayLevel";
|
|
case HIP_API_ID_hipGetProcAddress: return "hipGetProcAddress";
|
|
case HIP_API_ID_hipGetSymbolAddress: return "hipGetSymbolAddress";
|
|
case HIP_API_ID_hipGetSymbolSize: return "hipGetSymbolSize";
|
|
case HIP_API_ID_hipGraphAddBatchMemOpNode: return "hipGraphAddBatchMemOpNode";
|
|
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_hipGraphAddExternalSemaphoresSignalNode: return "hipGraphAddExternalSemaphoresSignalNode";
|
|
case HIP_API_ID_hipGraphAddExternalSemaphoresWaitNode: return "hipGraphAddExternalSemaphoresWaitNode";
|
|
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_hipGraphAddNode: return "hipGraphAddNode";
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeGetParams: return "hipGraphBatchMemOpNodeGetParams";
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeSetParams: return "hipGraphBatchMemOpNodeSetParams";
|
|
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_hipGraphExecBatchMemOpNodeSetParams: return "hipGraphExecBatchMemOpNodeSetParams";
|
|
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_hipGraphExecExternalSemaphoresSignalNodeSetParams: return "hipGraphExecExternalSemaphoresSignalNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecExternalSemaphoresWaitNodeSetParams: return "hipGraphExecExternalSemaphoresWaitNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecGetFlags: return "hipGraphExecGetFlags";
|
|
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_hipGraphExecNodeSetParams: return "hipGraphExecNodeSetParams";
|
|
case HIP_API_ID_hipGraphExecUpdate: return "hipGraphExecUpdate";
|
|
case HIP_API_ID_hipGraphExternalSemaphoresSignalNodeGetParams: return "hipGraphExternalSemaphoresSignalNodeGetParams";
|
|
case HIP_API_ID_hipGraphExternalSemaphoresSignalNodeSetParams: return "hipGraphExternalSemaphoresSignalNodeSetParams";
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeGetParams: return "hipGraphExternalSemaphoresWaitNodeGetParams";
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeSetParams: return "hipGraphExternalSemaphoresWaitNodeSetParams";
|
|
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_hipGraphInstantiateWithParams: return "hipGraphInstantiateWithParams";
|
|
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_hipGraphNodeSetParams: return "hipGraphNodeSetParams";
|
|
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_hipLaunchKernelExC: return "hipLaunchKernelExC";
|
|
case HIP_API_ID_hipLinkAddData: return "hipLinkAddData";
|
|
case HIP_API_ID_hipLinkAddFile: return "hipLinkAddFile";
|
|
case HIP_API_ID_hipLinkComplete: return "hipLinkComplete";
|
|
case HIP_API_ID_hipLinkCreate: return "hipLinkCreate";
|
|
case HIP_API_ID_hipLinkDestroy: return "hipLinkDestroy";
|
|
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_hipMemcpy2DArrayToArray: return "hipMemcpy2DArrayToArray";
|
|
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_hipMemcpyAtoA: return "hipMemcpyAtoA";
|
|
case HIP_API_ID_hipMemcpyAtoD: return "hipMemcpyAtoD";
|
|
case HIP_API_ID_hipMemcpyAtoH: return "hipMemcpyAtoH";
|
|
case HIP_API_ID_hipMemcpyAtoHAsync: return "hipMemcpyAtoHAsync";
|
|
case HIP_API_ID_hipMemcpyDtoA: return "hipMemcpyDtoA";
|
|
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_hipMemcpyHtoAAsync: return "hipMemcpyHtoAAsync";
|
|
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_hipSetValidDevices: return "hipSetValidDevices";
|
|
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_hipStreamBatchMemOp: return "hipStreamBatchMemOp";
|
|
case HIP_API_ID_hipStreamBeginCapture: return "hipStreamBeginCapture";
|
|
case HIP_API_ID_hipStreamBeginCaptureToGraph: return "hipStreamBeginCaptureToGraph";
|
|
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_hipStreamGetDevice: return "hipStreamGetDevice";
|
|
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_hipTexRefGetArray: return "hipTexRefGetArray";
|
|
case HIP_API_ID_hipTexRefGetBorderColor: return "hipTexRefGetBorderColor";
|
|
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("hipArray3DGetDescriptor", name) == 0) return HIP_API_ID_hipArray3DGetDescriptor;
|
|
if (strcmp("hipArrayCreate", name) == 0) return HIP_API_ID_hipArrayCreate;
|
|
if (strcmp("hipArrayDestroy", name) == 0) return HIP_API_ID_hipArrayDestroy;
|
|
if (strcmp("hipArrayGetDescriptor", name) == 0) return HIP_API_ID_hipArrayGetDescriptor;
|
|
if (strcmp("hipArrayGetInfo", name) == 0) return HIP_API_ID_hipArrayGetInfo;
|
|
if (strcmp("hipChooseDeviceR0000", name) == 0) return HIP_API_ID_hipChooseDeviceR0000;
|
|
if (strcmp("hipChooseDeviceR0600", name) == 0) return HIP_API_ID_hipChooseDeviceR0600;
|
|
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("hipDrvGraphAddMemFreeNode", name) == 0) return HIP_API_ID_hipDrvGraphAddMemFreeNode;
|
|
if (strcmp("hipDrvGraphAddMemcpyNode", name) == 0) return HIP_API_ID_hipDrvGraphAddMemcpyNode;
|
|
if (strcmp("hipDrvGraphAddMemsetNode", name) == 0) return HIP_API_ID_hipDrvGraphAddMemsetNode;
|
|
if (strcmp("hipDrvGraphExecMemcpyNodeSetParams", name) == 0) return HIP_API_ID_hipDrvGraphExecMemcpyNodeSetParams;
|
|
if (strcmp("hipDrvGraphExecMemsetNodeSetParams", name) == 0) return HIP_API_ID_hipDrvGraphExecMemsetNodeSetParams;
|
|
if (strcmp("hipDrvGraphMemcpyNodeGetParams", name) == 0) return HIP_API_ID_hipDrvGraphMemcpyNodeGetParams;
|
|
if (strcmp("hipDrvGraphMemcpyNodeSetParams", name) == 0) return HIP_API_ID_hipDrvGraphMemcpyNodeSetParams;
|
|
if (strcmp("hipDrvLaunchKernelEx", name) == 0) return HIP_API_ID_hipDrvLaunchKernelEx;
|
|
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("hipEventRecordWithFlags", name) == 0) return HIP_API_ID_hipEventRecordWithFlags;
|
|
if (strcmp("hipEventSynchronize", name) == 0) return HIP_API_ID_hipEventSynchronize;
|
|
if (strcmp("hipExtGetLastError", name) == 0) return HIP_API_ID_hipExtGetLastError;
|
|
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("hipExternalMemoryGetMappedMipmappedArray", name) == 0) return HIP_API_ID_hipExternalMemoryGetMappedMipmappedArray;
|
|
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("hipGetDevicePropertiesR0000", name) == 0) return HIP_API_ID_hipGetDevicePropertiesR0000;
|
|
if (strcmp("hipGetDevicePropertiesR0600", name) == 0) return HIP_API_ID_hipGetDevicePropertiesR0600;
|
|
if (strcmp("hipGetErrorString", name) == 0) return HIP_API_ID_hipGetErrorString;
|
|
if (strcmp("hipGetFuncBySymbol", name) == 0) return HIP_API_ID_hipGetFuncBySymbol;
|
|
if (strcmp("hipGetLastError", name) == 0) return HIP_API_ID_hipGetLastError;
|
|
if (strcmp("hipGetMipmappedArrayLevel", name) == 0) return HIP_API_ID_hipGetMipmappedArrayLevel;
|
|
if (strcmp("hipGetProcAddress", name) == 0) return HIP_API_ID_hipGetProcAddress;
|
|
if (strcmp("hipGetSymbolAddress", name) == 0) return HIP_API_ID_hipGetSymbolAddress;
|
|
if (strcmp("hipGetSymbolSize", name) == 0) return HIP_API_ID_hipGetSymbolSize;
|
|
if (strcmp("hipGraphAddBatchMemOpNode", name) == 0) return HIP_API_ID_hipGraphAddBatchMemOpNode;
|
|
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("hipGraphAddExternalSemaphoresSignalNode", name) == 0) return HIP_API_ID_hipGraphAddExternalSemaphoresSignalNode;
|
|
if (strcmp("hipGraphAddExternalSemaphoresWaitNode", name) == 0) return HIP_API_ID_hipGraphAddExternalSemaphoresWaitNode;
|
|
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("hipGraphAddNode", name) == 0) return HIP_API_ID_hipGraphAddNode;
|
|
if (strcmp("hipGraphBatchMemOpNodeGetParams", name) == 0) return HIP_API_ID_hipGraphBatchMemOpNodeGetParams;
|
|
if (strcmp("hipGraphBatchMemOpNodeSetParams", name) == 0) return HIP_API_ID_hipGraphBatchMemOpNodeSetParams;
|
|
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("hipGraphExecBatchMemOpNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecBatchMemOpNodeSetParams;
|
|
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("hipGraphExecExternalSemaphoresSignalNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecExternalSemaphoresSignalNodeSetParams;
|
|
if (strcmp("hipGraphExecExternalSemaphoresWaitNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecExternalSemaphoresWaitNodeSetParams;
|
|
if (strcmp("hipGraphExecGetFlags", name) == 0) return HIP_API_ID_hipGraphExecGetFlags;
|
|
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("hipGraphExecNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExecNodeSetParams;
|
|
if (strcmp("hipGraphExecUpdate", name) == 0) return HIP_API_ID_hipGraphExecUpdate;
|
|
if (strcmp("hipGraphExternalSemaphoresSignalNodeGetParams", name) == 0) return HIP_API_ID_hipGraphExternalSemaphoresSignalNodeGetParams;
|
|
if (strcmp("hipGraphExternalSemaphoresSignalNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExternalSemaphoresSignalNodeSetParams;
|
|
if (strcmp("hipGraphExternalSemaphoresWaitNodeGetParams", name) == 0) return HIP_API_ID_hipGraphExternalSemaphoresWaitNodeGetParams;
|
|
if (strcmp("hipGraphExternalSemaphoresWaitNodeSetParams", name) == 0) return HIP_API_ID_hipGraphExternalSemaphoresWaitNodeSetParams;
|
|
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("hipGraphInstantiateWithParams", name) == 0) return HIP_API_ID_hipGraphInstantiateWithParams;
|
|
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("hipGraphNodeSetParams", name) == 0) return HIP_API_ID_hipGraphNodeSetParams;
|
|
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("hipLaunchKernelExC", name) == 0) return HIP_API_ID_hipLaunchKernelExC;
|
|
if (strcmp("hipLinkAddData", name) == 0) return HIP_API_ID_hipLinkAddData;
|
|
if (strcmp("hipLinkAddFile", name) == 0) return HIP_API_ID_hipLinkAddFile;
|
|
if (strcmp("hipLinkComplete", name) == 0) return HIP_API_ID_hipLinkComplete;
|
|
if (strcmp("hipLinkCreate", name) == 0) return HIP_API_ID_hipLinkCreate;
|
|
if (strcmp("hipLinkDestroy", name) == 0) return HIP_API_ID_hipLinkDestroy;
|
|
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("hipMemcpy2DArrayToArray", name) == 0) return HIP_API_ID_hipMemcpy2DArrayToArray;
|
|
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("hipMemcpyAtoA", name) == 0) return HIP_API_ID_hipMemcpyAtoA;
|
|
if (strcmp("hipMemcpyAtoD", name) == 0) return HIP_API_ID_hipMemcpyAtoD;
|
|
if (strcmp("hipMemcpyAtoH", name) == 0) return HIP_API_ID_hipMemcpyAtoH;
|
|
if (strcmp("hipMemcpyAtoHAsync", name) == 0) return HIP_API_ID_hipMemcpyAtoHAsync;
|
|
if (strcmp("hipMemcpyDtoA", name) == 0) return HIP_API_ID_hipMemcpyDtoA;
|
|
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("hipMemcpyHtoAAsync", name) == 0) return HIP_API_ID_hipMemcpyHtoAAsync;
|
|
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("hipSetValidDevices", name) == 0) return HIP_API_ID_hipSetValidDevices;
|
|
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("hipStreamBatchMemOp", name) == 0) return HIP_API_ID_hipStreamBatchMemOp;
|
|
if (strcmp("hipStreamBeginCapture", name) == 0) return HIP_API_ID_hipStreamBeginCapture;
|
|
if (strcmp("hipStreamBeginCaptureToGraph", name) == 0) return HIP_API_ID_hipStreamBeginCaptureToGraph;
|
|
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("hipStreamGetDevice", name) == 0) return HIP_API_ID_hipStreamGetDevice;
|
|
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("hipTexRefGetArray", name) == 0) return HIP_API_ID_hipTexRefGetArray;
|
|
if (strcmp("hipTexRefGetBorderColor", name) == 0) return HIP_API_ID_hipTexRefGetBorderColor;
|
|
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_t* array;
|
|
hipArray_t array__val;
|
|
const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray;
|
|
HIP_ARRAY3D_DESCRIPTOR pAllocateArray__val;
|
|
} hipArray3DCreate;
|
|
struct {
|
|
HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor;
|
|
HIP_ARRAY3D_DESCRIPTOR pArrayDescriptor__val;
|
|
hipArray_t array;
|
|
} hipArray3DGetDescriptor;
|
|
struct {
|
|
hipArray_t* pHandle;
|
|
hipArray_t pHandle__val;
|
|
const HIP_ARRAY_DESCRIPTOR* pAllocateArray;
|
|
HIP_ARRAY_DESCRIPTOR pAllocateArray__val;
|
|
} hipArrayCreate;
|
|
struct {
|
|
hipArray_t array;
|
|
} hipArrayDestroy;
|
|
struct {
|
|
HIP_ARRAY_DESCRIPTOR* pArrayDescriptor;
|
|
HIP_ARRAY_DESCRIPTOR pArrayDescriptor__val;
|
|
hipArray_t array;
|
|
} hipArrayGetDescriptor;
|
|
struct {
|
|
hipChannelFormatDesc* desc;
|
|
hipChannelFormatDesc desc__val;
|
|
hipExtent* extent;
|
|
hipExtent extent__val;
|
|
unsigned int* flags;
|
|
unsigned int flags__val;
|
|
hipArray_t array;
|
|
} hipArrayGetInfo;
|
|
struct {
|
|
int* device;
|
|
int device__val;
|
|
const hipDeviceProp_tR0000* prop;
|
|
hipDeviceProp_tR0000 prop__val;
|
|
} hipChooseDeviceR0000;
|
|
struct {
|
|
int* device;
|
|
int device__val;
|
|
const hipDeviceProp_tR0600* prop;
|
|
hipDeviceProp_tR0600 prop__val;
|
|
} hipChooseDeviceR0600;
|
|
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 {
|
|
hipGraphNode_t* phGraphNode;
|
|
hipGraphNode_t phGraphNode__val;
|
|
hipGraph_t hGraph;
|
|
const hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
size_t numDependencies;
|
|
hipDeviceptr_t dptr;
|
|
} hipDrvGraphAddMemFreeNode;
|
|
struct {
|
|
hipGraphNode_t* phGraphNode;
|
|
hipGraphNode_t phGraphNode__val;
|
|
hipGraph_t hGraph;
|
|
const hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
size_t numDependencies;
|
|
const HIP_MEMCPY3D* copyParams;
|
|
HIP_MEMCPY3D copyParams__val;
|
|
hipCtx_t ctx;
|
|
} hipDrvGraphAddMemcpyNode;
|
|
struct {
|
|
hipGraphNode_t* phGraphNode;
|
|
hipGraphNode_t phGraphNode__val;
|
|
hipGraph_t hGraph;
|
|
const hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
size_t numDependencies;
|
|
const HIP_MEMSET_NODE_PARAMS* memsetParams;
|
|
HIP_MEMSET_NODE_PARAMS memsetParams__val;
|
|
hipCtx_t ctx;
|
|
} hipDrvGraphAddMemsetNode;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
const HIP_MEMCPY3D* copyParams;
|
|
HIP_MEMCPY3D copyParams__val;
|
|
hipCtx_t ctx;
|
|
} hipDrvGraphExecMemcpyNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
const HIP_MEMSET_NODE_PARAMS* memsetParams;
|
|
HIP_MEMSET_NODE_PARAMS memsetParams__val;
|
|
hipCtx_t ctx;
|
|
} hipDrvGraphExecMemsetNodeSetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
HIP_MEMCPY3D* nodeParams;
|
|
HIP_MEMCPY3D nodeParams__val;
|
|
} hipDrvGraphMemcpyNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
const HIP_MEMCPY3D* nodeParams;
|
|
HIP_MEMCPY3D nodeParams__val;
|
|
} hipDrvGraphMemcpyNodeSetParams;
|
|
struct {
|
|
const HIP_LAUNCH_CONFIG* config;
|
|
HIP_LAUNCH_CONFIG config__val;
|
|
hipFunction_t f;
|
|
void** params;
|
|
void* params__val;
|
|
void** extra;
|
|
void* extra__val;
|
|
} hipDrvLaunchKernelEx;
|
|
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;
|
|
hipStream_t stream;
|
|
unsigned int flags;
|
|
} hipEventRecordWithFlags;
|
|
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 {
|
|
hipMipmappedArray_t* mipmap;
|
|
hipMipmappedArray_t mipmap__val;
|
|
hipExternalMemory_t extMem;
|
|
const hipExternalMemoryMipmappedArrayDesc* mipmapDesc;
|
|
hipExternalMemoryMipmappedArrayDesc mipmapDesc__val;
|
|
} hipExternalMemoryGetMappedMipmappedArray;
|
|
struct {
|
|
void* ptr;
|
|
} hipFree;
|
|
struct {
|
|
hipArray_t array;
|
|
} 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_tR0000* prop;
|
|
hipDeviceProp_tR0000 prop__val;
|
|
int device;
|
|
} hipGetDevicePropertiesR0000;
|
|
struct {
|
|
hipDeviceProp_tR0600* prop;
|
|
hipDeviceProp_tR0600 prop__val;
|
|
int deviceId;
|
|
} hipGetDevicePropertiesR0600;
|
|
struct {
|
|
hipFunction_t* functionPtr;
|
|
hipFunction_t functionPtr__val;
|
|
const void* symbolPtr;
|
|
} hipGetFuncBySymbol;
|
|
struct {
|
|
hipArray_t* levelArray;
|
|
hipArray_t levelArray__val;
|
|
hipMipmappedArray_const_t mipmappedArray;
|
|
unsigned int level;
|
|
} hipGetMipmappedArrayLevel;
|
|
struct {
|
|
const char* symbol;
|
|
char symbol__val;
|
|
void** pfn;
|
|
void* pfn__val;
|
|
int hipVersion;
|
|
uint64_t flags;
|
|
hipDriverProcAddressQueryResult* symbolStatus;
|
|
hipDriverProcAddressQueryResult symbolStatus__val;
|
|
} hipGetProcAddress;
|
|
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* phGraphNode;
|
|
hipGraphNode_t phGraphNode__val;
|
|
hipGraph_t hGraph;
|
|
const hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
size_t numDependencies;
|
|
const hipBatchMemOpNodeParams* nodeParams;
|
|
hipBatchMemOpNodeParams nodeParams__val;
|
|
} hipGraphAddBatchMemOpNode;
|
|
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 hipExternalSemaphoreSignalNodeParams* nodeParams;
|
|
hipExternalSemaphoreSignalNodeParams nodeParams__val;
|
|
} hipGraphAddExternalSemaphoresSignalNode;
|
|
struct {
|
|
hipGraphNode_t* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
const hipExternalSemaphoreWaitNodeParams* nodeParams;
|
|
hipExternalSemaphoreWaitNodeParams nodeParams__val;
|
|
} hipGraphAddExternalSemaphoresWaitNode;
|
|
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* pGraphNode;
|
|
hipGraphNode_t pGraphNode__val;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* pDependencies;
|
|
hipGraphNode_t pDependencies__val;
|
|
size_t numDependencies;
|
|
hipGraphNodeParams* nodeParams;
|
|
hipGraphNodeParams nodeParams__val;
|
|
} hipGraphAddNode;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipBatchMemOpNodeParams* nodeParams_out;
|
|
hipBatchMemOpNodeParams nodeParams_out__val;
|
|
} hipGraphBatchMemOpNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipBatchMemOpNodeParams* nodeParams;
|
|
hipBatchMemOpNodeParams nodeParams__val;
|
|
} hipGraphBatchMemOpNodeSetParams;
|
|
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 hNode;
|
|
const hipBatchMemOpNodeParams* nodeParams;
|
|
hipBatchMemOpNodeParams nodeParams__val;
|
|
} hipGraphExecBatchMemOpNodeSetParams;
|
|
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 hNode;
|
|
const hipExternalSemaphoreSignalNodeParams* nodeParams;
|
|
hipExternalSemaphoreSignalNodeParams nodeParams__val;
|
|
} hipGraphExecExternalSemaphoresSignalNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t hGraphExec;
|
|
hipGraphNode_t hNode;
|
|
const hipExternalSemaphoreWaitNodeParams* nodeParams;
|
|
hipExternalSemaphoreWaitNodeParams nodeParams__val;
|
|
} hipGraphExecExternalSemaphoresWaitNodeSetParams;
|
|
struct {
|
|
hipGraphExec_t graphExec;
|
|
unsigned long long* flags;
|
|
unsigned long long flags__val;
|
|
} hipGraphExecGetFlags;
|
|
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 graphExec;
|
|
hipGraphNode_t node;
|
|
hipGraphNodeParams* nodeParams;
|
|
hipGraphNodeParams nodeParams__val;
|
|
} hipGraphExecNodeSetParams;
|
|
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 {
|
|
hipGraphNode_t hNode;
|
|
hipExternalSemaphoreSignalNodeParams* params_out;
|
|
hipExternalSemaphoreSignalNodeParams params_out__val;
|
|
} hipGraphExternalSemaphoresSignalNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
const hipExternalSemaphoreSignalNodeParams* nodeParams;
|
|
hipExternalSemaphoreSignalNodeParams nodeParams__val;
|
|
} hipGraphExternalSemaphoresSignalNodeSetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipExternalSemaphoreWaitNodeParams* params_out;
|
|
hipExternalSemaphoreWaitNodeParams params_out__val;
|
|
} hipGraphExternalSemaphoresWaitNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
const hipExternalSemaphoreWaitNodeParams* nodeParams;
|
|
hipExternalSemaphoreWaitNodeParams nodeParams__val;
|
|
} hipGraphExternalSemaphoresWaitNodeSetParams;
|
|
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 {
|
|
hipGraphExec_t* pGraphExec;
|
|
hipGraphExec_t pGraphExec__val;
|
|
hipGraph_t graph;
|
|
hipGraphInstantiateParams* instantiateParams;
|
|
hipGraphInstantiateParams instantiateParams__val;
|
|
} hipGraphInstantiateWithParams;
|
|
struct {
|
|
hipGraphNode_t hSrc;
|
|
hipGraphNode_t hDst;
|
|
} hipGraphKernelNodeCopyAttributes;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipLaunchAttributeID attr;
|
|
hipLaunchAttributeValue* value;
|
|
hipLaunchAttributeValue value__val;
|
|
} hipGraphKernelNodeGetAttribute;
|
|
struct {
|
|
hipGraphNode_t node;
|
|
hipKernelNodeParams* pNodeParams;
|
|
hipKernelNodeParams pNodeParams__val;
|
|
} hipGraphKernelNodeGetParams;
|
|
struct {
|
|
hipGraphNode_t hNode;
|
|
hipLaunchAttributeID attr;
|
|
const hipLaunchAttributeValue* value;
|
|
hipLaunchAttributeValue 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 {
|
|
hipGraphNode_t node;
|
|
hipGraphNodeParams* nodeParams;
|
|
hipGraphNodeParams nodeParams__val;
|
|
} hipGraphNodeSetParams;
|
|
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 {
|
|
const hipLaunchConfig_t* config;
|
|
hipLaunchConfig_t config__val;
|
|
const void* fPtr;
|
|
void** args;
|
|
void* args__val;
|
|
} hipLaunchKernelExC;
|
|
struct {
|
|
hipLinkState_t state;
|
|
hipJitInputType type;
|
|
void* data;
|
|
size_t size;
|
|
const char* name;
|
|
char name__val;
|
|
unsigned int numOptions;
|
|
hipJitOption* options;
|
|
hipJitOption options__val;
|
|
void** optionValues;
|
|
void* optionValues__val;
|
|
} hipLinkAddData;
|
|
struct {
|
|
hipLinkState_t state;
|
|
hipJitInputType type;
|
|
const char* path;
|
|
char path__val;
|
|
unsigned int numOptions;
|
|
hipJitOption* options;
|
|
hipJitOption options__val;
|
|
void** optionValues;
|
|
void* optionValues__val;
|
|
} hipLinkAddFile;
|
|
struct {
|
|
hipLinkState_t state;
|
|
void** hipBinOut;
|
|
void* hipBinOut__val;
|
|
size_t* sizeOut;
|
|
size_t sizeOut__val;
|
|
} hipLinkComplete;
|
|
struct {
|
|
unsigned int numOptions;
|
|
hipJitOption* options;
|
|
hipJitOption options__val;
|
|
void** optionValues;
|
|
void* optionValues__val;
|
|
hipLinkState_t* stateOut;
|
|
hipLinkState_t stateOut__val;
|
|
} hipLinkCreate;
|
|
struct {
|
|
hipLinkState_t state;
|
|
} hipLinkDestroy;
|
|
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_t* array;
|
|
hipArray_t 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 {
|
|
hipArray_t dst;
|
|
size_t wOffsetDst;
|
|
size_t hOffsetDst;
|
|
hipArray_const_t src;
|
|
size_t wOffsetSrc;
|
|
size_t hOffsetSrc;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy2DArrayToArray;
|
|
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_t dst;
|
|
size_t wOffset;
|
|
size_t hOffset;
|
|
const void* src;
|
|
size_t spitch;
|
|
size_t width;
|
|
size_t height;
|
|
hipMemcpyKind kind;
|
|
} hipMemcpy2DToArray;
|
|
struct {
|
|
hipArray_t dst;
|
|
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 {
|
|
hipArray_t dstArray;
|
|
size_t dstOffset;
|
|
hipArray_t srcArray;
|
|
size_t srcOffset;
|
|
size_t ByteCount;
|
|
} hipMemcpyAtoA;
|
|
struct {
|
|
hipDeviceptr_t dstDevice;
|
|
hipArray_t srcArray;
|
|
size_t srcOffset;
|
|
size_t ByteCount;
|
|
} hipMemcpyAtoD;
|
|
struct {
|
|
void* dst;
|
|
hipArray_t srcArray;
|
|
size_t srcOffset;
|
|
size_t count;
|
|
} hipMemcpyAtoH;
|
|
struct {
|
|
void* dstHost;
|
|
hipArray_t srcArray;
|
|
size_t srcOffset;
|
|
size_t ByteCount;
|
|
hipStream_t stream;
|
|
} hipMemcpyAtoHAsync;
|
|
struct {
|
|
hipArray_t dstArray;
|
|
size_t dstOffset;
|
|
hipDeviceptr_t srcDevice;
|
|
size_t ByteCount;
|
|
} hipMemcpyDtoA;
|
|
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_t dstArray;
|
|
size_t dstOffset;
|
|
const void* srcHost;
|
|
size_t count;
|
|
} hipMemcpyHtoA;
|
|
struct {
|
|
hipArray_t dstArray;
|
|
size_t dstOffset;
|
|
const void* srcHost;
|
|
size_t ByteCount;
|
|
hipStream_t stream;
|
|
} hipMemcpyHtoAAsync;
|
|
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_t dst;
|
|
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 {
|
|
int* device_arr;
|
|
int device_arr__val;
|
|
int len;
|
|
} hipSetValidDevices;
|
|
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;
|
|
unsigned int count;
|
|
hipStreamBatchMemOpParams* paramArray;
|
|
hipStreamBatchMemOpParams paramArray__val;
|
|
unsigned int flags;
|
|
} hipStreamBatchMemOp;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipStreamCaptureMode mode;
|
|
} hipStreamBeginCapture;
|
|
struct {
|
|
hipStream_t stream;
|
|
hipGraph_t graph;
|
|
const hipGraphNode_t* dependencies;
|
|
hipGraphNode_t dependencies__val;
|
|
const hipGraphEdgeData* dependencyData;
|
|
hipGraphEdgeData dependencyData__val;
|
|
size_t numDependencies;
|
|
hipStreamCaptureMode mode;
|
|
} hipStreamBeginCaptureToGraph;
|
|
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;
|
|
hipDevice_t* device;
|
|
hipDevice_t device__val;
|
|
} hipStreamGetDevice;
|
|
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 {
|
|
hipArray_t* pArray;
|
|
hipArray_t pArray__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetArray;
|
|
struct {
|
|
float* pBorderColor;
|
|
float pBorderColor__val;
|
|
const textureReference* texRef;
|
|
textureReference texRef__val;
|
|
} hipTexRefGetBorderColor;
|
|
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_t*', 'array'), ('const HIP_ARRAY3D_DESCRIPTOR*', 'pAllocateArray')]
|
|
#define INIT_hipArray3DCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArray3DCreate.array = (hipArray_t*)array; \
|
|
cb_data.args.hipArray3DCreate.pAllocateArray = (const HIP_ARRAY3D_DESCRIPTOR*)pAllocateArray; \
|
|
};
|
|
// hipArray3DGetDescriptor[('HIP_ARRAY3D_DESCRIPTOR*', 'pArrayDescriptor'), ('hipArray_t', 'array')]
|
|
#define INIT_hipArray3DGetDescriptor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArray3DGetDescriptor.pArrayDescriptor = (HIP_ARRAY3D_DESCRIPTOR*)pArrayDescriptor; \
|
|
cb_data.args.hipArray3DGetDescriptor.array = (hipArray_t)array; \
|
|
};
|
|
// hipArrayCreate[('hipArray_t*', 'pHandle'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
|
|
#define INIT_hipArrayCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayCreate.pHandle = (hipArray_t*)array; \
|
|
cb_data.args.hipArrayCreate.pAllocateArray = (const HIP_ARRAY_DESCRIPTOR*)pAllocateArray; \
|
|
};
|
|
// hipArrayDestroy[('hipArray_t', 'array')]
|
|
#define INIT_hipArrayDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayDestroy.array = (hipArray_t)array; \
|
|
};
|
|
// hipArrayGetDescriptor[('HIP_ARRAY_DESCRIPTOR*', 'pArrayDescriptor'), ('hipArray_t', 'array')]
|
|
#define INIT_hipArrayGetDescriptor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayGetDescriptor.pArrayDescriptor = (HIP_ARRAY_DESCRIPTOR*)pArrayDescriptor; \
|
|
cb_data.args.hipArrayGetDescriptor.array = (hipArray_t)array; \
|
|
};
|
|
// hipArrayGetInfo[('hipChannelFormatDesc*', 'desc'), ('hipExtent*', 'extent'), ('unsigned int*', 'flags'), ('hipArray_t', 'array')]
|
|
#define INIT_hipArrayGetInfo_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipArrayGetInfo.desc = (hipChannelFormatDesc*)desc; \
|
|
cb_data.args.hipArrayGetInfo.extent = (hipExtent*)extent; \
|
|
cb_data.args.hipArrayGetInfo.flags = (unsigned int*)flags; \
|
|
cb_data.args.hipArrayGetInfo.array = (hipArray_t)array; \
|
|
};
|
|
// hipChooseDeviceR0000[('int*', 'device'), ('const hipDeviceProp_tR0000*', 'prop')]
|
|
#define INIT_hipChooseDeviceR0000_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipChooseDeviceR0000.device = (int*)device; \
|
|
cb_data.args.hipChooseDeviceR0000.prop = (const hipDeviceProp_tR0000*)properties; \
|
|
};
|
|
// hipChooseDeviceR0600[('int*', 'device'), ('const hipDeviceProp_tR0600*', 'prop')]
|
|
#define INIT_hipChooseDeviceR0600_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipChooseDeviceR0600.device = (int*)device; \
|
|
cb_data.args.hipChooseDeviceR0600.prop = (const hipDeviceProp_tR0600*)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; \
|
|
};
|
|
// hipDrvGraphAddMemFreeNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('hipDeviceptr_t', 'dptr')]
|
|
#define INIT_hipDrvGraphAddMemFreeNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphAddMemFreeNode.phGraphNode = (hipGraphNode_t*)phGraphNode; \
|
|
cb_data.args.hipDrvGraphAddMemFreeNode.hGraph = (hipGraph_t)hGraph; \
|
|
cb_data.args.hipDrvGraphAddMemFreeNode.dependencies = (const hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipDrvGraphAddMemFreeNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipDrvGraphAddMemFreeNode.dptr = (hipDeviceptr_t)dptr; \
|
|
};
|
|
// hipDrvGraphAddMemcpyNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const HIP_MEMCPY3D*', 'copyParams'), ('hipCtx_t', 'ctx')]
|
|
#define INIT_hipDrvGraphAddMemcpyNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.phGraphNode = (hipGraphNode_t*)phGraphNode; \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.hGraph = (hipGraph_t)hGraph; \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.dependencies = (const hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.copyParams = (const HIP_MEMCPY3D*)copyParams; \
|
|
cb_data.args.hipDrvGraphAddMemcpyNode.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipDrvGraphAddMemsetNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const HIP_MEMSET_NODE_PARAMS*', 'memsetParams'), ('hipCtx_t', 'ctx')]
|
|
#define INIT_hipDrvGraphAddMemsetNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.phGraphNode = (hipGraphNode_t*)phGraphNode; \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.hGraph = (hipGraph_t)hGraph; \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.dependencies = (const hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.memsetParams = (const HIP_MEMSET_NODE_PARAMS*)memsetParams; \
|
|
cb_data.args.hipDrvGraphAddMemsetNode.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipDrvGraphExecMemcpyNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const HIP_MEMCPY3D*', 'copyParams'), ('hipCtx_t', 'ctx')]
|
|
#define INIT_hipDrvGraphExecMemcpyNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphExecMemcpyNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipDrvGraphExecMemcpyNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipDrvGraphExecMemcpyNodeSetParams.copyParams = (const HIP_MEMCPY3D*)copyParams; \
|
|
cb_data.args.hipDrvGraphExecMemcpyNodeSetParams.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipDrvGraphExecMemsetNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const HIP_MEMSET_NODE_PARAMS*', 'memsetParams'), ('hipCtx_t', 'ctx')]
|
|
#define INIT_hipDrvGraphExecMemsetNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphExecMemsetNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipDrvGraphExecMemsetNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipDrvGraphExecMemsetNodeSetParams.memsetParams = (const HIP_MEMSET_NODE_PARAMS*)memsetParams; \
|
|
cb_data.args.hipDrvGraphExecMemsetNodeSetParams.ctx = (hipCtx_t)ctx; \
|
|
};
|
|
// hipDrvGraphMemcpyNodeGetParams[('hipGraphNode_t', 'hNode'), ('HIP_MEMCPY3D*', 'nodeParams')]
|
|
#define INIT_hipDrvGraphMemcpyNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphMemcpyNodeGetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipDrvGraphMemcpyNodeGetParams.nodeParams = (HIP_MEMCPY3D*)nodeParams; \
|
|
};
|
|
// hipDrvGraphMemcpyNodeSetParams[('hipGraphNode_t', 'hNode'), ('const HIP_MEMCPY3D*', 'nodeParams')]
|
|
#define INIT_hipDrvGraphMemcpyNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvGraphMemcpyNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipDrvGraphMemcpyNodeSetParams.nodeParams = (const HIP_MEMCPY3D*)nodeParams; \
|
|
};
|
|
// hipDrvLaunchKernelEx[('const HIP_LAUNCH_CONFIG*', 'config'), ('hipFunction_t', 'f'), ('void**', 'params'), ('void**', 'extra')]
|
|
#define INIT_hipDrvLaunchKernelEx_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipDrvLaunchKernelEx.config = (const HIP_LAUNCH_CONFIG*)config; \
|
|
cb_data.args.hipDrvLaunchKernelEx.f = (hipFunction_t)f; \
|
|
cb_data.args.hipDrvLaunchKernelEx.params = (void**)kernelParams; \
|
|
cb_data.args.hipDrvLaunchKernelEx.extra = (void**)extra; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipEventRecordWithFlags[('hipEvent_t', 'event'), ('hipStream_t', 'stream'), ('unsigned int', 'flags')]
|
|
#define INIT_hipEventRecordWithFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventRecordWithFlags.event = (hipEvent_t)event; \
|
|
cb_data.args.hipEventRecordWithFlags.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipEventRecordWithFlags.flags = (unsigned int)flags; \
|
|
};
|
|
// hipEventSynchronize[('hipEvent_t', 'event')]
|
|
#define INIT_hipEventSynchronize_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipEventSynchronize.event = (hipEvent_t)event; \
|
|
};
|
|
// hipExtGetLastError[]
|
|
#define INIT_hipExtGetLastError_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipExternalMemoryGetMappedMipmappedArray[('hipMipmappedArray_t*', 'mipmap'), ('hipExternalMemory_t', 'extMem'), ('const hipExternalMemoryMipmappedArrayDesc*', 'mipmapDesc')]
|
|
#define INIT_hipExternalMemoryGetMappedMipmappedArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipExternalMemoryGetMappedMipmappedArray.mipmap = (hipMipmappedArray_t*)mipmap; \
|
|
cb_data.args.hipExternalMemoryGetMappedMipmappedArray.extMem = (hipExternalMemory_t)extMem; \
|
|
cb_data.args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc = (const hipExternalMemoryMipmappedArrayDesc*)mipmapDesc; \
|
|
};
|
|
// hipFree[('void*', 'ptr')]
|
|
#define INIT_hipFree_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFree.ptr = (void*)ptr; \
|
|
};
|
|
// hipFreeArray[('hipArray_t', 'array')]
|
|
#define INIT_hipFreeArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipFreeArray.array = (hipArray_t)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; \
|
|
};
|
|
// hipGetDevicePropertiesR0000[('hipDeviceProp_tR0000*', 'prop'), ('int', 'device')]
|
|
#define INIT_hipGetDevicePropertiesR0000_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDevicePropertiesR0000.prop = (hipDeviceProp_tR0000*)prop; \
|
|
cb_data.args.hipGetDevicePropertiesR0000.device = (int)device; \
|
|
};
|
|
// hipGetDevicePropertiesR0600[('hipDeviceProp_tR0600*', 'prop'), ('int', 'deviceId')]
|
|
#define INIT_hipGetDevicePropertiesR0600_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetDevicePropertiesR0600.prop = (hipDeviceProp_tR0600*)prop; \
|
|
cb_data.args.hipGetDevicePropertiesR0600.deviceId = (int)device; \
|
|
};
|
|
// hipGetErrorString[]
|
|
#define INIT_hipGetErrorString_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// hipGetFuncBySymbol[('hipFunction_t*', 'functionPtr'), ('const void*', 'symbolPtr')]
|
|
#define INIT_hipGetFuncBySymbol_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetFuncBySymbol.functionPtr = (hipFunction_t*)functionPtr; \
|
|
cb_data.args.hipGetFuncBySymbol.symbolPtr = (const void*)symbolPtr; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGetProcAddress[('const char*', 'symbol'), ('void**', 'pfn'), ('int', 'hipVersion'), ('uint64_t', 'flags'), ('hipDriverProcAddressQueryResult*', 'symbolStatus')]
|
|
#define INIT_hipGetProcAddress_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGetProcAddress.symbol = (symbol) ? strdup(symbol) : NULL; \
|
|
cb_data.args.hipGetProcAddress.pfn = (void**)pfn; \
|
|
cb_data.args.hipGetProcAddress.hipVersion = (int)hipVersion; \
|
|
cb_data.args.hipGetProcAddress.flags = (uint64_t)flags; \
|
|
cb_data.args.hipGetProcAddress.symbolStatus = (hipDriverProcAddressQueryResult*)symbolStatus; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphAddBatchMemOpNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphAddBatchMemOpNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddBatchMemOpNode.phGraphNode = (hipGraphNode_t*)phGraphNode; \
|
|
cb_data.args.hipGraphAddBatchMemOpNode.hGraph = (hipGraph_t)hGraph; \
|
|
cb_data.args.hipGraphAddBatchMemOpNode.dependencies = (const hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipGraphAddBatchMemOpNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddBatchMemOpNode.nodeParams = (const hipBatchMemOpNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphAddExternalSemaphoresSignalNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphAddExternalSemaphoresSignalNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresSignalNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresSignalNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresSignalNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresSignalNode.nodeParams = (const hipExternalSemaphoreSignalNodeParams*)nodeParams; \
|
|
};
|
|
// hipGraphAddExternalSemaphoresWaitNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphAddExternalSemaphoresWaitNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresWaitNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresWaitNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresWaitNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddExternalSemaphoresWaitNode.nodeParams = (const hipExternalSemaphoreWaitNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphAddNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphAddNode_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphAddNode.pGraphNode = (hipGraphNode_t*)pGraphNode; \
|
|
cb_data.args.hipGraphAddNode.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphAddNode.pDependencies = (const hipGraphNode_t*)pDependencies; \
|
|
cb_data.args.hipGraphAddNode.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipGraphAddNode.nodeParams = (hipGraphNodeParams*)nodeParams; \
|
|
};
|
|
// hipGraphBatchMemOpNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipBatchMemOpNodeParams*', 'nodeParams_out')]
|
|
#define INIT_hipGraphBatchMemOpNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphBatchMemOpNodeGetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphBatchMemOpNodeGetParams.nodeParams_out = (hipBatchMemOpNodeParams*)nodeParams_out; \
|
|
};
|
|
// hipGraphBatchMemOpNodeSetParams[('hipGraphNode_t', 'hNode'), ('hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphBatchMemOpNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphBatchMemOpNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphBatchMemOpNodeSetParams.nodeParams = (hipBatchMemOpNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphExecBatchMemOpNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExecBatchMemOpNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecBatchMemOpNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecBatchMemOpNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExecBatchMemOpNodeSetParams.nodeParams = (const hipBatchMemOpNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphExecExternalSemaphoresSignalNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExecExternalSemaphoresSignalNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecExternalSemaphoresSignalNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecExternalSemaphoresSignalNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams = (const hipExternalSemaphoreSignalNodeParams*)nodeParams; \
|
|
};
|
|
// hipGraphExecExternalSemaphoresWaitNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExecExternalSemaphoresWaitNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecExternalSemaphoresWaitNodeSetParams.hGraphExec = (hipGraphExec_t)hGraphExec; \
|
|
cb_data.args.hipGraphExecExternalSemaphoresWaitNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams = (const hipExternalSemaphoreWaitNodeParams*)nodeParams; \
|
|
};
|
|
// hipGraphExecGetFlags[('hipGraphExec_t', 'graphExec'), ('unsigned long long*', 'flags')]
|
|
#define INIT_hipGraphExecGetFlags_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecGetFlags.graphExec = (hipGraphExec_t)graphExec; \
|
|
cb_data.args.hipGraphExecGetFlags.flags = (unsigned long long*)flags; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphExecNodeSetParams[('hipGraphExec_t', 'graphExec'), ('hipGraphNode_t', 'node'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExecNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExecNodeSetParams.graphExec = (hipGraphExec_t)graphExec; \
|
|
cb_data.args.hipGraphExecNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphExecNodeSetParams.nodeParams = (hipGraphNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphExternalSemaphoresSignalNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipExternalSemaphoreSignalNodeParams*', 'params_out')]
|
|
#define INIT_hipGraphExternalSemaphoresSignalNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExternalSemaphoresSignalNodeGetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out = (hipExternalSemaphoreSignalNodeParams*)params_out; \
|
|
};
|
|
// hipGraphExternalSemaphoresSignalNodeSetParams[('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExternalSemaphoresSignalNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExternalSemaphoresSignalNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams = (const hipExternalSemaphoreSignalNodeParams*)nodeParams; \
|
|
};
|
|
// hipGraphExternalSemaphoresWaitNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipExternalSemaphoreWaitNodeParams*', 'params_out')]
|
|
#define INIT_hipGraphExternalSemaphoresWaitNodeGetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExternalSemaphoresWaitNodeGetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out = (hipExternalSemaphoreWaitNodeParams*)params_out; \
|
|
};
|
|
// hipGraphExternalSemaphoresWaitNodeSetParams[('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphExternalSemaphoresWaitNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphExternalSemaphoresWaitNodeSetParams.hNode = (hipGraphNode_t)hNode; \
|
|
cb_data.args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams = (const hipExternalSemaphoreWaitNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphInstantiateWithParams[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('hipGraphInstantiateParams*', 'instantiateParams')]
|
|
#define INIT_hipGraphInstantiateWithParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphInstantiateWithParams.pGraphExec = (hipGraphExec_t*)pGraphExec; \
|
|
cb_data.args.hipGraphInstantiateWithParams.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipGraphInstantiateWithParams.instantiateParams = (hipGraphInstantiateParams*)instantiateParams; \
|
|
};
|
|
// 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'), ('hipLaunchAttributeID', 'attr'), ('hipLaunchAttributeValue*', 'value')]
|
|
#define INIT_hipGraphKernelNodeGetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// 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'), ('hipLaunchAttributeID', 'attr'), ('const hipLaunchAttributeValue*', 'value')]
|
|
#define INIT_hipGraphKernelNodeSetAttribute_CB_ARGS_DATA(cb_data) { \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipGraphNodeSetParams[('hipGraphNode_t', 'node'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
#define INIT_hipGraphNodeSetParams_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipGraphNodeSetParams.node = (hipGraphNode_t)node; \
|
|
cb_data.args.hipGraphNodeSetParams.nodeParams = (hipGraphNodeParams*)nodeParams; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipLaunchKernelExC[('const hipLaunchConfig_t*', 'config'), ('const void*', 'fPtr'), ('void**', 'args')]
|
|
#define INIT_hipLaunchKernelExC_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLaunchKernelExC.config = (const hipLaunchConfig_t*)config; \
|
|
cb_data.args.hipLaunchKernelExC.fPtr = (const void*)fPtr; \
|
|
cb_data.args.hipLaunchKernelExC.args = (void**)args; \
|
|
};
|
|
// hipLinkAddData[('hipLinkState_t', 'state'), ('hipJitInputType', 'type'), ('void*', 'data'), ('size_t', 'size'), ('const char*', 'name'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
|
|
#define INIT_hipLinkAddData_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLinkAddData.state = (hipLinkState_t)hip_link_state; \
|
|
cb_data.args.hipLinkAddData.type = (hipJitInputType)input_type; \
|
|
cb_data.args.hipLinkAddData.data = (void*)image; \
|
|
cb_data.args.hipLinkAddData.size = (size_t)image_size; \
|
|
cb_data.args.hipLinkAddData.name = (name) ? strdup(name) : NULL; \
|
|
cb_data.args.hipLinkAddData.numOptions = (unsigned int)num_options; \
|
|
cb_data.args.hipLinkAddData.options = (hipJitOption*)options_ptr; \
|
|
cb_data.args.hipLinkAddData.optionValues = (void**)option_values; \
|
|
};
|
|
// hipLinkAddFile[('hipLinkState_t', 'state'), ('hipJitInputType', 'type'), ('const char*', 'path'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
|
|
#define INIT_hipLinkAddFile_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLinkAddFile.state = (hipLinkState_t)hip_link_state; \
|
|
cb_data.args.hipLinkAddFile.type = (hipJitInputType)input_type; \
|
|
cb_data.args.hipLinkAddFile.path = (file_path) ? strdup(file_path) : NULL; \
|
|
cb_data.args.hipLinkAddFile.numOptions = (unsigned int)num_options; \
|
|
cb_data.args.hipLinkAddFile.options = (hipJitOption*)options_ptr; \
|
|
cb_data.args.hipLinkAddFile.optionValues = (void**)option_values; \
|
|
};
|
|
// hipLinkComplete[('hipLinkState_t', 'state'), ('void**', 'hipBinOut'), ('size_t*', 'sizeOut')]
|
|
#define INIT_hipLinkComplete_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLinkComplete.state = (hipLinkState_t)hip_link_state; \
|
|
cb_data.args.hipLinkComplete.hipBinOut = (void**)bin_out; \
|
|
cb_data.args.hipLinkComplete.sizeOut = (size_t*)size_out; \
|
|
};
|
|
// hipLinkCreate[('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues'), ('hipLinkState_t*', 'stateOut')]
|
|
#define INIT_hipLinkCreate_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLinkCreate.numOptions = (unsigned int)num_options; \
|
|
cb_data.args.hipLinkCreate.options = (hipJitOption*)options_ptr; \
|
|
cb_data.args.hipLinkCreate.optionValues = (void**)options_vals_pptr; \
|
|
cb_data.args.hipLinkCreate.stateOut = (hipLinkState_t*)hip_link_state_ptr; \
|
|
};
|
|
// hipLinkDestroy[('hipLinkState_t', 'state')]
|
|
#define INIT_hipLinkDestroy_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipLinkDestroy.state = (hipLinkState_t)hip_link_state; \
|
|
};
|
|
// 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_t*', '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_t*)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; \
|
|
};
|
|
// hipMemcpy2DArrayToArray[('hipArray_t', 'dst'), ('size_t', 'wOffsetDst'), ('size_t', 'hOffsetDst'), ('hipArray_const_t', 'src'), ('size_t', 'wOffsetSrc'), ('size_t', 'hOffsetSrc'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
#define INIT_hipMemcpy2DArrayToArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpy2DArrayToArray.dst = (hipArray_t)dst; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.wOffsetDst = (size_t)wOffsetDst; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.hOffsetDst = (size_t)hOffsetDst; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.src = (hipArray_const_t)src; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.wOffsetSrc = (size_t)wOffsetSrc; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.hOffsetSrc = (size_t)hOffsetSrc; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.width = (size_t)width; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.height = (size_t)height; \
|
|
cb_data.args.hipMemcpy2DArrayToArray.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_t', '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_t)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_t', '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_t)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; \
|
|
};
|
|
// hipMemcpyAtoA[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount')]
|
|
#define INIT_hipMemcpyAtoA_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyAtoA.dstArray = (hipArray_t)dstArray; \
|
|
cb_data.args.hipMemcpyAtoA.dstOffset = (size_t)dstOffset; \
|
|
cb_data.args.hipMemcpyAtoA.srcArray = (hipArray_t)srcArray; \
|
|
cb_data.args.hipMemcpyAtoA.srcOffset = (size_t)srcOffset; \
|
|
cb_data.args.hipMemcpyAtoA.ByteCount = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyAtoD[('hipDeviceptr_t', 'dstDevice'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount')]
|
|
#define INIT_hipMemcpyAtoD_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyAtoD.dstDevice = (hipDeviceptr_t)dstDevice; \
|
|
cb_data.args.hipMemcpyAtoD.srcArray = (hipArray_t)srcArray; \
|
|
cb_data.args.hipMemcpyAtoD.srcOffset = (size_t)srcOffset; \
|
|
cb_data.args.hipMemcpyAtoD.ByteCount = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyAtoH[('void*', 'dst'), ('hipArray_t', '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_t)srcArray; \
|
|
cb_data.args.hipMemcpyAtoH.srcOffset = (size_t)srcOffset; \
|
|
cb_data.args.hipMemcpyAtoH.count = (size_t)ByteCount; \
|
|
};
|
|
// hipMemcpyAtoHAsync[('void*', 'dstHost'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyAtoHAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyAtoHAsync.dstHost = (void*)dstHost; \
|
|
cb_data.args.hipMemcpyAtoHAsync.srcArray = (hipArray_t)srcArray; \
|
|
cb_data.args.hipMemcpyAtoHAsync.srcOffset = (size_t)srcOffset; \
|
|
cb_data.args.hipMemcpyAtoHAsync.ByteCount = (size_t)ByteCount; \
|
|
cb_data.args.hipMemcpyAtoHAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// hipMemcpyDtoA[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('hipDeviceptr_t', 'srcDevice'), ('size_t', 'ByteCount')]
|
|
#define INIT_hipMemcpyDtoA_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyDtoA.dstArray = (hipArray_t)dstArray; \
|
|
cb_data.args.hipMemcpyDtoA.dstOffset = (size_t)dstOffset; \
|
|
cb_data.args.hipMemcpyDtoA.srcDevice = (hipDeviceptr_t)srcDevice; \
|
|
cb_data.args.hipMemcpyDtoA.ByteCount = (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_t', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
|
|
#define INIT_hipMemcpyHtoA_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyHtoA.dstArray = (hipArray_t)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; \
|
|
};
|
|
// hipMemcpyHtoAAsync[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'ByteCount'), ('hipStream_t', 'stream')]
|
|
#define INIT_hipMemcpyHtoAAsync_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipMemcpyHtoAAsync.dstArray = (hipArray_t)dstArray; \
|
|
cb_data.args.hipMemcpyHtoAAsync.dstOffset = (size_t)dstOffset; \
|
|
cb_data.args.hipMemcpyHtoAAsync.srcHost = (const void*)srcHost; \
|
|
cb_data.args.hipMemcpyHtoAAsync.ByteCount = (size_t)ByteCount; \
|
|
cb_data.args.hipMemcpyHtoAAsync.stream = (hipStream_t)stream; \
|
|
};
|
|
// 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_t', '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_t)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; \
|
|
};
|
|
// hipSetValidDevices[('int*', 'device_arr'), ('int', 'len')]
|
|
#define INIT_hipSetValidDevices_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipSetValidDevices.device_arr = (int*)device_arr; \
|
|
cb_data.args.hipSetValidDevices.len = (int)len; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipStreamBatchMemOp[('hipStream_t', 'stream'), ('unsigned int', 'count'), ('hipStreamBatchMemOpParams*', 'paramArray'), ('unsigned int', 'flags')]
|
|
#define INIT_hipStreamBatchMemOp_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamBatchMemOp.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamBatchMemOp.count = (unsigned int)count; \
|
|
cb_data.args.hipStreamBatchMemOp.paramArray = (hipStreamBatchMemOpParams*)paramArray; \
|
|
cb_data.args.hipStreamBatchMemOp.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; \
|
|
};
|
|
// hipStreamBeginCaptureToGraph[('hipStream_t', 'stream'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'dependencies'), ('const hipGraphEdgeData*', 'dependencyData'), ('size_t', 'numDependencies'), ('hipStreamCaptureMode', 'mode')]
|
|
#define INIT_hipStreamBeginCaptureToGraph_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.graph = (hipGraph_t)graph; \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.dependencies = (const hipGraphNode_t*)dependencies; \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.dependencyData = (const hipGraphEdgeData*)dependencyData; \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.numDependencies = (size_t)numDependencies; \
|
|
cb_data.args.hipStreamBeginCaptureToGraph.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; \
|
|
};
|
|
// hipStreamGetDevice[('hipStream_t', 'stream'), ('hipDevice_t*', 'device')]
|
|
#define INIT_hipStreamGetDevice_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipStreamGetDevice.stream = (hipStream_t)stream; \
|
|
cb_data.args.hipStreamGetDevice.device = (hipDevice_t*)device; \
|
|
};
|
|
// 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; \
|
|
};
|
|
// hipTexRefGetArray[('hipArray_t*', 'pArray'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetArray_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetArray.pArray = (hipArray_t*)pArray; \
|
|
cb_data.args.hipTexRefGetArray.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// hipTexRefGetBorderColor[('float*', 'pBorderColor'), ('const textureReference*', 'texRef')]
|
|
#define INIT_hipTexRefGetBorderColor_CB_ARGS_DATA(cb_data) { \
|
|
cb_data.args.hipTexRefGetBorderColor.pBorderColor = (float*)pBorderColor; \
|
|
cb_data.args.hipTexRefGetBorderColor.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) { \
|
|
cb_data.args.hipTexRefGetMipMappedArray.pArray = (hipMipmappedArray_t*)pArray; \
|
|
cb_data.args.hipTexRefGetMipMappedArray.texRef = (const textureReference*)texRef; \
|
|
};
|
|
// 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
|
|
// 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) {};
|
|
// hipDeviceGetTexture1DLinearMaxWidth()
|
|
#define INIT_hipDeviceGetTexture1DLinearMaxWidth_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) {};
|
|
// 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) {};
|
|
// hipTexRefGetFilterMode()
|
|
#define INIT_hipTexRefGetFilterMode_CB_ARGS_DATA(cb_data) {};
|
|
// hipTexRefGetMipmapFilterMode()
|
|
#define INIT_hipTexRefGetMipmapFilterMode_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_t*', '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;
|
|
// hipArray3DGetDescriptor[('HIP_ARRAY3D_DESCRIPTOR*', 'pArrayDescriptor'), ('hipArray_t', 'array')]
|
|
case HIP_API_ID_hipArray3DGetDescriptor:
|
|
if (data->args.hipArray3DGetDescriptor.pArrayDescriptor) data->args.hipArray3DGetDescriptor.pArrayDescriptor__val = *(data->args.hipArray3DGetDescriptor.pArrayDescriptor);
|
|
break;
|
|
// hipArrayCreate[('hipArray_t*', '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_t', 'array')]
|
|
case HIP_API_ID_hipArrayDestroy:
|
|
break;
|
|
// hipArrayGetDescriptor[('HIP_ARRAY_DESCRIPTOR*', 'pArrayDescriptor'), ('hipArray_t', 'array')]
|
|
case HIP_API_ID_hipArrayGetDescriptor:
|
|
if (data->args.hipArrayGetDescriptor.pArrayDescriptor) data->args.hipArrayGetDescriptor.pArrayDescriptor__val = *(data->args.hipArrayGetDescriptor.pArrayDescriptor);
|
|
break;
|
|
// hipArrayGetInfo[('hipChannelFormatDesc*', 'desc'), ('hipExtent*', 'extent'), ('unsigned int*', 'flags'), ('hipArray_t', 'array')]
|
|
case HIP_API_ID_hipArrayGetInfo:
|
|
if (data->args.hipArrayGetInfo.desc) data->args.hipArrayGetInfo.desc__val = *(data->args.hipArrayGetInfo.desc);
|
|
if (data->args.hipArrayGetInfo.extent) data->args.hipArrayGetInfo.extent__val = *(data->args.hipArrayGetInfo.extent);
|
|
if (data->args.hipArrayGetInfo.flags) data->args.hipArrayGetInfo.flags__val = *(data->args.hipArrayGetInfo.flags);
|
|
break;
|
|
// hipChooseDeviceR0000[('int*', 'device'), ('const hipDeviceProp_tR0000*', 'prop')]
|
|
case HIP_API_ID_hipChooseDeviceR0000:
|
|
if (data->args.hipChooseDeviceR0000.device) data->args.hipChooseDeviceR0000.device__val = *(data->args.hipChooseDeviceR0000.device);
|
|
if (data->args.hipChooseDeviceR0000.prop) data->args.hipChooseDeviceR0000.prop__val = *(data->args.hipChooseDeviceR0000.prop);
|
|
break;
|
|
// hipChooseDeviceR0600[('int*', 'device'), ('const hipDeviceProp_tR0600*', 'prop')]
|
|
case HIP_API_ID_hipChooseDeviceR0600:
|
|
if (data->args.hipChooseDeviceR0600.device) data->args.hipChooseDeviceR0600.device__val = *(data->args.hipChooseDeviceR0600.device);
|
|
if (data->args.hipChooseDeviceR0600.prop) data->args.hipChooseDeviceR0600.prop__val = *(data->args.hipChooseDeviceR0600.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;
|
|
// hipDrvGraphAddMemFreeNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('hipDeviceptr_t', 'dptr')]
|
|
case HIP_API_ID_hipDrvGraphAddMemFreeNode:
|
|
if (data->args.hipDrvGraphAddMemFreeNode.phGraphNode) data->args.hipDrvGraphAddMemFreeNode.phGraphNode__val = *(data->args.hipDrvGraphAddMemFreeNode.phGraphNode);
|
|
if (data->args.hipDrvGraphAddMemFreeNode.dependencies) data->args.hipDrvGraphAddMemFreeNode.dependencies__val = *(data->args.hipDrvGraphAddMemFreeNode.dependencies);
|
|
break;
|
|
// hipDrvGraphAddMemcpyNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const HIP_MEMCPY3D*', 'copyParams'), ('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipDrvGraphAddMemcpyNode:
|
|
if (data->args.hipDrvGraphAddMemcpyNode.phGraphNode) data->args.hipDrvGraphAddMemcpyNode.phGraphNode__val = *(data->args.hipDrvGraphAddMemcpyNode.phGraphNode);
|
|
if (data->args.hipDrvGraphAddMemcpyNode.dependencies) data->args.hipDrvGraphAddMemcpyNode.dependencies__val = *(data->args.hipDrvGraphAddMemcpyNode.dependencies);
|
|
if (data->args.hipDrvGraphAddMemcpyNode.copyParams) data->args.hipDrvGraphAddMemcpyNode.copyParams__val = *(data->args.hipDrvGraphAddMemcpyNode.copyParams);
|
|
break;
|
|
// hipDrvGraphAddMemsetNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const HIP_MEMSET_NODE_PARAMS*', 'memsetParams'), ('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipDrvGraphAddMemsetNode:
|
|
if (data->args.hipDrvGraphAddMemsetNode.phGraphNode) data->args.hipDrvGraphAddMemsetNode.phGraphNode__val = *(data->args.hipDrvGraphAddMemsetNode.phGraphNode);
|
|
if (data->args.hipDrvGraphAddMemsetNode.dependencies) data->args.hipDrvGraphAddMemsetNode.dependencies__val = *(data->args.hipDrvGraphAddMemsetNode.dependencies);
|
|
if (data->args.hipDrvGraphAddMemsetNode.memsetParams) data->args.hipDrvGraphAddMemsetNode.memsetParams__val = *(data->args.hipDrvGraphAddMemsetNode.memsetParams);
|
|
break;
|
|
// hipDrvGraphExecMemcpyNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const HIP_MEMCPY3D*', 'copyParams'), ('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipDrvGraphExecMemcpyNodeSetParams:
|
|
if (data->args.hipDrvGraphExecMemcpyNodeSetParams.copyParams) data->args.hipDrvGraphExecMemcpyNodeSetParams.copyParams__val = *(data->args.hipDrvGraphExecMemcpyNodeSetParams.copyParams);
|
|
break;
|
|
// hipDrvGraphExecMemsetNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const HIP_MEMSET_NODE_PARAMS*', 'memsetParams'), ('hipCtx_t', 'ctx')]
|
|
case HIP_API_ID_hipDrvGraphExecMemsetNodeSetParams:
|
|
if (data->args.hipDrvGraphExecMemsetNodeSetParams.memsetParams) data->args.hipDrvGraphExecMemsetNodeSetParams.memsetParams__val = *(data->args.hipDrvGraphExecMemsetNodeSetParams.memsetParams);
|
|
break;
|
|
// hipDrvGraphMemcpyNodeGetParams[('hipGraphNode_t', 'hNode'), ('HIP_MEMCPY3D*', 'nodeParams')]
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeGetParams:
|
|
if (data->args.hipDrvGraphMemcpyNodeGetParams.nodeParams) data->args.hipDrvGraphMemcpyNodeGetParams.nodeParams__val = *(data->args.hipDrvGraphMemcpyNodeGetParams.nodeParams);
|
|
break;
|
|
// hipDrvGraphMemcpyNodeSetParams[('hipGraphNode_t', 'hNode'), ('const HIP_MEMCPY3D*', 'nodeParams')]
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeSetParams:
|
|
if (data->args.hipDrvGraphMemcpyNodeSetParams.nodeParams) data->args.hipDrvGraphMemcpyNodeSetParams.nodeParams__val = *(data->args.hipDrvGraphMemcpyNodeSetParams.nodeParams);
|
|
break;
|
|
// hipDrvLaunchKernelEx[('const HIP_LAUNCH_CONFIG*', 'config'), ('hipFunction_t', 'f'), ('void**', 'params'), ('void**', 'extra')]
|
|
case HIP_API_ID_hipDrvLaunchKernelEx:
|
|
if (data->args.hipDrvLaunchKernelEx.config) data->args.hipDrvLaunchKernelEx.config__val = *(data->args.hipDrvLaunchKernelEx.config);
|
|
if (data->args.hipDrvLaunchKernelEx.params) data->args.hipDrvLaunchKernelEx.params__val = *(data->args.hipDrvLaunchKernelEx.params);
|
|
if (data->args.hipDrvLaunchKernelEx.extra) data->args.hipDrvLaunchKernelEx.extra__val = *(data->args.hipDrvLaunchKernelEx.extra);
|
|
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;
|
|
// hipEventRecordWithFlags[('hipEvent_t', 'event'), ('hipStream_t', 'stream'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipEventRecordWithFlags:
|
|
break;
|
|
// hipEventSynchronize[('hipEvent_t', 'event')]
|
|
case HIP_API_ID_hipEventSynchronize:
|
|
break;
|
|
// hipExtGetLastError[]
|
|
case HIP_API_ID_hipExtGetLastError:
|
|
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;
|
|
// hipExternalMemoryGetMappedMipmappedArray[('hipMipmappedArray_t*', 'mipmap'), ('hipExternalMemory_t', 'extMem'), ('const hipExternalMemoryMipmappedArrayDesc*', 'mipmapDesc')]
|
|
case HIP_API_ID_hipExternalMemoryGetMappedMipmappedArray:
|
|
if (data->args.hipExternalMemoryGetMappedMipmappedArray.mipmap) data->args.hipExternalMemoryGetMappedMipmappedArray.mipmap__val = *(data->args.hipExternalMemoryGetMappedMipmappedArray.mipmap);
|
|
if (data->args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc) data->args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc__val = *(data->args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc);
|
|
break;
|
|
// hipFree[('void*', 'ptr')]
|
|
case HIP_API_ID_hipFree:
|
|
break;
|
|
// hipFreeArray[('hipArray_t', 'array')]
|
|
case HIP_API_ID_hipFreeArray:
|
|
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;
|
|
// hipGetDevicePropertiesR0000[('hipDeviceProp_tR0000*', 'prop'), ('int', 'device')]
|
|
case HIP_API_ID_hipGetDevicePropertiesR0000:
|
|
if (data->args.hipGetDevicePropertiesR0000.prop) data->args.hipGetDevicePropertiesR0000.prop__val = *(data->args.hipGetDevicePropertiesR0000.prop);
|
|
break;
|
|
// hipGetDevicePropertiesR0600[('hipDeviceProp_tR0600*', 'prop'), ('int', 'deviceId')]
|
|
case HIP_API_ID_hipGetDevicePropertiesR0600:
|
|
if (data->args.hipGetDevicePropertiesR0600.prop) data->args.hipGetDevicePropertiesR0600.prop__val = *(data->args.hipGetDevicePropertiesR0600.prop);
|
|
break;
|
|
// hipGetErrorString[]
|
|
case HIP_API_ID_hipGetErrorString:
|
|
break;
|
|
// hipGetFuncBySymbol[('hipFunction_t*', 'functionPtr'), ('const void*', 'symbolPtr')]
|
|
case HIP_API_ID_hipGetFuncBySymbol:
|
|
if (data->args.hipGetFuncBySymbol.functionPtr) data->args.hipGetFuncBySymbol.functionPtr__val = *(data->args.hipGetFuncBySymbol.functionPtr);
|
|
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;
|
|
// hipGetProcAddress[('const char*', 'symbol'), ('void**', 'pfn'), ('int', 'hipVersion'), ('uint64_t', 'flags'), ('hipDriverProcAddressQueryResult*', 'symbolStatus')]
|
|
case HIP_API_ID_hipGetProcAddress:
|
|
if (data->args.hipGetProcAddress.symbol) data->args.hipGetProcAddress.symbol__val = *(data->args.hipGetProcAddress.symbol);
|
|
if (data->args.hipGetProcAddress.pfn) data->args.hipGetProcAddress.pfn__val = *(data->args.hipGetProcAddress.pfn);
|
|
if (data->args.hipGetProcAddress.symbolStatus) data->args.hipGetProcAddress.symbolStatus__val = *(data->args.hipGetProcAddress.symbolStatus);
|
|
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;
|
|
// hipGraphAddBatchMemOpNode[('hipGraphNode_t*', 'phGraphNode'), ('hipGraph_t', 'hGraph'), ('const hipGraphNode_t*', 'dependencies'), ('size_t', 'numDependencies'), ('const hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphAddBatchMemOpNode:
|
|
if (data->args.hipGraphAddBatchMemOpNode.phGraphNode) data->args.hipGraphAddBatchMemOpNode.phGraphNode__val = *(data->args.hipGraphAddBatchMemOpNode.phGraphNode);
|
|
if (data->args.hipGraphAddBatchMemOpNode.dependencies) data->args.hipGraphAddBatchMemOpNode.dependencies__val = *(data->args.hipGraphAddBatchMemOpNode.dependencies);
|
|
if (data->args.hipGraphAddBatchMemOpNode.nodeParams) data->args.hipGraphAddBatchMemOpNode.nodeParams__val = *(data->args.hipGraphAddBatchMemOpNode.nodeParams);
|
|
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;
|
|
// hipGraphAddExternalSemaphoresSignalNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphAddExternalSemaphoresSignalNode:
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode) data->args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode__val = *(data->args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode);
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.pDependencies) data->args.hipGraphAddExternalSemaphoresSignalNode.pDependencies__val = *(data->args.hipGraphAddExternalSemaphoresSignalNode.pDependencies);
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.nodeParams) data->args.hipGraphAddExternalSemaphoresSignalNode.nodeParams__val = *(data->args.hipGraphAddExternalSemaphoresSignalNode.nodeParams);
|
|
break;
|
|
// hipGraphAddExternalSemaphoresWaitNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphAddExternalSemaphoresWaitNode:
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode) data->args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode__val = *(data->args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode);
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.pDependencies) data->args.hipGraphAddExternalSemaphoresWaitNode.pDependencies__val = *(data->args.hipGraphAddExternalSemaphoresWaitNode.pDependencies);
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.nodeParams) data->args.hipGraphAddExternalSemaphoresWaitNode.nodeParams__val = *(data->args.hipGraphAddExternalSemaphoresWaitNode.nodeParams);
|
|
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;
|
|
// hipGraphAddNode[('hipGraphNode_t*', 'pGraphNode'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'pDependencies'), ('size_t', 'numDependencies'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphAddNode:
|
|
if (data->args.hipGraphAddNode.pGraphNode) data->args.hipGraphAddNode.pGraphNode__val = *(data->args.hipGraphAddNode.pGraphNode);
|
|
if (data->args.hipGraphAddNode.pDependencies) data->args.hipGraphAddNode.pDependencies__val = *(data->args.hipGraphAddNode.pDependencies);
|
|
if (data->args.hipGraphAddNode.nodeParams) data->args.hipGraphAddNode.nodeParams__val = *(data->args.hipGraphAddNode.nodeParams);
|
|
break;
|
|
// hipGraphBatchMemOpNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipBatchMemOpNodeParams*', 'nodeParams_out')]
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeGetParams:
|
|
if (data->args.hipGraphBatchMemOpNodeGetParams.nodeParams_out) data->args.hipGraphBatchMemOpNodeGetParams.nodeParams_out__val = *(data->args.hipGraphBatchMemOpNodeGetParams.nodeParams_out);
|
|
break;
|
|
// hipGraphBatchMemOpNodeSetParams[('hipGraphNode_t', 'hNode'), ('hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeSetParams:
|
|
if (data->args.hipGraphBatchMemOpNodeSetParams.nodeParams) data->args.hipGraphBatchMemOpNodeSetParams.nodeParams__val = *(data->args.hipGraphBatchMemOpNodeSetParams.nodeParams);
|
|
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;
|
|
// hipGraphExecBatchMemOpNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipBatchMemOpNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExecBatchMemOpNodeSetParams:
|
|
if (data->args.hipGraphExecBatchMemOpNodeSetParams.nodeParams) data->args.hipGraphExecBatchMemOpNodeSetParams.nodeParams__val = *(data->args.hipGraphExecBatchMemOpNodeSetParams.nodeParams);
|
|
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;
|
|
// hipGraphExecExternalSemaphoresSignalNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExecExternalSemaphoresSignalNodeSetParams:
|
|
if (data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams) data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams__val = *(data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams);
|
|
break;
|
|
// hipGraphExecExternalSemaphoresWaitNodeSetParams[('hipGraphExec_t', 'hGraphExec'), ('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExecExternalSemaphoresWaitNodeSetParams:
|
|
if (data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams) data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams__val = *(data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams);
|
|
break;
|
|
// hipGraphExecGetFlags[('hipGraphExec_t', 'graphExec'), ('unsigned long long*', 'flags')]
|
|
case HIP_API_ID_hipGraphExecGetFlags:
|
|
if (data->args.hipGraphExecGetFlags.flags) data->args.hipGraphExecGetFlags.flags__val = *(data->args.hipGraphExecGetFlags.flags);
|
|
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;
|
|
// hipGraphExecNodeSetParams[('hipGraphExec_t', 'graphExec'), ('hipGraphNode_t', 'node'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExecNodeSetParams:
|
|
if (data->args.hipGraphExecNodeSetParams.nodeParams) data->args.hipGraphExecNodeSetParams.nodeParams__val = *(data->args.hipGraphExecNodeSetParams.nodeParams);
|
|
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;
|
|
// hipGraphExternalSemaphoresSignalNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipExternalSemaphoreSignalNodeParams*', 'params_out')]
|
|
case HIP_API_ID_hipGraphExternalSemaphoresSignalNodeGetParams:
|
|
if (data->args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out) data->args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out__val = *(data->args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out);
|
|
break;
|
|
// hipGraphExternalSemaphoresSignalNodeSetParams[('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreSignalNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExternalSemaphoresSignalNodeSetParams:
|
|
if (data->args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams) data->args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams__val = *(data->args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams);
|
|
break;
|
|
// hipGraphExternalSemaphoresWaitNodeGetParams[('hipGraphNode_t', 'hNode'), ('hipExternalSemaphoreWaitNodeParams*', 'params_out')]
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeGetParams:
|
|
if (data->args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out) data->args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out__val = *(data->args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out);
|
|
break;
|
|
// hipGraphExternalSemaphoresWaitNodeSetParams[('hipGraphNode_t', 'hNode'), ('const hipExternalSemaphoreWaitNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeSetParams:
|
|
if (data->args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams) data->args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams__val = *(data->args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams);
|
|
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;
|
|
// hipGraphInstantiateWithParams[('hipGraphExec_t*', 'pGraphExec'), ('hipGraph_t', 'graph'), ('hipGraphInstantiateParams*', 'instantiateParams')]
|
|
case HIP_API_ID_hipGraphInstantiateWithParams:
|
|
if (data->args.hipGraphInstantiateWithParams.pGraphExec) data->args.hipGraphInstantiateWithParams.pGraphExec__val = *(data->args.hipGraphInstantiateWithParams.pGraphExec);
|
|
if (data->args.hipGraphInstantiateWithParams.instantiateParams) data->args.hipGraphInstantiateWithParams.instantiateParams__val = *(data->args.hipGraphInstantiateWithParams.instantiateParams);
|
|
break;
|
|
// hipGraphKernelNodeCopyAttributes[('hipGraphNode_t', 'hSrc'), ('hipGraphNode_t', 'hDst')]
|
|
case HIP_API_ID_hipGraphKernelNodeCopyAttributes:
|
|
break;
|
|
// hipGraphKernelNodeGetAttribute[('hipGraphNode_t', 'hNode'), ('hipLaunchAttributeID', 'attr'), ('hipLaunchAttributeValue*', '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'), ('hipLaunchAttributeID', 'attr'), ('const hipLaunchAttributeValue*', '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;
|
|
// hipGraphNodeSetParams[('hipGraphNode_t', 'node'), ('hipGraphNodeParams*', 'nodeParams')]
|
|
case HIP_API_ID_hipGraphNodeSetParams:
|
|
if (data->args.hipGraphNodeSetParams.nodeParams) data->args.hipGraphNodeSetParams.nodeParams__val = *(data->args.hipGraphNodeSetParams.nodeParams);
|
|
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;
|
|
// hipLaunchKernelExC[('const hipLaunchConfig_t*', 'config'), ('const void*', 'fPtr'), ('void**', 'args')]
|
|
case HIP_API_ID_hipLaunchKernelExC:
|
|
if (data->args.hipLaunchKernelExC.config) data->args.hipLaunchKernelExC.config__val = *(data->args.hipLaunchKernelExC.config);
|
|
if (data->args.hipLaunchKernelExC.args) data->args.hipLaunchKernelExC.args__val = *(data->args.hipLaunchKernelExC.args);
|
|
break;
|
|
// hipLinkAddData[('hipLinkState_t', 'state'), ('hipJitInputType', 'type'), ('void*', 'data'), ('size_t', 'size'), ('const char*', 'name'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
|
|
case HIP_API_ID_hipLinkAddData:
|
|
if (data->args.hipLinkAddData.name) data->args.hipLinkAddData.name__val = *(data->args.hipLinkAddData.name);
|
|
if (data->args.hipLinkAddData.options) data->args.hipLinkAddData.options__val = *(data->args.hipLinkAddData.options);
|
|
if (data->args.hipLinkAddData.optionValues) data->args.hipLinkAddData.optionValues__val = *(data->args.hipLinkAddData.optionValues);
|
|
break;
|
|
// hipLinkAddFile[('hipLinkState_t', 'state'), ('hipJitInputType', 'type'), ('const char*', 'path'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
|
|
case HIP_API_ID_hipLinkAddFile:
|
|
if (data->args.hipLinkAddFile.path) data->args.hipLinkAddFile.path__val = *(data->args.hipLinkAddFile.path);
|
|
if (data->args.hipLinkAddFile.options) data->args.hipLinkAddFile.options__val = *(data->args.hipLinkAddFile.options);
|
|
if (data->args.hipLinkAddFile.optionValues) data->args.hipLinkAddFile.optionValues__val = *(data->args.hipLinkAddFile.optionValues);
|
|
break;
|
|
// hipLinkComplete[('hipLinkState_t', 'state'), ('void**', 'hipBinOut'), ('size_t*', 'sizeOut')]
|
|
case HIP_API_ID_hipLinkComplete:
|
|
if (data->args.hipLinkComplete.hipBinOut) data->args.hipLinkComplete.hipBinOut__val = *(data->args.hipLinkComplete.hipBinOut);
|
|
if (data->args.hipLinkComplete.sizeOut) data->args.hipLinkComplete.sizeOut__val = *(data->args.hipLinkComplete.sizeOut);
|
|
break;
|
|
// hipLinkCreate[('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues'), ('hipLinkState_t*', 'stateOut')]
|
|
case HIP_API_ID_hipLinkCreate:
|
|
if (data->args.hipLinkCreate.options) data->args.hipLinkCreate.options__val = *(data->args.hipLinkCreate.options);
|
|
if (data->args.hipLinkCreate.optionValues) data->args.hipLinkCreate.optionValues__val = *(data->args.hipLinkCreate.optionValues);
|
|
if (data->args.hipLinkCreate.stateOut) data->args.hipLinkCreate.stateOut__val = *(data->args.hipLinkCreate.stateOut);
|
|
break;
|
|
// hipLinkDestroy[('hipLinkState_t', 'state')]
|
|
case HIP_API_ID_hipLinkDestroy:
|
|
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_t*', '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;
|
|
// hipMemcpy2DArrayToArray[('hipArray_t', 'dst'), ('size_t', 'wOffsetDst'), ('size_t', 'hOffsetDst'), ('hipArray_const_t', 'src'), ('size_t', 'wOffsetSrc'), ('size_t', 'hOffsetSrc'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpy2DArrayToArray:
|
|
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_t', '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:
|
|
break;
|
|
// hipMemcpy2DToArrayAsync[('hipArray_t', '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:
|
|
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;
|
|
// hipMemcpyAtoA[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount')]
|
|
case HIP_API_ID_hipMemcpyAtoA:
|
|
break;
|
|
// hipMemcpyAtoD[('hipDeviceptr_t', 'dstDevice'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount')]
|
|
case HIP_API_ID_hipMemcpyAtoD:
|
|
break;
|
|
// hipMemcpyAtoH[('void*', 'dst'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemcpyAtoH:
|
|
break;
|
|
// hipMemcpyAtoHAsync[('void*', 'dstHost'), ('hipArray_t', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'ByteCount'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyAtoHAsync:
|
|
break;
|
|
// hipMemcpyDtoA[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('hipDeviceptr_t', 'srcDevice'), ('size_t', 'ByteCount')]
|
|
case HIP_API_ID_hipMemcpyDtoA:
|
|
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_t', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
|
|
case HIP_API_ID_hipMemcpyHtoA:
|
|
break;
|
|
// hipMemcpyHtoAAsync[('hipArray_t', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'ByteCount'), ('hipStream_t', 'stream')]
|
|
case HIP_API_ID_hipMemcpyHtoAAsync:
|
|
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_t', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
|
|
case HIP_API_ID_hipMemcpyToArray:
|
|
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;
|
|
// hipSetValidDevices[('int*', 'device_arr'), ('int', 'len')]
|
|
case HIP_API_ID_hipSetValidDevices:
|
|
if (data->args.hipSetValidDevices.device_arr) data->args.hipSetValidDevices.device_arr__val = *(data->args.hipSetValidDevices.device_arr);
|
|
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;
|
|
// hipStreamBatchMemOp[('hipStream_t', 'stream'), ('unsigned int', 'count'), ('hipStreamBatchMemOpParams*', 'paramArray'), ('unsigned int', 'flags')]
|
|
case HIP_API_ID_hipStreamBatchMemOp:
|
|
if (data->args.hipStreamBatchMemOp.paramArray) data->args.hipStreamBatchMemOp.paramArray__val = *(data->args.hipStreamBatchMemOp.paramArray);
|
|
break;
|
|
// hipStreamBeginCapture[('hipStream_t', 'stream'), ('hipStreamCaptureMode', 'mode')]
|
|
case HIP_API_ID_hipStreamBeginCapture:
|
|
break;
|
|
// hipStreamBeginCaptureToGraph[('hipStream_t', 'stream'), ('hipGraph_t', 'graph'), ('const hipGraphNode_t*', 'dependencies'), ('const hipGraphEdgeData*', 'dependencyData'), ('size_t', 'numDependencies'), ('hipStreamCaptureMode', 'mode')]
|
|
case HIP_API_ID_hipStreamBeginCaptureToGraph:
|
|
if (data->args.hipStreamBeginCaptureToGraph.dependencies) data->args.hipStreamBeginCaptureToGraph.dependencies__val = *(data->args.hipStreamBeginCaptureToGraph.dependencies);
|
|
if (data->args.hipStreamBeginCaptureToGraph.dependencyData) data->args.hipStreamBeginCaptureToGraph.dependencyData__val = *(data->args.hipStreamBeginCaptureToGraph.dependencyData);
|
|
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;
|
|
// hipStreamGetDevice[('hipStream_t', 'stream'), ('hipDevice_t*', 'device')]
|
|
case HIP_API_ID_hipStreamGetDevice:
|
|
if (data->args.hipStreamGetDevice.device) data->args.hipStreamGetDevice.device__val = *(data->args.hipStreamGetDevice.device);
|
|
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;
|
|
// hipTexRefGetArray[('hipArray_t*', 'pArray'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetArray:
|
|
if (data->args.hipTexRefGetArray.pArray) data->args.hipTexRefGetArray.pArray__val = *(data->args.hipTexRefGetArray.pArray);
|
|
if (data->args.hipTexRefGetArray.texRef) data->args.hipTexRefGetArray.texRef__val = *(data->args.hipTexRefGetArray.texRef);
|
|
break;
|
|
// hipTexRefGetBorderColor[('float*', 'pBorderColor'), ('const textureReference*', 'texRef')]
|
|
case HIP_API_ID_hipTexRefGetBorderColor:
|
|
if (data->args.hipTexRefGetBorderColor.pBorderColor) data->args.hipTexRefGetBorderColor.pBorderColor__val = *(data->args.hipTexRefGetBorderColor.pBorderColor);
|
|
if (data->args.hipTexRefGetBorderColor.texRef) data->args.hipTexRefGetBorderColor.texRef__val = *(data->args.hipTexRefGetBorderColor.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, 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_hipArray3DGetDescriptor:
|
|
oss << "hipArray3DGetDescriptor(";
|
|
if (data->args.hipArray3DGetDescriptor.pArrayDescriptor == NULL) oss << "pArrayDescriptor=NULL";
|
|
else { oss << "pArrayDescriptor="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArray3DGetDescriptor.pArrayDescriptor__val); }
|
|
oss << ", array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArray3DGetDescriptor.array);
|
|
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, 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(";
|
|
oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayDestroy.array);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipArrayGetDescriptor:
|
|
oss << "hipArrayGetDescriptor(";
|
|
if (data->args.hipArrayGetDescriptor.pArrayDescriptor == NULL) oss << "pArrayDescriptor=NULL";
|
|
else { oss << "pArrayDescriptor="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetDescriptor.pArrayDescriptor__val); }
|
|
oss << ", array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetDescriptor.array);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipArrayGetInfo:
|
|
oss << "hipArrayGetInfo(";
|
|
if (data->args.hipArrayGetInfo.desc == NULL) oss << "desc=NULL";
|
|
else { oss << "desc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetInfo.desc__val); }
|
|
if (data->args.hipArrayGetInfo.extent == NULL) oss << ", extent=NULL";
|
|
else { oss << ", extent="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetInfo.extent__val); }
|
|
if (data->args.hipArrayGetInfo.flags == NULL) oss << ", flags=NULL";
|
|
else { oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetInfo.flags__val); }
|
|
oss << ", array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipArrayGetInfo.array);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipChooseDeviceR0000:
|
|
oss << "hipChooseDeviceR0000(";
|
|
if (data->args.hipChooseDeviceR0000.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDeviceR0000.device__val); }
|
|
if (data->args.hipChooseDeviceR0000.prop == NULL) oss << ", prop=NULL";
|
|
else { oss << ", prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDeviceR0000.prop__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipChooseDeviceR0600:
|
|
oss << "hipChooseDeviceR0600(";
|
|
if (data->args.hipChooseDeviceR0600.device == NULL) oss << "device=NULL";
|
|
else { oss << "device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDeviceR0600.device__val); }
|
|
if (data->args.hipChooseDeviceR0600.prop == NULL) oss << ", prop=NULL";
|
|
else { oss << ", prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipChooseDeviceR0600.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_hipDrvGraphAddMemFreeNode:
|
|
oss << "hipDrvGraphAddMemFreeNode(";
|
|
if (data->args.hipDrvGraphAddMemFreeNode.phGraphNode == NULL) oss << "phGraphNode=NULL";
|
|
else { oss << "phGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemFreeNode.phGraphNode__val); }
|
|
oss << ", hGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemFreeNode.hGraph);
|
|
if (data->args.hipDrvGraphAddMemFreeNode.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemFreeNode.dependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemFreeNode.numDependencies);
|
|
oss << ", dptr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemFreeNode.dptr);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphAddMemcpyNode:
|
|
oss << "hipDrvGraphAddMemcpyNode(";
|
|
if (data->args.hipDrvGraphAddMemcpyNode.phGraphNode == NULL) oss << "phGraphNode=NULL";
|
|
else { oss << "phGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.phGraphNode__val); }
|
|
oss << ", hGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.hGraph);
|
|
if (data->args.hipDrvGraphAddMemcpyNode.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.dependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.numDependencies);
|
|
if (data->args.hipDrvGraphAddMemcpyNode.copyParams == NULL) oss << ", copyParams=NULL";
|
|
else { oss << ", copyParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.copyParams__val); }
|
|
oss << ", ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemcpyNode.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphAddMemsetNode:
|
|
oss << "hipDrvGraphAddMemsetNode(";
|
|
if (data->args.hipDrvGraphAddMemsetNode.phGraphNode == NULL) oss << "phGraphNode=NULL";
|
|
else { oss << "phGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.phGraphNode__val); }
|
|
oss << ", hGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.hGraph);
|
|
if (data->args.hipDrvGraphAddMemsetNode.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.dependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.numDependencies);
|
|
if (data->args.hipDrvGraphAddMemsetNode.memsetParams == NULL) oss << ", memsetParams=NULL";
|
|
else { oss << ", memsetParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.memsetParams__val); }
|
|
oss << ", ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphAddMemsetNode.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphExecMemcpyNodeSetParams:
|
|
oss << "hipDrvGraphExecMemcpyNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemcpyNodeSetParams.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemcpyNodeSetParams.hNode);
|
|
if (data->args.hipDrvGraphExecMemcpyNodeSetParams.copyParams == NULL) oss << ", copyParams=NULL";
|
|
else { oss << ", copyParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemcpyNodeSetParams.copyParams__val); }
|
|
oss << ", ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemcpyNodeSetParams.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphExecMemsetNodeSetParams:
|
|
oss << "hipDrvGraphExecMemsetNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemsetNodeSetParams.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemsetNodeSetParams.hNode);
|
|
if (data->args.hipDrvGraphExecMemsetNodeSetParams.memsetParams == NULL) oss << ", memsetParams=NULL";
|
|
else { oss << ", memsetParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemsetNodeSetParams.memsetParams__val); }
|
|
oss << ", ctx="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphExecMemsetNodeSetParams.ctx);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeGetParams:
|
|
oss << "hipDrvGraphMemcpyNodeGetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphMemcpyNodeGetParams.hNode);
|
|
if (data->args.hipDrvGraphMemcpyNodeGetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphMemcpyNodeGetParams.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvGraphMemcpyNodeSetParams:
|
|
oss << "hipDrvGraphMemcpyNodeSetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphMemcpyNodeSetParams.hNode);
|
|
if (data->args.hipDrvGraphMemcpyNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvGraphMemcpyNodeSetParams.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipDrvLaunchKernelEx:
|
|
oss << "hipDrvLaunchKernelEx(";
|
|
if (data->args.hipDrvLaunchKernelEx.config == NULL) oss << "config=NULL";
|
|
else { oss << "config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvLaunchKernelEx.config__val); }
|
|
oss << ", f="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvLaunchKernelEx.f);
|
|
if (data->args.hipDrvLaunchKernelEx.params == NULL) oss << ", params=NULL";
|
|
else { oss << ", params="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvLaunchKernelEx.params__val); }
|
|
if (data->args.hipDrvLaunchKernelEx.extra == NULL) oss << ", extra=NULL";
|
|
else { oss << ", extra="; roctracer::hip_support::detail::operator<<(oss, data->args.hipDrvLaunchKernelEx.extra__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_hipEventRecordWithFlags:
|
|
oss << "hipEventRecordWithFlags(";
|
|
oss << "event="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventRecordWithFlags.event);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventRecordWithFlags.stream);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipEventRecordWithFlags.flags);
|
|
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_hipExtGetLastError:
|
|
oss << "hipExtGetLastError(";
|
|
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_hipExternalMemoryGetMappedMipmappedArray:
|
|
oss << "hipExternalMemoryGetMappedMipmappedArray(";
|
|
if (data->args.hipExternalMemoryGetMappedMipmappedArray.mipmap == NULL) oss << "mipmap=NULL";
|
|
else { oss << "mipmap="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedMipmappedArray.mipmap__val); }
|
|
oss << ", extMem="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedMipmappedArray.extMem);
|
|
if (data->args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc == NULL) oss << ", mipmapDesc=NULL";
|
|
else { oss << ", mipmapDesc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipExternalMemoryGetMappedMipmappedArray.mipmapDesc__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(";
|
|
oss << "array="; roctracer::hip_support::detail::operator<<(oss, data->args.hipFreeArray.array);
|
|
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_hipGetDevicePropertiesR0000:
|
|
oss << "hipGetDevicePropertiesR0000(";
|
|
if (data->args.hipGetDevicePropertiesR0000.prop == NULL) oss << "prop=NULL";
|
|
else { oss << "prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDevicePropertiesR0000.prop__val); }
|
|
oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDevicePropertiesR0000.device);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetDevicePropertiesR0600:
|
|
oss << "hipGetDevicePropertiesR0600(";
|
|
if (data->args.hipGetDevicePropertiesR0600.prop == NULL) oss << "prop=NULL";
|
|
else { oss << "prop="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDevicePropertiesR0600.prop__val); }
|
|
oss << ", deviceId="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetDevicePropertiesR0600.deviceId);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetErrorString:
|
|
oss << "hipGetErrorString(";
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGetFuncBySymbol:
|
|
oss << "hipGetFuncBySymbol(";
|
|
if (data->args.hipGetFuncBySymbol.functionPtr == NULL) oss << "functionPtr=NULL";
|
|
else { oss << "functionPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetFuncBySymbol.functionPtr__val); }
|
|
oss << ", symbolPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetFuncBySymbol.symbolPtr);
|
|
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_hipGetProcAddress:
|
|
oss << "hipGetProcAddress(";
|
|
if (data->args.hipGetProcAddress.symbol == NULL) oss << "symbol=NULL";
|
|
else { oss << "symbol="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetProcAddress.symbol__val); }
|
|
if (data->args.hipGetProcAddress.pfn == NULL) oss << ", pfn=NULL";
|
|
else { oss << ", pfn="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetProcAddress.pfn__val); }
|
|
oss << ", hipVersion="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetProcAddress.hipVersion);
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetProcAddress.flags);
|
|
if (data->args.hipGetProcAddress.symbolStatus == NULL) oss << ", symbolStatus=NULL";
|
|
else { oss << ", symbolStatus="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGetProcAddress.symbolStatus__val); }
|
|
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_hipGraphAddBatchMemOpNode:
|
|
oss << "hipGraphAddBatchMemOpNode(";
|
|
if (data->args.hipGraphAddBatchMemOpNode.phGraphNode == NULL) oss << "phGraphNode=NULL";
|
|
else { oss << "phGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddBatchMemOpNode.phGraphNode__val); }
|
|
oss << ", hGraph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddBatchMemOpNode.hGraph);
|
|
if (data->args.hipGraphAddBatchMemOpNode.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddBatchMemOpNode.dependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddBatchMemOpNode.numDependencies);
|
|
if (data->args.hipGraphAddBatchMemOpNode.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddBatchMemOpNode.nodeParams__val); }
|
|
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_hipGraphAddExternalSemaphoresSignalNode:
|
|
oss << "hipGraphAddExternalSemaphoresSignalNode(";
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresSignalNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresSignalNode.graph);
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresSignalNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresSignalNode.numDependencies);
|
|
if (data->args.hipGraphAddExternalSemaphoresSignalNode.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresSignalNode.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphAddExternalSemaphoresWaitNode:
|
|
oss << "hipGraphAddExternalSemaphoresWaitNode(";
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresWaitNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresWaitNode.graph);
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresWaitNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresWaitNode.numDependencies);
|
|
if (data->args.hipGraphAddExternalSemaphoresWaitNode.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddExternalSemaphoresWaitNode.nodeParams__val); }
|
|
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_hipGraphAddNode:
|
|
oss << "hipGraphAddNode(";
|
|
if (data->args.hipGraphAddNode.pGraphNode == NULL) oss << "pGraphNode=NULL";
|
|
else { oss << "pGraphNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddNode.pGraphNode__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddNode.graph);
|
|
if (data->args.hipGraphAddNode.pDependencies == NULL) oss << ", pDependencies=NULL";
|
|
else { oss << ", pDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddNode.pDependencies__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddNode.numDependencies);
|
|
if (data->args.hipGraphAddNode.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphAddNode.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeGetParams:
|
|
oss << "hipGraphBatchMemOpNodeGetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphBatchMemOpNodeGetParams.hNode);
|
|
if (data->args.hipGraphBatchMemOpNodeGetParams.nodeParams_out == NULL) oss << ", nodeParams_out=NULL";
|
|
else { oss << ", nodeParams_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphBatchMemOpNodeGetParams.nodeParams_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphBatchMemOpNodeSetParams:
|
|
oss << "hipGraphBatchMemOpNodeSetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphBatchMemOpNodeSetParams.hNode);
|
|
if (data->args.hipGraphBatchMemOpNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphBatchMemOpNodeSetParams.nodeParams__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_hipGraphExecBatchMemOpNodeSetParams:
|
|
oss << "hipGraphExecBatchMemOpNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecBatchMemOpNodeSetParams.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecBatchMemOpNodeSetParams.hNode);
|
|
if (data->args.hipGraphExecBatchMemOpNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecBatchMemOpNodeSetParams.nodeParams__val); }
|
|
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_hipGraphExecExternalSemaphoresSignalNodeSetParams:
|
|
oss << "hipGraphExecExternalSemaphoresSignalNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.hNode);
|
|
if (data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresSignalNodeSetParams.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecExternalSemaphoresWaitNodeSetParams:
|
|
oss << "hipGraphExecExternalSemaphoresWaitNodeSetParams(";
|
|
oss << "hGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.hGraphExec);
|
|
oss << ", hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.hNode);
|
|
if (data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecExternalSemaphoresWaitNodeSetParams.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExecGetFlags:
|
|
oss << "hipGraphExecGetFlags(";
|
|
oss << "graphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecGetFlags.graphExec);
|
|
if (data->args.hipGraphExecGetFlags.flags == NULL) oss << ", flags=NULL";
|
|
else { oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecGetFlags.flags__val); }
|
|
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_hipGraphExecNodeSetParams:
|
|
oss << "hipGraphExecNodeSetParams(";
|
|
oss << "graphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecNodeSetParams.graphExec);
|
|
oss << ", node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecNodeSetParams.node);
|
|
if (data->args.hipGraphExecNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExecNodeSetParams.nodeParams__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_hipGraphExternalSemaphoresSignalNodeGetParams:
|
|
oss << "hipGraphExternalSemaphoresSignalNodeGetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresSignalNodeGetParams.hNode);
|
|
if (data->args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out == NULL) oss << ", params_out=NULL";
|
|
else { oss << ", params_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresSignalNodeGetParams.params_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExternalSemaphoresSignalNodeSetParams:
|
|
oss << "hipGraphExternalSemaphoresSignalNodeSetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresSignalNodeSetParams.hNode);
|
|
if (data->args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresSignalNodeSetParams.nodeParams__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeGetParams:
|
|
oss << "hipGraphExternalSemaphoresWaitNodeGetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresWaitNodeGetParams.hNode);
|
|
if (data->args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out == NULL) oss << ", params_out=NULL";
|
|
else { oss << ", params_out="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresWaitNodeGetParams.params_out__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipGraphExternalSemaphoresWaitNodeSetParams:
|
|
oss << "hipGraphExternalSemaphoresWaitNodeSetParams(";
|
|
oss << "hNode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresWaitNodeSetParams.hNode);
|
|
if (data->args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphExternalSemaphoresWaitNodeSetParams.nodeParams__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_hipGraphInstantiateWithParams:
|
|
oss << "hipGraphInstantiateWithParams(";
|
|
if (data->args.hipGraphInstantiateWithParams.pGraphExec == NULL) oss << "pGraphExec=NULL";
|
|
else { oss << "pGraphExec="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithParams.pGraphExec__val); }
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithParams.graph);
|
|
if (data->args.hipGraphInstantiateWithParams.instantiateParams == NULL) oss << ", instantiateParams=NULL";
|
|
else { oss << ", instantiateParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphInstantiateWithParams.instantiateParams__val); }
|
|
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_hipGraphNodeSetParams:
|
|
oss << "hipGraphNodeSetParams(";
|
|
oss << "node="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeSetParams.node);
|
|
if (data->args.hipGraphNodeSetParams.nodeParams == NULL) oss << ", nodeParams=NULL";
|
|
else { oss << ", nodeParams="; roctracer::hip_support::detail::operator<<(oss, data->args.hipGraphNodeSetParams.nodeParams__val); }
|
|
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_hipLaunchKernelExC:
|
|
oss << "hipLaunchKernelExC(";
|
|
if (data->args.hipLaunchKernelExC.config == NULL) oss << "config=NULL";
|
|
else { oss << "config="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernelExC.config__val); }
|
|
oss << ", fPtr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernelExC.fPtr);
|
|
if (data->args.hipLaunchKernelExC.args == NULL) oss << ", args=NULL";
|
|
else { oss << ", args="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLaunchKernelExC.args__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLinkAddData:
|
|
oss << "hipLinkAddData(";
|
|
oss << "state="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.state);
|
|
oss << ", type="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.type);
|
|
oss << ", data="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.data);
|
|
oss << ", size="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.size);
|
|
if (data->args.hipLinkAddData.name == NULL) oss << ", name=NULL";
|
|
else { oss << ", name="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.name__val); }
|
|
oss << ", numOptions="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.numOptions);
|
|
if (data->args.hipLinkAddData.options == NULL) oss << ", options=NULL";
|
|
else { oss << ", options="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.options__val); }
|
|
if (data->args.hipLinkAddData.optionValues == NULL) oss << ", optionValues=NULL";
|
|
else { oss << ", optionValues="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddData.optionValues__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLinkAddFile:
|
|
oss << "hipLinkAddFile(";
|
|
oss << "state="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.state);
|
|
oss << ", type="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.type);
|
|
if (data->args.hipLinkAddFile.path == NULL) oss << ", path=NULL";
|
|
else { oss << ", path="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.path__val); }
|
|
oss << ", numOptions="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.numOptions);
|
|
if (data->args.hipLinkAddFile.options == NULL) oss << ", options=NULL";
|
|
else { oss << ", options="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.options__val); }
|
|
if (data->args.hipLinkAddFile.optionValues == NULL) oss << ", optionValues=NULL";
|
|
else { oss << ", optionValues="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkAddFile.optionValues__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLinkComplete:
|
|
oss << "hipLinkComplete(";
|
|
oss << "state="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkComplete.state);
|
|
if (data->args.hipLinkComplete.hipBinOut == NULL) oss << ", hipBinOut=NULL";
|
|
else { oss << ", hipBinOut="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkComplete.hipBinOut__val); }
|
|
if (data->args.hipLinkComplete.sizeOut == NULL) oss << ", sizeOut=NULL";
|
|
else { oss << ", sizeOut="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkComplete.sizeOut__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLinkCreate:
|
|
oss << "hipLinkCreate(";
|
|
oss << "numOptions="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkCreate.numOptions);
|
|
if (data->args.hipLinkCreate.options == NULL) oss << ", options=NULL";
|
|
else { oss << ", options="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkCreate.options__val); }
|
|
if (data->args.hipLinkCreate.optionValues == NULL) oss << ", optionValues=NULL";
|
|
else { oss << ", optionValues="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkCreate.optionValues__val); }
|
|
if (data->args.hipLinkCreate.stateOut == NULL) oss << ", stateOut=NULL";
|
|
else { oss << ", stateOut="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkCreate.stateOut__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipLinkDestroy:
|
|
oss << "hipLinkDestroy(";
|
|
oss << "state="; roctracer::hip_support::detail::operator<<(oss, data->args.hipLinkDestroy.state);
|
|
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, 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_hipMemcpy2DArrayToArray:
|
|
oss << "hipMemcpy2DArrayToArray(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.dst);
|
|
oss << ", wOffsetDst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.wOffsetDst);
|
|
oss << ", hOffsetDst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.hOffsetDst);
|
|
oss << ", src="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.src);
|
|
oss << ", wOffsetSrc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.wOffsetSrc);
|
|
oss << ", hOffsetSrc="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.hOffsetSrc);
|
|
oss << ", width="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.width);
|
|
oss << ", height="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.height);
|
|
oss << ", kind="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DArrayToArray.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(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArray.dst);
|
|
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(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpy2DToArrayAsync.dst);
|
|
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_hipMemcpyAtoA:
|
|
oss << "hipMemcpyAtoA(";
|
|
oss << "dstArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoA.dstArray);
|
|
oss << ", dstOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoA.dstOffset);
|
|
oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoA.srcArray);
|
|
oss << ", srcOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoA.srcOffset);
|
|
oss << ", ByteCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoA.ByteCount);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyAtoD:
|
|
oss << "hipMemcpyAtoD(";
|
|
oss << "dstDevice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoD.dstDevice);
|
|
oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoD.srcArray);
|
|
oss << ", srcOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoD.srcOffset);
|
|
oss << ", ByteCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoD.ByteCount);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyAtoH:
|
|
oss << "hipMemcpyAtoH(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.dst);
|
|
oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoH.srcArray);
|
|
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_hipMemcpyAtoHAsync:
|
|
oss << "hipMemcpyAtoHAsync(";
|
|
oss << "dstHost="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoHAsync.dstHost);
|
|
oss << ", srcArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoHAsync.srcArray);
|
|
oss << ", srcOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoHAsync.srcOffset);
|
|
oss << ", ByteCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoHAsync.ByteCount);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyAtoHAsync.stream);
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipMemcpyDtoA:
|
|
oss << "hipMemcpyDtoA(";
|
|
oss << "dstArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoA.dstArray);
|
|
oss << ", dstOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoA.dstOffset);
|
|
oss << ", srcDevice="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoA.srcDevice);
|
|
oss << ", ByteCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyDtoA.ByteCount);
|
|
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(";
|
|
oss << "dstArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoA.dstArray);
|
|
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_hipMemcpyHtoAAsync:
|
|
oss << "hipMemcpyHtoAAsync(";
|
|
oss << "dstArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoAAsync.dstArray);
|
|
oss << ", dstOffset="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoAAsync.dstOffset);
|
|
oss << ", srcHost="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoAAsync.srcHost);
|
|
oss << ", ByteCount="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoAAsync.ByteCount);
|
|
oss << ", stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyHtoAAsync.stream);
|
|
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(";
|
|
oss << "dst="; roctracer::hip_support::detail::operator<<(oss, data->args.hipMemcpyToArray.dst);
|
|
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_hipSetValidDevices:
|
|
oss << "hipSetValidDevices(";
|
|
if (data->args.hipSetValidDevices.device_arr == NULL) oss << "device_arr=NULL";
|
|
else { oss << "device_arr="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetValidDevices.device_arr__val); }
|
|
oss << ", len="; roctracer::hip_support::detail::operator<<(oss, data->args.hipSetValidDevices.len);
|
|
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_hipStreamBatchMemOp:
|
|
oss << "hipStreamBatchMemOp(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBatchMemOp.stream);
|
|
oss << ", count="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBatchMemOp.count);
|
|
if (data->args.hipStreamBatchMemOp.paramArray == NULL) oss << ", paramArray=NULL";
|
|
else { oss << ", paramArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBatchMemOp.paramArray__val); }
|
|
oss << ", flags="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBatchMemOp.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_hipStreamBeginCaptureToGraph:
|
|
oss << "hipStreamBeginCaptureToGraph(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.stream);
|
|
oss << ", graph="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.graph);
|
|
if (data->args.hipStreamBeginCaptureToGraph.dependencies == NULL) oss << ", dependencies=NULL";
|
|
else { oss << ", dependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.dependencies__val); }
|
|
if (data->args.hipStreamBeginCaptureToGraph.dependencyData == NULL) oss << ", dependencyData=NULL";
|
|
else { oss << ", dependencyData="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.dependencyData__val); }
|
|
oss << ", numDependencies="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.numDependencies);
|
|
oss << ", mode="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamBeginCaptureToGraph.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_hipStreamGetDevice:
|
|
oss << "hipStreamGetDevice(";
|
|
oss << "stream="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetDevice.stream);
|
|
if (data->args.hipStreamGetDevice.device == NULL) oss << ", device=NULL";
|
|
else { oss << ", device="; roctracer::hip_support::detail::operator<<(oss, data->args.hipStreamGetDevice.device__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_hipTexRefGetArray:
|
|
oss << "hipTexRefGetArray(";
|
|
if (data->args.hipTexRefGetArray.pArray == NULL) oss << "pArray=NULL";
|
|
else { oss << "pArray="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetArray.pArray__val); }
|
|
if (data->args.hipTexRefGetArray.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetArray.texRef__val); }
|
|
oss << ")";
|
|
break;
|
|
case HIP_API_ID_hipTexRefGetBorderColor:
|
|
oss << "hipTexRefGetBorderColor(";
|
|
if (data->args.hipTexRefGetBorderColor.pBorderColor == NULL) oss << "pBorderColor=NULL";
|
|
else { oss << "pBorderColor="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetBorderColor.pBorderColor__val); }
|
|
if (data->args.hipTexRefGetBorderColor.texRef == NULL) oss << ", texRef=NULL";
|
|
else { oss << ", texRef="; roctracer::hip_support::detail::operator<<(oss, data->args.hipTexRefGetBorderColor.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
|