Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add RAII for cl_objects 

- add removeVirtualEvent to cmdQueue fixture
- add const keyword in event functions

Change-Id: I11354eb8fceb15ae2c58bddd327863a15aab6393
This commit is contained in:
Kamil Diedrich 2019-02-06 08:49:35 +01:00 committed by sys_ocldev
parent 9f6eab0689
commit a7b46ccdbd
13 changed files with 160 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/command_queue/command_queue.h
View File

@ -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 <atomic>
#include <cstdint>

8
runtime/event/event.h
View File

@ -187,7 +187,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
// 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<Event> {
}
}
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<Event> {
return (CL_COMMAND_USER == cmdType);
}
bool isEventWithoutCommand() {
bool isEventWithoutCommand() const {
return eventWithoutCommand;
}
@ -239,7 +239,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
virtual uint32_t getTaskLevel();
cl_int peekExecutionStatus() {
cl_int peekExecutionStatus() const {
return executionStatus;
}

7
unit_tests/command_queue/command_queue_hw_tests.cpp
View File

@ -331,7 +331,7 @@ HWTEST_F(CommandQueueHwTest, GivenNotCompleteUserEventPassedToEnqueueWhenEventIs
auto mockCSR = new MockCsr<FamilyType>(executionStamp, *pDevice->executionEnvironment);
pDevice->resetCommandStreamReceiver(mockCSR);
UserEvent userEvent(context);
auto userEvent = make_releaseable<UserEvent>(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;

8
unit_tests/command_queue/enqueue_kernel_2_tests.cpp
View File

@ -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<UserEvent>(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();
}
}

27
unit_tests/command_queue/enqueue_svm_tests.cpp
View File

@ -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<UserEvent>();
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<UserEvent>();
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<UserEvent>();
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<UserEvent>();
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) {

4
unit_tests/event/event_builder_tests.cpp
View File

@ -68,7 +68,7 @@ TEST(EventBuilder, whenCreatingNewEventForwardsArgumentsToEventConstructor) {
finalizedEvent->release();
}
TEST(EventBuilder, givenVirtualEvenWhenVirtualEventWithCommandIsAddedThenFinilizeAddChild) {
TEST(EventBuilder, givenVirtualEventWithCommandThenFinalizeAddChild) {
using UniqueIH = std::unique_ptr<IndirectHeap>;
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;

14
unit_tests/event/event_fixture.h
View File

@ -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<HelloWorldFixtureFactory> {
public:
void TearDown() {
uEvent->setStatus(-1);
uEvent.reset();
HelloWorldFixture::TearDown();
}
protected:
ReleaseableObjectPtr<UserEvent> uEvent;
};

220
unit_tests/event/user_events_tests.cpp
View File

@ -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<HelloWorldFixtureFactory> EventTests;
TEST_F(EventTests, blockedUserEventPassedToEnqueueNdRangeWithoutReturnEventIsNotSubmittedToCSR) {
UserEvent uEvent;
TEST_F(MockEventTests, blockedUserEventPassedToEnqueueNdRangeWithoutReturnEventIsNotSubmittedToCSR) {
uEvent = make_releaseable<UserEvent>();
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<UserEvent>();
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>();
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<UserEvent>();
auto uEvent2 = make_releaseable<UserEvent>();
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<UserEvent>(context);
auto uEvent2 = make_releaseable<UserEvent>(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<UserEvent>(context);
auto uEvent2 = make_releaseable<UserEvent>(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<UserEvent>();
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<UserEvent>(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<UserEvent>(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<UserEvent>(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<UserEvent>(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<UserEvent>(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<UserEvent>(context);
auto uEvent2 = make_releaseable<UserEvent>(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<UserEvent>(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<UserEvent>(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<UserEvent>(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<CommandComputeKernel *>(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<UserEvent>(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<UserEvent>(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<UserEvent>(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<UserEvent>(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) {

12
unit_tests/event/user_events_tests_mt.cpp
View File

@ -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 <memory>
typedef HelloWorldTest<HelloWorldFixtureFactory> EventTests;
TEST_F(EventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) {
UserEvent uEvent;
TEST_F(MockEventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) {
uEvent = make_releaseable<UserEvent>();
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();
}

26
unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp
View File

@ -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<cl_event>(&uEvent);
auto uEvent = make_releaseable<UserEvent>(pContext);
auto clEvent = static_cast<cl_event>(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<FamilyType>();
csr.storeMakeResidentAllocations = true;
UserEvent uEvent(pContext);
auto clEvent = static_cast<cl_event>(&uEvent);
auto uEvent = make_releaseable<UserEvent>(pContext);
auto clEvent = static_cast<cl_event>(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<UserEvent> mockEvent(context);
auto mockEvent = make_releaseable<UserEvent>(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<FamilyType> *pDevQueueHw = castToObject<DeviceQueueHw<FamilyType>>(pDevQueue);
MockEvent<UserEvent> mockEvent(context);
cl_event eventBlocking = &mockEvent;
auto mockEvent = make_releaseable<MockEvent<UserEvent>>(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);
}
}

2
unit_tests/fixtures/hello_world_fixture.h
View File

@ -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;

2
unit_tests/mocks/mock_context.cpp
View File

@ -47,7 +47,7 @@ MockContext::MockContext(
MockContext::~MockContext() {
if (specialQueue) {
delete specialQueue;
specialQueue->release();
specialQueue = nullptr;
}
if (memoryManager->isAsyncDeleterEnabled()) {

5
unit_tests/utilities/base_object_utils.h
View File

@ -26,4 +26,9 @@ template <typename T>
static ReleaseableObjectPtr<T> clUniquePtr(T *object) {
return ReleaseableObjectPtr<T>{object};
}
template <class _Ty, class... _Types>
inline ReleaseableObjectPtr<_Ty> make_releaseable(_Types &&... _Args) {
return (ReleaseableObjectPtr<_Ty>(new _Ty(std::forward<_Types>(_Args)...)));
}
} // namespace OCLRT