Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor gem creation with extensions

Browse Source 
Related-To: NEO-6149

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2021-09-14 12:36:43 +00:00
committed by Compute-Runtime-Automation
parent d4a4c35759
commit 5c1c96fa94
10 changed files with 154 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
opencl/test/unit_test/os_interface/linux/drm_memory_info_tests.cpp
View File

@ -19,6 +19,12 @@ struct MemoryInfoImpl : public NEO::MemoryInfo {
size_t getMemoryRegionSize(uint32_t memoryBank) override {
return 0u;
}
uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override {
return 0u;
}
uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
return 0u;
}
};
TEST(DrmTest, whenQueryingMemoryInfoThenMemoryInfoIsNotCreatedAndNoIoctlsAreCalled) {

45
opencl/test/unit_test/os_interface/linux/drm_memory_info_tests_dg1.cpp
View File

@ -221,3 +221,48 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenGettingMemoryRegionClassAndInstan
regionSize = memoryInfo->getMemoryRegionSize(MemoryBanks::getBankForLocalMemory(1));
EXPECT_EQ(32 * GB, regionSize);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenCreatingGemWithExtensionsThenReturnCorrectValues) {
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probed_size = 16 * GB;
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExt(drm.get(), &regionInfo, 2, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_EQ(1024u, drm->createExt.size);
}
TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenCreatingGemExtWithSingleRegionThenReturnCorrectValues) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableLocalMemory.set(1);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[0].probed_size = 8 * GB;
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
regionInfo[1].probed_size = 16 * GB;
auto memoryInfo = std::make_unique<MemoryInfoImpl>(regionInfo, 2);
ASSERT_NE(nullptr, memoryInfo);
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
auto drm = std::make_unique<DrmMockDg1>(*executionEnvironment->rootDeviceEnvironments[0]);
uint32_t handle = 0;
auto ret = memoryInfo->createGemExtWithSingleRegion(drm.get(), 1, 1024, handle);
EXPECT_EQ(1u, handle);
EXPECT_EQ(0u, ret);
EXPECT_EQ(1u, drm->ioctlCallsCount);
EXPECT_EQ(I915_MEMORY_CLASS_DEVICE, drm->memRegions.memory_class);
EXPECT_EQ(1024u, drm->createExt.size);
}

23
opencl/test/unit_test/os_interface/linux/drm_memory_manager_local_memory_tests_dg1.cpp
View File

@ -1718,4 +1718,27 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithUnifiedMemoryAllocati
EXPECT_EQ(MemoryManager::AllocationStatus::Error, status);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, whenPrintBOCreateDestroyResultFlagIsSetWhileCreatingBufferObjectInMemoryRegionThenDebugInformationIsPrinted) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.PrintBOCreateDestroyResult.set(true);
DebugManager.flags.EnableLocalMemory.set(1);
drm_i915_memory_region_info regionInfo[2] = {};
regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
mock->memoryInfo.reset(new MemoryInfoImpl(regionInfo, 2));
auto gpuAddress = 0x1234u;
auto size = MemoryConstants::pageSize64k;
testing::internal::CaptureStdout();
auto bo = std::unique_ptr<BufferObject>(memoryManager->createBufferObjectInMemoryRegion(&memoryManager->getDrm(0), gpuAddress, size, (1 << (MemoryBanks::getBankForLocalMemory(0) - 1)), 1));
ASSERT_NE(nullptr, bo);
std::string output = testing::internal::GetCapturedStdout();
std::string expectedOutput("Performing GEM_CREATE_EXT with { size: 65536, param: 0x100000001, memory class: 1, memory instance: 0 }\nGEM_CREATE_EXT has returned: 0 BO-1 with size: 65536\n");
EXPECT_EQ(expectedOutput, output);
}
} // namespace NEO

9
opencl/test/unit_test/os_interface/linux/drm_mock_dg1.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -7,6 +7,8 @@
#pragma once
#include "shared/test/common/helpers/default_hw_info.h"
#include "opencl/test/unit_test/os_interface/linux/drm_mock.h"
#include "gtest/gtest.h"
@ -15,7 +17,10 @@ using namespace NEO;
class DrmMockDg1 : public DrmMock {
public:
DrmMockDg1(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) {}
DrmMockDg1(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMockDg1(rootDeviceEnvironment, defaultHwInfo.get()) {}
DrmMockDg1(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
rootDeviceEnvironment.setHwInfo(inputHwInfo);
}
uint32_t i915QuerySuccessCount = std::numeric_limits<uint32_t>::max();
uint32_t queryMemoryRegionInfoSuccessCount = std::numeric_limits<uint32_t>::max();

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

@ -1290,4 +1290,31 @@ GraphicsAllocation *DrmMemoryManager::allocateGraphicsMemoryInDevicePool(const A
return allocation.release();
}
BufferObject *DrmMemoryManager::createBufferObjectInMemoryRegion(Drm *drm,
uint64_t gpuAddress,
size_t size,
uint32_t memoryBanks,
size_t maxOsContextCount) {
auto memoryInfo = drm->getMemoryInfo();
if (!memoryInfo) {
return nullptr;
}
uint32_t handle = 0;
auto ret = memoryInfo->createGemExtWithSingleRegion(drm, memoryBanks, size, handle);
if (ret != 0) {
return nullptr;
}
auto bo = new (std::nothrow) BufferObject(drm, handle, size, maxOsContextCount);
if (!bo) {
return nullptr;
}
bo->setAddress(gpuAddress);
return bo;
}
} // namespace NEO

4
shared/source/os_interface/linux/drm_memory_manager_local_memory.cpp
View File

@ -13,10 +13,6 @@ bool DrmMemoryManager::createDrmAllocation(Drm *drm, DrmAllocation *allocation,
return false;
}
BufferObject *DrmMemoryManager::createBufferObjectInMemoryRegion(Drm *drm, uint64_t gpuAddress, size_t size, uint32_t memoryBanks, size_t maxOsContextCount) {
return nullptr;
}
DrmAllocation *DrmMemoryManager::createUSMHostAllocationFromSharedHandle(osHandle handle, const AllocationProperties &properties, bool hasMappedPtr) {
drm_prime_handle openFd = {0, 0, 0};
openFd.fd = handle;

44
shared/source/os_interface/linux/drm_memory_manager_local_memory_dg1.cpp
View File

@ -17,50 +17,6 @@
#include "shared/source/os_interface/linux/memory_info_impl.h"
namespace NEO {
BufferObject *DrmMemoryManager::createBufferObjectInMemoryRegion(Drm *drm,
uint64_t gpuAddress,
size_t size,
uint32_t memoryBanks,
size_t maxOsContextCount) {
auto memoryInfo = static_cast<MemoryInfoImpl *>(drm->getMemoryInfo());
if (!memoryInfo) {
return nullptr;
}
auto pHwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto regionClassAndInstance = memoryInfo->getMemoryRegionClassAndInstance(memoryBanks, *pHwInfo);
drm_i915_gem_memory_class_instance memRegions{};
memRegions.memory_class = regionClassAndInstance.memory_class;
memRegions.memory_instance = regionClassAndInstance.memory_instance;
drm_i915_gem_object_param regionParam{};
regionParam.size = 1;
regionParam.data = reinterpret_cast<uintptr_t>(&memRegions);
regionParam.param = I915_OBJECT_PARAM | I915_PARAM_MEMORY_REGIONS;
drm_i915_gem_create_ext_setparam setparamRegion{};
setparamRegion.base.name = I915_GEM_CREATE_EXT_SETPARAM;
setparamRegion.param = regionParam;
drm_i915_gem_create_ext createExt{};
createExt.size = size;
createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);
auto ret = drm->ioctl(DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
if (ret != 0) {
return nullptr;
}
auto bo = new (std::nothrow) BufferObject(drm, createExt.handle, size, maxOsContextCount);
if (!bo) {
return nullptr;
}
bo->setAddress(gpuAddress);
return bo;
}
GraphicsAllocation *DrmMemoryManager::createSharedUnifiedMemoryAllocation(const AllocationData &allocationData) {
return nullptr;
}

3
shared/source/os_interface/linux/memory_info.h
View File

@ -10,12 +10,15 @@
#include <cstdint>
namespace NEO {
class Drm;
class MemoryInfo {
public:
MemoryInfo() = default;
virtual ~MemoryInfo() = 0;
virtual size_t getMemoryRegionSize(uint32_t memoryBank) = 0;
virtual uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) = 0;
virtual uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) = 0;
};
inline MemoryInfo::~MemoryInfo(){};

33
shared/source/os_interface/linux/memory_info_impl.cpp
View File

@ -27,6 +27,39 @@ MemoryInfoImpl::MemoryInfoImpl(const drm_i915_memory_region_info *regionInfo, si
});
}
uint32_t MemoryInfoImpl::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
drm_i915_gem_object_param regionParam{};
regionParam.size = dataSize;
regionParam.data = reinterpret_cast<uintptr_t>(data);
regionParam.param = I915_OBJECT_PARAM | I915_PARAM_MEMORY_REGIONS;
drm_i915_gem_create_ext_setparam setparamRegion{};
setparamRegion.base.name = I915_GEM_CREATE_EXT_SETPARAM;
setparamRegion.param = regionParam;
drm_i915_gem_create_ext createExt{};
createExt.size = allocSize;
createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "Performing GEM_CREATE_EXT with { size: %lu, param: 0x%llX",
allocSize, regionParam.param);
if (DebugManager.flags.PrintBOCreateDestroyResult.get()) {
for (uint32_t i = 0; i < dataSize; i++) {
auto region = reinterpret_cast<drm_i915_gem_memory_class_instance *>(data)[i];
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, ", memory class: %d, memory instance: %d",
region.memory_class, region.memory_instance);
}
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
}
auto ret = drm->ioctl(DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
handle = createExt.handle;
return ret;
}
void MemoryInfoImpl::assignRegionsFromDistances(const void *distanceInfosPtr, size_t size) {
}

10
shared/source/os_interface/linux/memory_info_impl.h
View File

@ -6,6 +6,7 @@
*/
#pragma once
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/helpers/hw_helper.h"
@ -29,6 +30,8 @@ class MemoryInfoImpl : public MemoryInfo {
void assignRegionsFromDistances(const void *distanceInfosPtr, size_t size);
uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override;
drm_i915_gem_memory_class_instance getMemoryRegionClassAndInstance(uint32_t memoryBank, const HardwareInfo &hwInfo) {
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
if (!hwHelper.getEnableLocalMemory(hwInfo) || memoryBank == 0) {
@ -73,6 +76,13 @@ class MemoryInfoImpl : public MemoryInfo {
}
}
uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
auto pHwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
auto regionClassAndInstance = getMemoryRegionClassAndInstance(memoryBanks, *pHwInfo);
auto ret = createGemExt(drm, &regionClassAndInstance, 1, allocSize, handle);
return ret;
}
const RegionContainer &getDrmRegionInfos() const { return drmQueryRegions; }
protected: