284 lines
11 KiB
C++
284 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2017, Intel Corporation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "runtime/event/event_builder.h"
|
|
#include "runtime/event/user_event.h"
|
|
#include "runtime/utilities/arrayref.h"
|
|
#include "unit_tests/mocks/mock_event.h"
|
|
#include "unit_tests/mocks/mock_context.h"
|
|
#include "unit_tests/mocks/mock_command_queue.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
namespace OCLRT {
|
|
|
|
struct SmallEventBuilderEventMock : MockEvent<Event> {
|
|
SmallEventBuilderEventMock(int param1, float param2)
|
|
: MockEvent<Event>(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0), constructionParam1(param1), constructionParam2(param2) {
|
|
}
|
|
|
|
SmallEventBuilderEventMock()
|
|
: SmallEventBuilderEventMock(1, 2.0f) {
|
|
}
|
|
|
|
void overrideMagic(cl_long newMagic) {
|
|
this->magic = newMagic;
|
|
}
|
|
|
|
int constructionParam1 = 1;
|
|
float constructionParam2 = 2.0f;
|
|
};
|
|
|
|
struct SmallEventBuilderMock : EventBuilder {
|
|
void clear() {
|
|
EventBuilder::clear();
|
|
}
|
|
void clearEvent() {
|
|
event = nullptr;
|
|
}
|
|
|
|
ArrayRef<Event *> getParentEvents() {
|
|
return this->parentEvents;
|
|
}
|
|
};
|
|
|
|
TEST(EventBuilder, whenCreatingNewEventForwardsArgumentsToEventConstructor) {
|
|
EventBuilder eventBuilder;
|
|
EXPECT_EQ(nullptr, eventBuilder.getEvent());
|
|
|
|
constexpr int constrParam1 = 7;
|
|
constexpr float constrParam2 = 13.0f;
|
|
eventBuilder.create<SmallEventBuilderEventMock>(constrParam1, constrParam2);
|
|
Event *peekedEvent = eventBuilder.getEvent();
|
|
ASSERT_NE(nullptr, peekedEvent);
|
|
auto finalizedEvent = static_cast<SmallEventBuilderEventMock *>(eventBuilder.finalizeAndRelease());
|
|
EXPECT_EQ(peekedEvent, peekedEvent);
|
|
EXPECT_EQ(constrParam1, finalizedEvent->constructionParam1);
|
|
EXPECT_EQ(constrParam2, finalizedEvent->constructionParam2);
|
|
|
|
finalizedEvent->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenDestroyingEventBuilderImplicitFinalizeIscalled) {
|
|
SmallEventBuilderEventMock *ev = nullptr;
|
|
auto parentEvent = new UserEvent;
|
|
{
|
|
EventBuilder eventBuilder{};
|
|
eventBuilder.create<SmallEventBuilderEventMock>();
|
|
eventBuilder.addParentEvent(*parentEvent);
|
|
ev = static_cast<SmallEventBuilderEventMock *>(eventBuilder.getEvent());
|
|
ASSERT_NE(nullptr, ev);
|
|
EXPECT_EQ(0U, ev->peekNumEventsBlockingThis());
|
|
}
|
|
// make sure that finalize was called on EventBuilder's d-tor and parent was added properly
|
|
EXPECT_EQ(1U, ev->peekNumEventsBlockingThis());
|
|
ev->release();
|
|
parentEvent->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenFinalizeIsCalledTwiceOnEventBuilderThenSecondRequestIsDropped) {
|
|
SmallEventBuilderEventMock *ev = nullptr;
|
|
EventBuilder eventBuilder{};
|
|
eventBuilder.create<SmallEventBuilderEventMock>();
|
|
ev = static_cast<SmallEventBuilderEventMock *>(eventBuilder.getEvent());
|
|
ASSERT_NE(nullptr, ev);
|
|
eventBuilder.finalize();
|
|
auto *falseParentEvent = new UserEvent();
|
|
auto *falseChildEvent = new SmallEventBuilderEventMock;
|
|
auto numParents = ev->peekNumEventsBlockingThis();
|
|
auto numChildren = (ev->peekChildEvents() != nullptr) ? 1U + ev->peekChildEvents()->countSuccessors() : 0;
|
|
eventBuilder.addParentEvent(*falseParentEvent);
|
|
eventBuilder.finalize();
|
|
// make sure that new parent was not added in second finalize
|
|
EXPECT_EQ(numParents, ev->peekNumEventsBlockingThis());
|
|
EXPECT_EQ(numChildren, (ev->peekChildEvents() != nullptr) ? 1U + ev->peekChildEvents()->countSuccessors() : 0);
|
|
falseParentEvent->release();
|
|
falseChildEvent->release();
|
|
ev->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenFinalizeAndReleaseIsCalledThenEventBuilderReleasesReferenceToEvent) {
|
|
EventBuilder eventBuilder;
|
|
eventBuilder.create<SmallEventBuilderEventMock>();
|
|
auto ev = static_cast<SmallEventBuilderEventMock *>(eventBuilder.finalizeAndRelease());
|
|
ASSERT_NE(nullptr, ev);
|
|
ASSERT_EQ(nullptr, eventBuilder.getEvent());
|
|
ASSERT_EQ(nullptr, eventBuilder.finalizeAndRelease());
|
|
ev->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenClearIsCalledThenAllEventsAndReferencesAreDropped) {
|
|
auto parentEvent = new UserEvent();
|
|
SmallEventBuilderMock eventBuilder;
|
|
eventBuilder.addParentEvent(*parentEvent);
|
|
eventBuilder.clear();
|
|
|
|
EXPECT_EQ(0U, eventBuilder.getParentEvents().size());
|
|
EXPECT_EQ(nullptr, eventBuilder.getEvent());
|
|
|
|
parentEvent->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenCParentEventsGetAddedThenTheirReferenceCountGetsIncreasedUntilFinalizeIsCalled) {
|
|
UserEvent evParent1;
|
|
UserEvent evParent2;
|
|
|
|
EXPECT_EQ(1, evParent1.getRefInternalCount());
|
|
EXPECT_EQ(1, evParent2.getRefInternalCount());
|
|
|
|
EventBuilder eventBuilder;
|
|
eventBuilder.create<SmallEventBuilderEventMock>();
|
|
eventBuilder.addParentEvent(evParent1);
|
|
EXPECT_EQ(2, evParent1.getRefInternalCount());
|
|
eventBuilder.addParentEvent(evParent2);
|
|
EXPECT_EQ(2, evParent2.getRefInternalCount());
|
|
auto createdEvent = static_cast<SmallEventBuilderEventMock *>(eventBuilder.finalizeAndRelease());
|
|
EXPECT_EQ(2U, createdEvent->peekNumEventsBlockingThis());
|
|
createdEvent->release();
|
|
evParent1.setStatus(CL_COMPLETE);
|
|
evParent2.setStatus(CL_COMPLETE);
|
|
|
|
EXPECT_EQ(1, evParent1.getRefInternalCount());
|
|
EXPECT_EQ(1, evParent2.getRefInternalCount());
|
|
}
|
|
|
|
TEST(EventBuilder, whenFinalizeIsCalledWithEmptyEventsListsThenParentAndChildListsAreEmpty) {
|
|
EventBuilder eventBuilder;
|
|
eventBuilder.create<MockEvent<Event>>(nullptr, CL_COMMAND_MARKER, 0, 0);
|
|
Event *event = eventBuilder.finalizeAndRelease();
|
|
EXPECT_EQ(0U, event->peekNumEventsBlockingThis());
|
|
EXPECT_EQ(nullptr, event->peekChildEvents());
|
|
event->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenFinalizeIsCalledAndBuildersEventsListAreNotEmptyThenEventsListsAreAddedToEvent) {
|
|
MockEvent<UserEvent> *parentEvent = new MockEvent<UserEvent>();
|
|
|
|
EventBuilder eventBuilder;
|
|
eventBuilder.create<MockEvent<Event>>(nullptr, CL_COMMAND_MARKER, 0, 0);
|
|
eventBuilder.addParentEvent(*parentEvent);
|
|
Event *event = eventBuilder.finalizeAndRelease();
|
|
|
|
EXPECT_EQ(1U, event->peekNumEventsBlockingThis());
|
|
ASSERT_NE(nullptr, parentEvent->peekChildEvents());
|
|
EXPECT_EQ(event, parentEvent->peekChildEvents()->ref);
|
|
parentEvent->setStatus(CL_COMPLETE);
|
|
EXPECT_EQ(0U, event->peekNumEventsBlockingThis());
|
|
EXPECT_EQ(nullptr, parentEvent->peekChildEvents());
|
|
|
|
event->release();
|
|
parentEvent->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenFinalizeIsCalledAndParentsListContainsManyEventsFromWhichOnlyFirstOnesAreCompletedThenEventIsNotCompleted) {
|
|
MockEvent<UserEvent> *userEventNotCompleted = new MockEvent<UserEvent>();
|
|
MockEvent<UserEvent> *userEventCompleted = new MockEvent<UserEvent>();
|
|
userEventCompleted->setStatus(CL_COMPLETE);
|
|
|
|
EventBuilder eventBuilder;
|
|
eventBuilder.create<MockEvent<Event>>(nullptr, CL_COMMAND_MARKER, 0, 0);
|
|
eventBuilder.addParentEvent(*userEventCompleted);
|
|
eventBuilder.addParentEvent(*userEventNotCompleted);
|
|
Event *event = eventBuilder.finalizeAndRelease();
|
|
EXPECT_FALSE(event->updateStatusAndCheckCompletion());
|
|
EXPECT_EQ(1U, event->peekNumEventsBlockingThis());
|
|
ASSERT_EQ(nullptr, userEventCompleted->peekChildEvents());
|
|
ASSERT_NE(nullptr, userEventNotCompleted->peekChildEvents());
|
|
EXPECT_EQ(event, userEventNotCompleted->peekChildEvents()->ref);
|
|
userEventNotCompleted->setStatus(CL_COMPLETE);
|
|
EXPECT_EQ(0U, event->peekNumEventsBlockingThis());
|
|
EXPECT_EQ(nullptr, userEventNotCompleted->peekChildEvents());
|
|
event->release();
|
|
userEventCompleted->release();
|
|
userEventNotCompleted->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenAddingNullptrAsNewParentEventThenItIsIgnored) {
|
|
SmallEventBuilderMock eventBuilder;
|
|
EXPECT_EQ(0U, eventBuilder.getParentEvents().size());
|
|
eventBuilder.addParentEvent(nullptr);
|
|
EXPECT_EQ(0U, eventBuilder.getParentEvents().size());
|
|
}
|
|
|
|
TEST(EventBuilder, whenAddingValidEventAsNewParentEventThenItIsProperlyAddedToParentsList) {
|
|
auto event = new SmallEventBuilderEventMock;
|
|
SmallEventBuilderMock eventBuilder;
|
|
eventBuilder.create<MockEvent<Event>>(nullptr, CL_COMMAND_MARKER, 0, 0);
|
|
EXPECT_EQ(0U, eventBuilder.getParentEvents().size());
|
|
eventBuilder.addParentEvent(event);
|
|
EXPECT_EQ(1U, eventBuilder.getParentEvents().size());
|
|
event->release();
|
|
eventBuilder.finalize();
|
|
eventBuilder.getEvent()->release();
|
|
}
|
|
|
|
TEST(EventBuilder, whenAddingMultipleEventsAsNewParentsThenOnlyValidOnesAreInsertedIntoParentsList) {
|
|
auto event = new SmallEventBuilderEventMock;
|
|
auto invalidEvent = new SmallEventBuilderEventMock;
|
|
invalidEvent->overrideMagic(0);
|
|
cl_event eventsList[] = {nullptr, event, invalidEvent};
|
|
SmallEventBuilderMock eventBuilder;
|
|
eventBuilder.create<MockEvent<Event>>(nullptr, CL_COMMAND_MARKER, 0, 0);
|
|
EXPECT_EQ(0U, eventBuilder.getParentEvents().size());
|
|
eventBuilder.addParentEvents(ArrayRef<cl_event>(eventsList));
|
|
ASSERT_EQ(1U, eventBuilder.getParentEvents().size());
|
|
EXPECT_EQ(event, *eventBuilder.getParentEvents().begin());
|
|
invalidEvent->release();
|
|
event->release();
|
|
eventBuilder.finalize();
|
|
eventBuilder.getEvent()->release();
|
|
}
|
|
|
|
TEST(EventBuilder, parentListDoesNotHaveDuplicates) {
|
|
MockContext mockContext;
|
|
MockCommandQueue mockCommandQueue(&mockContext, nullptr, nullptr);
|
|
|
|
SmallEventBuilderMock *eventBuilder = new SmallEventBuilderMock;
|
|
eventBuilder->create<MockEvent<Event>>(&mockCommandQueue, CL_COMMAND_MARKER, 0, 0);
|
|
Event *event = eventBuilder->getEvent();
|
|
|
|
Event *parentEvent = new Event(&mockCommandQueue, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
|
|
Event *parentEvent2 = new Event(&mockCommandQueue, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
|
|
Event *parentEvent3 = new Event(&mockCommandQueue, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
|
|
|
|
eventBuilder->addParentEvent(parentEvent);
|
|
eventBuilder->addParentEvent(parentEvent2);
|
|
eventBuilder->addParentEvent(parentEvent3);
|
|
// add duplicate
|
|
eventBuilder->addParentEvent(parentEvent);
|
|
|
|
auto parents = eventBuilder->getParentEvents();
|
|
size_t numberOfParents = parents.size();
|
|
EXPECT_EQ(3u, numberOfParents);
|
|
|
|
event->release();
|
|
parentEvent->release();
|
|
parentEvent2->release();
|
|
parentEvent3->release();
|
|
eventBuilder->clear();
|
|
eventBuilder->clearEvent();
|
|
|
|
delete eventBuilder;
|
|
}
|
|
|
|
} // namespace OCLRT
|