From ef170607c8b34a22b1884e28a28ba5b00c5ad8bb Mon Sep 17 00:00:00 2001 From: Maciej Dziuban Date: Tue, 24 Nov 2020 13:29:07 +0000 Subject: [PATCH] OpenCL Queue Families extension 3/n Check queue capabilities in enqueue calls for buffers Signed-off-by: Maciej Dziuban Related-To: NEO-5120 --- opencl/source/api/api.cpp | 55 ++++++++++++++++ opencl/source/command_queue/command_queue.cpp | 12 ++++ opencl/source/command_queue/command_queue.h | 4 ++ opencl/test/unit_test/api/cl_api_tests.h | 11 +++- .../api/cl_enqueue_copy_buffer_rect_tests.inl | 27 ++++++++ .../api/cl_enqueue_fill_buffer_tests.inl | 36 ++++++++++ .../api/cl_enqueue_map_buffer_tests.inl | 20 ++++++ .../api/cl_enqueue_read_buffer_rect_tests.inl | 29 ++++++++ .../api/cl_enqueue_read_buffer_tests.inl | 37 +++++++++++ .../api/cl_enqueue_unmap_mem_object_tests.inl | 18 +++++ .../cl_enqueue_write_buffer_rect_tests.inl | 56 ++++++++++++++++ .../api/cl_enqueue_write_buffer_tests.inl | 37 +++++++++++ .../command_queue/command_queue_tests.cpp | 36 ++++++++++ .../enqueue_copy_buffer_tests.cpp | 66 ++++++++++++++++--- .../test/unit_test/mocks/mock_command_queue.h | 1 + 15 files changed, 436 insertions(+), 9 deletions(-) diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp index 31e0decd6f..53144257c8 100644 --- a/opencl/source/api/api.cpp +++ b/opencl/source/api/api.cpp @@ -2253,6 +2253,12 @@ cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue commandQueue, return retVal; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueReadBuffer, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueReadBuffer( pBuffer, blockingRead, @@ -2338,6 +2344,12 @@ cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue commandQueue, return retVal; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueReadBufferRect, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueReadBufferRect( pBuffer, blockingRead, @@ -2391,6 +2403,12 @@ cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue commandQueue, return retVal; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueWriteBuffer, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueWriteBuffer( pBuffer, blockingWrite, @@ -2466,6 +2484,12 @@ cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue commandQueue, return retVal; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueWriteBufferRect, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueWriteBufferRect( pBuffer, blockingWrite, @@ -2516,6 +2540,12 @@ cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue commandQueue, EventWaitList(numEventsInWaitList, eventWaitList)); if (CL_SUCCESS == retVal) { + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_FILL_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueFillBuffer, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueFillBuffer( pBuffer, pattern, @@ -2567,6 +2597,12 @@ cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue commandQueue, return retVal; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueCopyBuffer, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueCopyBuffer( pSrcBuffer, pDstBuffer, @@ -2619,6 +2655,12 @@ cl_int CL_API_CALL clEnqueueCopyBufferRect(cl_command_queue commandQueue, WithCastToInternal(dstBuffer, &pDstBuffer)); if (CL_SUCCESS == retVal) { + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueCopyBufferRect, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueCopyBufferRect( pSrcBuffer, pDstBuffer, @@ -3061,6 +3103,11 @@ void *CL_API_CALL clEnqueueMapBuffer(cl_command_queue commandQueue, break; } + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + break; + } + retPtr = pCommandQueue->enqueueMapBuffer( pBuffer, blockingMap, @@ -3192,6 +3239,14 @@ cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue commandQueue, return retVal; } + if (pMemObj->peekClMemObjType() == CL_MEM_OBJECT_BUFFER) { + if (!pCommandQueue->validateCapabilityForOperation(CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL, eventWaitList, event)) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueUnmapMemObject, &retVal); + return retVal; + } + } + retVal = pCommandQueue->enqueueUnmapMemObject(pMemObj, mappedPtr, numEventsInWaitList, eventWaitList, event); } diff --git a/opencl/source/command_queue/command_queue.cpp b/opencl/source/command_queue/command_queue.cpp index a30e30b157..f3cce2dae9 100644 --- a/opencl/source/command_queue/command_queue.cpp +++ b/opencl/source/command_queue/command_queue.cpp @@ -538,6 +538,17 @@ bool CommandQueue::setupDebugSurface(Kernel *kernel) { return true; } +bool CommandQueue::validateCapability(cl_command_queue_capabilities_intel capability) const { + return this->queueCapabilities == CL_QUEUE_CAPABILITY_ALL_INTEL || isValueSet(this->queueCapabilities, capability); +} + +bool CommandQueue::validateCapabilityForOperation(cl_command_queue_capabilities_intel capability, const cl_event *waitList, const cl_event *outEvent) const { + const bool operationValid = validateCapability(capability); + const bool waitListValid = waitList == nullptr || validateCapability(CL_QUEUE_CAPABILITY_EVENT_WAIT_LIST_INTEL); + const bool outEventValid = outEvent == nullptr || validateCapability(CL_QUEUE_CAPABILITY_EVENTS_INTEL); + return operationValid && waitListValid && outEventValid; +} + IndirectHeap &CommandQueue::getIndirectHeap(IndirectHeap::Type heapType, size_t minRequiredSize) { return getGpgpuCommandStreamReceiver().getIndirectHeap(heapType, minRequiredSize); } @@ -730,6 +741,7 @@ void CommandQueue::processProperties(const cl_queue_properties *properties) { auto engine = queueFamily->at(selectedQueueIndex); auto engineType = engine.getEngineType(); this->overrideEngine(engineType); + this->queueCapabilities = getClDevice().getDeviceInfo().queueFamilyProperties[selectedQueueFamilyIndex].capabilities; } } } diff --git a/opencl/source/command_queue/command_queue.h b/opencl/source/command_queue/command_queue.h index 72f43c8086..b6b44a32b3 100644 --- a/opencl/source/command_queue/command_queue.h +++ b/opencl/source/command_queue/command_queue.h @@ -300,6 +300,9 @@ class CommandQueue : public BaseObject<_cl_command_queue> { MOCKABLE_VIRTUAL bool setupDebugSurface(Kernel *kernel); + bool validateCapability(cl_command_queue_capabilities_intel capability) const; + bool validateCapabilityForOperation(cl_command_queue_capabilities_intel capability, const cl_event *waitList, const cl_event *outEvent) const; + bool getRequiresCacheFlushAfterWalker() const { return requiresCacheFlushAfterWalker; } @@ -357,6 +360,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> { cl_command_queue_properties commandQueueProperties = 0; std::vector propertiesVector; + cl_command_queue_capabilities_intel queueCapabilities = CL_QUEUE_CAPABILITY_ALL_INTEL; QueuePriority priority = QueuePriority::MEDIUM; QueueThrottle throttle = QueueThrottle::MEDIUM; diff --git a/opencl/test/unit_test/api/cl_api_tests.h b/opencl/test/unit_test/api/cl_api_tests.h index 066ab1eea8..6bb545699c 100644 --- a/opencl/test/unit_test/api/cl_api_tests.h +++ b/opencl/test/unit_test/api/cl_api_tests.h @@ -63,11 +63,20 @@ struct ApiFixture { } pDevice->decRefInternal(); } + + void disableQueueCapabilities(cl_command_queue_capabilities_intel capabilities) { + if (pCommandQueue->queueCapabilities == CL_QUEUE_CAPABILITY_ALL_INTEL) { + pCommandQueue->queueCapabilities = pDevice->getQueueFamilyCapabilitiesAll(); + } + + pCommandQueue->queueCapabilities &= ~capabilities; + } + DebugManagerStateRestore restorer; cl_int retVal = CL_SUCCESS; size_t retSize = 0; - CommandQueue *pCommandQueue = nullptr; + MockCommandQueue *pCommandQueue = nullptr; Context *pContext = nullptr; MockKernel *pKernel = nullptr; MockProgram *pProgram = nullptr; diff --git a/opencl/test/unit_test/api/cl_enqueue_copy_buffer_rect_tests.inl b/opencl/test/unit_test/api/cl_enqueue_copy_buffer_rect_tests.inl index 99b3f10e0e..aab74d495f 100644 --- a/opencl/test/unit_test/api/cl_enqueue_copy_buffer_rect_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_copy_buffer_rect_tests.inl @@ -68,4 +68,31 @@ TEST_F(clEnqueueCopyBufferRectTests, GivenNullCommandQueueWhenEnqueingCopyBuffer EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal); } + +TEST_F(clEnqueueCopyBufferRectTests, GivenQueueIncapableWhenEnqueingCopyBufferRectThenInvalidOperationIsReturned) { + MockBuffer srcBuffer; + MockBuffer dstBuffer; + size_t srcOrigin[] = {0, 0, 0}; + size_t dstOrigin[] = {0, 0, 0}; + size_t region[] = {10, 10, 0}; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL); + auto retVal = clEnqueueCopyBufferRect( + pCommandQueue, + &srcBuffer, //srcBuffer + &dstBuffer, //dstBuffer + srcOrigin, + dstOrigin, + region, + 10, //srcRowPitch + 0, //srcSlicePitch + 10, //dstRowPitch + 0, //dstSlicePitch + 0, //numEventsInWaitList + nullptr, + nullptr); + + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_fill_buffer_tests.inl b/opencl/test/unit_test/api/cl_enqueue_fill_buffer_tests.inl index d6a530dd91..0c0ada1a3c 100644 --- a/opencl/test/unit_test/api/cl_enqueue_fill_buffer_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_fill_buffer_tests.inl @@ -51,4 +51,40 @@ TEST_F(clEnqueueFillBufferTests, GivenNullBufferWhenFillingBufferThenInvalidMemO EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } + +TEST_F(clEnqueueFillBufferTests, GivenValidArgumentsWhenFillingBufferThenSuccessIsReturned) { + MockBuffer buffer{}; + cl_float pattern = 1.0f; + + retVal = clEnqueueFillBuffer( + pCommandQueue, + &buffer, + &pattern, + sizeof(pattern), + 0, + sizeof(pattern), + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clEnqueueFillBufferTests, GivenQueueIncapableWhenFillingBufferThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + cl_float pattern = 1.0f; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_FILL_BUFFER_INTEL); + retVal = clEnqueueFillBuffer( + pCommandQueue, + &buffer, + &pattern, + sizeof(pattern), + 0, + sizeof(pattern), + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_map_buffer_tests.inl b/opencl/test/unit_test/api/cl_enqueue_map_buffer_tests.inl index 814431c6c8..234e520df0 100644 --- a/opencl/test/unit_test/api/cl_enqueue_map_buffer_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_map_buffer_tests.inl @@ -7,6 +7,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_buffer.h" #include "cl_api_tests.h" @@ -90,6 +91,25 @@ TEST_F(clEnqueueMapBufferTests, GivenValidParametersWhenMappingBufferThenSuccess clReleaseEvent(eventReturned); } +TEST_F(clEnqueueMapBufferTests, GivenQueueIncapableWhenMappingBufferThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + + disableQueueCapabilities(CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL); + auto ptrResult = clEnqueueMapBuffer( + pCommandQueue, + &buffer, + CL_TRUE, + CL_MAP_READ, + 0, + 8, + 0, + nullptr, + nullptr, + &retVal); + EXPECT_EQ(nullptr, ptrResult); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + TEST_F(clEnqueueMapBufferTests, GivenMappedPointerWhenCreatingBufferFromThisPointerThenInvalidHostPtrErrorIsReturned) { unsigned int bufferSize = 16; diff --git a/opencl/test/unit_test/api/cl_enqueue_read_buffer_rect_tests.inl b/opencl/test/unit_test/api/cl_enqueue_read_buffer_rect_tests.inl index 6ad919a63b..337869fe82 100644 --- a/opencl/test/unit_test/api/cl_enqueue_read_buffer_rect_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_read_buffer_rect_tests.inl @@ -9,6 +9,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_buffer.h" #include "cl_api_tests.h" @@ -141,6 +142,34 @@ TEST_F(clEnqueueReadBufferRectTest, GivenValidParametersWhenReadingRectangularRe clReleaseMemObject(buffer); } +TEST_F(clEnqueueReadBufferRectTest, GivenQueueIncapableWhenReadingRectangularRegionThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + char ptr[10]; + + size_t buffOrigin[] = {0, 0, 0}; + size_t hostOrigin[] = {0, 0, 0}; + size_t region[] = {10, 10, 0}; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL); + auto retVal = clEnqueueReadBufferRect( + pCommandQueue, + &buffer, + CL_FALSE, + buffOrigin, + hostOrigin, + region, + 10, //bufferRowPitch + 0, //bufferSlicePitch + 10, //hostRowPitch + 0, //hostSlicePitch + ptr, //hostPtr + 0, //numEventsInWaitList + nullptr, + nullptr); + + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + TEST_F(clEnqueueReadBufferRectTest, GivenInvalidPitchWhenReadingRectangularRegionThenInvalidValueErrorIsReturned) { auto buffer = clCreateBuffer( pContext, diff --git a/opencl/test/unit_test/api/cl_enqueue_read_buffer_tests.inl b/opencl/test/unit_test/api/cl_enqueue_read_buffer_tests.inl index 8541ed159d..7275b431ab 100644 --- a/opencl/test/unit_test/api/cl_enqueue_read_buffer_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_read_buffer_tests.inl @@ -10,6 +10,7 @@ #include "opencl/source/cl_device/cl_device_info.h" #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_buffer.h" #include "cl_api_tests.h" @@ -19,6 +20,42 @@ typedef api_tests clEnqueueReadBufferTests; namespace ULT { +TEST_F(clEnqueueReadBufferTests, GivenCorrectArgumentsWhenReadingBufferThenSuccessIsReturned) { + MockBuffer buffer{}; + auto data = 1; + auto retVal = clEnqueueReadBuffer( + pCommandQueue, + &buffer, + false, + 0, + sizeof(data), + &data, + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clEnqueueReadBufferTests, GivenQueueIncapableArgumentsWhenReadingBufferThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + auto data = 1; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL); + auto retVal = clEnqueueReadBuffer( + pCommandQueue, + &buffer, + false, + 0, + sizeof(data), + &data, + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + TEST_F(clEnqueueReadBufferTests, GivenNullCommandQueueWhenReadingBufferThenInvalidCommandQueueErrorIsReturned) { auto data = 1; auto retVal = clEnqueueReadBuffer( diff --git a/opencl/test/unit_test/api/cl_enqueue_unmap_mem_object_tests.inl b/opencl/test/unit_test/api/cl_enqueue_unmap_mem_object_tests.inl index 319793340d..2e3eebf09b 100644 --- a/opencl/test/unit_test/api/cl_enqueue_unmap_mem_object_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_unmap_mem_object_tests.inl @@ -32,6 +32,24 @@ TEST_F(clEnqueueUnmapMemObjTests, givenValidAddressWhenUnmappingThenReturnSucces EXPECT_EQ(CL_SUCCESS, retVal); } +TEST_F(clEnqueueUnmapMemObjTests, GivenQueueIncapableWhenUnmappingBufferThenInvalidOperationIsReturned) { + auto buffer = std::unique_ptr(BufferHelper>::create(pContext)); + cl_int retVal = CL_SUCCESS; + + auto mappedPtr = clEnqueueMapBuffer(pCommandQueue, buffer.get(), CL_TRUE, CL_MAP_READ, 0, 1, 0, nullptr, nullptr, &retVal); + EXPECT_EQ(CL_SUCCESS, retVal); + + disableQueueCapabilities(CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL); + retVal = clEnqueueUnmapMemObject( + pCommandQueue, + buffer.get(), + mappedPtr, + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + TEST_F(clEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnCpuThenReturnError) { auto buffer = std::unique_ptr(BufferHelper>::create(pContext)); EXPECT_TRUE(buffer->mappingOnCpuAllowed()); diff --git a/opencl/test/unit_test/api/cl_enqueue_write_buffer_rect_tests.inl b/opencl/test/unit_test/api/cl_enqueue_write_buffer_rect_tests.inl index 8e43626340..5a369ff8c3 100644 --- a/opencl/test/unit_test/api/cl_enqueue_write_buffer_rect_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_write_buffer_rect_tests.inl @@ -104,4 +104,60 @@ TEST_F(clEnqueueWriteBufferRectTests, GivenNullHostPtrWhenWritingRectangularRegi retVal = clReleaseMemObject(buffer); EXPECT_EQ(CL_SUCCESS, retVal); } + +TEST_F(clEnqueueWriteBufferRectTests, GivenCorrectParametersWhenWritingRectangularRegionThenSuccessIsReturned) { + MockBuffer buffer{}; + char ptr[10]; + + size_t buffOrigin[] = {0, 0, 0}; + size_t hostOrigin[] = {0, 0, 0}; + size_t region[] = {10, 10, 0}; + + auto retVal = clEnqueueWriteBufferRect( + pCommandQueue, + &buffer, + CL_FALSE, + buffOrigin, + hostOrigin, + region, + 10, //bufferRowPitch + 0, //bufferSlicePitch + 10, //hostRowPitch + 0, //hostSlicePitch + ptr, //hostPtr + 0, //numEventsInWaitList + nullptr, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clEnqueueWriteBufferRectTests, GivenQueueIncapableWhenWritingRectangularRegionThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + char ptr[10]; + + size_t buffOrigin[] = {0, 0, 0}; + size_t hostOrigin[] = {0, 0, 0}; + size_t region[] = {10, 10, 0}; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL); + auto retVal = clEnqueueWriteBufferRect( + pCommandQueue, + &buffer, + CL_FALSE, + buffOrigin, + hostOrigin, + region, + 10, //bufferRowPitch + 0, //bufferSlicePitch + 10, //hostRowPitch + 0, //hostSlicePitch + ptr, //hostPtr + 0, //numEventsInWaitList + nullptr, + nullptr); + + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_write_buffer_tests.inl b/opencl/test/unit_test/api/cl_enqueue_write_buffer_tests.inl index 03ede0706d..3d370e1e80 100644 --- a/opencl/test/unit_test/api/cl_enqueue_write_buffer_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_write_buffer_tests.inl @@ -8,6 +8,7 @@ #include "shared/source/helpers/ptr_math.h" #include "opencl/source/command_queue/command_queue.h" +#include "opencl/test/unit_test/mocks/mock_buffer.h" #include "cl_api_tests.h" @@ -17,6 +18,42 @@ typedef api_tests clEnqueueWriteBufferTests; namespace ULT { +TEST_F(clEnqueueWriteBufferTests, GivenCorrectArgumentsWhenWritingBufferThenSuccessIsReturned) { + MockBuffer buffer{}; + auto data = 1; + auto retVal = clEnqueueWriteBuffer( + pCommandQueue, + &buffer, + false, + 0, + sizeof(data), + &data, + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clEnqueueWriteBufferTests, GivenQueueIncapableArgumentsWhenWritingBufferThenInvalidOperationIsReturned) { + MockBuffer buffer{}; + auto data = 1; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL); + auto retVal = clEnqueueWriteBuffer( + pCommandQueue, + &buffer, + false, + 0, + sizeof(data), + &data, + 0, + nullptr, + nullptr); + + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + TEST_F(clEnqueueWriteBufferTests, GivenNullCommandQueueWhenWritingBufferThenInvalidCommandQueueErrorIsReturned) { auto buffer = (cl_mem)ptrGarbage; diff --git a/opencl/test/unit_test/command_queue/command_queue_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_tests.cpp index d02c49191a..602019c0f5 100644 --- a/opencl/test/unit_test/command_queue/command_queue_tests.cpp +++ b/opencl/test/unit_test/command_queue/command_queue_tests.cpp @@ -1217,6 +1217,42 @@ TEST(CommandQueue, givenCopySizeAndOffsetWhenCallingBlitEnqueueImageAllowedThenR } } +TEST(CommandQueue, givenSupportForOperationWhenValidatingSupportThenReturnSuccess) { + MockCommandQueue queue{}; + + queue.queueCapabilities = CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL; + EXPECT_FALSE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); + + queue.queueCapabilities |= CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL; + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); +} + +TEST(CommandQueue, givenSupportForWaitListAndWaitListPassedWhenValidatingSupportThenReturnSuccess) { + MockCommandQueue queue{}; + cl_event waitList[1] = {}; + + queue.queueCapabilities = CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL; + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); + EXPECT_FALSE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, waitList, nullptr)); + + queue.queueCapabilities |= CL_QUEUE_CAPABILITY_EVENT_WAIT_LIST_INTEL; + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, waitList, nullptr)); +} + +TEST(CommandQueue, givenSupportForOutEventAndOutEventIsPassedWhenValidatingSupportThenReturnSuccess) { + MockCommandQueue queue{}; + cl_event outEvent{}; + + queue.queueCapabilities = CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL; + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); + EXPECT_FALSE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, &outEvent)); + + queue.queueCapabilities |= CL_QUEUE_CAPABILITY_EVENTS_INTEL; + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, nullptr)); + EXPECT_TRUE(queue.validateCapabilityForOperation(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL, nullptr, &outEvent)); +} + using KernelExecutionTypesTests = DispatchFlagsTests; HWTEST_F(KernelExecutionTypesTests, givenConcurrentKernelWhileDoingNonBlockedEnqueueThenCorrectKernelTypeIsSetInCSR) { using CsrType = MockCsrHw2; diff --git a/opencl/test/unit_test/command_queue/enqueue_copy_buffer_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_copy_buffer_tests.cpp index 8f5ca1133c..eb3389f9ac 100644 --- a/opencl/test/unit_test/command_queue/enqueue_copy_buffer_tests.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_copy_buffer_tests.cpp @@ -12,6 +12,7 @@ #include "opencl/source/command_queue/command_queue_hw.h" #include "opencl/source/helpers/dispatch_info.h" #include "opencl/source/kernel/kernel.h" +#include "opencl/test/unit_test/api/cl_api_tests.h" #include "opencl/test/unit_test/command_queue/enqueue_copy_buffer_fixture.h" #include "opencl/test/unit_test/command_queue/enqueue_fixture.h" #include "opencl/test/unit_test/gen_common/gen_commands_common_validation.h" @@ -26,13 +27,15 @@ using namespace NEO; -HWTEST_F(EnqueueCopyBufferTest, GivenNullSrcMemObjWhenCopyingBufferThenClInvalidMemObjectErrorIsReturned) { - auto dstBuffer = std::unique_ptr(BufferHelper<>::create()); +using clEnqueueCopyBufferTests = api_tests; + +HWTEST_F(clEnqueueCopyBufferTests, GivenNullSrcMemObjWhenCopyingBufferThenClInvalidMemObjectErrorIsReturned) { + MockBuffer dstBuffer{}; auto retVal = clEnqueueCopyBuffer( - pCmdQ, + pCommandQueue, nullptr, - dstBuffer.get(), + &dstBuffer, 0, 0, sizeof(float), @@ -42,12 +45,12 @@ HWTEST_F(EnqueueCopyBufferTest, GivenNullSrcMemObjWhenCopyingBufferThenClInvalid EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } -HWTEST_F(EnqueueCopyBufferTest, GivenNullDstMemObjWhenCopyingBufferThenClInvalidMemObjectErrorIsReturned) { - auto srcBuffer = std::unique_ptr(BufferHelper<>::create()); +HWTEST_F(clEnqueueCopyBufferTests, GivenNullDstMemObjWhenCopyingBufferThenClInvalidMemObjectErrorIsReturned) { + MockBuffer srcBuffer{}; auto retVal = clEnqueueCopyBuffer( - pCmdQ, - srcBuffer.get(), + pCommandQueue, + &srcBuffer, nullptr, 0, 0, @@ -58,6 +61,41 @@ HWTEST_F(EnqueueCopyBufferTest, GivenNullDstMemObjWhenCopyingBufferThenClInvalid EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } +HWTEST_F(clEnqueueCopyBufferTests, GivenCorrectArgumentsWhenCopyingBufferThenSuccessIsReturned) { + MockBuffer srcBuffer{}; + MockBuffer dstBuffer{}; + + retVal = clEnqueueCopyBuffer( + pCommandQueue, + &srcBuffer, + &dstBuffer, + 0, + 0, + 128, + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clEnqueueCopyBufferTests, GivenQueueIncapableWhenCopyingBufferThenInvalidOperationIsReturned) { + MockBuffer srcBuffer{}; + MockBuffer dstBuffer{}; + + this->disableQueueCapabilities(CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL); + retVal = clEnqueueCopyBuffer( + pCommandQueue, + &srcBuffer, + &dstBuffer, + 0, + 0, + 128, + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + HWTEST_F(EnqueueCopyBufferTest, GivenInvalidMemoryLocationWhenCopyingBufferThenClInvalidValueErrorIsReturned) { auto retVal = clEnqueueCopyBuffer( pCmdQ, @@ -70,6 +108,18 @@ HWTEST_F(EnqueueCopyBufferTest, GivenInvalidMemoryLocationWhenCopyingBufferThenC nullptr, nullptr); EXPECT_EQ(CL_INVALID_VALUE, retVal); + + retVal = clEnqueueCopyBuffer( + pCmdQ, + srcBuffer, + dstBuffer, + 8, + 0, + 128, + 0, + nullptr, + nullptr); + EXPECT_EQ(CL_INVALID_VALUE, retVal); } HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenTaskCountIsAlignedWithCsr) { diff --git a/opencl/test/unit_test/mocks/mock_command_queue.h b/opencl/test/unit_test/mocks/mock_command_queue.h index 988a3cbe88..b12d27d98c 100644 --- a/opencl/test/unit_test/mocks/mock_command_queue.h +++ b/opencl/test/unit_test/mocks/mock_command_queue.h @@ -25,6 +25,7 @@ class MockCommandQueue : public CommandQueue { using CommandQueue::gpgpuEngine; using CommandQueue::isCopyOnly; using CommandQueue::obtainNewTimestampPacketNodes; + using CommandQueue::queueCapabilities; using CommandQueue::requiresCacheFlushAfterWalker; using CommandQueue::throttle; using CommandQueue::timestampPacketContainer;