From b00819cafe439df4a90f78f5bba4ee486e284338 Mon Sep 17 00:00:00 2001 From: "Mrozek, Michal" Date: Fri, 5 Jan 2018 11:33:30 +0100 Subject: [PATCH] Add refcount on MemObj in blocked scenarios. - Prevents destruction of MemObj while it may still be in use. - Add UNRECOVERABLE to check whether object is deleted while having dependencies, fix all problems is tests due to that fact. - Fix special queue setting, clean interfaces. Change-Id: I2a467e80df00ea1650decdcfa6866acf10b441f8 --- runtime/command_queue/command_queue.cpp | 4 +- runtime/command_queue/command_queue.h | 5 ++ .../compiler_interface/compiler_interface.h | 1 + runtime/context/context.cpp | 14 +-- runtime/context/context.h | 1 + runtime/event/event.cpp | 89 +++++++++---------- runtime/helpers/task_information.cpp | 15 +++- runtime/helpers/task_information.h | 7 +- runtime/kernel/kernel.cpp | 3 +- runtime/utilities/reference_tracked_object.h | 6 +- .../api/cl_set_event_callback_tests.cpp | 5 ++ .../command_queue/command_queue_fixture.cpp | 7 +- .../command_queue/command_queue_hw_tests.cpp | 84 +++++++++++------ .../command_queue/command_queue_tests.cpp | 49 +++++----- .../command_queue/enqueue_handler_tests.cpp | 34 +++---- .../command_queue/enqueue_waitlist_tests.cpp | 8 +- unit_tests/context/context_tests.cpp | 5 +- .../device_queue/device_queue_tests.cpp | 6 +- .../event/async_events_handler_tests.cpp | 1 + unit_tests/event/event_tests.cpp | 31 +++++-- unit_tests/mem_obj/nv12_image_tests.cpp | 12 +-- unit_tests/mocks/mock_context.cpp | 4 +- unit_tests/mocks/mock_kernel.h | 12 ++- ...d_enqueue_with_callback_scenario_tests.cpp | 4 + 24 files changed, 247 insertions(+), 160 deletions(-) diff --git a/runtime/command_queue/command_queue.cpp b/runtime/command_queue/command_queue.cpp index e4c8fe64b5..2b8579862f 100644 --- a/runtime/command_queue/command_queue.cpp +++ b/runtime/command_queue/command_queue.cpp @@ -123,7 +123,9 @@ CommandQueue::~CommandQueue() { } } - if (context && !context->isSpecialQueue(this)) { + //for normal queue, decrement ref count on context + //special queue is owned by context so ref count doesn't have to be decremented + if (context && !isSpecialCommandQueue) { context->decRefInternal(); } } diff --git a/runtime/command_queue/command_queue.h b/runtime/command_queue/command_queue.h index 3e994942a3..1fae8d3e71 100644 --- a/runtime/command_queue/command_queue.h +++ b/runtime/command_queue/command_queue.h @@ -372,6 +372,10 @@ class CommandQueue : public BaseObject<_cl_command_queue> { bool setPerfCountersEnabled(bool perfCountersEnabled, cl_uint configuration); + void setIsSpecialCommandQueue(bool newValue) { + this->isSpecialCommandQueue = newValue; + } + uint16_t getPerfCountersUserRegistersNumber() { return perfCountersUserRegistersNumber; } @@ -406,6 +410,7 @@ class CommandQueue : public BaseObject<_cl_command_queue> { IndirectHeap *indirectHeap[NUM_HEAPS]; bool mapDcFlushRequired = false; + bool isSpecialCommandQueue = false; }; typedef CommandQueue *(*CommandQueueCreateFunc)( diff --git a/runtime/compiler_interface/compiler_interface.h b/runtime/compiler_interface/compiler_interface.h index a452e29435..badcaf6df5 100644 --- a/runtime/compiler_interface/compiler_interface.h +++ b/runtime/compiler_interface/compiler_interface.h @@ -72,6 +72,7 @@ class CompilerInterface { } static void shutdown() { + std::unique_lock destructionLock(CompilerInterface::mtx); if (pInstance) { delete pInstance; pInstance = nullptr; diff --git a/runtime/context/context.cpp b/runtime/context/context.cpp index 7c5e409bfe..e71e1f54ad 100644 --- a/runtime/context/context.cpp +++ b/runtime/context/context.cpp @@ -87,11 +87,12 @@ CommandQueue *Context::getSpecialQueue() { void Context::setSpecialQueue(CommandQueue *commandQueue) { specialQueue = commandQueue; - if (commandQueue) { - decRefInternal(); - } else { - incRefInternal(); - } +} +void Context::overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue) { + setSpecialQueue(commandQueue); + commandQueue->setIsSpecialCommandQueue(true); + //decrement ref count that special queue added + this->decRefInternal(); }; bool Context::isSpecialQueue(CommandQueue *commandQueue) { @@ -179,8 +180,7 @@ bool Context::createImpl(const cl_context_properties *properties, auto commandQueue = CommandQueue::create(this, devices[0], nullptr, errcodeRet); DEBUG_BREAK_IF(commandQueue == nullptr); - - setSpecialQueue(commandQueue); + overrideSpecialQueueAndDecrementRefCount(commandQueue); return true; } diff --git a/runtime/context/context.h b/runtime/context/context.h index 8cbe1bba8c..7b60f36ac6 100644 --- a/runtime/context/context.h +++ b/runtime/context/context.h @@ -92,6 +92,7 @@ class Context : public BaseObject<_cl_context> { CommandQueue *getSpecialQueue(); void setSpecialQueue(CommandQueue *commandQueue); + void overrideSpecialQueueAndDecrementRefCount(CommandQueue *commandQueue); bool isSpecialQueue(CommandQueue *commandQueue); void deleteSpecialQueue(); diff --git a/runtime/event/event.cpp b/runtime/event/event.cpp index dc3ac518cd..63da149695 100644 --- a/runtime/event/event.cpp +++ b/runtime/event/event.cpp @@ -102,56 +102,51 @@ Event::Event( } Event::~Event() { - try { - DBG_LOG(EventsDebugEnable, "~Event()", this); - //no commands should be registred - DEBUG_BREAK_IF(this->cmdToSubmit.load()); + DBG_LOG(EventsDebugEnable, "~Event()", this); + //no commands should be registred + DEBUG_BREAK_IF(this->cmdToSubmit.load()); - submitCommand(true); + submitCommand(true); - int32_t lastStatus = executionStatus; - if (isStatusCompleted(&lastStatus) == false) { - transitionExecutionStatus(-1); - DEBUG_BREAK_IF(peekHasCallbacks() || peekHasChildEvents()); - } - - // Note from OCL spec: - // "All callbacks registered for an event object must be called. - // All enqueued callbacks shall be called before the event object is destroyed." - if (peekHasCallbacks()) { - executeCallbacks(lastStatus); - } - - { - // clean-up submitted command if needed - std::unique_ptr submittedCommand(submittedCmd.exchange(nullptr)); - } - - if (cmdQueue != nullptr) { - cmdQueue->decRefInternal(); - } - - if (ctx != nullptr) { - if (timeStampNode != nullptr) { - TagAllocator *allocator = ctx->getDevice(0)->getMemoryManager()->getEventTsAllocator(); - allocator->returnTag(timeStampNode); - } - if (perfCounterNode != nullptr) { - TagAllocator *allocator = ctx->getDevice(0)->getMemoryManager()->getEventPerfCountAllocator(); - allocator->returnTag(perfCounterNode); - } - ctx->decRefInternal(); - } - if (perfConfigurationData) { - delete perfConfigurationData; - } - - // in case event did not unblock child events before - unblockEventsBlockedByThis(executionStatus); - } catch (...) //Don't throw from destructor - { - DEBUG_BREAK_IF(false); + int32_t lastStatus = executionStatus; + if (isStatusCompleted(&lastStatus) == false) { + transitionExecutionStatus(-1); + DEBUG_BREAK_IF(peekHasCallbacks() || peekHasChildEvents()); } + + // Note from OCL spec: + // "All callbacks registered for an event object must be called. + // All enqueued callbacks shall be called before the event object is destroyed." + if (peekHasCallbacks()) { + executeCallbacks(lastStatus); + } + + { + // clean-up submitted command if needed + std::unique_ptr submittedCommand(submittedCmd.exchange(nullptr)); + } + + if (cmdQueue != nullptr) { + cmdQueue->decRefInternal(); + } + + if (ctx != nullptr) { + if (timeStampNode != nullptr) { + TagAllocator *allocator = ctx->getDevice(0)->getMemoryManager()->getEventTsAllocator(); + allocator->returnTag(timeStampNode); + } + if (perfCounterNode != nullptr) { + TagAllocator *allocator = ctx->getDevice(0)->getMemoryManager()->getEventPerfCountAllocator(); + allocator->returnTag(perfCounterNode); + } + ctx->decRefInternal(); + } + if (perfConfigurationData) { + delete perfConfigurationData; + } + + // in case event did not unblock child events before + unblockEventsBlockedByThis(executionStatus); } cl_int Event::getEventProfilingInfo(cl_profiling_info paramName, diff --git a/runtime/helpers/task_information.cpp b/runtime/helpers/task_information.cpp index e372c21a8f..8ab70103ca 100644 --- a/runtime/helpers/task_information.cpp +++ b/runtime/helpers/task_information.cpp @@ -45,6 +45,15 @@ KernelOperation::~KernelOperation() { alignedFree(commandStream->getBase()); } +CommandMapUnmap::CommandMapUnmap(MapOperationType op, MemObj &memObj, CommandStreamReceiver &csr, CommandQueue &cmdQ) + : memObj(memObj), csr(csr), cmdQ(cmdQ), op(op) { + memObj.incRefInternal(); +} + +CommandMapUnmap::~CommandMapUnmap() { + memObj.decRefInternal(); +} + CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) { if (terminated) { return completionStamp; @@ -77,12 +86,12 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) { cmdQ.waitUntilComplete(completionStamp.taskCount, completionStamp.flushStamp); - if (m.isMemObjZeroCopy() == false) { + if (memObj.isMemObjZeroCopy() == false) { if (op == MAP) { - m.transferDataToHostPtr(); + memObj.transferDataToHostPtr(); } else { DEBUG_BREAK_IF(op != UNMAP); - m.transferDataFromHostPtrToMemoryStorage(); + memObj.transferDataFromHostPtrToMemoryStorage(); } } diff --git a/runtime/helpers/task_information.h b/runtime/helpers/task_information.h index 150337d73f..51ecb86f9c 100644 --- a/runtime/helpers/task_information.h +++ b/runtime/helpers/task_information.h @@ -59,13 +59,12 @@ class Command : public IFNode { class CommandMapUnmap : public Command { public: - CommandMapUnmap(MapOperationType op, MemObj &m, CommandStreamReceiver &csr, CommandQueue &cmdQ) - : m(m), csr(csr), cmdQ(cmdQ), op(op) { - } + CommandMapUnmap(MapOperationType op, MemObj &memObj, CommandStreamReceiver &csr, CommandQueue &cmdQ); + ~CommandMapUnmap() override; CompletionStamp &submit(uint32_t taskLevel, bool terminated) override; private: - MemObj &m; + MemObj &memObj; CommandStreamReceiver &csr; CommandQueue &cmdQ; MapOperationType op; diff --git a/runtime/kernel/kernel.cpp b/runtime/kernel/kernel.cpp index b1adf56ef7..b7e1ab6133 100644 --- a/runtime/kernel/kernel.cpp +++ b/runtime/kernel/kernel.cpp @@ -124,8 +124,7 @@ Kernel::~Kernel() { } kernelArgHandlers.clear(); - if (program) - program->release(); + program->release(); } // Checks if patch offset is invalid (undefined) diff --git a/runtime/utilities/reference_tracked_object.h b/runtime/utilities/reference_tracked_object.h index 053cb0c901..165744f7b4 100644 --- a/runtime/utilities/reference_tracked_object.h +++ b/runtime/utilities/reference_tracked_object.h @@ -132,7 +132,7 @@ class unique_ptr_if_unused : public std::unique_ptr class ReferenceTrackedObject { public: - virtual ~ReferenceTrackedObject() = default; + virtual ~ReferenceTrackedObject(); int32_t getRefInternalCount() const { return refInternal.peek(); @@ -181,4 +181,8 @@ class ReferenceTrackedObject { RefCounter<> refInternal; RefCounter<> refApi; }; +template +inline ReferenceTrackedObject::~ReferenceTrackedObject() { + UNRECOVERABLE_IF(refInternal.peek() > 1); +} } diff --git a/unit_tests/api/cl_set_event_callback_tests.cpp b/unit_tests/api/cl_set_event_callback_tests.cpp index aeb4da86da..3ea3246305 100644 --- a/unit_tests/api/cl_set_event_callback_tests.cpp +++ b/unit_tests/api/cl_set_event_callback_tests.cpp @@ -57,6 +57,7 @@ TEST_F(clSetEventCallback_, ValidEvent) { cl_event clevent = (cl_event)event; retVal = clSetEventCallback(clevent, CL_COMPLETE, eventCallBack, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); + event->decRefInternal(); delete event; } @@ -74,11 +75,13 @@ TEST_F(clSetEventCallback_, ValidCallbackTypes) { cl_event clevent = (cl_event)event; retVal = clSetEventCallback(clevent, CL_COMPLETE, eventCallBack, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); + event->decRefInternal(); delete event; event = new Event(nullptr, 0, 0, 0); clevent = (cl_event)event; retVal = clSetEventCallback(clevent, CL_RUNNING, eventCallBack, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); + event->decRefInternal(); delete event; event = new Event(nullptr, 0, 0, 0); clevent = (cl_event)event; @@ -112,6 +115,8 @@ TEST_F(clSetEventCallback_, MultipleCallbacks) { EXPECT_EQ(CL_SUCCESS, retVal); retVal = clSetEventCallback(clevent, CL_SUBMITTED, eventCallBack, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); + event->decRefInternal(); + event->decRefInternal(); delete event; } diff --git a/unit_tests/command_queue/command_queue_fixture.cpp b/unit_tests/command_queue/command_queue_fixture.cpp index 550f71626c..12cbd4e6c7 100644 --- a/unit_tests/command_queue/command_queue_fixture.cpp +++ b/unit_tests/command_queue/command_queue_fixture.cpp @@ -64,7 +64,12 @@ void CommandQueueHwFixture::SetUp( } void CommandQueueHwFixture::TearDown() { - delete pCmdQ; + //resolve event dependencies + if (pCmdQ) { + auto blocked = pCmdQ->isQueueBlocked(); + UNRECOVERABLE_IF(blocked); + pCmdQ->release(); + } context->release(); } diff --git a/unit_tests/command_queue/command_queue_hw_tests.cpp b/unit_tests/command_queue/command_queue_hw_tests.cpp index 2509a299a0..374e769b51 100644 --- a/unit_tests/command_queue/command_queue_hw_tests.cpp +++ b/unit_tests/command_queue/command_queue_hw_tests.cpp @@ -121,6 +121,29 @@ HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDependenciesCreateVirtua pHwQ->virtualEvent = nullptr; } +HWTEST_F(CommandQueueHwTest, givenBlockedMapBufferCallWhenMemObjectIsPassedToCommandThenItsRefCountIsBeingIncreased) { + + CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); + MockBuffer buffer; + pHwQ->virtualEvent = nullptr; + + auto currentRefCount = buffer.getRefInternalCount(); + + MockEventBuilder eventBuilder; + pHwQ->addMapUnmapToWaitlistEventsDependencies(nullptr, + 0, + MAP, + &buffer, + eventBuilder); + + EXPECT_EQ(currentRefCount + 1, buffer.getRefInternalCount()); + + ASSERT_NE(nullptr, pHwQ->virtualEvent); + pHwQ->virtualEvent->decRefInternal(); + pHwQ->virtualEvent = nullptr; + EXPECT_EQ(currentRefCount, buffer.getRefInternalCount()); +} + HWTEST_F(CommandQueueHwTest, givenNoReturnEventWhenCallingAddMapUnmapToWaitlistEventsDependenciesThenVirtualEventIncrementsCommandQueueInternalRefCount) { CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); @@ -148,11 +171,11 @@ HWTEST_F(CommandQueueHwTest, givenNoReturnEventWhenCallingAddMapUnmapToWaitlistE HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDoesntAddDependenciesIntoChild) { - MockBuffer buffer; + auto buffer = new MockBuffer; CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); - Event *returnEvent = new Event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); - Event event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); - const cl_event eventWaitList = &event; + auto returnEvent = new Event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); + auto event = new Event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); + const cl_event eventWaitList = event; pHwQ->virtualEvent = nullptr; @@ -160,47 +183,50 @@ HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDoesntAddDependenciesInt pHwQ->addMapUnmapToWaitlistEventsDependencies(&eventWaitList, 1, MAP, - &buffer, + buffer, eventBuilder); EXPECT_EQ(returnEvent, pHwQ->virtualEvent); - ASSERT_EQ(nullptr, event.peekChildEvents()); + ASSERT_EQ(nullptr, event->peekChildEvents()); // Release API refcount (i.e. from workload's perspective) returnEvent->release(); + event->decRefInternal(); + buffer->decRefInternal(); } HWTEST_F(CommandQueueHwTest, givenMapCommandWhenZeroStateCommandIsSubmittedThenTaskCountIsBeingWaited) { - MockBuffer buffer; + auto buffer = new MockBuffer; CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); MockEventBuilder eventBuilder; pHwQ->addMapUnmapToWaitlistEventsDependencies(nullptr, 0, MAP, - &buffer, + buffer, eventBuilder); EXPECT_NE(nullptr, pHwQ->virtualEvent); pHwQ->virtualEvent->setStatus(CL_COMPLETE); EXPECT_EQ(1u, pHwQ->latestTaskCountWaited); + buffer->decRefInternal(); } HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDependenciesInjectedCommand) { CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); Event *returnEvent = new Event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); - MockBuffer buffer; + auto buffer = new MockBuffer; pHwQ->virtualEvent = nullptr; MockEventBuilder eventBuilder(returnEvent); pHwQ->addMapUnmapToWaitlistEventsDependencies(nullptr, 0, MAP, - &buffer, + buffer, eventBuilder); eventBuilder.finalizeAndRelease(); @@ -211,11 +237,12 @@ HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDependenciesInjectedComm pHwQ->virtualEvent = nullptr; // now delete delete returnEvent; + buffer->decRefInternal(); } HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDependenciesPreviousEventHasNotInjectedChild) { - MockBuffer buffer; + auto buffer = new MockBuffer; CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); Event *returnEvent = new Event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); Event event(pHwQ, CL_COMMAND_MAP_BUFFER, 0, 0); @@ -230,13 +257,14 @@ HWTEST_F(CommandQueueHwTest, addMapUnmapToWaitlistEventsDependenciesPreviousEven pHwQ->addMapUnmapToWaitlistEventsDependencies(nullptr, 0, MAP, - &buffer, + buffer, eventBuilder); EXPECT_EQ(returnEvent, pHwQ->virtualEvent); ASSERT_EQ(nullptr, event.peekChildEvents()); returnEvent->release(); + buffer->decRefInternal(); } HWTEST_F(CommandQueueHwTest, GivenNonEmptyQueueOnBlockingMapBufferWillWaitForPrecedingCommandsToComplete) { @@ -612,8 +640,8 @@ HWTEST_F(CommandQueueHwTest, GivenEventThatIsNotCompletedWhenFinishIsCalledAndIt }; auto Value = 0u; - Event ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, Event::eventNotReady + 1); - clSetEventCallback(&ev, CL_COMPLETE, ClbFuncTempStruct::ClbFuncT, &Value); + auto ev = new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, Event::eventNotReady + 1); + clSetEventCallback(ev, CL_COMPLETE, ClbFuncTempStruct::ClbFuncT, &Value); auto &csr = this->pCmdQ->getDevice().getCommandStreamReceiver(); EXPECT_GT(3u, csr.peekTaskCount()); @@ -621,7 +649,9 @@ HWTEST_F(CommandQueueHwTest, GivenEventThatIsNotCompletedWhenFinishIsCalledAndIt ret = clFinish(this->pCmdQ); ASSERT_EQ(CL_SUCCESS, ret); - EXPECT_EQ(0u, Value); // will be handled asynchronously + ev->updateExecutionStatus(); + EXPECT_EQ(1u, Value); + ev->decRefInternal(); } void CloneMdi(MultiDispatchInfo &dst, const MultiDispatchInfo &src) { @@ -802,35 +832,36 @@ HWTEST_F(CommandQueueHwTest, givenBlockedInOrderCmdQueueAndAsynchronouslyComplet } }; - Event event(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, 10, 0); + auto event = new Event(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, 10, 0); uint32_t virtualEventTaskLevel = 77; uint32_t virtualEventTaskCount = 80; - MockEventWithSetCompleteOnUpdate virtualEvent(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, virtualEventTaskLevel, virtualEventTaskCount); - virtualEvent.setStatus(CL_SUBMITTED); + auto virtualEvent = new MockEventWithSetCompleteOnUpdate(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, virtualEventTaskLevel, virtualEventTaskCount); + virtualEvent->setStatus(CL_SUBMITTED); - cl_event blockedEvent = &event; + cl_event blockedEvent = event; // Put Queue in blocked state by assigning virtualEvent - virtualEvent.incRefInternal(); - event.addChild(virtualEvent); - cmdQHw->virtualEvent = &virtualEvent; - cmdQHw->incRefInternal(); + event->addChild(*virtualEvent); + virtualEvent->incRefInternal(); + cmdQHw->virtualEvent = virtualEvent; cmdQHw->taskLevel = 23; cmdQHw->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr); //new virtual event is created on enqueue, bind it to the created virtual event - EXPECT_NE(cmdQHw->virtualEvent, &virtualEvent); + EXPECT_NE(cmdQHw->virtualEvent, virtualEvent); - event.setStatus(CL_SUBMITTED); + event->setStatus(CL_SUBMITTED); - virtualEvent.Event::updateExecutionStatus(); + virtualEvent->Event::updateExecutionStatus(); EXPECT_FALSE(cmdQHw->isQueueBlocked()); // +1 for next level after virtualEvent is unblocked // +1 as virtualEvent was a parent for event with actual command that is being submitted EXPECT_EQ(virtualEventTaskLevel + 2, cmdQHw->taskLevel); //command being submitted was dependant only on virtual event hence only +1 EXPECT_EQ(virtualEventTaskLevel + 1, mockCSR->lastTaskLevelToFlushTask); + virtualEvent->decRefInternal(); + event->decRefInternal(); } HWTEST_F(OOQueueHwTest, givenBlockedOutOfOrderCmdQueueAndAsynchronouslyCompletedEventWhenEnqueueCompletesVirtualEventThenUpdatedTaskLevelIsPassedToEnqueueAndFlushTask) { @@ -868,7 +899,6 @@ HWTEST_F(OOQueueHwTest, givenBlockedOutOfOrderCmdQueueAndAsynchronouslyCompleted virtualEvent.incRefInternal(); event.addChild(virtualEvent); cmdQHw->virtualEvent = &virtualEvent; - cmdQHw->incRefInternal(); cmdQHw->taskLevel = 23; cmdQHw->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr); diff --git a/unit_tests/command_queue/command_queue_tests.cpp b/unit_tests/command_queue/command_queue_tests.cpp index 1b0958ef90..97f1b526f3 100644 --- a/unit_tests/command_queue/command_queue_tests.cpp +++ b/unit_tests/command_queue/command_queue_tests.cpp @@ -212,40 +212,44 @@ TEST(CommandQueue, GivenOOQwhenUpdateFromCompletionStampWithTrueIsCalledThenTask } TEST(CommandQueue, givenCmdQueueBlockedByReadyVirtualEventWhenUnblockingThenUpdateFlushTaskFromEvent) { - MockContext context; - CommandQueue cmdQ(&context, nullptr, 0); - Event userEvent(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); - userEvent.setStatus(CL_COMPLETE); - userEvent.flushStamp->setStamp(5); + auto context = new MockContext; + auto cmdQ = new CommandQueue(context, nullptr, 0); + auto userEvent = new Event(cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); + userEvent->setStatus(CL_COMPLETE); + userEvent->flushStamp->setStamp(5); + userEvent->incRefInternal(); FlushStamp expectedFlushStamp = 0; - EXPECT_EQ(expectedFlushStamp, cmdQ.flushStamp->peekStamp()); - userEvent.incRefInternal(); - cmdQ.virtualEvent = &userEvent; - cmdQ.incRefInternal(); + EXPECT_EQ(expectedFlushStamp, cmdQ->flushStamp->peekStamp()); + cmdQ->virtualEvent = userEvent; - EXPECT_FALSE(cmdQ.isQueueBlocked()); - EXPECT_EQ(userEvent.flushStamp->peekStamp(), cmdQ.flushStamp->peekStamp()); + EXPECT_FALSE(cmdQ->isQueueBlocked()); + EXPECT_EQ(userEvent->flushStamp->peekStamp(), cmdQ->flushStamp->peekStamp()); + userEvent->decRefInternal(); + cmdQ->decRefInternal(); + context->decRefInternal(); } TEST(CommandQueue, givenCmdQueueBlockedByAbortedVirtualEventWhenUnblockingThenUpdateFlushTaskFromEvent) { - MockContext context; + auto context = new MockContext; std::unique_ptr mockDevice(Device::create(nullptr)); - CommandQueue cmdQ(&context, mockDevice.get(), 0); + auto cmdQ = new CommandQueue(context, mockDevice.get(), 0); - Event userEvent(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); - userEvent.setStatus(-1); - userEvent.flushStamp->setStamp(5); + auto userEvent = new Event(cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); + userEvent->setStatus(-1); + userEvent->flushStamp->setStamp(5); FlushStamp expectedFlushStamp = 0; - EXPECT_EQ(expectedFlushStamp, cmdQ.flushStamp->peekStamp()); - userEvent.incRefInternal(); - cmdQ.virtualEvent = &userEvent; - cmdQ.incRefInternal(); + EXPECT_EQ(expectedFlushStamp, cmdQ->flushStamp->peekStamp()); + userEvent->incRefInternal(); + cmdQ->virtualEvent = userEvent; - EXPECT_FALSE(cmdQ.isQueueBlocked()); - EXPECT_EQ(expectedFlushStamp, cmdQ.flushStamp->peekStamp()); + EXPECT_FALSE(cmdQ->isQueueBlocked()); + EXPECT_EQ(expectedFlushStamp, cmdQ->flushStamp->peekStamp()); + userEvent->decRefInternal(); + cmdQ->decRefInternal(); + context->decRefInternal(); } struct CommandQueueCommandStreamTest : public CommandQueueMemoryDevice, @@ -272,7 +276,6 @@ HWTEST_F(CommandQueueCommandStreamTest, givenCommandQueueThatWaitsOnAbortedUserE userEvent.setStatus(-1); userEvent.incRefInternal(); cmdQ.virtualEvent = &userEvent; - cmdQ.incRefInternal(); EXPECT_FALSE(cmdQ.isQueueBlocked()); EXPECT_EQ(100u, cmdQ.taskLevel); diff --git a/unit_tests/command_queue/enqueue_handler_tests.cpp b/unit_tests/command_queue/enqueue_handler_tests.cpp index a69cda0b19..5f9ac827d1 100644 --- a/unit_tests/command_queue/enqueue_handler_tests.cpp +++ b/unit_tests/command_queue/enqueue_handler_tests.cpp @@ -37,13 +37,15 @@ class EnqueueHandlerTest : public DeviceFixture, public testing::Test { public: void SetUp() override { + context = new MockContext; DeviceFixture::SetUp(); } void TearDown() override { DeviceFixture::TearDown(); + context->decRefInternal(); } - MockContext context; + MockContext *context; }; HWTEST_F(EnqueueHandlerTest, enqueueHandlerWithKernelCallsProcessEvictionOnCSR) { @@ -52,7 +54,7 @@ HWTEST_F(EnqueueHandlerTest, enqueueHandlerWithKernelCallsProcessEvictionOnCSR) pDevice->resetCommandStreamReceiver(csr); MockKernelWithInternals mockKernel(*pDevice); - auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(&context, pDevice, 0)); + auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(context, pDevice, 0)); size_t gws[] = {1, 1, 1}; mockCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr); @@ -65,7 +67,7 @@ HWTEST_F(EnqueueHandlerTest, enqueueHandlerCallOnEnqueueMarkerDoesntCallProcessE auto csr = new MockCsrBase(tag); pDevice->resetCommandStreamReceiver(csr); - auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(&context, pDevice, 0)); + auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(context, pDevice, 0)); mockCmdQ->enqueueMarkerWithWaitList( 0, @@ -82,7 +84,7 @@ HWTEST_F(EnqueueHandlerTest, enqueueHandlerForMarkerOnUnblockedQueueDoesntIncrem auto csr = new MockCsrBase(tag); pDevice->resetCommandStreamReceiver(csr); - auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(&context, pDevice, 0)); + auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(context, pDevice, 0)); // put queue into initial unblocked state mockCmdQ->taskLevel = 0; @@ -100,7 +102,7 @@ HWTEST_F(EnqueueHandlerTest, enqueueHandlerForMarkerOnBlockedQueueShouldNotIncre auto csr = new MockCsrBase(tag); pDevice->resetCommandStreamReceiver(csr); - auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(&context, pDevice, 0)); + auto mockCmdQ = std::unique_ptr>(new MockCommandQueueHw(context, pDevice, 0)); // put queue into initial blocked state mockCmdQ->taskLevel = Event::eventNotReady; @@ -115,13 +117,13 @@ HWTEST_F(EnqueueHandlerTest, enqueueHandlerForMarkerOnBlockedQueueShouldNotIncre HWTEST_F(EnqueueHandlerTest, enqueueBlockedWithoutReturnEventCreatesVirtualEventAndIncremetsCommandQueueInternalRefCount) { - MockKernelWithInternals kernelInternals(*pDevice, &context); + MockKernelWithInternals kernelInternals(*pDevice, context); Kernel *kernel = kernelInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(kernel); - auto mockCmdQ = new MockCommandQueueHw(&context, pDevice, 0); + auto mockCmdQ = new MockCommandQueueHw(context, pDevice, 0); // put queue into initial blocked state mockCmdQ->taskLevel = Event::eventNotReady; @@ -142,19 +144,20 @@ HWTEST_F(EnqueueHandlerTest, enqueueBlockedWithoutReturnEventCreatesVirtualEvent auto refCountInternal = mockCmdQ->getRefInternalCount(); EXPECT_EQ(initialRefCountInternal + 1, refCountInternal); - mockCmdQ->decRefInternal(); + mockCmdQ->virtualEvent->setStatus(CL_COMPLETE); + mockCmdQ->isQueueBlocked(); mockCmdQ->release(); } HWTEST_F(EnqueueHandlerTest, enqueueBlockedSetsVirtualEventAsCurrentCmdQVirtualEvent) { - MockKernelWithInternals kernelInternals(*pDevice, &context); + MockKernelWithInternals kernelInternals(*pDevice, context); Kernel *kernel = kernelInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(kernel); - auto mockCmdQ = new MockCommandQueueHw(&context, pDevice, 0); + auto mockCmdQ = new MockCommandQueueHw(context, pDevice, 0); // put queue into initial blocked state mockCmdQ->taskLevel = Event::eventNotReady; @@ -172,7 +175,8 @@ HWTEST_F(EnqueueHandlerTest, enqueueBlockedSetsVirtualEventAsCurrentCmdQVirtualE EXPECT_TRUE(mockCmdQ->virtualEvent->isCurrentCmdQVirtualEvent()); - mockCmdQ->decRefInternal(); + mockCmdQ->virtualEvent->setStatus(CL_COMPLETE); + mockCmdQ->isQueueBlocked(); mockCmdQ->release(); } @@ -181,13 +185,13 @@ HWTEST_F(EnqueueHandlerTest, enqueueBlockedUnsetsCurrentCmdQVirtualEventForPrevi UserEvent userEvent; cl_event clUserEvent = &userEvent; - MockKernelWithInternals kernelInternals(*pDevice, &context); + MockKernelWithInternals kernelInternals(*pDevice, context); Kernel *kernel = kernelInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(kernel); - auto mockCmdQ = new MockCommandQueueHw(&context, pDevice, 0); + auto mockCmdQ = new MockCommandQueueHw(context, pDevice, 0); // put queue into initial blocked state with userEvent @@ -218,12 +222,12 @@ HWTEST_F(EnqueueHandlerTest, enqueueBlockedUnsetsCurrentCmdQVirtualEventForPrevi } HWTEST_F(EnqueueHandlerTest, enqueueWithOutputEventRegistersEvent) { - MockKernelWithInternals kernelInternals(*pDevice, &context); + MockKernelWithInternals kernelInternals(*pDevice, context); Kernel *kernel = kernelInternals.mockKernel; MockMultiDispatchInfo multiDispatchInfo(kernel); cl_event outputEvent = nullptr; - auto mockCmdQ = new MockCommandQueueHw(&context, pDevice, 0); + auto mockCmdQ = new MockCommandQueueHw(context, pDevice, 0); bool blocking = false; mockCmdQ->template enqueueHandler(nullptr, diff --git a/unit_tests/command_queue/enqueue_waitlist_tests.cpp b/unit_tests/command_queue/enqueue_waitlist_tests.cpp index 3a0799bc90..a315f6d672 100644 --- a/unit_tests/command_queue/enqueue_waitlist_tests.cpp +++ b/unit_tests/command_queue/enqueue_waitlist_tests.cpp @@ -80,10 +80,10 @@ struct EnqueueWaitlistTest : public EnqueueWaitlistFixture, } void TearDown() override { - delete buffer; - delete bufferNonZeroCopy; - delete image; - delete imageNonZeroCopy; + buffer->decRefInternal(); + bufferNonZeroCopy->decRefInternal(); + image->decRefInternal(); + imageNonZeroCopy->decRefInternal(); EnqueueWaitlistFixture::TearDown(); } diff --git a/unit_tests/context/context_tests.cpp b/unit_tests/context/context_tests.cpp index 672f97fd42..9dec14446f 100644 --- a/unit_tests/context/context_tests.cpp +++ b/unit_tests/context/context_tests.cpp @@ -241,7 +241,7 @@ TEST_F(ContextTest, givenSpecialCmdQueueWithContextWhenBeingCreatedNextAutoDelet EXPECT_EQ(1, context.getRefInternalCount()); auto cmdQ = new CommandQueue(&context, (Device *)devices[0], 0); - context.setSpecialQueue(cmdQ); + context.overrideSpecialQueueAndDecrementRefCount(cmdQ); EXPECT_EQ(1, context.getRefInternalCount()); //special queue is to be deleted implicitly by context @@ -252,13 +252,12 @@ TEST_F(ContextTest, givenSpecialCmdQueueWithContextWhenBeingCreatedNextDeletedTh EXPECT_EQ(1, context.getRefInternalCount()); auto cmdQ = new CommandQueue(&context, (Device *)devices[0], 0); - context.setSpecialQueue(cmdQ); + context.overrideSpecialQueueAndDecrementRefCount(cmdQ); EXPECT_EQ(1, context.getRefInternalCount()); delete cmdQ; EXPECT_EQ(1, context.getRefInternalCount()); - //if special queue is deleted explicitly, then it needs to be detached from context context.setSpecialQueue(nullptr); } diff --git a/unit_tests/device_queue/device_queue_tests.cpp b/unit_tests/device_queue/device_queue_tests.cpp index f4ceb56fc1..4639dc04f2 100644 --- a/unit_tests/device_queue/device_queue_tests.cpp +++ b/unit_tests/device_queue/device_queue_tests.cpp @@ -253,7 +253,8 @@ TEST_F(DefaultDeviceQueue, createOnlyOneDefaultDeviceQueueWhenSingleDeviceQueueI EXPECT_EQ(pContext->getDefaultDeviceQueue(), deviceQueue1); EXPECT_EQ(deviceQueue1->getReference(), 2); - delete deviceQueue1; + deviceQueue1->release(); + deviceQueue2->release(); const_cast(&device->getDeviceInfo())->maxOnDeviceQueues = maxOnDeviceQueues; } @@ -278,7 +279,8 @@ TEST_F(DefaultDeviceQueue, createOnlyOneDefaultDeviceQueueWhenMultipleDeviceQueu EXPECT_EQ(pContext->getDefaultDeviceQueue(), deviceQueue1); EXPECT_EQ(deviceQueue1->getReference(), 2); - delete deviceQueue1; + deviceQueue1->release(); + deviceQueue2->release(); const_cast(&device->getDeviceInfo())->maxOnDeviceQueues = maxOnDeviceQueues; } diff --git a/unit_tests/event/async_events_handler_tests.cpp b/unit_tests/event/async_events_handler_tests.cpp index edefd87214..54f2acacf9 100644 --- a/unit_tests/event/async_events_handler_tests.cpp +++ b/unit_tests/event/async_events_handler_tests.cpp @@ -246,6 +246,7 @@ TEST_F(AsyncEventsHandlerTests, givenUserEventWhenCallbackIsAddedThenDontRegiste EXPECT_TRUE(handler->peekIsListEmpty()); EXPECT_TRUE(handler->peekIsRegisterListEmpty()); EXPECT_TRUE(userEvent.peekHasCallbacks()); + userEvent.decRefInternal(); } TEST_F(AsyncEventsHandlerTests, givenRegistredEventsWhenProcessIsCalledThenReturnCandidateWithLowestTaskCount) { diff --git a/unit_tests/event/event_tests.cpp b/unit_tests/event/event_tests.cpp index a9215c5574..712844093f 100644 --- a/unit_tests/event/event_tests.cpp +++ b/unit_tests/event/event_tests.cpp @@ -330,6 +330,7 @@ TEST_F(EventTest, GetEventInfo_CL_EVENT_REFERENCE_COUNT_Retain_Event) { EXPECT_EQ(sizeof(refCount), sizeReturned); EXPECT_EQ(2u, refCount); + event.release(); } TEST_F(EventTest, GetEventInfo_CL_EVENT_REFERENCE_COUNT_Retain_Release_Event) { @@ -630,9 +631,9 @@ TEST_F(InternalsEventTest, processBlockedCommandsMapOperation) { CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, 0); auto &csr = pDevice->getCommandStreamReceiver(); - MockBuffer buffer; + auto buffer = new MockBuffer; - event.setCommand(std::unique_ptr(new CommandMapUnmap(MAP, buffer, csr, *pCmdQ))); + event.setCommand(std::unique_ptr(new CommandMapUnmap(MAP, *buffer, csr, *pCmdQ))); auto taskLevelBefore = csr.peekTaskLevel(); @@ -641,6 +642,7 @@ TEST_F(InternalsEventTest, processBlockedCommandsMapOperation) { auto taskLevelAfter = csr.peekTaskLevel(); EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter); + buffer->decRefInternal(); delete pCmdQ; } @@ -649,9 +651,9 @@ TEST_F(InternalsEventTest, processBlockedCommandsMapOperationNonZeroCopyBuffer) CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, 0); auto &csr = pDevice->getCommandStreamReceiver(); - UnalignedBuffer buffer; + auto buffer = new UnalignedBuffer; - event.setCommand(std::unique_ptr(new CommandMapUnmap(MAP, buffer, csr, *pCmdQ))); + event.setCommand(std::unique_ptr(new CommandMapUnmap(MAP, *buffer, csr, *pCmdQ))); auto taskLevelBefore = csr.peekTaskLevel(); @@ -660,6 +662,7 @@ TEST_F(InternalsEventTest, processBlockedCommandsMapOperationNonZeroCopyBuffer) auto taskLevelAfter = csr.peekTaskLevel(); EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter); + buffer->decRefInternal(); delete pCmdQ; } @@ -757,9 +760,9 @@ TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperation) { CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props); auto &csr = pDevice->getCommandStreamReceiver(); - UnalignedBuffer buffer; + auto buffer = new UnalignedBuffer; - event.setCommand(std::unique_ptr(new CommandMapUnmap(UNMAP, buffer, csr, *pCmdQ))); + event.setCommand(std::unique_ptr(new CommandMapUnmap(UNMAP, *buffer, csr, *pCmdQ))); auto taskLevelBefore = csr.peekTaskLevel(); @@ -768,6 +771,7 @@ TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperation) { auto taskLevelAfter = csr.peekTaskLevel(); EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter); + buffer->decRefInternal(); delete pCmdQ; } @@ -777,9 +781,9 @@ TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperationNonZeroCopyBuffer CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props); auto &csr = pDevice->getCommandStreamReceiver(); - UnalignedBuffer buffer; + auto buffer = new UnalignedBuffer; - event.setCommand(std::unique_ptr(new CommandMapUnmap(UNMAP, buffer, csr, *pCmdQ))); + event.setCommand(std::unique_ptr(new CommandMapUnmap(UNMAP, *buffer, csr, *pCmdQ))); auto taskLevelBefore = csr.peekTaskLevel(); @@ -788,6 +792,7 @@ TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperationNonZeroCopyBuffer auto taskLevelAfter = csr.peekTaskLevel(); EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter); + buffer->decRefInternal(); delete pCmdQ; } @@ -1308,18 +1313,21 @@ TEST(EventCallback, GivenEventWithCallbacksOnPeekHasCallbacksReturnsTrue) { SmallMockEvent ev; ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_SUBMITTED, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); } { SmallMockEvent ev; ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); } { SmallMockEvent ev; ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); } { @@ -1327,6 +1335,8 @@ TEST(EventCallback, GivenEventWithCallbacksOnPeekHasCallbacksReturnsTrue) { ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_SUBMITTED, nullptr); ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); + ev.decRefInternal(); } { @@ -1334,6 +1344,8 @@ TEST(EventCallback, GivenEventWithCallbacksOnPeekHasCallbacksReturnsTrue) { ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr); ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); + ev.decRefInternal(); } { @@ -1342,6 +1354,9 @@ TEST(EventCallback, GivenEventWithCallbacksOnPeekHasCallbacksReturnsTrue) { ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr); ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr); EXPECT_TRUE(ev.peekHasCallbacks()); + ev.decRefInternal(); + ev.decRefInternal(); + ev.decRefInternal(); } } diff --git a/unit_tests/mem_obj/nv12_image_tests.cpp b/unit_tests/mem_obj/nv12_image_tests.cpp index 7dfc76cd24..b49b615aa1 100644 --- a/unit_tests/mem_obj/nv12_image_tests.cpp +++ b/unit_tests/mem_obj/nv12_image_tests.cpp @@ -389,20 +389,20 @@ HWTEST_F(Nv12ImageTest, checkIfPlanesAreWritten) { char hostPtr[16 * 16 * 16]; - MockContext contextWithMockCmdQ(device.get(), true); - MockCommandQueueHw cmdQ(&contextWithMockCmdQ, device.get(), 0); + auto contextWithMockCmdQ = new MockContext(device.get(), true); + auto cmdQ = new MockCommandQueueHw(contextWithMockCmdQ, device.get(), 0); - contextWithMockCmdQ.setSpecialQueue(&cmdQ); + contextWithMockCmdQ->overrideSpecialQueueAndDecrementRefCount(cmdQ); // Create Parent NV12 image cl_mem_flags flags = CL_MEM_READ_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL | CL_MEM_USE_HOST_PTR; auto surfaceFormat = Image::getSurfaceFormatFromTable(flags, &imageFormat); - auto imageNV12 = Image::create(&contextWithMockCmdQ, flags, surfaceFormat, &imageDesc, hostPtr, retVal); + auto imageNV12 = Image::create(contextWithMockCmdQ, flags, surfaceFormat, &imageDesc, hostPtr, retVal); - EXPECT_EQ(2u, cmdQ.EnqueueWriteImageCounter); - contextWithMockCmdQ.setSpecialQueue(nullptr); + EXPECT_EQ(2u, cmdQ->EnqueueWriteImageCounter); ASSERT_NE(nullptr, imageNV12); + contextWithMockCmdQ->release(); delete imageNV12; } diff --git a/unit_tests/mocks/mock_context.cpp b/unit_tests/mocks/mock_context.cpp index 8b01a10ef8..c9b9b4546d 100644 --- a/unit_tests/mocks/mock_context.cpp +++ b/unit_tests/mocks/mock_context.cpp @@ -41,7 +41,7 @@ MockContext::MockContext(Device *device, bool noSpecialQueue) { if (!specialQueue && !noSpecialQueue) { auto commandQueue = CommandQueue::create(this, device, nullptr, retVal); assert(retVal == CL_SUCCESS); - setSpecialQueue(commandQueue); + overrideSpecialQueueAndDecrementRefCount(commandQueue); } } @@ -80,7 +80,7 @@ MockContext::MockContext() { if (!specialQueue) { auto commandQueue = CommandQueue::create(this, device.get(), nullptr, retVal); assert(retVal == CL_SUCCESS); - setSpecialQueue(commandQueue); + overrideSpecialQueueAndDecrementRefCount(commandQueue); } } diff --git a/unit_tests/mocks/mock_kernel.h b/unit_tests/mocks/mock_kernel.h index 97cdd437a3..cd0cb38745 100644 --- a/unit_tests/mocks/mock_kernel.h +++ b/unit_tests/mocks/mock_kernel.h @@ -203,7 +203,11 @@ class MockKernelWithInternals { kernelInfo.patchInfo.threadPayload = &threadPayload; if (context == nullptr) { - context = &mockContext; + mockContext = new MockContext; + context = mockContext; + } else { + context->incRefInternal(); + mockContext = context; } mockProgram = new MockProgram(context); @@ -214,6 +218,7 @@ class MockKernelWithInternals { ~MockKernelWithInternals() { mockKernel->decRefInternal(); mockProgram->decRefInternal(); + mockContext->decRefInternal(); } operator MockKernel *() { @@ -222,7 +227,7 @@ class MockKernelWithInternals { MockKernel *mockKernel; MockProgram *mockProgram; - MockContext mockContext; + Context *mockContext; KernelInfo kernelInfo; SKernelBinaryHeaderCommon kernelHeader; SPatchThreadPayload threadPayload; @@ -450,8 +455,7 @@ class MockParentKernel : public Kernel { delete[](uint64_t *) blockInfo->heapInfo.pDsh; } if (mockProgram) { - this->program = nullptr; - delete mockProgram; + mockProgram->decRefInternal(); } } diff --git a/unit_tests/scenarios/blocked_enqueue_with_callback_scenario_tests.cpp b/unit_tests/scenarios/blocked_enqueue_with_callback_scenario_tests.cpp index a24074bf4e..83ef95412d 100644 --- a/unit_tests/scenarios/blocked_enqueue_with_callback_scenario_tests.cpp +++ b/unit_tests/scenarios/blocked_enqueue_with_callback_scenario_tests.cpp @@ -25,6 +25,8 @@ #include "unit_tests/mocks/mock_command_queue.h" #include "unit_tests/mocks/mock_kernel.h" #include "runtime/helpers/options.h" +#include "runtime/platform/platform.h" +#include "runtime/event/async_events_handler.h" #include "gtest/gtest.h" #include "test.h" @@ -143,4 +145,6 @@ TEST_F(ScenarioTest, givenAsyncHandlerEnabledAndUserEventBlockingEnqueueAndOutpu clReleaseEvent(eventOut); clReleaseCommandQueue(clCommandQ); + + platform()->getAsyncEventsHandler()->closeThread(); }