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