From b26650c7b064e059ee8b7f86f84d94e037371183 Mon Sep 17 00:00:00 2001 From: "Anton V. Gorshkov" Date: Mon, 13 May 2019 09:30:40 +0200 Subject: [PATCH] Added host-side API tracing support Change-Id: Id473243344d76e58e326c5a1cb487c57cf5c736c Signed-off-by: Anton V Gorshkov --- Jenkinsfile | 4 +- runtime/api/api.cpp | 438 +- runtime/api/api.h | 30 + runtime/sharings/gl/cl_gl_api.cpp | 62 +- runtime/tracing/CMakeLists.txt | 16 + runtime/tracing/tracing_api.cpp | 192 + runtime/tracing/tracing_api.h | 26 + runtime/tracing/tracing_handle.h | 47 + runtime/tracing/tracing_notify.h | 7989 +++++++++++++++++ runtime/tracing/tracing_types.h | 1094 +++ unit_tests/api/CMakeLists.txt | 1 + unit_tests/api/api_tests_wrapper3.cpp | 3 +- unit_tests/api/cl_api_tests.h | 1 + ...on_function_address_for_platform_tests.inl | 30 + ...l_get_extension_function_address_tests.inl | 29 + unit_tests/api/cl_intel_tracing_tests.inl | 867 ++ unit_tests/api/cl_intel_tracing_tests_mt.cpp | 122 + unit_tests/api/gl/CMakeLists.txt | 3 +- .../api/gl/cl_gl_intel_tracing_tests.cpp | 132 + unit_tests/mt_tests/api/CMakeLists.txt | 3 +- 20 files changed, 11039 insertions(+), 50 deletions(-) create mode 100644 runtime/tracing/CMakeLists.txt create mode 100644 runtime/tracing/tracing_api.cpp create mode 100644 runtime/tracing/tracing_api.h create mode 100644 runtime/tracing/tracing_handle.h create mode 100644 runtime/tracing/tracing_notify.h create mode 100644 runtime/tracing/tracing_types.h create mode 100644 unit_tests/api/cl_intel_tracing_tests.inl create mode 100644 unit_tests/api/cl_intel_tracing_tests_mt.cpp create mode 100644 unit_tests/api/gl/cl_gl_intel_tracing_tests.cpp diff --git a/Jenkinsfile b/Jenkinsfile index d427711124..878607095b 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -1,5 +1,5 @@ #!groovy dependenciesRevision='a66ac3f752b1b9dd54de3e8008615ca8ca85ccde-1256' strategy='EQUAL' -allowedCD=274 -allowedF=4 +allowedCD=268 +allowedF=5 diff --git a/runtime/api/api.cpp b/runtime/api/api.cpp index e98fa982b3..c6eca7a566 100644 --- a/runtime/api/api.cpp +++ b/runtime/api/api.cpp @@ -36,6 +36,8 @@ #include "runtime/program/program.h" #include "runtime/sampler/sampler.h" #include "runtime/sharings/sharing_factory.h" +#include "runtime/tracing/tracing_api.h" +#include "runtime/tracing/tracing_notify.h" #include "runtime/utilities/api_intercept.h" #include "runtime/utilities/stackvec.h" @@ -50,6 +52,7 @@ using namespace NEO; cl_int CL_API_CALL clGetPlatformIDs(cl_uint numEntries, cl_platform_id *platforms, cl_uint *numPlatforms) { + TRACING_ENTER(clGetPlatformIDs, &numEntries, &platforms, &numPlatforms); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("numEntries", numEntries, @@ -90,6 +93,7 @@ cl_int CL_API_CALL clGetPlatformIDs(cl_uint numEntries, *numPlatforms = 1; } } while (false); + TRACING_EXIT(clGetPlatformIDs, &retVal); return retVal; } @@ -110,6 +114,7 @@ cl_int CL_API_CALL clGetPlatformInfo(cl_platform_id platform, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetPlatformInfo, &platform, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_INVALID_PLATFORM; API_ENTER(&retVal); DBG_LOG_INPUTS("platform", platform, @@ -122,6 +127,7 @@ cl_int CL_API_CALL clGetPlatformInfo(cl_platform_id platform, retVal = pPlatform->getInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetPlatformInfo, &retVal); return retVal; } @@ -130,6 +136,7 @@ cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform, cl_uint numEntries, cl_device_id *devices, cl_uint *numDevices) { + TRACING_ENTER(clGetDeviceIDs, &platform, &deviceType, &numEntries, &devices, &numDevices); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("platform", platform, @@ -212,6 +219,7 @@ cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform, if (retNum == 0) retVal = CL_DEVICE_NOT_FOUND; } while (false); + TRACING_EXIT(clGetDeviceIDs, &retVal); return retVal; } @@ -220,6 +228,7 @@ cl_int CL_API_CALL clGetDeviceInfo(cl_device_id device, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetDeviceInfo, &device, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_INVALID_DEVICE; API_ENTER(&retVal); DBG_LOG_INPUTS("clDevice", device, "paramName", paramName, "paramValueSize", paramValueSize, "paramValue", DebugManager.infoPointerToString(paramValue, paramValueSize), "paramValueSizeRet", paramValueSizeRet); @@ -229,6 +238,7 @@ cl_int CL_API_CALL clGetDeviceInfo(cl_device_id device, retVal = pDevice->getDeviceInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetDeviceInfo, &retVal); return retVal; } @@ -237,6 +247,7 @@ cl_int CL_API_CALL clCreateSubDevices(cl_device_id inDevice, cl_uint numDevices, cl_device_id *outDevices, cl_uint *numDevicesRet) { + TRACING_ENTER(clCreateSubDevices, &inDevice, &properties, &numDevices, &outDevices, &numDevicesRet); cl_int retVal = CL_INVALID_DEVICE; API_ENTER(&retVal); DBG_LOG_INPUTS("inDevice", inDevice, @@ -245,10 +256,12 @@ cl_int CL_API_CALL clCreateSubDevices(cl_device_id inDevice, "outDevices:", outDevices, "numDevicesRet", numDevicesRet); + TRACING_EXIT(clCreateSubDevices, &retVal); return retVal; } cl_int CL_API_CALL clRetainDevice(cl_device_id device) { + TRACING_ENTER(clRetainDevice, &device); cl_int retVal = CL_INVALID_DEVICE; API_ENTER(&retVal); DBG_LOG_INPUTS("device", device); @@ -258,10 +271,12 @@ cl_int CL_API_CALL clRetainDevice(cl_device_id device) { retVal = CL_SUCCESS; } + TRACING_EXIT(clRetainDevice, &retVal); return retVal; } cl_int CL_API_CALL clReleaseDevice(cl_device_id device) { + TRACING_ENTER(clReleaseDevice, &device); cl_int retVal = CL_INVALID_DEVICE; API_ENTER(&retVal); DBG_LOG_INPUTS("device", device); @@ -271,6 +286,7 @@ cl_int CL_API_CALL clReleaseDevice(cl_device_id device) { retVal = CL_SUCCESS; } + TRACING_EXIT(clReleaseDevice, &retVal); return retVal; } @@ -281,6 +297,7 @@ cl_context CL_API_CALL clCreateContext(const cl_context_properties *properties, size_t, void *), void *userData, cl_int *errcodeRet) { + TRACING_ENTER(clCreateContext, &properties, &numDevices, &devices, &funcNotify, &userData, &errcodeRet); cl_int retVal = CL_SUCCESS; cl_context context = nullptr; @@ -314,6 +331,7 @@ cl_context CL_API_CALL clCreateContext(const cl_context_properties *properties, if (errcodeRet) { *errcodeRet = retVal; } + TRACING_EXIT(clCreateContext, &context); return context; } @@ -323,6 +341,7 @@ cl_context CL_API_CALL clCreateContextFromType(const cl_context_properties *prop size_t, void *), void *userData, cl_int *errcodeRet) { + TRACING_ENTER(clCreateContextFromType, &properties, &deviceType, &funcNotify, &userData, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("properties", properties, "deviceType", deviceType, "funcNotify", funcNotify, "userData", userData); @@ -358,32 +377,39 @@ cl_context CL_API_CALL clCreateContextFromType(const cl_context_properties *prop if (errcodeRet) { *errcodeRet = retVal; } + TRACING_EXIT(clCreateContextFromType, (cl_context *)&pContext); return pContext; } cl_int CL_API_CALL clRetainContext(cl_context context) { + TRACING_ENTER(clRetainContext, &context); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context); Context *pContext = castToObject(context); if (pContext) { pContext->retain(); + TRACING_EXIT(clRetainContext, &retVal); return retVal; } retVal = CL_INVALID_CONTEXT; + TRACING_EXIT(clRetainContext, &retVal); return retVal; } cl_int CL_API_CALL clReleaseContext(cl_context context) { + TRACING_ENTER(clReleaseContext, &context); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context); Context *pContext = castToObject(context); if (pContext) { pContext->release(); + TRACING_EXIT(clReleaseContext, &retVal); return retVal; } retVal = CL_INVALID_CONTEXT; + TRACING_EXIT(clReleaseContext, &retVal); return retVal; } @@ -392,6 +418,7 @@ cl_int CL_API_CALL clGetContextInfo(cl_context context, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetContextInfo, &context, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); auto retVal = CL_INVALID_CONTEXT; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -406,6 +433,7 @@ cl_int CL_API_CALL clGetContextInfo(cl_context context, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetContextInfo, &retVal); return retVal; } @@ -413,6 +441,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context, cl_device_id device, const cl_command_queue_properties properties, cl_int *errcodeRet) { + TRACING_ENTER(clCreateCommandQueue, &context, &device, (cl_command_queue_properties *)&properties, &errcodeRet); cl_command_queue commandQueue = nullptr; ErrorCodeHelper err(errcodeRet, CL_SUCCESS); cl_int retVal = CL_SUCCESS; @@ -461,35 +490,42 @@ cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context, err.set(retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); + TRACING_EXIT(clCreateCommandQueue, &commandQueue); return commandQueue; } cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue commandQueue) { + TRACING_ENTER(clRetainCommandQueue, &commandQueue); cl_int retVal = CL_INVALID_COMMAND_QUEUE; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); retainQueue(commandQueue, retVal); if (retVal == CL_SUCCESS) { + TRACING_EXIT(clRetainCommandQueue, &retVal); return retVal; } // if host queue not found - try to query device queue retainQueue(commandQueue, retVal); + TRACING_EXIT(clRetainCommandQueue, &retVal); return retVal; } cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue commandQueue) { + TRACING_ENTER(clReleaseCommandQueue, &commandQueue); cl_int retVal = CL_INVALID_COMMAND_QUEUE; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); releaseQueue(commandQueue, retVal); if (retVal == CL_SUCCESS) { + TRACING_EXIT(clReleaseCommandQueue, &retVal); return retVal; } // if host queue not found - try to query device queue releaseQueue(commandQueue, retVal); + TRACING_EXIT(clReleaseCommandQueue, &retVal); return retVal; } @@ -498,6 +534,7 @@ cl_int CL_API_CALL clGetCommandQueueInfo(cl_command_queue commandQueue, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetCommandQueueInfo, &commandQueue, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_INVALID_COMMAND_QUEUE; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, @@ -509,10 +546,12 @@ cl_int CL_API_CALL clGetCommandQueueInfo(cl_command_queue commandQueue, getQueueInfo(commandQueue, paramName, paramValueSize, paramValue, paramValueSizeRet, retVal); // if host queue not found - try to query device queue if (retVal == CL_SUCCESS) { + TRACING_EXIT(clGetCommandQueueInfo, &retVal); return retVal; } getQueueInfo(commandQueue, paramName, paramValueSize, paramValue, paramValueSizeRet, retVal); + TRACING_EXIT(clGetCommandQueueInfo, &retVal); return retVal; } @@ -521,12 +560,14 @@ cl_int CL_API_CALL clSetCommandQueueProperty(cl_command_queue commandQueue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties *oldProperties) { + TRACING_ENTER(clSetCommandQueueProperty, &commandQueue, &properties, &enable, &oldProperties); cl_int retVal = CL_INVALID_VALUE; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "properties", properties, "enable", enable, "oldProperties", oldProperties); + TRACING_EXIT(clSetCommandQueueProperty, &retVal); return retVal; } @@ -535,6 +576,7 @@ cl_mem CL_API_CALL clCreateBuffer(cl_context context, size_t size, void *hostPtr, cl_int *errcodeRet) { + TRACING_ENTER(clCreateBuffer, &context, &flags, &size, &hostPtr, &errcodeRet); DBG_LOG_INPUTS("cl_context", context, "cl_mem_flags", flags, "size", size, @@ -551,6 +593,7 @@ cl_mem CL_API_CALL clCreateBuffer(cl_context context, err.set(retVal); DBG_LOG_INPUTS("buffer", buffer); + TRACING_EXIT(clCreateBuffer, &buffer); return buffer; } @@ -587,6 +630,7 @@ cl_mem CL_API_CALL clCreateSubBuffer(cl_mem buffer, cl_buffer_create_type bufferCreateType, const void *bufferCreateInfo, cl_int *errcodeRet) { + TRACING_ENTER(clCreateSubBuffer, &buffer, &flags, &bufferCreateType, &bufferCreateInfo, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("buffer", buffer, @@ -681,6 +725,7 @@ cl_mem CL_API_CALL clCreateSubBuffer(cl_mem buffer, *errcodeRet = retVal; } + TRACING_EXIT(clCreateSubBuffer, &subBuffer); return subBuffer; } @@ -690,6 +735,7 @@ cl_mem CL_API_CALL clCreateImage(cl_context context, const cl_image_desc *imageDesc, void *hostPtr, cl_int *errcodeRet) { + TRACING_ENTER(clCreateImage, &context, &flags, &imageFormat, &imageDesc, &hostPtr, &errcodeRet); Context *pContext = nullptr; auto retVal = validateObjects(WithCastToInternal(context, &pContext)); @@ -727,6 +773,7 @@ cl_mem CL_API_CALL clCreateImage(cl_context context, *errcodeRet = retVal; } DBG_LOG_INPUTS("image", image); + TRACING_EXIT(clCreateImage, &image); return image; } @@ -739,6 +786,7 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context, size_t imageRowPitch, void *hostPtr, cl_int *errcodeRet) { + TRACING_ENTER(clCreateImage2D, &context, &flags, &imageFormat, &imageWidth, &imageHeight, &imageRowPitch, &hostPtr, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -767,6 +815,7 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context, *errcodeRet = retVal; } DBG_LOG_INPUTS("image 2D", image2D); + TRACING_EXIT(clCreateImage2D, &image2D); return image2D; } @@ -781,6 +830,7 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context, size_t imageSlicePitch, void *hostPtr, cl_int *errcodeRet) { + TRACING_ENTER(clCreateImage3D, &context, &flags, &imageFormat, &imageWidth, &imageHeight, &imageDepth, &imageRowPitch, &imageSlicePitch, &hostPtr, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -814,10 +864,12 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context, *errcodeRet = retVal; } DBG_LOG_INPUTS("image 3D", image3D); + TRACING_EXIT(clCreateImage3D, &image3D); return image3D; } cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) { + TRACING_ENTER(clRetainMemObject, &memobj); cl_int retVal = CL_INVALID_MEM_OBJECT; API_ENTER(&retVal); DBG_LOG_INPUTS("memobj", memobj); @@ -826,13 +878,16 @@ cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) { if (pMemObj) { pMemObj->retain(); retVal = CL_SUCCESS; + TRACING_EXIT(clRetainMemObject, &retVal); return retVal; } + TRACING_EXIT(clRetainMemObject, &retVal); return retVal; } cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj) { + TRACING_ENTER(clReleaseMemObject, &memobj); cl_int retVal = CL_INVALID_MEM_OBJECT; API_ENTER(&retVal); @@ -842,9 +897,11 @@ cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj) { if (pMemObj) { pMemObj->release(); retVal = CL_SUCCESS; + TRACING_EXIT(clReleaseMemObject, &retVal); return retVal; } + TRACING_EXIT(clReleaseMemObject, &retVal); return retVal; } @@ -854,6 +911,7 @@ cl_int CL_API_CALL clGetSupportedImageFormats(cl_context context, cl_uint numEntries, cl_image_format *imageFormats, cl_uint *numImageFormats) { + TRACING_ENTER(clGetSupportedImageFormats, &context, &flags, &imageType, &numEntries, &imageFormats, &numImageFormats); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -873,6 +931,7 @@ cl_int CL_API_CALL clGetSupportedImageFormats(cl_context context, retVal = CL_INVALID_CONTEXT; } + TRACING_EXIT(clGetSupportedImageFormats, &retVal); return retVal; } @@ -881,6 +940,7 @@ cl_int CL_API_CALL clGetMemObjectInfo(cl_mem memobj, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetMemObjectInfo, &memobj, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("memobj", memobj, @@ -891,11 +951,13 @@ cl_int CL_API_CALL clGetMemObjectInfo(cl_mem memobj, MemObj *pMemObj = nullptr; retVal = validateObjects(WithCastToInternal(memobj, &pMemObj)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clGetMemObjectInfo, &retVal); return retVal; } retVal = pMemObj->getMemObjectInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); + TRACING_EXIT(clGetMemObjectInfo, &retVal); return retVal; } @@ -904,6 +966,7 @@ cl_int CL_API_CALL clGetImageInfo(cl_mem image, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetImageInfo, &image, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("image", image, @@ -913,16 +976,19 @@ cl_int CL_API_CALL clGetImageInfo(cl_mem image, "paramValueSizeRet", paramValueSizeRet); retVal = validateObjects(image); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clGetImageInfo, &retVal); return retVal; } auto pImgObj = castToObject(image); if (pImgObj == nullptr) { retVal = CL_INVALID_MEM_OBJECT; + TRACING_EXIT(clGetImageInfo, &retVal); return retVal; } retVal = pImgObj->getImageInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); + TRACING_EXIT(clGetImageInfo, &retVal); return retVal; } @@ -964,17 +1030,20 @@ cl_int CL_API_CALL clGetImageParamsINTEL(cl_context context, cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem memobj, void(CL_CALLBACK *funcNotify)(cl_mem, void *), void *userData) { + TRACING_ENTER(clSetMemObjectDestructorCallback, &memobj, &funcNotify, &userData); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("memobj", memobj, "funcNotify", funcNotify, "userData", userData); retVal = validateObjects(memobj, (void *)funcNotify); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clSetMemObjectDestructorCallback, &retVal); return retVal; } auto pMemObj = castToObject(memobj); retVal = pMemObj->setDestructorCallback(funcNotify, userData); + TRACING_EXIT(clSetMemObjectDestructorCallback, &retVal); return retVal; } @@ -983,6 +1052,7 @@ cl_sampler CL_API_CALL clCreateSampler(cl_context context, cl_addressing_mode addressingMode, cl_filter_mode filterMode, cl_int *errcodeRet) { + TRACING_ENTER(clCreateSampler, &context, &normalizedCoords, &addressingMode, &filterMode, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -1009,32 +1079,39 @@ cl_sampler CL_API_CALL clCreateSampler(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateSampler, &sampler); return sampler; } cl_int CL_API_CALL clRetainSampler(cl_sampler sampler) { + TRACING_ENTER(clRetainSampler, &sampler); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("sampler", sampler); auto pSampler = castToObject(sampler); if (pSampler) { pSampler->retain(); + TRACING_EXIT(clRetainSampler, &retVal); return retVal; } retVal = CL_INVALID_SAMPLER; + TRACING_EXIT(clRetainSampler, &retVal); return retVal; } cl_int CL_API_CALL clReleaseSampler(cl_sampler sampler) { + TRACING_ENTER(clReleaseSampler, &sampler); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("sampler", sampler); auto pSampler = castToObject(sampler); if (pSampler) { pSampler->release(); + TRACING_EXIT(clReleaseSampler, &retVal); return retVal; } retVal = CL_INVALID_SAMPLER; + TRACING_EXIT(clReleaseSampler, &retVal); return retVal; } @@ -1043,6 +1120,7 @@ cl_int CL_API_CALL clGetSamplerInfo(cl_sampler sampler, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetSamplerInfo, &sampler, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_INVALID_SAMPLER; API_ENTER(&retVal); DBG_LOG_INPUTS("sampler", sampler, @@ -1058,6 +1136,7 @@ cl_int CL_API_CALL clGetSamplerInfo(cl_sampler sampler, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetSamplerInfo, &retVal); return retVal; } @@ -1066,6 +1145,7 @@ cl_program CL_API_CALL clCreateProgramWithSource(cl_context context, const char **strings, const size_t *lengths, cl_int *errcodeRet) { + TRACING_ENTER(clCreateProgramWithSource, &context, &count, &strings, &lengths, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -1088,6 +1168,7 @@ cl_program CL_API_CALL clCreateProgramWithSource(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateProgramWithSource, &program); return program; } @@ -1098,6 +1179,7 @@ cl_program CL_API_CALL clCreateProgramWithBinary(cl_context context, const unsigned char **binaries, cl_int *binaryStatus, cl_int *errcodeRet) { + TRACING_ENTER(clCreateProgramWithBinary, &context, &numDevices, &deviceList, &lengths, &binaries, &binaryStatus, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -1126,6 +1208,7 @@ cl_program CL_API_CALL clCreateProgramWithBinary(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateProgramWithBinary, &program); return program; } @@ -1133,6 +1216,7 @@ cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, const void *il, size_t length, cl_int *errcodeRet) { + TRACING_ENTER(clCreateProgramWithIL, &context, &il, &length, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -1153,6 +1237,7 @@ cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateProgramWithIL, &program); return program; } @@ -1161,6 +1246,7 @@ cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context context, const cl_device_id *deviceList, const char *kernelNames, cl_int *errcodeRet) { + TRACING_ENTER(clCreateProgramWithBuiltInKernels, &context, &numDevices, &deviceList, &kernelNames, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -1199,32 +1285,39 @@ cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateProgramWithBuiltInKernels, &program); return program; } cl_int CL_API_CALL clRetainProgram(cl_program program) { + TRACING_ENTER(clRetainProgram, &program); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("program", program); auto pProgram = castToObject(program); if (pProgram) { pProgram->retain(); + TRACING_EXIT(clRetainProgram, &retVal); return retVal; } retVal = CL_INVALID_PROGRAM; + TRACING_EXIT(clRetainProgram, &retVal); return retVal; } cl_int CL_API_CALL clReleaseProgram(cl_program program) { + TRACING_ENTER(clReleaseProgram, &program); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("program", program); auto pProgram = castToObject(program); if (pProgram) { pProgram->release(); + TRACING_EXIT(clReleaseProgram, &retVal); return retVal; } retVal = CL_INVALID_PROGRAM; + TRACING_EXIT(clReleaseProgram, &retVal); return retVal; } @@ -1234,6 +1327,7 @@ cl_int CL_API_CALL clBuildProgram(cl_program program, const char *options, void(CL_CALLBACK *funcNotify)(cl_program program, void *userData), void *userData) { + TRACING_ENTER(clBuildProgram, &program, &numDevices, &deviceList, &options, &funcNotify, &userData); cl_int retVal = CL_INVALID_PROGRAM; API_ENTER(&retVal); DBG_LOG_INPUTS("clProgram", program, "numDevices", numDevices, "cl_device_id", deviceList, "options", (options != nullptr) ? options : "", "funcNotify", funcNotify, "userData", userData); @@ -1243,6 +1337,7 @@ cl_int CL_API_CALL clBuildProgram(cl_program program, retVal = pProgram->build(numDevices, deviceList, options, funcNotify, userData, clCacheEnabled); } + TRACING_EXIT(clBuildProgram, &retVal); return retVal; } @@ -1255,6 +1350,7 @@ cl_int CL_API_CALL clCompileProgram(cl_program program, const char **headerIncludeNames, void(CL_CALLBACK *funcNotify)(cl_program program, void *userData), void *userData) { + TRACING_ENTER(clCompileProgram, &program, &numDevices, &deviceList, &options, &numInputHeaders, &inputHeaders, &headerIncludeNames, &funcNotify, &userData); cl_int retVal = CL_INVALID_PROGRAM; API_ENTER(&retVal); DBG_LOG_INPUTS("clProgram", program, "numDevices", numDevices, "cl_device_id", deviceList, "options", (options != nullptr) ? options : "", "numInputHeaders", numInputHeaders); @@ -1266,6 +1362,7 @@ cl_int CL_API_CALL clCompileProgram(cl_program program, funcNotify, userData); } + TRACING_EXIT(clCompileProgram, &retVal); return retVal; } @@ -1278,6 +1375,7 @@ cl_program CL_API_CALL clLinkProgram(cl_context context, void(CL_CALLBACK *funcNotify)(cl_program program, void *userData), void *userData, cl_int *errcodeRet) { + TRACING_ENTER(clLinkProgram, &context, &numDevices, &deviceList, &options, &numInputPrograms, &inputPrograms, &funcNotify, &userData, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("cl_context", context, "numDevices", numDevices, "cl_device_id", deviceList, "options", (options != nullptr) ? options : "", "numInputPrograms", numInputPrograms); @@ -1299,13 +1397,16 @@ cl_program CL_API_CALL clLinkProgram(cl_context context, err.set(retVal); + TRACING_EXIT(clLinkProgram, (cl_program *)&program); return program; } cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id platform) { + TRACING_ENTER(clUnloadPlatformCompiler, &platform); cl_int retVal = CL_OUT_OF_HOST_MEMORY; API_ENTER(&retVal); DBG_LOG_INPUTS("platform", platform); + TRACING_EXIT(clUnloadPlatformCompiler, &retVal); return retVal; } @@ -1314,6 +1415,7 @@ cl_int CL_API_CALL clGetProgramInfo(cl_program program, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetProgramInfo, &program, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("clProgram", program, "paramName", paramName, @@ -1331,6 +1433,7 @@ cl_int CL_API_CALL clGetProgramInfo(cl_program program, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetProgramInfo, &retVal); return retVal; } @@ -1340,6 +1443,7 @@ cl_int CL_API_CALL clGetProgramBuildInfo(cl_program program, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetProgramBuildInfo, &program, &device, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("clProgram", program, "cl_device_id", device, @@ -1358,12 +1462,14 @@ cl_int CL_API_CALL clGetProgramBuildInfo(cl_program program, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetProgramBuildInfo, &retVal); return retVal; } cl_kernel CL_API_CALL clCreateKernel(cl_program clProgram, const char *kernelName, cl_int *errcodeRet) { + TRACING_ENTER(clCreateKernel, &clProgram, &kernelName, &errcodeRet); API_ENTER(errcodeRet); Program *pProgram = nullptr; cl_kernel kernel = nullptr; @@ -1412,6 +1518,7 @@ cl_kernel CL_API_CALL clCreateKernel(cl_program clProgram, if (kernel != nullptr) { gtpinNotifyKernelCreate(kernel); } + TRACING_EXIT(clCreateKernel, &kernel); return kernel; } @@ -1419,6 +1526,7 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram, cl_uint numKernels, cl_kernel *kernels, cl_uint *numKernelsRet) { + TRACING_ENTER(clCreateKernelsInProgram, &clProgram, &numKernels, &kernels, &numKernelsRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("clProgram", clProgram, @@ -1432,6 +1540,7 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram, if (kernels) { if (numKernels < numKernelsInProgram) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clCreateKernelsInProgram, &retVal); return retVal; } @@ -1452,35 +1561,43 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram, if (numKernelsRet) { *numKernelsRet = static_cast(numKernelsInProgram); } + TRACING_EXIT(clCreateKernelsInProgram, &retVal); return retVal; } retVal = CL_INVALID_PROGRAM; + TRACING_EXIT(clCreateKernelsInProgram, &retVal); return retVal; } cl_int CL_API_CALL clRetainKernel(cl_kernel kernel) { + TRACING_ENTER(clRetainKernel, &kernel); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("kernel", kernel); auto pKernel = castToObject(kernel); if (pKernel) { pKernel->retain(); + TRACING_EXIT(clRetainKernel, &retVal); return retVal; } retVal = CL_INVALID_KERNEL; + TRACING_EXIT(clRetainKernel, &retVal); return retVal; } cl_int CL_API_CALL clReleaseKernel(cl_kernel kernel) { + TRACING_ENTER(clReleaseKernel, &kernel); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("kernel", kernel); auto pKernel = castToObject(kernel); if (pKernel) { pKernel->release(); + TRACING_EXIT(clReleaseKernel, &retVal); return retVal; } retVal = CL_INVALID_KERNEL; + TRACING_EXIT(clReleaseKernel, &retVal); return retVal; } @@ -1488,6 +1605,7 @@ cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel, cl_uint argIndex, size_t argSize, const void *argValue) { + TRACING_ENTER(clSetKernelArg, &kernel, &argIndex, &argSize, &argValue); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1515,6 +1633,7 @@ cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel, break; } while (false); + TRACING_EXIT(clSetKernelArg, &retVal); return retVal; } @@ -1523,6 +1642,7 @@ cl_int CL_API_CALL clGetKernelInfo(cl_kernel kernel, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetKernelInfo, &kernel, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("kernel", kernel, "paramName", paramName, @@ -1537,6 +1657,7 @@ cl_int CL_API_CALL clGetKernelInfo(cl_kernel kernel, paramValue, paramValueSizeRet) : CL_INVALID_KERNEL; + TRACING_EXIT(clGetKernelInfo, &retVal); return retVal; } @@ -1546,6 +1667,7 @@ cl_int CL_API_CALL clGetKernelArgInfo(cl_kernel kernel, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetKernelArgInfo, &kernel, &argIndx, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1565,6 +1687,7 @@ cl_int CL_API_CALL clGetKernelArgInfo(cl_kernel kernel, paramValue, paramValueSizeRet) : CL_INVALID_KERNEL; + TRACING_EXIT(clGetKernelArgInfo, &retVal); return retVal; } @@ -1574,6 +1697,7 @@ cl_int CL_API_CALL clGetKernelWorkGroupInfo(cl_kernel kernel, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetKernelWorkGroupInfo, &kernel, &device, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1593,11 +1717,13 @@ cl_int CL_API_CALL clGetKernelWorkGroupInfo(cl_kernel kernel, paramValue, paramValueSizeRet) : CL_INVALID_KERNEL; + TRACING_EXIT(clGetKernelWorkGroupInfo, &retVal); return retVal; } cl_int CL_API_CALL clWaitForEvents(cl_uint numEvents, const cl_event *eventList) { + TRACING_ENTER(clWaitForEvents, &numEvents, &eventList); auto retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1606,10 +1732,13 @@ cl_int CL_API_CALL clWaitForEvents(cl_uint numEvents, for (unsigned int i = 0; i < numEvents && retVal == CL_SUCCESS; i++) retVal = validateObjects(eventList[i]); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clWaitForEvents, &retVal); return retVal; + } retVal = Event::waitForEvents(numEvents, eventList); + TRACING_EXIT(clWaitForEvents, &retVal); return retVal; } @@ -1618,6 +1747,7 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetEventInfo, &event, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); auto retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1630,6 +1760,7 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event, Event *neoEvent = castToObject(event); if (neoEvent == nullptr) { retVal = CL_INVALID_EVENT; + TRACING_EXIT(clGetEventInfo, &retVal); return retVal; } @@ -1638,6 +1769,7 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event, switch (paramName) { default: { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clGetEventInfo, &retVal); return retVal; } // From OCL spec : @@ -1645,14 +1777,22 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event, // a nullptr value is returned." case CL_EVENT_COMMAND_QUEUE: { if (neoEvent->isUserEvent()) { - return info.set(nullptr); + retVal = info.set(nullptr); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; } - return info.set(neoEvent->getCommandQueue()); + retVal = info.set(neoEvent->getCommandQueue()); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; } case CL_EVENT_CONTEXT: - return info.set(neoEvent->getContext()); + retVal = info.set(neoEvent->getContext()); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; case CL_EVENT_COMMAND_TYPE: - return info.set(neoEvent->getCommandType()); + retVal = info.set(neoEvent->getCommandType()); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; case CL_EVENT_COMMAND_EXECUTION_STATUS: neoEvent->tryFlushEvent(); if (neoEvent->isUserEvent()) { @@ -1664,17 +1804,24 @@ cl_int CL_API_CALL clGetEventInfo(cl_event event, if (executionStatus == CL_QUEUED) { executionStatus = CL_SUBMITTED; } - return info.set(executionStatus); + retVal = info.set(executionStatus); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; } - return info.set(neoEvent->updateEventAndReturnCurrentStatus()); + retVal = info.set(neoEvent->updateEventAndReturnCurrentStatus()); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; case CL_EVENT_REFERENCE_COUNT: - return info.set(neoEvent->getReference()); + retVal = info.set(neoEvent->getReference()); + TRACING_EXIT(clGetEventInfo, &retVal); + return retVal; } } cl_event CL_API_CALL clCreateUserEvent(cl_context context, cl_int *errcodeRet) { + TRACING_ENTER(clCreateUserEvent, &context, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context); @@ -1684,17 +1831,21 @@ cl_event CL_API_CALL clCreateUserEvent(cl_context context, Context *ctx = castToObject(context); if (ctx == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + cl_event retVal = nullptr; + TRACING_EXIT(clCreateUserEvent, &retVal); + return retVal; } Event *userEvent = new UserEvent(ctx); cl_event userClEvent = userEvent; DebugManager.logInputs("cl_event", userClEvent, "UserEvent", userEvent); + TRACING_EXIT(clCreateUserEvent, &userClEvent); return userClEvent; } cl_int CL_API_CALL clRetainEvent(cl_event event) { + TRACING_ENTER(clRetainEvent, &event); auto retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1705,13 +1856,16 @@ cl_int CL_API_CALL clRetainEvent(cl_event event) { if (pEvent) { pEvent->retain(); + TRACING_EXIT(clRetainEvent, &retVal); return retVal; } retVal = CL_INVALID_EVENT; + TRACING_EXIT(clRetainEvent, &retVal); return retVal; } cl_int CL_API_CALL clReleaseEvent(cl_event event) { + TRACING_ENTER(clReleaseEvent, &event); auto retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("cl_event", event); @@ -1720,14 +1874,17 @@ cl_int CL_API_CALL clReleaseEvent(cl_event event) { if (pEvent) { pEvent->release(); + TRACING_EXIT(clReleaseEvent, &retVal); return retVal; } retVal = CL_INVALID_EVENT; + TRACING_EXIT(clReleaseEvent, &retVal); return retVal; } cl_int CL_API_CALL clSetUserEventStatus(cl_event event, cl_int executionStatus) { + TRACING_ENTER(clSetUserEventStatus, &event, &executionStatus); auto retVal = CL_SUCCESS; API_ENTER(&retVal); auto userEvent = castToObject(event); @@ -1735,20 +1892,24 @@ cl_int CL_API_CALL clSetUserEventStatus(cl_event event, if (userEvent == nullptr) { retVal = CL_INVALID_EVENT; + TRACING_EXIT(clSetUserEventStatus, &retVal); return retVal; } if (executionStatus > CL_COMPLETE) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetUserEventStatus, &retVal); return retVal; } if (!userEvent->isInitialEventStatus()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clSetUserEventStatus, &retVal); return retVal; } userEvent->setStatus(executionStatus); + TRACING_EXIT(clSetUserEventStatus, &retVal); return retVal; } @@ -1756,6 +1917,7 @@ cl_int CL_API_CALL clSetEventCallback(cl_event event, cl_int commandExecCallbackType, void(CL_CALLBACK *funcNotify)(cl_event, cl_int, void *), void *userData) { + TRACING_ENTER(clSetEventCallback, &event, &commandExecCallbackType, &funcNotify, &userData); auto retVal = CL_SUCCESS; API_ENTER(&retVal); auto eventObject = castToObject(event); @@ -1763,6 +1925,7 @@ cl_int CL_API_CALL clSetEventCallback(cl_event event, if (eventObject == nullptr) { retVal = CL_INVALID_EVENT; + TRACING_EXIT(clSetEventCallback, &retVal); return retVal; } switch (commandExecCallbackType) { @@ -1772,16 +1935,19 @@ cl_int CL_API_CALL clSetEventCallback(cl_event event, break; default: { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetEventCallback, &retVal); return retVal; } } if (funcNotify == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetEventCallback, &retVal); return retVal; } eventObject->tryFlushEvent(); eventObject->addCallback(funcNotify, commandExecCallbackType, userData); + TRACING_EXIT(clSetEventCallback, &retVal); return retVal; } @@ -1790,6 +1956,7 @@ cl_int CL_API_CALL clGetEventProfilingInfo(cl_event event, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetEventProfilingInfo, &event, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); auto retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("event", event, @@ -1801,16 +1968,20 @@ cl_int CL_API_CALL clGetEventProfilingInfo(cl_event event, if (eventObject == nullptr) { retVal = CL_INVALID_EVENT; + TRACING_EXIT(clGetEventProfilingInfo, &retVal); return retVal; } - return eventObject->getEventProfilingInfo(paramName, - paramValueSize, - paramValue, - paramValueSizeRet); + retVal = eventObject->getEventProfilingInfo(paramName, + paramValueSize, + paramValue, + paramValueSizeRet); + TRACING_EXIT(clGetEventProfilingInfo, &retVal); + return retVal; } cl_int CL_API_CALL clFlush(cl_command_queue commandQueue) { + TRACING_ENTER(clFlush, &commandQueue); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); @@ -1819,10 +1990,12 @@ cl_int CL_API_CALL clFlush(cl_command_queue commandQueue) { retVal = pCommandQueue ? pCommandQueue->flush() : CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clFlush, &retVal); return retVal; } cl_int CL_API_CALL clFinish(cl_command_queue commandQueue) { + TRACING_ENTER(clFinish, &commandQueue); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); @@ -1831,6 +2004,7 @@ cl_int CL_API_CALL clFinish(cl_command_queue commandQueue) { retVal = pCommandQueue ? pCommandQueue->finish(false) : CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clFinish, &retVal); return retVal; } @@ -1843,6 +2017,7 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueReadBuffer, &commandQueue, &buffer, &blockingRead, &offset, &cb, &ptr, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; Buffer *pBuffer = nullptr; @@ -1863,6 +2038,7 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue, if (pBuffer->readMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueReadBuffer, &retVal); return retVal; } @@ -1879,6 +2055,7 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue, } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueReadBuffer, &retVal); return retVal; } @@ -1896,6 +2073,7 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueReadBufferRect, &commandQueue, &buffer, &blockingRead, &bufferOrigin, &hostOrigin, ®ion, &bufferRowPitch, &bufferSlicePitch, &hostRowPitch, &hostSlicePitch, &ptr, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, @@ -1928,11 +2106,13 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue, ptr); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueReadBufferRect, &retVal); return retVal; } if (pBuffer->readMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueReadBufferRect, &retVal); return retVal; } @@ -1943,6 +2123,7 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue, hostRowPitch, hostSlicePitch) == false) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueReadBufferRect, &retVal); return retVal; } @@ -1960,6 +2141,7 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue, numEventsInWaitList, eventWaitList, event); + TRACING_EXIT(clEnqueueReadBufferRect, &retVal); return retVal; } @@ -1972,6 +2154,7 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueWriteBuffer, &commandQueue, &buffer, &blockingWrite, &offset, &cb, &ptr, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -1993,6 +2176,7 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue, if (pBuffer->writeMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueWriteBuffer, &retVal); return retVal; } @@ -2009,6 +2193,7 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue, } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueWriteBuffer, &retVal); return retVal; } @@ -2026,6 +2211,7 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueWriteBufferRect, &commandQueue, &buffer, &blockingWrite, &bufferOrigin, &hostOrigin, ®ion, &bufferRowPitch, &bufferSlicePitch, &hostRowPitch, &hostSlicePitch, &ptr, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2048,11 +2234,13 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue, ptr); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueWriteBufferRect, &retVal); return retVal; } if (pBuffer->writeMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueWriteBufferRect, &retVal); return retVal; } @@ -2063,6 +2251,7 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue, hostRowPitch, hostSlicePitch) == false) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueWriteBufferRect, &retVal); return retVal; } @@ -2081,6 +2270,7 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueWriteBufferRect, &retVal); return retVal; } @@ -2093,6 +2283,7 @@ cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueFillBuffer, &commandQueue, &buffer, &pattern, &patternSize, &offset, &size, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2124,6 +2315,7 @@ cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue commandQueue, eventWaitList, event); } + TRACING_EXIT(clEnqueueFillBuffer, &retVal); return retVal; } @@ -2136,6 +2328,7 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueCopyBuffer, &commandQueue, &srcBuffer, &dstBuffer, &srcOffset, &dstOffset, &cb, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2159,6 +2352,7 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue, size_t dstSize = pDstBuffer->getSize(); if (srcOffset + cb > srcSize || dstOffset + cb > dstSize) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueCopyBuffer, &retVal); return retVal; } @@ -2173,6 +2367,7 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueCopyBuffer, &retVal); return retVal; } @@ -2189,6 +2384,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueCopyBufferRect, &commandQueue, &srcBuffer, &dstBuffer, &srcOrigin, &dstOrigin, ®ion, &srcRowPitch, &srcSlicePitch, &dstRowPitch, &dstSlicePitch, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2227,6 +2423,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueCopyBufferRect, &retVal); return retVal; } @@ -2241,6 +2438,7 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueReadImage, &commandQueue, &image, &blockingRead, &origin, ®ion, &rowPitch, &slicePitch, &ptr, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; Image *pImage = nullptr; @@ -2263,15 +2461,19 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue, if (pImage->readMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueReadImage, &retVal); return retVal; } if (IsPackedYuvImage(&pImage->getImageFormat())) { retVal = validateYuvOperation(origin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueReadImage, &retVal); return retVal; + } } retVal = Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueReadImage, &retVal); return retVal; } @@ -2289,6 +2491,7 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueReadImage, &retVal); return retVal; } @@ -2303,6 +2506,7 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueWriteImage, &commandQueue, &image, &blockingWrite, &origin, ®ion, &inputRowPitch, &inputSlicePitch, &ptr, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; Image *pImage = nullptr; @@ -2324,15 +2528,19 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue, if (CL_SUCCESS == retVal) { if (pImage->writeMemObjFlagsInvalid()) { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueWriteImage, &retVal); return retVal; } if (IsPackedYuvImage(&pImage->getImageFormat())) { retVal = validateYuvOperation(origin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueWriteImage, &retVal); return retVal; + } } retVal = Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueWriteImage, &retVal); return retVal; } @@ -2350,6 +2558,7 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueWriteImage, &retVal); return retVal; } @@ -2361,6 +2570,7 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueFillImage, &commandQueue, &image, &fillColor, &origin, ®ion, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; Image *dstImage = nullptr; @@ -2383,6 +2593,7 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue, if (CL_SUCCESS == retVal) { retVal = Image::validateRegionAndOrigin(origin, region, dstImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueFillImage, &retVal); return retVal; } @@ -2396,6 +2607,7 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueFillImage, &retVal); return retVal; } @@ -2408,6 +2620,7 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueCopyImage, &commandQueue, &srcImage, &dstImage, &srcOrigin, &dstOrigin, ®ion, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; Image *pSrcImage = nullptr; @@ -2430,29 +2643,37 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue, if (CL_SUCCESS == retVal) { if (memcmp(&pSrcImage->getImageFormat(), &pDstImage->getImageFormat(), sizeof(cl_image_format))) { retVal = CL_IMAGE_FORMAT_MISMATCH; + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; } if (IsPackedYuvImage(&pSrcImage->getImageFormat())) { retVal = validateYuvOperation(srcOrigin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; + } } if (IsPackedYuvImage(&pDstImage->getImageFormat())) { retVal = validateYuvOperation(dstOrigin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; + } if (pDstImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE2D && dstOrigin[2] != 0) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; } } retVal = Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; } retVal = Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; } @@ -2467,6 +2688,7 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue, event); } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueCopyImage, &retVal); return retVal; } @@ -2479,6 +2701,7 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueCopyImageToBuffer, &commandQueue, &srcImage, &dstBuffer, &srcOrigin, ®ion, (size_t *)&dstOffset, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2502,11 +2725,14 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue, if (CL_SUCCESS == retVal) { if (IsPackedYuvImage(&pSrcImage->getImageFormat())) { retVal = validateYuvOperation(srcOrigin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImageToBuffer, &retVal); return retVal; + } } retVal = Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyImageToBuffer, &retVal); return retVal; } @@ -2522,6 +2748,7 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue, } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueCopyImageToBuffer, &retVal); return retVal; } @@ -2534,6 +2761,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueCopyBufferToImage, &commandQueue, &srcBuffer, &dstImage, &srcOffset, &dstOrigin, ®ion, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2556,11 +2784,14 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue, if (CL_SUCCESS == retVal) { if (IsPackedYuvImage(&pDstImage->getImageFormat())) { retVal = validateYuvOperation(dstOrigin, region); - if (retVal != CL_SUCCESS) + if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyBufferToImage, &retVal); return retVal; + } } retVal = Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc()); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueCopyBufferToImage, &retVal); return retVal; } @@ -2576,6 +2807,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue, } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueCopyBufferToImage, &retVal); return retVal; } @@ -2589,6 +2821,7 @@ void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue commandQueue, const cl_event *eventWaitList, cl_event *event, cl_int *errcodeRet) { + TRACING_ENTER(clEnqueueMapBuffer, &commandQueue, &buffer, &blockingMap, &mapFlags, &offset, &cb, &numEventsInWaitList, &eventWaitList, &event, &errcodeRet); void *retPtr = nullptr; ErrorCodeHelper err(errcodeRet, CL_SUCCESS); cl_int retVal; @@ -2633,6 +2866,7 @@ void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue commandQueue, err.set(retVal); DBG_LOG_INPUTS("retPtr", retPtr, "event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueMapBuffer, &retPtr); return retPtr; } @@ -2648,6 +2882,7 @@ void *CL_API_CALL clEnqueueMapImage(cl_command_queue commandQueue, const cl_event *eventWaitList, cl_event *event, cl_int *errcodeRet) { + TRACING_ENTER(clEnqueueMapImage, &commandQueue, &image, &blockingMap, &mapFlags, &origin, ®ion, &imageRowPitch, &imageSlicePitch, &numEventsInWaitList, &eventWaitList, &event, &errcodeRet); void *retPtr = nullptr; ErrorCodeHelper err(errcodeRet, CL_SUCCESS); @@ -2711,6 +2946,7 @@ void *CL_API_CALL clEnqueueMapImage(cl_command_queue commandQueue, err.set(retVal); DBG_LOG_INPUTS("retPtr", retPtr, "event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueMapImage, &retPtr); return retPtr; } @@ -2720,6 +2956,7 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueUnmapMemObject, &commandQueue, &memObj, &mappedPtr, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; MemObj *pMemObj = nullptr; @@ -2740,6 +2977,7 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue, if (retVal == CL_SUCCESS) { if (pMemObj->peekClMemObjType() == CL_MEM_OBJECT_PIPE) { retVal = CL_INVALID_MEM_OBJECT; + TRACING_EXIT(clEnqueueUnmapMemObject, &retVal); return retVal; } @@ -2747,6 +2985,7 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue, } DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueUnmapMemObject, &retVal); return retVal; } @@ -2757,6 +2996,7 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueMigrateMemObjects, &commandQueue, &numMemObjects, &memObjects, &flags, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -2774,11 +3014,13 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueMigrateMemObjects, &retVal); return retVal; } if (numMemObjects == 0 || memObjects == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueMigrateMemObjects, &retVal); return retVal; } @@ -2786,6 +3028,7 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue, if ((flags & (~allValidFlags)) != 0) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueMigrateMemObjects, &retVal); return retVal; } @@ -2796,6 +3039,7 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue, eventWaitList, event); DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueMigrateMemObjects, &retVal); return retVal; } @@ -2808,6 +3052,7 @@ cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueNDRangeKernel, &commandQueue, &kernel, &workDim, &globalWorkOffset, &globalWorkSize, &localWorkSize, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "cl_kernel", kernel, @@ -2828,6 +3073,7 @@ cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueNDRangeKernel, &retVal); return retVal; } @@ -2848,6 +3094,7 @@ cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue commandQueue, event); DBG_LOG_INPUTS("event", DebugManager.getEvents(reinterpret_cast(event), 1u)); + TRACING_EXIT(clEnqueueNDRangeKernel, &retVal); return retVal; } @@ -2856,6 +3103,7 @@ cl_int CL_API_CALL clEnqueueTask(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueTask, &commandQueue, &kernel, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "kernel", kernel, @@ -2876,6 +3124,7 @@ cl_int CL_API_CALL clEnqueueTask(cl_command_queue commandQueue, numEventsInWaitList, eventWaitList, event)); + TRACING_EXIT(clEnqueueTask, &retVal); return retVal; } @@ -2889,6 +3138,7 @@ cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueNativeKernel, &commandQueue, &userFunc, &args, &cbArgs, &numMemObjects, &memList, &argsMemLoc, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_OUT_OF_HOST_MEMORY; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "userFunc", userFunc, "args", args, @@ -2897,12 +3147,14 @@ cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue commandQueue, "eventWaitList", DebugManager.getEvents(reinterpret_cast(eventWaitList), numEventsInWaitList), "event", DebugManager.getEvents(reinterpret_cast(event), 1)); + TRACING_EXIT(clEnqueueNativeKernel, &retVal); return retVal; } // deprecated OpenCL 1.1 cl_int CL_API_CALL clEnqueueMarker(cl_command_queue commandQueue, cl_event *event) { + TRACING_ENTER(clEnqueueMarker, &commandQueue, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "cl_event", event); @@ -2913,9 +3165,11 @@ cl_int CL_API_CALL clEnqueueMarker(cl_command_queue commandQueue, 0, nullptr, event); + TRACING_EXIT(clEnqueueMarker, &retVal); return retVal; } retVal = CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clEnqueueMarker, &retVal); return retVal; } @@ -2923,6 +3177,7 @@ cl_int CL_API_CALL clEnqueueMarker(cl_command_queue commandQueue, cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue commandQueue, cl_uint numEvents, const cl_event *eventList) { + TRACING_ENTER(clEnqueueWaitForEvents, &commandQueue, &numEvents, &eventList); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, "eventList", DebugManager.getEvents(reinterpret_cast(eventList), numEvents)); @@ -2930,6 +3185,7 @@ cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue commandQueue, auto pCommandQueue = castToObject(commandQueue); if (!pCommandQueue) { retVal = CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clEnqueueWaitForEvents, &retVal); return retVal; } for (unsigned int i = 0; i < numEvents && retVal == CL_SUCCESS; i++) { @@ -2937,16 +3193,19 @@ cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue commandQueue, } if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueWaitForEvents, &retVal); return retVal; } retVal = Event::waitForEvents(numEvents, eventList); + TRACING_EXIT(clEnqueueWaitForEvents, &retVal); return retVal; } // deprecated OpenCL 1.1 cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue commandQueue) { + TRACING_ENTER(clEnqueueBarrier, &commandQueue); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue); @@ -2956,9 +3215,11 @@ cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue commandQueue) { 0, nullptr, nullptr); + TRACING_EXIT(clEnqueueBarrier, &retVal); return retVal; } retVal = CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clEnqueueBarrier, &retVal); return retVal; } @@ -2966,6 +3227,7 @@ cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueMarkerWithWaitList, &commandQueue, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DebugManager.logInputs("cl_command_queue", commandQueue, @@ -2979,19 +3241,23 @@ cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueMarkerWithWaitList, &retVal); return retVal; } - return pCommandQueue->enqueueMarkerWithWaitList( + retVal = pCommandQueue->enqueueMarkerWithWaitList( numEventsInWaitList, eventWaitList, event); + TRACING_EXIT(clEnqueueMarkerWithWaitList, &retVal); + return retVal; } cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueBarrierWithWaitList, &commandQueue, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("cl_command_queue", commandQueue, @@ -3006,12 +3272,14 @@ cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueBarrierWithWaitList, &retVal); return retVal; } retVal = pCommandQueue->enqueueBarrierWithWaitList( numEventsInWaitList, eventWaitList, event); + TRACING_EXIT(clEnqueueBarrierWithWaitList, &retVal); return retVal; } @@ -3258,13 +3526,15 @@ cl_program CL_API_CALL clCreateProgramWithILKHR(cl_context context, return program; } -#define RETURN_FUNC_PTR_IF_EXIST(name) \ - { \ - if (!strcmp(funcName, #name)) { \ - return ((void *)(name)); \ - } \ +#define RETURN_FUNC_PTR_IF_EXIST(name) \ + { \ + if (!strcmp(funcName, #name)) { \ + TRACING_EXIT(clGetExtensionFunctionAddress, (void **)&name); \ + return ((void *)(name)); \ + } \ } void *CL_API_CALL clGetExtensionFunctionAddress(const char *funcName) { + TRACING_ENTER(clGetExtensionFunctionAddress, &funcName); DBG_LOG_INPUTS("funcName", funcName); // Support an internal call by the ICD @@ -3282,34 +3552,51 @@ void *CL_API_CALL clGetExtensionFunctionAddress(const char *funcName) { RETURN_FUNC_PTR_IF_EXIST(clAddCommentINTEL); RETURN_FUNC_PTR_IF_EXIST(clEnqueueVerifyMemoryINTEL); + RETURN_FUNC_PTR_IF_EXIST(clCreateTracingHandleINTEL); + RETURN_FUNC_PTR_IF_EXIST(clSetTracingPointINTEL); + RETURN_FUNC_PTR_IF_EXIST(clDestroyTracingHandleINTEL); + RETURN_FUNC_PTR_IF_EXIST(clEnableTracingINTEL); + RETURN_FUNC_PTR_IF_EXIST(clDisableTracingINTEL); + RETURN_FUNC_PTR_IF_EXIST(clGetTracingStateINTEL); + void *ret = sharingFactory.getExtensionFunctionAddress(funcName); - if (ret != nullptr) + if (ret != nullptr) { + TRACING_EXIT(clGetExtensionFunctionAddress, &ret); return ret; + } // SPIR-V support through the cl_khr_il_program extension RETURN_FUNC_PTR_IF_EXIST(clCreateProgramWithILKHR); RETURN_FUNC_PTR_IF_EXIST(clCreateCommandQueueWithPropertiesKHR); - return getAdditionalExtensionFunctionAddress(funcName); + ret = getAdditionalExtensionFunctionAddress(funcName); + TRACING_EXIT(clGetExtensionFunctionAddress, &ret); + return ret; } // OpenCL 1.2 void *CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, const char *funcName) { + TRACING_ENTER(clGetExtensionFunctionAddressForPlatform, &platform, &funcName); DBG_LOG_INPUTS("platform", platform, "funcName", funcName); auto pPlatform = castToObject(platform); if (pPlatform == nullptr) { - return nullptr; + void *ret = nullptr; + TRACING_EXIT(clGetExtensionFunctionAddressForPlatform, &ret); + return ret; } - return clGetExtensionFunctionAddress(funcName); + void *ret = clGetExtensionFunctionAddress(funcName); + TRACING_EXIT(clGetExtensionFunctionAddressForPlatform, &ret); + return ret; } void *CL_API_CALL clSVMAlloc(cl_context context, cl_svm_mem_flags flags, size_t size, cl_uint alignment) { + TRACING_ENTER(clSVMAlloc, &context, &flags, &size, &alignment); DBG_LOG_INPUTS("context", context, "flags", flags, "size", size, @@ -3321,6 +3608,7 @@ void *CL_API_CALL clSVMAlloc(cl_context context, Context *pContext = nullptr; if (validateObjects(WithCastToInternal(context, &pContext), pDevice) != CL_SUCCESS) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } @@ -3339,23 +3627,28 @@ void *CL_API_CALL clSVMAlloc(cl_context context, (flags == (CL_MEM_WRITE_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) || (flags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER)) || (flags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)))) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } if ((size == 0) || (size > pDevice->getDeviceInfo().maxMemAllocSize)) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } if ((alignment && (alignment & (alignment - 1))) || (alignment > sizeof(cl_ulong16))) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } const HardwareInfo &hwInfo = pDevice->getHardwareInfo(); if (!hwInfo.capabilityTable.ftrSvm) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } if (!hwInfo.capabilityTable.ftrSupportsCoherency && (flags & (CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS))) { + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } @@ -3364,17 +3657,20 @@ void *CL_API_CALL clSVMAlloc(cl_context context, if (pContext->isProvidingPerformanceHints()) { pContext->providePerformanceHint(CL_CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL, CL_SVM_ALLOC_MEETS_ALIGNMENT_RESTRICTIONS, pAlloc, size); } + TRACING_EXIT(clSVMAlloc, &pAlloc); return pAlloc; } void CL_API_CALL clSVMFree(cl_context context, void *svmPointer) { + TRACING_ENTER(clSVMFree, &context, &svmPointer); DBG_LOG_INPUTS("context", context, "svmPointer", svmPointer); Context *pContext = nullptr; if (validateObject(WithCastToInternal(context, &pContext)) == CL_SUCCESS) { pContext->getSVMAllocsManager()->freeSVMAlloc(svmPointer); } + TRACING_EXIT(clSVMFree, nullptr); } cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue, @@ -3388,6 +3684,7 @@ cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMFree, &commandQueue, &numSvmPointers, &svmPointers, &pfnFreeFunc, &userData, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; @@ -3407,12 +3704,14 @@ cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue, "event", DebugManager.getEvents(reinterpret_cast(event), 1)); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueSVMFree, &retVal); return retVal; } if (((svmPointers != nullptr) && (numSvmPointers == 0)) || ((svmPointers == nullptr) && (numSvmPointers != 0))) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMFree, &retVal); return retVal; } @@ -3425,6 +3724,7 @@ cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMFree, &retVal); return retVal; } @@ -3436,6 +3736,7 @@ cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMMemcpy, &commandQueue, &blockingCopy, &dstPtr, &srcPtr, &size, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; @@ -3455,11 +3756,13 @@ cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue commandQueue, "event", DebugManager.getEvents(reinterpret_cast(event), 1)); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueSVMMemcpy, &retVal); return retVal; } if ((dstPtr == nullptr) || (srcPtr == nullptr)) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMemcpy, &retVal); return retVal; } @@ -3472,6 +3775,7 @@ cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMMemcpy, &retVal); return retVal; } @@ -3483,6 +3787,7 @@ cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMMemFill, &commandQueue, &svmPtr, &pattern, &patternSize, &size, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; @@ -3502,11 +3807,13 @@ cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue commandQueue, "event", DebugManager.getEvents(reinterpret_cast(event), 1)); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueSVMMemFill, &retVal); return retVal; } if ((svmPtr == nullptr) || (size == 0)) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMemFill, &retVal); return retVal; } @@ -3519,6 +3826,7 @@ cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMMemFill, &retVal); return retVal; } @@ -3530,6 +3838,7 @@ cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMMap, &commandQueue, &blockingMap, &mapFlags, &svmPtr, &size, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; @@ -3547,11 +3856,13 @@ cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue commandQueue, "event", DebugManager.getEvents(reinterpret_cast(event), 1)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueSVMMap, &retVal); return retVal; } if ((svmPtr == nullptr) || (size == 0)) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMap, &retVal); return retVal; } @@ -3564,6 +3875,7 @@ cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMMap, &retVal); return retVal; } @@ -3572,6 +3884,7 @@ cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMUnmap, &commandQueue, &svmPtr, &numEventsInWaitList, &eventWaitList, &event); CommandQueue *pCommandQueue = nullptr; @@ -3589,6 +3902,7 @@ cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue commandQueue, "event", DebugManager.getEvents(reinterpret_cast(event), 1)); if (retVal != CL_SUCCESS) { + TRACING_EXIT(clEnqueueSVMUnmap, &retVal); return retVal; } @@ -3598,12 +3912,14 @@ cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue commandQueue, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMUnmap, &retVal); return retVal; } cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, cl_uint argIndex, const void *argValue) { + TRACING_ENTER(clSetKernelArgSVMPointer, &kernel, &argIndex, &argValue); Kernel *pKernel = nullptr; @@ -3613,11 +3929,13 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, DBG_LOG_INPUTS("kernel", kernel, "argIndex", argIndex, "argValue", argValue); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clSetKernelArgSVMPointer, &retVal); return retVal; } if (argIndex >= pKernel->getKernelArgsNumber()) { retVal = CL_INVALID_ARG_INDEX; + TRACING_EXIT(clSetKernelArgSVMPointer, &retVal); return retVal; } @@ -3631,6 +3949,7 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, if ((kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_GLOBAL) && (kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_CONSTANT)) { retVal = CL_INVALID_ARG_VALUE; + TRACING_EXIT(clSetKernelArgSVMPointer, &retVal); return retVal; } @@ -3639,11 +3958,13 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, auto svmData = svmManager->getSVMAlloc(argValue); if (svmData == nullptr) { retVal = CL_INVALID_ARG_VALUE; + TRACING_EXIT(clSetKernelArgSVMPointer, &retVal); return retVal; } pSvmAlloc = svmData->gpuAllocation; } retVal = pKernel->setArgSvmAlloc(argIndex, const_cast(argValue), pSvmAlloc); + TRACING_EXIT(clSetKernelArgSVMPointer, &retVal); return retVal; } @@ -3651,6 +3972,7 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, cl_kernel_exec_info paramName, size_t paramValueSize, const void *paramValue) { + TRACING_ENTER(clSetKernelExecInfo, &kernel, ¶mName, ¶mValueSize, ¶mValue); Kernel *pKernel = nullptr; auto retVal = validateObjects(WithCastToInternal(kernel, &pKernel)); @@ -3660,6 +3982,7 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, "paramValueSize", paramValueSize, "paramValue", DebugManager.infoPointerToString(paramValue, paramValueSize)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } @@ -3669,6 +3992,7 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, (paramValueSize % sizeof(void *)) || (paramValue == nullptr)) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } size_t numPointers = paramValueSize / sizeof(void *); @@ -3683,6 +4007,7 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, auto svmData = pKernel->getContext().getSVMAllocsManager()->getSVMAlloc((const void *)pSvmPtrList[i]); if (svmData == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } GraphicsAllocation *svmAlloc = svmData->gpuAllocation; @@ -3692,14 +4017,17 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, } case CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM: { retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } default: { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } } + TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; }; @@ -3709,6 +4037,7 @@ cl_mem CL_API_CALL clCreatePipe(cl_context context, cl_uint pipeMaxPackets, const cl_pipe_properties *properties, cl_int *errcodeRet) { + TRACING_ENTER(clCreatePipe, &context, &flags, &pipePacketSize, &pipeMaxPackets, &properties, &errcodeRet); cl_mem pipe = nullptr; cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -3762,6 +4091,7 @@ cl_mem CL_API_CALL clCreatePipe(cl_context context, *errcodeRet = retVal; } DBG_LOG_INPUTS("pipe", pipe); + TRACING_EXIT(clCreatePipe, &pipe); return pipe; } @@ -3770,6 +4100,7 @@ cl_int CL_API_CALL clGetPipeInfo(cl_mem pipe, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetPipeInfo, &pipe, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -3782,6 +4113,7 @@ cl_int CL_API_CALL clGetPipeInfo(cl_mem pipe, retVal = validateObjects(pipe); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clGetPipeInfo, &retVal); return retVal; } @@ -3789,10 +4121,12 @@ cl_int CL_API_CALL clGetPipeInfo(cl_mem pipe, if (pPipeObj == nullptr) { retVal = CL_INVALID_MEM_OBJECT; + TRACING_EXIT(clGetPipeInfo, &retVal); return retVal; } retVal = pPipeObj->getPipeInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); + TRACING_EXIT(clGetPipeInfo, &retVal); return retVal; } @@ -3800,6 +4134,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte cl_device_id device, const cl_queue_properties *properties, cl_int *errcodeRet) { + TRACING_ENTER(clCreateCommandQueueWithProperties, &context, &device, &properties, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -3818,6 +4153,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte if (CL_SUCCESS != retVal) { err.set(retVal); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } @@ -3833,6 +4169,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte tokenValue != CL_QUEUE_THROTTLE_KHR && !isExtraToken(propertiesAddress)) { err.set(CL_INVALID_VALUE); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } propertiesAddress += 2; @@ -3841,6 +4178,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte if (!verifyExtraTokens(pDevice, *pContext, properties)) { err.set(CL_INVALID_VALUE); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } @@ -3851,6 +4189,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte if (commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE)) { if (!(commandQueueProperties & static_cast(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE))) { err.set(CL_INVALID_VALUE); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } } @@ -3858,23 +4197,27 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte if (commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE_DEFAULT)) { if (!(commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE))) { err.set(CL_INVALID_VALUE); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } } else if (commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE)) { if ((maxOnDeviceQueues == 0) || ((maxOnDeviceQueues == 1) && pContext->getDefaultDeviceQueue())) { err.set(CL_OUT_OF_RESOURCES); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } } if (getCmdQueueProperties(properties, CL_QUEUE_SIZE) > maxOnDeviceQueueSize) { err.set(CL_INVALID_QUEUE_PROPERTIES); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } if (commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE)) { if (getCmdQueueProperties(properties, CL_QUEUE_PRIORITY_KHR)) { err.set(CL_INVALID_QUEUE_PROPERTIES); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } } @@ -3882,6 +4225,7 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte if (commandQueueProperties & static_cast(CL_QUEUE_ON_DEVICE)) { if (getCmdQueueProperties(properties, CL_QUEUE_THROTTLE_KHR)) { err.set(CL_INVALID_QUEUE_PROPERTIES); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } } @@ -3918,12 +4262,14 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte err.set(retVal); + TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue); return commandQueue; } cl_sampler CL_API_CALL clCreateSamplerWithProperties(cl_context context, const cl_sampler_properties *samplerProperties, cl_int *errcodeRet) { + TRACING_ENTER(clCreateSamplerWithProperties, &context, &samplerProperties, &errcodeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("context", context, @@ -3942,12 +4288,15 @@ cl_sampler CL_API_CALL clCreateSamplerWithProperties(cl_context context, *errcodeRet = retVal; } + TRACING_EXIT(clCreateSamplerWithProperties, &sampler); return sampler; } cl_int CL_API_CALL clUnloadCompiler() { + TRACING_ENTER(clUnloadCompiler); cl_int retVal = CL_OUT_OF_HOST_MEMORY; API_ENTER(&retVal); + TRACING_EXIT(clUnloadCompiler, &retVal); return retVal; } @@ -3996,6 +4345,7 @@ cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(cl_kernel kernel, cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device, cl_ulong *deviceTimestamp, cl_ulong *hostTimestamp) { + TRACING_ENTER(clGetDeviceAndHostTimer, &device, &deviceTimestamp, &hostTimestamp); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("device", device, @@ -4017,11 +4367,13 @@ cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device, } } while (false); + TRACING_EXIT(clGetDeviceAndHostTimer, &retVal); return retVal; } cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong *hostTimestamp) { + TRACING_ENTER(clGetHostTimer, &device, &hostTimestamp); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("device", device, @@ -4043,6 +4395,7 @@ cl_int CL_API_CALL clGetHostTimer(cl_device_id device, } } while (false); + TRACING_EXIT(clGetHostTimer, &retVal); return retVal; } @@ -4054,6 +4407,7 @@ cl_int CL_API_CALL clGetKernelSubGroupInfo(cl_kernel kernel, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetKernelSubGroupInfo, &kernel, &device, ¶mName, &inputValueSize, &inputValue, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("kernel", kernel, @@ -4070,18 +4424,22 @@ cl_int CL_API_CALL clGetKernelSubGroupInfo(cl_kernel kernel, WithCastToInternal(kernel, &pKernel)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clGetKernelSubGroupInfo, &retVal); return retVal; } - return pKernel->getSubGroupInfo(paramName, - inputValueSize, inputValue, - paramValueSize, paramValue, - paramValueSizeRet); + retVal = pKernel->getSubGroupInfo(paramName, + inputValueSize, inputValue, + paramValueSize, paramValue, + paramValueSizeRet); + TRACING_EXIT(clGetKernelSubGroupInfo, &retVal); + return retVal; } cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, cl_device_id device, cl_command_queue commandQueue) { + TRACING_ENTER(clSetDefaultDeviceCommandQueue, &context, &device, &commandQueue); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -4094,6 +4452,7 @@ cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, retVal = validateObjects(WithCastToInternal(context, &pContext), device); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal); return retVal; } @@ -4101,17 +4460,20 @@ cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, if (!pDeviceQueue) { retVal = CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal); return retVal; } if (&pDeviceQueue->getContext() != pContext) { retVal = CL_INVALID_COMMAND_QUEUE; + TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal); return retVal; } pContext->setDefaultDeviceQueue(pDeviceQueue); retVal = CL_SUCCESS; + TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal); return retVal; } @@ -4123,6 +4485,7 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueSVMMigrateMem, &commandQueue, &numSvmPointers, &svmPointers, &sizes, &flags, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); DBG_LOG_INPUTS("commandQueue", commandQueue, @@ -4140,11 +4503,13 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS != retVal) { + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } if (numSvmPointers == 0 || svmPointers == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } @@ -4153,6 +4518,7 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, if ((flags & (~allValidFlags)) != 0) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } auto pSvmAllocMgr = pCommandQueue->getContext().getSVMAllocsManager(); @@ -4166,12 +4532,14 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, auto svmData = pSvmAllocMgr->getSVMAlloc(svmPointers[i]); if (svmData == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } if (sizes != nullptr && sizes[i] != 0) { svmData = pSvmAllocMgr->getSVMAlloc(reinterpret_cast((size_t)svmPointers[i] + sizes[i] - 1)); if (svmData == nullptr) { retVal = CL_INVALID_VALUE; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } } @@ -4181,6 +4549,7 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, auto pEvent = castToObject(eventWaitList[i]); if (pEvent->getContext() != &pCommandQueue->getContext()) { retVal = CL_INVALID_CONTEXT; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } } @@ -4191,11 +4560,13 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, numEventsInWaitList, eventWaitList, event); + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } cl_kernel CL_API_CALL clCloneKernel(cl_kernel sourceKernel, cl_int *errcodeRet) { + TRACING_ENTER(clCloneKernel, &sourceKernel, &errcodeRet); Kernel *pSourceKernel = nullptr; Kernel *pClonedKernel = nullptr; @@ -4219,6 +4590,7 @@ cl_kernel CL_API_CALL clCloneKernel(cl_kernel sourceKernel, gtpinNotifyKernelCreate(pClonedKernel); } + TRACING_EXIT(clCloneKernel, (cl_kernel *)&pClonedKernel); return pClonedKernel; } diff --git a/runtime/api/api.h b/runtime/api/api.h index ab80ddd98c..b59ca27f8d 100644 --- a/runtime/api/api.h +++ b/runtime/api/api.h @@ -244,6 +244,11 @@ cl_program CL_API_CALL clCreateProgramWithBinary( cl_int *binaryStatus, cl_int *errcodeRet); +cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, + const void *il, + size_t length, + cl_int *errcodeRet); + cl_program CL_API_CALL clCreateProgramWithBuiltInKernels( cl_context context, cl_uint numDevices, @@ -859,6 +864,31 @@ cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device, cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong *hostTimestamp); +cl_int CL_API_CALL clGetKernelSubGroupInfo(cl_kernel kernel, + cl_device_id device, + cl_kernel_sub_group_info paramName, + size_t inputValueSize, + const void *inputValue, + size_t paramValueSize, + void *paramValue, + size_t *paramValueSizeRet); + +cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, + cl_device_id device, + cl_command_queue commandQueue); + +cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, + cl_uint numSvmPointers, + const void **svmPointers, + const size_t *sizes, + const cl_mem_migration_flags flags, + cl_uint numEventsInWaitList, + const cl_event *eventWaitList, + cl_event *event); + +cl_kernel CL_API_CALL clCloneKernel(cl_kernel sourceKernel, + cl_int *errcodeRet); + extern CL_API_ENTRY cl_command_queue CL_API_CALL clCreatePerfCountersCommandQueueINTEL( cl_context context, diff --git a/runtime/sharings/gl/cl_gl_api.cpp b/runtime/sharings/gl/cl_gl_api.cpp index 877033c836..14be3a57a4 100644 --- a/runtime/sharings/gl/cl_gl_api.cpp +++ b/runtime/sharings/gl/cl_gl_api.cpp @@ -21,6 +21,7 @@ #include "runtime/sharings/gl/gl_sharing.h" #include "runtime/sharings/gl/gl_sync_event.h" #include "runtime/sharings/gl/gl_texture.h" +#include "runtime/tracing/tracing_notify.h" #include "runtime/utilities/api_intercept.h" #include "CL/cl.h" @@ -30,6 +31,7 @@ using namespace NEO; cl_mem CL_API_CALL clCreateFromGLBuffer(cl_context context, cl_mem_flags flags, cl_GLuint bufobj, cl_int *errcodeRet) { + TRACING_ENTER(clCreateFromGLBuffer, &context, &flags, &bufobj, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context, "flags", flags, "bufobj", bufobj); @@ -41,19 +43,26 @@ cl_mem CL_API_CALL clCreateFromGLBuffer(cl_context context, cl_mem_flags flags, ErrorCodeHelper err(errcodeRet, returnCode); if (returnCode != CL_SUCCESS) { - return nullptr; + cl_mem buffer = nullptr; + TRACING_EXIT(clCreateFromGLBuffer, &buffer); + return buffer; } if (pContext->getSharing() == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + cl_mem buffer = nullptr; + TRACING_EXIT(clCreateFromGLBuffer, &buffer); + return buffer; } - return GlBuffer::createSharedGlBuffer(pContext, flags, bufobj, errcodeRet); + cl_mem buffer = GlBuffer::createSharedGlBuffer(pContext, flags, bufobj, errcodeRet); + TRACING_EXIT(clCreateFromGLBuffer, &buffer); + return buffer; } cl_mem CL_API_CALL clCreateFromGLTexture(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture, cl_int *errcodeRet) { + TRACING_ENTER(clCreateFromGLTexture, &context, &flags, &target, &miplevel, &texture, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture); @@ -65,21 +74,25 @@ cl_mem CL_API_CALL clCreateFromGLTexture(cl_context context, cl_mem_flags flags, cl_mem image = nullptr; if (returnCode != CL_SUCCESS) { - return nullptr; + TRACING_EXIT(clCreateFromGLTexture, &image); + return image; } if (pContext->getSharing() == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + TRACING_EXIT(clCreateFromGLTexture, &image); + return image; } image = GlTexture::createSharedGlTexture(pContext, flags, target, miplevel, texture, errcodeRet); DBG_LOG_INPUTS("image", image); + TRACING_EXIT(clCreateFromGLTexture, &image); return image; } // deprecated OpenCL 1.1 cl_mem CL_API_CALL clCreateFromGLTexture2D(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture, cl_int *errcodeRet) { + TRACING_ENTER(clCreateFromGLTexture2D, &context, &flags, &target, &miplevel, &texture, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture); @@ -90,22 +103,26 @@ cl_mem CL_API_CALL clCreateFromGLTexture2D(cl_context context, cl_mem_flags flag cl_mem image = nullptr; if (returnCode != CL_SUCCESS) { - return nullptr; + TRACING_EXIT(clCreateFromGLTexture2D, &image); + return image; } if (pContext->getSharing() == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + TRACING_EXIT(clCreateFromGLTexture2D, &image); + return image; } image = GlTexture::createSharedGlTexture(pContext, flags, target, miplevel, texture, errcodeRet); DBG_LOG_INPUTS("image", image); + TRACING_EXIT(clCreateFromGLTexture2D, &image); return image; } // deprecated OpenCL 1.1 cl_mem CL_API_CALL clCreateFromGLTexture3D(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture, cl_int *errcodeRet) { + TRACING_ENTER(clCreateFromGLTexture3D, &context, &flags, &target, &miplevel, &texture, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context, "flags", flags, "target", target, "miplevel", miplevel, "texture", texture); @@ -116,20 +133,24 @@ cl_mem CL_API_CALL clCreateFromGLTexture3D(cl_context context, cl_mem_flags flag cl_mem image = nullptr; if (returnCode != CL_SUCCESS) { - return nullptr; + TRACING_EXIT(clCreateFromGLTexture3D, &image); + return image; } if (pContext->getSharing() == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + TRACING_EXIT(clCreateFromGLTexture3D, &image); + return image; } image = GlTexture::createSharedGlTexture(pContext, flags, target, miplevel, texture, errcodeRet); DBG_LOG_INPUTS("image", image); + TRACING_EXIT(clCreateFromGLTexture3D, &image); return image; } cl_mem CL_API_CALL clCreateFromGLRenderbuffer(cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer, cl_int *errcodeRet) { + TRACING_ENTER(clCreateFromGLRenderbuffer, &context, &flags, &renderbuffer, &errcodeRet); API_ENTER(errcodeRet); DBG_LOG_INPUTS("context", context, "flags", flags, "renderbuffer", renderbuffer); @@ -139,18 +160,25 @@ cl_mem CL_API_CALL clCreateFromGLRenderbuffer(cl_context context, cl_mem_flags f ErrorCodeHelper err(errcodeRet, returnCode); if (returnCode != CL_SUCCESS) { - return nullptr; + cl_mem buffer = nullptr; + TRACING_EXIT(clCreateFromGLRenderbuffer, &buffer); + return buffer; } if (pContext->getSharing() == nullptr) { err.set(CL_INVALID_CONTEXT); - return nullptr; + cl_mem buffer = nullptr; + TRACING_EXIT(clCreateFromGLRenderbuffer, &buffer); + return buffer; } - return GlTexture::createSharedGlTexture(pContext, flags, GL_RENDERBUFFER_EXT, 0, renderbuffer, errcodeRet); + cl_mem buffer = GlTexture::createSharedGlTexture(pContext, flags, GL_RENDERBUFFER_EXT, 0, renderbuffer, errcodeRet); + TRACING_EXIT(clCreateFromGLRenderbuffer, &buffer); + return buffer; } cl_int CL_API_CALL clGetGLObjectInfo(cl_mem memobj, cl_gl_object_type *glObjectType, cl_GLuint *glObjectName) { + TRACING_ENTER(clGetGLObjectInfo, &memobj, &glObjectType, &glObjectName); cl_int retValue = CL_SUCCESS; API_ENTER(&retValue); DBG_LOG_INPUTS("memobj", memobj, "glObjectType", glObjectType, "glObjectName", glObjectName); @@ -162,14 +190,17 @@ cl_int CL_API_CALL clGetGLObjectInfo(cl_mem memobj, cl_gl_object_type *glObjectT handler->getGlObjectInfo(glObjectType, glObjectName); } else { retValue = CL_INVALID_GL_OBJECT; + TRACING_EXIT(clGetGLObjectInfo, &retValue); return retValue; } } + TRACING_EXIT(clGetGLObjectInfo, &retValue); return retValue; } cl_int CL_API_CALL clGetGLTextureInfo(cl_mem memobj, cl_gl_texture_info paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) { + TRACING_ENTER(clGetGLTextureInfo, &memobj, ¶mName, ¶mValueSize, ¶mValue, ¶mValueSizeRet); cl_int retValue = CL_SUCCESS; API_ENTER(&retValue); DBG_LOG_INPUTS("memobj", memobj, "paramName", paramName, "paramValueSize", paramValueSize, "paramValueSize", @@ -181,11 +212,13 @@ cl_int CL_API_CALL clGetGLTextureInfo(cl_mem memobj, cl_gl_texture_info paramNam auto glTexture = (GlTexture *)pMemObj->peekSharingHandler(); retValue = glTexture->getGlTextureInfo(paramName, paramValueSize, paramValue, paramValueSizeRet); } + TRACING_EXIT(clGetGLTextureInfo, &retValue); return retValue; } cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue commandQueue, cl_uint numObjects, const cl_mem *memObjects, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueAcquireGLObjects, &commandQueue, &numObjects, &memObjects, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -199,6 +232,7 @@ cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue commandQueue, cl_u if (retVal == CL_SUCCESS) { if (pCommandQueue->getContext().getSharing() == nullptr) { retVal = CL_INVALID_CONTEXT; + TRACING_EXIT(clEnqueueAcquireGLObjects, &retVal); return retVal; } @@ -215,11 +249,13 @@ cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue commandQueue, cl_u CL_COMMAND_ACQUIRE_GL_OBJECTS); } + TRACING_EXIT(clEnqueueAcquireGLObjects, &retVal); return retVal; } cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_uint numObjects, const cl_mem *memObjects, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *event) { + TRACING_ENTER(clEnqueueReleaseGLObjects, &commandQueue, &numObjects, &memObjects, &numEventsInWaitList, &eventWaitList, &event); cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); @@ -233,6 +269,7 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u if (retVal == CL_SUCCESS) { if (pCommandQueue->getContext().getSharing() == nullptr) { retVal = CL_INVALID_CONTEXT; + TRACING_EXIT(clEnqueueReleaseGLObjects, &retVal); return retVal; } @@ -241,6 +278,7 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u CL_COMMAND_RELEASE_GL_OBJECTS); } + TRACING_EXIT(clEnqueueReleaseGLObjects, &retVal); return retVal; } diff --git a/runtime/tracing/CMakeLists.txt b/runtime/tracing/CMakeLists.txt new file mode 100644 index 0000000000..a79fafcd70 --- /dev/null +++ b/runtime/tracing/CMakeLists.txt @@ -0,0 +1,16 @@ +# +# Copyright (C) 2019 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +set(RUNTIME_SRCS_TRACING + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/tracing_api.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/tracing_api.h + ${CMAKE_CURRENT_SOURCE_DIR}/tracing_handle.h + ${CMAKE_CURRENT_SOURCE_DIR}/tracing_notify.h + ${CMAKE_CURRENT_SOURCE_DIR}/tracing_types.h +) +target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_SRCS_TRACING}) +set_property(GLOBAL PROPERTY RUNTIME_SRCS_TRACING ${RUNTIME_SRCS_TRACING}) diff --git a/runtime/tracing/tracing_api.cpp b/runtime/tracing/tracing_api.cpp new file mode 100644 index 0000000000..7cdd636e0b --- /dev/null +++ b/runtime/tracing/tracing_api.cpp @@ -0,0 +1,192 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "runtime/tracing/tracing_api.h" + +#include "runtime/tracing/tracing_handle.h" +#include "runtime/tracing/tracing_notify.h" + +namespace HostSideTracing { + +// [XYZZ..Z] - { X - enabled/disabled bit, Y - locked/unlocked bit, ZZ..Z - client count bits } +std::atomic tracingState(0); +std::vector tracingHandle; +std::atomic tracingCorrelationId(0); + +bool addTracingClient() { + uint32_t state = tracingState.load(std::memory_order_acquire); + state = TRACING_SET_ENABLED_BIT(state); + state = TRACING_UNSET_LOCKED_BIT(state); + AtomicBackoff backoff; + while (!tracingState.compare_exchange_weak(state, state + 1, std::memory_order_release, + std::memory_order_acquire)) { + if (!TRACING_GET_ENABLED_BIT(state)) { + return false; + } else if (TRACING_GET_LOCKED_BIT(state)) { + DEBUG_BREAK_IF(TRACING_GET_CLIENT_COUNTER(state) != 0); + state = TRACING_UNSET_LOCKED_BIT(state); + backoff.pause(); + } else { + backoff.pause(); + } + } + return true; +} + +void removeTracingClient() { + DEBUG_BREAK_IF(!TRACING_GET_ENABLED_BIT(tracingState.load(std::memory_order_acquire))); + DEBUG_BREAK_IF(TRACING_GET_LOCKED_BIT(tracingState.load(std::memory_order_acquire))); + DEBUG_BREAK_IF(TRACING_GET_CLIENT_COUNTER(tracingState.load(std::memory_order_acquire)) == 0); + tracingState.fetch_sub(1, std::memory_order_acq_rel); +} + +static void LockTracingState() { + uint32_t state = tracingState.load(std::memory_order_acquire); + state = TRACING_ZERO_CLIENT_COUNTER(state); + state = TRACING_UNSET_LOCKED_BIT(state); + AtomicBackoff backoff; + while (!tracingState.compare_exchange_weak(state, TRACING_SET_LOCKED_BIT(state), + std::memory_order_release, std::memory_order_acquire)) { + state = TRACING_ZERO_CLIENT_COUNTER(state); + state = TRACING_UNSET_LOCKED_BIT(state); + backoff.pause(); + } + DEBUG_BREAK_IF(!TRACING_GET_LOCKED_BIT(tracingState.load(std::memory_order_acquire))); + DEBUG_BREAK_IF(TRACING_GET_CLIENT_COUNTER(tracingState.load(std::memory_order_acquire)) > 0); +} + +static void UnlockTracingState() { + DEBUG_BREAK_IF(!TRACING_GET_LOCKED_BIT(tracingState.load(std::memory_order_acquire))); + DEBUG_BREAK_IF(TRACING_GET_CLIENT_COUNTER(tracingState.load(std::memory_order_acquire)) > 0); + tracingState.fetch_and(~TRACING_STATE_LOCKED_BIT, std::memory_order_acq_rel); +} + +} // namespace HostSideTracing + +using namespace HostSideTracing; + +cl_int CL_API_CALL clCreateTracingHandleINTEL(cl_device_id device, cl_tracing_callback callback, void *userData, cl_tracing_handle *handle) { + if (device == nullptr || callback == nullptr || handle == nullptr) { + return CL_INVALID_VALUE; + } + + *handle = new _cl_tracing_handle; + if (*handle == nullptr) { + return CL_OUT_OF_HOST_MEMORY; + } + + (*handle)->handle = new TracingHandle(callback, userData); + if ((*handle)->handle == nullptr) { + delete *handle; + return CL_OUT_OF_HOST_MEMORY; + } + + return CL_SUCCESS; +} + +cl_int CL_API_CALL clSetTracingPointINTEL(cl_tracing_handle handle, cl_function_id fid, cl_bool enable) { + if (handle == nullptr) { + return CL_INVALID_VALUE; + } + + DEBUG_BREAK_IF(handle->handle == nullptr); + if (static_cast(fid) >= CL_FUNCTION_COUNT) { + return CL_INVALID_VALUE; + } + + handle->handle->setTracingPoint(fid, enable); + + return CL_SUCCESS; +} + +cl_int CL_API_CALL clDestroyTracingHandleINTEL(cl_tracing_handle handle) { + if (handle == nullptr) { + return CL_INVALID_VALUE; + } + + DEBUG_BREAK_IF(handle->handle == nullptr); + delete handle->handle; + delete handle; + + return CL_SUCCESS; +} + +cl_int CL_API_CALL clEnableTracingINTEL(cl_tracing_handle handle) { + if (handle == nullptr) { + return CL_INVALID_VALUE; + } + + LockTracingState(); + + DEBUG_BREAK_IF(handle->handle == nullptr); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + if (tracingHandle[i] == handle->handle) { + UnlockTracingState(); + return CL_INVALID_VALUE; + } + } + + if (tracingHandle.size() == TRACING_MAX_HANDLE_COUNT) { + UnlockTracingState(); + return CL_OUT_OF_RESOURCES; + } + + tracingHandle.push_back(handle->handle); + if (tracingHandle.size() == 1) { + tracingState.fetch_or(TRACING_STATE_ENABLED_BIT, std::memory_order_acq_rel); + } + + UnlockTracingState(); + return CL_SUCCESS; +} + +cl_int CL_API_CALL clDisableTracingINTEL(cl_tracing_handle handle) { + if (handle == nullptr) { + return CL_INVALID_VALUE; + } + + LockTracingState(); + + DEBUG_BREAK_IF(handle->handle == nullptr); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + if (tracingHandle[i] == handle->handle) { + if (tracingHandle.size() == 1) { + tracingState.fetch_and(~TRACING_STATE_ENABLED_BIT, std::memory_order_acq_rel); + std::vector().swap(tracingHandle); + } else { + tracingHandle[i] = tracingHandle[tracingHandle.size() - 1]; + tracingHandle.pop_back(); + } + UnlockTracingState(); + return CL_SUCCESS; + } + } + + UnlockTracingState(); + return CL_INVALID_VALUE; +} + +cl_int CL_API_CALL clGetTracingStateINTEL(cl_tracing_handle handle, cl_bool *enable) { + if (handle == nullptr || enable == nullptr) { + return CL_INVALID_VALUE; + } + + LockTracingState(); + + *enable = CL_FALSE; + + DEBUG_BREAK_IF(handle->handle == nullptr); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + if (tracingHandle[i] == handle->handle) { + *enable = CL_TRUE; + break; + } + } + + UnlockTracingState(); + return CL_SUCCESS; +} diff --git a/runtime/tracing/tracing_api.h b/runtime/tracing/tracing_api.h new file mode 100644 index 0000000000..5600e85c75 --- /dev/null +++ b/runtime/tracing/tracing_api.h @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "runtime/tracing/tracing_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +cl_int CL_API_CALL clCreateTracingHandleINTEL(cl_device_id device, cl_tracing_callback callback, void *userData, cl_tracing_handle *handle); +cl_int CL_API_CALL clSetTracingPointINTEL(cl_tracing_handle handle, cl_function_id fid, cl_bool enable); +cl_int CL_API_CALL clDestroyTracingHandleINTEL(cl_tracing_handle handle); + +cl_int CL_API_CALL clEnableTracingINTEL(cl_tracing_handle handle); +cl_int CL_API_CALL clDisableTracingINTEL(cl_tracing_handle handle); +cl_int CL_API_CALL clGetTracingStateINTEL(cl_tracing_handle handle, cl_bool *enable); + +#ifdef __cplusplus +} +#endif diff --git a/runtime/tracing/tracing_handle.h b/runtime/tracing/tracing_handle.h new file mode 100644 index 0000000000..e806eca90d --- /dev/null +++ b/runtime/tracing/tracing_handle.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "runtime/helpers/debug_helpers.h" +#include "runtime/tracing/tracing_types.h" + +#include +#include + +namespace HostSideTracing { + +struct TracingHandle { + public: + TracingHandle(cl_tracing_callback callback, void *userData) : callback(callback), userData(userData) {} + + void call(cl_function_id fid, cl_callback_data *callbackData) { + callback(fid, callbackData, userData); + } + + void setTracingPoint(cl_function_id fid, bool enable) { + DEBUG_BREAK_IF(static_cast(fid) >= CL_FUNCTION_COUNT); + mask[static_cast(fid)] = enable; + } + + bool getTracingPoint(cl_function_id fid) const { + DEBUG_BREAK_IF(static_cast(fid) >= CL_FUNCTION_COUNT); + return mask[static_cast(fid)]; + } + + private: + cl_tracing_callback callback; + void *userData; + std::bitset mask; +}; + +} // namespace HostSideTracing + +struct _cl_tracing_handle { + cl_device_id device; + HostSideTracing::TracingHandle *handle; +}; diff --git a/runtime/tracing/tracing_notify.h b/runtime/tracing/tracing_notify.h new file mode 100644 index 0000000000..224d0ff0aa --- /dev/null +++ b/runtime/tracing/tracing_notify.h @@ -0,0 +1,7989 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "runtime/tracing/tracing_handle.h" + +#include +#include +#include +#include + +namespace HostSideTracing { + +#define TRACING_SET_ENABLED_BIT(state) ((state) | (HostSideTracing::TRACING_STATE_ENABLED_BIT)) +#define TRACING_UNSET_ENABLED_BIT(state) ((state) & (~HostSideTracing::TRACING_STATE_ENABLED_BIT)) +#define TRACING_GET_ENABLED_BIT(state) ((state) & (HostSideTracing::TRACING_STATE_ENABLED_BIT)) + +#define TRACING_SET_LOCKED_BIT(state) ((state) | (HostSideTracing::TRACING_STATE_LOCKED_BIT)) +#define TRACING_UNSET_LOCKED_BIT(state) ((state) & (~HostSideTracing::TRACING_STATE_LOCKED_BIT)) +#define TRACING_GET_LOCKED_BIT(state) ((state) & (HostSideTracing::TRACING_STATE_LOCKED_BIT)) + +#define TRACING_ZERO_CLIENT_COUNTER(state) ((state) & (HostSideTracing::TRACING_STATE_ENABLED_BIT | HostSideTracing::TRACING_STATE_LOCKED_BIT)) +#define TRACING_GET_CLIENT_COUNTER(state) ((state) & (~(HostSideTracing::TRACING_STATE_ENABLED_BIT | HostSideTracing::TRACING_STATE_LOCKED_BIT))) + +#define TRACING_ENTER(name, ...) \ + bool isHostSideTracingEnabled_##name = false; \ + HostSideTracing::name##Tracer tracer_##name; \ + if (TRACING_GET_ENABLED_BIT(HostSideTracing::tracingState.load(std::memory_order_acquire))) { \ + isHostSideTracingEnabled_##name = HostSideTracing::addTracingClient(); \ + if (isHostSideTracingEnabled_##name) { \ + tracer_##name.enter(__VA_ARGS__); \ + } \ + } + +#define TRACING_EXIT(name, ...) \ + if (isHostSideTracingEnabled_##name) { \ + tracer_##name.exit(__VA_ARGS__); \ + HostSideTracing::removeTracingClient(); \ + } + +typedef enum _tracing_notify_state_t { + TRACING_NOTIFY_STATE_NOTHING_CALLED = 0, + TRACING_NOTIFY_STATE_ENTER_CALLED = 1, + TRACING_NOTIFY_STATE_EXIT_CALLED = 2, +} tracing_notify_state_t; + +constexpr size_t TRACING_MAX_HANDLE_COUNT = 16; + +constexpr uint32_t TRACING_STATE_ENABLED_BIT = 0x80000000u; +constexpr uint32_t TRACING_STATE_LOCKED_BIT = 0x40000000u; + +extern std::atomic tracingState; +extern std::vector tracingHandle; +extern std::atomic tracingCorrelationId; + +bool addTracingClient(); +void removeTracingClient(); + +class AtomicBackoff { + public: + AtomicBackoff() {} + + void pause() { + if (count < loopsBeforeYield) { + for (uint32_t i = 0; i < count; i++) { + _mm_pause(); + } + count *= 2; + } else { + std::this_thread::yield(); + } + } + + private: + static const uint32_t loopsBeforeYield = 16; + uint32_t count = 1; +}; + +class clBuildProgramTracer { + public: + clBuildProgramTracer() {} + + void enter(cl_program *program, + cl_uint *numDevices, + const cl_device_id **deviceList, + const char **options, + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData), + void **userData) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.numDevices = numDevices; + params.deviceList = deviceList; + params.options = options; + params.funcNotify = funcNotify; + params.userData = userData; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clBuildProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clBuildProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clBuildProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clBuildProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clBuildProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clBuildProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clBuildProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCloneKernelTracer { + public: + clCloneKernelTracer() {} + + void enter(cl_kernel *sourceKernel, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.sourceKernel = sourceKernel; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCloneKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCloneKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCloneKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_kernel *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCloneKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCloneKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCloneKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCloneKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCompileProgramTracer { + public: + clCompileProgramTracer() {} + + void enter(cl_program *program, + cl_uint *numDevices, + const cl_device_id **deviceList, + const char **options, + cl_uint *numInputHeaders, + const cl_program **inputHeaders, + const char ***headerIncludeNames, + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData), + void **userData) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.numDevices = numDevices; + params.deviceList = deviceList; + params.options = options; + params.numInputHeaders = numInputHeaders; + params.inputHeaders = inputHeaders; + params.headerIncludeNames = headerIncludeNames; + params.funcNotify = funcNotify; + params.userData = userData; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCompileProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCompileProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCompileProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCompileProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCompileProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCompileProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCompileProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateBufferTracer { + public: + clCreateBufferTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + size_t *size, + void **hostPtr, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.size = size; + params.hostPtr = hostPtr; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateCommandQueueTracer { + public: + clCreateCommandQueueTracer() {} + + void enter(cl_context *context, + cl_device_id *device, + cl_command_queue_properties *properties, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.device = device; + params.properties = properties; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateCommandQueue"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_command_queue *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateCommandQueueTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateCommandQueue params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateCommandQueueWithPropertiesTracer { + public: + clCreateCommandQueueWithPropertiesTracer() {} + + void enter(cl_context *context, + cl_device_id *device, + const cl_queue_properties **properties, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.device = device; + params.properties = properties; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateCommandQueueWithProperties"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithProperties)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateCommandQueueWithProperties, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_command_queue *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateCommandQueueWithProperties)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateCommandQueueWithProperties, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateCommandQueueWithPropertiesTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateCommandQueueWithProperties params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateContextTracer { + public: + clCreateContextTracer() {} + + void enter(const cl_context_properties **properties, + cl_uint *numDevices, + const cl_device_id **devices, + void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *), + void **userData, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.properties = properties; + params.numDevices = numDevices; + params.devices = devices; + params.funcNotify = funcNotify; + params.userData = userData; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateContext"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_context *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateContextTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateContext params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateContextFromTypeTracer { + public: + clCreateContextFromTypeTracer() {} + + void enter(const cl_context_properties **properties, + cl_device_type *deviceType, + void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *), + void **userData, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.properties = properties; + params.deviceType = deviceType; + params.funcNotify = funcNotify; + params.userData = userData; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateContextFromType"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateContextFromType)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateContextFromType, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_context *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateContextFromType)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateContextFromType, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateContextFromTypeTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateContextFromType params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateImageTracer { + public: + clCreateImageTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + const cl_image_format **imageFormat, + const cl_image_desc **imageDesc, + void **hostPtr, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.imageFormat = imageFormat; + params.imageDesc = imageDesc; + params.hostPtr = hostPtr; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateImage2DTracer { + public: + clCreateImage2DTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + const cl_image_format **imageFormat, + size_t *imageWidth, + size_t *imageHeight, + size_t *imageRowPitch, + void **hostPtr, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.imageFormat = imageFormat; + params.imageWidth = imageWidth; + params.imageHeight = imageHeight; + params.imageRowPitch = imageRowPitch; + params.hostPtr = hostPtr; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateImage2D"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage2D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage2D, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage2D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage2D, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateImage2DTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateImage2D params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateImage3DTracer { + public: + clCreateImage3DTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + const cl_image_format **imageFormat, + size_t *imageWidth, + size_t *imageHeight, + size_t *imageDepth, + size_t *imageRowPitch, + size_t *imageSlicePitch, + void **hostPtr, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.imageFormat = imageFormat; + params.imageWidth = imageWidth; + params.imageHeight = imageHeight; + params.imageDepth = imageDepth; + params.imageRowPitch = imageRowPitch; + params.imageSlicePitch = imageSlicePitch; + params.hostPtr = hostPtr; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateImage3D"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage3D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage3D, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateImage3D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateImage3D, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateImage3DTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateImage3D params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateKernelTracer { + public: + clCreateKernelTracer() {} + + void enter(cl_program *program, + const char **kernelName, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.kernelName = kernelName; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_kernel *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateKernelsInProgramTracer { + public: + clCreateKernelsInProgramTracer() {} + + void enter(cl_program *program, + cl_uint *numKernels, + cl_kernel **kernels, + cl_uint **numKernelsRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.numKernels = numKernels; + params.kernels = kernels; + params.numKernelsRet = numKernelsRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateKernelsInProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateKernelsInProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateKernelsInProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateKernelsInProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateKernelsInProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateKernelsInProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateKernelsInProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreatePipeTracer { + public: + clCreatePipeTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_uint *pipePacketSize, + cl_uint *pipeMaxPackets, + const cl_pipe_properties **properties, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.pipePacketSize = pipePacketSize; + params.pipeMaxPackets = pipeMaxPackets; + params.properties = properties; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreatePipe"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreatePipe)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreatePipe, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreatePipe)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreatePipe, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreatePipeTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreatePipe params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateProgramWithBinaryTracer { + public: + clCreateProgramWithBinaryTracer() {} + + void enter(cl_context *context, + cl_uint *numDevices, + const cl_device_id **deviceList, + const size_t **lengths, + const unsigned char ***binaries, + cl_int **binaryStatus, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.numDevices = numDevices; + params.deviceList = deviceList; + params.lengths = lengths; + params.binaries = binaries; + params.binaryStatus = binaryStatus; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateProgramWithBinary"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBinary)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithBinary, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_program *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBinary)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithBinary, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateProgramWithBinaryTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateProgramWithBinary params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateProgramWithBuiltInKernelsTracer { + public: + clCreateProgramWithBuiltInKernelsTracer() {} + + void enter(cl_context *context, + cl_uint *numDevices, + const cl_device_id **deviceList, + const char **kernelNames, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.numDevices = numDevices; + params.deviceList = deviceList; + params.kernelNames = kernelNames; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateProgramWithBuiltInKernels"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBuiltInKernels)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithBuiltInKernels, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_program *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithBuiltInKernels)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithBuiltInKernels, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateProgramWithBuiltInKernelsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateProgramWithBuiltInKernels params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateProgramWithILTracer { + public: + clCreateProgramWithILTracer() {} + + void enter(cl_context *context, + const void **il, + size_t *length, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.il = il; + params.length = length; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateProgramWithIL"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithIL)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithIL, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_program *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithIL)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithIL, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateProgramWithILTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateProgramWithIL params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateProgramWithSourceTracer { + public: + clCreateProgramWithSourceTracer() {} + + void enter(cl_context *context, + cl_uint *count, + const char ***strings, + const size_t **lengths, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.count = count; + params.strings = strings; + params.lengths = lengths; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateProgramWithSource"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithSource)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithSource, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_program *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateProgramWithSource)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateProgramWithSource, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateProgramWithSourceTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateProgramWithSource params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateSamplerTracer { + public: + clCreateSamplerTracer() {} + + void enter(cl_context *context, + cl_bool *normalizedCoords, + cl_addressing_mode *addressingMode, + cl_filter_mode *filterMode, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.normalizedCoords = normalizedCoords; + params.addressingMode = addressingMode; + params.filterMode = filterMode; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateSampler"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_sampler *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateSamplerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateSampler params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateSamplerWithPropertiesTracer { + public: + clCreateSamplerWithPropertiesTracer() {} + + void enter(cl_context *context, + const cl_sampler_properties **samplerProperties, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.samplerProperties = samplerProperties; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateSamplerWithProperties"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSamplerWithProperties)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSamplerWithProperties, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_sampler *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSamplerWithProperties)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSamplerWithProperties, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateSamplerWithPropertiesTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateSamplerWithProperties params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateSubBufferTracer { + public: + clCreateSubBufferTracer() {} + + void enter(cl_mem *buffer, + cl_mem_flags *flags, + cl_buffer_create_type *bufferCreateType, + const void **bufferCreateInfo, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.buffer = buffer; + params.flags = flags; + params.bufferCreateType = bufferCreateType; + params.bufferCreateInfo = bufferCreateInfo; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateSubBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSubBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSubBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSubBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSubBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateSubBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateSubBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateSubDevicesTracer { + public: + clCreateSubDevicesTracer() {} + + void enter(cl_device_id *inDevice, + const cl_device_partition_property **properties, + cl_uint *numDevices, + cl_device_id **outDevices, + cl_uint **numDevicesRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.inDevice = inDevice; + params.properties = properties; + params.numDevices = numDevices; + params.outDevices = outDevices; + params.numDevicesRet = numDevicesRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateSubDevices"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSubDevices)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSubDevices, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateSubDevices)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateSubDevices, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateSubDevicesTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateSubDevices params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateUserEventTracer { + public: + clCreateUserEventTracer() {} + + void enter(cl_context *context, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateUserEvent"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateUserEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateUserEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_event *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateUserEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateUserEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateUserEventTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateUserEvent params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueBarrierTracer { + public: + clEnqueueBarrierTracer() {} + + void enter(cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueBarrier"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrier)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueBarrier, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrier)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueBarrier, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueBarrierTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueBarrier params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueBarrierWithWaitListTracer { + public: + clEnqueueBarrierWithWaitListTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueBarrierWithWaitList"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrierWithWaitList)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueBarrierWithWaitList, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueBarrierWithWaitList)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueBarrierWithWaitList, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueBarrierWithWaitListTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueBarrierWithWaitList params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueCopyBufferTracer { + public: + clEnqueueCopyBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *srcBuffer, + cl_mem *dstBuffer, + size_t *srcOffset, + size_t *dstOffset, + size_t *cb, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.srcBuffer = srcBuffer; + params.dstBuffer = dstBuffer; + params.srcOffset = srcOffset; + params.dstOffset = dstOffset; + params.cb = cb; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueCopyBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueCopyBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueCopyBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueCopyBufferRectTracer { + public: + clEnqueueCopyBufferRectTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *srcBuffer, + cl_mem *dstBuffer, + const size_t **srcOrigin, + const size_t **dstOrigin, + const size_t **region, + size_t *srcRowPitch, + size_t *srcSlicePitch, + size_t *dstRowPitch, + size_t *dstSlicePitch, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.srcBuffer = srcBuffer; + params.dstBuffer = dstBuffer; + params.srcOrigin = srcOrigin; + params.dstOrigin = dstOrigin; + params.region = region; + params.srcRowPitch = srcRowPitch; + params.srcSlicePitch = srcSlicePitch; + params.dstRowPitch = dstRowPitch; + params.dstSlicePitch = dstSlicePitch; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueCopyBufferRect"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueCopyBufferRectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueCopyBufferRect params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueCopyBufferToImageTracer { + public: + clEnqueueCopyBufferToImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *srcBuffer, + cl_mem *dstImage, + size_t *srcOffset, + const size_t **dstOrigin, + const size_t **region, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.srcBuffer = srcBuffer; + params.dstImage = dstImage; + params.srcOffset = srcOffset; + params.dstOrigin = dstOrigin; + params.region = region; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueCopyBufferToImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferToImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBufferToImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyBufferToImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyBufferToImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueCopyBufferToImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueCopyBufferToImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueCopyImageTracer { + public: + clEnqueueCopyImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *srcImage, + cl_mem *dstImage, + const size_t **srcOrigin, + const size_t **dstOrigin, + const size_t **region, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.srcImage = srcImage; + params.dstImage = dstImage; + params.srcOrigin = srcOrigin; + params.dstOrigin = dstOrigin; + params.region = region; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueCopyImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueCopyImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueCopyImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueCopyImageToBufferTracer { + public: + clEnqueueCopyImageToBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *srcImage, + cl_mem *dstBuffer, + const size_t **srcOrigin, + const size_t **region, + size_t *dstOffset, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.srcImage = srcImage; + params.dstBuffer = dstBuffer; + params.srcOrigin = srcOrigin; + params.region = region; + params.dstOffset = dstOffset; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueCopyImageToBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImageToBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyImageToBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueCopyImageToBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueCopyImageToBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueCopyImageToBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueCopyImageToBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueFillBufferTracer { + public: + clEnqueueFillBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + const void **pattern, + size_t *patternSize, + size_t *offset, + size_t *size, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.pattern = pattern; + params.patternSize = patternSize; + params.offset = offset; + params.size = size; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueFillBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueFillBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueFillBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueFillBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueFillBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueFillImageTracer { + public: + clEnqueueFillImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *image, + const void **fillColor, + const size_t **origin, + const size_t **region, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.image = image; + params.fillColor = fillColor; + params.origin = origin; + params.region = region; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueFillImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueFillImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueFillImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueFillImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueFillImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueFillImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueMapBufferTracer { + public: + clEnqueueMapBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + cl_bool *blockingMap, + cl_map_flags *mapFlags, + size_t *offset, + size_t *cb, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.blockingMap = blockingMap; + params.mapFlags = mapFlags; + params.offset = offset; + params.cb = cb; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueMapBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMapBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void **retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMapBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueMapBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueMapBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueMapImageTracer { + public: + clEnqueueMapImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *image, + cl_bool *blockingMap, + cl_map_flags *mapFlags, + const size_t **origin, + const size_t **region, + size_t **imageRowPitch, + size_t **imageSlicePitch, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.image = image; + params.blockingMap = blockingMap; + params.mapFlags = mapFlags; + params.origin = origin; + params.region = region; + params.imageRowPitch = imageRowPitch; + params.imageSlicePitch = imageSlicePitch; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueMapImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMapImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void **retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMapImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMapImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueMapImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueMapImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueMarkerTracer { + public: + clEnqueueMarkerTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueMarker"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarker)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMarker, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarker)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMarker, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueMarkerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueMarker params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueMarkerWithWaitListTracer { + public: + clEnqueueMarkerWithWaitListTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueMarkerWithWaitList"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarkerWithWaitList)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMarkerWithWaitList, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMarkerWithWaitList)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMarkerWithWaitList, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueMarkerWithWaitListTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueMarkerWithWaitList params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueMigrateMemObjectsTracer { + public: + clEnqueueMigrateMemObjectsTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numMemObjects, + const cl_mem **memObjects, + cl_mem_migration_flags *flags, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numMemObjects = numMemObjects; + params.memObjects = memObjects; + params.flags = flags; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueMigrateMemObjects"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMigrateMemObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueMigrateMemObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueMigrateMemObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueMigrateMemObjectsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueMigrateMemObjects params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueNDRangeKernelTracer { + public: + clEnqueueNDRangeKernelTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_kernel *kernel, + cl_uint *workDim, + const size_t **globalWorkOffset, + const size_t **globalWorkSize, + const size_t **localWorkSize, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.kernel = kernel; + params.workDim = workDim; + params.globalWorkOffset = globalWorkOffset; + params.globalWorkSize = globalWorkSize; + params.localWorkSize = localWorkSize; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueNDRangeKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDRangeKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueNDRangeKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNDRangeKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueNDRangeKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueNDRangeKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueNDRangeKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueNativeKernelTracer { + public: + clEnqueueNativeKernelTracer() {} + + void enter(cl_command_queue *commandQueue, + void(CL_CALLBACK **userFunc)(void *), + void **args, + size_t *cbArgs, + cl_uint *numMemObjects, + const cl_mem **memList, + const void ***argsMemLoc, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.userFunc = userFunc; + params.args = args; + params.cbArgs = cbArgs; + params.numMemObjects = numMemObjects; + params.memList = memList; + params.argsMemLoc = argsMemLoc; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueNativeKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNativeKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueNativeKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueNativeKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueNativeKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueNativeKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueNativeKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueReadBufferTracer { + public: + clEnqueueReadBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + cl_bool *blockingRead, + size_t *offset, + size_t *cb, + void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.blockingRead = blockingRead; + params.offset = offset; + params.cb = cb; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueReadBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueReadBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueReadBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueReadBufferRectTracer { + public: + clEnqueueReadBufferRectTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + cl_bool *blockingRead, + const size_t **bufferOrigin, + const size_t **hostOrigin, + const size_t **region, + size_t *bufferRowPitch, + size_t *bufferSlicePitch, + size_t *hostRowPitch, + size_t *hostSlicePitch, + void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.blockingRead = blockingRead; + params.bufferOrigin = bufferOrigin; + params.hostOrigin = hostOrigin; + params.region = region; + params.bufferRowPitch = bufferRowPitch; + params.bufferSlicePitch = bufferSlicePitch; + params.hostRowPitch = hostRowPitch; + params.hostSlicePitch = hostSlicePitch; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueReadBufferRect"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueReadBufferRectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueReadBufferRect params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueReadImageTracer { + public: + clEnqueueReadImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *image, + cl_bool *blockingRead, + const size_t **origin, + const size_t **region, + size_t *rowPitch, + size_t *slicePitch, + void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.image = image; + params.blockingRead = blockingRead; + params.origin = origin; + params.region = region; + params.rowPitch = rowPitch; + params.slicePitch = slicePitch; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueReadImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReadImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReadImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueReadImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueReadImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMFreeTracer { + public: + clEnqueueSVMFreeTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numSvmPointers, + void ***svmPointers, + void(CL_CALLBACK **pfnFreeFunc)(cl_command_queue queue, cl_uint numSvmPointers, void **svmPointers, void *userData), + void **userData, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numSvmPointers = numSvmPointers; + params.svmPointers = svmPointers; + params.pfnFreeFunc = pfnFreeFunc; + params.userData = userData; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMFree"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMFree)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMFree, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMFree)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMFree, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMFreeTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMFree params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMMapTracer { + public: + clEnqueueSVMMapTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_bool *blockingMap, + cl_map_flags *mapFlags, + void **svmPtr, + size_t *size, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.blockingMap = blockingMap; + params.mapFlags = mapFlags; + params.svmPtr = svmPtr; + params.size = size; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMMap"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMap)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMap, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMap)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMap, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMMapTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMMap params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMMemFillTracer { + public: + clEnqueueSVMMemFillTracer() {} + + void enter(cl_command_queue *commandQueue, + void **svmPtr, + const void **pattern, + size_t *patternSize, + size_t *size, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.svmPtr = svmPtr; + params.pattern = pattern; + params.patternSize = patternSize; + params.size = size; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMMemFill"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemFill)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMemFill, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemFill)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMemFill, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMMemFillTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMMemFill params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMMemcpyTracer { + public: + clEnqueueSVMMemcpyTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_bool *blockingCopy, + void **dstPtr, + const void **srcPtr, + size_t *size, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.blockingCopy = blockingCopy; + params.dstPtr = dstPtr; + params.srcPtr = srcPtr; + params.size = size; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMMemcpy"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemcpy)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMemcpy, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMemcpy)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMemcpy, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMMemcpyTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMMemcpy params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMMigrateMemTracer { + public: + clEnqueueSVMMigrateMemTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numSvmPointers, + const void ***svmPointers, + const size_t **sizes, + const cl_mem_migration_flags *flags, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numSvmPointers = numSvmPointers; + params.svmPointers = svmPointers; + params.sizes = sizes; + params.flags = flags; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMMigrateMem"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMigrateMem)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMigrateMem, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMMigrateMem)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMMigrateMem, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMMigrateMemTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMMigrateMem params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueSVMUnmapTracer { + public: + clEnqueueSVMUnmapTracer() {} + + void enter(cl_command_queue *commandQueue, + void **svmPtr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.svmPtr = svmPtr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueSVMUnmap"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMUnmap)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMUnmap, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueSVMUnmap)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueSVMUnmap, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueSVMUnmapTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueSVMUnmap params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueTaskTracer { + public: + clEnqueueTaskTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_kernel *kernel, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.kernel = kernel; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueTask"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueTask)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueTask, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueTask)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueTask, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueTaskTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueTask params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueUnmapMemObjectTracer { + public: + clEnqueueUnmapMemObjectTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *memobj, + void **mappedPtr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.memobj = memobj; + params.mappedPtr = mappedPtr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueUnmapMemObject"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueUnmapMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueUnmapMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueUnmapMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueUnmapMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueUnmapMemObjectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueUnmapMemObject params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueWaitForEventsTracer { + public: + clEnqueueWaitForEventsTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numEvents, + const cl_event **eventList) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numEvents = numEvents; + params.eventList = eventList; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueWaitForEvents"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWaitForEvents)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWaitForEvents, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWaitForEvents)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWaitForEvents, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueWaitForEventsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueWaitForEvents params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueWriteBufferTracer { + public: + clEnqueueWriteBufferTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + cl_bool *blockingWrite, + size_t *offset, + size_t *cb, + const void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.blockingWrite = blockingWrite; + params.offset = offset; + params.cb = cb; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueWriteBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueWriteBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueWriteBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueWriteBufferRectTracer { + public: + clEnqueueWriteBufferRectTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *buffer, + cl_bool *blockingWrite, + const size_t **bufferOrigin, + const size_t **hostOrigin, + const size_t **region, + size_t *bufferRowPitch, + size_t *bufferSlicePitch, + size_t *hostRowPitch, + size_t *hostSlicePitch, + const void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.buffer = buffer; + params.blockingWrite = blockingWrite; + params.bufferOrigin = bufferOrigin; + params.hostOrigin = hostOrigin; + params.region = region; + params.bufferRowPitch = bufferRowPitch; + params.bufferSlicePitch = bufferSlicePitch; + params.hostRowPitch = hostRowPitch; + params.hostSlicePitch = hostSlicePitch; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueWriteBufferRect"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteBufferRect)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteBufferRect, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueWriteBufferRectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueWriteBufferRect params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueWriteImageTracer { + public: + clEnqueueWriteImageTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_mem *image, + cl_bool *blockingWrite, + const size_t **origin, + const size_t **region, + size_t *inputRowPitch, + size_t *inputSlicePitch, + const void **ptr, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.image = image; + params.blockingWrite = blockingWrite; + params.origin = origin; + params.region = region; + params.inputRowPitch = inputRowPitch; + params.inputSlicePitch = inputSlicePitch; + params.ptr = ptr; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueWriteImage"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueWriteImage)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueWriteImage, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueWriteImageTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueWriteImage params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clFinishTracer { + public: + clFinishTracer() {} + + void enter(cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clFinish"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clFinish)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clFinish, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clFinish)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clFinish, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clFinishTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clFinish params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clFlushTracer { + public: + clFlushTracer() {} + + void enter(cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clFlush"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clFlush)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clFlush, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clFlush)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clFlush, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clFlushTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clFlush params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetCommandQueueInfoTracer { + public: + clGetCommandQueueInfoTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_command_queue_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetCommandQueueInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetCommandQueueInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetCommandQueueInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetCommandQueueInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetCommandQueueInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetCommandQueueInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetCommandQueueInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetContextInfoTracer { + public: + clGetContextInfoTracer() {} + + void enter(cl_context *context, + cl_context_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetContextInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetContextInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetContextInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetContextInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetContextInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetContextInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetContextInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetDeviceAndHostTimerTracer { + public: + clGetDeviceAndHostTimerTracer() {} + + void enter(cl_device_id *device, + cl_ulong **deviceTimestamp, + cl_ulong **hostTimestamp) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.device = device; + params.deviceTimestamp = deviceTimestamp; + params.hostTimestamp = hostTimestamp; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetDeviceAndHostTimer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceAndHostTimer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceAndHostTimer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceAndHostTimer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceAndHostTimer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetDeviceAndHostTimerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetDeviceAndHostTimer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetDeviceIDsTracer { + public: + clGetDeviceIDsTracer() {} + + void enter(cl_platform_id *platform, + cl_device_type *deviceType, + cl_uint *numEntries, + cl_device_id **devices, + cl_uint **numDevices) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.platform = platform; + params.deviceType = deviceType; + params.numEntries = numEntries; + params.devices = devices; + params.numDevices = numDevices; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetDeviceIDs"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceIDs)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceIDs, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceIDs)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceIDs, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetDeviceIDsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetDeviceIDs params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetDeviceInfoTracer { + public: + clGetDeviceInfoTracer() {} + + void enter(cl_device_id *device, + cl_device_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.device = device; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetDeviceInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetDeviceInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetDeviceInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetDeviceInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetDeviceInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetEventInfoTracer { + public: + clGetEventInfoTracer() {} + + void enter(cl_event *event, + cl_event_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetEventInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetEventInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetEventInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetEventInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetEventInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetEventInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetEventInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetEventProfilingInfoTracer { + public: + clGetEventProfilingInfoTracer() {} + + void enter(cl_event *event, + cl_profiling_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetEventProfilingInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetEventProfilingInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetEventProfilingInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetEventProfilingInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetEventProfilingInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetEventProfilingInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetEventProfilingInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetExtensionFunctionAddressTracer { + public: + clGetExtensionFunctionAddressTracer() {} + + void enter(const char **funcName) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.funcName = funcName; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetExtensionFunctionAddress"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddress)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetExtensionFunctionAddress, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void **retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddress)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetExtensionFunctionAddress, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetExtensionFunctionAddressTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetExtensionFunctionAddress params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetExtensionFunctionAddressForPlatformTracer { + public: + clGetExtensionFunctionAddressForPlatformTracer() {} + + void enter(cl_platform_id *platform, + const char **funcName) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.platform = platform; + params.funcName = funcName; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetExtensionFunctionAddressForPlatform"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void **retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetExtensionFunctionAddressForPlatform, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetExtensionFunctionAddressForPlatformTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetExtensionFunctionAddressForPlatform params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetHostTimerTracer { + public: + clGetHostTimerTracer() {} + + void enter(cl_device_id *device, + cl_ulong **hostTimestamp) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.device = device; + params.hostTimestamp = hostTimestamp; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetHostTimer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetHostTimer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetHostTimer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetHostTimer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetHostTimer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetHostTimerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetHostTimer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetImageInfoTracer { + public: + clGetImageInfoTracer() {} + + void enter(cl_mem *image, + cl_image_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.image = image; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetImageInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetImageInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetImageInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetImageInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetImageInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetImageInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetImageInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetKernelArgInfoTracer { + public: + clGetKernelArgInfoTracer() {} + + void enter(cl_kernel *kernel, + cl_uint *argIndx, + cl_kernel_arg_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.argIndx = argIndx; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetKernelArgInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelArgInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelArgInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelArgInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelArgInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetKernelArgInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetKernelArgInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetKernelInfoTracer { + public: + clGetKernelInfoTracer() {} + + void enter(cl_kernel *kernel, + cl_kernel_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetKernelInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetKernelInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetKernelInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetKernelSubGroupInfoTracer { + public: + clGetKernelSubGroupInfoTracer() {} + + void enter(cl_kernel *kernel, + cl_device_id *device, + cl_kernel_sub_group_info *paramName, + size_t *inputValueSize, + const void **inputValue, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.device = device; + params.paramName = paramName; + params.inputValueSize = inputValueSize; + params.inputValue = inputValue; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetKernelSubGroupInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelSubGroupInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelSubGroupInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelSubGroupInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetKernelSubGroupInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetKernelSubGroupInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetKernelWorkGroupInfoTracer { + public: + clGetKernelWorkGroupInfoTracer() {} + + void enter(cl_kernel *kernel, + cl_device_id *device, + cl_kernel_work_group_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.device = device; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetKernelWorkGroupInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelWorkGroupInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelWorkGroupInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetKernelWorkGroupInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetKernelWorkGroupInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetKernelWorkGroupInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetKernelWorkGroupInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetMemObjectInfoTracer { + public: + clGetMemObjectInfoTracer() {} + + void enter(cl_mem *memobj, + cl_mem_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetMemObjectInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetMemObjectInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetMemObjectInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetMemObjectInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetMemObjectInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetMemObjectInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetMemObjectInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetPipeInfoTracer { + public: + clGetPipeInfoTracer() {} + + void enter(cl_mem *pipe, + cl_pipe_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.pipe = pipe; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetPipeInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPipeInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPipeInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPipeInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPipeInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetPipeInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetPipeInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetPlatformIDsTracer { + public: + clGetPlatformIDsTracer() {} + + void enter(cl_uint *numEntries, + cl_platform_id **platforms, + cl_uint **numPlatforms) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.numEntries = numEntries; + params.platforms = platforms; + params.numPlatforms = numPlatforms; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetPlatformIDs"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformIDs)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPlatformIDs, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformIDs)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPlatformIDs, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetPlatformIDsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetPlatformIDs params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetPlatformInfoTracer { + public: + clGetPlatformInfoTracer() {} + + void enter(cl_platform_id *platform, + cl_platform_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.platform = platform; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetPlatformInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPlatformInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetPlatformInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetPlatformInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetPlatformInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetPlatformInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetProgramBuildInfoTracer { + public: + clGetProgramBuildInfoTracer() {} + + void enter(cl_program *program, + cl_device_id *device, + cl_program_build_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.device = device; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetProgramBuildInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetProgramBuildInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetProgramBuildInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetProgramBuildInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetProgramBuildInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetProgramBuildInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetProgramBuildInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetProgramInfoTracer { + public: + clGetProgramInfoTracer() {} + + void enter(cl_program *program, + cl_program_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetProgramInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetProgramInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetProgramInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetProgramInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetProgramInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetProgramInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetProgramInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetSamplerInfoTracer { + public: + clGetSamplerInfoTracer() {} + + void enter(cl_sampler *sampler, + cl_sampler_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.sampler = sampler; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetSamplerInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetSamplerInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetSamplerInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetSamplerInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetSamplerInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetSamplerInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetSamplerInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetSupportedImageFormatsTracer { + public: + clGetSupportedImageFormatsTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_mem_object_type *imageType, + cl_uint *numEntries, + cl_image_format **imageFormats, + cl_uint **numImageFormats) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.imageType = imageType; + params.numEntries = numEntries; + params.imageFormats = imageFormats; + params.numImageFormats = numImageFormats; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetSupportedImageFormats"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetSupportedImageFormats)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetSupportedImageFormats, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetSupportedImageFormats)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetSupportedImageFormats, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetSupportedImageFormatsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetSupportedImageFormats params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clLinkProgramTracer { + public: + clLinkProgramTracer() {} + + void enter(cl_context *context, + cl_uint *numDevices, + const cl_device_id **deviceList, + const char **options, + cl_uint *numInputPrograms, + const cl_program **inputPrograms, + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData), + void **userData, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.numDevices = numDevices; + params.deviceList = deviceList; + params.options = options; + params.numInputPrograms = numInputPrograms; + params.inputPrograms = inputPrograms; + params.funcNotify = funcNotify; + params.userData = userData; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clLinkProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clLinkProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clLinkProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_program *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clLinkProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clLinkProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clLinkProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clLinkProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseCommandQueueTracer { + public: + clReleaseCommandQueueTracer() {} + + void enter(cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseCommandQueue"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseCommandQueueTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseCommandQueue params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseContextTracer { + public: + clReleaseContextTracer() {} + + void enter(cl_context *context) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseContext"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseContextTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseContext params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseDeviceTracer { + public: + clReleaseDeviceTracer() {} + + void enter(cl_device_id *device) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.device = device; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseDevice"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseDevice)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseDevice, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseDevice)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseDevice, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseDeviceTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseDevice params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseEventTracer { + public: + clReleaseEventTracer() {} + + void enter(cl_event *event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseEvent"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseEventTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseEvent params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseKernelTracer { + public: + clReleaseKernelTracer() {} + + void enter(cl_kernel *kernel) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseMemObjectTracer { + public: + clReleaseMemObjectTracer() {} + + void enter(cl_mem *memobj) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseMemObject"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseMemObjectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseMemObject params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseProgramTracer { + public: + clReleaseProgramTracer() {} + + void enter(cl_program *program) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clReleaseSamplerTracer { + public: + clReleaseSamplerTracer() {} + + void enter(cl_sampler *sampler) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.sampler = sampler; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clReleaseSampler"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clReleaseSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clReleaseSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clReleaseSamplerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clReleaseSampler params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainCommandQueueTracer { + public: + clRetainCommandQueueTracer() {} + + void enter(cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainCommandQueue"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainCommandQueueTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainCommandQueue params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainContextTracer { + public: + clRetainContextTracer() {} + + void enter(cl_context *context) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainContext"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainContext)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainContext, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainContextTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainContext params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainDeviceTracer { + public: + clRetainDeviceTracer() {} + + void enter(cl_device_id *device) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.device = device; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainDevice"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainDevice)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainDevice, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainDevice)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainDevice, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainDeviceTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainDevice params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainEventTracer { + public: + clRetainEventTracer() {} + + void enter(cl_event *event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainEvent"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainEvent)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainEvent, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainEventTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainEvent params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainKernelTracer { + public: + clRetainKernelTracer() {} + + void enter(cl_kernel *kernel) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainKernel"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainKernel)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainKernel, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainKernelTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainKernel params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainMemObjectTracer { + public: + clRetainMemObjectTracer() {} + + void enter(cl_mem *memobj) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainMemObject"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainMemObject)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainMemObject, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainMemObjectTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainMemObject params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainProgramTracer { + public: + clRetainProgramTracer() {} + + void enter(cl_program *program) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.program = program; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainProgram"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainProgram)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainProgram, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainProgramTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainProgram params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clRetainSamplerTracer { + public: + clRetainSamplerTracer() {} + + void enter(cl_sampler *sampler) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.sampler = sampler; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clRetainSampler"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clRetainSampler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clRetainSampler, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clRetainSamplerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clRetainSampler params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSVMAllocTracer { + public: + clSVMAllocTracer() {} + + void enter(cl_context *context, + cl_svm_mem_flags *flags, + size_t *size, + cl_uint *alignment) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.size = size; + params.alignment = alignment; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSVMAlloc"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSVMAlloc)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSVMAlloc, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void **retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSVMAlloc)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSVMAlloc, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSVMAllocTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSVMAlloc params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSVMFreeTracer { + public: + clSVMFreeTracer() {} + + void enter(cl_context *context, + void **svmPointer) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.svmPointer = svmPointer; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSVMFree"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSVMFree)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSVMFree, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(void *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSVMFree)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSVMFree, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSVMFreeTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSVMFree params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetCommandQueuePropertyTracer { + public: + clSetCommandQueuePropertyTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_command_queue_properties *properties, + cl_bool *enable, + cl_command_queue_properties **oldProperties) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.properties = properties; + params.enable = enable; + params.oldProperties = oldProperties; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetCommandQueueProperty"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetCommandQueueProperty)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetCommandQueueProperty, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetCommandQueueProperty)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetCommandQueueProperty, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetCommandQueuePropertyTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetCommandQueueProperty params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetDefaultDeviceCommandQueueTracer { + public: + clSetDefaultDeviceCommandQueueTracer() {} + + void enter(cl_context *context, + cl_device_id *device, + cl_command_queue *commandQueue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.device = device; + params.commandQueue = commandQueue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetDefaultDeviceCommandQueue"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetDefaultDeviceCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetDefaultDeviceCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetDefaultDeviceCommandQueue)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetDefaultDeviceCommandQueue, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetDefaultDeviceCommandQueueTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetDefaultDeviceCommandQueue params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetEventCallbackTracer { + public: + clSetEventCallbackTracer() {} + + void enter(cl_event *event, + cl_int *commandExecCallbackType, + void(CL_CALLBACK **funcNotify)(cl_event, cl_int, void *), + void **userData) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + params.commandExecCallbackType = commandExecCallbackType; + params.funcNotify = funcNotify; + params.userData = userData; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetEventCallback"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetEventCallback)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetEventCallback, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetEventCallback)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetEventCallback, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetEventCallbackTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetEventCallback params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetKernelArgTracer { + public: + clSetKernelArgTracer() {} + + void enter(cl_kernel *kernel, + cl_uint *argIndex, + size_t *argSize, + const void **argValue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.argIndex = argIndex; + params.argSize = argSize; + params.argValue = argValue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetKernelArg"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArg)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelArg, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArg)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelArg, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetKernelArgTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetKernelArg params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetKernelArgSVMPointerTracer { + public: + clSetKernelArgSVMPointerTracer() {} + + void enter(cl_kernel *kernel, + cl_uint *argIndex, + const void **argValue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.argIndex = argIndex; + params.argValue = argValue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetKernelArgSVMPointer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgSVMPointer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelArgSVMPointer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelArgSVMPointer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelArgSVMPointer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetKernelArgSVMPointerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetKernelArgSVMPointer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetKernelExecInfoTracer { + public: + clSetKernelExecInfoTracer() {} + + void enter(cl_kernel *kernel, + cl_kernel_exec_info *paramName, + size_t *paramValueSize, + const void **paramValue) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.kernel = kernel; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetKernelExecInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelExecInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelExecInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetKernelExecInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetKernelExecInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetKernelExecInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetKernelExecInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetMemObjectDestructorCallbackTracer { + public: + clSetMemObjectDestructorCallbackTracer() {} + + void enter(cl_mem *memobj, + void(CL_CALLBACK **funcNotify)(cl_mem, void *), + void **userData) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + params.funcNotify = funcNotify; + params.userData = userData; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetMemObjectDestructorCallback"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetMemObjectDestructorCallback)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetMemObjectDestructorCallback, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetMemObjectDestructorCallback)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetMemObjectDestructorCallback, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetMemObjectDestructorCallbackTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetMemObjectDestructorCallback params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clSetUserEventStatusTracer { + public: + clSetUserEventStatusTracer() {} + + void enter(cl_event *event, + cl_int *executionStatus) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.event = event; + params.executionStatus = executionStatus; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clSetUserEventStatus"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetUserEventStatus)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetUserEventStatus, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clSetUserEventStatus)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clSetUserEventStatus, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clSetUserEventStatusTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clSetUserEventStatus params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clUnloadCompilerTracer { + public: + clUnloadCompilerTracer() {} + + void enter() { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clUnloadCompiler"; + data.functionParams = nullptr; + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clUnloadCompiler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clUnloadCompiler, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clUnloadCompiler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clUnloadCompiler, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clUnloadCompilerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clUnloadPlatformCompilerTracer { + public: + clUnloadPlatformCompilerTracer() {} + + void enter(cl_platform_id *platform) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.platform = platform; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clUnloadPlatformCompiler"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clUnloadPlatformCompiler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clUnloadPlatformCompiler, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clUnloadPlatformCompiler)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clUnloadPlatformCompiler, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clUnloadPlatformCompilerTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clUnloadPlatformCompiler params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clWaitForEventsTracer { + public: + clWaitForEventsTracer() {} + + void enter(cl_uint *numEvents, + const cl_event **eventList) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.numEvents = numEvents; + params.eventList = eventList; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clWaitForEvents"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clWaitForEvents)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clWaitForEvents, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clWaitForEvents)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clWaitForEvents, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clWaitForEventsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clWaitForEvents params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +#ifdef _WIN32 + +class clCreateFromGLBufferTracer { + public: + clCreateFromGLBufferTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_GLuint *bufobj, + int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.bufobj = bufobj; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateFromGLBuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLBuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLBuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateFromGLBufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateFromGLBuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateFromGLRenderbufferTracer { + public: + clCreateFromGLRenderbufferTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_GLuint *renderbuffer, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.renderbuffer = renderbuffer; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateFromGLRenderbuffer"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLRenderbuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLRenderbuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLRenderbuffer)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLRenderbuffer, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateFromGLRenderbufferTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateFromGLRenderbuffer params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateFromGLTextureTracer { + public: + clCreateFromGLTextureTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_GLenum *target, + cl_GLint *miplevel, + cl_GLuint *texture, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.target = target; + params.miplevel = miplevel; + params.texture = texture; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateFromGLTexture"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateFromGLTextureTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateFromGLTexture params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateFromGLTexture2DTracer { + public: + clCreateFromGLTexture2DTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_GLenum *target, + cl_GLint *miplevel, + cl_GLuint *texture, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.target = target; + params.miplevel = miplevel; + params.texture = texture; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateFromGLTexture2D"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture2D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture2D, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture2D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture2D, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateFromGLTexture2DTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateFromGLTexture2D params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clCreateFromGLTexture3DTracer { + public: + clCreateFromGLTexture3DTracer() {} + + void enter(cl_context *context, + cl_mem_flags *flags, + cl_GLenum *target, + cl_GLint *miplevel, + cl_GLuint *texture, + cl_int **errcodeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.context = context; + params.flags = flags; + params.target = target; + params.miplevel = miplevel; + params.texture = texture; + params.errcodeRet = errcodeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clCreateFromGLTexture3D"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture3D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture3D, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_mem *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clCreateFromGLTexture3D)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clCreateFromGLTexture3D, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clCreateFromGLTexture3DTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clCreateFromGLTexture3D params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueAcquireGLObjectsTracer { + public: + clEnqueueAcquireGLObjectsTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numObjects, + const cl_mem **memObjects, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numObjects = numObjects; + params.memObjects = memObjects; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueAcquireGLObjects"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireGLObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueAcquireGLObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueAcquireGLObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueAcquireGLObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueAcquireGLObjectsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueAcquireGLObjects params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clEnqueueReleaseGLObjectsTracer { + public: + clEnqueueReleaseGLObjectsTracer() {} + + void enter(cl_command_queue *commandQueue, + cl_uint *numObjects, + const cl_mem **memObjects, + cl_uint *numEventsInWaitList, + const cl_event **eventWaitList, + cl_event **event) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.commandQueue = commandQueue; + params.numObjects = numObjects; + params.memObjects = memObjects; + params.numEventsInWaitList = numEventsInWaitList; + params.eventWaitList = eventWaitList; + params.event = event; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clEnqueueReleaseGLObjects"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseGLObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReleaseGLObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clEnqueueReleaseGLObjects)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clEnqueueReleaseGLObjects, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clEnqueueReleaseGLObjectsTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clEnqueueReleaseGLObjects params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetGLObjectInfoTracer { + public: + clGetGLObjectInfoTracer() {} + + void enter(cl_mem *memobj, + cl_gl_object_type **glObjectType, + cl_GLuint **glObjectName) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + params.glObjectType = glObjectType; + params.glObjectName = glObjectName; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetGLObjectInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetGLObjectInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetGLObjectInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetGLObjectInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetGLObjectInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetGLObjectInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetGLObjectInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +class clGetGLTextureInfoTracer { + public: + clGetGLTextureInfoTracer() {} + + void enter(cl_mem *memobj, + cl_gl_texture_info *paramName, + size_t *paramValueSize, + void **paramValue, + size_t **paramValueSizeRet) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_NOTHING_CALLED); + + params.memobj = memobj; + params.paramName = paramName; + params.paramValueSize = paramValueSize; + params.paramValue = paramValue; + params.paramValueSizeRet = paramValueSizeRet; + + data.site = CL_CALLBACK_SITE_ENTER; + data.correlationId = tracingCorrelationId.fetch_add(1, std::memory_order_acq_rel); + data.functionName = "clGetGLTextureInfo"; + data.functionParams = static_cast(¶ms); + data.functionReturnValue = nullptr; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetGLTextureInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetGLTextureInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_ENTER_CALLED; + } + + void exit(cl_int *retVal) { + DEBUG_BREAK_IF(state != TRACING_NOTIFY_STATE_ENTER_CALLED); + data.site = CL_CALLBACK_SITE_EXIT; + data.functionReturnValue = retVal; + + DEBUG_BREAK_IF(tracingHandle.size() == 0); + DEBUG_BREAK_IF(tracingHandle.size() >= TRACING_MAX_HANDLE_COUNT); + for (size_t i = 0; i < tracingHandle.size(); ++i) { + TracingHandle *handle = tracingHandle[i]; + DEBUG_BREAK_IF(handle == nullptr); + if (handle->getTracingPoint(CL_FUNCTION_clGetGLTextureInfo)) { + data.correlationData = correlationData + i; + handle->call(CL_FUNCTION_clGetGLTextureInfo, &data); + } + } + + state = TRACING_NOTIFY_STATE_EXIT_CALLED; + } + + ~clGetGLTextureInfoTracer() { + DEBUG_BREAK_IF(state == TRACING_NOTIFY_STATE_ENTER_CALLED); + } + + private: + cl_params_clGetGLTextureInfo params; + cl_callback_data data; + uint64_t correlationData[TRACING_MAX_HANDLE_COUNT]; + tracing_notify_state_t state = TRACING_NOTIFY_STATE_NOTHING_CALLED; +}; + +#endif + +} // namespace HostSideTracing diff --git a/runtime/tracing/tracing_types.h b/runtime/tracing/tracing_types.h new file mode 100644 index 0000000000..baf1db5376 --- /dev/null +++ b/runtime/tracing/tracing_types.h @@ -0,0 +1,1094 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "CL/cl.h" +#include "CL/cl_gl.h" + +struct _cl_tracing_handle; +typedef _cl_tracing_handle *cl_tracing_handle; + +typedef enum _cl_callback_site { + CL_CALLBACK_SITE_ENTER = 0, + CL_CALLBACK_SITE_EXIT = 1 +} cl_callback_site; + +typedef struct _cl_callback_data { + cl_callback_site site; + cl_uint correlationId; + cl_ulong *correlationData; + const char *functionName; + const void *functionParams; + void *functionReturnValue; +} cl_callback_data; + +typedef enum _cl_function_id { + CL_FUNCTION_clBuildProgram = 0, + CL_FUNCTION_clCloneKernel = 1, + CL_FUNCTION_clCompileProgram = 2, + CL_FUNCTION_clCreateBuffer = 3, + CL_FUNCTION_clCreateCommandQueue = 4, + CL_FUNCTION_clCreateCommandQueueWithProperties = 5, + CL_FUNCTION_clCreateContext = 6, + CL_FUNCTION_clCreateContextFromType = 7, + CL_FUNCTION_clCreateFromGLBuffer = 8, + CL_FUNCTION_clCreateFromGLRenderbuffer = 9, + CL_FUNCTION_clCreateFromGLTexture = 10, + CL_FUNCTION_clCreateFromGLTexture2D = 11, + CL_FUNCTION_clCreateFromGLTexture3D = 12, + CL_FUNCTION_clCreateImage = 13, + CL_FUNCTION_clCreateImage2D = 14, + CL_FUNCTION_clCreateImage3D = 15, + CL_FUNCTION_clCreateKernel = 16, + CL_FUNCTION_clCreateKernelsInProgram = 17, + CL_FUNCTION_clCreatePipe = 18, + CL_FUNCTION_clCreateProgramWithBinary = 19, + CL_FUNCTION_clCreateProgramWithBuiltInKernels = 20, + CL_FUNCTION_clCreateProgramWithIL = 21, + CL_FUNCTION_clCreateProgramWithSource = 22, + CL_FUNCTION_clCreateSampler = 23, + CL_FUNCTION_clCreateSamplerWithProperties = 24, + CL_FUNCTION_clCreateSubBuffer = 25, + CL_FUNCTION_clCreateSubDevices = 26, + CL_FUNCTION_clCreateUserEvent = 27, + CL_FUNCTION_clEnqueueAcquireGLObjects = 28, + CL_FUNCTION_clEnqueueBarrier = 29, + CL_FUNCTION_clEnqueueBarrierWithWaitList = 30, + CL_FUNCTION_clEnqueueCopyBuffer = 31, + CL_FUNCTION_clEnqueueCopyBufferRect = 32, + CL_FUNCTION_clEnqueueCopyBufferToImage = 33, + CL_FUNCTION_clEnqueueCopyImage = 34, + CL_FUNCTION_clEnqueueCopyImageToBuffer = 35, + CL_FUNCTION_clEnqueueFillBuffer = 36, + CL_FUNCTION_clEnqueueFillImage = 37, + CL_FUNCTION_clEnqueueMapBuffer = 38, + CL_FUNCTION_clEnqueueMapImage = 39, + CL_FUNCTION_clEnqueueMarker = 40, + CL_FUNCTION_clEnqueueMarkerWithWaitList = 41, + CL_FUNCTION_clEnqueueMigrateMemObjects = 42, + CL_FUNCTION_clEnqueueNDRangeKernel = 43, + CL_FUNCTION_clEnqueueNativeKernel = 44, + CL_FUNCTION_clEnqueueReadBuffer = 45, + CL_FUNCTION_clEnqueueReadBufferRect = 46, + CL_FUNCTION_clEnqueueReadImage = 47, + CL_FUNCTION_clEnqueueReleaseGLObjects = 48, + CL_FUNCTION_clEnqueueSVMFree = 49, + CL_FUNCTION_clEnqueueSVMMap = 50, + CL_FUNCTION_clEnqueueSVMMemFill = 51, + CL_FUNCTION_clEnqueueSVMMemcpy = 52, + CL_FUNCTION_clEnqueueSVMMigrateMem = 53, + CL_FUNCTION_clEnqueueSVMUnmap = 54, + CL_FUNCTION_clEnqueueTask = 55, + CL_FUNCTION_clEnqueueUnmapMemObject = 56, + CL_FUNCTION_clEnqueueWaitForEvents = 57, + CL_FUNCTION_clEnqueueWriteBuffer = 58, + CL_FUNCTION_clEnqueueWriteBufferRect = 59, + CL_FUNCTION_clEnqueueWriteImage = 60, + CL_FUNCTION_clFinish = 61, + CL_FUNCTION_clFlush = 62, + CL_FUNCTION_clGetCommandQueueInfo = 63, + CL_FUNCTION_clGetContextInfo = 64, + CL_FUNCTION_clGetDeviceAndHostTimer = 65, + CL_FUNCTION_clGetDeviceIDs = 66, + CL_FUNCTION_clGetDeviceInfo = 67, + CL_FUNCTION_clGetEventInfo = 68, + CL_FUNCTION_clGetEventProfilingInfo = 69, + CL_FUNCTION_clGetExtensionFunctionAddress = 70, + CL_FUNCTION_clGetExtensionFunctionAddressForPlatform = 71, + CL_FUNCTION_clGetGLObjectInfo = 72, + CL_FUNCTION_clGetGLTextureInfo = 73, + CL_FUNCTION_clGetHostTimer = 74, + CL_FUNCTION_clGetImageInfo = 75, + CL_FUNCTION_clGetKernelArgInfo = 76, + CL_FUNCTION_clGetKernelInfo = 77, + CL_FUNCTION_clGetKernelSubGroupInfo = 78, + CL_FUNCTION_clGetKernelWorkGroupInfo = 79, + CL_FUNCTION_clGetMemObjectInfo = 80, + CL_FUNCTION_clGetPipeInfo = 81, + CL_FUNCTION_clGetPlatformIDs = 82, + CL_FUNCTION_clGetPlatformInfo = 83, + CL_FUNCTION_clGetProgramBuildInfo = 84, + CL_FUNCTION_clGetProgramInfo = 85, + CL_FUNCTION_clGetSamplerInfo = 86, + CL_FUNCTION_clGetSupportedImageFormats = 87, + CL_FUNCTION_clLinkProgram = 88, + CL_FUNCTION_clReleaseCommandQueue = 89, + CL_FUNCTION_clReleaseContext = 90, + CL_FUNCTION_clReleaseDevice = 91, + CL_FUNCTION_clReleaseEvent = 92, + CL_FUNCTION_clReleaseKernel = 93, + CL_FUNCTION_clReleaseMemObject = 94, + CL_FUNCTION_clReleaseProgram = 95, + CL_FUNCTION_clReleaseSampler = 96, + CL_FUNCTION_clRetainCommandQueue = 97, + CL_FUNCTION_clRetainContext = 98, + CL_FUNCTION_clRetainDevice = 99, + CL_FUNCTION_clRetainEvent = 100, + CL_FUNCTION_clRetainKernel = 101, + CL_FUNCTION_clRetainMemObject = 102, + CL_FUNCTION_clRetainProgram = 103, + CL_FUNCTION_clRetainSampler = 104, + CL_FUNCTION_clSVMAlloc = 105, + CL_FUNCTION_clSVMFree = 106, + CL_FUNCTION_clSetCommandQueueProperty = 107, + CL_FUNCTION_clSetDefaultDeviceCommandQueue = 108, + CL_FUNCTION_clSetEventCallback = 109, + CL_FUNCTION_clSetKernelArg = 110, + CL_FUNCTION_clSetKernelArgSVMPointer = 111, + CL_FUNCTION_clSetKernelExecInfo = 112, + CL_FUNCTION_clSetMemObjectDestructorCallback = 113, + CL_FUNCTION_clSetUserEventStatus = 114, + CL_FUNCTION_clUnloadCompiler = 115, + CL_FUNCTION_clUnloadPlatformCompiler = 116, + CL_FUNCTION_clWaitForEvents = 117, + CL_FUNCTION_COUNT = 118, +} cl_function_id; + +typedef void (*cl_tracing_callback)(cl_function_id fid, cl_callback_data *callbackData, void *userData); + +typedef struct _cl_params_clBuildProgram { + cl_program *program; + cl_uint *numDevices; + const cl_device_id **deviceList; + const char **options; + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData); + void **userData; +} cl_params_clBuildProgram; + +typedef struct _cl_params_clCloneKernel { + cl_kernel *sourceKernel; + cl_int **errcodeRet; +} cl_params_clCloneKernel; + +typedef struct _cl_params_clCompileProgram { + cl_program *program; + cl_uint *numDevices; + const cl_device_id **deviceList; + const char **options; + cl_uint *numInputHeaders; + const cl_program **inputHeaders; + const char ***headerIncludeNames; + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData); + void **userData; +} cl_params_clCompileProgram; + +typedef struct _cl_params_clCreateBuffer { + cl_context *context; + cl_mem_flags *flags; + size_t *size; + void **hostPtr; + cl_int **errcodeRet; +} cl_params_clCreateBuffer; + +typedef struct _cl_params_clCreateCommandQueue { + cl_context *context; + cl_device_id *device; + cl_command_queue_properties *properties; + cl_int **errcodeRet; +} cl_params_clCreateCommandQueue; + +typedef struct _cl_params_clCreateCommandQueueWithProperties { + cl_context *context; + cl_device_id *device; + const cl_queue_properties **properties; + cl_int **errcodeRet; +} cl_params_clCreateCommandQueueWithProperties; + +typedef struct _cl_params_clCreateContext { + const cl_context_properties **properties; + cl_uint *numDevices; + const cl_device_id **devices; + void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *); + void **userData; + cl_int **errcodeRet; +} cl_params_clCreateContext; + +typedef struct _cl_params_clCreateContextFromType { + const cl_context_properties **properties; + cl_device_type *deviceType; + void(CL_CALLBACK **funcNotify)(const char *, const void *, size_t, void *); + void **userData; + cl_int **errcodeRet; +} cl_params_clCreateContextFromType; + +typedef struct _cl_params_clCreateFromGLBuffer { + cl_context *context; + cl_mem_flags *flags; + cl_GLuint *bufobj; + int **errcodeRet; +} cl_params_clCreateFromGLBuffer; + +typedef struct _cl_params_clCreateFromGLRenderbuffer { + cl_context *context; + cl_mem_flags *flags; + cl_GLuint *renderbuffer; + cl_int **errcodeRet; +} cl_params_clCreateFromGLRenderbuffer; + +typedef struct _cl_params_clCreateFromGLTexture { + cl_context *context; + cl_mem_flags *flags; + cl_GLenum *target; + cl_GLint *miplevel; + cl_GLuint *texture; + cl_int **errcodeRet; +} cl_params_clCreateFromGLTexture; + +typedef struct _cl_params_clCreateFromGLTexture2D { + cl_context *context; + cl_mem_flags *flags; + cl_GLenum *target; + cl_GLint *miplevel; + cl_GLuint *texture; + cl_int **errcodeRet; +} cl_params_clCreateFromGLTexture2D; + +typedef struct _cl_params_clCreateFromGLTexture3D { + cl_context *context; + cl_mem_flags *flags; + cl_GLenum *target; + cl_GLint *miplevel; + cl_GLuint *texture; + cl_int **errcodeRet; +} cl_params_clCreateFromGLTexture3D; + +typedef struct _cl_params_clCreateImage { + cl_context *context; + cl_mem_flags *flags; + const cl_image_format **imageFormat; + const cl_image_desc **imageDesc; + void **hostPtr; + cl_int **errcodeRet; +} cl_params_clCreateImage; + +typedef struct _cl_params_clCreateImage2D { + cl_context *context; + cl_mem_flags *flags; + const cl_image_format **imageFormat; + size_t *imageWidth; + size_t *imageHeight; + size_t *imageRowPitch; + void **hostPtr; + cl_int **errcodeRet; +} cl_params_clCreateImage2D; + +typedef struct _cl_params_clCreateImage3D { + cl_context *context; + cl_mem_flags *flags; + const cl_image_format **imageFormat; + size_t *imageWidth; + size_t *imageHeight; + size_t *imageDepth; + size_t *imageRowPitch; + size_t *imageSlicePitch; + void **hostPtr; + cl_int **errcodeRet; +} cl_params_clCreateImage3D; + +typedef struct _cl_params_clCreateKernel { + cl_program *program; + const char **kernelName; + cl_int **errcodeRet; +} cl_params_clCreateKernel; + +typedef struct _cl_params_clCreateKernelsInProgram { + cl_program *program; + cl_uint *numKernels; + cl_kernel **kernels; + cl_uint **numKernelsRet; +} cl_params_clCreateKernelsInProgram; + +typedef struct _cl_params_clCreatePipe { + cl_context *context; + cl_mem_flags *flags; + cl_uint *pipePacketSize; + cl_uint *pipeMaxPackets; + const cl_pipe_properties **properties; + cl_int **errcodeRet; +} cl_params_clCreatePipe; + +typedef struct _cl_params_clCreateProgramWithBinary { + cl_context *context; + cl_uint *numDevices; + const cl_device_id **deviceList; + const size_t **lengths; + const unsigned char ***binaries; + cl_int **binaryStatus; + cl_int **errcodeRet; +} cl_params_clCreateProgramWithBinary; + +typedef struct _cl_params_clCreateProgramWithBuiltInKernels { + cl_context *context; + cl_uint *numDevices; + const cl_device_id **deviceList; + const char **kernelNames; + cl_int **errcodeRet; +} cl_params_clCreateProgramWithBuiltInKernels; + +typedef struct _cl_params_clCreateProgramWithIL { + cl_context *context; + const void **il; + size_t *length; + cl_int **errcodeRet; +} cl_params_clCreateProgramWithIL; + +typedef struct _cl_params_clCreateProgramWithSource { + cl_context *context; + cl_uint *count; + const char ***strings; + const size_t **lengths; + cl_int **errcodeRet; +} cl_params_clCreateProgramWithSource; + +typedef struct _cl_params_clCreateSampler { + cl_context *context; + cl_bool *normalizedCoords; + cl_addressing_mode *addressingMode; + cl_filter_mode *filterMode; + cl_int **errcodeRet; +} cl_params_clCreateSampler; + +typedef struct _cl_params_clCreateSamplerWithProperties { + cl_context *context; + const cl_sampler_properties **samplerProperties; + cl_int **errcodeRet; +} cl_params_clCreateSamplerWithProperties; + +typedef struct _cl_params_clCreateSubBuffer { + cl_mem *buffer; + cl_mem_flags *flags; + cl_buffer_create_type *bufferCreateType; + const void **bufferCreateInfo; + cl_int **errcodeRet; +} cl_params_clCreateSubBuffer; + +typedef struct _cl_params_clCreateSubDevices { + cl_device_id *inDevice; + const cl_device_partition_property **properties; + cl_uint *numDevices; + cl_device_id **outDevices; + cl_uint **numDevicesRet; +} cl_params_clCreateSubDevices; + +typedef struct _cl_params_clCreateUserEvent { + cl_context *context; + cl_int **errcodeRet; +} cl_params_clCreateUserEvent; + +typedef struct _cl_params_clEnqueueAcquireGLObjects { + cl_command_queue *commandQueue; + cl_uint *numObjects; + const cl_mem **memObjects; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueAcquireGLObjects; + +typedef struct _cl_params_clEnqueueBarrier { + cl_command_queue *commandQueue; +} cl_params_clEnqueueBarrier; + +typedef struct _cl_params_clEnqueueBarrierWithWaitList { + cl_command_queue *commandQueue; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueBarrierWithWaitList; + +typedef struct _cl_params_clEnqueueCopyBuffer { + cl_command_queue *commandQueue; + cl_mem *srcBuffer; + cl_mem *dstBuffer; + size_t *srcOffset; + size_t *dstOffset; + size_t *cb; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueCopyBuffer; + +typedef struct _cl_params_clEnqueueCopyBufferRect { + cl_command_queue *commandQueue; + cl_mem *srcBuffer; + cl_mem *dstBuffer; + const size_t **srcOrigin; + const size_t **dstOrigin; + const size_t **region; + size_t *srcRowPitch; + size_t *srcSlicePitch; + size_t *dstRowPitch; + size_t *dstSlicePitch; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueCopyBufferRect; + +typedef struct _cl_params_clEnqueueCopyBufferToImage { + cl_command_queue *commandQueue; + cl_mem *srcBuffer; + cl_mem *dstImage; + size_t *srcOffset; + const size_t **dstOrigin; + const size_t **region; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueCopyBufferToImage; + +typedef struct _cl_params_clEnqueueCopyImage { + cl_command_queue *commandQueue; + cl_mem *srcImage; + cl_mem *dstImage; + const size_t **srcOrigin; + const size_t **dstOrigin; + const size_t **region; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueCopyImage; + +typedef struct _cl_params_clEnqueueCopyImageToBuffer { + cl_command_queue *commandQueue; + cl_mem *srcImage; + cl_mem *dstBuffer; + const size_t **srcOrigin; + const size_t **region; + size_t *dstOffset; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueCopyImageToBuffer; + +typedef struct _cl_params_clEnqueueFillBuffer { + cl_command_queue *commandQueue; + cl_mem *buffer; + const void **pattern; + size_t *patternSize; + size_t *offset; + size_t *size; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueFillBuffer; + +typedef struct _cl_params_clEnqueueFillImage { + cl_command_queue *commandQueue; + cl_mem *image; + const void **fillColor; + const size_t **origin; + const size_t **region; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueFillImage; + +typedef struct _cl_params_clEnqueueMapBuffer { + cl_command_queue *commandQueue; + cl_mem *buffer; + cl_bool *blockingMap; + cl_map_flags *mapFlags; + size_t *offset; + size_t *cb; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; + cl_int **errcodeRet; +} cl_params_clEnqueueMapBuffer; + +typedef struct _cl_params_clEnqueueMapImage { + cl_command_queue *commandQueue; + cl_mem *image; + cl_bool *blockingMap; + cl_map_flags *mapFlags; + const size_t **origin; + const size_t **region; + size_t **imageRowPitch; + size_t **imageSlicePitch; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; + cl_int **errcodeRet; +} cl_params_clEnqueueMapImage; + +typedef struct _cl_params_clEnqueueMarker { + cl_command_queue *commandQueue; + cl_event **event; +} cl_params_clEnqueueMarker; + +typedef struct _cl_params_clEnqueueMarkerWithWaitList { + cl_command_queue *commandQueue; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueMarkerWithWaitList; + +typedef struct _cl_params_clEnqueueMigrateMemObjects { + cl_command_queue *commandQueue; + cl_uint *numMemObjects; + const cl_mem **memObjects; + cl_mem_migration_flags *flags; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueMigrateMemObjects; + +typedef struct _cl_params_clEnqueueNDRangeKernel { + cl_command_queue *commandQueue; + cl_kernel *kernel; + cl_uint *workDim; + const size_t **globalWorkOffset; + const size_t **globalWorkSize; + const size_t **localWorkSize; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueNDRangeKernel; + +typedef struct _cl_params_clEnqueueNativeKernel { + cl_command_queue *commandQueue; + void(CL_CALLBACK **userFunc)(void *); + void **args; + size_t *cbArgs; + cl_uint *numMemObjects; + const cl_mem **memList; + const void ***argsMemLoc; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueNativeKernel; + +typedef struct _cl_params_clEnqueueReadBuffer { + cl_command_queue *commandQueue; + cl_mem *buffer; + cl_bool *blockingRead; + size_t *offset; + size_t *cb; + void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueReadBuffer; + +typedef struct _cl_params_clEnqueueReadBufferRect { + cl_command_queue *commandQueue; + cl_mem *buffer; + cl_bool *blockingRead; + const size_t **bufferOrigin; + const size_t **hostOrigin; + const size_t **region; + size_t *bufferRowPitch; + size_t *bufferSlicePitch; + size_t *hostRowPitch; + size_t *hostSlicePitch; + void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueReadBufferRect; + +typedef struct _cl_params_clEnqueueReadImage { + cl_command_queue *commandQueue; + cl_mem *image; + cl_bool *blockingRead; + const size_t **origin; + const size_t **region; + size_t *rowPitch; + size_t *slicePitch; + void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueReadImage; + +typedef struct _cl_params_clEnqueueReleaseGLObjects { + cl_command_queue *commandQueue; + cl_uint *numObjects; + const cl_mem **memObjects; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueReleaseGLObjects; + +typedef struct _cl_params_clEnqueueSVMFree { + cl_command_queue *commandQueue; + cl_uint *numSvmPointers; + void ***svmPointers; + void(CL_CALLBACK **pfnFreeFunc)(cl_command_queue queue, cl_uint numSvmPointers, void **svmPointers, void *userData); + void **userData; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMFree; + +typedef struct _cl_params_clEnqueueSVMMap { + cl_command_queue *commandQueue; + cl_bool *blockingMap; + cl_map_flags *mapFlags; + void **svmPtr; + size_t *size; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMMap; + +typedef struct _cl_params_clEnqueueSVMMemFill { + cl_command_queue *commandQueue; + void **svmPtr; + const void **pattern; + size_t *patternSize; + size_t *size; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMMemFill; + +typedef struct _cl_params_clEnqueueSVMMemcpy { + cl_command_queue *commandQueue; + cl_bool *blockingCopy; + void **dstPtr; + const void **srcPtr; + size_t *size; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMMemcpy; + +typedef struct _cl_params_clEnqueueSVMMigrateMem { + cl_command_queue *commandQueue; + cl_uint *numSvmPointers; + const void ***svmPointers; + const size_t **sizes; + const cl_mem_migration_flags *flags; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMMigrateMem; + +typedef struct _cl_params_clEnqueueSVMUnmap { + cl_command_queue *commandQueue; + void **svmPtr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueSVMUnmap; + +typedef struct _cl_params_clEnqueueTask { + cl_command_queue *commandQueue; + cl_kernel *kernel; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueTask; + +typedef struct _cl_params_clEnqueueUnmapMemObject { + cl_command_queue *commandQueue; + cl_mem *memobj; + void **mappedPtr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueUnmapMemObject; + +typedef struct _cl_params_clEnqueueWaitForEvents { + cl_command_queue *commandQueue; + cl_uint *numEvents; + const cl_event **eventList; +} cl_params_clEnqueueWaitForEvents; + +typedef struct _cl_params_clEnqueueWriteBuffer { + cl_command_queue *commandQueue; + cl_mem *buffer; + cl_bool *blockingWrite; + size_t *offset; + size_t *cb; + const void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueWriteBuffer; + +typedef struct _cl_params_clEnqueueWriteBufferRect { + cl_command_queue *commandQueue; + cl_mem *buffer; + cl_bool *blockingWrite; + const size_t **bufferOrigin; + const size_t **hostOrigin; + const size_t **region; + size_t *bufferRowPitch; + size_t *bufferSlicePitch; + size_t *hostRowPitch; + size_t *hostSlicePitch; + const void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueWriteBufferRect; + +typedef struct _cl_params_clEnqueueWriteImage { + cl_command_queue *commandQueue; + cl_mem *image; + cl_bool *blockingWrite; + const size_t **origin; + const size_t **region; + size_t *inputRowPitch; + size_t *inputSlicePitch; + const void **ptr; + cl_uint *numEventsInWaitList; + const cl_event **eventWaitList; + cl_event **event; +} cl_params_clEnqueueWriteImage; + +typedef struct _cl_params_clFinish { + cl_command_queue *commandQueue; +} cl_params_clFinish; + +typedef struct _cl_params_clFlush { + cl_command_queue *commandQueue; +} cl_params_clFlush; + +typedef struct _cl_params_clGetCommandQueueInfo { + cl_command_queue *commandQueue; + cl_command_queue_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetCommandQueueInfo; + +typedef struct _cl_params_clGetContextInfo { + cl_context *context; + cl_context_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetContextInfo; + +typedef struct _cl_params_clGetDeviceAndHostTimer { + cl_device_id *device; + cl_ulong **deviceTimestamp; + cl_ulong **hostTimestamp; +} cl_params_clGetDeviceAndHostTimer; + +typedef struct _cl_params_clGetDeviceIDs { + cl_platform_id *platform; + cl_device_type *deviceType; + cl_uint *numEntries; + cl_device_id **devices; + cl_uint **numDevices; +} cl_params_clGetDeviceIDs; + +typedef struct _cl_params_clGetDeviceInfo { + cl_device_id *device; + cl_device_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetDeviceInfo; + +typedef struct _cl_params_clGetEventInfo { + cl_event *event; + cl_event_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetEventInfo; + +typedef struct _cl_params_clGetEventProfilingInfo { + cl_event *event; + cl_profiling_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetEventProfilingInfo; + +typedef struct _cl_params_clGetExtensionFunctionAddress { + const char **funcName; +} cl_params_clGetExtensionFunctionAddress; + +typedef struct _cl_params_clGetExtensionFunctionAddressForPlatform { + cl_platform_id *platform; + const char **funcName; +} cl_params_clGetExtensionFunctionAddressForPlatform; + +typedef struct _cl_params_clGetGLObjectInfo { + cl_mem *memobj; + cl_gl_object_type **glObjectType; + cl_GLuint **glObjectName; +} cl_params_clGetGLObjectInfo; + +typedef struct _cl_params_clGetGLTextureInfo { + cl_mem *memobj; + cl_gl_texture_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetGLTextureInfo; + +typedef struct _cl_params_clGetHostTimer { + cl_device_id *device; + cl_ulong **hostTimestamp; +} cl_params_clGetHostTimer; + +typedef struct _cl_params_clGetImageInfo { + cl_mem *image; + cl_image_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetImageInfo; + +typedef struct _cl_params_clGetKernelArgInfo { + cl_kernel *kernel; + cl_uint *argIndx; + cl_kernel_arg_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetKernelArgInfo; + +typedef struct _cl_params_clGetKernelInfo { + cl_kernel *kernel; + cl_kernel_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetKernelInfo; + +typedef struct _cl_params_clGetKernelSubGroupInfo { + cl_kernel *kernel; + cl_device_id *device; + cl_kernel_sub_group_info *paramName; + size_t *inputValueSize; + const void **inputValue; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetKernelSubGroupInfo; + +typedef struct _cl_params_clGetKernelWorkGroupInfo { + cl_kernel *kernel; + cl_device_id *device; + cl_kernel_work_group_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetKernelWorkGroupInfo; + +typedef struct _cl_params_clGetMemObjectInfo { + cl_mem *memobj; + cl_mem_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetMemObjectInfo; + +typedef struct _cl_params_clGetPipeInfo { + cl_mem *pipe; + cl_pipe_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetPipeInfo; + +typedef struct _cl_params_clGetPlatformIDs { + cl_uint *numEntries; + cl_platform_id **platforms; + cl_uint **numPlatforms; +} cl_params_clGetPlatformIDs; + +typedef struct _cl_params_clGetPlatformInfo { + cl_platform_id *platform; + cl_platform_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetPlatformInfo; + +typedef struct _cl_params_clGetProgramBuildInfo { + cl_program *program; + cl_device_id *device; + cl_program_build_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetProgramBuildInfo; + +typedef struct _cl_params_clGetProgramInfo { + cl_program *program; + cl_program_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetProgramInfo; + +typedef struct _cl_params_clGetSamplerInfo { + cl_sampler *sampler; + cl_sampler_info *paramName; + size_t *paramValueSize; + void **paramValue; + size_t **paramValueSizeRet; +} cl_params_clGetSamplerInfo; + +typedef struct _cl_params_clGetSupportedImageFormats { + cl_context *context; + cl_mem_flags *flags; + cl_mem_object_type *imageType; + cl_uint *numEntries; + cl_image_format **imageFormats; + cl_uint **numImageFormats; +} cl_params_clGetSupportedImageFormats; + +typedef struct _cl_params_clLinkProgram { + cl_context *context; + cl_uint *numDevices; + const cl_device_id **deviceList; + const char **options; + cl_uint *numInputPrograms; + const cl_program **inputPrograms; + void(CL_CALLBACK **funcNotify)(cl_program program, void *userData); + void **userData; + cl_int **errcodeRet; +} cl_params_clLinkProgram; + +typedef struct _cl_params_clReleaseCommandQueue { + cl_command_queue *commandQueue; +} cl_params_clReleaseCommandQueue; + +typedef struct _cl_params_clReleaseContext { + cl_context *context; +} cl_params_clReleaseContext; + +typedef struct _cl_params_clReleaseDevice { + cl_device_id *device; +} cl_params_clReleaseDevice; + +typedef struct _cl_params_clReleaseEvent { + cl_event *event; +} cl_params_clReleaseEvent; + +typedef struct _cl_params_clReleaseKernel { + cl_kernel *kernel; +} cl_params_clReleaseKernel; + +typedef struct _cl_params_clReleaseMemObject { + cl_mem *memobj; +} cl_params_clReleaseMemObject; + +typedef struct _cl_params_clReleaseProgram { + cl_program *program; +} cl_params_clReleaseProgram; + +typedef struct _cl_params_clReleaseSampler { + cl_sampler *sampler; +} cl_params_clReleaseSampler; + +typedef struct _cl_params_clRetainCommandQueue { + cl_command_queue *commandQueue; +} cl_params_clRetainCommandQueue; + +typedef struct _cl_params_clRetainContext { + cl_context *context; +} cl_params_clRetainContext; + +typedef struct _cl_params_clRetainDevice { + cl_device_id *device; +} cl_params_clRetainDevice; + +typedef struct _cl_params_clRetainEvent { + cl_event *event; +} cl_params_clRetainEvent; + +typedef struct _cl_params_clRetainKernel { + cl_kernel *kernel; +} cl_params_clRetainKernel; + +typedef struct _cl_params_clRetainMemObject { + cl_mem *memobj; +} cl_params_clRetainMemObject; + +typedef struct _cl_params_clRetainProgram { + cl_program *program; +} cl_params_clRetainProgram; + +typedef struct _cl_params_clRetainSampler { + cl_sampler *sampler; +} cl_params_clRetainSampler; + +typedef struct _cl_params_clSVMAlloc { + cl_context *context; + cl_svm_mem_flags *flags; + size_t *size; + cl_uint *alignment; +} cl_params_clSVMAlloc; + +typedef struct _cl_params_clSVMFree { + cl_context *context; + void **svmPointer; +} cl_params_clSVMFree; + +typedef struct _cl_params_clSetCommandQueueProperty { + cl_command_queue *commandQueue; + cl_command_queue_properties *properties; + cl_bool *enable; + cl_command_queue_properties **oldProperties; +} cl_params_clSetCommandQueueProperty; + +typedef struct _cl_params_clSetDefaultDeviceCommandQueue { + cl_context *context; + cl_device_id *device; + cl_command_queue *commandQueue; +} cl_params_clSetDefaultDeviceCommandQueue; + +typedef struct _cl_params_clSetEventCallback { + cl_event *event; + cl_int *commandExecCallbackType; + void(CL_CALLBACK **funcNotify)(cl_event, cl_int, void *); + void **userData; +} cl_params_clSetEventCallback; + +typedef struct _cl_params_clSetKernelArg { + cl_kernel *kernel; + cl_uint *argIndex; + size_t *argSize; + const void **argValue; +} cl_params_clSetKernelArg; + +typedef struct _cl_params_clSetKernelArgSVMPointer { + cl_kernel *kernel; + cl_uint *argIndex; + const void **argValue; +} cl_params_clSetKernelArgSVMPointer; + +typedef struct _cl_params_clSetKernelExecInfo { + cl_kernel *kernel; + cl_kernel_exec_info *paramName; + size_t *paramValueSize; + const void **paramValue; +} cl_params_clSetKernelExecInfo; + +typedef struct _cl_params_clSetMemObjectDestructorCallback { + cl_mem *memobj; + void(CL_CALLBACK **funcNotify)(cl_mem, void *); + void **userData; +} cl_params_clSetMemObjectDestructorCallback; + +typedef struct _cl_params_clSetUserEventStatus { + cl_event *event; + cl_int *executionStatus; +} cl_params_clSetUserEventStatus; + +typedef struct _cl_params_clUnloadCompiler { +} cl_params_clUnloadCompiler; + +typedef struct _cl_params_clUnloadPlatformCompiler { + cl_platform_id *platform; +} cl_params_clUnloadPlatformCompiler; + +typedef struct _cl_params_clWaitForEvents { + cl_uint *numEvents; + const cl_event **eventList; +} cl_params_clWaitForEvents; diff --git a/unit_tests/api/CMakeLists.txt b/unit_tests/api/CMakeLists.txt index f77c0f79e8..39fdafc914 100644 --- a/unit_tests/api/CMakeLists.txt +++ b/unit_tests/api/CMakeLists.txt @@ -92,6 +92,7 @@ set(IGDRCL_SRCS_tests_api ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_supported_image_formats_tests.inl ${CMAKE_CURRENT_SOURCE_DIR}/cl_icd_get_platform_ids_khr_tests.inl ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_accelerator_tests.inl + ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_tracing_tests.inl ${CMAKE_CURRENT_SOURCE_DIR}/cl_intel_motion_estimation.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cl_link_program_tests.inl ${CMAKE_CURRENT_SOURCE_DIR}/cl_mem_locally_uncached_resource_tests.cpp diff --git a/unit_tests/api/api_tests_wrapper3.cpp b/unit_tests/api/api_tests_wrapper3.cpp index 3ef01acfec..64c0b1c58a 100644 --- a/unit_tests/api/api_tests_wrapper3.cpp +++ b/unit_tests/api/api_tests_wrapper3.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 Intel Corporation + * Copyright (C) 2018-2019 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -15,6 +15,7 @@ #include "unit_tests/api/cl_get_supported_image_formats_tests.inl" #include "unit_tests/api/cl_icd_get_platform_ids_khr_tests.inl" #include "unit_tests/api/cl_intel_accelerator_tests.inl" +#include "unit_tests/api/cl_intel_tracing_tests.inl" #include "unit_tests/api/cl_link_program_tests.inl" #include "unit_tests/api/cl_release_command_queue_tests.inl" #include "unit_tests/api/cl_release_context_tests.inl" diff --git a/unit_tests/api/cl_api_tests.h b/unit_tests/api/cl_api_tests.h index 99d08c8671..4636e1223f 100644 --- a/unit_tests/api/cl_api_tests.h +++ b/unit_tests/api/cl_api_tests.h @@ -7,6 +7,7 @@ #pragma once #include "runtime/api/api.h" +#include "runtime/tracing/tracing_api.h" #include "test.h" #include "unit_tests/fixtures/platform_fixture.h" diff --git a/unit_tests/api/cl_get_extension_function_address_for_platform_tests.inl b/unit_tests/api/cl_get_extension_function_address_for_platform_tests.inl index c4ab14e773..37c9a03af2 100644 --- a/unit_tests/api/cl_get_extension_function_address_for_platform_tests.inl +++ b/unit_tests/api/cl_get_extension_function_address_for_platform_tests.inl @@ -47,4 +47,34 @@ TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClCreateProgramWithIL auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clCreateProgramWithILKHR"); EXPECT_EQ(retVal, reinterpret_cast(clCreateProgramWithILKHR)); } + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClCreateTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clCreateTracingHandleINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clCreateTracingHandleINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClSetTracingPointINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clSetTracingPointINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clSetTracingPointINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClDestroyTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clDestroyTracingHandleINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clDestroyTracingHandleINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClEnableTracingINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clEnableTracingINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clEnableTracingINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClDisableTracingINTELLWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clDisableTracingINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clDisableTracingINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressForPlatformTests, GivenClGetTracingStateINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddressForPlatform(pPlatform, "clGetTracingStateINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clGetTracingStateINTEL)); +} } // namespace ULT diff --git a/unit_tests/api/cl_get_extension_function_address_tests.inl b/unit_tests/api/cl_get_extension_function_address_tests.inl index 36083e0e1c..b104e2fe8a 100644 --- a/unit_tests/api/cl_get_extension_function_address_tests.inl +++ b/unit_tests/api/cl_get_extension_function_address_tests.inl @@ -63,4 +63,33 @@ TEST_F(clGetExtensionFunctionAddressTests, givenClAddCommentToAubIntelAsInputWhe EXPECT_EQ(functionPointer, reinterpret_cast(clAddCommentINTEL)); } +TEST_F(clGetExtensionFunctionAddressTests, GivenClCreateTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clCreateTracingHandleINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clCreateTracingHandleINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressTests, GivenClSetTracingPointINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clSetTracingPointINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clSetTracingPointINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressTests, GivenClDestroyTracingHandleINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clDestroyTracingHandleINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clDestroyTracingHandleINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressTests, GivenClEnableTracingINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clEnableTracingINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clEnableTracingINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressTests, GivenClDisableTracingINTELLWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clDisableTracingINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clDisableTracingINTEL)); +} + +TEST_F(clGetExtensionFunctionAddressTests, GivenClGetTracingStateINTELWhenGettingExtensionFunctionThenCorrectAddressIsReturned) { + auto retVal = clGetExtensionFunctionAddress("clGetTracingStateINTEL"); + EXPECT_EQ(retVal, reinterpret_cast(clGetTracingStateINTEL)); +} } // namespace ULT diff --git a/unit_tests/api/cl_intel_tracing_tests.inl b/unit_tests/api/cl_intel_tracing_tests.inl new file mode 100644 index 0000000000..f0e9050a16 --- /dev/null +++ b/unit_tests/api/cl_intel_tracing_tests.inl @@ -0,0 +1,867 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "runtime/tracing/tracing_api.h" +#include "runtime/tracing/tracing_notify.h" +#include "unit_tests/api/cl_api_tests.h" + +using namespace NEO; + +namespace ULT { + +struct IntelTracingTest : public api_tests { + public: + IntelTracingTest() {} + + void SetUp() override { + api_tests::SetUp(); + } + + void TearDown() override { + api_tests::TearDown(); + } + + protected: + static void callback(cl_function_id fid, cl_callback_data *callbackData, void *userData) { + ASSERT_NE(nullptr, userData); + IntelTracingTest *base = (IntelTracingTest *)userData; + base->vcallback(fid, callbackData, nullptr); + } + + virtual void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) {} + + protected: + cl_tracing_handle handle = nullptr; + cl_int status = CL_SUCCESS; +}; + +TEST_F(IntelTracingTest, GivenInvalidDeviceExpectFail) { + status = clCreateTracingHandleINTEL(nullptr, callback, nullptr, &handle); + EXPECT_EQ(static_cast(nullptr), handle); + EXPECT_EQ(CL_INVALID_VALUE, status); +} + +TEST_F(IntelTracingTest, GivenInvalidCallbackExpectFail) { + status = clCreateTracingHandleINTEL(devices[0], nullptr, nullptr, &handle); + EXPECT_EQ(static_cast(nullptr), handle); + EXPECT_EQ(CL_INVALID_VALUE, status); +} + +TEST_F(IntelTracingTest, GivenInvalidHandlePointerExpectFail) { + status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, nullptr); + EXPECT_EQ(CL_INVALID_VALUE, status); +} + +TEST_F(IntelTracingTest, GivenInvalidHandleExpectFail) { + status = clSetTracingPointINTEL(nullptr, CL_FUNCTION_clBuildProgram, CL_TRUE); + EXPECT_EQ(CL_INVALID_VALUE, status); + + status = clDestroyTracingHandleINTEL(nullptr); + EXPECT_EQ(CL_INVALID_VALUE, status); + + status = clEnableTracingINTEL(nullptr); + EXPECT_EQ(CL_INVALID_VALUE, status); + + status = clDisableTracingINTEL(nullptr); + EXPECT_EQ(CL_INVALID_VALUE, status); + + status = clSetTracingPointINTEL(nullptr, CL_FUNCTION_clBuildProgram, CL_FALSE); + EXPECT_EQ(CL_INVALID_VALUE, status); + + cl_bool enabled = CL_FALSE; + status = clGetTracingStateINTEL(nullptr, &enabled); + EXPECT_EQ(CL_INVALID_VALUE, status); +} + +TEST_F(IntelTracingTest, GivenInactiveHandleExpectFail) { + status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, &handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clDisableTracingINTEL(handle); + EXPECT_EQ(CL_INVALID_VALUE, status); + + status = clDestroyTracingHandleINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); +} + +TEST_F(IntelTracingTest, GivenTooManyHandlesExpectFail) { + cl_tracing_handle handle[HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1] = {nullptr}; + + for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1; ++i) { + status = clCreateTracingHandleINTEL(devices[0], callback, nullptr, &(handle[i])); + EXPECT_EQ(CL_SUCCESS, status); + } + + for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT; ++i) { + status = clEnableTracingINTEL(handle[i]); + EXPECT_EQ(CL_SUCCESS, status); + } + + status = clEnableTracingINTEL(handle[HostSideTracing::TRACING_MAX_HANDLE_COUNT]); + EXPECT_EQ(CL_OUT_OF_RESOURCES, status); + + for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT; ++i) { + status = clDisableTracingINTEL(handle[i]); + EXPECT_EQ(CL_SUCCESS, status); + } + + for (uint32_t i = 0; i < HostSideTracing::TRACING_MAX_HANDLE_COUNT + 1; ++i) { + status = clDestroyTracingHandleINTEL(handle[i]); + EXPECT_EQ(CL_SUCCESS, status); + } +} + +TEST_F(IntelTracingTest, EnableTracingExpectPass) { + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clSetTracingPointINTEL(handle, CL_FUNCTION_clBuildProgram, CL_TRUE); + EXPECT_EQ(CL_SUCCESS, status); + + cl_bool enabled = CL_FALSE; + status = clGetTracingStateINTEL(handle, &enabled); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_EQ(static_cast(CL_FALSE), enabled); + + status = clEnableTracingINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clGetTracingStateINTEL(handle, &enabled); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_EQ(static_cast(CL_TRUE), enabled); + + status = clDisableTracingINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clGetTracingStateINTEL(handle, &enabled); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_EQ(static_cast(CL_FALSE), enabled); + + status = clSetTracingPointINTEL(handle, CL_FUNCTION_clBuildProgram, CL_FALSE); + EXPECT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); +} + +TEST_F(IntelTracingTest, EnableTwoHandlesExpectPass) { + cl_tracing_handle handle1 = nullptr; + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle1); + EXPECT_EQ(CL_SUCCESS, status); + cl_tracing_handle handle2 = nullptr; + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle2); + EXPECT_EQ(CL_SUCCESS, status); + + status = clSetTracingPointINTEL(handle1, CL_FUNCTION_clBuildProgram, CL_TRUE); + EXPECT_EQ(CL_SUCCESS, status); + status = clSetTracingPointINTEL(handle2, CL_FUNCTION_clBuildProgram, CL_TRUE); + EXPECT_EQ(CL_SUCCESS, status); + + status = clEnableTracingINTEL(handle1); + EXPECT_EQ(CL_SUCCESS, status); + status = clEnableTracingINTEL(handle2); + EXPECT_EQ(CL_SUCCESS, status); + + cl_bool enabled = CL_FALSE; + status = clGetTracingStateINTEL(handle1, &enabled); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_EQ(static_cast(CL_TRUE), enabled); + status = clGetTracingStateINTEL(handle2, &enabled); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_EQ(static_cast(CL_TRUE), enabled); + + status = clDisableTracingINTEL(handle1); + EXPECT_EQ(CL_SUCCESS, status); + status = clDisableTracingINTEL(handle2); + EXPECT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(handle1); + EXPECT_EQ(CL_SUCCESS, status); + status = clDestroyTracingHandleINTEL(handle2); + EXPECT_EQ(CL_SUCCESS, status); +} + +struct IntelAllTracingTest : public IntelTracingTest { + public: + IntelAllTracingTest() {} + + void SetUp() override { + IntelTracingTest::SetUp(); + + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle); + ASSERT_NE(nullptr, handle); + ASSERT_EQ(CL_SUCCESS, status); + + for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) { + status = clSetTracingPointINTEL(handle, static_cast(i), CL_TRUE); + ASSERT_EQ(CL_SUCCESS, status); + } + + status = clEnableTracingINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + } + + void TearDown() override { + status = clDisableTracingINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + + IntelTracingTest::TearDown(); + } + + protected: + void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override { + if (fid == functionId) { + if (callbackData->site == CL_CALLBACK_SITE_ENTER) { + ++enterCount; + } else if (callbackData->site == CL_CALLBACK_SITE_EXIT) { + ++exitCount; + } + } + } + + uint16_t callFunctions() { + uint16_t count = 0; + + ++count; + functionId = CL_FUNCTION_clBuildProgram; + clBuildProgram(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCloneKernel; + clCloneKernel(0, 0); + + ++count; + functionId = CL_FUNCTION_clCompileProgram; + clCompileProgram(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateBuffer; + clCreateBuffer(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateCommandQueue; + clCreateCommandQueue(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateCommandQueueWithProperties; + clCreateCommandQueueWithProperties(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateContext; + clCreateContext(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateContextFromType; + clCreateContextFromType(0, 0, 0, 0, 0); + + ++count; + cl_image_desc imageDesc = {0}; + functionId = CL_FUNCTION_clCreateImage; + clCreateImage(0, 0, 0, &imageDesc, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateImage2D; + clCreateImage2D(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateImage3D; + clCreateImage3D(0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateKernel; + clCreateKernel(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateKernelsInProgram; + clCreateKernelsInProgram(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreatePipe; + clCreatePipe(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateProgramWithBinary; + const size_t length = 32; + unsigned char binary[length] = {0}; + clCreateProgramWithBinary(0, 0, &(devices[0]), &length, reinterpret_cast(&binary), 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateProgramWithBuiltInKernels; + clCreateProgramWithBuiltInKernels(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateProgramWithIL; + clCreateProgramWithIL(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateProgramWithSource; + clCreateProgramWithSource(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateSampler; + clCreateSampler(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateSamplerWithProperties; + clCreateSamplerWithProperties(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateSubBuffer; + clCreateSubBuffer(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateSubDevices; + clCreateSubDevices(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateUserEvent; + clCreateUserEvent(0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueBarrier; + clEnqueueBarrier(0); + + ++count; + functionId = CL_FUNCTION_clEnqueueBarrierWithWaitList; + clEnqueueBarrierWithWaitList(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueCopyBuffer; + clEnqueueCopyBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueCopyBufferRect; + clEnqueueCopyBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueCopyBufferToImage; + clEnqueueCopyBufferToImage(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueCopyImage; + clEnqueueCopyImage(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueCopyImageToBuffer; + clEnqueueCopyImageToBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueFillBuffer; + clEnqueueFillBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueFillImage; + clEnqueueFillImage(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueMapBuffer; + clEnqueueMapBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueMapImage; + clEnqueueMapImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueMarker; + clEnqueueMarker(0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueMarkerWithWaitList; + clEnqueueMarkerWithWaitList(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueMigrateMemObjects; + clEnqueueMigrateMemObjects(0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueNDRangeKernel; + clEnqueueNDRangeKernel(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueNativeKernel; + clEnqueueNativeKernel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueReadBuffer; + clEnqueueReadBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueReadBufferRect; + clEnqueueReadBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueReadImage; + clEnqueueReadImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMFree; + clEnqueueSVMFree(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMMap; + clEnqueueSVMMap(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMMemFill; + clEnqueueSVMMemFill(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMMemcpy; + clEnqueueSVMMemcpy(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMMigrateMem; + clEnqueueSVMMigrateMem(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueSVMUnmap; + clEnqueueSVMUnmap(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueTask; + clEnqueueTask(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueUnmapMemObject; + clEnqueueUnmapMemObject(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueWaitForEvents; + clEnqueueWaitForEvents(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueWriteBuffer; + clEnqueueWriteBuffer(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueWriteBufferRect; + clEnqueueWriteBufferRect(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueWriteImage; + clEnqueueWriteImage(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clFinish; + clFinish(0); + + ++count; + functionId = CL_FUNCTION_clFlush; + clFlush(0); + + ++count; + functionId = CL_FUNCTION_clGetCommandQueueInfo; + clGetCommandQueueInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetContextInfo; + clGetContextInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetDeviceAndHostTimer; + clGetDeviceAndHostTimer(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetDeviceIDs; + clGetDeviceIDs(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetDeviceInfo; + clGetDeviceInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetEventInfo; + clGetEventInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetEventProfilingInfo; + clGetEventProfilingInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetExtensionFunctionAddress; + clGetExtensionFunctionAddress("test"); + + ++count; + functionId = CL_FUNCTION_clGetExtensionFunctionAddressForPlatform; + clGetExtensionFunctionAddressForPlatform(0, "test"); + + ++count; + functionId = CL_FUNCTION_clGetHostTimer; + clGetHostTimer(0, 0); + + ++count; + functionId = CL_FUNCTION_clGetImageInfo; + clGetImageInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetKernelArgInfo; + clGetKernelArgInfo(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetKernelInfo; + clGetKernelInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetKernelSubGroupInfo; + clGetKernelSubGroupInfo(0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetKernelWorkGroupInfo; + clGetKernelWorkGroupInfo(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetMemObjectInfo; + clGetMemObjectInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetPipeInfo; + clGetPipeInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetPlatformIDs; + clGetPlatformIDs(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetPlatformInfo; + clGetPlatformInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetProgramBuildInfo; + clGetProgramBuildInfo(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetProgramInfo; + clGetProgramInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetSamplerInfo; + clGetSamplerInfo(0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetSupportedImageFormats; + clGetSupportedImageFormats(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clLinkProgram; + clLinkProgram(0, 0, 0, 0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clReleaseCommandQueue; + clReleaseCommandQueue(0); + + ++count; + functionId = CL_FUNCTION_clReleaseContext; + clReleaseContext(0); + + ++count; + functionId = CL_FUNCTION_clReleaseDevice; + clReleaseDevice(0); + + ++count; + functionId = CL_FUNCTION_clReleaseEvent; + clReleaseEvent(0); + + ++count; + functionId = CL_FUNCTION_clReleaseKernel; + clReleaseKernel(0); + + ++count; + functionId = CL_FUNCTION_clReleaseMemObject; + clReleaseMemObject(0); + + ++count; + functionId = CL_FUNCTION_clReleaseProgram; + clReleaseProgram(0); + + ++count; + functionId = CL_FUNCTION_clReleaseSampler; + clReleaseSampler(0); + + ++count; + functionId = CL_FUNCTION_clRetainCommandQueue; + clRetainCommandQueue(0); + + ++count; + functionId = CL_FUNCTION_clRetainContext; + clRetainContext(0); + + ++count; + functionId = CL_FUNCTION_clRetainDevice; + clRetainDevice(0); + + ++count; + functionId = CL_FUNCTION_clRetainEvent; + clRetainEvent(0); + + ++count; + functionId = CL_FUNCTION_clRetainKernel; + clRetainKernel(0); + + ++count; + functionId = CL_FUNCTION_clRetainMemObject; + clRetainMemObject(0); + + ++count; + functionId = CL_FUNCTION_clRetainProgram; + clRetainProgram(0); + + ++count; + functionId = CL_FUNCTION_clRetainSampler; + clRetainSampler(0); + + ++count; + functionId = CL_FUNCTION_clSVMAlloc; + clSVMAlloc(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSVMFree; + clSVMFree(0, 0); + + ++count; + functionId = CL_FUNCTION_clSetCommandQueueProperty; + clSetCommandQueueProperty(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetDefaultDeviceCommandQueue; + clSetDefaultDeviceCommandQueue(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetEventCallback; + clSetEventCallback(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetKernelArg; + clSetKernelArg(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetKernelArgSVMPointer; + clSetKernelArgSVMPointer(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetKernelExecInfo; + clSetKernelExecInfo(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetMemObjectDestructorCallback; + clSetMemObjectDestructorCallback(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clSetUserEventStatus; + clSetUserEventStatus(0, 0); + + ++count; + functionId = CL_FUNCTION_clUnloadCompiler; + clUnloadCompiler(); + + ++count; + functionId = CL_FUNCTION_clUnloadPlatformCompiler; + clUnloadPlatformCompiler(0); + + ++count; + functionId = CL_FUNCTION_clWaitForEvents; + clWaitForEvents(0, 0); + + return count; + } + + protected: + uint16_t enterCount = 0; + uint16_t exitCount = 0; + cl_function_id functionId = CL_FUNCTION_COUNT; +}; + +TEST_F(IntelAllTracingTest, GivenAllFunctionsToTraceExpectPass) { + uint16_t count = callFunctions(); + EXPECT_EQ(count, enterCount); + EXPECT_EQ(count, exitCount); +} + +TEST_F(IntelAllTracingTest, GivenNoFunctionsToTraceExpectPass) { + for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) { + status = clSetTracingPointINTEL(handle, static_cast(i), CL_FALSE); + EXPECT_EQ(CL_SUCCESS, status); + } + + callFunctions(); + + EXPECT_EQ(0, enterCount); + EXPECT_EQ(0, exitCount); +} + +struct IntelClGetDeviceInfoTracingCollectTest : public IntelAllTracingTest { + public: + IntelClGetDeviceInfoTracingCollectTest() {} + + protected: + void call(cl_device_id target) { + device = target; + status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, ¶mValueSizeRet); + } + + void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override { + EXPECT_EQ(CL_FUNCTION_clGetDeviceInfo, fid); + EXPECT_NE(nullptr, callbackData); + + if (callbackData->site == CL_CALLBACK_SITE_ENTER) { + correlationId = callbackData->correlationId; + EXPECT_NE(nullptr, callbackData->correlationData); + callbackData->correlationData[0] = 777ull; + } else { + EXPECT_EQ(correlationId, callbackData->correlationId); + EXPECT_NE(nullptr, callbackData->correlationData); + EXPECT_EQ(777ull, callbackData->correlationData[0]); + } + + EXPECT_NE(nullptr, callbackData->functionName); + EXPECT_STREQ("clGetDeviceInfo", callbackData->functionName); + EXPECT_NE(nullptr, callbackData->functionParams); + if (callbackData->site == CL_CALLBACK_SITE_ENTER) { + EXPECT_EQ(nullptr, callbackData->functionReturnValue); + } else { + EXPECT_NE(nullptr, callbackData->functionReturnValue); + } + + cl_params_clGetDeviceInfo *params = (cl_params_clGetDeviceInfo *)callbackData->functionParams; + EXPECT_NE(nullptr, *params->device); + EXPECT_EQ(static_cast(CL_DEVICE_VENDOR), *params->paramName); + EXPECT_EQ(0u, *params->paramValueSize); + EXPECT_EQ(nullptr, *params->paramValue); + + if (callbackData->site == CL_CALLBACK_SITE_EXIT) { + cl_int *retVal = (cl_int *)callbackData->functionReturnValue; + EXPECT_EQ(CL_SUCCESS, *retVal); + EXPECT_LT(0u, **params->paramValueSizeRet); + } + + if (callbackData->site == CL_CALLBACK_SITE_ENTER) { + ++enterCount; + } else if (callbackData->site == CL_CALLBACK_SITE_EXIT) { + ++exitCount; + } + } + + protected: + cl_device_id device = nullptr; + size_t paramValueSizeRet = 0; + uint64_t correlationId = 0; +}; + +TEST_F(IntelClGetDeviceInfoTracingCollectTest, GeneralTracingCollectionExpectPass) { + call(devices[0]); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_LT(0u, paramValueSizeRet); + + EXPECT_EQ(1u, enterCount); + EXPECT_EQ(1u, exitCount); +} + +struct IntelClGetDeviceInfoTracingChangeParamsTest : public IntelAllTracingTest { + public: + IntelClGetDeviceInfoTracingChangeParamsTest() {} + + protected: + void call(cl_device_id target) { + device = target; + status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, ¶mValueSizeRet); + } + + void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override { + if (callbackData->site == CL_CALLBACK_SITE_ENTER) { + cl_params_clGetDeviceInfo *params = (cl_params_clGetDeviceInfo *)callbackData->functionParams; + *params->paramValueSize = paramValueSize; + *params->paramValue = paramValue; + } + } + + protected: + cl_device_id device = nullptr; + size_t paramValueSizeRet = 0; + static const size_t paramValueSize = 256; + char paramValue[paramValueSize]; +}; + +TEST_F(IntelClGetDeviceInfoTracingChangeParamsTest, GeneralTracingWithParamsChangeExpectPass) { + paramValue[0] = '\0'; + call(devices[0]); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_LT(0u, paramValueSizeRet); + EXPECT_STRNE("", paramValue); +} + +struct IntelClGetDeviceInfoTracingChangeRetValTest : public IntelAllTracingTest { + public: + IntelClGetDeviceInfoTracingChangeRetValTest() {} + + protected: + void call(cl_device_id target) { + device = target; + status = clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, ¶mValueSizeRet); + } + + void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) override { + if (callbackData->site == CL_CALLBACK_SITE_EXIT) { + cl_int *retVal = reinterpret_cast(callbackData->functionReturnValue); + *retVal = CL_INVALID_VALUE; + } + } + + protected: + cl_device_id device = nullptr; + size_t paramValueSizeRet = 0; +}; + +TEST_F(IntelClGetDeviceInfoTracingChangeRetValTest, GeneralTracingWithRetValChangeExpectPass) { + call(devices[0]); + EXPECT_EQ(CL_INVALID_VALUE, status); + EXPECT_LT(0u, paramValueSizeRet); +} + +struct IntelClGetDeviceInfoTwoHandlesTracingCollectTest : public IntelClGetDeviceInfoTracingCollectTest { + public: + IntelClGetDeviceInfoTwoHandlesTracingCollectTest() {} + + void SetUp() override { + IntelClGetDeviceInfoTracingCollectTest::SetUp(); + + status = clCreateTracingHandleINTEL(devices[0], callback, this, &secondHandle); + ASSERT_NE(nullptr, secondHandle); + ASSERT_EQ(CL_SUCCESS, status); + + status = clSetTracingPointINTEL(secondHandle, CL_FUNCTION_clGetDeviceInfo, CL_TRUE); + ASSERT_EQ(CL_SUCCESS, status); + + status = clEnableTracingINTEL(secondHandle); + ASSERT_EQ(CL_SUCCESS, status); + } + + void TearDown() override { + status = clDisableTracingINTEL(secondHandle); + ASSERT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(secondHandle); + ASSERT_EQ(CL_SUCCESS, status); + + IntelClGetDeviceInfoTracingCollectTest::TearDown(); + } + + protected: + cl_tracing_handle secondHandle = nullptr; +}; + +TEST_F(IntelClGetDeviceInfoTwoHandlesTracingCollectTest, GeneralTracingCollectionWithTwoHandlesExpectPass) { + call(devices[0]); + EXPECT_EQ(CL_SUCCESS, status); + EXPECT_LT(0u, paramValueSizeRet); + + EXPECT_EQ(2u, enterCount); + EXPECT_EQ(2u, exitCount); +} + +} // namespace ULT \ No newline at end of file diff --git a/unit_tests/api/cl_intel_tracing_tests_mt.cpp b/unit_tests/api/cl_intel_tracing_tests_mt.cpp new file mode 100644 index 0000000000..f71bc82a84 --- /dev/null +++ b/unit_tests/api/cl_intel_tracing_tests_mt.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "runtime/tracing/tracing_api.h" +#include "runtime/tracing/tracing_notify.h" +#include "unit_tests/api/cl_api_tests.h" + +using namespace NEO; + +namespace ULT { + +struct IntelTracingMtTest : public api_tests { + public: + IntelTracingMtTest() : started(false), count(0) {} + + void SetUp() override { + api_tests::SetUp(); + } + + void TearDown() override { + api_tests::TearDown(); + } + + protected: + static void threadBody(int iterationCount, IntelTracingMtTest *test) { + test->vthreadBody(iterationCount); + } + + virtual void vthreadBody(int iterationCount) { + cl_int status = CL_SUCCESS; + cl_platform_id platform = nullptr; + const uint32_t maxStrSize = 1024; + char buffer[maxStrSize] = {0}; + + while (!started) { + } + + for (int i = 0; i < iterationCount; ++i) { + HostSideTracing::AtomicBackoff backoff; + + status = clGetDeviceInfo(devices[0], CL_DEVICE_NAME, maxStrSize, buffer, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + backoff.pause(); + + status = clGetDeviceInfo(devices[0], CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + backoff.pause(); + + status = clGetPlatformInfo(platform, CL_PLATFORM_VERSION, maxStrSize, buffer, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + backoff.pause(); + + status = clGetPlatformInfo(platform, CL_PLATFORM_NAME, maxStrSize, buffer, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + backoff.pause(); + } + } + + static void callback(cl_function_id fid, cl_callback_data *callbackData, void *userData) { + ASSERT_NE(nullptr, userData); + IntelTracingMtTest *base = (IntelTracingMtTest *)userData; + base->vcallback(fid, callbackData, nullptr); + } + + virtual void vcallback(cl_function_id fid, cl_callback_data *callbackData, void *userData) { + if (fid == CL_FUNCTION_clGetDeviceInfo || + fid == CL_FUNCTION_clGetPlatformInfo) { + ++count; + } + } + + protected: + cl_tracing_handle handle = nullptr; + cl_int status = CL_SUCCESS; + + std::atomic started; + std::atomic count; +}; + +TEST_F(IntelTracingMtTest, SafeTracingFromMultipleThreads) { + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clSetTracingPointINTEL(handle, CL_FUNCTION_clGetDeviceInfo, CL_TRUE); + EXPECT_EQ(CL_SUCCESS, status); + + status = clSetTracingPointINTEL(handle, CL_FUNCTION_clGetPlatformInfo, CL_TRUE); + EXPECT_EQ(CL_SUCCESS, status); + + status = clEnableTracingINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); + + int numThreads = 4; + int iterationCount = 1024; + std::vector threads; + + for (int i = 0; i < numThreads; ++i) { + threads.push_back(std::thread(threadBody, iterationCount, this)); + } + + started = true; + + for (size_t i = 0; i < threads.size(); ++i) { + threads[i].join(); + } + + status = clDisableTracingINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(handle); + EXPECT_EQ(CL_SUCCESS, status); + + int callsPerIteration = 4; + int callbacksPerCall = 2; + EXPECT_EQ(numThreads * iterationCount * callsPerIteration * callbacksPerCall, count); +} + +} // namespace ULT \ No newline at end of file diff --git a/unit_tests/api/gl/CMakeLists.txt b/unit_tests/api/gl/CMakeLists.txt index dd1839df31..b7e2d53ebf 100644 --- a/unit_tests/api/gl/CMakeLists.txt +++ b/unit_tests/api/gl/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2017-2018 Intel Corporation +# Copyright (C) 2017-2019 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -18,6 +18,7 @@ if(WIN32) ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_context_info_khr_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_object_info_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_texture_info_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/cl_gl_intel_tracing_tests.cpp ) target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_api_gl}) endif() diff --git a/unit_tests/api/gl/cl_gl_intel_tracing_tests.cpp b/unit_tests/api/gl/cl_gl_intel_tracing_tests.cpp new file mode 100644 index 0000000000..f10390f42f --- /dev/null +++ b/unit_tests/api/gl/cl_gl_intel_tracing_tests.cpp @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2019 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "runtime/tracing/tracing_api.h" +#include "runtime/tracing/tracing_notify.h" +#include "unit_tests/api/cl_api_tests.h" + +using namespace NEO; + +namespace ULT { + +struct IntelGlTracingTest : public api_tests { + public: + IntelGlTracingTest() {} + + void SetUp() override { + api_tests::SetUp(); + + status = clCreateTracingHandleINTEL(devices[0], callback, this, &handle); + ASSERT_NE(nullptr, handle); + ASSERT_EQ(CL_SUCCESS, status); + + for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) { + status = clSetTracingPointINTEL(handle, static_cast(i), CL_TRUE); + ASSERT_EQ(CL_SUCCESS, status); + } + + status = clEnableTracingINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + } + + void TearDown() override { + status = clDisableTracingINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + + status = clDestroyTracingHandleINTEL(handle); + ASSERT_EQ(CL_SUCCESS, status); + + api_tests::TearDown(); + } + + protected: + static void callback(cl_function_id fid, cl_callback_data *callback_data, void *user_data) { + ASSERT_NE(nullptr, user_data); + IntelGlTracingTest *base = (IntelGlTracingTest *)user_data; + base->vcallback(fid, callback_data, nullptr); + } + + virtual void vcallback(cl_function_id fid, cl_callback_data *callback_data, void *user_data) { + if (fid == functionId) { + if (callback_data->site == CL_CALLBACK_SITE_ENTER) { + ++enterCount; + } else if (callback_data->site == CL_CALLBACK_SITE_EXIT) { + ++exitCount; + } + } + } + + uint16_t callFunctions() { + uint16_t count = 0; + + ++count; + functionId = CL_FUNCTION_clCreateFromGLBuffer; + clCreateFromGLBuffer(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateFromGLRenderbuffer; + clCreateFromGLRenderbuffer(0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateFromGLTexture; + clCreateFromGLTexture(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateFromGLTexture2D; + clCreateFromGLTexture2D(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clCreateFromGLTexture3D; + clCreateFromGLTexture3D(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueAcquireGLObjects; + clEnqueueAcquireGLObjects(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clEnqueueReleaseGLObjects; + clEnqueueReleaseGLObjects(0, 0, 0, 0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetGLObjectInfo; + clGetGLObjectInfo(0, 0, 0); + + ++count; + functionId = CL_FUNCTION_clGetGLTextureInfo; + clGetGLTextureInfo(0, 0, 0, 0, 0); + + return count; + } + + protected: + cl_tracing_handle handle = nullptr; + cl_int status = CL_SUCCESS; + + uint16_t enterCount = 0; + uint16_t exitCount = 0; + cl_function_id functionId = CL_FUNCTION_COUNT; +}; + +TEST_F(IntelGlTracingTest, GivenAllFunctionsToTraceExpectPass) { + uint16_t count = callFunctions(); + EXPECT_EQ(count, enterCount); + EXPECT_EQ(count, exitCount); +} + +TEST_F(IntelGlTracingTest, GivenNoFunctionsToTraceExpectPass) { + for (uint32_t i = 0; i < CL_FUNCTION_COUNT; ++i) { + status = clSetTracingPointINTEL(handle, static_cast(i), CL_FALSE); + EXPECT_EQ(CL_SUCCESS, status); + } + + callFunctions(); + + EXPECT_EQ(0, enterCount); + EXPECT_EQ(0, exitCount); +} + +} // namespace ULT diff --git a/unit_tests/mt_tests/api/CMakeLists.txt b/unit_tests/mt_tests/api/CMakeLists.txt index be2ba076b5..9e42600c81 100644 --- a/unit_tests/mt_tests/api/CMakeLists.txt +++ b/unit_tests/mt_tests/api/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2017-2018 Intel Corporation +# Copyright (C) 2017-2019 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -12,6 +12,7 @@ set(IGDRCL_SRCS_mt_tests_api ${IGDRCL_SOURCE_DIR}/unit_tests/api/cl_api_tests.cpp ${IGDRCL_SOURCE_DIR}/unit_tests/api/cl_create_user_event_tests_mt.cpp ${IGDRCL_SOURCE_DIR}/unit_tests/api/cl_get_platform_ids_tests_mt.cpp + ${IGDRCL_SOURCE_DIR}/unit_tests/api/cl_intel_tracing_tests_mt.cpp ${IGDRCL_SOURCE_DIR}/unit_tests/api/cl_set_mem_object_destructor_callback_tests_mt.cpp ) target_sources(igdrcl_mt_tests PRIVATE ${IGDRCL_SRCS_mt_tests_api})