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>

shared/test/common/mocks/mock_deferrable_deletion.cpp

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

@@ -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/common/mocks/mock_memory_manager.cpp

@@ -55,6 +55,7 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemoryWithProperties(cons
     recentlyPassedDeviceBitfield = properties.subDevicesBitfield;
     AllocationProperties adjustedProperties(properties);
     adjustedProperties.size = redundancyRatio * properties.size;
+    adjustedProperties.rootDeviceIndex = properties.rootDeviceIndex;
     return OsAgnosticMemoryManager::allocateGraphicsMemoryWithProperties(adjustedProperties);
 }