intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Deferred deletion of allocations in main thread"

Browse Source 
This reverts commit c268e30189.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2023-01-04 17:39:52 +01:00
committed by Compute-Runtime-Automation
parent 0dbf92d401
commit af81c79076
13 changed files with 14 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
opencl/test/unit_test/memory_manager/memory_manager_tests.cpp
View File

@@ -2204,7 +2204,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));

2
opencl/test/unit_test/mt_tests/memory_manager/deferred_deleter_clear_queue_mt_tests.cpp
View File

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

17
opencl/test/unit_test/mt_tests/memory_manager/deferred_deleter_mt_tests.cpp
View File

@@ -223,20 +223,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());
}

20
shared/source/memory_manager/deferred_deleter.cpp
View File

@@ -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() {
if (numClients > 0) {
return;
}
clearQueue(true);
}
void DeferredDeleter::clearQueue(bool breakOnFailure) {
void DeferredDeleter::clearQueue() {
do {
auto deletion = queue.removeFrontOne();
if (deletion) {
if (deletion->apply()) {
elementsToRelease--;
} else {
if (breakOnFailure) {
queue.pushFrontOne(*deletion.release());
break;
} else {
queue.pushTailOne(*deletion.release());
}
queue.pushTailOne(*deletion.release());
}
}
} while (!queue.peekIsEmpty());

4
shared/source/memory_manager/deferred_deleter.h
View File

@@ -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();

6
shared/source/memory_manager/memory_manager.cpp
View File

@@ -261,7 +261,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()) {
@@ -963,10 +963,6 @@ OsContext *MemoryManager::getDefaultEngineContext(uint32_t rootDeviceIndex, Devi
return defaultContext;
}
void MemoryManager::commonCleanup() {
multiContextResourceDestructor->drain(true);
}
bool MemoryTransferHelper::transferMemoryToAllocation(bool useBlitter, const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory, size_t srcSize) {
if (useBlitter) {
if (BlitHelperFunctions::blitMemoryToAllocation(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}) == BlitOperationResult::Success) {

2
shared/source/memory_manager/memory_manager.h
View File

@@ -215,7 +215,7 @@ class MemoryManager {
static HeapIndex selectExternalHeap(bool useLocalMemory);
static uint32_t maxOsContextCount;
virtual void commonCleanup();
virtual void commonCleanup(){};
virtual bool isCpuCopyRequired(const void *ptr) { return false; }
virtual bool isWCMemory(const void *ptr) { return false; }

1
shared/source/os_interface/linux/drm_memory_manager.cpp
View File

@@ -154,7 +154,6 @@ void DrmMemoryManager::releaseBufferObject(uint32_t rootDeviceIndex) {
}
void DrmMemoryManager::commonCleanup() {
MemoryManager::commonCleanup();
if (gemCloseWorker) {
gemCloseWorker->close(true);
}

4
shared/test/common/mocks/mock_deferrable_deletion.cpp
View File

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

5
shared/test/common/mocks/mock_deferrable_deletion.h
View File

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

20
shared/test/common/mocks/mock_deferred_deleter.cpp
View File

@@ -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) {
DeferredDeleter::clearQueue(breakOnFailure);
void MockDeferredDeleter::clearQueue() {
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

12
shared/test/common/mocks/mock_deferred_deleter.h
View File

@@ -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;
int clearQueueTillFirstFailureCalled = 0;
void clearQueue(bool breakOnFailure) override;
void clearQueue() override;
};
} // namespace NEO

69
shared/test/unit_test/memory_manager/deferred_deleter_tests.cpp
View File

@@ -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);
}