Deferred deletion of allocations in main thread

Add a clearQueueTillFirstFailure interface to DeferredDeleter, which
iterates the queue from the front and delete the allocations in the
queue till a failure. It is called by defer deletion of allocations
occupied by mutliple contexts to unlock the execution in main thread.

Related-To: NEO-7532

Signed-off-by: HeFan2017 <fan.f.he@intel.com>

opencl/test/unit_test/memory_manager/memory_manager_tests.cpp

@@ -2186,7 +2186,7 @@ HWTEST_F(GraphicsAllocationTests, givenAllocationUsedByManyOsContextsWhenCheckin
     auto memoryManager = new MockMemoryManager(false, false, *executionEnvironment);
     executionEnvironment->memoryManager.reset(memoryManager);
     auto multiContextDestructor = new MockDeferredDeleter();
-    multiContextDestructor->expectDrainBlockingValue(false);
+    multiContextDestructor->expectClearQueueTillFirstFailure();
     memoryManager->multiContextResourceDestructor.reset(multiContextDestructor);
 
     auto device = std::unique_ptr<MockDevice>(MockDevice::create<MockDevice>(executionEnvironment, 0u));

opencl/test/unit_test/mt_tests/memory_manager/deferred_deleter_clear_queue_mt_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,7 +30,7 @@ struct ClearQueueTest : public ::testing::Test,
     static void threadMethod(MockDeferredDeleter *deleter) {
         while (!startClear)
             ;
-        deleter->clearQueue();
+        deleter->clearQueue(false);
         threadStopped++;
     }
     MockDeferrableDeletion *createDeletion() {

opencl/test/unit_test/mt_tests/memory_manager/deferred_deleter_mt_tests.cpp

@@ -224,3 +224,20 @@ TEST_F(DeferredDeleterTest, givenDeferredDeleterWhenNonBlockingDrainIsCalledThen
     EXPECT_EQ(0, deleter->areElementsReleasedCalled);
     EXPECT_EQ(1, deleter->drainCalled);
 }
+
+TEST_F(DeferredDeleterTest, GivenAsyncThreadStartedThenCallClearQueueTillFirstFailure) {
+    deleter->DeferredDeleter::addClient();
+
+    waitForAsyncThread();
+
+    auto deletion = createDeletion();
+    deleter->DeferredDeleter::deferDeletion(deletion);
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_TRUE(deleter->isThreadRunning());
+    EXPECT_TRUE(deleter->isWorking());
+    EXPECT_EQ(0, deleter->clearCalledWithBreakTillFailure);
+    deleter->allowEarlyStopThread();
+    deleter->DeferredDeleter::removeClient();
+
+    EXPECT_TRUE(deleter->isQueueEmpty());
+}

shared/source/memory_manager/deferred_deleter.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -96,7 +96,7 @@ void *DeferredDeleter::run(void *arg) {
         }
         lock.unlock();
         // Delete items placed into deferred delete queue
-        self->clearQueue();
+        self->clearQueue(false);
         lock.lock();
         // Check whether working thread should be stopped
     } while (!self->shouldStop());
@@ -105,21 +105,33 @@ void *DeferredDeleter::run(void *arg) {
 }
 
 void DeferredDeleter::drain(bool blocking) {
-    clearQueue();
+    clearQueue(false);
     if (blocking) {
         while (!areElementsReleased())
             ;
     }
 }
 
-void DeferredDeleter::clearQueue() {
+void DeferredDeleter::clearQueueTillFirstFailure() {
+    if (numClients > 0) {
+        return;
+    }
+    clearQueue(true);
+}
+
+void DeferredDeleter::clearQueue(bool breakOnFailure) {
     do {
         auto deletion = queue.removeFrontOne();
         if (deletion) {
             if (deletion->apply()) {
                 elementsToRelease--;
             } else {
-                queue.pushTailOne(*deletion.release());
+                if (breakOnFailure) {
+                    queue.pushFrontOne(*deletion.release());
+                    break;
+                } else {
+                    queue.pushTailOne(*deletion.release());
+                }
             }
         }
     } while (!queue.peekIsEmpty());

shared/source/memory_manager/deferred_deleter.h

@@ -31,11 +31,13 @@ class DeferredDeleter {
 
     MOCKABLE_VIRTUAL void drain(bool blocking);
 
+    MOCKABLE_VIRTUAL void clearQueueTillFirstFailure();
+
   protected:
     void stop();
     void safeStop();
     void ensureThread();
-    MOCKABLE_VIRTUAL void clearQueue();
+    MOCKABLE_VIRTUAL void clearQueue(bool breakOnFailure);
     MOCKABLE_VIRTUAL bool areElementsReleased();
     MOCKABLE_VIRTUAL bool shouldStop();
 

shared/source/memory_manager/memory_manager.cpp

@@ -258,7 +258,7 @@ void MemoryManager::checkGpuUsageAndDestroyGraphicsAllocations(GraphicsAllocatio
     if (gfxAllocation->isUsed()) {
         if (gfxAllocation->isUsedByManyOsContexts()) {
             multiContextResourceDestructor->deferDeletion(new DeferrableAllocationDeletion{*this, *gfxAllocation});
-            multiContextResourceDestructor->drain(false);
+            multiContextResourceDestructor->clearQueueTillFirstFailure();
             return;
         }
         for (auto &engine : getRegisteredEngines()) {

shared/test/common/mocks/mock_deferrable_deletion.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,9 +10,9 @@
 namespace NEO {
 bool MockDeferrableDeletion::apply() {
     applyCalled++;
-    return true;
+    return (applyCalled < trialTimes) ? false : true;
 }
 MockDeferrableDeletion::~MockDeferrableDeletion() {
-    EXPECT_EQ(1, applyCalled);
+    EXPECT_EQ(trialTimes, applyCalled);
 }
 } // namespace NEO

shared/test/common/mocks/mock_deferrable_deletion.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,6 +16,11 @@ class MockDeferrableDeletion : public DeferrableDeletion {
     bool apply() override;
 
     ~MockDeferrableDeletion() override;
+
+    void setTrialTimes(int times) { trialTimes = times; }
     int applyCalled = 0;
+
+  private:
+    int trialTimes = 1;
 };
 } // namespace NEO

shared/test/common/mocks/mock_deferred_deleter.cpp

@@ -18,6 +18,7 @@ namespace NEO {
 MockDeferredDeleter::MockDeferredDeleter() {
     shouldStopCalled = 0;
     clearCalled = 0;
+    clearCalledWithBreakTillFailure = 0;
 }
 
 void MockDeferredDeleter::deferDeletion(DeferrableDeletion *deletion) {
@@ -42,6 +43,11 @@ void MockDeferredDeleter::drain(bool blocking) {
     drainCalled++;
 }
 
+void MockDeferredDeleter::clearQueueTillFirstFailure() {
+    DeferredDeleter::clearQueueTillFirstFailure();
+    clearQueueTillFirstFailureCalled++;
+}
+
 void MockDeferredDeleter::drain() {
     return drain(true);
 }
@@ -65,9 +71,12 @@ bool MockDeferredDeleter::shouldStop() {
     return shouldStopCalled > 1;
 }
 
-void MockDeferredDeleter::clearQueue() {
-    DeferredDeleter::clearQueue();
+void MockDeferredDeleter::clearQueue(bool breakOnFailure) {
+    DeferredDeleter::clearQueue(breakOnFailure);
     clearCalled++;
+    if (breakOnFailure) {
+        clearCalledWithBreakTillFailure++;
+    }
 }
 
 int MockDeferredDeleter::getClientsNum() {
@@ -133,10 +142,17 @@ MockDeferredDeleter::~MockDeferredDeleter() {
     if (expectDrainCalled) {
         EXPECT_NE(0, drainCalled);
     }
+    if (expectClearQueueTillFirstFailureCalled) {
+        EXPECT_NE(0, clearQueueTillFirstFailureCalled);
+    }
 }
 
 void MockDeferredDeleter::expectDrainBlockingValue(bool value) {
     expectedDrainValue = value;
     expectDrainCalled = true;
 }
+
+void MockDeferredDeleter::expectClearQueueTillFirstFailure() {
+    expectClearQueueTillFirstFailureCalled = true;
+}
 } // namespace NEO

shared/test/common/mocks/mock_deferred_deleter.h

@@ -24,6 +24,8 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     void drain(bool blocking) override;
 
+    void clearQueueTillFirstFailure() override;
+
     bool areElementsReleased() override;
 
     bool shouldStop() override;
@@ -60,6 +62,8 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     std::atomic<int> clearCalled;
 
+    std::atomic<int> clearCalledWithBreakTillFailure;
+
     int deferDeletionCalled = 0;
     bool stopAfter3loopsInRun = false;
 
@@ -69,10 +73,16 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     void expectDrainBlockingValue(bool value);
 
+    void expectClearQueueTillFirstFailure();
+
     bool expectedDrainValue = false;
 
     bool expectDrainCalled = false;
 
-    void clearQueue() override;
+    bool expectClearQueueTillFirstFailureCalled = false;
+
+    int clearQueueTillFirstFailureCalled = 0;
+
+    void clearQueue(bool breakOnFailure) override;
 };
 } // namespace NEO

shared/test/unit_test/memory_manager/deferred_deleter_tests.cpp

@@ -5,6 +5,7 @@
  *
  */
 
+#include "shared/test/common/mocks/mock_deferrable_deletion.h"
 #include "shared/test/common/mocks/mock_deferred_deleter.h"
 
 #include "gtest/gtest.h"
@@ -20,3 +21,71 @@ TEST(DeferredDeleter, WhenDeferredDeleterIsCreatedThenItIsNotAssignable) {
     EXPECT_FALSE(std::is_move_assignable<DeferredDeleter>::value);
     EXPECT_FALSE(std::is_copy_assignable<DeferredDeleter>::value);
 }
+
+struct DeferredDeleterTest : public ::testing::Test {
+
+    void SetUp() override {
+        deleter.reset(new MockDeferredDeleter());
+    }
+
+    void TearDown() override {
+        EXPECT_TRUE(deleter->isQueueEmpty());
+        EXPECT_EQ(0, deleter->getElementsToRelease());
+    }
+
+    std::unique_ptr<MockDeferredDeleter> deleter;
+};
+
+TEST_F(DeferredDeleterTest, WhenTheAllocationsAreReadyThenCallClearQueueTillFirstFailure) {
+    auto deletion1 = new MockDeferrableDeletion();
+    auto deletion2 = new MockDeferrableDeletion();
+    deleter->DeferredDeleter::deferDeletion(deletion1);
+    deleter->DeferredDeleter::deferDeletion(deletion2);
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_TRUE(deleter->isQueueEmpty());
+    EXPECT_EQ(1, deleter->clearQueueTillFirstFailureCalled);
+    EXPECT_EQ(1, deleter->clearCalled);
+    EXPECT_EQ(1, deleter->clearCalledWithBreakTillFailure);
+}
+
+TEST_F(DeferredDeleterTest, WhenSomeAllocationIsNotReadyThenCallClearQueueTillFirstFailureMultipleTimes) {
+    auto deletionReady = new MockDeferrableDeletion();
+    auto deletionNotReadyTill3 = new MockDeferrableDeletion();
+    deletionNotReadyTill3->setTrialTimes(3);
+    deleter->DeferredDeleter::deferDeletion(deletionReady);
+    deleter->DeferredDeleter::deferDeletion(deletionNotReadyTill3);
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    EXPECT_EQ(1, deleter->clearQueueTillFirstFailureCalled);
+    EXPECT_EQ(1, deleter->clearCalled);
+    EXPECT_EQ(1, deleter->clearCalledWithBreakTillFailure);
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_TRUE(deleter->isQueueEmpty());
+}
+
+TEST_F(DeferredDeleterTest, WhenSomeAllocationIsNotReadyThenCallClearQueueTillFirstFailureAndThenDrain) {
+    auto deletionReady = new MockDeferrableDeletion();
+    auto deletionNotReadyTill3 = new MockDeferrableDeletion();
+    deletionNotReadyTill3->setTrialTimes(3);
+    deleter->DeferredDeleter::deferDeletion(deletionReady);
+    deleter->DeferredDeleter::deferDeletion(deletionNotReadyTill3);
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_FALSE(deleter->isQueueEmpty());
+    EXPECT_EQ(1, deleter->clearQueueTillFirstFailureCalled);
+    EXPECT_EQ(1, deleter->clearCalled);
+    EXPECT_EQ(1, deleter->clearCalledWithBreakTillFailure);
+    deleter->drain();
+    EXPECT_EQ(1, deleter->drainCalled);
+    EXPECT_TRUE(deleter->isQueueEmpty());
+}
+
+TEST_F(DeferredDeleterTest, GivenDeferredDeleterWithEmptyQueueThenCallClearQueueTillFirstFailure) {
+    deleter->clearQueueTillFirstFailure();
+    EXPECT_EQ(0, deleter->areElementsReleasedCalled);
+    EXPECT_EQ(1, deleter->clearQueueTillFirstFailureCalled);
+}