remove MT tests from igdrcl_tests target

these tests are executed as part of igdrcl_mt_tests

Change-Id: I907bbe99b1283962db2b5ad5fae1e4c848683ff1
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>

opencl/test/unit_test/mt_tests/event/CMakeLists.txt

@@ -7,8 +7,7 @@
 set(IGDRCL_SRCS_mt_tests_event
   # local files
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-
-  # necessary dependencies from igdrcl_tests
-  ${NEO_SOURCE_DIR}/opencl/test/unit_test/event/user_events_tests_mt.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/event_tests_mt.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/user_events_tests_mt.cpp
 )
 target_sources(igdrcl_mt_tests PRIVATE ${IGDRCL_SRCS_mt_tests_event})

opencl/test/unit_test/mt_tests/event/event_tests_mt.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2017-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
+
+#include "opencl/test/unit_test/event/event_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_event.h"
+
+#include <memory>
+
+class SmallMockEvent : public Event {
+  public:
+    SmallMockEvent(Context *ctx) : Event(ctx, nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0) {}
+    void switchToSubmitted() {
+        transitionExecutionStatus(CL_SUBMITTED);
+    }
+    void switchToComplete() {
+        transitionExecutionStatus(CL_COMPLETE);
+    }
+};
+
+TEST(EventTestMt, WhenWaitingForEventsThenDoNotReturnUntilAllStatusesSetToComplete) {
+
+    for (uint32_t i = 0; i < 100; i++) {
+        std::unique_ptr<UserEvent> userEvent = std::unique_ptr<UserEvent>(new UserEvent(nullptr));
+
+        std::thread t([&]() {
+            userEvent->setStatus(CL_COMPLETE);
+        });
+
+        t.join();
+        cl_event clEvent = userEvent.get();
+        Event::waitForEvents(1, &clEvent);
+    }
+}

opencl/test/unit_test/mt_tests/event/user_events_tests_mt.cpp

@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2017-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/memory_manager/memory_manager.h"
+
+#include "opencl/test/unit_test/event/event_fixture.h"
+#include "opencl/test/unit_test/fixtures/buffer_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_command_queue.h"
+
+#include <memory>
+
+typedef HelloWorldTest<HelloWorldFixtureFactory> EventTests;
+
+TEST_F(MockEventTests, eventCreatedFromUserEventsThatIsNotSignaledDoesntFlushToCSR) {
+    uEvent = make_releaseable<UserEvent>();
+    cl_event retEvent = nullptr;
+    cl_event eventWaitList[] = {uEvent.get()};
+    int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event);
+
+    //call NDR
+    auto retVal = callOneWorkItemNDRKernel(eventWaitList, sizeOfWaitList, &retEvent);
+
+    auto &csr = pCmdQ->getGpgpuCommandStreamReceiver();
+    *csr.getTagAddress() = (unsigned int)-1;
+    auto taskLevelBeforeWaitForEvents = csr.peekTaskLevel();
+
+    int counter = 0;
+    int Deadline = 20000;
+
+    std::atomic<bool> ThreadStarted(false);
+    std::atomic<bool> WaitForEventsCompleted(false);
+
+    std::thread t([&]() {
+        ThreadStarted = true;
+        //call WaitForEvents
+        clWaitForEvents(1, &retEvent);
+        WaitForEventsCompleted = true;
+    });
+    //wait for the thread to start
+    while (!ThreadStarted)
+        ;
+    //now wait a while.
+    while (!WaitForEventsCompleted && counter++ < Deadline)
+        ;
+
+    ASSERT_EQ(WaitForEventsCompleted, false) << "WaitForEvents returned while user event is not signaled!";
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    EXPECT_EQ(taskLevelBeforeWaitForEvents, csr.peekTaskLevel());
+
+    //set event to CL_COMPLETE
+    uEvent->setStatus(CL_COMPLETE);
+    t.join();
+
+    retVal = clReleaseEvent(retEvent);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsCompletedAfterBlockedPathIsChosenThenBlockingFlagDoesNotCauseStall) {
+
+    std::unique_ptr<Buffer> srcBuffer(BufferHelper<>::create());
+    std::unique_ptr<char[]> dst(new char[srcBuffer->getSize()]);
+
+    for (int32_t i = 0; i < 20; i++) {
+        UserEvent uEvent;
+        cl_event eventWaitList[] = {&uEvent};
+        int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event);
+
+        std::thread t([&]() {
+            uEvent.setStatus(CL_COMPLETE);
+        });
+
+        auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, nullptr);
+        EXPECT_EQ(CL_SUCCESS, retVal);
+
+        t.join();
+    }
+}
+
+TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsCompletedAfterUpdateFromCompletionStampThenBlockingFlagDoesNotCauseStall) {
+
+    std::unique_ptr<Buffer> srcBuffer(BufferHelper<>::create());
+    std::unique_ptr<char[]> dst(new char[srcBuffer->getSize()]);
+
+    UserEvent uEvent;
+    cl_event eventWaitList[] = {&uEvent};
+    int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event);
+
+    std::thread t([&]() {
+        while (true) {
+            pCmdQ->takeOwnership();
+
+            if (pCmdQ->taskLevel == CompletionStamp::levelNotReady) {
+                pCmdQ->releaseOwnership();
+                break;
+            }
+            pCmdQ->releaseOwnership();
+        }
+        uEvent.setStatus(CL_COMPLETE);
+    });
+
+    auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_TRUE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    t.join();
+}
+
+HWTEST_F(EventTests, givenOneThreadUpdatingUserEventAnotherWaitingOnFinishWhenFinishIsCalledThenItWaitsForCorrectTaskCount) {
+    MockCommandQueueHw<FamilyType> mockCmdQueue(context, pClDevice, nullptr);
+    std::unique_ptr<Buffer> srcBuffer(BufferHelper<>::create());
+    std::unique_ptr<char[]> dst(new char[srcBuffer->getSize()]);
+    for (uint32_t i = 0; i < 100; i++) {
+
+        UserEvent uEvent;
+        cl_event eventWaitList[] = {&uEvent};
+        int sizeOfWaitList = sizeof(eventWaitList) / sizeof(cl_event);
+        cl_event returnedEvent = nullptr;
+
+        std::atomic_bool go{false};
+        std::atomic_bool updateEvent{true};
+
+        std::thread t([&]() {
+            while (!go)
+                ;
+
+            uEvent.setStatus(CL_COMPLETE);
+        });
+
+        auto retVal = mockCmdQueue.enqueueReadBuffer(srcBuffer.get(), CL_FALSE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, &returnedEvent);
+        EXPECT_EQ(CL_SUCCESS, retVal);
+
+        std::thread t2([&]() {
+            while (updateEvent) {
+                castToObject<Event>(returnedEvent)->updateExecutionStatus();
+            }
+        });
+
+        go = true;
+
+        clFinish(&mockCmdQueue);
+        EXPECT_EQ(mockCmdQueue.latestTaskCountWaited, i + 1);
+
+        t.join();
+        updateEvent = false;
+        t2.join();
+        clReleaseEvent(returnedEvent);
+    }
+}