From 0a6da52bd4eb709667c0e147c5a5e4ea88de3007 Mon Sep 17 00:00:00 2001 From: Filip Hazubski Date: Tue, 12 May 2020 13:47:44 +0200 Subject: [PATCH] Add implementation of new OpenCL 3.0 API functions Additionally unify implementation of API functions related to creating buffers and images. Related-To: NEO-4368 Change-Id: Icfafc32f15e667e249fb318072194b6f76bd6481 Signed-off-by: Filip Hazubski --- opencl/source/api/api.cpp | 177 +++++++++--------- opencl/source/api/api.h | 21 ++- opencl/source/api/dispatch.cpp | 6 +- opencl/source/api/dispatch.h | 22 +++ opencl/source/dll/linux/ocl_internal.exports | 2 + .../dll/windows/OpenCLInternalExports.def.in | 2 + .../helpers/memory_properties_helpers.cpp | 31 ++- opencl/source/mem_obj/buffer.cpp | 56 ++++-- opencl/source/mem_obj/buffer.h | 57 +++--- opencl/source/mem_obj/buffer_factory_init.inl | 2 +- opencl/source/mem_obj/image.cpp | 38 +++- opencl/source/mem_obj/image.h | 51 +++-- opencl/source/mem_obj/image_factory_init.inl | 2 +- .../unit_test/api/cl_create_buffer_tests.cpp | 70 ++++++- .../unit_test/api/cl_create_image_tests.cpp | 84 ++++++++- .../multiple_map_image_tests.cpp | 2 +- .../test/unit_test/mem_obj/buffer_tests.cpp | 2 +- .../mem_obj/image_validate_tests.cpp | 14 +- 18 files changed, 450 insertions(+), 189 deletions(-) diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp index 6af729b0c0..cc652c8fa9 100644 --- a/opencl/source/api/api.cpp +++ b/opencl/source/api/api.cpp @@ -649,36 +649,45 @@ cl_mem CL_API_CALL clCreateBuffer(cl_context context, cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); - cl_mem buffer = nullptr; - ErrorCodeHelper err(errcodeRet, CL_SUCCESS); - Context *pContext = nullptr; - retVal = validateObjects(WithCastToInternal(context, &pContext)); - if (retVal != CL_SUCCESS) { - err.set(retVal); - TRACING_EXIT(clCreateBuffer, &buffer); - return nullptr; - } + cl_mem_properties *properties = nullptr; + cl_mem_flags_intel flagsIntel = 0; + cl_mem buffer = BufferFunctions::validateInputAndCreateBuffer(context, properties, flags, flagsIntel, size, hostPtr, retVal); - MemoryProperties memoryProperties = MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0); - if (isFieldValid(flags, MemObjHelper::validFlagsForBuffer)) { - Buffer::validateInputAndCreateBuffer(*pContext, memoryProperties, flags, 0, size, hostPtr, retVal, buffer); - } else { - retVal = CL_INVALID_VALUE; - } - - err.set(retVal); + ErrorCodeHelper{errcodeRet, retVal}; DBG_LOG_INPUTS("buffer", buffer); TRACING_EXIT(clCreateBuffer, &buffer); return buffer; } +cl_mem CL_API_CALL clCreateBufferWithProperties(cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + size_t size, + void *hostPtr, + cl_int *errcodeRet) { + DBG_LOG_INPUTS("cl_context", context, + "cl_mem_properties", properties, + "cl_mem_flags", flags, + "size", size, + "hostPtr", NEO::FileLoggerInstance().infoPointerToString(hostPtr, size)); + + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); + + cl_mem_flags_intel flagsIntel = 0; + cl_mem buffer = BufferFunctions::validateInputAndCreateBuffer(context, properties, flags, flagsIntel, size, hostPtr, retVal); + + ErrorCodeHelper{errcodeRet, retVal}; + DBG_LOG_INPUTS("buffer", buffer); + return buffer; +} + cl_mem CL_API_CALL clCreateBufferWithPropertiesINTEL(cl_context context, const cl_mem_properties_intel *properties, size_t size, void *hostPtr, cl_int *errcodeRet) { - DBG_LOG_INPUTS("cl_context", context, "cl_mem_properties_intel", properties, "size", size, @@ -686,28 +695,12 @@ cl_mem CL_API_CALL clCreateBufferWithPropertiesINTEL(cl_context context, cl_int retVal = CL_SUCCESS; API_ENTER(&retVal); - cl_mem buffer = nullptr; - ErrorCodeHelper err(errcodeRet, CL_SUCCESS); - Context *pContext = nullptr; - retVal = validateObjects(WithCastToInternal(context, &pContext)); - if (retVal != CL_SUCCESS) { - err.set(retVal); - return nullptr; - } - - MemoryProperties memoryProperties; cl_mem_flags flags = 0; cl_mem_flags_intel flagsIntel = 0; - cl_mem_alloc_flags_intel allocflags = 0; - if (MemoryPropertiesHelper::parseMemoryProperties(properties, memoryProperties, flags, flagsIntel, allocflags, - MemoryPropertiesHelper::ObjType::BUFFER, *pContext)) { - Buffer::validateInputAndCreateBuffer(*pContext, memoryProperties, flags, flagsIntel, size, hostPtr, retVal, buffer); - } else { - retVal = CL_INVALID_VALUE; - } + cl_mem buffer = BufferFunctions::validateInputAndCreateBuffer(context, properties, flags, flagsIntel, size, hostPtr, retVal); - err.set(retVal); + ErrorCodeHelper{errcodeRet, retVal}; DBG_LOG_INPUTS("buffer", buffer); return buffer; } @@ -825,9 +818,6 @@ cl_mem CL_API_CALL clCreateImage(cl_context context, cl_int *errcodeRet) { TRACING_ENTER(clCreateImage, &context, &flags, &imageFormat, &imageDesc, &hostPtr, &errcodeRet); - cl_int retVal = CL_SUCCESS; - - API_ENTER(&retVal); DBG_LOG_INPUTS("cl_context", context, "cl_mem_flags", flags, "cl_image_format.channel_data_type", imageFormat->image_channel_data_type, @@ -839,18 +829,12 @@ cl_mem CL_API_CALL clCreateImage(cl_context context, "cl_image_desc.array_size", imageDesc->image_array_size, "hostPtr", hostPtr); - cl_mem image = nullptr; - Context *pContext = nullptr; - retVal = validateObjects(WithCastToInternal(context, &pContext)); + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); - if (retVal == CL_SUCCESS) { - MemoryProperties memoryProperties = MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0); - if (isFieldValid(flags, MemObjHelper::validFlagsForImage)) { - image = Image::validateAndCreateImage(pContext, memoryProperties, flags, 0, imageFormat, imageDesc, hostPtr, retVal); - } else { - retVal = CL_INVALID_VALUE; - } - } + cl_mem_properties *properties = nullptr; + cl_mem_flags_intel flagsIntel = 0; + cl_mem image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal); ErrorCodeHelper err(errcodeRet, retVal); DBG_LOG_INPUTS("image", image); @@ -858,15 +842,44 @@ cl_mem CL_API_CALL clCreateImage(cl_context context, return image; } +cl_mem CL_API_CALL clCreateImageWithProperties(cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + const cl_image_format *imageFormat, + const cl_image_desc *imageDesc, + void *hostPtr, + cl_int *errcodeRet) { + + DBG_LOG_INPUTS("cl_context", context, + "cl_mem_properties", properties, + "cl_mem_flags", flags, + "cl_image_format.channel_data_type", imageFormat->image_channel_data_type, + "cl_image_format.channel_order", imageFormat->image_channel_order, + "cl_image_desc.width", imageDesc->image_width, + "cl_image_desc.heigth", imageDesc->image_height, + "cl_image_desc.depth", imageDesc->image_depth, + "cl_image_desc.type", imageDesc->image_type, + "cl_image_desc.array_size", imageDesc->image_array_size, + "hostPtr", hostPtr); + + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); + + cl_mem_flags_intel flagsIntel = 0; + cl_mem image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal); + + ErrorCodeHelper{errcodeRet, retVal}; + DBG_LOG_INPUTS("image", image); + return image; +} + cl_mem CL_API_CALL clCreateImageWithPropertiesINTEL(cl_context context, - cl_mem_properties_intel *properties, + const cl_mem_properties_intel *properties, const cl_image_format *imageFormat, const cl_image_desc *imageDesc, void *hostPtr, cl_int *errcodeRet) { - cl_int retVal = CL_SUCCESS; - API_ENTER(&retVal); DBG_LOG_INPUTS("cl_context", context, "cl_mem_properties_intel", properties, "cl_image_format.channel_data_type", imageFormat->image_channel_data_type, @@ -878,24 +891,14 @@ cl_mem CL_API_CALL clCreateImageWithPropertiesINTEL(cl_context context, "cl_image_desc.array_size", imageDesc->image_array_size, "hostPtr", hostPtr); - cl_mem image = nullptr; - Context *pContext = nullptr; - MemoryProperties memoryProperties; + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); + cl_mem_flags flags = 0; cl_mem_flags_intel flagsIntel = 0; - cl_mem_alloc_flags_intel allocflags = 0; - retVal = validateObjects(WithCastToInternal(context, &pContext)); + cl_mem image = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal); - if (retVal == CL_SUCCESS) { - if (MemoryPropertiesHelper::parseMemoryProperties(properties, memoryProperties, flags, flagsIntel, allocflags, - MemoryPropertiesHelper::ObjType::IMAGE, *pContext)) { - image = Image::validateAndCreateImage(pContext, memoryProperties, flags, flagsIntel, imageFormat, imageDesc, hostPtr, retVal); - } else { - retVal = CL_INVALID_VALUE; - } - } - - ErrorCodeHelper err(errcodeRet, retVal); + ErrorCodeHelper{errcodeRet, retVal}; DBG_LOG_INPUTS("image", image); return image; } @@ -911,9 +914,6 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context, 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, "flags", flags, "imageFormat", imageFormat, @@ -922,7 +922,9 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context, "imageRowPitch", imageRowPitch, "hostPtr", hostPtr); - cl_mem image2D = nullptr; + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); + cl_image_desc imageDesc; memset(&imageDesc, 0, sizeof(cl_image_desc)); @@ -931,15 +933,11 @@ cl_mem CL_API_CALL clCreateImage2D(cl_context context, imageDesc.image_row_pitch = imageRowPitch; imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D; - Context *pContext = nullptr; - retVal = validateObjects(WithCastToInternal(context, &pContext)); + cl_mem_properties *properties = nullptr; + cl_mem_flags_intel flagsIntel = 0; + cl_mem image2D = ImageFunctions::validateAndCreateImage(context, properties, flags, flagsIntel, imageFormat, &imageDesc, hostPtr, retVal); - if (retVal == CL_SUCCESS) { - MemoryProperties memoryProperties = MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0); - image2D = Image::validateAndCreateImage(pContext, memoryProperties, flags, 0, imageFormat, &imageDesc, hostPtr, retVal); - } - - ErrorCodeHelper err(errcodeRet, retVal); + ErrorCodeHelper{errcodeRet, retVal}; DBG_LOG_INPUTS("image 2D", image2D); TRACING_EXIT(clCreateImage2D, &image2D); return image2D; @@ -958,9 +956,6 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context, 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, "flags", flags, "imageFormat", imageFormat, @@ -971,7 +966,9 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context, "imageSlicePitch", imageSlicePitch, "hostPtr", hostPtr); - cl_mem image3D = nullptr; + cl_int retVal = CL_SUCCESS; + API_ENTER(&retVal); + cl_image_desc imageDesc; memset(&imageDesc, 0, sizeof(cl_image_desc)); @@ -982,15 +979,11 @@ cl_mem CL_API_CALL clCreateImage3D(cl_context context, imageDesc.image_slice_pitch = imageSlicePitch; imageDesc.image_type = CL_MEM_OBJECT_IMAGE3D; - Context *pContext = nullptr; - retVal = validateObjects(WithCastToInternal(context, &pContext)); + cl_mem_properties *properties = nullptr; + cl_mem_flags_intel intelFlags = 0; + cl_mem image3D = ImageFunctions::validateAndCreateImage(context, properties, flags, intelFlags, imageFormat, &imageDesc, hostPtr, retVal); - if (retVal == CL_SUCCESS) { - MemoryProperties memoryProperties = MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0); - image3D = Image::validateAndCreateImage(pContext, memoryProperties, flags, 0, imageFormat, &imageDesc, hostPtr, retVal); - } - - ErrorCodeHelper err(errcodeRet, retVal); + ErrorCodeHelper{errcodeRet, retVal}; DBG_LOG_INPUTS("image 3D", image3D); TRACING_EXIT(clCreateImage3D, &image3D); return image3D; diff --git a/opencl/source/api/api.h b/opencl/source/api/api.h index 9ba798f489..0d3a2b2561 100644 --- a/opencl/source/api/api.h +++ b/opencl/source/api/api.h @@ -147,7 +147,7 @@ cl_mem CL_API_CALL clCreateImage( cl_mem CL_API_CALL clCreateImageWithPropertiesINTEL( cl_context context, - cl_mem_properties_intel *properties, + const cl_mem_properties_intel *properties, const cl_image_format *imageFormat, const cl_image_desc *imageDesc, void *hostPtr, @@ -1069,3 +1069,22 @@ cl_int CL_API_CALL clSetProgramSpecializationConstant( cl_uint specId, size_t specSize, const void *specValue); + +// OpenCL 3.0 + +cl_mem CL_API_CALL clCreateBufferWithProperties( + cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + size_t size, + void *hostPtr, + cl_int *errcodeRet); + +cl_mem CL_API_CALL clCreateImageWithProperties( + cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + const cl_image_format *imageFormat, + const cl_image_desc *imageDesc, + void *hostPtr, + cl_int *errcodeRet); diff --git a/opencl/source/api/dispatch.cpp b/opencl/source/api/dispatch.cpp index 488913b795..c50fe111f3 100644 --- a/opencl/source/api/dispatch.cpp +++ b/opencl/source/api/dispatch.cpp @@ -182,7 +182,11 @@ SDispatchTable icdGlobalDispatchTable = /* OpenCL 2.2 */ clSetProgramReleaseCallback, - clSetProgramSpecializationConstant}; + clSetProgramSpecializationConstant, + + /* OpenCL 3.0 */ + clCreateBufferWithProperties, + clCreateImageWithProperties}; SCRTDispatchTable crtGlobalDispatchTable = { clGetKernelArgInfo, diff --git a/opencl/source/api/dispatch.h b/opencl/source/api/dispatch.h index 3991443a9a..a6b3941db0 100644 --- a/opencl/source/api/dispatch.h +++ b/opencl/source/api/dispatch.h @@ -988,6 +988,24 @@ typedef CL_API_ENTRY cl_int(CL_API_CALL *KHRpfn_clSetProgramSpecializationConsta size_t specSize, const void *specValue) CL_API_SUFFIX__VERSION_2_2; +/*OpenCL3.0*/ +typedef CL_API_ENTRY cl_mem(CL_API_CALL *KHRpfn_clCreateBufferWithProperties)( + cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + size_t size, + void *hostPtr, + cl_int *errcodeRet) CL_API_SUFFIX__VERSION_3_0; + +typedef CL_API_ENTRY cl_mem(CL_API_CALL *KHRpfn_clCreateImageWithProperties)( + cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + const cl_image_format *imageFormat, + const cl_image_desc *imageDesc, + void *hostPtr, + cl_int *errcodeRet) CL_API_SUFFIX__VERSION_3_0; + /* clCreateImage */ typedef CL_API_ENTRY cl_int(CL_API_CALL *INTELpfn_clGetImageParamsINTEL)( @@ -1255,6 +1273,10 @@ struct SDispatchTable { /* OpenCL 2.2 */ KHRpfn_clSetProgramReleaseCallback clSetProgramReleaseCallback; KHRpfn_clSetProgramSpecializationConstant clSetProgramSpecializationConstant; + + /* OpenCL 3.0 */ + KHRpfn_clCreateBufferWithProperties clCreateBufferWithProperties; + KHRpfn_clCreateImageWithProperties clCreateImageWithProperties; }; struct SCRTDispatchTable { diff --git a/opencl/source/dll/linux/ocl_internal.exports b/opencl/source/dll/linux/ocl_internal.exports index c9eb83424e..03033fb0ff 100644 --- a/opencl/source/dll/linux/ocl_internal.exports +++ b/opencl/source/dll/linux/ocl_internal.exports @@ -119,6 +119,8 @@ clSetDefaultDeviceCommandQueue; clSetProgramReleaseCallback; clSetProgramSpecializationConstant; + clCreateBufferWithProperties; + clCreateImageWithProperties; clGetKernelArgInfo; clGetImageParamsINTEL; clCreatePerfCountersCommandQueueINTEL; diff --git a/opencl/source/dll/windows/OpenCLInternalExports.def.in b/opencl/source/dll/windows/OpenCLInternalExports.def.in index 7c8b31e0f9..2cd1fabdd4 100644 --- a/opencl/source/dll/windows/OpenCLInternalExports.def.in +++ b/opencl/source/dll/windows/OpenCLInternalExports.def.in @@ -134,6 +134,8 @@ clGetKernelSubGroupInfo clSetDefaultDeviceCommandQueue clSetProgramReleaseCallback clSetProgramSpecializationConstant +clCreateBufferWithProperties +clCreateImageWithProperties clGetKernelArgInfo clGetImageParamsINTEL clCreatePerfCountersCommandQueueINTEL diff --git a/opencl/source/helpers/memory_properties_helpers.cpp b/opencl/source/helpers/memory_properties_helpers.cpp index c4e472b246..009bece961 100644 --- a/opencl/source/helpers/memory_properties_helpers.cpp +++ b/opencl/source/helpers/memory_properties_helpers.cpp @@ -16,23 +16,22 @@ void MemoryPropertiesHelper::addExtraMemoryProperties(MemoryProperties &properti bool MemoryPropertiesHelper::parseMemoryProperties(const cl_mem_properties_intel *properties, MemoryProperties &memoryProperties, cl_mem_flags &flags, cl_mem_flags_intel &flagsIntel, cl_mem_alloc_flags_intel &allocflags, ObjType objectType, Context &context) { - if (properties == nullptr) { - return true; - } - for (int i = 0; properties[i] != 0; i += 2) { - switch (properties[i]) { - case CL_MEM_FLAGS: - flags |= static_cast(properties[i + 1]); - break; - case CL_MEM_FLAGS_INTEL: - flagsIntel |= static_cast(properties[i + 1]); - break; - case CL_MEM_ALLOC_FLAGS_INTEL: - allocflags |= static_cast(properties[i + 1]); - break; - default: - return false; + if (properties != nullptr) { + for (int i = 0; properties[i] != 0; i += 2) { + switch (properties[i]) { + case CL_MEM_FLAGS: + flags |= static_cast(properties[i + 1]); + break; + case CL_MEM_FLAGS_INTEL: + flagsIntel |= static_cast(properties[i + 1]); + break; + case CL_MEM_ALLOC_FLAGS_INTEL: + allocflags |= static_cast(properties[i + 1]); + break; + default: + return false; + } } } diff --git a/opencl/source/mem_obj/buffer.cpp b/opencl/source/mem_obj/buffer.cpp index 276b7cff36..cdd783e693 100644 --- a/opencl/source/mem_obj/buffer.cpp +++ b/opencl/source/mem_obj/buffer.cpp @@ -13,6 +13,7 @@ #include "shared/source/gmm_helper/gmm.h" #include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/helpers/aligned_memory.h" +#include "shared/source/helpers/get_info.h" #include "shared/source/helpers/hw_helper.h" #include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/ptr_math.h" @@ -32,7 +33,11 @@ namespace NEO { -BufferFuncs bufferFactory[IGFX_MAX_CORE] = {}; +BufferFactoryFuncs bufferFactory[IGFX_MAX_CORE] = {}; + +namespace BufferFunctions { +ValidateInputAndCreateBufferFunc validateInputAndCreateBuffer = Buffer::validateInputAndCreateBuffer; +} // namespace BufferFunctions Buffer::Buffer(Context *context, MemoryProperties memoryProperties, @@ -85,38 +90,57 @@ bool Buffer::isValidSubBufferOffset(size_t offset) { return false; } -void Buffer::validateInputAndCreateBuffer(Context &context, - MemoryProperties memoryProperties, - cl_mem_flags flags, - cl_mem_flags_intel flagsIntel, - size_t size, - void *hostPtr, - cl_int &retVal, - cl_mem &buffer) { +cl_mem Buffer::validateInputAndCreateBuffer(cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + cl_mem_flags_intel flagsIntel, + size_t size, + void *hostPtr, + cl_int &retVal) { - if (!MemObjHelper::validateMemoryPropertiesForBuffer(memoryProperties, flags, flagsIntel, context)) { - retVal = CL_INVALID_VALUE; - return; + Context *pContext = nullptr; + retVal = validateObjects(WithCastToInternal(context, &pContext)); + if (retVal != CL_SUCCESS) { + return nullptr; } - auto pDevice = context.getDevice(0); + MemoryProperties memoryProperties{}; + if ((false == isFieldValid(flags, MemObjHelper::validFlagsForBuffer)) || + (false == MemObjHelper::validateMemoryPropertiesForBuffer(memoryProperties, flags, flagsIntel, *pContext))) { + retVal = CL_INVALID_VALUE; + return nullptr; + } + + cl_mem_alloc_flags_intel allocflags = 0; + if (false == MemoryPropertiesHelper::parseMemoryProperties(properties, memoryProperties, flags, flagsIntel, allocflags, + MemoryPropertiesHelper::ObjType::BUFFER, *pContext)) { + retVal = CL_INVALID_PROPERTY; + return nullptr; + } + + if (!MemObjHelper::validateMemoryPropertiesForBuffer(memoryProperties, flags, flagsIntel, *pContext)) { + retVal = CL_INVALID_PROPERTY; + return nullptr; + } + + auto pDevice = pContext->getDevice(0); bool allowCreateBuffersWithUnrestrictedSize = isValueSet(flags, CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL) || isValueSet(flagsIntel, CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL); if (size == 0 || (size > pDevice->getHardwareCapabilities().maxMemAllocSize && !allowCreateBuffersWithUnrestrictedSize)) { retVal = CL_INVALID_BUFFER_SIZE; - return; + return nullptr; } /* Check the host ptr and data */ bool expectHostPtr = (flags & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) != 0; if ((hostPtr == nullptr) == expectHostPtr) { retVal = CL_INVALID_HOST_PTR; - return; + return nullptr; } // create the buffer - buffer = create(&context, memoryProperties, flags, flagsIntel, size, hostPtr, retVal); + return create(pContext, memoryProperties, flags, flagsIntel, size, hostPtr, retVal); } Buffer *Buffer::create(Context *context, diff --git a/opencl/source/mem_obj/buffer.h b/opencl/source/mem_obj/buffer.h index a3f978676f..41655e2bee 100644 --- a/opencl/source/mem_obj/buffer.h +++ b/opencl/source/mem_obj/buffer.h @@ -16,29 +16,42 @@ #include "igfxfmid.h" #include "memory_properties_flags.h" +#include + namespace NEO { class Device; class Buffer; class ClDevice; class MemoryManager; -typedef Buffer *(*BufferCreatFunc)(Context *context, - MemoryProperties memoryProperties, - cl_mem_flags flags, - cl_mem_flags_intel flagsIntel, - size_t size, - void *memoryStorage, - void *hostPtr, - GraphicsAllocation *gfxAllocation, - bool zeroCopy, - bool isHostPtrSVM, - bool isImageRedescribed); +using BufferCreatFunc = Buffer *(*)(Context *context, + MemoryProperties memoryProperties, + cl_mem_flags flags, + cl_mem_flags_intel flagsIntel, + size_t size, + void *memoryStorage, + void *hostPtr, + GraphicsAllocation *gfxAllocation, + bool zeroCopy, + bool isHostPtrSVM, + bool isImageRedescribed); -typedef struct { +struct BufferFactoryFuncs { BufferCreatFunc createBufferFunction; -} BufferFuncs; +}; -extern BufferFuncs bufferFactory[IGFX_MAX_CORE]; +extern BufferFactoryFuncs bufferFactory[IGFX_MAX_CORE]; + +namespace BufferFunctions { +using ValidateInputAndCreateBufferFunc = std::function; +extern ValidateInputAndCreateBufferFunc validateInputAndCreateBuffer; +} // namespace BufferFunctions class Buffer : public MemObj { public: @@ -49,14 +62,13 @@ class Buffer : public MemObj { ~Buffer() override; - static void validateInputAndCreateBuffer(Context &context, - MemoryProperties memoryProperties, - cl_mem_flags flags, - cl_mem_flags_intel flagsIntel, - size_t size, - void *hostPtr, - cl_int &retVal, - cl_mem &buffer); + static cl_mem validateInputAndCreateBuffer(cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + cl_mem_flags_intel flagsIntel, + size_t size, + void *hostPtr, + cl_int &retVal); static Buffer *create(Context *context, cl_mem_flags flags, @@ -224,4 +236,5 @@ class BufferHw : public Buffer { typedef typename GfxFamily::RENDER_SURFACE_STATE SURFACE_STATE; typename SURFACE_STATE::SURFACE_TYPE surfaceType; }; + } // namespace NEO diff --git a/opencl/source/mem_obj/buffer_factory_init.inl b/opencl/source/mem_obj/buffer_factory_init.inl index 2abcdc1952..b5072d2f95 100644 --- a/opencl/source/mem_obj/buffer_factory_init.inl +++ b/opencl/source/mem_obj/buffer_factory_init.inl @@ -7,6 +7,6 @@ template <> void populateFactoryTable>() { - extern BufferFuncs bufferFactory[IGFX_MAX_CORE]; + extern BufferFactoryFuncs bufferFactory[IGFX_MAX_CORE]; bufferFactory[gfxCore].createBufferFunction = BufferHw::create; } diff --git a/opencl/source/mem_obj/image.cpp b/opencl/source/mem_obj/image.cpp index 67cf7c94fe..daeda6162c 100644 --- a/opencl/source/mem_obj/image.cpp +++ b/opencl/source/mem_obj/image.cpp @@ -39,7 +39,11 @@ namespace NEO { -ImageFuncs imageFactory[IGFX_MAX_CORE] = {}; +ImageFactoryFuncs imageFactory[IGFX_MAX_CORE] = {}; + +namespace ImageFunctions { +ValidateAndCreateImageFunc validateAndCreateImage = Image::validateAndCreateImage; +} // namespace ImageFunctions Image::Image(Context *context, const MemoryProperties &memoryProperties, @@ -1110,8 +1114,8 @@ bool Image::isDepthFormat(const cl_image_format &imageFormat) { return imageFormat.image_channel_order == CL_DEPTH || imageFormat.image_channel_order == CL_DEPTH_STENCIL; } -Image *Image::validateAndCreateImage(Context *context, - const MemoryProperties &memoryProperties, +cl_mem Image::validateAndCreateImage(cl_context context, + const cl_mem_properties *properties, cl_mem_flags flags, cl_mem_flags_intel flagsIntel, const cl_image_format *imageFormat, @@ -1119,11 +1123,31 @@ Image *Image::validateAndCreateImage(Context *context, const void *hostPtr, cl_int &errcodeRet) { - if (!MemObjHelper::validateMemoryPropertiesForImage(memoryProperties, flags, flagsIntel, imageDesc->mem_object, *context)) { + Context *pContext = nullptr; + errcodeRet = validateObjects(WithCastToInternal(context, &pContext)); + if (errcodeRet != CL_SUCCESS) { + return nullptr; + } + + cl_mem_alloc_flags_intel allocflags = 0; + MemoryProperties memoryProperties = MemoryPropertiesHelper::createMemoryProperties(flags, flagsIntel, allocflags); + if ((false == isFieldValid(flags, MemObjHelper::validFlagsForImage)) || + (false == MemObjHelper::validateMemoryPropertiesForImage(memoryProperties, flags, flagsIntel, imageDesc->mem_object, *pContext))) { errcodeRet = CL_INVALID_VALUE; return nullptr; } + if (false == MemoryPropertiesHelper::parseMemoryProperties(properties, memoryProperties, flags, flagsIntel, allocflags, + MemoryPropertiesHelper::ObjType::IMAGE, *pContext)) { + errcodeRet = CL_INVALID_PROPERTY; + return nullptr; + } + + if (!MemObjHelper::validateMemoryPropertiesForImage(memoryProperties, flags, flagsIntel, imageDesc->mem_object, *pContext)) { + errcodeRet = CL_INVALID_PROPERTY; + return nullptr; + } + bool isHostPtrUsed = (hostPtr != nullptr); bool areHostPtrFlagsUsed = memoryProperties.flags.copyHostPtr || memoryProperties.flags.useHostPtr; if (isHostPtrUsed != areHostPtrFlagsUsed) { @@ -1136,14 +1160,14 @@ Image *Image::validateAndCreateImage(Context *context, return nullptr; } - const auto surfaceFormat = Image::getSurfaceFormatFromTable(flags, imageFormat, context->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features); + const auto surfaceFormat = Image::getSurfaceFormatFromTable(flags, imageFormat, pContext->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features); - errcodeRet = Image::validate(context, memoryProperties, surfaceFormat, imageDesc, hostPtr); + errcodeRet = Image::validate(pContext, memoryProperties, surfaceFormat, imageDesc, hostPtr); if (errcodeRet != CL_SUCCESS) { return nullptr; } - return Image::create(context, memoryProperties, flags, flagsIntel, surfaceFormat, imageDesc, hostPtr, errcodeRet); + return Image::create(pContext, memoryProperties, flags, flagsIntel, surfaceFormat, imageDesc, hostPtr, errcodeRet); } bool Image::isValidSingleChannelFormat(const cl_image_format *imageFormat) { diff --git a/opencl/source/mem_obj/image.h b/opencl/source/mem_obj/image.h index 6ccfebf2c1..d2b32054a8 100644 --- a/opencl/source/mem_obj/image.h +++ b/opencl/source/mem_obj/image.h @@ -19,25 +19,37 @@ class Image; struct KernelInfo; struct SurfaceFormatInfo; -typedef Image *(*ImageCreatFunc)(Context *context, - const MemoryProperties &memoryProperties, - uint64_t flags, - uint64_t flagsIntel, - size_t size, - void *hostPtr, - const cl_image_format &imageFormat, - const cl_image_desc &imageDesc, - bool zeroCopy, - GraphicsAllocation *graphicsAllocation, - bool isImageRedescribed, - uint32_t baseMipLevel, - uint32_t mipCount, - const ClSurfaceFormatInfo *surfaceFormatInfo, - const SurfaceOffsets *surfaceOffsets); +using ImageCreatFunc = Image *(*)(Context *context, + const MemoryProperties &memoryProperties, + uint64_t flags, + uint64_t flagsIntel, + size_t size, + void *hostPtr, + const cl_image_format &imageFormat, + const cl_image_desc &imageDesc, + bool zeroCopy, + GraphicsAllocation *graphicsAllocation, + bool isImageRedescribed, + uint32_t baseMipLevel, + uint32_t mipCount, + const ClSurfaceFormatInfo *surfaceFormatInfo, + const SurfaceOffsets *surfaceOffsets); -typedef struct { +struct ImageFactoryFuncs { ImageCreatFunc createImageFunction; -} ImageFuncs; +}; + +namespace ImageFunctions { +using ValidateAndCreateImageFunc = std::function; +extern ValidateAndCreateImageFunc validateAndCreateImage; +} // namespace ImageFunctions class Image : public MemObj { public: @@ -55,8 +67,8 @@ class Image : public MemObj { const void *hostPtr, cl_int &errcodeRet); - static Image *validateAndCreateImage(Context *context, - const MemoryProperties &memoryProperties, + static cl_mem validateAndCreateImage(cl_context context, + const cl_mem_properties *properties, cl_mem_flags flags, cl_mem_flags_intel flagsIntel, const cl_image_format *imageFormat, @@ -352,4 +364,5 @@ class ImageHw : public Image { } typename RENDER_SURFACE_STATE::SURFACE_TYPE surfaceType; }; + } // namespace NEO diff --git a/opencl/source/mem_obj/image_factory_init.inl b/opencl/source/mem_obj/image_factory_init.inl index 5562a566a1..fbddb8e6ef 100644 --- a/opencl/source/mem_obj/image_factory_init.inl +++ b/opencl/source/mem_obj/image_factory_init.inl @@ -8,6 +8,6 @@ template class ImageHw; template <> void populateFactoryTable>() { - extern ImageFuncs imageFactory[IGFX_MAX_CORE]; + extern ImageFactoryFuncs imageFactory[IGFX_MAX_CORE]; imageFactory[gfxCore].createImageFunction = ImageHw::create; } diff --git a/opencl/test/unit_test/api/cl_create_buffer_tests.cpp b/opencl/test/unit_test/api/cl_create_buffer_tests.cpp index 4401e55753..7b04859daa 100644 --- a/opencl/test/unit_test/api/cl_create_buffer_tests.cpp +++ b/opencl/test/unit_test/api/cl_create_buffer_tests.cpp @@ -83,7 +83,7 @@ TEST_P(clCreateBufferInvalidFlagsTests, GivenInvalidFlagsWhenCreatingBufferThenB buffer = clCreateBufferWithPropertiesINTEL(pContext, properties, 64, nullptr, &retVal); EXPECT_EQ(nullptr, buffer); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(CL_INVALID_PROPERTY, retVal); }; cl_mem_flags invalidFlags[] = { @@ -132,7 +132,7 @@ TEST_P(clCreateBufferInvalidFlagsIntelTests, GivenInvalidFlagsIntelWhenCreatingB auto buffer = clCreateBufferWithPropertiesINTEL(pContext, properties, 64, nullptr, &retVal); EXPECT_EQ(nullptr, buffer); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(CL_INVALID_PROPERTY, retVal); }; cl_mem_flags invalidFlagsIntel[] = { @@ -151,7 +151,7 @@ TEST_F(clCreateBufferInvalidProperties, GivenInvalidPropertyKeyWhenCreatingBuffe auto buffer = clCreateBufferWithPropertiesINTEL(pContext, properties, 64, nullptr, &retVal); EXPECT_EQ(nullptr, buffer); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(CL_INVALID_PROPERTY, retVal); }; TEST_F(clCreateBufferTests, GivenValidParametersWhenCreatingBufferThenSuccessIsReturned) { @@ -289,6 +289,70 @@ TEST_F(clCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatin EXPECT_EQ(CL_SUCCESS, retVal); } +TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenParametersAreCorrectlyPassed) { + VariableBackup bufferCreateBackup{&BufferFunctions::validateInputAndCreateBuffer}; + + cl_context context = pContext; + cl_mem_properties *propertiesValues[] = {nullptr, reinterpret_cast(0x1234)}; + cl_mem_flags flagsValues[] = {0, 4321}; + size_t bufferSize = 128; + void *pHostMem = reinterpret_cast(0x8000); + + for (auto properties : propertiesValues) { + for (auto flags : flagsValues) { + auto mockFunction = [context, properties, flags, bufferSize, pHostMem](cl_context contextArg, + const cl_mem_properties *propertiesArg, + cl_mem_flags flagsArg, + cl_mem_flags_intel flagsIntelArg, + size_t sizeArg, + void *hostPtrArg, + cl_int &retValArg) -> cl_mem { + cl_mem_flags_intel expectedFlagsIntelArg = 0; + + EXPECT_EQ(context, contextArg); + EXPECT_EQ(properties, propertiesArg); + EXPECT_EQ(flags, flagsArg); + EXPECT_EQ(expectedFlagsIntelArg, flagsIntelArg); + EXPECT_EQ(bufferSize, sizeArg); + EXPECT_EQ(pHostMem, hostPtrArg); + + return nullptr; + }; + bufferCreateBackup = mockFunction; + clCreateBufferWithProperties(context, properties, flags, bufferSize, pHostMem, nullptr); + } + } +} + +TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenErrorCodeIsCorrectlySet) { + VariableBackup bufferCreateBackup{&BufferFunctions::validateInputAndCreateBuffer}; + + cl_mem_properties *properties = nullptr; + cl_mem_flags flags = 0; + size_t bufferSize = 128; + void *pHostMem = nullptr; + cl_int errcodeRet; + + cl_int retValues[] = {CL_SUCCESS, CL_INVALID_PROPERTY}; + + for (auto retValue : retValues) { + auto mockFunction = [retValue](cl_context contextArg, + const cl_mem_properties *propertiesArg, + cl_mem_flags flagsArg, + cl_mem_flags_intel flagsIntelArg, + size_t sizeArg, + void *hostPtrArg, + cl_int &retValArg) -> cl_mem { + retValArg = retValue; + + return nullptr; + }; + bufferCreateBackup = mockFunction; + clCreateBufferWithProperties(pContext, properties, flags, bufferSize, pHostMem, &errcodeRet); + EXPECT_EQ(retValue, errcodeRet); + } +} + using clCreateBufferTestsWithRestrictions = api_test_using_aligned_memory_manager; TEST_F(clCreateBufferTestsWithRestrictions, GivenMemoryManagerRestrictionsWhenMinIsLessThanHostPtrThenUseZeroCopy) { diff --git a/opencl/test/unit_test/api/cl_create_image_tests.cpp b/opencl/test/unit_test/api/cl_create_image_tests.cpp index 63e63928da..c7af0b8c9b 100644 --- a/opencl/test/unit_test/api/cl_create_image_tests.cpp +++ b/opencl/test/unit_test/api/cl_create_image_tests.cpp @@ -9,6 +9,7 @@ #include "shared/test/unit_test/mocks/mock_device.h" #include "opencl/source/context/context.h" +#include "opencl/source/mem_obj/image.h" #include "opencl/test/unit_test/helpers/unit_test_helper.h" #include "opencl/test/unit_test/mocks/mock_cl_device.h" #include "opencl/test/unit_test/test_macros/test_checks_ocl.h" @@ -396,6 +397,74 @@ TEST_F(clCreateImageTest, GivenNullContextWhenCreatingImageThenInvalidContextErr EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } +TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenParametersAreCorrectlyPassed) { + VariableBackup imageCreateBackup{&ImageFunctions::validateAndCreateImage}; + + cl_context context = pContext; + cl_mem_properties *propertiesValues[] = {nullptr, reinterpret_cast(0x1234)}; + cl_mem_flags flagsValues[] = {0, 4321}; + cl_image_format imageFormat = this->imageFormat; + cl_image_desc imageDesc = this->imageDesc; + void *pHostMem = reinterpret_cast(0x8000); + + for (auto properties : propertiesValues) { + for (auto flags : flagsValues) { + + auto mockFunction = [context, properties, flags, &imageFormat, &imageDesc, pHostMem](cl_context contextArg, + const cl_mem_properties *propertiesArg, + cl_mem_flags flagsArg, + cl_mem_flags_intel flagsIntelArg, + const cl_image_format *imageFormatArg, + const cl_image_desc *imageDescArg, + const void *hostPtrArg, + cl_int &errcodeRetArg) -> cl_mem { + cl_mem_flags_intel expectedFlagsIntelArg = 0; + + EXPECT_EQ(context, contextArg); + EXPECT_EQ(properties, propertiesArg); + EXPECT_EQ(flags, flagsArg); + EXPECT_EQ(expectedFlagsIntelArg, flagsIntelArg); + EXPECT_EQ(&imageFormat, imageFormatArg); + EXPECT_EQ(&imageDesc, imageDescArg); + EXPECT_EQ(pHostMem, hostPtrArg); + + return nullptr; + }; + imageCreateBackup = mockFunction; + clCreateImageWithProperties(context, properties, flags, &imageFormat, &imageDesc, pHostMem, nullptr); + } + } +} + +TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectlySet) { + VariableBackup imageCreateBackup{&ImageFunctions::validateAndCreateImage}; + + cl_mem_properties *properties = nullptr; + cl_mem_flags flags = 0; + void *pHostMem = nullptr; + cl_int errcodeRet; + + cl_int retValues[] = {CL_SUCCESS, CL_INVALID_PROPERTY}; + + for (auto retValue : retValues) { + auto mockFunction = [retValue](cl_context contextArg, + const cl_mem_properties *propertiesArg, + cl_mem_flags flagsArg, + cl_mem_flags_intel flagsIntelArg, + const cl_image_format *imageFormatArg, + const cl_image_desc *imageDescArg, + const void *hostPtrArg, + cl_int &errcodeRetArg) -> cl_mem { + errcodeRetArg = retValue; + + return nullptr; + }; + imageCreateBackup = mockFunction; + clCreateImageWithProperties(pContext, properties, flags, &imageFormat, &imageDesc, pHostMem, &errcodeRet); + EXPECT_EQ(retValue, errcodeRet); + } +} + typedef clCreateImageTests<::testing::Test> clCreateImageTestYUV; TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValueErrorIsReturned) { imageFormat.image_channel_order = CL_YUYV_INTEL; @@ -513,6 +582,19 @@ TEST_P(clCreateImageInvalidFlags, GivenInvalidFlagsCombinationsWhenCreatingImage ASSERT_EQ(CL_INVALID_VALUE, retVal); EXPECT_EQ(nullptr, image); + cl_mem_properties_intel properties[] = {CL_MEM_FLAGS, flags, 0}; + + image = clCreateImageWithPropertiesINTEL( + pContext, + properties, + &imageFormat, + &imageDesc, + ptr, + &retVal); + + ASSERT_EQ(CL_INVALID_PROPERTY, retVal); + EXPECT_EQ(nullptr, image); + retVal = clReleaseMemObject(image); EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } @@ -869,7 +951,7 @@ TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidPropertyKeyWhenCreating &retVal); EXPECT_EQ(nullptr, image); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(CL_INVALID_PROPERTY, retVal); } typedef clCreateImageTests<::testing::Test> clCreateImageFromImageTest; diff --git a/opencl/test/unit_test/command_queue/multiple_map_image_tests.cpp b/opencl/test/unit_test/command_queue/multiple_map_image_tests.cpp index 34b44f1226..e20e5dc27b 100644 --- a/opencl/test/unit_test/command_queue/multiple_map_image_tests.cpp +++ b/opencl/test/unit_test/command_queue/multiple_map_image_tests.cpp @@ -16,7 +16,7 @@ #include "test.h" namespace NEO { -extern ImageFuncs imageFactory[IGFX_MAX_CORE]; +extern ImageFactoryFuncs imageFactory[IGFX_MAX_CORE]; struct MultipleMapImageTest : public DeviceFixture, public ::testing::Test { template diff --git a/opencl/test/unit_test/mem_obj/buffer_tests.cpp b/opencl/test/unit_test/mem_obj/buffer_tests.cpp index 5f583fe438..52403df576 100644 --- a/opencl/test/unit_test/mem_obj/buffer_tests.cpp +++ b/opencl/test/unit_test/mem_obj/buffer_tests.cpp @@ -1989,7 +1989,7 @@ TEST_P(NoHostPtr, ValidFlags) { } TEST_P(NoHostPtr, GivenNoHostPtrWhenHwBufferCreationFailsThenReturnNullptr) { - BufferFuncs BufferFuncsBackup[IGFX_MAX_CORE]; + BufferFactoryFuncs BufferFuncsBackup[IGFX_MAX_CORE]; for (uint32_t i = 0; i < IGFX_MAX_CORE; i++) { BufferFuncsBackup[i] = bufferFactory[i]; diff --git a/opencl/test/unit_test/mem_obj/image_validate_tests.cpp b/opencl/test/unit_test/mem_obj/image_validate_tests.cpp index b8ede36f42..6573dfa464 100644 --- a/opencl/test/unit_test/mem_obj/image_validate_tests.cpp +++ b/opencl/test/unit_test/mem_obj/image_validate_tests.cpp @@ -669,10 +669,10 @@ TEST(validateAndCreateImage, givenInvalidImageFormatWhenValidateAndCreateImageIs MockContext context; cl_image_format imageFormat; cl_int retVal = CL_SUCCESS; - Image *image; + cl_mem image; imageFormat.image_channel_order = 0; imageFormat.image_channel_data_type = 0; - image = Image::validateAndCreateImage(&context, {}, 0, 0, &imageFormat, &Image1dDefaults::imageDesc, nullptr, retVal); + image = Image::validateAndCreateImage(&context, nullptr, 0, 0, &imageFormat, &Image1dDefaults::imageDesc, nullptr, retVal); EXPECT_EQ(nullptr, image); EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal); } @@ -681,9 +681,9 @@ TEST(validateAndCreateImage, givenNotSupportedImageFormatWhenValidateAndCreateIm MockContext context; cl_image_format imageFormat = {CL_INTENSITY, CL_UNORM_INT8}; cl_int retVal = CL_SUCCESS; - Image *image; + cl_mem image; cl_mem_flags flags = CL_MEM_READ_WRITE; - image = Image::validateAndCreateImage(&context, MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0), flags, 0, &imageFormat, &Image1dDefaults::imageDesc, nullptr, retVal); + image = Image::validateAndCreateImage(&context, nullptr, flags, 0, &imageFormat, &Image1dDefaults::imageDesc, nullptr, retVal); EXPECT_EQ(nullptr, image); EXPECT_EQ(CL_IMAGE_FORMAT_NOT_SUPPORTED, retVal); } @@ -709,15 +709,15 @@ TEST(validateAndCreateImage, givenValidImageParamsWhenValidateAndCreateImageIsCa cl_int retVal = CL_SUCCESS; std::unique_ptr image = nullptr; - image.reset(Image::validateAndCreateImage( + image.reset(static_cast(Image::validateAndCreateImage( &context, - MemoryPropertiesHelper::createMemoryProperties(flags, 0, 0), + nullptr, flags, 0, &imageFormat, &imageDesc, nullptr, - retVal)); + retVal))); EXPECT_NE(nullptr, image); EXPECT_EQ(CL_SUCCESS, retVal); }