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

ULT renaming: Memory alignment tests 

Related-To: NEO-2236

Change-Id: I47ef07092ed5c37dbb355e0d5b3b6c3bf1862160
Signed-off-by: Adam Cetnerowski <adam.cetnerowski@intel.com>
This commit is contained in:
Adam Cetnerowski 2020-03-26 17:54:39 +01:00 committed by sys_ocldev
parent 6f6d64569d
commit 000f8bdd65
1 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
shared/test/unit_test/helpers/aligned_memory_tests.cpp
View File

@ -11,7 +11,7 @@
#include <cstdint> #include <cstdint>
TEST(AlignedFree, nullptrShouldntCrash) { TEST(AlignedFree, GivenNullPtrWhenFreeingAlignedThenNoCrash) {
alignedFree(nullptr); alignedFree(nullptr);
} }
void *ptrAlignedToPage = (void *)0x1000; void *ptrAlignedToPage = (void *)0x1000;
@ -32,21 +32,21 @@ struct AlignedMalloc : public ::testing::TestWithParam<size_t> {
size_t alignAlloc; size_t alignAlloc;
}; };
TEST_P(AlignedMalloc, size0) { TEST_P(AlignedMalloc, GivenSizeZeroWhenAllocatingAlignedThenAlignedPointerIsReturned) {
size_t sizeAlloc = 0; size_t sizeAlloc = 0;
ptr = alignedMalloc(sizeAlloc, alignAlloc); ptr = alignedMalloc(sizeAlloc, alignAlloc);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);
EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc); EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc);
} }
TEST_P(AlignedMalloc, size4096) { TEST_P(AlignedMalloc, GivenSize4096WhenAllocatingAlignedThenAlignedPointerIsReturned) {
size_t sizeAlloc = 4096; size_t sizeAlloc = 4096;
ptr = alignedMalloc(sizeAlloc, alignAlloc); ptr = alignedMalloc(sizeAlloc, alignAlloc);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);
EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc); EXPECT_EQ(0u, (uintptr_t)ptr % alignAlloc);
} }
TEST(AlignedMallocTests, size0align4096) { TEST(AlignedMallocTests, GivenSizeZeroAndAlign4096WhenAllocatingAlignedThenAlignedPointerIsReturned) {
size_t sizeAlloc = 0; size_t sizeAlloc = 0;
auto ptr = alignedMalloc(sizeAlloc, 4096); auto ptr = alignedMalloc(sizeAlloc, 4096);
EXPECT_NE(nullptr, ptr); EXPECT_NE(nullptr, ptr);
@ -67,7 +67,7 @@ INSTANTIATE_TEST_CASE_P(
struct AlignUp : public ::testing::TestWithParam<size_t> { struct AlignUp : public ::testing::TestWithParam<size_t> {
}; };
TEST_P(AlignUp, belowAlignmentBefore) { TEST_P(AlignUp, GivenPointerBelowAlignmentWhenAligningUpThenReturnAlignedPointer) {
uintptr_t addrBefore = 0x1fffffff; uintptr_t addrBefore = 0x1fffffff;
auto ptrBefore = (uint32_t *)addrBefore; auto ptrBefore = (uint32_t *)addrBefore;
@ -78,7 +78,7 @@ TEST_P(AlignUp, belowAlignmentBefore) {
EXPECT_EQ(0u, addrAfter % alignment); EXPECT_EQ(0u, addrAfter % alignment);
} }
TEST_P(AlignUp, AtAlignmentBefore) { TEST_P(AlignUp, GivenPointerAtAlignmentWhenAligningUpThenReturnAlignedPointer) {
uintptr_t addrBefore = 0x20000000; uintptr_t addrBefore = 0x20000000;
auto ptrBefore = (uint32_t *)addrBefore; auto ptrBefore = (uint32_t *)addrBefore;
@ -89,7 +89,7 @@ TEST_P(AlignUp, AtAlignmentBefore) {
EXPECT_EQ(0u, addrAfter % alignment); EXPECT_EQ(0u, addrAfter % alignment);
} }
TEST_P(AlignUp, AboveAlignmentBefore) { TEST_P(AlignUp, GivenPointerAboveAlignmentWhenAligningUpThenReturnAlignedPointer) {
uintptr_t addrBefore = 0x20000001; uintptr_t addrBefore = 0x20000001;
auto ptrBefore = (uint32_t *)addrBefore; auto ptrBefore = (uint32_t *)addrBefore;
@ -100,7 +100,7 @@ TEST_P(AlignUp, AboveAlignmentBefore) {
EXPECT_EQ(0u, addrAfter % alignment); EXPECT_EQ(0u, addrAfter % alignment);
} }
TEST_P(AlignUp, preserve64Bit) { TEST_P(AlignUp, WhenAligningUpThen64BitIsPreserved) {
uint64_t aligned = 1ULL << 48; uint64_t aligned = 1ULL << 48;
auto alignment = GetParam(); auto alignment = GetParam();
auto result = alignUp(aligned, alignment); auto result = alignUp(aligned, alignment);
@ -119,36 +119,36 @@ INSTANTIATE_TEST_CASE_P(
256, 256,
4096)); 4096));
TEST(AlignWholeSize, alignWholeSizeToPage) { TEST(AlignWholeSize, GivenSizeLessThanPageSizeWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
int size = 1; int size = 1;
auto retSize = alignSizeWholePage(ptrAlignedToPage, size); auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
EXPECT_EQ(retSize, 4096u); EXPECT_EQ(retSize, 4096u);
} }
TEST(AlignWholeSize, sizeGreaterThenPageResultsIn2Pages) { TEST(AlignWholeSize, GivenSizeGreaterThanPageSizeWhenAligningWholeSizeToPageThenAlignedSizeIsMultipleOfPageSize) {
int size = 4097; int size = 4097;
auto retSize = alignSizeWholePage(ptrAlignedToPage, size); auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
EXPECT_EQ(retSize, 4096u * 2); EXPECT_EQ(retSize, 4096u * 2);
} }
TEST(AlignWholeSize, allocationNotPageAligned) { TEST(AlignWholeSize, GivenSizeGreaterThanPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsMultipleOfPageSize) {
int size = 4097; int size = 4097;
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
EXPECT_EQ(retSize, 4096u * 2); EXPECT_EQ(retSize, 4096u * 2);
} }
TEST(AlignWholeSize, ptrNotAligned) { TEST(AlignWholeSize, GivenSizeOneAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
int size = 1; int size = 1;
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
EXPECT_EQ(retSize, 4096u); EXPECT_EQ(retSize, 4096u);
} }
TEST(AlignWholeSize, allocationFitsToOnePage) { TEST(AlignWholeSize, GivenSizeOneLessThanPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsPageSize) {
int size = 4095; int size = 4095;
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
EXPECT_EQ(retSize, 4096u); EXPECT_EQ(retSize, 4096u);
} }
TEST(AlignWholeSize, allocationFitsTo2Pages) { TEST(AlignWholeSize, GivenSizeOneLessThanTwoPageSizeAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsTwoPageSize) {
int size = 4095 + 4096; int size = 4095 + 4096;
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
@ -160,54 +160,54 @@ TEST(AlignWholeSize, allocationOverlapsToAnotherPage) {
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
EXPECT_EQ(retSize, 4096u * 2); EXPECT_EQ(retSize, 4096u * 2);
} }
TEST(AlignWholeSize, allocationOverlapsTo2AnotherPage) { TEST(AlignWholeSize, GivenSizeofTwoPagesAndUnalignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsThreePageSize) {
int size = 4096 * 2; int size = 4096 * 2;
auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size); auto retSize = alignSizeWholePage(ptrNotAlignedToPage, size);
EXPECT_EQ(retSize, 4096u * 3); EXPECT_EQ(retSize, 4096u * 3);
} }
TEST(AlignWholeSize, ptrProperlyAlignedTo2Pages) { TEST(AlignWholeSize, GivenSizeofTwoPagesAndAlignedPointerWhenAligningWholeSizeToPageThenAlignedSizeIsTwoPageSize) {
int size = 4096 * 2; int size = 4096 * 2;
auto retSize = alignSizeWholePage(ptrAlignedToPage, size); auto retSize = alignSizeWholePage(ptrAlignedToPage, size);
EXPECT_EQ(retSize, 4096u * 2); EXPECT_EQ(retSize, 4096u * 2);
} }
TEST(AlignDown, ptrAlignedToPageWhenAlignedDownReturnsTheSamePointer) { TEST(AlignDown, GivenPtrAlignedToPageWhenAligningDownToPageSizeThenReturnTheSamePointer) {
void *ptr = (void *)0x1000; void *ptr = (void *)0x1000;
auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize); auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
EXPECT_EQ(ptr, alignedDownPtr); EXPECT_EQ(ptr, alignedDownPtr);
} }
TEST(AlignDown, ptrNotAlignedToPageWhenAlignedDownReturnsPageAlignedPointer) { TEST(AlignDown, GivenPtrNotAlignedToPageWhenAligningDownToPageSizeThenPageAlignedPointerIsReturned) {
void *ptr = (void *)0x1001; void *ptr = (void *)0x1001;
void *expected_ptr = (void *)0x1000; void *expected_ptr = (void *)0x1000;
auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize); auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
EXPECT_EQ(expected_ptr, alignedDownPtr); EXPECT_EQ(expected_ptr, alignedDownPtr);
} }
TEST(AlignDown, ptrNotAlignedToPage2WhenAlignedDownReturnsPageAlignedPointer) { TEST(AlignDown, GivenPtrNotAlignedToTwoPageWhenAligningDownToPageSizeThenReturnAlignedPointerToPreviousPage) {
void *ptr = (void *)0x1241; void *ptr = (void *)0x1241;
void *expected_ptr = (void *)0x1000; void *expected_ptr = (void *)0x1000;
auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize); auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
EXPECT_EQ(expected_ptr, alignedDownPtr); EXPECT_EQ(expected_ptr, alignedDownPtr);
} }
TEST(AlignDown, ptrNotAlignedToPage3WhenAlignedDownReturnsPageAlignedPointer) { TEST(AlignDown, GivenPtrNotAlignedToThreePageWhenAligningDownToPageSizeThenReturnAlignedPointerToPreviousPage) {
void *ptr = (void *)0x3241; void *ptr = (void *)0x3241;
void *expected_ptr = (void *)0x3000; void *expected_ptr = (void *)0x3000;
auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize); auto alignedDownPtr = alignDown(ptr, MemoryConstants::pageSize);
EXPECT_EQ(expected_ptr, alignedDownPtr); EXPECT_EQ(expected_ptr, alignedDownPtr);
} }
TEST(AlignDown, ptrNotAlignedToDwordWhenAlignedDownReturnsDwordAlignedPointer) { TEST(AlignDown, GivenPtrNotAlignedToDwordWhenAligningDownToDwordThenDwordAlignedPointerIsReturned) {
void *ptr = (void *)0x3241; void *ptr = (void *)0x3241;
void *expected_ptr = (void *)0x3240; void *expected_ptr = (void *)0x3240;
auto alignedDownPtr = alignDown(ptr, 4); auto alignedDownPtr = alignDown(ptr, 4);
EXPECT_EQ(expected_ptr, alignedDownPtr); EXPECT_EQ(expected_ptr, alignedDownPtr);
} }
TEST(AlignDown, preserve64Bit) { TEST(AlignDown, WhenAligningDownThen64BitIsPreserved) {
uint64_t aligned = 1ULL << 48; uint64_t aligned = 1ULL << 48;
auto result = alignDown(aligned, MemoryConstants::pageSize); auto result = alignDown(aligned, MemoryConstants::pageSize);
EXPECT_EQ(aligned, result); EXPECT_EQ(aligned, result);
@ -243,7 +243,7 @@ class IsAlignedTests : public ::testing::Test {
typedef ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double> IsAlignedTypes; typedef ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double> IsAlignedTypes;
TYPED_TEST_CASE(IsAlignedTests, IsAlignedTypes); TYPED_TEST_CASE(IsAlignedTests, IsAlignedTypes);
TYPED_TEST(IsAlignedTests, aligned) { TYPED_TEST(IsAlignedTests, WhenCheckingForAlignmentThenReturnCorrectValue) {
TypeParam *ptr = reinterpret_cast<TypeParam *>(static_cast<uintptr_t>(0xdeadbeefu)); TypeParam *ptr = reinterpret_cast<TypeParam *>(static_cast<uintptr_t>(0xdeadbeefu));
// one byte alignment should always return true // one byte alignment should always return true
if (alignof(TypeParam) == 1) if (alignof(TypeParam) == 1)
@ -265,7 +265,7 @@ TYPED_TEST(IsAlignedTests, aligned) {
EXPECT_FALSE(isAligned(ptr3)); EXPECT_FALSE(isAligned(ptr3));
} }
TEST(IsAligned, nonPointerType) { TEST(IsAligned, GivenNonPointerTypeWhenCheckingForAlignmentThenReturnIsCorrect) {
EXPECT_TRUE(isAligned<3>(0)); EXPECT_TRUE(isAligned<3>(0));
EXPECT_FALSE(isAligned<3>(1)); EXPECT_FALSE(isAligned<3>(1));
EXPECT_FALSE(isAligned<3>(2)); EXPECT_FALSE(isAligned<3>(2));
@ -275,7 +275,7 @@ TEST(IsAligned, nonPointerType) {
EXPECT_TRUE(isAligned<3>(6)); EXPECT_TRUE(isAligned<3>(6));
} }
TEST(IsAligned, supportsConstexprEvaluation) { TEST(IsAligned, WhenUsingConstexprEvaluationThenResultIsCorrect) {
static_assert(false == isAligned<3>(2), ""); static_assert(false == isAligned<3>(2), "");
static_assert(true == isAligned<3>(3), ""); static_assert(true == isAligned<3>(3), "");
} }