Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add GfxPartition::initAdditionalRange() stub 

Related-To: NEO-2941

Change-Id: Iec74652a5ee2cc79af9093d520e892cb30045cdf
Signed-off-by: Venevtsev, Igor <igor.venevtsev@intel.com>
This commit is contained in:
Venevtsev, Igor 2019-09-10 14:59:45 +02:00 committed by sys_ocldev
parent 5c120893ed
commit 3fab76d95e
8 changed files with 150 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Jenkinsfile vendored
View File

@ -1,5 +1,5 @@
#!groovy
dependenciesRevision='3387a68d271545925f5ff091109728166e6f6d46-1309'
strategy='EQUAL'
allowedCD=260
allowedCD=259
allowedF=5

1
core/memory_manager/CMakeLists.txt
View File

@ -9,6 +9,7 @@ set(NEO_CORE_MEMORY_MANAGER
${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}/engine_limits.h
${CMAKE_CURRENT_SOURCE_DIR}/eviction_status.h
${CMAKE_CURRENT_SOURCE_DIR}/gfx_partition.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/gfx_partition_init_additional_range.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gfx_partition.h
${CMAKE_CURRENT_SOURCE_DIR}/host_ptr_defines.h
${CMAKE_CURRENT_SOURCE_DIR}/local_memory_usage.cpp

2
core/memory_manager/gfx_partition.cpp
View File

@ -125,7 +125,7 @@ void GfxPartition::init(uint64_t gpuAddressSpace, size_t cpuAddressRangeSizeToRe
gfxBase = 0ull;
heapInit(HeapIndex::HEAP_SVM, 0ull, 0ull);
} else {
UNRECOVERABLE_IF("Invalid GPU Address Range!");
initAdditionalRange(gpuAddressSpace, gfxBase, gfxTop);
}
}

2
core/memory_manager/gfx_partition.h
View File

@ -70,6 +70,8 @@ class GfxPartition {
static const std::array<HeapIndex, 6> heapNonSvmNames;
protected:
void initAdditionalRange(uint64_t gpuAddressSpace, uint64_t &gfxBase, uint64_t &gfxTop);
class Heap {
public:
Heap() = default;

16
core/memory_manager/gfx_partition_init_additional_range.cpp Normal file
View File

@ -0,0 +1,16 @@
/*
* Copyright (C) 2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/memory_manager/gfx_partition.h"
namespace NEO {
void GfxPartition::initAdditionalRange(uint64_t gpuAddressSpace, uint64_t &gfxBase, uint64_t &gfxTop) {
UNRECOVERABLE_IF("Invalid GPU Address Range!");
}
} // namespace NEO

3
unit_tests/memory_manager/CMakeLists.txt
View File

@ -10,7 +10,8 @@ set(IGDRCL_SRCS_tests_memory_manager
${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_memory_sync_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/deferrable_allocation_deletion_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_mt_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gfx_partition_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/gfx_partition_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gfx_partition_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/graphics_allocation_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/host_ptr_manager_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/internal_allocation_storage_tests.cpp

105
unit_tests/memory_manager/gfx_partition_tests.cpp
View File

@ -5,107 +5,4 @@
*
*/
#include "core/helpers/aligned_memory.h"
#include "core/helpers/basic_math.h"
#include "core/helpers/ptr_math.h"
#include "core/os_interface/os_memory.h"
#include "unit_tests/mocks/mock_gfx_partition.h"
#include "gtest/gtest.h"
using namespace NEO;
void testGfxPartition(uint64_t gpuAddressSpace) {
MockGfxPartition gfxPartition;
size_t reservedCpuAddressRangeSize = is64bit ? (6 * 4 * GB) : 0;
gfxPartition.init(gpuAddressSpace, reservedCpuAddressRangeSize);
uint64_t gfxTop = gpuAddressSpace + 1;
uint64_t gfxBase = MemoryConstants::maxSvmAddress + 1;
const uint64_t sizeHeap32 = 4 * MemoryConstants::gigaByte;
if (is32bit || maxNBitValue<48> == gpuAddressSpace) {
// Full range SVM 48/32-bit
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_SVM));
EXPECT_EQ(gfxPartition.getHeapBase(HeapIndex::HEAP_SVM), 0ull);
EXPECT_EQ(gfxPartition.getHeapSize(HeapIndex::HEAP_SVM), gfxBase);
EXPECT_EQ(gfxPartition.getHeapLimit(HeapIndex::HEAP_SVM), MemoryConstants::maxSvmAddress);
} else if (maxNBitValue<47> == gpuAddressSpace) {
// Full range SVM 47-bit
gfxBase = (uint64_t)gfxPartition.getReservedCpuAddressRange();
gfxTop = gfxBase + gfxPartition.getReservedCpuAddressRangeSize();
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_SVM));
EXPECT_EQ(gfxPartition.getHeapBase(HeapIndex::HEAP_SVM), 0ull);
EXPECT_EQ(gfxPartition.getHeapSize(HeapIndex::HEAP_SVM), is64bit ? gpuAddressSpace + 1 : gfxBase);
EXPECT_EQ(gfxPartition.getHeapLimit(HeapIndex::HEAP_SVM), MemoryConstants::maxSvmAddress);
} else {
// Limited range
EXPECT_FALSE(gfxPartition.heapInitialized(HeapIndex::HEAP_SVM));
gfxBase = 0ull;
}
for (auto heap32 : GfxPartition::heap32Names) {
EXPECT_TRUE(gfxPartition.heapInitialized(heap32));
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(gfxPartition.getHeapBase(heap32)));
EXPECT_EQ(gfxPartition.getHeapBase(heap32), gfxBase);
EXPECT_EQ(gfxPartition.getHeapSize(heap32), sizeHeap32);
gfxBase += sizeHeap32;
}
uint64_t sizeStandard = (gfxTop - gfxBase) >> 1;
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_STANDARD));
auto heapStandardBase = gfxPartition.getHeapBase(HeapIndex::HEAP_STANDARD);
auto heapStandardSize = gfxPartition.getHeapSize(HeapIndex::HEAP_STANDARD);
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(heapStandardBase));
EXPECT_EQ(heapStandardBase, gfxBase);
EXPECT_EQ(heapStandardSize, sizeStandard);
gfxBase += sizeStandard;
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_STANDARD64KB));
auto heapStandard64KbBase = gfxPartition.getHeapBase(HeapIndex::HEAP_STANDARD64KB);
auto heapStandard64KbSize = gfxPartition.getHeapSize(HeapIndex::HEAP_STANDARD64KB);
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(heapStandard64KbBase));
EXPECT_EQ(heapStandard64KbBase, heapStandardBase + heapStandardSize);
EXPECT_EQ(heapStandard64KbSize, heapStandardSize);
EXPECT_EQ(heapStandard64KbBase + heapStandard64KbSize, gfxTop);
EXPECT_EQ(gfxBase + sizeStandard, gfxTop);
size_t sizeSmall = MemoryConstants::pageSize;
size_t sizeBig = 4 * MemoryConstants::megaByte + MemoryConstants::pageSize;
for (auto heap : MockGfxPartition::allHeapNames) {
if (!gfxPartition.heapInitialized(heap)) {
EXPECT_TRUE(heap == HeapIndex::HEAP_SVM);
continue;
}
EXPECT_GT(gfxPartition.getHeapMinimalAddress(heap), gfxPartition.getHeapBase(heap));
EXPECT_EQ(gfxPartition.getHeapMinimalAddress(heap), gfxPartition.getHeapBase(heap) + GfxPartition::heapGranularity);
auto ptrBig = gfxPartition.heapAllocate(heap, sizeBig);
EXPECT_NE(ptrBig, 0ull);
EXPECT_LT(gfxPartition.getHeapBase(heap), ptrBig);
EXPECT_EQ(ptrBig, gfxPartition.getHeapBase(heap) + GfxPartition::heapGranularity);
gfxPartition.heapFree(heap, ptrBig, sizeBig);
auto ptrSmall = gfxPartition.heapAllocate(heap, sizeSmall);
EXPECT_NE(ptrSmall, 0ull);
EXPECT_LT(gfxPartition.getHeapBase(heap), ptrSmall);
EXPECT_GT(gfxPartition.getHeapLimit(heap), ptrSmall);
EXPECT_EQ(ptrSmall, gfxPartition.getHeapBase(heap) + gfxPartition.getHeapSize(heap) - GfxPartition::heapGranularity - sizeSmall);
gfxPartition.heapFree(heap, ptrSmall, sizeSmall);
}
}
TEST(GfxPartitionTest, testGfxPartitionFullRange48BitSVM) {
testGfxPartition(maxNBitValue<48>);
}
TEST(GfxPartitionTest, testGfxPartitionFullRange47BitSVM) {
testGfxPartition(maxNBitValue<47>);
}
TEST(GfxPartitionTest, testGfxPartitionLimitedRange) {
testGfxPartition(maxNBitValue<47 - 1>);
}
#include "unit_tests/memory_manager/gfx_partition_tests.inl"

126
unit_tests/memory_manager/gfx_partition_tests.inl Normal file
View File

@ -0,0 +1,126 @@
/*
* Copyright (C) 2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/helpers/aligned_memory.h"
#include "core/helpers/basic_math.h"
#include "core/helpers/ptr_math.h"
#include "core/os_interface/os_memory.h"
#include "unit_tests/mocks/mock_gfx_partition.h"
#include "gtest/gtest.h"
using namespace NEO;
constexpr size_t reservedCpuAddressRangeSize = is64bit ? (6 * 4 * GB) : 0;
constexpr uint64_t sizeHeap32 = 4 * MemoryConstants::gigaByte;
void testGfxPartition(MockGfxPartition &gfxPartition, uint64_t gfxBase, uint64_t gfxTop, uint64_t svmTop) {
if (svmTop) {
// SVM should be initialized
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_SVM));
EXPECT_EQ(gfxPartition.getHeapBase(HeapIndex::HEAP_SVM), 0ull);
EXPECT_EQ(gfxPartition.getHeapSize(HeapIndex::HEAP_SVM), svmTop);
EXPECT_EQ(gfxPartition.getHeapLimit(HeapIndex::HEAP_SVM), svmTop - 1);
} else {
// Limited range
EXPECT_FALSE(gfxPartition.heapInitialized(HeapIndex::HEAP_SVM));
}
for (auto heap32 : GfxPartition::heap32Names) {
EXPECT_TRUE(gfxPartition.heapInitialized(heap32));
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(gfxPartition.getHeapBase(heap32)));
EXPECT_EQ(gfxPartition.getHeapBase(heap32), gfxBase);
EXPECT_EQ(gfxPartition.getHeapSize(heap32), sizeHeap32);
gfxBase += sizeHeap32;
}
uint64_t sizeStandard = (gfxTop - gfxBase) >> 1;
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_STANDARD));
auto heapStandardBase = gfxPartition.getHeapBase(HeapIndex::HEAP_STANDARD);
auto heapStandardSize = gfxPartition.getHeapSize(HeapIndex::HEAP_STANDARD);
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(heapStandardBase));
EXPECT_EQ(heapStandardBase, gfxBase);
EXPECT_EQ(heapStandardSize, sizeStandard);
gfxBase += sizeStandard;
EXPECT_TRUE(gfxPartition.heapInitialized(HeapIndex::HEAP_STANDARD64KB));
auto heapStandard64KbBase = gfxPartition.getHeapBase(HeapIndex::HEAP_STANDARD64KB);
auto heapStandard64KbSize = gfxPartition.getHeapSize(HeapIndex::HEAP_STANDARD64KB);
EXPECT_TRUE(isAligned<GfxPartition::heapGranularity>(heapStandard64KbBase));
EXPECT_EQ(heapStandard64KbBase, heapStandardBase + heapStandardSize);
EXPECT_EQ(heapStandard64KbSize, heapStandardSize);
EXPECT_EQ(heapStandard64KbBase + heapStandard64KbSize, gfxTop);
EXPECT_EQ(gfxBase + sizeStandard, gfxTop);
size_t sizeSmall = MemoryConstants::pageSize;
size_t sizeBig = 4 * MemoryConstants::megaByte + MemoryConstants::pageSize;
for (auto heap : MockGfxPartition::allHeapNames) {
if (!gfxPartition.heapInitialized(heap)) {
EXPECT_TRUE(heap == HeapIndex::HEAP_SVM);
continue;
}
EXPECT_GT(gfxPartition.getHeapMinimalAddress(heap), gfxPartition.getHeapBase(heap));
EXPECT_EQ(gfxPartition.getHeapMinimalAddress(heap), gfxPartition.getHeapBase(heap) + GfxPartition::heapGranularity);
auto ptrBig = gfxPartition.heapAllocate(heap, sizeBig);
EXPECT_NE(ptrBig, 0ull);
EXPECT_LT(gfxPartition.getHeapBase(heap), ptrBig);
EXPECT_EQ(ptrBig, gfxPartition.getHeapBase(heap) + GfxPartition::heapGranularity);
gfxPartition.heapFree(heap, ptrBig, sizeBig);
auto ptrSmall = gfxPartition.heapAllocate(heap, sizeSmall);
EXPECT_NE(ptrSmall, 0ull);
EXPECT_LT(gfxPartition.getHeapBase(heap), ptrSmall);
EXPECT_GT(gfxPartition.getHeapLimit(heap), ptrSmall);
EXPECT_EQ(ptrSmall, gfxPartition.getHeapBase(heap) + gfxPartition.getHeapSize(heap) - GfxPartition::heapGranularity - sizeSmall);
gfxPartition.heapFree(heap, ptrSmall, sizeSmall);
}
}
TEST(GfxPartitionTest, testGfxPartitionFullRange48BitSVM) {
MockGfxPartition gfxPartition;
gfxPartition.init(maxNBitValue<48>, reservedCpuAddressRangeSize);
uint64_t gfxTop = maxNBitValue<48> + 1;
uint64_t gfxBase = MemoryConstants::maxSvmAddress + 1;
testGfxPartition(gfxPartition, gfxBase, gfxTop, gfxBase);
}
TEST(GfxPartitionTest, testGfxPartitionFullRange47BitSVM) {
MockGfxPartition gfxPartition;
gfxPartition.init(maxNBitValue<47>, reservedCpuAddressRangeSize);
uint64_t gfxBase = is32bit ? MemoryConstants::maxSvmAddress + 1 : (uint64_t)gfxPartition.getReservedCpuAddressRange();
uint64_t gfxTop = is32bit ? maxNBitValue<47> + 1 : gfxBase + gfxPartition.getReservedCpuAddressRangeSize();
uint64_t svmTop = MemoryConstants::maxSvmAddress + 1;
testGfxPartition(gfxPartition, gfxBase, gfxTop, svmTop);
}
TEST(GfxPartitionTest, testGfxPartitionLimitedRange) {
MockGfxPartition gfxPartition;
gfxPartition.init(maxNBitValue<47 - 1>, reservedCpuAddressRangeSize);
uint64_t gfxBase = is32bit ? MemoryConstants::maxSvmAddress + 1 : 0ull;
uint64_t gfxTop = maxNBitValue<47 - 1> + 1;
uint64_t svmTop = gfxBase;
testGfxPartition(gfxPartition, gfxBase, gfxTop, svmTop);
}
TEST(GfxPartitionTest, testGfxPartitionUnsupportedRange) {
if (is32bit) {
GTEST_SKIP();
}
MockGfxPartition gfxPartition;
EXPECT_THROW(gfxPartition.init(maxNBitValue<48 + 1>, reservedCpuAddressRangeSize), std::exception);
}