intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-22 10:17:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move OCL specific part of FileLogger to ClFileLogger

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2021-10-08 11:02:35 +00:00
committed by Compute-Runtime-Automation
parent 06561a06b6
commit ec1e39bab8
13 changed files with 353 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
opencl/source/api/api.cpp
View File

@@ -50,6 +50,7 @@
#include "opencl/source/sharings/sharing_factory.h"
#include "opencl/source/tracing/tracing_api.h"
#include "opencl/source/tracing/tracing_notify.h"
#include "opencl/source/utilities/cl_logger.h"
#include "CL/cl.h"
#include "config.h"
@@ -1974,7 +1975,7 @@ cl_int CL_API_CALL clWaitForEvents(cl_uint numEvents,
auto retVal = CL_SUCCESS;
API_ENTER(&retVal);
DBG_LOG_INPUTS("eventList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventList), numEvents));
DBG_LOG_INPUTS("eventList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventList), numEvents));
for (unsigned int i = 0; i < numEvents && retVal == CL_SUCCESS; i++)
retVal = validateObjects(eventList[i]);
@@ -2282,8 +2283,8 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue, "buffer", buffer, "blockingRead", blockingRead,
"offset", offset, "cb", cb, "ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS == retVal) {
@@ -2311,7 +2312,7 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueReadBuffer, &retVal);
return retVal;
}
@@ -2351,8 +2352,8 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue,
"hostSlicePitch", hostSlicePitch,
"ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pBuffer = nullptr;
@@ -2425,8 +2426,8 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue, "buffer", buffer, "blockingWrite", blockingWrite,
"offset", offset, "cb", cb, "ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pBuffer = nullptr;
@@ -2462,7 +2463,7 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueWriteBuffer, &retVal);
return retVal;
}
@@ -2492,8 +2493,8 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue,
"bufferRowPitch", bufferRowPitch, "bufferSlicePitch", bufferSlicePitch,
"hostRowPitch", hostRowPitch, "hostSlicePitch", hostSlicePitch, "ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pBuffer = nullptr;
@@ -2568,8 +2569,8 @@ cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue commandQueue,
"pattern", NEO::FileLoggerInstance().infoPointerToString(pattern, patternSize), "patternSize", patternSize,
"offset", offset, "size", size,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pBuffer = nullptr;
@@ -2618,8 +2619,8 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue, "srcBuffer", srcBuffer, "dstBuffer", dstBuffer,
"srcOffset", srcOffset, "dstOffset", dstOffset, "cb", cb,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pSrcBuffer = nullptr;
@@ -2655,7 +2656,7 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueCopyBuffer, &retVal);
return retVal;
}
@@ -2684,8 +2685,8 @@ cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue commandQueue,
"srcRowPitch", srcRowPitch, "srcSlicePitch", srcSlicePitch,
"dstRowPitch", dstRowPitch, "dstSlicePitch", dstSlicePitch,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pSrcBuffer = nullptr;
@@ -2736,7 +2737,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueCopyBufferRect, &retVal);
return retVal;
}
@@ -2768,8 +2769,8 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue,
"region[0]", NEO::FileLoggerInstance().getInput(region, 0), "region[1]", NEO::FileLoggerInstance().getInput(region, 1), "region[2]", NEO::FileLoggerInstance().getInput(region, 2),
"rowPitch", rowPitch, "slicePitch", slicePitch, "ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS == retVal) {
@@ -2810,7 +2811,7 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueReadImage, &retVal);
return retVal;
}
@@ -2842,8 +2843,8 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue,
"region[0]", NEO::FileLoggerInstance().getInput(region, 0), "region[1]", NEO::FileLoggerInstance().getInput(region, 1), "region[2]", NEO::FileLoggerInstance().getInput(region, 2),
"inputRowPitch", inputRowPitch, "inputSlicePitch", inputSlicePitch, "ptr", ptr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS == retVal) {
if (pImage->writeMemObjFlagsInvalid()) {
@@ -2883,7 +2884,7 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueWriteImage, &retVal);
return retVal;
}
@@ -2913,8 +2914,8 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue,
"origin[0]", NEO::FileLoggerInstance().getInput(origin, 0), "origin[1]", NEO::FileLoggerInstance().getInput(origin, 1), "origin[2]", NEO::FileLoggerInstance().getInput(origin, 2),
"region[0]", NEO::FileLoggerInstance().getInput(region, 0), "region[1]", NEO::FileLoggerInstance().getInput(region, 1), "region[2]", NEO::FileLoggerInstance().getInput(region, 2),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS == retVal) {
retVal = Image::validateRegionAndOrigin(origin, region, dstImage->getImageDesc());
@@ -2938,7 +2939,7 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueFillImage, &retVal);
return retVal;
}
@@ -2969,8 +2970,8 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue,
"dstOrigin[0]", NEO::FileLoggerInstance().getInput(dstOrigin, 0), "dstOrigin[1]", NEO::FileLoggerInstance().getInput(dstOrigin, 1), "dstOrigin[2]", NEO::FileLoggerInstance().getInput(dstOrigin, 2),
"region[0]", region ? region[0] : 0, "region[1]", region ? region[1] : 0, "region[2]", region ? region[2] : 0,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS == retVal) {
if (memcmp(&pSrcImage->getImageFormat(), &pDstImage->getImageFormat(), sizeof(cl_image_format))) {
@@ -3025,7 +3026,7 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue,
eventWaitList,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueCopyImage, &retVal);
return retVal;
}
@@ -3048,8 +3049,8 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue,
"region[0]", NEO::FileLoggerInstance().getInput(region, 0), "region[1]", NEO::FileLoggerInstance().getInput(region, 1), "region[2]", NEO::FileLoggerInstance().getInput(region, 2),
"dstOffset", dstOffset,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Image *pSrcImage = nullptr;
@@ -3091,7 +3092,7 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueCopyImageToBuffer, &retVal);
return retVal;
}
@@ -3113,8 +3114,8 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue,
"dstOrigin[0]", NEO::FileLoggerInstance().getInput(dstOrigin, 0), "dstOrigin[1]", NEO::FileLoggerInstance().getInput(dstOrigin, 1), "dstOrigin[2]", NEO::FileLoggerInstance().getInput(dstOrigin, 2),
"region[0]", NEO::FileLoggerInstance().getInput(region, 0), "region[1]", NEO::FileLoggerInstance().getInput(region, 1), "region[2]", NEO::FileLoggerInstance().getInput(region, 2),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Buffer *pSrcBuffer = nullptr;
@@ -3156,7 +3157,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue,
event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueCopyBufferToImage, &retVal);
return retVal;
}
@@ -3179,8 +3180,8 @@ void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue, "buffer", buffer, "blockingMap", blockingMap,
"mapFlags", mapFlags, "offset", offset, "cb", cb,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
do {
auto pCommandQueue = castToObject<CommandQueue>(commandQueue);
@@ -3219,7 +3220,7 @@ void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue commandQueue,
} while (false);
err.set(retVal);
DBG_LOG_INPUTS("retPtr", retPtr, "event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("retPtr", retPtr, "event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueMapBuffer, &retPtr);
return retPtr;
@@ -3253,8 +3254,8 @@ void *CL_API_CALL clEnqueueMapImage(cl_command_queue commandQueue,
"imageRowPitch", NEO::FileLoggerInstance().getInput(imageRowPitch, 0),
"imageSlicePitch", NEO::FileLoggerInstance().getInput(imageSlicePitch, 0),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
do {
Image *pImage = nullptr;
@@ -3304,7 +3305,7 @@ void *CL_API_CALL clEnqueueMapImage(cl_command_queue commandQueue,
} while (false);
err.set(retVal);
DBG_LOG_INPUTS("retPtr", retPtr, "event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("retPtr", retPtr, "event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueMapImage, &retPtr);
return retPtr;
@@ -3331,8 +3332,8 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue,
"memObj", memObj,
"mappedPtr", mappedPtr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal == CL_SUCCESS) {
cl_command_queue_capabilities_intel requiredCapability = 0u;
@@ -3363,7 +3364,7 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue,
retVal = pCommandQueue->enqueueUnmapMemObject(pMemObj, mappedPtr, numEventsInWaitList, eventWaitList, event);
}
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueUnmapMemObject, &retVal);
return retVal;
}
@@ -3384,8 +3385,8 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue,
"memObjects", memObjects,
"flags", flags,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(
@@ -3426,7 +3427,7 @@ cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue commandQueue,
numEventsInWaitList,
eventWaitList,
event);
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueMigrateMemObjects, &retVal);
return retVal;
}
@@ -3450,8 +3451,8 @@ cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue commandQueue,
"globalWorkSize", NEO::FileLoggerInstance().getSizes(globalWorkSize, workDim, false),
"localWorkSize", NEO::FileLoggerInstance().getSizes(localWorkSize, workDim, true),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
MultiDeviceKernel *pMultiDeviceKernel = nullptr;
@@ -3495,7 +3496,7 @@ cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue commandQueue,
eventWaitList,
event);
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
TRACING_EXIT(clEnqueueNDRangeKernel, &retVal);
return retVal;
}
@@ -3510,8 +3511,8 @@ cl_int CL_API_CALL clEnqueueTask(cl_command_queue commandQueue,
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue, "kernel", kernel,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
cl_uint workDim = 3;
size_t *globalWorkOffset = nullptr;
size_t globalWorkSize[3] = {1, 1, 1};
@@ -3546,8 +3547,8 @@ cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue, "userFunc", userFunc, "args", args,
"cbArgs", cbArgs, "numMemObjects", numMemObjects, "memList", memList, "argsMemLoc", argsMemLoc,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
TRACING_EXIT(clEnqueueNativeKernel, &retVal);
return retVal;
@@ -3588,7 +3589,7 @@ cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue commandQueue,
TRACING_ENTER(clEnqueueWaitForEvents, &commandQueue, &numEvents, &eventList);
cl_int retVal = CL_SUCCESS;
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue, "eventList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventList), numEvents));
DBG_LOG_INPUTS("commandQueue", commandQueue, "eventList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventList), numEvents));
auto pCommandQueue = castToObject<CommandQueue>(commandQueue);
if (!pCommandQueue) {
@@ -3652,8 +3653,8 @@ cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue commandQueue,
API_ENTER(&retVal);
DBG_LOG_INPUTS("cl_command_queue", commandQueue,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(
@@ -3688,8 +3689,8 @@ cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue commandQueue,
API_ENTER(&retVal);
DBG_LOG_INPUTS("cl_command_queue", commandQueue,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
@@ -4548,8 +4549,8 @@ cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue,
"pfnFreeFunc", pfnFreeFunc,
"userData", userData,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
TRACING_EXIT(clEnqueueSVMFree, &retVal);
@@ -4607,8 +4608,8 @@ cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue commandQueue,
"srcPtr", srcPtr,
"size", size,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
TRACING_EXIT(clEnqueueSVMMemcpy, &retVal);
@@ -4671,8 +4672,8 @@ cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue commandQueue,
"patternSize", patternSize,
"size", size,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
TRACING_EXIT(clEnqueueSVMMemFill, &retVal);
@@ -4733,8 +4734,8 @@ cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue commandQueue,
"svmPtr", NEO::FileLoggerInstance().infoPointerToString(svmPtr, size),
"size", size,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (CL_SUCCESS != retVal) {
TRACING_EXIT(clEnqueueSVMMap, &retVal);
@@ -4793,8 +4794,8 @@ cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue commandQueue,
DBG_LOG_INPUTS("commandQueue", commandQueue,
"svmPtr", svmPtr,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
TRACING_EXIT(clEnqueueSVMUnmap, &retVal);
@@ -5527,8 +5528,8 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue,
"sizes", NEO::FileLoggerInstance().getInput(sizes, 0),
"flags", flags,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(
@@ -5914,8 +5915,8 @@ cl_int CL_API_CALL clEnqueueNDCountKernelINTEL(cl_command_queue commandQueue,
"workgroupCount", NEO::FileLoggerInstance().getSizes(workgroupCount, workDim, false),
"localWorkSize", NEO::FileLoggerInstance().getSizes(localWorkSize, workDim, true),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
Kernel *pKernel = nullptr;
@@ -5991,7 +5992,7 @@ cl_int CL_API_CALL clEnqueueNDCountKernelINTEL(cl_command_queue commandQueue,
eventWaitList,
event);
DBG_LOG_INPUTS("event", NEO::FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
DBG_LOG_INPUTS("event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1u));
return retVal;
}

3
opencl/source/command_queue/enqueue_common.h
View File

@@ -40,6 +40,7 @@
#include "opencl/source/memory_manager/migration_controller.h"
#include "opencl/source/program/block_kernel_manager.h"
#include "opencl/source/program/printf_handler.h"
#include "opencl/source/utilities/cl_logger.h"
#include "pipe_control_args.h"
@@ -427,7 +428,7 @@ void CommandQueueHw<GfxFamily>::processDispatchForKernels(const MultiDispatchInf
KernelOperation *blockedCommandsData,
TimestampPacketDependencies &timestampPacketDependencies) {
TagNodeBase *hwPerfCounter = nullptr;
FileLoggerInstance().dumpKernelArgs(&multiDispatchInfo);
getClFileLogger().dumpKernelArgs(&multiDispatchInfo);
printfHandler.reset(PrintfHandler::create(multiDispatchInfo, *device));
if (printfHandler) {

33
opencl/source/os_interface/windows/api_win.cpp
View File

@@ -21,6 +21,7 @@
#include "opencl/source/sharings/d3d/d3d_buffer.h"
#include "opencl/source/sharings/d3d/d3d_surface.h"
#include "opencl/source/sharings/d3d/d3d_texture.h"
#include "opencl/source/utilities/cl_logger.h"
using namespace NEO;
@@ -158,8 +159,8 @@ cl_int CL_API_CALL clEnqueueAcquireDX9ObjectsINTEL(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -177,8 +178,8 @@ cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -250,8 +251,8 @@ cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(cl_command_queue commandQ
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -270,8 +271,8 @@ cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue commandQ
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -446,8 +447,8 @@ cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -479,8 +480,8 @@ cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -655,8 +656,8 @@ cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}
@@ -688,8 +689,8 @@ cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(cl_command_queue commandQueue
"numObjects", numObjects,
"memObjects", memObjects,
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
if (retVal != CL_SUCCESS) {
return retVal;
}

9
opencl/source/sharings/gl/windows/cl_gl_api.cpp
View File

@@ -26,6 +26,7 @@
#include "opencl/source/sharings/gl/gl_texture.h"
#include "opencl/source/sharings/gl/windows/gl_sharing_windows.h"
#include "opencl/source/tracing/tracing_notify.h"
#include "opencl/source/utilities/cl_logger.h"
#include "CL/cl.h"
#include "CL/cl_gl.h"
@@ -227,8 +228,8 @@ cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue commandQueue, cl_u
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue, "numObjects", numObjects, "memObjects", memObjects, "numEventsInWaitList",
numEventsInWaitList, "eventWaitList",
FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(WithCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));
@@ -264,8 +265,8 @@ cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue commandQueue, cl_u
API_ENTER(&retVal);
DBG_LOG_INPUTS("commandQueue", commandQueue, "numObjects", numObjects, "memObjects", memObjects, "numEventsInWaitList",
numEventsInWaitList, "eventWaitList",
FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList), "event",
getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
retVal = validateObjects(WithCastToInternal(commandQueue, &pCommandQueue), EventWaitList(numEventsInWaitList, eventWaitList));

13
opencl/source/sharings/va/cl_va_api.cpp
View File

@@ -16,6 +16,7 @@
#include "opencl/source/sharings/va/va_device.h"
#include "opencl/source/sharings/va/va_sharing.h"
#include "opencl/source/sharings/va/va_surface.h"
#include "opencl/source/utilities/cl_logger.h"
#include "CL/cl.h"
@@ -96,10 +97,10 @@ clEnqueueAcquireVA_APIMediaSurfacesINTEL(cl_command_queue commandQueue,
API_ENTER(&status);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
"memObjects", FileLoggerInstance().getMemObjects(reinterpret_cast<const uintptr_t *>(memObjects), numObjects),
"memObjects", getClFileLogger().getMemObjects(reinterpret_cast<const uintptr_t *>(memObjects), numObjects),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;
@@ -123,10 +124,10 @@ clEnqueueReleaseVA_APIMediaSurfacesINTEL(cl_command_queue commandQueue,
API_ENTER(&status);
DBG_LOG_INPUTS("commandQueue", commandQueue,
"numObjects", numObjects,
"memObjects", FileLoggerInstance().getMemObjects(reinterpret_cast<const uintptr_t *>(memObjects), numObjects),
"memObjects", getClFileLogger().getMemObjects(reinterpret_cast<const uintptr_t *>(memObjects), numObjects),
"numEventsInWaitList", numEventsInWaitList,
"eventWaitList", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", FileLoggerInstance().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
"eventWaitList", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(eventWaitList), numEventsInWaitList),
"event", getClFileLogger().getEvents(reinterpret_cast<const uintptr_t *>(event), 1));
CommandQueue *pCommandQueue = nullptr;

3
opencl/source/utilities/CMakeLists.txt
View File

@@ -6,7 +6,8 @@
set(RUNTIME_SRCS_UTILITIES_BASE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/logger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/cl_logger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/cl_logger.h
)
set_property(GLOBAL PROPERTY RUNTIME_SRCS_UTILITIES_BASE ${RUNTIME_SRCS_UTILITIES_BASE})

136
opencl/source/utilities/cl_logger.cpp Normal file
View File

@@ -0,0 +1,136 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/source/utilities/cl_logger.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "opencl/source/event/event.h"
#include "opencl/source/helpers/dispatch_info.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/mem_obj.h"
namespace NEO {
template <DebugFunctionalityLevel DebugLevel>
ClFileLogger<DebugLevel>::ClFileLogger(FileLogger<DebugLevel> &baseLoggerIn, const DebugVariables &flags) : baseLogger(baseLoggerIn) {
dumpKernelArgsEnabled = flags.DumpKernelArgs.get();
}
ClFileLogger<globalDebugFunctionalityLevel> &getClFileLogger() {
static ClFileLogger<globalDebugFunctionalityLevel> clFileLoggerInstance(FileLoggerInstance(), DebugManager.flags);
return clFileLoggerInstance;
}
template <DebugFunctionalityLevel DebugLevel>
void ClFileLogger<DebugLevel>::dumpKernelArgs(const MultiDispatchInfo *multiDispatchInfo) {
if (false == baseLogger.enabled()) {
return;
}
if (dumpKernelArgsEnabled == false || multiDispatchInfo == nullptr) {
return;
}
for (auto &dispatchInfo : *multiDispatchInfo) {
auto kernel = dispatchInfo.getKernel();
if (kernel == nullptr) {
continue;
}
const auto &kernelDescriptor = kernel->getKernelInfo().kernelDescriptor;
const auto &explicitArgs = kernelDescriptor.payloadMappings.explicitArgs;
for (unsigned int i = 0; i < explicitArgs.size(); i++) {
std::string type;
std::string fileName;
const char *ptr = nullptr;
size_t size = 0;
uint64_t flags = 0;
std::unique_ptr<char[]> argVal = nullptr;
const auto &arg = explicitArgs[i];
if (arg.getTraits().getAddressQualifier() == KernelArgMetadata::AddrLocal) {
type = "local";
} else if (arg.is<ArgDescriptor::ArgTImage>()) {
type = "image";
auto clMem = reinterpret_cast<const _cl_mem *>(kernel->getKernelArg(i));
auto memObj = castToObject<MemObj>(clMem);
if (memObj != nullptr) {
ptr = static_cast<char *>(memObj->getCpuAddress());
size = memObj->getSize();
flags = memObj->getFlags();
}
} else if (arg.is<ArgDescriptor::ArgTSampler>()) {
type = "sampler";
} else if (arg.is<ArgDescriptor::ArgTPointer>()) {
type = "buffer";
auto clMem = reinterpret_cast<const _cl_mem *>(kernel->getKernelArg(i));
auto memObj = castToObject<MemObj>(clMem);
if (memObj != nullptr) {
ptr = static_cast<char *>(memObj->getCpuAddress());
size = memObj->getSize();
flags = memObj->getFlags();
}
} else {
type = "immediate";
auto crossThreadData = kernel->getCrossThreadData();
auto crossThreadDataSize = kernel->getCrossThreadDataSize();
argVal = std::unique_ptr<char[]>(new char[crossThreadDataSize]);
size_t totalArgSize = 0;
for (const auto &element : arg.as<ArgDescValue>().elements) {
auto pSource = ptrOffset(crossThreadData, element.offset);
auto pDestination = ptrOffset(argVal.get(), element.sourceOffset);
memcpy_s(pDestination, element.size, pSource, element.size);
totalArgSize += element.size;
}
size = totalArgSize;
ptr = argVal.get();
}
if (ptr && size) {
fileName = kernelDescriptor.kernelMetadata.kernelName + "_arg_" + std::to_string(i) + "_" + type + "_size_" + std::to_string(size) + "_flags_" + std::to_string(flags) + ".bin";
baseLogger.writeToFile(fileName, ptr, size, std::ios::trunc | std::ios::binary);
}
}
}
}
template <DebugFunctionalityLevel DebugLevel>
const std::string ClFileLogger<DebugLevel>::getEvents(const uintptr_t *input, uint32_t numOfEvents) {
if (false == baseLogger.enabled()) {
return "";
}
std::stringstream os;
for (uint32_t i = 0; i < numOfEvents; i++) {
if (input != nullptr) {
cl_event event = (reinterpret_cast<const cl_event *>(input))[i];
os << "cl_event " << event << ", Event " << (Event *)event << ", ";
}
}
return os.str();
}
template <DebugFunctionalityLevel DebugLevel>
const std::string ClFileLogger<DebugLevel>::getMemObjects(const uintptr_t *input, uint32_t numOfObjects) {
if (false == baseLogger.enabled()) {
return "";
}
std::stringstream os;
for (uint32_t i = 0; i < numOfObjects; i++) {
if (input != nullptr) {
cl_mem mem = const_cast<cl_mem>(reinterpret_cast<const cl_mem *>(input)[i]);
os << "cl_mem " << mem << ", MemObj " << static_cast<MemObj *>(mem) << ", ";
}
}
return os.str();
}
template class ClFileLogger<DebugFunctionalityLevel::None>;
template class ClFileLogger<DebugFunctionalityLevel::RegKeys>;
template class ClFileLogger<DebugFunctionalityLevel::Full>;
} // namespace NEO

34
opencl/source/utilities/cl_logger.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "shared/source/utilities/logger.h"
#include <cinttypes>
#include <cstddef>
#include <string>
namespace NEO {
struct MultiDispatchInfo;
template <DebugFunctionalityLevel DebugLevel>
class ClFileLogger : public NonCopyableOrMovableClass {
public:
ClFileLogger(FileLogger<DebugLevel> &baseLoggerInm, const DebugVariables &flags);
void dumpKernelArgs(const MultiDispatchInfo *multiDispatchInfo);
const std::string getEvents(const uintptr_t *input, uint32_t numOfEvents);
const std::string getMemObjects(const uintptr_t *input, uint32_t numOfObjects);
protected:
bool dumpKernelArgsEnabled = false;
FileLogger<DebugLevel> &baseLogger;
};
ClFileLogger<globalDebugFunctionalityLevel> &getClFileLogger();
}; // namespace NEO

85
opencl/test/unit_test/utilities/file_logger_tests.cpp
View File

@@ -230,10 +230,11 @@ TEST(FileLogger, WhenGettingEventsThenCorrectValueIsReturned) {
flags.LogApiCalls.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
// getEvents returns string
uintptr_t event = 8;
uintptr_t *input[3] = {&event, &event, &event};
std::string eventsString = fileLogger.getEvents((uintptr_t *)input, 2);
std::string eventsString = clFileLogger.getEvents((uintptr_t *)input, 2);
EXPECT_NE(0u, eventsString.size());
}
@@ -242,8 +243,9 @@ TEST(FileLogger, GivenNullInputWhenGettingEventsThenZeroIsReturned) {
DebugVariables flags;
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
// getEvents returns 0 sized string
std::string event = fileLogger.getEvents(nullptr, 2);
std::string event = clFileLogger.getEvents(nullptr, 2);
EXPECT_EQ(0u, event.size());
}
@@ -253,13 +255,14 @@ TEST(FileLogger, GivenLoggerWithDebugFunctionalityWhenGetMemObjectsIsCalledThenC
flags.LogApiCalls.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
MockBuffer buffer;
MemObj *memoryObject = &buffer;
cl_mem clMem = memoryObject;
cl_mem clMemObjects[] = {clMem, clMem};
cl_uint numObjects = 2;
std::string memObjectString = fileLogger.getMemObjects(reinterpret_cast<const uintptr_t *>(clMemObjects), numObjects);
std::string memObjectString = clFileLogger.getMemObjects(reinterpret_cast<const uintptr_t *>(clMemObjects), numObjects);
EXPECT_NE(0u, memObjectString.size());
std::stringstream output;
output << "cl_mem " << clMem << ", MemObj " << memoryObject;
@@ -270,7 +273,8 @@ TEST(FileLogger, GivenDebugFunctionalityWhenGetMemObjectsIsCalledWithNullptrThen
std::string testFile = "testfile";
DebugVariables flags;
FullyEnabledFileLogger fileLogger(testFile, flags);
std::string memObjectString = fileLogger.getMemObjects(nullptr, 2);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
std::string memObjectString = clFileLogger.getMemObjects(nullptr, 2);
EXPECT_EQ(0u, memObjectString.size());
}
@@ -278,7 +282,8 @@ TEST(FileLogger, GiveDisabledDebugFunctionalityWhenGetMemObjectsIsCalledThenCall
std::string testFile = "testfile";
DebugVariables flags;
FullyDisabledFileLogger fileLogger(testFile, flags);
std::string memObjectString = fileLogger.getMemObjects(nullptr, 2);
FullyDisabledClFileLogger clFileLogger(fileLogger, flags);
std::string memObjectString = clFileLogger.getMemObjects(nullptr, 2);
EXPECT_EQ(0u, memObjectString.size());
}
@@ -338,8 +343,9 @@ TEST(FileLogger, GivenNullMdiWhenDumpingKernelsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs((const MultiDispatchInfo *)nullptr);
clFileLogger.dumpKernelArgs(nullptr);
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
}
@@ -362,8 +368,9 @@ TEST(FileLogger, GivenDebugFunctionalityWhenDebugFlagIsDisabledThenDoNotDumpKern
DebugVariables flags;
flags.DumpKernelArgs.set(false);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(multiDispatchInfo.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// check if file was created
std::string expectedFile = "_arg_0_immediate_size_32_flags_0.bin";
@@ -391,8 +398,9 @@ TEST(FileLogger, GivenMdiWhenDumpingKernelArgsThenFileIsCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(multiDispatchInfo.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// check if file was created
std::string expectedFile = "_arg_0_immediate_size_32_flags_0.bin";
@@ -407,7 +415,11 @@ TEST(FileLogger, GivenNullWhenDumpingKernelArgsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
fileLogger.dumpKernelArgs((const Kernel *)nullptr);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), nullptr));
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
}
@@ -418,13 +430,15 @@ TEST(FileLogger, GivenEmptyKernelWhenDumpingKernelArgsThenFileIsNotCreated) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(toClDeviceVector(*device));
auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
std::string testFile = "testfile";
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
}
@@ -436,6 +450,7 @@ TEST(FileLogger, GivenImmediateWhenDumpingKernelArgsThenFileIsCreated) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(toClDeviceVector(*device));
auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgImmediate(0, 32, 32);
@@ -447,8 +462,9 @@ TEST(FileLogger, GivenImmediateWhenDumpingKernelArgsThenFileIsCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// check if file was created
EXPECT_TRUE(fileLogger.wasFileCreated("_arg_0_immediate_size_32_flags_0.bin"));
@@ -463,6 +479,7 @@ TEST(FileLogger, GivenImmediateZeroSizeWhenDumpingKernelArgsThenFileIsNotCreated
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(toClDeviceVector(*device));
auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgImmediate(0, 0, 32);
@@ -474,7 +491,8 @@ TEST(FileLogger, GivenImmediateZeroSizeWhenDumpingKernelArgsThenFileIsNotCreated
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
fileLogger.dumpKernelArgs(kernel.get());
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// no files should be created for zero size
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
@@ -486,6 +504,7 @@ TEST(FileLogger, GivenLocalBufferWhenDumpingKernelArgsThenFileIsNotCreated) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockProgram program(toClDeviceVector(*device));
auto kernel = std::unique_ptr<MockKernel>(new MockKernel(&program, *kernelInfo, *device));
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgBuffer(0);
kernelInfo->setAddressQualifier(0, KernelArgMetadata::AddrLocal);
@@ -494,7 +513,8 @@ TEST(FileLogger, GivenLocalBufferWhenDumpingKernelArgsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
fileLogger.dumpKernelArgs(kernel.get());
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// no files should be created for local buffer
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
@@ -507,6 +527,7 @@ TEST(FileLogger, GivenBufferNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
auto context = clUniquePtr(new MockContext(device.get()));
auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgBuffer(0);
kernelInfo->addExtendedMetadata(0, "", "uint8 *buffer");
@@ -521,8 +542,9 @@ TEST(FileLogger, GivenBufferNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// no files should be created for local buffer
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
@@ -538,6 +560,7 @@ TEST(FileLogger, GivenBufferWhenDumpingKernelArgsThenFileIsCreated) {
kernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgBuffer(0);
kernelInfo->addExtendedMetadata(0, "", "uint8 *buffer");
@@ -554,8 +577,9 @@ TEST(FileLogger, GivenBufferWhenDumpingKernelArgsThenFileIsCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
buffer->release();
@@ -573,6 +597,7 @@ TEST(FileLogger, GivenSamplerWhenDumpingKernelArgsThenFileIsNotCreated) {
auto context = clUniquePtr(new MockContext(device.get()));
auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgSampler(0);
kernelInfo->addExtendedMetadata(0, "", "sampler test");
@@ -583,8 +608,9 @@ TEST(FileLogger, GivenSamplerWhenDumpingKernelArgsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// no files should be created for sampler arg
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
@@ -597,6 +623,7 @@ TEST(FileLogger, GivenImageNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
auto context = clUniquePtr(new MockContext(device.get()));
auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
char surfaceStateHeap[0x80];
kernelInfo->heapInfo.pSsh = surfaceStateHeap;
@@ -616,8 +643,9 @@ TEST(FileLogger, GivenImageNotSetWhenDumpingKernelArgsThenFileIsNotCreated) {
DebugVariables flags;
flags.DumpKernelArgs.set(true);
FullyEnabledFileLogger fileLogger(testFile, flags);
FullyEnabledClFileLogger clFileLogger(fileLogger, flags);
fileLogger.dumpKernelArgs(kernel.get());
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// no files should be created for local buffer
EXPECT_EQ(fileLogger.createdFilesCount(), 0);
@@ -652,6 +680,7 @@ TEST(FileLogger, GivenDisabledDebugFunctionalityWhenLoggingThenDumpingDoesNotOcc
flags.LogApiCalls.set(true);
flags.DumpKernelArgs.set(true);
FullyDisabledFileLogger fileLogger(testFile, flags);
FullyDisabledClFileLogger clFileLogger(fileLogger, flags);
// Should not be enabled without debug functionality
EXPECT_FALSE(fileLogger.enabled());
@@ -679,7 +708,7 @@ TEST(FileLogger, GivenDisabledDebugFunctionalityWhenLoggingThenDumpingDoesNotOcc
EXPECT_EQ(0u, output);
// getEvents returns 0-size string
std::string event = fileLogger.getEvents(&input, 0);
std::string event = clFileLogger.getEvents(&input, 0);
EXPECT_EQ(0u, event.size());
// getSizes returns 0-size string
@@ -696,7 +725,25 @@ TEST(FileLogger, GivenDisabledDebugFunctionalityWhenLoggingThenDumpingDoesNotOcc
fileLogger.dumpBinaryProgram(1, &length, &ptrBinary);
EXPECT_FALSE(fileLogger.wasFileCreated(programDumpFile));
fileLogger.dumpKernelArgs((const Kernel *)nullptr);
auto kernelInfo = std::make_unique<MockKernelInfo>();
kernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
auto context = clUniquePtr(new MockContext(device.get()));
auto program = clUniquePtr(new MockProgram(context.get(), false, toClDeviceVector(*device)));
auto kernel = std::make_unique<MockKernel>(program.get(), *kernelInfo, *device);
auto multiDispatchInfo = std::unique_ptr<MockMultiDispatchInfo>(new MockMultiDispatchInfo(device.get(), kernel.get()));
kernelInfo->addArgBuffer(0);
kernelInfo->addExtendedMetadata(0, "", "uint8 *buffer");
kernel->initialize();
size_t crossThreadDataSize = sizeof(void *);
auto crossThreadData = std::unique_ptr<uint8_t>(new uint8_t[crossThreadDataSize]);
kernel->setCrossThreadData(crossThreadData.get(), static_cast<uint32_t>(crossThreadDataSize));
kernel->setArg(0, nullptr);
clFileLogger.dumpKernelArgs(multiDispatchInfo.get());
// test api input logging
fileLogger.logInputs("Arg name", "value");

5
opencl/test/unit_test/utilities/file_logger_tests.h
View File

@@ -12,6 +12,8 @@
#include "shared/source/utilities/directory.h"
#include "shared/source/utilities/logger.h"
#include "opencl/source/utilities/cl_logger.h"
#include <map>
template <DebugFunctionalityLevel DebugLevel>
@@ -58,6 +60,9 @@ class TestFileLogger : public NEO::FileLogger<DebugLevel> {
using FullyEnabledFileLogger = TestFileLogger<DebugFunctionalityLevel::Full>;
using FullyDisabledFileLogger = TestFileLogger<DebugFunctionalityLevel::None>;
using FullyEnabledClFileLogger = NEO::ClFileLogger<DebugFunctionalityLevel::Full>;
using FullyDisabledClFileLogger = NEO::ClFileLogger<DebugFunctionalityLevel::None>;
template <bool DebugFunctionality>
class TestLoggerApiEnterWrapper : public NEO::LoggerApiEnterWrapper<DebugFunctionality> {
public:

1
shared/source/utilities/CMakeLists.txt
View File

@@ -24,6 +24,7 @@ set(NEO_CORE_UTILITIES
${CMAKE_CURRENT_SOURCE_DIR}/iflist.h
${CMAKE_CURRENT_SOURCE_DIR}/idlist.h
${CMAKE_CURRENT_SOURCE_DIR}/io_functions.h
${CMAKE_CURRENT_SOURCE_DIR}/logger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/logger.h
${CMAKE_CURRENT_SOURCE_DIR}/metrics_library.h
${CMAKE_CURRENT_SOURCE_DIR}/numeric.h

124
opencl/source/utilities/logger.cpp → shared/source/utilities/logger.cpp
View File

@@ -10,12 +10,6 @@
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/timestamp_packet.h"
#include "opencl/source/cl_device/cl_device.h"
#include "opencl/source/event/event.h"
#include "opencl/source/helpers/dispatch_info.h"
#include "opencl/source/kernel/kernel.h"
#include "opencl/source/mem_obj/mem_obj.h"
#include <memory>
#include <string>
@@ -32,7 +26,6 @@ FileLogger<DebugLevel>::FileLogger(std::string filename, const DebugVariables &f
std::remove(logFileName.c_str());
dumpKernels = flags.DumpKernels.get();
dumpKernelArgsEnabled = flags.DumpKernelArgs.get();
logApiCalls = flags.LogApiCalls.get();
logAllocationMemoryPool = flags.LogAllocationMemoryPool.get();
logAllocationType = flags.LogAllocationType.get();
@@ -43,6 +36,7 @@ FileLogger<DebugLevel>::~FileLogger() = default;
template <DebugFunctionalityLevel DebugLevel>
void FileLogger<DebugLevel>::writeToFile(std::string filename, const char *str, size_t length, std::ios_base::openmode mode) {
std::unique_lock<std::mutex> theLock(mtx);
std::ofstream outFile(filename, mode);
if (outFile.is_open()) {
outFile.write(str, length);
@@ -69,7 +63,6 @@ void FileLogger<DebugLevel>::logApiCall(const char *function, bool enter, int32_
}
if (logApiCalls) {
std::unique_lock<std::mutex> theLock(mtx);
std::thread::id thisThread = std::this_thread::get_id();
std::stringstream ss;
@@ -110,7 +103,6 @@ void FileLogger<DebugLevel>::logAllocation(GraphicsAllocation const *graphicsAll
auto str = ss.str();
std::unique_lock<std::mutex> theLock(mtx);
writeToFile(logFileName, str.c_str(), str.size(), std::ios::app);
}
}
@@ -122,38 +114,6 @@ size_t FileLogger<DebugLevel>::getInput(const size_t *input, int32_t index) {
return input != nullptr ? input[index] : 0;
}
template <DebugFunctionalityLevel DebugLevel>
const std::string FileLogger<DebugLevel>::getEvents(const uintptr_t *input, uint32_t numOfEvents) {
if (false == enabled()) {
return "";
}
std::stringstream os;
for (uint32_t i = 0; i < numOfEvents; i++) {
if (input != nullptr) {
cl_event event = ((cl_event *)input)[i];
os << "cl_event " << event << ", Event " << (Event *)event << ", ";
}
}
return os.str();
}
template <DebugFunctionalityLevel DebugLevel>
const std::string FileLogger<DebugLevel>::getMemObjects(const uintptr_t *input, uint32_t numOfObjects) {
if (false == enabled()) {
return "";
}
std::stringstream os;
for (uint32_t i = 0; i < numOfObjects; i++) {
if (input != nullptr) {
cl_mem mem = const_cast<cl_mem>(reinterpret_cast<const cl_mem *>(input)[i]);
os << "cl_mem " << mem << ", MemObj " << static_cast<MemObj *>(mem) << ", ";
}
}
return os.str();
}
template <DebugFunctionalityLevel DebugLevel>
void FileLogger<DebugLevel>::dumpBinaryProgram(int32_t numDevices, const size_t *lengths, const unsigned char **binaries) {
if (false == enabled()) {
@@ -163,93 +123,11 @@ void FileLogger<DebugLevel>::dumpBinaryProgram(int32_t numDevices, const size_t
if (dumpKernels) {
if (lengths != nullptr && binaries != nullptr &&
lengths[0] != 0 && binaries[0] != nullptr) {
std::unique_lock<std::mutex> theLock(mtx);
writeToFile("programBinary.bin", reinterpret_cast<const char *>(binaries[0]), lengths[0], std::ios::trunc | std::ios::binary);
}
}
}
template <DebugFunctionalityLevel DebugLevel>
void FileLogger<DebugLevel>::dumpKernelArgs(const Kernel *kernel) {
if (false == enabled()) {
return;
}
if (dumpKernelArgsEnabled && kernel != nullptr) {
std::unique_lock<std::mutex> theLock(mtx);
std::ofstream outFile;
const auto &kernelDescriptor = kernel->getKernelInfo().kernelDescriptor;
const auto &explicitArgs = kernelDescriptor.payloadMappings.explicitArgs;
for (unsigned int i = 0; i < explicitArgs.size(); i++) {
std::string type;
std::string fileName;
const char *ptr = nullptr;
size_t size = 0;
uint64_t flags = 0;
std::unique_ptr<char[]> argVal = nullptr;
const auto &arg = explicitArgs[i];
if (arg.getTraits().getAddressQualifier() == KernelArgMetadata::AddrLocal) {
type = "local";
} else if (arg.is<ArgDescriptor::ArgTImage>()) {
type = "image";
auto clMem = (const cl_mem)kernel->getKernelArg(i);
auto memObj = castToObject<MemObj>(clMem);
if (memObj != nullptr) {
ptr = static_cast<char *>(memObj->getCpuAddress());
size = memObj->getSize();
flags = memObj->getFlags();
}
} else if (arg.is<ArgDescriptor::ArgTSampler>()) {
type = "sampler";
} else if (arg.is<ArgDescriptor::ArgTPointer>()) {
type = "buffer";
auto clMem = (const cl_mem)kernel->getKernelArg(i);
auto memObj = castToObject<MemObj>(clMem);
if (memObj != nullptr) {
ptr = static_cast<char *>(memObj->getCpuAddress());
size = memObj->getSize();
flags = memObj->getFlags();
}
} else {
type = "immediate";
auto crossThreadData = kernel->getCrossThreadData();
auto crossThreadDataSize = kernel->getCrossThreadDataSize();
argVal = std::unique_ptr<char[]>(new char[crossThreadDataSize]);
size_t totalArgSize = 0;
for (const auto &element : arg.as<ArgDescValue>().elements) {
auto pSource = ptrOffset(crossThreadData, element.offset);
auto pDestination = ptrOffset(argVal.get(), element.sourceOffset);
memcpy_s(pDestination, element.size, pSource, element.size);
totalArgSize += element.size;
}
size = totalArgSize;
ptr = argVal.get();
}
if (ptr && size) {
fileName = kernelDescriptor.kernelMetadata.kernelName + "_arg_" + std::to_string(i) + "_" + type + "_size_" + std::to_string(size) + "_flags_" + std::to_string(flags) + ".bin";
writeToFile(fileName, ptr, size, std::ios::trunc | std::ios::binary);
}
}
}
}
template <DebugFunctionalityLevel DebugLevel>
void FileLogger<DebugLevel>::dumpKernelArgs(const MultiDispatchInfo *multiDispatchInfo) {
if (enabled() == false) {
return;
}
if (dumpKernelArgsEnabled == false || multiDispatchInfo == nullptr) {
return;
}
for (auto &dispatchInfo : *multiDispatchInfo) {
dumpKernelArgs(dispatchInfo.getKernel());
}
}
const char *getAllocationTypeString(GraphicsAllocation const *graphicsAllocation) {
auto type = graphicsAllocation->getAllocationType();

5
shared/source/utilities/logger.h
View File

@@ -39,14 +39,10 @@ class FileLogger {
void logApiCall(const char *function, bool enter, int32_t errorCode);
void logAllocation(GraphicsAllocation const *graphicsAllocation);
size_t getInput(const size_t *input, int32_t index);
const std::string getEvents(const uintptr_t *input, uint32_t numOfEvents);
const std::string getMemObjects(const uintptr_t *input, uint32_t numOfObjects);
MOCKABLE_VIRTUAL void writeToFile(std::string filename, const char *str, size_t length, std::ios_base::openmode mode);
void dumpBinaryProgram(int32_t numDevices, const size_t *lengths, const unsigned char **binaries);
void dumpKernelArgs(const Kernel *kernel);
void dumpKernelArgs(const MultiDispatchInfo *multiDispatchInfo);
const std::string getSizes(const uintptr_t *input, uint32_t workDim, bool local) {
if (false == enabled()) {
@@ -145,7 +141,6 @@ class FileLogger {
std::mutex mtx;
std::string logFileName;
bool dumpKernels = false;
bool dumpKernelArgsEnabled = false;
bool logApiCalls = false;
bool logAllocationMemoryPool = false;
bool logAllocationType = false;