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

refactor: l0 usm host pool to unique ptr

Browse Source 
Related-To: NEO-16084

Signed-off-by: Dominik Dabek <dominik.dabek@intel.com>
This commit is contained in:
Dominik Dabek
2025-10-22 12:53:04 +00:00
committed by Compute-Runtime-Automation
parent c92ab7c40f
commit 74d050f7be
7 changed files with 56 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
level_zero/core/source/context/context_imp.cpp
View File

@@ -178,8 +178,8 @@ ze_result_t ContextImp::allocHostMem(const ze_host_mem_alloc_desc_t *hostDesc,
return ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY;
}
if (false == lookupTable.exportMemory) {
if (auto usmPtrFromPool = this->driverHandle->usmHostMemAllocPool.createUnifiedMemoryAllocation(size, unifiedMemoryProperties)) {
if (false == lookupTable.exportMemory && this->driverHandle->usmHostMemAllocPool) {
if (auto usmPtrFromPool = this->driverHandle->usmHostMemAllocPool->createUnifiedMemoryAllocation(size, unifiedMemoryProperties)) {
*ptr = usmPtrFromPool;
return ZE_RESULT_SUCCESS;
}
@@ -494,8 +494,9 @@ NEO::UsmMemAllocPool *ContextImp::getUsmPoolOwningPtr(const void *ptr, NEO::SvmA
NEO::UsmMemAllocPool *usmPool = nullptr;
if (InternalMemoryType::hostUnifiedMemory == svmData->memoryType &&
driverHandle->usmHostMemAllocPool.isInPool(ptr)) {
usmPool = &driverHandle->usmHostMemAllocPool;
driverHandle->usmHostMemAllocPool &&
driverHandle->usmHostMemAllocPool->isInPool(ptr)) {
usmPool = driverHandle->usmHostMemAllocPool.get();
} else if (InternalMemoryType::deviceUnifiedMemory == svmData->memoryType) {
usmPool = svmData->device->getUsmPoolOwningPtr(ptr);
}

7
level_zero/core/source/driver/driver_handle_imp.cpp
View File

@@ -240,7 +240,9 @@ DriverHandleImp::~DriverHandleImp() {
memoryManager->peekExecutionEnvironment().prepareForCleanup();
if (this->svmAllocsManager) {
this->svmAllocsManager->cleanupUSMAllocCaches();
this->usmHostMemAllocPool.cleanup();
if (this->usmHostMemAllocPool) {
this->usmHostMemAllocPool->cleanup();
}
}
}
@@ -384,7 +386,8 @@ void DriverHandleImp::initHostUsmAllocPool() {
if (usmHostAllocPoolingEnabled) {
NEO::SVMAllocsManager::UnifiedMemoryProperties memoryProperties(InternalMemoryType::hostUnifiedMemory, MemoryConstants::pageSize2M,
rootDeviceIndices, deviceBitfields);
usmHostMemAllocPool.initialize(svmAllocsManager, memoryProperties, poolParams.poolSize, poolParams.minServicedSize, poolParams.maxServicedSize);
usmHostMemAllocPool.reset(new NEO::UsmMemAllocPool);
usmHostMemAllocPool->initialize(svmAllocsManager, memoryProperties, poolParams.poolSize, poolParams.minServicedSize, poolParams.maxServicedSize);
}
}

2
level_zero/core/source/driver/driver_handle_imp.h
View File

@@ -137,7 +137,7 @@ struct DriverHandleImp : public DriverHandle {
NEO::MemoryManager *memoryManager = nullptr;
NEO::SVMAllocsManager *svmAllocsManager = nullptr;
NEO::UsmMemAllocPool usmHostMemAllocPool;
std::unique_ptr<NEO::UsmMemAllocPool> usmHostMemAllocPool;
ze_context_handle_t defaultContext = nullptr;
std::unique_ptr<NEO::StagingBufferManager> stagingBufferManager;

5
level_zero/core/test/common/ult_helpers_l0.h
View File

@@ -14,7 +14,10 @@ namespace L0 {
namespace ult {
struct L0UltHelper {
static void cleanupUsmAllocPoolsAndReuse(DriverHandleImp *driverHandle) {
driverHandle->usmHostMemAllocPool.cleanup();
if (driverHandle->usmHostMemAllocPool) {
driverHandle->usmHostMemAllocPool->cleanup();
driverHandle->usmHostMemAllocPool.reset(nullptr);
}
for (auto device : driverHandle->devices) {
device->getNEODevice()->cleanupUsmAllocationPool();
}

14
level_zero/core/test/unit_tests/sources/memory/test_memory.cpp
View File

@@ -539,13 +539,13 @@ TEST_F(MemoryTest, givenHostPointerThenDriverGetAllocPropertiesReturnsExpectedPr
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(memoryProperties.type, ZE_MEMORY_TYPE_HOST);
auto usmPool = &driverHandle->usmHostMemAllocPool;
auto usmPool = driverHandle->usmHostMemAllocPool.get();
auto alloc = context->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
EXPECT_NE(alloc, nullptr);
EXPECT_NE(alloc->pageSizeForAlignment, 0u);
EXPECT_EQ(alloc->pageSizeForAlignment, memoryProperties.pageSize);
if (usmPool->isInPool(ptr)) {
if (usmPool && usmPool->isInPool(ptr)) {
EXPECT_EQ(memoryProperties.id, alloc->getAllocId());
} else {
EXPECT_EQ(memoryProperties.id,
@@ -2789,11 +2789,7 @@ TEST_F(FreeExtTests,
TEST_F(FreeExtTests,
whenAllocMemFailsWithDeferredFreeAllocationThenMemoryFreedAndRetrySucceeds) {
// does not make sense for usm pooling, disable for test
driverHandle->usmHostMemAllocPool.cleanup();
if (auto deviceUsmPool = neoDevice->getUsmMemAllocPool()) {
deviceUsmPool->cleanup();
neoDevice->usmMemAllocPool.reset(nullptr);
}
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
size_t size = 1024;
size_t alignment = 1u;
@@ -5792,7 +5788,7 @@ struct AllocHostMemoryTest : public ::testing::Test {
TEST_F(AllocHostMemoryTest,
whenCallingAllocHostMemThenAllocateGraphicsMemoryWithPropertiesIsCalledTheNumberOfTimesOfRootDevices) {
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
void *ptr = nullptr;
static_cast<MockMemoryManager *>(driverHandle->getMemoryManager())->isMockHostMemoryManager = true;
@@ -5828,7 +5824,7 @@ TEST_F(AllocHostMemoryTest,
TEST_F(AllocHostMemoryTest,
whenCallingAllocHostMemAndFailingOnCreatingGraphicsAllocationWithHostPointerThenNullIsReturned) {
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
static_cast<MockMemoryManager *>(driverHandle->getMemoryManager())->isMockHostMemoryManager = true;
static_cast<MockMemoryManager *>(driverHandle->getMemoryManager())->forceFailureInAllocationWithHostPointer = true;

55
level_zero/core/test/unit_tests/sources/memory/test_memory_pooling.cpp
View File

@@ -20,6 +20,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/core/test/common/ult_helpers_l0.h"
#include "level_zero/core/test/unit_tests/mock.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
namespace L0 {
@@ -94,51 +95,57 @@ struct AllocUsmPoolMemoryTest : public ::testing::Test {
using AllocUsmHostDefaultMemoryTest = AllocUsmPoolMemoryTest<-1, -1, 0, true>;
TEST_F(AllocUsmHostDefaultMemoryTest, givenDriverHandleWhenCallinginitHostUsmAllocPoolThenInitIfEnabledForAllDevicesAndNoDebugger) {
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
mockProductHelpers[0]->isHostUsmPoolAllocatorSupportedResult = false;
mockProductHelpers[1]->isHostUsmPoolAllocatorSupportedResult = false;
driverHandle->initHostUsmAllocPool();
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInitialized());
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
mockProductHelpers[0]->isHostUsmPoolAllocatorSupportedResult = true;
mockProductHelpers[1]->isHostUsmPoolAllocatorSupportedResult = false;
driverHandle->initHostUsmAllocPool();
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInitialized());
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
mockProductHelpers[0]->isHostUsmPoolAllocatorSupportedResult = true;
mockProductHelpers[1]->isHostUsmPoolAllocatorSupportedResult = true;
driverHandle->initHostUsmAllocPool();
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInitialized());
ASSERT_NE(nullptr, driverHandle->usmHostMemAllocPool.get());
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInitialized());
for (int32_t csrType = 0; csrType < static_cast<int32_t>(CommandStreamReceiverType::typesNum); ++csrType) {
DebugManagerStateRestore restorer;
debugManager.flags.SetCommandStreamReceiver.set(static_cast<int32_t>(csrType));
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
mockProductHelpers[0]->isHostUsmPoolAllocatorSupportedResult = true;
mockProductHelpers[1]->isHostUsmPoolAllocatorSupportedResult = true;
driverHandle->initHostUsmAllocPool();
EXPECT_EQ(NEO::DeviceFactory::isHwModeSelected(), driverHandle->usmHostMemAllocPool.isInitialized());
if (NEO::DeviceFactory::isHwModeSelected()) {
ASSERT_NE(nullptr, driverHandle->usmHostMemAllocPool.get());
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInitialized());
} else {
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
}
}
driverHandle->usmHostMemAllocPool.cleanup();
L0UltHelper::cleanupUsmAllocPoolsAndReuse(driverHandle.get());
auto debuggerL0 = DebuggerL0::create(l0Devices[1]->getNEODevice());
executionEnvironment->rootDeviceEnvironments[1]->debugger.reset(debuggerL0.release());
driverHandle->initHostUsmAllocPool();
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInitialized());
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
}
using AllocUsmHostDisabledMemoryTest = AllocUsmPoolMemoryTest<0, -1>;
TEST_F(AllocUsmHostDisabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemThenDoNotUsePool) {
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInitialized());
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
void *ptr = nullptr;
ze_host_mem_alloc_desc_t hostDesc = {};
ze_result_t result = context->allocHostMem(&hostDesc, 1u, 0u, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInitialized());
EXPECT_EQ(nullptr, driverHandle->usmHostMemAllocPool.get());
result = context->freeMem(ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
@@ -146,8 +153,9 @@ TEST_F(AllocUsmHostDisabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemT
using AllocUsmHostEnabledMemoryTest = AllocUsmPoolMemoryTest<1, -1, 0>;
TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWithVariousParametersThenUsePoolIfAllowed) {
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(&driverHandle->usmHostMemAllocPool);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInitialized());
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(driverHandle->usmHostMemAllocPool.get());
ASSERT_NE(nullptr, driverHandle->usmHostMemAllocPool.get());
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInitialized());
auto poolAllocationData = driverHandle->svmAllocsManager->getSVMAlloc(mockHostMemAllocPool->pool);
void *ptr1Byte = nullptr;
@@ -155,7 +163,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
ze_result_t result = context->allocHostMem(&hostDesc, 1u, 0u, &ptr1Byte);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr1Byte);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInPool(ptr1Byte));
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInPool(ptr1Byte));
EXPECT_EQ(1u, mockHostMemAllocPool->allocations.getNumAllocs());
EXPECT_EQ(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(ptr1Byte));
result = context->freeMem(ptr1Byte);
@@ -166,7 +174,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
result = context->allocHostMem(&hostDesc, poolAllocationThreshold, 0u, &ptrThreshold);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptrThreshold);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInPool(ptrThreshold));
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInPool(ptrThreshold));
EXPECT_EQ(1u, mockHostMemAllocPool->allocations.getNumAllocs());
EXPECT_EQ(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(ptrThreshold));
result = context->freeMem(ptrThreshold);
@@ -177,7 +185,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
result = context->allocHostMem(&hostDesc, poolAllocationThreshold + 1u, 0u, &ptrOverThreshold);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptrOverThreshold);
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInPool(ptrOverThreshold));
EXPECT_FALSE(driverHandle->usmHostMemAllocPool->isInPool(ptrOverThreshold));
EXPECT_EQ(0u, mockHostMemAllocPool->allocations.getNumAllocs());
EXPECT_NE(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(ptrOverThreshold));
result = context->freeMem(ptrOverThreshold);
@@ -188,7 +196,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
result = context->allocHostMem(&hostDesc, poolAllocationThreshold, 0u, &ptrFreeMemExt);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptrFreeMemExt);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInPool(ptrFreeMemExt));
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInPool(ptrFreeMemExt));
EXPECT_EQ(1u, mockHostMemAllocPool->allocations.getNumAllocs());
EXPECT_EQ(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(ptrFreeMemExt));
ze_memory_free_ext_desc_t memFreeDesc = {};
@@ -205,7 +213,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
result = context->allocHostMem(&hostDesc, poolAllocationThreshold, 0u, &ptrExportMemory);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptrExportMemory);
EXPECT_FALSE(driverHandle->usmHostMemAllocPool.isInPool(ptrExportMemory));
EXPECT_FALSE(driverHandle->usmHostMemAllocPool->isInPool(ptrExportMemory));
EXPECT_EQ(0u, mockHostMemAllocPool->allocations.getNumAllocs());
EXPECT_NE(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(ptrExportMemory));
result = context->freeMem(ptrExportMemory);
@@ -219,7 +227,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDriverHandleWhenCallingAllocHostMemWi
}
TEST_F(AllocUsmHostEnabledMemoryTest, givenPooledAllocationWhenCallingGetMemAddressRangeThenCorrectValuesAreReturned) {
auto pool = &driverHandle->usmHostMemAllocPool;
auto pool = driverHandle->usmHostMemAllocPool.get();
{
auto mockDeviceMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(pool);
@@ -250,8 +258,9 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenPooledAllocationWhenCallingGetMemAddr
}
TEST_F(AllocUsmHostEnabledMemoryTest, givenDrmDriverModelWhenOpeningIpcHandleFromPooledAllocationThenOffsetIsApplied) {
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(&driverHandle->usmHostMemAllocPool);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInitialized());
ASSERT_NE(nullptr, driverHandle->usmHostMemAllocPool.get());
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(driverHandle->usmHostMemAllocPool.get());
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInitialized());
auto poolAllocationData = driverHandle->svmAllocsManager->getSVMAlloc(mockHostMemAllocPool->pool);
executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface());
executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::make_unique<NEO::MockDriverModelDRM>());
@@ -261,7 +270,7 @@ TEST_F(AllocUsmHostEnabledMemoryTest, givenDrmDriverModelWhenOpeningIpcHandleFro
ze_result_t result = context->allocHostMem(&hostDesc, 1u, 0u, &pooledAllocation);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, pooledAllocation);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInPool(pooledAllocation));
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInPool(pooledAllocation));
EXPECT_EQ(poolAllocationData, driverHandle->svmAllocsManager->getSVMAlloc(pooledAllocation));
const auto pooledAllocationOffset = ptrDiff(mockHostMemAllocPool->allocations.get(pooledAllocation)->address, castToUint64(mockHostMemAllocPool->pool));
EXPECT_NE(0u, pooledAllocationOffset);

7
level_zero/core/test/unit_tests/sources/memory/test_memory_wddm.cpp
View File

@@ -387,8 +387,9 @@ struct HostUsmPoolMemoryOpenIpcHandleTest : public MemoryIPCTests {
TEST_F(HostUsmPoolMemoryOpenIpcHandleTest,
givenCallToOpenIpcMemHandleItIsSuccessfullyOpenedAndClosed) {
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(&driverHandle->usmHostMemAllocPool);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInitialized());
ASSERT_NE(nullptr, driverHandle->usmHostMemAllocPool.get());
auto mockHostMemAllocPool = reinterpret_cast<MockUsmMemAllocPool *>(driverHandle->usmHostMemAllocPool.get());
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInitialized());
size_t size = 1;
size_t alignment = 0u;
void *ptr = nullptr;
@@ -398,7 +399,7 @@ TEST_F(HostUsmPoolMemoryOpenIpcHandleTest,
size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, ptr);
EXPECT_TRUE(driverHandle->usmHostMemAllocPool.isInPool(ptr));
EXPECT_TRUE(driverHandle->usmHostMemAllocPool->isInPool(ptr));
const auto pooledAllocationOffset = ptrDiff(mockHostMemAllocPool->allocations.get(ptr)->address, castToUint64(mockHostMemAllocPool->pool));
EXPECT_GT(pooledAllocationOffset, 0u);