Revert "Deferred deletion of allocations in main thread"

This reverts commit 418e0f7322.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@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->expectClearQueueTillFirstFailure();
+    multiContextDestructor->expectDrainBlockingValue(false);
     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

@@ -30,7 +30,7 @@ struct ClearQueueTest : public ::testing::Test,
     static void threadMethod(MockDeferredDeleter *deleter) {
         while (!startClear)
             ;
-        deleter->clearQueue(false);
+        deleter->clearQueue();
         threadStopped++;
     }
     MockDeferrableDeletion *createDeletion() {

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

@@ -224,20 +224,3 @@ 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

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

shared/source/memory_manager/deferred_deleter.h

@@ -31,13 +31,11 @@ class DeferredDeleter {
 
     MOCKABLE_VIRTUAL void drain(bool blocking);
 
-    MOCKABLE_VIRTUAL void clearQueueTillFirstFailure();
-
   protected:
     void stop();
     void safeStop();
     void ensureThread();
-    MOCKABLE_VIRTUAL void clearQueue(bool breakOnFailure);
+    MOCKABLE_VIRTUAL void clearQueue();
     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->clearQueueTillFirstFailure();
+            multiContextResourceDestructor->drain(false);
             return;
         }
         for (auto &engine : getRegisteredEngines()) {

shared/test/common/mocks/mock_deferrable_deletion.cpp

@@ -10,9 +10,9 @@
 namespace NEO {
 bool MockDeferrableDeletion::apply() {
     applyCalled++;
-    return (applyCalled < trialTimes) ? false : true;
+    return true;
 }
 MockDeferrableDeletion::~MockDeferrableDeletion() {
-    EXPECT_EQ(trialTimes, applyCalled);
+    EXPECT_EQ(1, applyCalled);
 }
 } // namespace NEO

shared/test/common/mocks/mock_deferrable_deletion.h

@@ -16,11 +16,6 @@ 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,7 +18,6 @@ namespace NEO {
 MockDeferredDeleter::MockDeferredDeleter() {
     shouldStopCalled = 0;
     clearCalled = 0;
-    clearCalledWithBreakTillFailure = 0;
 }
 
 void MockDeferredDeleter::deferDeletion(DeferrableDeletion *deletion) {
@@ -43,11 +42,6 @@ void MockDeferredDeleter::drain(bool blocking) {
     drainCalled++;
 }
 
-void MockDeferredDeleter::clearQueueTillFirstFailure() {
-    DeferredDeleter::clearQueueTillFirstFailure();
-    clearQueueTillFirstFailureCalled++;
-}
-
 void MockDeferredDeleter::drain() {
     return drain(true);
 }
@@ -71,12 +65,9 @@ bool MockDeferredDeleter::shouldStop() {
     return shouldStopCalled > 1;
 }
 
-void MockDeferredDeleter::clearQueue(bool breakOnFailure) {
+void MockDeferredDeleter::clearQueue() {
-    DeferredDeleter::clearQueue(breakOnFailure);
+    DeferredDeleter::clearQueue();
     clearCalled++;
-    if (breakOnFailure) {
-        clearCalledWithBreakTillFailure++;
-    }
 }
 
 int MockDeferredDeleter::getClientsNum() {
@@ -142,17 +133,10 @@ 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,8 +24,6 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     void drain(bool blocking) override;
 
-    void clearQueueTillFirstFailure() override;
-
     bool areElementsReleased() override;
 
     bool shouldStop() override;
@@ -62,8 +60,6 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     std::atomic<int> clearCalled;
 
-    std::atomic<int> clearCalledWithBreakTillFailure;
-
     int deferDeletionCalled = 0;
     bool stopAfter3loopsInRun = false;
 
@@ -73,16 +69,10 @@ class MockDeferredDeleter : public DeferredDeleter {
 
     void expectDrainBlockingValue(bool value);
 
-    void expectClearQueueTillFirstFailure();
-
     bool expectedDrainValue = false;
 
     bool expectDrainCalled = false;
 
-    bool expectClearQueueTillFirstFailureCalled = false;
+    void clearQueue() override;
-
-    int clearQueueTillFirstFailureCalled = 0;
-
-    void clearQueue(bool breakOnFailure) override;
 };
 } // namespace NEO

shared/test/unit_test/memory_manager/deferred_deleter_tests.cpp

@@ -5,7 +5,6 @@
  *
  */
 
-#include "shared/test/common/mocks/mock_deferrable_deletion.h"
 #include "shared/test/common/mocks/mock_deferred_deleter.h"
 
 #include "gtest/gtest.h"
@@ -21,71 +20,3 @@ 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);
-}