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

Simplify Memory Manager API [2/n]

Browse Source 
- make AllocationData a protected structure
- use AllocationProperties instead of AllocationFlags
- refactor methods: allocateGraphicsMemory64kb, allocateGraphicsMemoryForSVM
- call AllocateGraphicsMemoryInPreferredPool in AllocateGraphicsMemory
  where there is no host ptr

Change-Id: Ie9ca47b1bccacd00f8486e7d1bf6fb3985e5cb12
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2018-12-06 15:03:06 +01:00
committed by sys_ocldev
parent 7e397b0132
commit a6be6533ea
36 changed files with 229 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
runtime/memory_manager/memory_manager.h
View File

@@ -59,7 +59,7 @@ struct AllocationProperties {
flags.flushL3RequiredForWrite = 1;
}
AllocationProperties(bool allocateMemory) {
AllocationProperties(bool allocateMemory, size_t size) : size(size) {
allFlags = 0;
flags.flushL3RequiredForRead = 1;
flags.flushL3RequiredForWrite = 1;
@@ -67,31 +67,6 @@ struct AllocationProperties {
}
};
using AllocationFlags = AllocationProperties;
struct AllocationData {
union {
struct {
uint32_t mustBeZeroCopy : 1;
uint32_t allocateMemory : 1;
uint32_t allow64kbPages : 1;
uint32_t allow32Bit : 1;
uint32_t useSystemMemory : 1;
uint32_t forcePin : 1;
uint32_t uncacheable : 1;
uint32_t flushL3 : 1;
uint32_t reserved : 24;
} flags;
uint32_t allFlags = 0;
};
static_assert(sizeof(AllocationData::flags) == sizeof(AllocationData::allFlags), "");
GraphicsAllocation::AllocationType type = GraphicsAllocation::AllocationType::UNKNOWN;
const void *hostPtr = nullptr;
size_t size = 0;
size_t alignment = 0;
DevicesBitfield devicesBitfield = 0;
};
struct AlignedMallocRestrictions {
uintptr_t minAddress;
};
@@ -119,22 +94,13 @@ class MemoryManager {
virtual void removeAllocationFromHostPtrManager(GraphicsAllocation *memory) = 0;
GraphicsAllocation *allocateGraphicsMemory(size_t size) {
AllocationData allocationData;
allocationData.size = size;
allocationData.alignment = MemoryConstants::preferredAlignment;
return allocateGraphicsMemoryWithAlignment(allocationData);
return allocateGraphicsMemoryInPreferredPool(AllocationProperties(true, size), 0u, nullptr, GraphicsAllocation::AllocationType::UNDECIDED);
}
GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) {
AllocationData allocationData;
allocationData.alignment = properties.alignment;
allocationData.size = properties.size;
allocationData.flags.uncacheable = properties.flags.uncacheable;
allocationData.flags.forcePin = properties.flags.forcePin;
return allocateGraphicsMemoryWithAlignment(allocationData);
return allocateGraphicsMemoryInPreferredPool(properties, 0u, nullptr, GraphicsAllocation::AllocationType::UNDECIDED);
}
virtual GraphicsAllocation *allocateGraphicsMemory64kb(size_t size, size_t alignment, bool forcePin, bool preferRenderCompressed) = 0;
virtual GraphicsAllocation *allocateGraphicsMemoryForNonSvmHostPtr(size_t size, void *cpuPtr) = 0;
virtual GraphicsAllocation *allocateGraphicsMemory(size_t size, const void *ptr) {
@@ -160,7 +126,7 @@ class MemoryManager {
virtual GraphicsAllocation *allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) = 0;
MOCKABLE_VIRTUAL GraphicsAllocation *allocateGraphicsMemoryInPreferredPool(AllocationFlags flags, DevicesBitfield devicesBitfield, const void *hostPtr, size_t size, GraphicsAllocation::AllocationType type);
GraphicsAllocation *allocateGraphicsMemoryInPreferredPool(AllocationProperties properties, DevicesBitfield devicesBitfield, const void *hostPtr, GraphicsAllocation::AllocationType type);
GraphicsAllocation *allocateGraphicsMemoryForSVM(size_t size, bool coherent);
@@ -168,21 +134,6 @@ class MemoryManager {
virtual GraphicsAllocation *createGraphicsAllocationFromNTHandle(void *handle) = 0;
virtual GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const AllocationData &allocationData, AllocationStatus &status) {
status = AllocationStatus::Error;
if (!allocationData.flags.useSystemMemory && !(allocationData.flags.allow32Bit && this->force32bitAllocations)) {
auto allocation = allocateGraphicsMemory(allocationData);
if (allocation) {
allocation->devicesBitfield = allocationData.devicesBitfield;
allocation->flushL3Required = allocationData.flags.flushL3;
status = AllocationStatus::Success;
}
return allocation;
}
status = AllocationStatus::RetryInNonDevicePool;
return nullptr;
}
virtual bool mapAuxGpuVA(GraphicsAllocation *graphicsAllocation) { return false; };
virtual void *lockResource(GraphicsAllocation *graphicsAllocation) = 0;
@@ -251,12 +202,51 @@ class MemoryManager {
void setDefaultEngineIndex(uint32_t index) { defaultEngineIndex = index; }
protected:
static bool getAllocationData(AllocationData &allocationData, const AllocationFlags &flags, const DevicesBitfield devicesBitfield,
const void *hostPtr, size_t size, GraphicsAllocation::AllocationType type);
struct AllocationData {
union {
struct {
uint32_t mustBeZeroCopy : 1;
uint32_t allocateMemory : 1;
uint32_t allow64kbPages : 1;
uint32_t allow32Bit : 1;
uint32_t useSystemMemory : 1;
uint32_t forcePin : 1;
uint32_t uncacheable : 1;
uint32_t flushL3 : 1;
uint32_t preferRenderCompressed : 1;
uint32_t reserved : 23;
} flags;
uint32_t allFlags = 0;
};
static_assert(sizeof(AllocationData::flags) == sizeof(AllocationData::allFlags), "");
GraphicsAllocation::AllocationType type = GraphicsAllocation::AllocationType::UNKNOWN;
const void *hostPtr = nullptr;
size_t size = 0;
size_t alignment = 0;
DevicesBitfield devicesBitfield = 0;
};
static bool getAllocationData(AllocationData &allocationData, const AllocationProperties &properties, const DevicesBitfield devicesBitfield,
const void *hostPtr, GraphicsAllocation::AllocationType type);
GraphicsAllocation *allocateGraphicsMemory(const AllocationData &allocationData);
virtual GraphicsAllocation *allocateGraphicsMemoryWithHostPtr(const AllocationData &allocationData);
virtual GraphicsAllocation *allocateGraphicsMemoryWithAlignment(const AllocationData &allocationData) = 0;
virtual GraphicsAllocation *allocateGraphicsMemory64kb(AllocationData allocationData) = 0;
virtual GraphicsAllocation *allocateGraphicsMemoryInDevicePool(const AllocationData &allocationData, AllocationStatus &status) {
status = AllocationStatus::Error;
if (!allocationData.flags.useSystemMemory && !(allocationData.flags.allow32Bit && this->force32bitAllocations)) {
auto allocation = allocateGraphicsMemory(allocationData);
if (allocation) {
allocation->devicesBitfield = allocationData.devicesBitfield;
allocation->flushL3Required = allocationData.flags.flushL3;
status = AllocationStatus::Success;
}
return allocation;
}
status = AllocationStatus::RetryInNonDevicePool;
return nullptr;
}
bool force32bitAllocations = false;
bool virtualPaddingAvailable = false;