Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-11-10 05:49:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add shareable allocation for Windows

Browse Source 
Signed-off-by: Kamil Diedrich <kamil.diedrich@intel.com>
This commit is contained in:
Kamil Diedrich
2021-08-11 10:36:04 +00:00
committed by Compute-Runtime-Automation
parent c7ff2bacd3
commit 4390590831
22 changed files with 111 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -160,7 +160,7 @@ ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
deviceBitfields[rootDeviceIndex] = neoDevice->getDeviceBitfield();
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, this->driverHandle->rootDeviceIndices, deviceBitfields);
unifiedMemoryProperties.allocationFlags.flags.shareable = 1u;
unifiedMemoryProperties.allocationFlags.flags.shareable = static_cast<uint32_t>(lookupTable.isSharedHandle);
unifiedMemoryProperties.device = neoDevice;
if (deviceDesc->flags & ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED) {

2
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@@ -56,7 +56,7 @@ class MemoryManagerEventPoolFailMock : public NEO::MemoryManager {
NEO::GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const NEO::AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override { return nullptr; };
NEO::GraphicsAllocation *allocateShareableMemory(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateMemoryByKMD(const NEO::AllocationData &allocationData) override { return nullptr; };
void *lockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override { return nullptr; };
void unlockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override{};
};

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

@@ -1321,7 +1321,7 @@ class MemoryManagerIpcMock : public NEO::MemoryManager {
NEO::GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const NEO::AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override { return nullptr; };
NEO::GraphicsAllocation *allocateShareableMemory(const NEO::AllocationData &allocationData) override { return nullptr; };
NEO::GraphicsAllocation *allocateMemoryByKMD(const NEO::AllocationData &allocationData) override { return nullptr; };
void *lockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override { return nullptr; };
void unlockResourceImpl(NEO::GraphicsAllocation &graphicsAllocation) override{};
};

2
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@@ -1388,7 +1388,7 @@ TEST_F(DeviceGetCapsTest, givenFlagEnabled64kbPagesWhenCallConstructorMemoryMana
GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const AllocationData &allocationData) override { return nullptr; };
GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override { return nullptr; };
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override { return nullptr; };
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override { return nullptr; };
void *lockResourceImpl(GraphicsAllocation &graphicsAllocation) override { return nullptr; };
void unlockResourceImpl(GraphicsAllocation &graphicsAllocation) override{};
};

66
opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp
View File

@@ -593,7 +593,6 @@ TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenSharedUnifiedM
TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithSingleBitSetWhenSharedUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) {
MockCommandQueue cmdQ;
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0x8)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
@@ -608,17 +607,19 @@ TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithSingleBitSetWh
}
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContextFlagTrueThenProperPropertiesArePassedToMemoryManager) {
MockCommandQueue cmdQ;
DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleSubDevices.set(4);
MockExecutionEnvironment executionEnvironment;
auto memoryManager = std::make_unique<MemoryManagerPropertiesCheck>(false, true, executionEnvironment);
auto svmManager = std::make_unique<MockSVMAllocsManager>(memoryManager.get(), false);
memoryManager->pageFaultManager = std::make_unique<MockPageFaultManager>();
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0xf)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
svmManager->multiOsContextSupport = true;
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
auto ptr = svmManager->createSharedUnifiedMemoryAllocation(4096u, unifiedMemoryProperties, &cmdQ);
EXPECT_FALSE(memoryManager->multiOsContextCapablePassed);
EXPECT_TRUE(memoryManager->multiStorageResourcePassed);
@@ -628,6 +629,7 @@ TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContext
}
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContextFlagFalseThenLowestSubDevicePassedToMemoryManager) {
MockCommandQueue cmdQ;
DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleSubDevices.set(4);
DebugManager.flags.OverrideLeastOccupiedBank.set(1);
@@ -635,12 +637,13 @@ TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContext
MockExecutionEnvironment executionEnvironment;
auto memoryManager = std::make_unique<MemoryManagerPropertiesCheck>(false, true, executionEnvironment);
auto svmManager = std::make_unique<MockSVMAllocsManager>(memoryManager.get(), false);
memoryManager->pageFaultManager = std::make_unique<MockPageFaultManager>();
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0xE)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
svmManager->multiOsContextSupport = false;
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
auto ptr = svmManager->createSharedUnifiedMemoryAllocation(4096u, unifiedMemoryProperties, &cmdQ);
auto expectedSubDevices = unifiedMemoryProperties.subdeviceBitfields.at(mockRootDeviceIndex);
expectedSubDevices.reset();
@@ -653,18 +656,64 @@ TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContext
svmManager->freeSVMAlloc(ptr);
}
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithSingleBitsSetWhenMultiOsContextFlagTrueThenProperPropertiesArePassedToMemoryManager) {
DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleSubDevices.set(1);
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenMultiOsContextFlagTrueAndDeviceMemoryThenProperPropertiesArePassedToMemoryManager) {
MockContext mockContext;
auto device = mockContext.getDevice(0u);
MockExecutionEnvironment executionEnvironment;
auto memoryManager = std::make_unique<MemoryManagerPropertiesCheck>(false, true, executionEnvironment);
auto svmManager = std::make_unique<MockSVMAllocsManager>(memoryManager.get(), false);
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0xf)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
unifiedMemoryProperties.device = &device->getDevice();
svmManager->multiOsContextSupport = true;
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
EXPECT_FALSE(memoryManager->multiOsContextCapablePassed);
EXPECT_TRUE(memoryManager->multiStorageResourcePassed);
EXPECT_EQ(unifiedMemoryProperties.subdeviceBitfields.at(mockRootDeviceIndex), memoryManager->subDevicesBitfieldPassed);
svmManager->freeSVMAlloc(ptr);
}
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithTwoBitsSetWhenMultiOsContextFlagTrueAndDeviceMemoryThenProperPropertiesArePassedToMemoryManager) {
MockContext mockContext;
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
MockExecutionEnvironment executionEnvironment;
auto memoryManager = std::make_unique<MemoryManagerPropertiesCheck>(false, true, executionEnvironment);
auto svmManager = std::make_unique<MockSVMAllocsManager>(memoryManager.get(), false);
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0x6)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
auto device = mockContext.getDevice(0u);
unifiedMemoryProperties.device = &device->getDevice();
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
EXPECT_FALSE(memoryManager->multiOsContextCapablePassed);
EXPECT_FALSE(memoryManager->multiStorageResourcePassed);
auto expectedSubDevices = unifiedMemoryProperties.subdeviceBitfields.at(mockRootDeviceIndex);
expectedSubDevices.reset();
expectedSubDevices.set(1);
EXPECT_EQ(expectedSubDevices, memoryManager->subDevicesBitfieldPassed);
svmManager->freeSVMAlloc(ptr);
}
TEST(UnifiedMemoryTest, givenDeviceBitfieldWithSingleBitsSetWhenMultiOsContextFlagTrueThenProperPropertiesArePassedToMemoryManager) {
MockCommandQueue cmdQ;
DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleSubDevices.set(1);
MockExecutionEnvironment executionEnvironment;
auto memoryManager = std::make_unique<MemoryManagerPropertiesCheck>(false, true, executionEnvironment);
auto svmManager = std::make_unique<MockSVMAllocsManager>(memoryManager.get(), false);
memoryManager->pageFaultManager = std::make_unique<MockPageFaultManager>();
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0x1)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
svmManager->multiOsContextSupport = true;
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
auto ptr = svmManager->createSharedUnifiedMemoryAllocation(4096u, unifiedMemoryProperties, &cmdQ);
EXPECT_FALSE(memoryManager->multiOsContextCapablePassed);
EXPECT_FALSE(memoryManager->multiStorageResourcePassed);
@@ -674,11 +723,12 @@ TEST(UnifiedMemoryTest, givenDeviceBitfieldWithSingleBitsSetWhenMultiOsContextFl
}
TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithSingleBitSetWhenDeviceUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) {
MockCommandQueue cmdQ;
std::set<uint32_t> rootDeviceIndices{mockRootDeviceIndex};
std::map<uint32_t, DeviceBitfield> deviceBitfields{{mockRootDeviceIndex, DeviceBitfield(0x8)}};
SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::SHARED_UNIFIED_MEMORY, rootDeviceIndices, deviceBitfields);
auto ptr = svmManager->createUnifiedMemoryAllocation(4096u, unifiedMemoryProperties);
auto ptr = svmManager->createSharedUnifiedMemoryAllocation(4096u, unifiedMemoryProperties, &cmdQ);
EXPECT_FALSE(memoryManager->multiOsContextCapablePassed);
EXPECT_FALSE(memoryManager->multiStorageResourcePassed);

9
opencl/test/unit_test/mocks/mock_memory_manager.cpp
View File

@@ -33,6 +33,11 @@ void *MockMemoryManager::allocateSystemMemory(size_t size, size_t alignment) {
if (failAllocateSystemMemory) {
return nullptr;
}
if (fakeBigAllocations && size > bigAllocation) {
size = MemoryConstants::pageSize64k;
}
return OsAgnosticMemoryManager::allocateSystemMemory(redundancyRatio * size, alignment);
}
@@ -74,9 +79,9 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemoryForImage(const Allo
return allocation;
}
GraphicsAllocation *MockMemoryManager::allocateShareableMemory(const AllocationData &allocationData) {
GraphicsAllocation *MockMemoryManager::allocateMemoryByKMD(const AllocationData &allocationData) {
allocateForShareableCalled = true;
return OsAgnosticMemoryManager::allocateShareableMemory(allocationData);
return OsAgnosticMemoryManager::allocateMemoryByKMD(allocationData);
}
GraphicsAllocation *MockMemoryManager::allocateGraphicsMemory64kb(const AllocationData &allocationData) {

4
opencl/test/unit_test/mocks/mock_memory_manager.h
View File

@@ -73,7 +73,7 @@ class MockMemoryManager : public MemoryManagerCreate<OsAgnosticMemoryManager> {
void setDeferredDeleter(DeferredDeleter *deleter);
void overrideAsyncDeleterFlag(bool newValue);
GraphicsAllocation *allocateGraphicsMemoryForImage(const AllocationData &allocationData) override;
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override;
int redundancyRatio = 1;
GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const AllocationData &allocationData, AllocationStatus &status) override;
@@ -262,7 +262,7 @@ class FailMemoryManager : public MockMemoryManager {
GraphicsAllocation *allocateGraphicsMemoryForImage(const AllocationData &allocationData) override {
return nullptr;
}
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override {
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override {
return nullptr;
}
int32_t failedAllocationsCount = 0;

2
opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
View File

@@ -1096,7 +1096,7 @@ TEST_F(DrmMemoryManagerTest, GivenShareableEnabledWhenAskedToCreateGraphicsAlloc
allocationData.size = MemoryConstants::pageSize;
allocationData.flags.shareable = true;
auto allocation = memoryManager->allocateShareableMemory(allocationData);
auto allocation = memoryManager->allocateMemoryByKMD(allocationData);
EXPECT_NE(nullptr, allocation);
EXPECT_NE(0u, allocation->getGpuAddress());

2
opencl/test/unit_test/os_interface/windows/mock_wddm_memory_manager.h
View File

@@ -23,7 +23,7 @@ class MockWddmMemoryManager : public MemoryManagerCreate<WddmMemoryManager> {
using BaseClass::allocateGraphicsMemoryWithAlignment;
using BaseClass::allocateGraphicsMemoryWithGpuVa;
using BaseClass::allocateGraphicsMemoryWithProperties;
using BaseClass::allocateShareableMemory;
using BaseClass::allocateMemoryByKMD;
using BaseClass::createGraphicsAllocation;
using BaseClass::createWddmAllocation;
using BaseClass::getWddm;

20
opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -157,6 +157,22 @@ TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemory
memoryManager->freeGraphicsMemory(allocation);
}
class MockCreateWddmAllocationMemoryManager : public MockWddmMemoryManager {
public:
MockCreateWddmAllocationMemoryManager(NEO::ExecutionEnvironment &execEnv) : MockWddmMemoryManager(execEnv) {}
bool createWddmAllocation(WddmAllocation *allocation, void *requiredGpuPtr) override {
return false;
}
};
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWhenAllocateGraphicsMemoryFailedThenNullptrFromAllocateMemoryByKMDIsReturned) {
memoryManager.reset(new MockCreateWddmAllocationMemoryManager(*executionEnvironment));
AllocationData allocationData;
allocationData.size = MemoryConstants::pageSize;
auto allocation = memoryManager->allocateMemoryByKMD(allocationData);
EXPECT_EQ(nullptr, allocation);
}
TEST_F(WddmMemoryManagerSimpleTest, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemory64kbIsCalledThenMemoryPoolIsSystem64KBPages) {
memoryManager.reset(new MockWddmMemoryManager(false, false, *executionEnvironment));
AllocationData allocationData;
@@ -353,7 +369,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndSmallSizeWhenAskedTo
AllocationData allocationData;
allocationData.size = 4096u;
allocationData.flags.shareable = true;
auto allocation = memoryManager->allocateShareableMemory(allocationData);
auto allocation = memoryManager->allocateMemoryByKMD(allocationData);
EXPECT_NE(nullptr, allocation);
EXPECT_FALSE(memoryManager->allocateHugeGraphicsMemoryCalled);
memoryManager->freeGraphicsMemory(allocation);
@@ -365,7 +381,7 @@ TEST_F(WddmMemoryManagerSimpleTest, GivenShareableEnabledAndHugeSizeWhenAskedToC
AllocationData allocationData;
allocationData.size = 2ULL * MemoryConstants::pageSize64k;
allocationData.flags.shareable = true;
auto allocation = memoryManager->allocateShareableMemory(allocationData);
auto allocation = memoryManager->allocateMemoryByKMD(allocationData);
EXPECT_NE(nullptr, allocation);
EXPECT_TRUE(memoryManager->allocateHugeGraphicsMemoryCalled);
memoryManager->freeGraphicsMemory(allocation);

3
shared/source/memory_manager/allocation_properties.h
View File

@@ -103,7 +103,8 @@ struct AllocationData {
uint32_t isUSMHostAllocation : 1;
uint32_t use32BitFrontWindow : 1;
uint32_t crossRootDeviceAccess : 1;
uint32_t reserved : 17;
uint32_t isUSMDeviceMemory : 1;
uint32_t reserved : 16;
} flags;
uint32_t allFlags = 0;
};

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

@@ -402,6 +402,7 @@ bool MemoryManager::getAllocationData(AllocationData &allocationData, const Allo
}
allocationData.flags.shareable = properties.flags.shareable;
allocationData.flags.isUSMDeviceMemory = properties.flags.isUSMDeviceAllocation;
allocationData.flags.requiresCpuAccess = GraphicsAllocation::isCpuAccessRequired(properties.allocationType);
allocationData.flags.allocateMemory = properties.flags.allocateMemory;
allocationData.flags.allow32Bit = allow32Bit;
@@ -501,8 +502,8 @@ GraphicsAllocation *MemoryManager::allocateGraphicsMemory(const AllocationData &
UNRECOVERABLE_IF(allocationData.imgInfo == nullptr);
return allocateGraphicsMemoryForImage(allocationData);
}
if (allocationData.flags.shareable) {
return allocateShareableMemory(allocationData);
if (allocationData.flags.shareable || allocationData.flags.isUSMDeviceMemory) {
return allocateMemoryByKMD(allocationData);
}
if (useNonSvmHostPtrAlloc(allocationData.type, allocationData.rootDeviceIndex) || isNonSvmBuffer(allocationData.hostPtr, allocationData.type, allocationData.rootDeviceIndex)) {
auto allocation = allocateGraphicsMemoryForNonSvmHostPtr(allocationData);

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

@@ -239,7 +239,7 @@ class MemoryManager {
GraphicsAllocation *allocateGraphicsMemoryForImageFromHostPtr(const AllocationData &allocationData);
MOCKABLE_VIRTUAL GraphicsAllocation *allocateGraphicsMemoryForImage(const AllocationData &allocationData);
virtual GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const AllocationData &allocationData, std::unique_ptr<Gmm> gmm) = 0;
virtual GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) = 0;
virtual GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) = 0;
virtual void *lockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0;
virtual void unlockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0;
virtual void freeAssociatedResourceImpl(GraphicsAllocation &graphicsAllocation) { return unlockResourceImpl(graphicsAllocation); };

2
shared/source/memory_manager/os_agnostic_memory_manager.cpp
View File

@@ -325,7 +325,7 @@ void OsAgnosticMemoryManager::cleanOsHandles(OsHandleStorage &handleStorage, uin
}
}
GraphicsAllocation *OsAgnosticMemoryManager::allocateShareableMemory(const AllocationData &allocationData) {
GraphicsAllocation *OsAgnosticMemoryManager::allocateMemoryByKMD(const AllocationData &allocationData) {
auto gmm = std::make_unique<Gmm>(executionEnvironment.rootDeviceEnvironments[allocationData.rootDeviceIndex]->getGmmClientContext(), allocationData.hostPtr, allocationData.size, 0u, false);
GraphicsAllocation *alloc = nullptr;

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

@@ -98,7 +98,7 @@ class OsAgnosticMemoryManager : public MemoryManager {
GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const AllocationData &allocationData) override;
GraphicsAllocation *allocateUSMHostGraphicsMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemory64kb(const AllocationData &allocationData) override;
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override;
GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const AllocationData &allocationData) override;
@@ -108,10 +108,10 @@ class OsAgnosticMemoryManager : public MemoryManager {
GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const AllocationData &allocationData, AllocationStatus &status) override;
MemoryAllocation *createMemoryAllocation(GraphicsAllocation::AllocationType allocationType, void *driverAllocatedCpuPointer, void *pMem, uint64_t gpuAddress, size_t memSize,
uint64_t count, MemoryPool::Type pool, uint32_t rootDeviceIndex, bool uncacheable, bool flushL3Required, bool requireSpecificBitness);
bool fakeBigAllocations = false;
private:
unsigned long long counter = 0;
bool fakeBigAllocations = false;
};
} // namespace NEO

7
shared/source/memory_manager/unified_memory_manager.cpp
View File

@@ -195,14 +195,15 @@ void *SVMAllocsManager::createUnifiedMemoryAllocation(size_t size,
false,
multiStorageAllocation,
deviceBitfield};
unifiedMemoryProperties.flags.isUSMDeviceAllocation = false;
unifiedMemoryProperties.flags.shareable = memoryProperties.allocationFlags.flags.shareable;
unifiedMemoryProperties.flags.isUSMDeviceAllocation = true;
unifiedMemoryProperties.cacheRegion = MemoryPropertiesHelper::getCacheRegion(memoryProperties.allocationFlags);
unifiedMemoryProperties.flags.uncacheable = memoryProperties.allocationFlags.flags.locallyUncachedResource;
if (memoryProperties.memoryType == InternalMemoryType::HOST_UNIFIED_MEMORY) {
if (memoryProperties.memoryType == InternalMemoryType::DEVICE_UNIFIED_MEMORY) {
unifiedMemoryProperties.flags.isUSMDeviceAllocation = true;
} else if (memoryProperties.memoryType == InternalMemoryType::HOST_UNIFIED_MEMORY) {
unifiedMemoryProperties.flags.isUSMHostAllocation = true;
unifiedMemoryProperties.flags.isUSMDeviceAllocation = false;
}
GraphicsAllocation *unifiedMemoryAllocation = memoryManager->allocateGraphicsMemoryWithProperties(unifiedMemoryProperties);

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

@@ -452,7 +452,7 @@ DrmAllocation *DrmMemoryManager::allocateGraphicsMemory64kb(const AllocationData
return nullptr;
}
GraphicsAllocation *DrmMemoryManager::allocateShareableMemory(const AllocationData &allocationData) {
GraphicsAllocation *DrmMemoryManager::allocateMemoryByKMD(const AllocationData &allocationData) {
auto gmm = std::make_unique<Gmm>(executionEnvironment.rootDeviceEnvironments[allocationData.rootDeviceIndex]->getGmmClientContext(), allocationData.hostPtr, allocationData.size, 0u, false);
size_t bufferSize = allocationData.size;
uint64_t gpuRange = acquireGpuRange(bufferSize, allocationData.rootDeviceIndex, HeapIndex::HEAP_STANDARD64KB);

2
shared/source/os_interface/linux/drm_memory_manager.h
View File

@@ -99,7 +99,7 @@ class DrmMemoryManager : public MemoryManager {
DrmAllocation *allocateUSMHostGraphicsMemory(const AllocationData &allocationData) override;
DrmAllocation *allocateGraphicsMemoryWithHostPtr(const AllocationData &allocationData) override;
DrmAllocation *allocateGraphicsMemory64kb(const AllocationData &allocationData) override;
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override;
GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const AllocationData &allocationData) override;
GraphicsAllocation *createSharedUnifiedMemoryAllocation(const AllocationData &allocationData);

1
shared/source/os_interface/windows/wddm/wddm.cpp
View File

@@ -506,6 +506,7 @@ NTSTATUS Wddm::createAllocation(const void *alignedCpuPtr, const Gmm *gmm, D3DKM
AllocationInfo.PrivateDriverDataSize = static_cast<uint32_t>(gmm->gmmResourceInfo->peekHandleSize());
CreateAllocation.NumAllocations = 1;
CreateAllocation.Flags.CreateShared = outSharedHandle ? TRUE : FALSE;
CreateAllocation.Flags.NtSecuritySharing = outSharedHandle ? TRUE : FALSE;
CreateAllocation.Flags.CreateResource = outSharedHandle || alignedCpuPtr ? TRUE : FALSE;
CreateAllocation.pAllocationInfo2 = &AllocationInfo;
CreateAllocation.hDevice = device;

2
shared/source/os_interface/windows/wddm_memory_manager.cpp
View File

@@ -61,7 +61,7 @@ WddmMemoryManager::WddmMemoryManager(ExecutionEnvironment &executionEnvironment)
initialized = true;
}
GraphicsAllocation *WddmMemoryManager::allocateShareableMemory(const AllocationData &allocationData) {
GraphicsAllocation *WddmMemoryManager::allocateMemoryByKMD(const AllocationData &allocationData) {
if (allocationData.size > getHugeGfxMemoryChunkSize(GfxMemoryAllocationMethod::AllocateByKmd)) {
return allocateHugeGraphicsMemory(allocationData, false);
}

4
shared/source/os_interface/windows/wddm_memory_manager.h
View File

@@ -79,7 +79,7 @@ class WddmMemoryManager : public MemoryManager {
GraphicsAllocation *allocateUSMHostGraphicsMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemoryWithHostPtr(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemory64kb(const AllocationData &allocationData) override;
GraphicsAllocation *allocateShareableMemory(const AllocationData &allocationData) override;
GraphicsAllocation *allocateMemoryByKMD(const AllocationData &allocationData) override;
GraphicsAllocation *allocateGraphicsMemoryForImageImpl(const AllocationData &allocationData, std::unique_ptr<Gmm> gmm) override;
GraphicsAllocation *allocateGraphicsMemoryWithGpuVa(const AllocationData &allocationData) override { return nullptr; }
@@ -98,7 +98,7 @@ class WddmMemoryManager : public MemoryManager {
GraphicsAllocation *createAllocationFromHandle(osHandle handle, bool requireSpecificBitness, bool ntHandle, GraphicsAllocation::AllocationType allocationType, uint32_t rootDeviceIndex);
static bool validateAllocation(WddmAllocation *alloc);
bool createWddmAllocation(WddmAllocation *allocation, void *requiredGpuPtr);
MOCKABLE_VIRTUAL bool createWddmAllocation(WddmAllocation *allocation, void *requiredGpuPtr);
bool mapGpuVirtualAddress(WddmAllocation *graphicsAllocation, const void *requiredGpuPtr);
bool mapGpuVaForOneHandleAllocation(WddmAllocation *graphicsAllocation, const void *requiredGpuPtr);
bool mapMultiHandleAllocationWithRetry(WddmAllocation *allocation, const void *requiredGpuPtr);

2
shared/test/common/mocks/linux/mock_drm_memory_manager.h
View File

@@ -69,7 +69,7 @@ class TestedDrmMemoryManager : public MemoryManagerCreate<DrmMemoryManager> {
using DrmMemoryManager::allocateGraphicsMemoryForNonSvmHostPtr;
using DrmMemoryManager::allocateGraphicsMemoryWithAlignment;
using DrmMemoryManager::allocateGraphicsMemoryWithHostPtr;
using DrmMemoryManager::allocateShareableMemory;
using DrmMemoryManager::allocateMemoryByKMD;
using DrmMemoryManager::allocUserptr;
using DrmMemoryManager::createAllocWithAlignment;
using DrmMemoryManager::createAllocWithAlignmentFromUserptr;