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

Add support for USM shared in WSL for dGPU

Browse Source 
This patch force KMD allocation path for USM shared
Additionally we force 64kb page from lock which is
required to properly program GPU VA

Related-To: NEO-6913
Signed-off-by: Kamil Diedrich kamil.diedrich@intel.com
This commit is contained in:
Kamil Diedrich
2022-11-23 00:11:25 +01:00
committed by Compute-Runtime-Automation
parent bc619fcbec
commit 44d8a6ae2b
7 changed files with 166 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
shared/test/unit_test/os_interface/windows/CMakeLists.txt
View File

@@ -24,6 +24,7 @@ if(WIN32)
${CMAKE_CURRENT_SOURCE_DIR}/wddm_address_space_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_command_stream_l0_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_mapper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_memory_manager_test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_preemption_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_shared_allocations_test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/wddm_special_heap_test.cpp

144
shared/test/unit_test/os_interface/windows/wddm_memory_manager_test.cpp Normal file
View File

@@ -0,0 +1,144 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/helpers/execution_environment_helper.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
#include "shared/test/common/os_interface/windows/mock_wddm_memory_manager.h"
#include "shared/test/common/os_interface/windows/wddm_fixture.h"
using namespace NEO;
using namespace ::testing;
class MockAllocateGraphicsMemoryWithAlignmentWddm : public MemoryManagerCreate<WddmMemoryManager> {
public:
using WddmMemoryManager::allocateGraphicsMemoryWithAlignment;
MockAllocateGraphicsMemoryWithAlignmentWddm(ExecutionEnvironment &executionEnvironment) : MemoryManagerCreate(false, false, executionEnvironment) {}
bool allocateSystemMemoryAndCreateGraphicsAllocationFromItCalled = false;
bool allocateGraphicsMemoryUsingKmdAndMapItToCpuVACalled = false;
bool mapGpuVirtualAddressWithCpuPtr = false;
GraphicsAllocation *allocateSystemMemoryAndCreateGraphicsAllocationFromIt(const AllocationData &allocationData) override {
allocateSystemMemoryAndCreateGraphicsAllocationFromItCalled = true;
return nullptr;
}
GraphicsAllocation *allocateGraphicsMemoryUsingKmdAndMapItToCpuVA(const AllocationData &allocationData, bool allowLargePages) override {
allocateGraphicsMemoryUsingKmdAndMapItToCpuVACalled = true;
return nullptr;
}
bool mapGpuVirtualAddress(WddmAllocation *graphicsAllocation, const void *requiredGpuPtr) override {
if (requiredGpuPtr != nullptr) {
mapGpuVirtualAddressWithCpuPtr = true;
} else {
mapGpuVirtualAddressWithCpuPtr = false;
}
return true;
}
};
class WddmMemoryManagerTests : public ::testing::Test {
public:
MockAllocateGraphicsMemoryWithAlignmentWddm *memoryManager = nullptr;
WddmMock *wddm = nullptr;
ExecutionEnvironment *executionEnvironment = nullptr;
void SetUp() override {
HardwareInfo *hwInfo = nullptr;
executionEnvironment = getExecutionEnvironmentImpl(hwInfo, 1);
memoryManager = new MockAllocateGraphicsMemoryWithAlignmentWddm(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
wddm = static_cast<WddmMock *>(executionEnvironment->rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Wddm>());
}
void TearDown() override {
delete executionEnvironment;
}
};
TEST_F(WddmMemoryManagerTests, GivenAllocDataWithSVMCPUSetWhenAllocateGraphicsMemoryWithAlignmentThenProperFunctionIsUsed) {
NEO::AllocationData allocData = {};
allocData.type = NEO::AllocationType::SVM_CPU;
allocData.forceKMDAllocation = true;
allocData.makeGPUVaDifferentThanCPUPtr = true;
memoryManager->allocateGraphicsMemoryWithAlignment(allocData);
if (preferredAllocationMethod == GfxMemoryAllocationMethod::AllocateByKmd) {
EXPECT_TRUE(memoryManager->allocateGraphicsMemoryUsingKmdAndMapItToCpuVACalled);
} else {
EXPECT_TRUE(memoryManager->allocateSystemMemoryAndCreateGraphicsAllocationFromItCalled);
}
}
class MockAllocateGraphicsMemoryUsingKmdAndMapItToCpuVAWddm : public MemoryManagerCreate<WddmMemoryManager> {
public:
using WddmMemoryManager::allocateGraphicsMemoryUsingKmdAndMapItToCpuVA;
using WddmMemoryManager::mapGpuVirtualAddress;
MockAllocateGraphicsMemoryUsingKmdAndMapItToCpuVAWddm(ExecutionEnvironment &executionEnvironment) : MemoryManagerCreate(false, false, executionEnvironment) {}
bool mapGpuVirtualAddressWithCpuPtr = false;
bool mapGpuVirtualAddress(WddmAllocation *graphicsAllocation, const void *requiredGpuPtr) override {
if (requiredGpuPtr != nullptr) {
mapGpuVirtualAddressWithCpuPtr = true;
} else {
mapGpuVirtualAddressWithCpuPtr = false;
}
return true;
}
};
class WddmMemoryManagerAllocPathTests : public ::testing::Test {
public:
MockAllocateGraphicsMemoryUsingKmdAndMapItToCpuVAWddm *memoryManager = nullptr;
WddmMock *wddm = nullptr;
ExecutionEnvironment *executionEnvironment = nullptr;
void SetUp() override {
HardwareInfo *hwInfo = nullptr;
executionEnvironment = getExecutionEnvironmentImpl(hwInfo, 1);
memoryManager = new MockAllocateGraphicsMemoryUsingKmdAndMapItToCpuVAWddm(*executionEnvironment);
executionEnvironment->memoryManager.reset(memoryManager);
wddm = static_cast<WddmMock *>(executionEnvironment->rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Wddm>());
}
void TearDown() override {
delete executionEnvironment;
}
};
TEST_F(WddmMemoryManagerAllocPathTests, givenAllocateGraphicsMemoryUsingKmdAndMapItToCpuVAWhenPreferedAllocationMethodThenProperArgumentsAreSet) {
{
NEO::AllocationData allocData = {};
allocData.type = NEO::AllocationType::SVM_CPU;
allocData.forceKMDAllocation = true;
allocData.makeGPUVaDifferentThanCPUPtr = true;
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryUsingKmdAndMapItToCpuVA(allocData, false);
if (preferredAllocationMethod == GfxMemoryAllocationMethod::AllocateByKmd) {
EXPECT_FALSE(memoryManager->mapGpuVirtualAddressWithCpuPtr);
} else {
EXPECT_TRUE(memoryManager->mapGpuVirtualAddressWithCpuPtr);
}
memoryManager->freeGraphicsMemory(graphicsAllocation);
}
{
NEO::AllocationData allocData = {};
allocData.type = NEO::AllocationType::EXTERNAL_HOST_PTR;
auto graphicsAllocation = memoryManager->allocateGraphicsMemoryUsingKmdAndMapItToCpuVA(allocData, false);
EXPECT_TRUE(memoryManager->mapGpuVirtualAddressWithCpuPtr);
memoryManager->freeGraphicsMemory(graphicsAllocation);
}
}