From fc7a490496468fbfbe164cbfbe4546bcb6cdc8dd Mon Sep 17 00:00:00 2001 From: Wenbin Lu Date: Mon, 8 Jul 2024 10:27:57 -0500 Subject: [PATCH] Split USM alignment tests into small and large alignments (#48) Related-To: NEO-8431 Signed-off-by: Wenbin Lu --- .../core/test_memory/src/test_memory.cpp | 135 +++++++++++------- scripts/level_zero_report_utils.py | 3 + .../test_harness/test_harness_memory.hpp | 6 +- 3 files changed, 90 insertions(+), 54 deletions(-) diff --git a/conformance_tests/core/test_memory/src/test_memory.cpp b/conformance_tests/core/test_memory/src/test_memory.cpp index 860654d8..dc155a16 100644 --- a/conformance_tests/core/test_memory/src/test_memory.cpp +++ b/conformance_tests/core/test_memory/src/test_memory.cpp @@ -1,6 +1,6 @@ /* * - * Copyright (C) 2019-2023 Intel Corporation + * Copyright (C) 2019-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -8,8 +8,6 @@ #include #include -#include -#include #include "gtest/gtest.h" @@ -66,11 +64,17 @@ TEST_P(zeDriverAllocDeviceMemAlignmentTests, } } -INSTANTIATE_TEST_SUITE_P(zeDriverAllocDeviceMemTestVarySizeAndAlignment, - zeDriverAllocDeviceMemAlignmentTests, - ::testing::Combine(::testing::Values(0), - lzt::memory_allocation_sizes, - lzt::memory_allocation_alignments)); +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocDeviceMemTestVarySizeAndAlignment, + zeDriverAllocDeviceMemAlignmentTests, + ::testing::Combine(::testing::Values(0), lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_small)); + +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocDeviceMemTestVarySizeAndLargeAlignment, + zeDriverAllocDeviceMemAlignmentTests, + ::testing::Combine(::testing::Values(0), lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_large)); class zeMemGetAllocPropertiesTests : public zeDriverAllocDeviceMemTests {}; @@ -266,37 +270,53 @@ class zeDriverAllocSharedMemAlignmentTests : public ::testing::Test, public ::testing::WithParamInterface< std::tuple> {}; + size_t, size_t>> { +protected: + void SetUp() override { + const ze_device_mem_alloc_flag_t dev_flags = std::get<0>(GetParam()); + const ze_host_mem_alloc_flag_t host_flags = std::get<1>(GetParam()); + size_ = std::get<2>(GetParam()); + alignment_ = std::get<3>(GetParam()); -TEST_P(zeDriverAllocSharedMemAlignmentTests, - GivenSizeAndAlignmentWhenAllocatingSharedMemoryThenPointerIsAligned) { + auto driver = lzt::get_default_driver(); + auto device = lzt::get_default_device(driver); + context_ = lzt::create_context(); + memory_ = lzt::allocate_shared_memory(size_, alignment_, dev_flags, + host_flags, device, context_); + } - const ze_device_mem_alloc_flag_t dev_flags = std::get<0>(GetParam()); - const ze_host_mem_alloc_flag_t host_flags = std::get<1>(GetParam()); - const size_t size = std::get<2>(GetParam()); - const size_t alignment = std::get<3>(GetParam()); + void TearDown() override { + lzt::free_memory(context_, memory_); + lzt::destroy_context(context_); + } - void *memory = nullptr; - auto driver = lzt::get_default_driver(); - auto device = lzt::get_default_device(driver); - auto context = lzt::create_context(); + size_t size_; + size_t alignment_; + void *memory_ = nullptr; + ze_context_handle_t context_; +}; - memory = lzt::allocate_shared_memory(size, alignment, dev_flags, host_flags, - device, context); - EXPECT_NE(nullptr, memory); - if (alignment != 0) { - EXPECT_EQ(0u, reinterpret_cast(memory) % alignment); +TEST_P(zeDriverAllocSharedMemAlignmentTests, + GivenSizeAndAlignmentWhenAllocatingSharedMemoryThenPointerIsAligned) { + EXPECT_NE(nullptr, memory_); + if (alignment_ != 0) { + EXPECT_EQ(0u, reinterpret_cast(memory_) % alignment_); } - lzt::free_memory(context, memory); - lzt::destroy_context(context); } -INSTANTIATE_TEST_SUITE_P(zeDriverAllocSharedMemTestVarySizeAndAlignment, - zeDriverAllocSharedMemAlignmentTests, - ::testing::Combine(::testing::Values(0), - ::testing::Values(0), - lzt::memory_allocation_sizes, - lzt::memory_allocation_alignments)); +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocSharedMemTestVarySizeAndAlignment, + zeDriverAllocSharedMemAlignmentTests, + ::testing::Combine(::testing::Values(0), ::testing::Values(0), + lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_small)); + +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocSharedMemTestVarySizeAndLargeAlignment, + zeDriverAllocSharedMemAlignmentTests, + ::testing::Combine(::testing::Values(0), ::testing::Values(0), + lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_large)); class zeSharedMemGetPropertiesTests : public ::testing::Test, @@ -433,33 +453,42 @@ INSTANTIATE_TEST_SUITE_P( ZE_HOST_MEM_ALLOC_FLAG_BIAS_WRITE_COMBINED), lzt::memory_allocation_sizes, lzt::memory_allocation_alignments)); -class zeDriverAllocHostMemAlignmentTests : public zeDriverAllocHostMemTests {}; - -TEST_P(zeDriverAllocHostMemAlignmentTests, - GivenSizeAndAlignmentWhenAllocatingHostMemoryThenPointerIsAligned) { - - const ze_host_mem_alloc_flag_t flags = std::get<0>(GetParam()); +class zeDriverAllocHostMemAlignmentTests : public zeDriverAllocHostMemTests { +protected: + void SetUp() override { + const ze_host_mem_alloc_flag_t flags = std::get<0>(GetParam()); + size_ = std::get<1>(GetParam()); + alignment_ = std::get<2>(GetParam()); + memory_ = lzt::allocate_host_memory(size_, alignment_, flags, nullptr, + lzt::get_default_context()); + } - const size_t size = std::get<1>(GetParam()); - const size_t alignment = std::get<2>(GetParam()); + void TearDown() override { lzt::free_memory(memory_); } - void *memory = nullptr; - memory = lzt::allocate_host_memory(size, alignment, flags, nullptr, - lzt::get_default_context()); + size_t size_; + size_t alignment_; + void *memory_ = nullptr; +}; - EXPECT_NE(nullptr, memory); - if (alignment != 0) { - EXPECT_EQ(0u, reinterpret_cast(memory) % alignment); +TEST_P(zeDriverAllocHostMemAlignmentTests, + GivenSizeAndAlignmentWhenAllocatingHostMemoryThenPointerIsAligned) { + EXPECT_NE(nullptr, memory_); + if (alignment_ != 0) { + EXPECT_EQ(0u, reinterpret_cast(memory_) % alignment_); } - - lzt::free_memory(memory); } -INSTANTIATE_TEST_SUITE_P(zeDriverAllocHostMemTestVarySizeAndAlignment, - zeDriverAllocHostMemAlignmentTests, - ::testing::Combine(::testing::Values(0), - lzt::memory_allocation_sizes, - lzt::memory_allocation_alignments)); +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocHostMemTestVarySizeAndAlignment, + zeDriverAllocHostMemAlignmentTests, + ::testing::Combine(::testing::Values(0), lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_small)); + +INSTANTIATE_TEST_SUITE_P( + zeDriverAllocHostMemTestVarySizeAndLargeAlignment, + zeDriverAllocHostMemAlignmentTests, + ::testing::Combine(::testing::Values(0), lzt::memory_allocation_sizes, + lzt::memory_allocation_alignments_large)); class zeHostMemPropertiesTests : public ::testing::Test, diff --git a/scripts/level_zero_report_utils.py b/scripts/level_zero_report_utils.py index 14ac9170..042a11d4 100644 --- a/scripts/level_zero_report_utils.py +++ b/scripts/level_zero_report_utils.py @@ -137,6 +137,9 @@ def assign_test_feature_tag(test_feature: str, test_name: str, test_section: str (re.search('L0_CTS_zeDriverAllocSharedMemTestVarySizeAndAlignment_zeDriverAllocSharedMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingDeviceMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ (re.search('L0_CTS_zeDriverAllocHostMemTestVarySizeAndAlignment_zeDriverAllocHostMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingHostMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ (re.search('L0_CTS_zeDriverAllocDeviceMemTestVarySizeAndAlignment_zeDriverAllocDeviceMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingDeviceMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ + (re.search('L0_CTS_zeDriverAllocDeviceMemTestVarySizeAndLargeAlignment_zeDriverAllocDeviceMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingDeviceMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ + (re.search('L0_CTS_zeDriverAllocHostMemTestVarySizeAndLargeAlignment_zeDriverAllocHostMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingHostMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ + (re.search('L0_CTS_zeDriverAllocSharedMemTestVarySizeAndLargeAlignment_zeDriverAllocSharedMemAlignmentTests_GivenSizeAndAlignmentWhenAllocatingSharedMemoryThenPointerIsAligned', test_name, re.IGNORECASE)) or \ (re.search('L0_CTS_IpcMemoryAccessTest_GivenL0MemoryAllocatedInChildProcessWhenUsingL0IPCOnImmediateCmdListThenParentProcessReadsMemoryCorrectly', test_name, re.IGNORECASE)) or \ (re.search('L0_CTS_IpcMemoryAccessTest_GivenL0MemoryAllocatedInChildProcessBiasCachedWhenUsingL0IPCThenParentProcessReadsMemoryCorrectly', test_name, re.IGNORECASE)) or \ (re.search('L0_CTS_IpcMemoryAccessTest_GivenL0MemoryAllocatedInChildProcessBiasCachedWhenUsingL0IPCOnImmediateCmdListThenParentProcessReadsMemoryCorrectly', test_name, re.IGNORECASE)) or \ diff --git a/utils/test_harness/include/test_harness/test_harness_memory.hpp b/utils/test_harness/include/test_harness/test_harness_memory.hpp index 1a3d4574..6735f995 100644 --- a/utils/test_harness/include/test_harness/test_harness_memory.hpp +++ b/utils/test_harness/include/test_harness/test_harness_memory.hpp @@ -9,7 +9,6 @@ #ifndef level_zero_tests_ZE_TEST_HARNESS_MEMORY_HPP #define level_zero_tests_ZE_TEST_HARNESS_MEMORY_HPP -#include "test_harness_device.hpp" #include #include "gtest/gtest.h" @@ -29,6 +28,11 @@ const auto memory_allocation_sizes = const auto memory_allocation_alignments = ::testing::Values( 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 1u << 17, 1u << 18, 1u << 19, 1u << 20, 1u << 21, 1u << 22); +const auto memory_allocation_alignments_small = + ::testing::Values(0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, + 4096, 8192, 16384, 32768, 65536); +const auto memory_allocation_alignments_large = ::testing::Values( + 1u << 17, 1u << 18, 1u << 19, 1u << 20, 1u << 21, 1u << 22, 1u << 23); void *allocate_host_memory(const size_t size); void *allocate_host_memory(const size_t size, const size_t alignment);