diff --git a/runtime/command_queue/command_queue.h b/runtime/command_queue/command_queue.h index ac11070f74..cc156a11b2 100644 --- a/runtime/command_queue/command_queue.h +++ b/runtime/command_queue/command_queue.h @@ -10,7 +10,7 @@ #include "runtime/helpers/engine_control.h" #include "runtime/helpers/task_information.h" #include "runtime/helpers/dispatch_info.h" -#include "runtime/event/user_event.h" +#include "runtime/event/event.h" #include "instrumentation.h" #include #include diff --git a/runtime/event/event.h b/runtime/event/event.h index 0004a46c60..a0c35af1c5 100644 --- a/runtime/event/event.h +++ b/runtime/event/event.h @@ -187,7 +187,7 @@ class Event : public BaseObject<_cl_event>, public IDNode { // Note from OCL spec : // "A negative integer value causes all enqueued commands that wait on this user event // to be terminated." - bool isStatusCompletedByTermination(const int32_t *executionStatusSnapshot = nullptr) { + bool isStatusCompletedByTermination(const int32_t *executionStatusSnapshot = nullptr) const { if (executionStatusSnapshot == nullptr) { return (peekExecutionStatus() < 0); } else { @@ -195,7 +195,7 @@ class Event : public BaseObject<_cl_event>, public IDNode { } } - bool peekIsSubmitted(const int32_t *executionStatusSnapshot = nullptr) { + bool peekIsSubmitted(const int32_t *executionStatusSnapshot = nullptr) const { if (executionStatusSnapshot == nullptr) { return (peekExecutionStatus() == CL_SUBMITTED); } else { @@ -221,7 +221,7 @@ class Event : public BaseObject<_cl_event>, public IDNode { return (CL_COMMAND_USER == cmdType); } - bool isEventWithoutCommand() { + bool isEventWithoutCommand() const { return eventWithoutCommand; } @@ -239,7 +239,7 @@ class Event : public BaseObject<_cl_event>, public IDNode { virtual uint32_t getTaskLevel(); - cl_int peekExecutionStatus() { + cl_int peekExecutionStatus() const { return executionStatus; } diff --git a/unit_tests/command_queue/command_queue_hw_tests.cpp b/unit_tests/command_queue/command_queue_hw_tests.cpp index 612ed08b30..8f60568623 100644 --- a/unit_tests/command_queue/command_queue_hw_tests.cpp +++ b/unit_tests/command_queue/command_queue_hw_tests.cpp @@ -331,7 +331,7 @@ HWTEST_F(CommandQueueHwTest, GivenNotCompleteUserEventPassedToEnqueueWhenEventIs auto mockCSR = new MockCsr(executionStamp, *pDevice->executionEnvironment); pDevice->resetCommandStreamReceiver(mockCSR); - UserEvent userEvent(context); + auto userEvent = make_releaseable(context); KernelInfo kernelInfo; MockKernelWithInternals mockKernelWithInternals(*pDevice); auto mockKernel = mockKernelWithInternals.mockKernel; @@ -348,10 +348,10 @@ HWTEST_F(CommandQueueHwTest, GivenNotCompleteUserEventPassedToEnqueueWhenEventIs mockKernel->setPrivateSurface(privateSurface, 10); - cl_event blockedEvent = &userEvent; + cl_event blockedEvent = userEvent.get(); pCmdQ->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr); - userEvent.setStatus(CL_COMPLETE); + userEvent->setStatus(CL_COMPLETE); EXPECT_TRUE(mockCSR->isMadeResident(constantSurface)); EXPECT_TRUE(mockCSR->isMadeResident(privateSurface)); @@ -362,7 +362,6 @@ HWTEST_F(CommandQueueHwTest, GivenNotCompleteUserEventPassedToEnqueueWhenEventIs mockCSR->getMemoryManager()->freeGraphicsMemory(privateSurface); mockCSR->getMemoryManager()->freeGraphicsMemory(printfSurface); mockCSR->getMemoryManager()->freeGraphicsMemory(constantSurface); - pCmdQ->isQueueBlocked(); } typedef CommandQueueHwTest BlockedCommandQueueTest; diff --git a/unit_tests/command_queue/enqueue_kernel_2_tests.cpp b/unit_tests/command_queue/enqueue_kernel_2_tests.cpp index 7b0d2ec25a..2bceb4934e 100644 --- a/unit_tests/command_queue/enqueue_kernel_2_tests.cpp +++ b/unit_tests/command_queue/enqueue_kernel_2_tests.cpp @@ -18,6 +18,7 @@ #include "unit_tests/mocks/mock_command_queue.h" #include "unit_tests/mocks/mock_device_queue.h" #include "unit_tests/mocks/mock_buffer.h" +#include "unit_tests/utilities/base_object_utils.h" using namespace OCLRT; @@ -596,7 +597,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn if (!pDevice->getMemoryManager()->peekForce32BitAllocations()) { testing::internal::CaptureStdout(); - UserEvent userEvent(context); + auto userEvent = make_releaseable(context); SPatchAllocateStatelessPrintfSurface patchData; patchData.Size = 256; @@ -622,7 +623,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn FillValues(); - cl_event blockedEvent = &userEvent; + cl_event blockedEvent = userEvent.get(); auto retVal = pCmdQ->enqueueKernel( mockKernel, workDim, @@ -639,11 +640,10 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn printfAllocation[0] = 8; printfAllocation[1] = 0; - userEvent.setStatus(CL_COMPLETE); + userEvent->setStatus(CL_COMPLETE); std::string output = testing::internal::GetCapturedStdout(); EXPECT_STREQ("test", output.c_str()); - pCmdQ->releaseVirtualEvent(); } } diff --git a/unit_tests/command_queue/enqueue_svm_tests.cpp b/unit_tests/command_queue/enqueue_svm_tests.cpp index 4ad1bd0097..2cb3534b29 100644 --- a/unit_tests/command_queue/enqueue_svm_tests.cpp +++ b/unit_tests/command_queue/enqueue_svm_tests.cpp @@ -100,7 +100,6 @@ TEST_F(EnqueueSvmTest, enqueueSVMMapBlockedOnEvent_Success) { nullptr // cl_event *event ); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EnqueueSvmTest, enqueueSVMUnmap_InvalidValue) { @@ -134,7 +133,6 @@ TEST_F(EnqueueSvmTest, enqueueSVMUnmapBlockedOnEvent_Success) { nullptr // cl_event *event ); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EnqueueSvmTest, enqueueSVMFreeWithoutCallback_Success) { @@ -235,7 +233,6 @@ TEST_F(EnqueueSvmTest, enqueueSVMFreeBlockedOnEvent_Success) { nullptr // cl_event *event ); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EnqueueSvmTest, enqueueSVMMemcpy_InvalidValueDstPtrIsNull) { @@ -306,8 +303,8 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemcpyBlocking_Success) { TEST_F(EnqueueSvmTest, enqueueSVMMemcpyBlockedOnEvent_Success) { void *pDstSVM = ptrSVM; void *pSrcSVM = context->getSVMAllocsManager()->createSVMAlloc(256, false, false); - UserEvent uEvent; - cl_event eventWaitList[] = {&uEvent}; + auto uEvent = make_releaseable(); + cl_event eventWaitList[] = {uEvent.get()}; retVal = this->pCmdQ->enqueueSVMMemcpy( false, // cl_bool blocking_copy pDstSVM, // void *dst_ptr @@ -319,7 +316,7 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemcpyBlockedOnEvent_Success) { ); EXPECT_EQ(CL_SUCCESS, retVal); context->getSVMAllocsManager()->freeSVMAlloc(pSrcSVM); - pCmdQ->releaseVirtualEvent(); + uEvent->setStatus(-1); } TEST_F(EnqueueSvmTest, enqueueSVMMemcpyCoherent_Success) { @@ -341,8 +338,8 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemcpyCoherent_Success) { TEST_F(EnqueueSvmTest, enqueueSVMMemcpyCoherentBlockedOnEvent_Success) { void *pDstSVM = ptrSVM; void *pSrcSVM = context->getSVMAllocsManager()->createSVMAlloc(256, true, false); - UserEvent uEvent; - cl_event eventWaitList[] = {&uEvent}; + auto uEvent = make_releaseable(); + cl_event eventWaitList[] = {uEvent.get()}; retVal = this->pCmdQ->enqueueSVMMemcpy( false, // cl_bool blocking_copy pDstSVM, // void *dst_ptr @@ -354,7 +351,7 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemcpyCoherentBlockedOnEvent_Success) { ); EXPECT_EQ(CL_SUCCESS, retVal); context->getSVMAllocsManager()->freeSVMAlloc(pSrcSVM); - pCmdQ->releaseVirtualEvent(); + uEvent->setStatus(-1); } TEST_F(EnqueueSvmTest, enqueueSVMMemFill_InvalidValue) { @@ -391,8 +388,8 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemFill_Success) { TEST_F(EnqueueSvmTest, enqueueSVMMemFillBlockedOnEvent_Success) { const float pattern[1] = {1.2345f}; const size_t patternSize = sizeof(pattern); - UserEvent uEvent; - cl_event eventWaitList[] = {&uEvent}; + auto uEvent = make_releaseable(); + cl_event eventWaitList[] = {uEvent.get()}; retVal = this->pCmdQ->enqueueSVMMemFill( ptrSVM, // void *svm_ptr pattern, // const void *pattern @@ -403,7 +400,7 @@ TEST_F(EnqueueSvmTest, enqueueSVMMemFillBlockedOnEvent_Success) { nullptr // cL_event *event ); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); + uEvent->setStatus(-1); } TEST_F(EnqueueSvmTest, enqueueSVMMemFillDoubleToReuseAllocation_Success) { @@ -498,8 +495,8 @@ TEST_F(EnqueueSvmTest, givenEnqueueTaskBlockedOnUserEventWhenItIsEnqueuedThenSur kernel->setKernelExecInfo(pSvmAlloc); - UserEvent uEvent; - cl_event eventWaitList[] = {&uEvent}; + auto uEvent = make_releaseable(); + cl_event eventWaitList[] = {uEvent.get()}; size_t offset = 0; size_t size = 1; retVal = this->pCmdQ->enqueueKernel( @@ -520,7 +517,7 @@ TEST_F(EnqueueSvmTest, givenEnqueueTaskBlockedOnUserEventWhenItIsEnqueuedThenSur delete surface; EXPECT_EQ(1u, kernel->getKernelSvmGfxAllocations().size()); - pCmdQ->releaseVirtualEvent(); + uEvent->setStatus(-1); } TEST_F(EnqueueSvmTest, concurentMapAccess) { diff --git a/unit_tests/event/event_builder_tests.cpp b/unit_tests/event/event_builder_tests.cpp index 6cff60f9f5..8abc6a52f8 100644 --- a/unit_tests/event/event_builder_tests.cpp +++ b/unit_tests/event/event_builder_tests.cpp @@ -68,7 +68,7 @@ TEST(EventBuilder, whenCreatingNewEventForwardsArgumentsToEventConstructor) { finalizedEvent->release(); } -TEST(EventBuilder, givenVirtualEvenWhenVirtualEventWithCommandIsAddedThenFinilizeAddChild) { +TEST(EventBuilder, givenVirtualEventWithCommandThenFinalizeAddChild) { using UniqueIH = std::unique_ptr; class MockCommandComputeKernel : public CommandComputeKernel { public: @@ -112,7 +112,7 @@ TEST(EventBuilder, givenVirtualEvenWhenVirtualEventWithCommandIsAddedThenFiniliz peekedEvent->release(); } -TEST(EventBuilder, givenVirtualEvenWhenVirtualEventWithSubmittedCommandIsAddedThenFinilizeNotChild) { +TEST(EventBuilder, givenVirtualEventWithSubmittedCommandAsParentThenFinalizeNotAddChild) { class MockVirtualEvent : public VirtualEvent { public: using VirtualEvent::eventWithoutCommand; diff --git a/unit_tests/event/event_fixture.h b/unit_tests/event/event_fixture.h index 5802ae0cdc..a277c92eff 100644 --- a/unit_tests/event/event_fixture.h +++ b/unit_tests/event/event_fixture.h @@ -16,7 +16,9 @@ #include "unit_tests/mocks/mock_buffer.h" #include "unit_tests/mocks/mock_context.h" #include "unit_tests/fixtures/device_fixture.h" +#include "unit_tests/fixtures/hello_world_fixture.h" #include "unit_tests/indirect_heap/indirect_heap_fixture.h" +#include "unit_tests/utilities/base_object_utils.h" #include "gtest/gtest.h" using namespace OCLRT; @@ -117,3 +119,15 @@ struct MyEvent : public Event { uint64_t globalStartTimestamp; }; + +class MockEventTests : public HelloWorldTest { + public: + void TearDown() { + uEvent->setStatus(-1); + uEvent.reset(); + HelloWorldFixture::TearDown(); + } + + protected: + ReleaseableObjectPtr uEvent; +}; diff --git a/unit_tests/event/user_events_tests.cpp b/unit_tests/event/user_events_tests.cpp index 3a44dacf7f..fcfcbda693 100644 --- a/unit_tests/event/user_events_tests.cpp +++ b/unit_tests/event/user_events_tests.cpp @@ -7,10 +7,8 @@ #include "event_fixture.h" #include "unit_tests/command_queue/enqueue_fixture.h" -#include "unit_tests/fixtures/hello_world_fixture.h" #include "unit_tests/helpers/debug_manager_state_restore.h" #include "unit_tests/mocks/mock_event.h" -#include "unit_tests/utilities/base_object_utils.h" #include "runtime/memory_manager/internal_allocation_storage.h" #include "runtime/memory_manager/memory_manager.h" #include "runtime/os_interface/os_context.h" @@ -166,10 +164,10 @@ TEST(UserEvent, givenUserEventWhenStatusIsCompletedThenReturnZeroTaskLevel) { typedef HelloWorldTest EventTests; -TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeWithoutReturnEventIsNotSubmittedToCSR) { - UserEvent uEvent; +TEST_F(MockEventTests, blockedUserEventPassedToEnqueueNdRangeWithoutReturnEventIsNotSubmittedToCSR) { + uEvent = make_releaseable(); - cl_event userEvent = (cl_event)&uEvent; + cl_event userEvent = uEvent.get(); cl_event *eventWaitList = &userEvent; auto &csr = pCmdQ->getCommandStreamReceiver(); @@ -196,13 +194,12 @@ TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeWithoutReturnEventIsNot EXPECT_EQ(taskCountAfter, taskCount); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeWithReturnEventIsNotSubmittedToCSR) { - UserEvent uEvent; +TEST_F(MockEventTests, blockedUserEventPassedToEnqueueNdRangeWithReturnEventIsNotSubmittedToCSR) { + uEvent = make_releaseable(); - cl_event userEvent = (cl_event)&uEvent; + cl_event userEvent = uEvent.get(); cl_event retEvent = nullptr; cl_event *eventWaitList = &userEvent; @@ -240,14 +237,12 @@ TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeWithReturnEventIsNotSub retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, userEventInjectsCountOnReturnEventAndCreatesConnection) { +TEST_F(MockEventTests, userEventInjectsCountOnReturnEventAndCreatesConnection) { + uEvent = make_releaseable(); - UserEvent uEvent; - cl_event userEvent = (cl_event)&uEvent; + cl_event userEvent = uEvent.get(); cl_event retEvent = nullptr; cl_event *eventWaitList = &userEvent; @@ -261,15 +256,14 @@ TEST_F(EventTests, userEventInjectsCountOnReturnEventAndCreatesConnection) { EXPECT_EQ(1U, returnEvent->peekNumEventsBlockingThis()); //check if user event knows his childs - EXPECT_TRUE(uEvent.peekHasChildEvents()); + EXPECT_TRUE(uEvent->peekHasChildEvents()); //make sure that proper event is set as child Event *childEvent = pCmdQ->virtualEvent; - EXPECT_EQ(childEvent, uEvent.peekChildEvents()->ref); + EXPECT_EQ(childEvent, uEvent->peekChildEvents()->ref); auto retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, givenNormalEventThatHasParentUserEventWhenUserEventIsUnblockedThenChildEventIsCompleteIfGpuCompletedProcessing) { @@ -284,13 +278,12 @@ TEST_F(EventTests, givenNormalEventThatHasParentUserEventWhenUserEventIsUnblocke EXPECT_EQ(CL_COMPLETE, event.peekExecutionStatus()); } -TEST_F(EventTests, twoUserEventInjectsCountOnReturnEventAndCreatesConnection) { - - UserEvent uEvent; - UserEvent uEvent2; +TEST_F(MockEventTests, twoUserEventInjectsCountOnReturnEventAndCreatesConnection) { + uEvent = make_releaseable(); + auto uEvent2 = make_releaseable(); cl_event retEvent = nullptr; - cl_event eventWaitList[] = {&uEvent, &uEvent2}; + cl_event eventWaitList[] = {uEvent.get(), uEvent2.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -302,37 +295,37 @@ TEST_F(EventTests, twoUserEventInjectsCountOnReturnEventAndCreatesConnection) { ASSERT_EQ(2U, returnEvent->peekNumEventsBlockingThis()); //check if user event knows his childs - EXPECT_TRUE(uEvent.peekHasChildEvents()); + EXPECT_TRUE(uEvent->peekHasChildEvents()); //check if user event knows his childs - EXPECT_TRUE(uEvent2.peekHasChildEvents()); + EXPECT_TRUE(uEvent2->peekHasChildEvents()); //make sure that proper event is set as child Event *childEvent = pCmdQ->virtualEvent; - EXPECT_EQ(childEvent, uEvent.peekChildEvents()->ref); + EXPECT_EQ(childEvent, uEvent->peekChildEvents()->ref); EXPECT_FALSE(childEvent->isReadyForSubmission()); //make sure that proper event is set as child - EXPECT_EQ(childEvent, uEvent2.peekChildEvents()->ref); + EXPECT_EQ(childEvent, uEvent2->peekChildEvents()->ref); //signal one user event, child event after this operation isn't be ready for submission - uEvent.setStatus(0); + uEvent->setStatus(0); //check if user event knows his childs - EXPECT_FALSE(uEvent.peekHasChildEvents()); + EXPECT_FALSE(uEvent->peekHasChildEvents()); EXPECT_EQ(1U, returnEvent->peekNumEventsBlockingThis()); EXPECT_FALSE(returnEvent->isReadyForSubmission()); auto retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); + + uEvent2->setStatus(-1); } -TEST_F(EventTests, twoUserEventInjectsCountOnNDR1whichIsPropagatedToNDR2viaVirtualEvent) { +TEST_F(MockEventTests, twoUserEventInjectsCountOnNDR1whichIsPropagatedToNDR2viaVirtualEvent) { + uEvent = make_releaseable(context); + auto uEvent2 = make_releaseable(context); - UserEvent uEvent(context); - UserEvent uEvent2(context); - - cl_event eventWaitList[] = {&uEvent, &uEvent2}; + cl_event eventWaitList[] = {uEvent.get(), uEvent2.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR, no return Event @@ -345,17 +338,17 @@ TEST_F(EventTests, twoUserEventInjectsCountOnNDR1whichIsPropagatedToNDR2viaVirtu ASSERT_EQ(2U, returnEvent1->peekNumEventsBlockingThis()); //check if user event knows his childs - EXPECT_TRUE(uEvent.peekHasChildEvents()); + EXPECT_TRUE(uEvent->peekHasChildEvents()); //check if user event knows his childs - EXPECT_TRUE(uEvent2.peekHasChildEvents()); + EXPECT_TRUE(uEvent2->peekHasChildEvents()); //make sure that proper event is set as child Event *childEvent = pCmdQ->virtualEvent; - EXPECT_EQ(childEvent, uEvent.peekChildEvents()->ref); + EXPECT_EQ(childEvent, uEvent->peekChildEvents()->ref); //make sure that proper event is set as child - EXPECT_EQ(childEvent, uEvent2.peekChildEvents()->ref); + EXPECT_EQ(childEvent, uEvent2->peekChildEvents()->ref); //call NDR, no events, Virtual Event mustn't leak and will be bind to previous Virtual Event retVal = callOneWorkItemNDRKernel(); @@ -371,8 +364,8 @@ TEST_F(EventTests, twoUserEventInjectsCountOnNDR1whichIsPropagatedToNDR2viaVirtu EXPECT_EQ(returnEvent2, returnEvent1->peekChildEvents()->ref); //now signal both parents and see if all childs are notified - uEvent.setStatus(CL_COMPLETE); - uEvent2.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); + uEvent2->setStatus(CL_COMPLETE); //queue shoud be in unblocked state EXPECT_EQ(pCmdQ->isQueueBlocked(), false); @@ -398,35 +391,35 @@ TEST_F(EventTests, givenQueueThatIsBlockedByUserEventWhenIsQueueBlockedIsCalledT pCmdQ->virtualEvent = nullptr; } -TEST_F(EventTests, finishDoesntBlockAfterUserEventSignaling) { - UserEvent uEvent(context); - UserEvent uEvent2(context); +TEST_F(MockEventTests, finishDoesntBlockAfterUserEventSignaling) { + uEvent = make_releaseable(context); + auto uEvent2 = make_releaseable(context); - cl_event eventWaitList[] = {&uEvent, &uEvent2}; + cl_event eventWaitList[] = {uEvent.get(), uEvent2.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR, no return Event auto retVal = callOneWorkItemNDRKernel(eventWaitList, sizeOfWaitList, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); - uEvent.setStatus(0); - uEvent2.setStatus(0); + uEvent->setStatus(0); + uEvent2->setStatus(0); retVal = clFinish(pCmdQ); EXPECT_EQ(CL_SUCCESS, retVal); } -TEST_F(EventTests, userEventStatusPropagatedToNormalEvent) { - UserEvent uEvent; +TEST_F(MockEventTests, userEventStatusPropagatedToNormalEvent) { + uEvent = make_releaseable(); cl_event retEvent = nullptr; - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR callOneWorkItemNDRKernel(eventWaitList, sizeOfWaitList, &retEvent); //set user event status - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); //wait for returend event, this should return with success. auto retVal = clWaitForEvents(1, &retEvent); @@ -434,7 +427,6 @@ TEST_F(EventTests, userEventStatusPropagatedToNormalEvent) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } HWTEST_F(EventTests, userEventObtainsProperTaskLevelAfterSignaling) { @@ -454,13 +446,13 @@ HWTEST_F(EventTests, userEventObtainsProperTaskLevelAfterSignaling) { EXPECT_EQ(0u, uEvent.taskLevel); } -TEST_F(EventTests, normalEventsBasingOnUserEventHasProperTaskLevel) { - UserEvent uEvent(context); +TEST_F(MockEventTests, normalEventsBasingOnUserEventHasProperTaskLevel) { + uEvent = make_releaseable(context); auto &csr = pCmdQ->getCommandStreamReceiver(); auto taskLevel = csr.peekTaskLevel(); cl_event retEvent = nullptr; - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -473,7 +465,7 @@ TEST_F(EventTests, normalEventsBasingOnUserEventHasProperTaskLevel) { EXPECT_EQ(Event::eventNotReady, returnEvent->peekTaskCount()); //now set user event for complete status, this triggers update of childs. - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); //child event should have the same taskLevel as parentEvent, as parent event is top of the tree and doesn't have any commands. EXPECT_EQ(returnEvent->taskLevel, taskLevel); @@ -481,14 +473,13 @@ TEST_F(EventTests, normalEventsBasingOnUserEventHasProperTaskLevel) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, waitForEventThatWaitsOnSignaledUserEvent) { - UserEvent uEvent(context); +TEST_F(MockEventTests, waitForEventThatWaitsOnSignaledUserEvent) { + uEvent = make_releaseable(context); cl_event retEvent = nullptr; - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -500,14 +491,13 @@ TEST_F(EventTests, waitForEventThatWaitsOnSignaledUserEvent) { EXPECT_EQ(Event::eventNotReady, returnEvent->taskLevel); //now set user event for complete status, this triggers update of childs. - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); retVal = clWaitForEvents(1, &retEvent); EXPECT_EQ(CL_SUCCESS, retVal); retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, waitForAbortedUserEventReturnsFailure) { @@ -522,10 +512,10 @@ TEST_F(EventTests, waitForAbortedUserEventReturnsFailure) { EXPECT_EQ(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, retVal); } -TEST_F(EventTests, enqueueWithAbortedUserEventDoesntFlushToCSR) { - UserEvent uEvent(context); +TEST_F(MockEventTests, enqueueWithAbortedUserEventDoesntFlushToCSR) { + uEvent = make_releaseable(context); - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent = nullptr; @@ -537,7 +527,7 @@ TEST_F(EventTests, enqueueWithAbortedUserEventDoesntFlushToCSR) { EXPECT_EQ(CL_SUCCESS, retVal); //negative values indicate abortion - uEvent.setStatus(-1); + uEvent->setStatus(-1); auto taskCountAfter = csr.peekTaskCount(); @@ -553,13 +543,12 @@ TEST_F(EventTests, enqueueWithAbortedUserEventDoesntFlushToCSR) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, childEventDestructorDoesntProcessBlockedCommandsWhenParentEventWasAborted) { - UserEvent uEvent(context); +TEST_F(MockEventTests, childEventDestructorDoesntProcessBlockedCommandsWhenParentEventWasAborted) { + uEvent = make_releaseable(context); - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent = nullptr; @@ -575,7 +564,7 @@ TEST_F(EventTests, childEventDestructorDoesntProcessBlockedCommandsWhenParentEve EXPECT_EQ(CL_SUCCESS, retVal); //negative values indicate abortion - uEvent.setStatus(-1); + uEvent->setStatus(-1); auto taskCountAfter = csr.peekTaskCount(); @@ -594,13 +583,12 @@ TEST_F(EventTests, childEventDestructorDoesntProcessBlockedCommandsWhenParentEve taskCountAfter = csr.peekTaskCount(); EXPECT_EQ(taskCount, taskCountAfter); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, waitForEventDependingOnAbortedUserEventReturnsFailure) { - UserEvent uEvent(context); +TEST_F(MockEventTests, waitForEventDependingOnAbortedUserEventReturnsFailure) { + uEvent = make_releaseable(context); - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent = nullptr; @@ -609,7 +597,7 @@ TEST_F(EventTests, waitForEventDependingOnAbortedUserEventReturnsFailure) { EXPECT_EQ(CL_SUCCESS, retVal); //negative values indicate abortion - uEvent.setStatus(-1); + uEvent->setStatus(-1); eventWaitList[0] = retEvent; @@ -618,13 +606,12 @@ TEST_F(EventTests, waitForEventDependingOnAbortedUserEventReturnsFailure) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, waitForEventDependingOnAbortedUserEventReturnsFailureTwoInputEvents) { - UserEvent uEvent(context); - UserEvent uEvent2(context); - cl_event eventWaitList[] = {&uEvent, &uEvent2}; +TEST_F(MockEventTests, waitForEventDependingOnAbortedUserEventReturnsFailureTwoInputEvents) { + uEvent = make_releaseable(context); + auto uEvent2 = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get(), uEvent2.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent = nullptr; @@ -633,25 +620,25 @@ TEST_F(EventTests, waitForEventDependingOnAbortedUserEventReturnsFailureTwoInput EXPECT_EQ(CL_SUCCESS, retVal); //negative values indicate abortion - uEvent.setStatus(-1); + uEvent->setStatus(-1); eventWaitList[0] = retEvent; retVal = clWaitForEvents(sizeOfWaitList, eventWaitList); EXPECT_EQ(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, retVal); + uEvent2->setStatus(-1); retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, finishReturnsSuccessAfterQueueIsAborted) { - UserEvent uEvent(context); +TEST_F(MockEventTests, finishReturnsSuccessAfterQueueIsAborted) { + uEvent = make_releaseable(context); auto &csr = pCmdQ->getCommandStreamReceiver(); auto taskLevel = csr.peekTaskLevel(); - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -659,19 +646,18 @@ TEST_F(EventTests, finishReturnsSuccessAfterQueueIsAborted) { EXPECT_EQ(CL_SUCCESS, retVal); //negative values indicate abortion - uEvent.setStatus(-1); + uEvent->setStatus(-1); //make sure we didn't asked CSR for task level for this event, as it is aborted - EXPECT_NE(taskLevel, uEvent.taskLevel); + EXPECT_NE(taskLevel, uEvent->taskLevel); retVal = clFinish(pCmdQ); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, userEventRecordsDependantPacket) { - UserEvent uEvent(context); - cl_event eventWaitList[] = {&uEvent}; +TEST_F(MockEventTests, userEventRecordsDependantPacket) { + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -681,12 +667,11 @@ TEST_F(EventTests, userEventRecordsDependantPacket) { ASSERT_NE(nullptr, pCmdQ->virtualEvent); EXPECT_NE(nullptr, pCmdQ->virtualEvent->peekCommand()); EXPECT_FALSE(pCmdQ->virtualEvent->peekIsCmdSubmitted()); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, userEventDependantCommandPacketContainsValidCommandStream) { - UserEvent uEvent(context); - cl_event eventWaitList[] = {&uEvent}; +TEST_F(MockEventTests, userEventDependantCommandPacketContainsValidCommandStream) { + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -696,15 +681,14 @@ TEST_F(EventTests, userEventDependantCommandPacketContainsValidCommandStream) { ASSERT_NE(nullptr, pCmdQ->virtualEvent); auto cmd = static_cast(pCmdQ->virtualEvent->peekCommand()); EXPECT_NE(0u, cmd->getCommandStream()->getUsed()); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, unblockingEventSendsBlockedPackets) { - UserEvent uEvent(context); +TEST_F(MockEventTests, unblockingEventSendsBlockedPackets) { + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; auto &csr = pCmdQ->getCommandStreamReceiver(); - cl_event eventWaitList[] = {&uEvent}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -723,16 +707,14 @@ TEST_F(EventTests, unblockingEventSendsBlockedPackets) { EXPECT_NE(nullptr, childEvent->peekCommand()); //signal the input user event - uEvent.setStatus(0); + uEvent->setStatus(0); EXPECT_EQ(csr.peekTaskLevel(), 1u); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, virtualEventObtainedFromReturnedEventCannotBeReleasedByIsQueueBlocked) { - UserEvent uEvent(context); - - cl_event eventWaitList[] = {&uEvent}; +TEST_F(MockEventTests, virtualEventObtainedFromReturnedEventCannotBeReleasedByIsQueueBlocked) { + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent; @@ -740,7 +722,7 @@ TEST_F(EventTests, virtualEventObtainedFromReturnedEventCannotBeReleasedByIsQueu retVal = callOneWorkItemNDRKernel(eventWaitList, sizeOfWaitList, &retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - uEvent.setStatus(0); + uEvent->setStatus(0); //call finish multiple times retVal |= clFinish(pCmdQ); retVal |= clFinish(pCmdQ); @@ -752,13 +734,11 @@ TEST_F(EventTests, virtualEventObtainedFromReturnedEventCannotBeReleasedByIsQueu EXPECT_EQ(nullptr, pCmdQ->virtualEvent); retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, userEventsDoesntChangeCommandStreamWhileEnqueueButDoesAfterSignaling) { - UserEvent uEvent(context); - - cl_event eventWaitList[] = {&uEvent}; +TEST_F(MockEventTests, userEventsDoesntChangeCommandStreamWhileEnqueueButDoesAfterSignaling) { + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); cl_event retEvent; @@ -773,7 +753,7 @@ TEST_F(EventTests, userEventsDoesntChangeCommandStreamWhileEnqueueButDoesAfterSi EXPECT_EQ(used2, used); - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); auto used3 = cs.getSpace(0); @@ -785,7 +765,6 @@ TEST_F(EventTests, userEventsDoesntChangeCommandStreamWhileEnqueueButDoesAfterSi retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, givenUserEventThatHasCallbackAndBlockQueueWhenQueueIsQueriedForBlockedThenCallBackIsCalled) { @@ -865,7 +844,6 @@ TEST_F(EventTests, CallBackAfterEnqueue) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, CallBackAfterEnqueueWithoutWait) { @@ -894,13 +872,12 @@ TEST_F(EventTests, CallBackAfterEnqueueWithoutWait) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } -TEST_F(EventTests, enqueueReadImageBlockedOnUserEvent) { +TEST_F(MockEventTests, enqueueReadImageBlockedOnUserEvent) { cl_event retEvent; - UserEvent userEvent(this->context); - cl_event events[] = {&userEvent}; + uEvent = make_releaseable(context); + cl_event eventWaitList[] = {uEvent.get()}; auto image = clUniquePtr(Image2dHelper<>::create(this->context)); ASSERT_NE(nullptr, image); @@ -914,11 +891,11 @@ TEST_F(EventTests, enqueueReadImageBlockedOnUserEvent) { EnqueueReadImageTraits::slicePitch, EnqueueReadImageTraits::hostPtr, 1, - events, + eventWaitList, &retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - retVal = clSetUserEventStatus(&userEvent, CL_COMPLETE); + retVal = clSetUserEventStatus(uEvent.get(), CL_COMPLETE); ASSERT_EQ(CL_SUCCESS, retVal); retVal = clWaitForEvents(1, &retEvent); @@ -926,7 +903,6 @@ TEST_F(EventTests, enqueueReadImageBlockedOnUserEvent) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, waitForEventsDestroysTemporaryAllocations) { @@ -1021,7 +997,6 @@ TEST_F(EventTests, WhenCalbackWasRegisteredOnCallbackExecutionPassesCorrectExecu EXPECT_EQ(CL_COMPLETE, completeClbExecStatus); clReleaseEvent(retEvent); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, eventOnQueryReturnsCorrentNumberOfBlockerEvents) { @@ -1061,7 +1036,6 @@ TEST_F(EventTests, eventOnQueryReturnsCorrentNumberOfBlockerEvents) { retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeDoesntRetainCommandQueue) { diff --git a/unit_tests/event/user_events_tests_mt.cpp b/unit_tests/event/user_events_tests_mt.cpp index 6bd6b0d11d..3684e7184f 100644 --- a/unit_tests/event/user_events_tests_mt.cpp +++ b/unit_tests/event/user_events_tests_mt.cpp @@ -7,17 +7,16 @@ #include "event_fixture.h" #include "unit_tests/fixtures/buffer_fixture.h" -#include "unit_tests/fixtures/hello_world_fixture.h" #include "runtime/memory_manager/memory_manager.h" #include typedef HelloWorldTest EventTests; -TEST_F(EventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) { - UserEvent uEvent; +TEST_F(MockEventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) { + uEvent = make_releaseable(); cl_event retEvent = nullptr; - cl_event eventWaitList[] = {&uEvent}; + cl_event eventWaitList[] = {uEvent.get()}; int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event); //call NDR @@ -53,12 +52,11 @@ TEST_F(EventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) EXPECT_EQ(taskLevelBeforeWaitForEvents, csr.peekTaskLevel()); //set event to CL_COMPLETE - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); t.join(); retVal = clReleaseEvent(retEvent); EXPECT_EQ(CL_SUCCESS, retVal); - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsCompletedAfterBlockedPathIsChosenThenBlockingFlagDoesNotCauseStall) { @@ -80,7 +78,6 @@ TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsC t.join(); } - pCmdQ->releaseVirtualEvent(); } TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsCompletedAfterUpdateFromCompletionStampThenBlockingFlagDoesNotCauseStall) { @@ -108,5 +105,4 @@ TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsC auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), sizeOfWaitList, eventWaitList, nullptr); EXPECT_EQ(CL_SUCCESS, retVal); t.join(); - pCmdQ->releaseVirtualEvent(); } diff --git a/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp b/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp index a1ed87ef15..34cc842a40 100644 --- a/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp +++ b/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp @@ -22,6 +22,7 @@ #include "unit_tests/mocks/mock_event.h" #include "unit_tests/mocks/mock_mdi.h" #include "unit_tests/mocks/mock_submissions_aggregator.h" +#include "unit_tests/utilities/base_object_utils.h" using namespace OCLRT; @@ -131,15 +132,14 @@ HWTEST_P(ParentKernelEnqueueTest, GivenBlocksWithPrivateMemoryWhenEnqueueKernelT auto privateAllocation = csr.getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}); blockKernelManager->pushPrivateSurface(privateAllocation, 0); - UserEvent uEvent(pContext); - auto clEvent = static_cast(&uEvent); + auto uEvent = make_releaseable(pContext); + auto clEvent = static_cast(uEvent.get()); pCmdQ->enqueueKernel(pKernel, 1, offset, gws, gws, 1, &clEvent, nullptr); EXPECT_FALSE(csr.isMadeResident(privateAllocation)); - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); EXPECT_TRUE(csr.isMadeResident(privateAllocation)); - pCmdQ->releaseVirtualEvent(); } } @@ -185,8 +185,8 @@ HWTEST_P(ParentKernelEnqueueTest, GivenParentKernelWithBlocksWhenEnqueueKernelTh auto &csr = pDevice->getUltCommandStreamReceiver(); csr.storeMakeResidentAllocations = true; - UserEvent uEvent(pContext); - auto clEvent = static_cast(&uEvent); + auto uEvent = make_releaseable(pContext); + auto clEvent = static_cast(uEvent.get()); pCmdQ->enqueueKernel(pKernel, 1, offset, gws, gws, 1, &clEvent, nullptr); @@ -195,12 +195,11 @@ HWTEST_P(ParentKernelEnqueueTest, GivenParentKernelWithBlocksWhenEnqueueKernelTh EXPECT_FALSE(csr.isMadeResident(blockKernelManager->getBlockKernelInfo(blockId)->getGraphicsAllocation())); } - uEvent.setStatus(CL_COMPLETE); + uEvent->setStatus(CL_COMPLETE); for (auto blockId = 0u; blockId < blockCount; blockId++) { EXPECT_TRUE(csr.isMadeResident(blockKernelManager->getBlockKernelInfo(blockId)->getGraphicsAllocation())); } - pCmdQ->releaseVirtualEvent(); } } @@ -332,14 +331,13 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenBlockedQueueWhenParent // Acquire CS to check if reset queue was called mockDevQueue.acquireEMCriticalSection(); - MockEvent mockEvent(context); + auto mockEvent = make_releaseable(context); - cl_event eventBlocking = &mockEvent; + cl_event eventBlocking = mockEvent.get(); pCmdQ->enqueueKernel(pKernel, 1, globalOffsets, workItems, workItems, 1, &eventBlocking, nullptr); EXPECT_FALSE(mockDevQueue.isEMCriticalSectionFree()); - pCmdQ->releaseVirtualEvent(); } } @@ -495,15 +493,15 @@ HWTEST_F(ParentKernelEnqueueFixture, GivenParentKernelWhenEnqueuedToBlockedQueue size_t gws[3] = {1, 1, 1}; DeviceQueueHw *pDevQueueHw = castToObject>(pDevQueue); - MockEvent mockEvent(context); - cl_event eventBlocking = &mockEvent; + auto mockEvent = make_releaseable>(context); + cl_event eventBlocking = mockEvent.get(); EXPECT_TRUE(pDevQueueHw->isEMCriticalSectionFree()); pCmdQ->enqueueKernel(parentKernel, 1, offset, gws, gws, 1, &eventBlocking, nullptr); EXPECT_TRUE(pDevQueueHw->isEMCriticalSectionFree()); - pCmdQ->releaseVirtualEvent(); + mockEvent->setStatus(-1); } } diff --git a/unit_tests/fixtures/hello_world_fixture.h b/unit_tests/fixtures/hello_world_fixture.h index f5295ac5c0..f88fef4684 100644 --- a/unit_tests/fixtures/hello_world_fixture.h +++ b/unit_tests/fixtures/hello_world_fixture.h @@ -105,7 +105,7 @@ struct HelloWorldFixture : public FixtureFactory::IndirectHeapFixture, IndirectHeapFixture::TearDown(); CommandStreamFixture::TearDown(); CommandQueueFixture::TearDown(); - delete BufferDefaults::context; + BufferDefaults::context->release(); DeviceFixture::TearDown(); } Buffer *srcBuffer; diff --git a/unit_tests/mocks/mock_context.cpp b/unit_tests/mocks/mock_context.cpp index 67862ad3d0..2e52983fbd 100644 --- a/unit_tests/mocks/mock_context.cpp +++ b/unit_tests/mocks/mock_context.cpp @@ -47,7 +47,7 @@ MockContext::MockContext( MockContext::~MockContext() { if (specialQueue) { - delete specialQueue; + specialQueue->release(); specialQueue = nullptr; } if (memoryManager->isAsyncDeleterEnabled()) { diff --git a/unit_tests/utilities/base_object_utils.h b/unit_tests/utilities/base_object_utils.h index 9a7c5c445f..422d7a3ee5 100644 --- a/unit_tests/utilities/base_object_utils.h +++ b/unit_tests/utilities/base_object_utils.h @@ -26,4 +26,9 @@ template static ReleaseableObjectPtr clUniquePtr(T *object) { return ReleaseableObjectPtr{object}; } + +template +inline ReleaseableObjectPtr<_Ty> make_releaseable(_Types &&... _Args) { + return (ReleaseableObjectPtr<_Ty>(new _Ty(std::forward<_Types>(_Args)...))); +} } // namespace OCLRT