From 2c1551d40d97f2f335fb326b1a3fbe639873b832 Mon Sep 17 00:00:00 2001 From: Krzysztof Gibala Date: Thu, 29 Oct 2020 10:21:29 +0100 Subject: [PATCH] Extend specialQueue in context to StackVec Related-To: NEO-4589 Change-Id: I92db4cf8511e13a35307a4f48b51041a6fc7330f Signed-off-by: Krzysztof Gibala --- opencl/source/api/api.cpp | 2 +- opencl/source/context/context.cpp | 32 ++++++++++++------- opencl/source/context/context.h | 8 ++--- opencl/source/mem_obj/buffer.cpp | 2 +- opencl/source/mem_obj/image.cpp | 8 ++--- opencl/source/mem_obj/image.h | 2 +- .../unit_test/api/cl_create_context_tests.inl | 28 ++++++++++++++++ .../command_queue/enqueue_svm_tests.cpp | 6 ++-- .../test/unit_test/context/context_tests.cpp | 16 +++++----- opencl/test/unit_test/kernel/kernel_tests.cpp | 18 +++++------ .../test/unit_test/mem_obj/buffer_tests.cpp | 2 +- .../unit_test/mem_obj/nv12_image_tests.cpp | 2 +- opencl/test/unit_test/mocks/mock_context.cpp | 21 ++++++++---- 13 files changed, 95 insertions(+), 52 deletions(-) diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp index fc54a579bc..5c692151ec 100644 --- a/opencl/source/api/api.cpp +++ b/opencl/source/api/api.cpp @@ -3678,7 +3678,7 @@ void *clSharedMemAllocINTEL( err.set(CL_INVALID_BUFFER_SIZE); return nullptr; } - auto ptr = neoContext->getSVMAllocsManager()->createSharedUnifiedMemoryAllocation(neoDevice->getRootDeviceIndex(), size, unifiedMemoryProperties, neoContext->getSpecialQueue()); + auto ptr = neoContext->getSVMAllocsManager()->createSharedUnifiedMemoryAllocation(neoDevice->getRootDeviceIndex(), size, unifiedMemoryProperties, neoContext->getSpecialQueue(neoDevice->getRootDeviceIndex())); if (!ptr) { err.set(CL_OUT_OF_RESOURCES); } diff --git a/opencl/source/context/context.cpp b/opencl/source/context/context.cpp index c9d53ad369..76a10a651f 100644 --- a/opencl/source/context/context.cpp +++ b/opencl/source/context/context.cpp @@ -49,8 +49,11 @@ Context::Context( Context::~Context() { delete[] properties; - if (specialQueue) { - delete specialQueue; + + for (auto rootDeviceIndex = 0u; rootDeviceIndex < specialQueues.size(); rootDeviceIndex++) { + if (specialQueues[rootDeviceIndex]) { + delete specialQueues[rootDeviceIndex]; + } } if (svmAllocsManager) { delete svmAllocsManager; @@ -100,15 +103,15 @@ void Context::setDefaultDeviceQueue(DeviceQueue *queue) { defaultDeviceQueue = queue; } -CommandQueue *Context::getSpecialQueue() { - return specialQueue; +CommandQueue *Context::getSpecialQueue(uint32_t rootDeviceIndex) { + return specialQueues[rootDeviceIndex]; } -void Context::setSpecialQueue(CommandQueue *commandQueue) { - specialQueue = commandQueue; +void Context::setSpecialQueue(CommandQueue *commandQueue, uint32_t rootDeviceIndex) { + specialQueues[rootDeviceIndex] = commandQueue; } -void Context::overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue) { - setSpecialQueue(commandQueue); +void Context::overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue, uint32_t rootDeviceIndex) { + setSpecialQueue(commandQueue, rootDeviceIndex); commandQueue->setIsSpecialCommandQueue(true); //decrement ref count that special queue added this->decRefInternal(); @@ -197,7 +200,7 @@ bool Context::createImpl(const cl_context_properties *properties, return false; } - this->devices = inputDevices; + devices = inputDevices; for (auto &rootDeviceIndex : rootDeviceIndices) { DeviceBitfield deviceBitfield{}; for (const auto &pDevice : devices) { @@ -210,6 +213,7 @@ bool Context::createImpl(const cl_context_properties *properties, if (devices.size() > 0) { maxRootDeviceIndex = *std::max_element(rootDeviceIndices.begin(), rootDeviceIndices.end(), std::less()); + specialQueues.resize(maxRootDeviceIndex + 1u); auto device = this->getDevice(0); this->memoryManager = device->getMemoryManager(); if (memoryManager->isAsyncDeleterEnabled()) { @@ -228,9 +232,13 @@ bool Context::createImpl(const cl_context_properties *properties, setupContextType(); } - auto commandQueue = CommandQueue::create(this, devices[0], nullptr, true, errcodeRet); - DEBUG_BREAK_IF(commandQueue == nullptr); - overrideSpecialQueueAndDecrementRefCount(commandQueue); + for (auto &device : devices) { + if (!specialQueues[device->getRootDeviceIndex()]) { + auto commandQueue = CommandQueue::create(this, device, nullptr, true, errcodeRet); // NOLINT + DEBUG_BREAK_IF(commandQueue == nullptr); + overrideSpecialQueueAndDecrementRefCount(commandQueue, device->getRootDeviceIndex()); + } + } return true; } diff --git a/opencl/source/context/context.h b/opencl/source/context/context.h index ddf1dfe287..0141e81d33 100644 --- a/opencl/source/context/context.h +++ b/opencl/source/context/context.h @@ -98,9 +98,9 @@ class Context : public BaseObject<_cl_context> { DeviceQueue *getDefaultDeviceQueue(); void setDefaultDeviceQueue(DeviceQueue *queue); - CommandQueue *getSpecialQueue(); - void setSpecialQueue(CommandQueue *commandQueue); - void overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue); + CommandQueue *getSpecialQueue(uint32_t rootDeviceIndex); + void setSpecialQueue(CommandQueue *commandQueue, uint32_t rootDeviceIndex); + void overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue, uint32_t rootDeviceIndex); template Sharing *getSharing(); @@ -194,7 +194,7 @@ class Context : public BaseObject<_cl_context> { void *userData = nullptr; MemoryManager *memoryManager = nullptr; SVMAllocsManager *svmAllocsManager = nullptr; - CommandQueue *specialQueue = nullptr; + StackVec specialQueues; DeviceQueue *defaultDeviceQueue = nullptr; DriverDiagnostics *driverDiagnostics = nullptr; diff --git a/opencl/source/mem_obj/buffer.cpp b/opencl/source/mem_obj/buffer.cpp index 1f4e7ae246..0cfabeb88f 100644 --- a/opencl/source/mem_obj/buffer.cpp +++ b/opencl/source/mem_obj/buffer.cpp @@ -383,7 +383,7 @@ Buffer *Buffer::create(Context *context, auto blitMemoryToAllocationResult = BlitHelperFunctions::blitMemoryToAllocation(pBuffer->getContext()->getDevice(rootDeviceIndex)->getDevice(), allocationInfo[rootDeviceIndex].memory, pBuffer->getOffset(), hostPtr, {size, 1, 1}); if (blitMemoryToAllocationResult != BlitOperationResult::Success) { - auto cmdQ = context->getSpecialQueue(); + auto cmdQ = context->getSpecialQueue(rootDeviceIndex); if (CL_SUCCESS != cmdQ->enqueueWriteBuffer(pBuffer, CL_TRUE, 0, size, hostPtr, allocationInfo[rootDeviceIndex].mapAllocation, 0, nullptr, nullptr)) { errcodeRet = CL_OUT_OF_RESOURCES; } diff --git a/opencl/source/mem_obj/image.cpp b/opencl/source/mem_obj/image.cpp index f45f3fc815..1232d0ddb1 100644 --- a/opencl/source/mem_obj/image.cpp +++ b/opencl/source/mem_obj/image.cpp @@ -402,10 +402,10 @@ Image *Image::create(Context *context, } if (!imgInfo.linearStorage || !MemoryPool::isSystemMemoryPool(memory->getMemoryPool())) { - auto cmdQ = context->getSpecialQueue(); + auto cmdQ = context->getSpecialQueue(rootDeviceIndex); if (IsNV12Image(&image->getImageFormat())) { - errcodeRet = image->writeNV12Planes(hostPtr, hostPtrRowPitch); + errcodeRet = image->writeNV12Planes(hostPtr, hostPtrRowPitch, rootDeviceIndex); } else { errcodeRet = cmdQ->enqueueWriteImage(image, CL_TRUE, ©Origin[0], ©Region[0], hostPtrRowPitch, hostPtrSlicePitch, @@ -1022,8 +1022,8 @@ void Image::transferDataFromHostPtr(MemObjSizeArray ©Size, MemObjOffsetArray copySize, copyOffset); } -cl_int Image::writeNV12Planes(const void *hostPtr, size_t hostPtrRowPitch) { - CommandQueue *cmdQ = context->getSpecialQueue(); +cl_int Image::writeNV12Planes(const void *hostPtr, size_t hostPtrRowPitch, uint32_t rootDeviceIndex) { + CommandQueue *cmdQ = context->getSpecialQueue(rootDeviceIndex); size_t origin[3] = {0, 0, 0}; size_t region[3] = {this->imageDesc.image_width, this->imageDesc.image_height, 1}; diff --git a/opencl/source/mem_obj/image.h b/opencl/source/mem_obj/image.h index 9b453e9dfc..f89b52e5cd 100644 --- a/opencl/source/mem_obj/image.h +++ b/opencl/source/mem_obj/image.h @@ -183,7 +183,7 @@ class Image : public MemObj { static const ClSurfaceFormatInfo *getSurfaceFormatFromTable(cl_mem_flags flags, const cl_image_format *imageFormat, bool supportsOcl20Features); static cl_int validateRegionAndOrigin(const size_t *origin, const size_t *region, const cl_image_desc &imgDesc); - cl_int writeNV12Planes(const void *hostPtr, size_t hostPtrRowPitch); + cl_int writeNV12Planes(const void *hostPtr, size_t hostPtrRowPitch, uint32_t rootDeviceIndex); void setMcsSurfaceInfo(const McsSurfaceInfo &info) { mcsSurfaceInfo = info; } const McsSurfaceInfo &getMcsSurfaceInfo() { return mcsSurfaceInfo; } size_t calculateOffsetForMapping(const MemObjOffsetArray &origin) const override; diff --git a/opencl/test/unit_test/api/cl_create_context_tests.inl b/opencl/test/unit_test/api/cl_create_context_tests.inl index 3fd9b3d4ab..11d812cd84 100644 --- a/opencl/test/unit_test/api/cl_create_context_tests.inl +++ b/opencl/test/unit_test/api/cl_create_context_tests.inl @@ -89,6 +89,7 @@ TEST_F(clCreateContextTests, givenMultipleRootDevicesWhenCreateContextThenOutOrH EXPECT_EQ(nullptr, context); EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, retVal); } + TEST_F(clCreateContextTests, givenEnabledMultipleRootDeviceSupportWhenCreateContextWithMultipleRootDevicesThenContextIsCreated) { UltClDeviceFactory deviceFactory{2, 0}; DebugManager.flags.EnableMultiRootDeviceContexts.set(true); @@ -132,6 +133,33 @@ TEST_F(clCreateContextTests, givenMultipleRootDevicesWhenCreateContextThenMaxRoo clReleaseContext(context); } +TEST_F(clCreateContextTests, givenMultipleRootDevicesWhenCreateContextThenSpecialQueueIsProperlyFilled) { + UltClDeviceFactory deviceFactory{3, 0}; + DebugManager.flags.EnableMultiRootDeviceContexts.set(true); + cl_device_id devices[] = {deviceFactory.rootDevices[0], deviceFactory.rootDevices[2]}; + auto context = clCreateContext(nullptr, 2u, devices, eventCallBack, nullptr, &retVal); + EXPECT_NE(nullptr, context); + EXPECT_EQ(CL_SUCCESS, retVal); + + auto pContext = castToObject(context); + auto rootDeviceIndices = pContext->getRootDeviceIndices(); + + EXPECT_EQ(2u, pContext->getMaxRootDeviceIndex()); + StackVec specialQueues; + specialQueues.resize(pContext->getMaxRootDeviceIndex()); + + for (auto numDevice = 0u; numDevice < pContext->getNumDevices(); numDevice++) { + auto rootDeviceIndex = rootDeviceIndices.find(pContext->getDevice(numDevice)->getRootDeviceIndex()); + EXPECT_EQ(*rootDeviceIndex, pContext->getDevice(numDevice)->getRootDeviceIndex()); + EXPECT_EQ(*rootDeviceIndex, pContext->getSpecialQueue(*rootDeviceIndex)->getDevice().getRootDeviceIndex()); + specialQueues[numDevice] = pContext->getSpecialQueue(*rootDeviceIndex); + } + + EXPECT_EQ(2u, specialQueues.size()); + + clReleaseContext(context); +} + TEST_F(clCreateContextTests, givenInvalidContextCreationPropertiesThenContextCreationFails) { cl_context_properties invalidProperties[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties) nullptr, 0}; auto context = clCreateContext(invalidProperties, 1u, &testedClDevice, nullptr, nullptr, &retVal); diff --git a/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp index b26fee73f8..2cab6b5055 100644 --- a/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp +++ b/opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp @@ -1851,8 +1851,8 @@ TEST_F(EnqueueSvmTest, givenPageFaultManagerWhenEnqueueMemcpyThenAllocIsDecommit auto memoryManager = context->getMemoryManager(); context->memoryManager = mockMemoryManager.get(); auto srcSvm = context->getSVMAllocsManager()->createSVMAlloc(pDevice->getRootDeviceIndex(), 256, {}, pDevice->getDeviceBitfield()); - mockMemoryManager->getPageFaultManager()->insertAllocation(srcSvm, 256, context->getSVMAllocsManager(), context->getSpecialQueue(), {}); - mockMemoryManager->getPageFaultManager()->insertAllocation(ptrSVM, 256, context->getSVMAllocsManager(), context->getSpecialQueue(), {}); + mockMemoryManager->getPageFaultManager()->insertAllocation(srcSvm, 256, context->getSVMAllocsManager(), context->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); + mockMemoryManager->getPageFaultManager()->insertAllocation(ptrSVM, 256, context->getSVMAllocsManager(), context->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); EXPECT_EQ(static_cast(mockMemoryManager->getPageFaultManager())->transferToCpuCalled, 0); this->pCmdQ->enqueueSVMMemcpy(false, ptrSVM, srcSvm, 256, 0, nullptr, nullptr); @@ -1872,7 +1872,7 @@ TEST_F(EnqueueSvmTest, givenPageFaultManagerWhenEnqueueMemFillThenAllocIsDecommi mockMemoryManager->pageFaultManager.reset(new MockPageFaultManager()); auto memoryManager = context->getMemoryManager(); context->memoryManager = mockMemoryManager.get(); - mockMemoryManager->getPageFaultManager()->insertAllocation(ptrSVM, 256, context->getSVMAllocsManager(), context->getSpecialQueue(), {}); + mockMemoryManager->getPageFaultManager()->insertAllocation(ptrSVM, 256, context->getSVMAllocsManager(), context->getSpecialQueue(0u), {}); EXPECT_EQ(static_cast(mockMemoryManager->getPageFaultManager())->transferToCpuCalled, 0); EXPECT_EQ(static_cast(mockMemoryManager->getPageFaultManager())->protectMemoryCalled, 0); diff --git a/opencl/test/unit_test/context/context_tests.cpp b/opencl/test/unit_test/context/context_tests.cpp index c676f9805b..c7b6d7af04 100644 --- a/opencl/test/unit_test/context/context_tests.cpp +++ b/opencl/test/unit_test/context/context_tests.cpp @@ -107,19 +107,19 @@ TEST_F(ContextTest, WhenCreatingContextThenPropertiesAreValid) { } TEST_F(ContextTest, WhenCreatingContextThenSpecialQueueIsAvailable) { - auto specialQ = context->getSpecialQueue(); + auto specialQ = context->getSpecialQueue(0u); EXPECT_NE(specialQ, nullptr); } TEST_F(ContextTest, WhenSettingSpecialQueueThenQueueIsAvailable) { MockContext context((ClDevice *)devices[0], true); - auto specialQ = context.getSpecialQueue(); + auto specialQ = context.getSpecialQueue(0u); EXPECT_EQ(specialQ, nullptr); auto cmdQ = new MockCommandQueue(&context, (ClDevice *)devices[0], 0); - context.setSpecialQueue(cmdQ); - specialQ = context.getSpecialQueue(); + context.setSpecialQueue(cmdQ, 0u); + specialQ = context.getSpecialQueue(0u); EXPECT_NE(specialQ, nullptr); } @@ -235,7 +235,7 @@ TEST_F(ContextTest, givenSpecialCmdQueueWithContextWhenBeingCreatedNextAutoDelet EXPECT_EQ(1, context.getRefInternalCount()); auto cmdQ = new MockCommandQueue(&context, (ClDevice *)devices[0], 0); - context.overrideSpecialQueueAndDecrementRefCount(cmdQ); + context.overrideSpecialQueueAndDecrementRefCount(cmdQ, 0u); EXPECT_EQ(1, context.getRefInternalCount()); //special queue is to be deleted implicitly by context @@ -246,13 +246,13 @@ TEST_F(ContextTest, givenSpecialCmdQueueWithContextWhenBeingCreatedNextDeletedTh EXPECT_EQ(1, context.getRefInternalCount()); auto cmdQ = new MockCommandQueue(&context, (ClDevice *)devices[0], 0); - context.overrideSpecialQueueAndDecrementRefCount(cmdQ); + context.overrideSpecialQueueAndDecrementRefCount(cmdQ, 0u); EXPECT_EQ(1, context.getRefInternalCount()); delete cmdQ; EXPECT_EQ(1, context.getRefInternalCount()); - context.setSpecialQueue(nullptr); + context.setSpecialQueue(nullptr, 0u); } TEST_F(ContextTest, GivenInteropSyncParamWhenCreateContextThenSetContextParam) { @@ -332,7 +332,7 @@ TEST(Context, whenCreateContextThenSpecialQueueUsesInternalEngine) { ASSERT_NE(nullptr, context); EXPECT_EQ(CL_SUCCESS, retVal); - auto specialQueueEngine = context->getSpecialQueue()->getGpgpuEngine(); + auto specialQueueEngine = context->getSpecialQueue(device->getRootDeviceIndex())->getGpgpuEngine(); auto internalEngine = device->getInternalEngine(); EXPECT_EQ(internalEngine.commandStreamReceiver, specialQueueEngine.commandStreamReceiver); } diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp index 477b9e8c03..f2d6ede0b9 100644 --- a/opencl/test/unit_test/kernel/kernel_tests.cpp +++ b/opencl/test/unit_test/kernel/kernel_tests.cpp @@ -1792,7 +1792,7 @@ HWTEST_F(KernelResidencyTest, givenKernelUsingIndirectSharedMemoryWhenMakeReside auto svmAllocationsManager = mockKernel.mockContext->getSVMAllocsManager(); auto sharedProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); auto hostProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); - auto unifiedSharedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue()); + auto unifiedSharedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex())); auto unifiedHostMemoryAllocation = svmAllocationsManager->createUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, hostProperties); mockKernel.mockKernel->makeResident(this->pDevice->getGpgpuCommandStreamReceiver()); @@ -1842,9 +1842,9 @@ HWTEST_F(KernelResidencyTest, givenSharedUnifiedMemoryAndPageFaultManagerWhenMak auto svmAllocationsManager = mockKernel.mockContext->getSVMAllocsManager(); auto sharedProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); - auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue()); + auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex())); auto unifiedMemoryGraphicsAllocation = svmAllocationsManager->getSVMAlloc(unifiedMemoryAllocation); - mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(), {}); + mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); EXPECT_EQ(mockPageFaultManager->transferToCpuCalled, 0); @@ -1876,9 +1876,9 @@ HWTEST_F(KernelResidencyTest, givenSharedUnifiedMemoryAndNotRequiredMemSyncWhenM auto svmAllocationsManager = mockKernel.mockContext->getSVMAllocsManager(); auto sharedProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); - auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue()); + auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex())); auto unifiedMemoryGraphicsAllocation = svmAllocationsManager->getSVMAlloc(unifiedMemoryAllocation); - mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(), {}); + mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); EXPECT_EQ(mockPageFaultManager->transferToCpuCalled, 0); auto gpuAllocation = unifiedMemoryGraphicsAllocation->gpuAllocations.getGraphicsAllocation(pDevice->getRootDeviceIndex()); @@ -1904,9 +1904,9 @@ HWTEST_F(KernelResidencyTest, givenSharedUnifiedMemoryRequiredMemSyncWhenMakeRes auto svmAllocationsManager = mockKernel.mockContext->getSVMAllocsManager(); auto sharedProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); - auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue()); + auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex())); auto unifiedMemoryGraphicsAllocation = svmAllocationsManager->getSVMAlloc(unifiedMemoryAllocation); - mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(), {}); + mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); auto gpuAllocation = unifiedMemoryGraphicsAllocation->gpuAllocations.getGraphicsAllocation(pDevice->getRootDeviceIndex()); EXPECT_EQ(mockPageFaultManager->transferToCpuCalled, 0); @@ -1932,8 +1932,8 @@ HWTEST_F(KernelResidencyTest, givenSharedUnifiedMemoryAllocPageFaultManagerAndIn auto svmAllocationsManager = mockKernel.mockContext->getSVMAllocsManager(); auto sharedProperties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, pDevice->getDeviceBitfield()); - auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue()); - mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(), {}); + auto unifiedMemoryAllocation = svmAllocationsManager->createSharedUnifiedMemoryAllocation(pDevice->getRootDeviceIndex(), 4096u, sharedProperties, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex())); + mockPageFaultManager->insertAllocation(unifiedMemoryAllocation, 4096u, svmAllocationsManager, mockKernel.mockContext->getSpecialQueue(pDevice->getRootDeviceIndex()), {}); EXPECT_EQ(mockPageFaultManager->transferToCpuCalled, 0); mockKernel.mockKernel->unifiedMemoryControls.indirectSharedAllocationsAllowed = true; diff --git a/opencl/test/unit_test/mem_obj/buffer_tests.cpp b/opencl/test/unit_test/mem_obj/buffer_tests.cpp index 0d4aabe2d6..8bb5757297 100644 --- a/opencl/test/unit_test/mem_obj/buffer_tests.cpp +++ b/opencl/test/unit_test/mem_obj/buffer_tests.cpp @@ -617,7 +617,7 @@ struct RenderCompressedBuffersCopyHostMemoryTests : public RenderCompressedBuffe device->injectMemoryManager(new MockMemoryManager(true, false, *platform()->peekExecutionEnvironment())); context->memoryManager = device->getMemoryManager(); mockCmdQ = new MockCommandQueue(); - context->setSpecialQueue(mockCmdQ); + context->setSpecialQueue(mockCmdQ, device->getRootDeviceIndex()); } MockCommandQueue *mockCmdQ = nullptr; diff --git a/opencl/test/unit_test/mem_obj/nv12_image_tests.cpp b/opencl/test/unit_test/mem_obj/nv12_image_tests.cpp index edc98fb00a..435674736c 100644 --- a/opencl/test/unit_test/mem_obj/nv12_image_tests.cpp +++ b/opencl/test/unit_test/mem_obj/nv12_image_tests.cpp @@ -398,7 +398,7 @@ HWTEST_F(Nv12ImageTest, WhenCreatingParentImageThenPlanesAreWritten) { auto contextWithMockCmdQ = new MockContext(device.get(), true); auto cmdQ = new MockCommandQueueHw(contextWithMockCmdQ, device.get(), 0); - contextWithMockCmdQ->overrideSpecialQueueAndDecrementRefCount(cmdQ); + contextWithMockCmdQ->overrideSpecialQueueAndDecrementRefCount(cmdQ, device->getRootDeviceIndex()); // Create Parent NV12 image cl_mem_flags flags = CL_MEM_READ_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL | CL_MEM_USE_HOST_PTR; diff --git a/opencl/test/unit_test/mocks/mock_context.cpp b/opencl/test/unit_test/mocks/mock_context.cpp index 9b206a6686..2e07120e75 100644 --- a/opencl/test/unit_test/mocks/mock_context.cpp +++ b/opencl/test/unit_test/mocks/mock_context.cpp @@ -40,7 +40,7 @@ MockContext::MockContext( contextCallback = funcNotify; userData = data; memoryManager = nullptr; - specialQueue = nullptr; + StackVec specialQueues; defaultDeviceQueue = nullptr; driverDiagnostics = nullptr; rootDeviceIndices = {}; @@ -49,9 +49,11 @@ MockContext::MockContext( } MockContext::~MockContext() { - if (specialQueue) { - specialQueue->release(); - specialQueue = nullptr; + for (auto &rootDeviceIndex : rootDeviceIndices) { + if (specialQueues[rootDeviceIndex]) { + specialQueues[rootDeviceIndex]->release(); + specialQueues[rootDeviceIndex] = nullptr; + } } if (memoryManager && memoryManager->isAsyncDeleterEnabled()) { memoryManager->getDeferredDeleter()->removeClient(); @@ -97,6 +99,7 @@ void MockContext::initializeWithDevices(const ClDeviceVector &devices, bool noSp rootDeviceIndices.insert(pClDevice->getRootDeviceIndex()); } maxRootDeviceIndex = *std::max_element(rootDeviceIndices.begin(), rootDeviceIndices.end(), std::less()); + specialQueues.resize(maxRootDeviceIndex + 1u); this->devices = devices; memoryManager = devices[0]->getMemoryManager(); @@ -114,9 +117,13 @@ void MockContext::initializeWithDevices(const ClDeviceVector &devices, bool noSp cl_int retVal; if (!noSpecialQueue) { - auto commandQueue = CommandQueue::create(this, devices[0], nullptr, false, retVal); - assert(retVal == CL_SUCCESS); - overrideSpecialQueueAndDecrementRefCount(commandQueue); + for (auto &device : devices) { + if (!specialQueues[device->getRootDeviceIndex()]) { + auto commandQueue = CommandQueue::create(this, device, nullptr, false, retVal); + assert(retVal == CL_SUCCESS); + overrideSpecialQueueAndDecrementRefCount(commandQueue, device->getRootDeviceIndex()); + } + } } }