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

Add GfxPartition::initAdditionalRange() stub

Browse Source 
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
Download Patch File Download Diff File Expand all files Collapse all files

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);
}