From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7DCF74410E; Thu, 30 May 2024 11:41:32 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A8BCD40ED0; Thu, 30 May 2024 11:41:03 +0200 (CEST) Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by mails.dpdk.org (Postfix) with ESMTP id F3DFF40DFD for ; Thu, 30 May 2024 11:40:55 +0200 (CEST) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 77F461650; Thu, 30 May 2024 02:41:19 -0700 (PDT) Received: from ampere-altra-2-3.austin.arm.com (ampere-altra-2-3.austin.arm.com [10.118.14.97]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 342853F905; Thu, 30 May 2024 02:40:55 -0700 (PDT) From: Paul Szczepanek To: dev@dpdk.org Cc: mb@smartsharesystems.com, Paul Szczepanek , Honnappa Nagarahalli , Nathan Brown , Jack Bond-Preston Subject: [PATCH v13 6/6] test: add unit test for ptr compression Date: Thu, 30 May 2024 09:40:42 +0000 Message-Id: <20240530094042.1960212-7-paul.szczepanek@arm.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240530094042.1960212-1-paul.szczepanek@arm.com> References: <20230927150854.3670391-2-paul.szczepanek@arm.com> <20240530094042.1960212-1-paul.szczepanek@arm.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Test compresses and decompresses pointers with various combinations of memory regions and alignments and verifies the pointers are recovered correctly. Additionally tests helper macros perform calculations correctly. Signed-off-by: Paul Szczepanek Reviewed-by: Honnappa Nagarahalli Reviewed-by: Nathan Brown Reviewed-by: Jack Bond-Preston --- MAINTAINERS | 1 + app/test/meson.build | 1 + app/test/test_ptr_compress.c | 193 +++++++++++++++++++++++++++++++++++ 3 files changed, 195 insertions(+) create mode 100644 app/test/test_ptr_compress.c diff --git a/MAINTAINERS b/MAINTAINERS index ed50121bd2..2565ef5f4b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1697,6 +1697,7 @@ F: lib/pci/ Pointer Compression M: Paul Szczepanek F: lib/ptr_compress/ +F: app/test/test_ptr_compress.c F: doc/guides/prog_guide/ptr_compress_lib.rst Power management diff --git a/app/test/meson.build b/app/test/meson.build index df8cc00730..e29258e6ec 100644 --- a/app/test/meson.build +++ b/app/test/meson.build @@ -144,6 +144,7 @@ source_file_deps = { 'test_power_intel_uncore.c': ['power'], 'test_power_kvm_vm.c': ['power'], 'test_prefetch.c': [], + 'test_ptr_compress.c': ['ptr_compress'], 'test_rand_perf.c': [], 'test_rawdev.c': ['rawdev', 'bus_vdev'], 'test_rcu_qsbr.c': ['rcu', 'hash'], diff --git a/app/test/test_ptr_compress.c b/app/test/test_ptr_compress.c new file mode 100644 index 0000000000..ab33815974 --- /dev/null +++ b/app/test/test_ptr_compress.c @@ -0,0 +1,193 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2024 Arm Limited + */ + +#include "test.h" +#include +#include + +#include + +#define MAX_ALIGN_EXPONENT 3 +#define MAX_PTRS 16 +#define NUM_BASES 2 +#define NUM_REGIONS 4 +#define MAX_32BIT_REGION ((uint64_t)UINT32_MAX + 1) +#define MAX_16BIT_REGION (UINT16_MAX + 1) + +static int +test_ptr_compress_params( + void *base, + uint64_t mem_sz, + unsigned int align_exp, + unsigned int num_ptrs, + bool use_32_bit) +{ + unsigned int i; + unsigned int align = 1 << align_exp; + void *ptrs[MAX_PTRS] = {0}; + void *ptrs_out[MAX_PTRS] = {0}; + uint32_t offsets32[MAX_PTRS] = {0}; + uint16_t offsets16[MAX_PTRS] = {0}; + + for (i = 0; i < num_ptrs; i++) { + /* make pointers point at memory in steps of align */ + /* alternate steps from the start and end of memory region */ + if ((i & 1) == 1) + ptrs[i] = (char *)base + mem_sz - i * align; + else + ptrs[i] = (char *)base + i * align; + } + + if (use_32_bit) { + rte_ptr_compress_32_shift( + base, ptrs, offsets32, num_ptrs, align_exp); + rte_ptr_decompress_32_shift(base, offsets32, ptrs_out, num_ptrs, + align_exp); + } else { + rte_ptr_compress_16_shift( + base, ptrs, offsets16, num_ptrs, align_exp); + rte_ptr_decompress_16_shift(base, offsets16, ptrs_out, num_ptrs, + align_exp); + } + + TEST_ASSERT_BUFFERS_ARE_EQUAL(ptrs, ptrs_out, sizeof(void *) * num_ptrs, + "Decompressed pointers corrupted\nbase pointer: %p, " + "memory region size: %" PRIu64 ", alignment exponent: %u, " + "num of pointers: %u, using %s offsets", + base, mem_sz, align_exp, num_ptrs, + use_32_bit ? "32-bit" : "16-bit"); + + return 0; +} + +static int +test_ptr_compress(void) +{ + unsigned int j, k, n; + int ret = 0; + /* the test is run with multiple memory regions and base addresses */ + void * const bases[NUM_BASES] = { (void *)0, (void *)UINT16_MAX }; + /* maximum size for pointers aligned by consecutive powers of 2 */ + const uint64_t region_sizes_16[NUM_REGIONS] = { + MAX_16BIT_REGION, + MAX_16BIT_REGION * 2, + MAX_16BIT_REGION * 4, + MAX_16BIT_REGION * 8, + }; + const uint64_t region_sizes_32[NUM_REGIONS] = { + MAX_32BIT_REGION, + MAX_32BIT_REGION * 2, + MAX_32BIT_REGION * 4, + MAX_32BIT_REGION * 8, + }; + + /* main test compresses and decompresses arrays of pointers + * and compares the array before and after to verify that + * pointers are successfully decompressed + */ + + for (j = 0; j < NUM_REGIONS; j++) { + for (k = 0; k < NUM_BASES; k++) { + for (n = 1; n < MAX_PTRS; n++) { + ret |= test_ptr_compress_params( + bases[k], + region_sizes_16[j], + j /* exponent of alignment */, + n, + false + ); + ret |= test_ptr_compress_params( + bases[k], + region_sizes_32[j], + j /* exponent of alignment */, + n, + true + ); + if (ret != 0) + return ret; + } + } + } + + /* verify helper macro computations */ + + n = RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE(0); + TEST_ASSERT_EQUAL(n, 1, + "RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE(1); + TEST_ASSERT_EQUAL(n, 1, + "RTE_PTR_COMPREtopSS_BITS_REQUIRED_TO_STORE_VALUE " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE(MAX_16BIT_REGION); + TEST_ASSERT_EQUAL(n, 16, + "RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE(MAX_32BIT_REGION); + TEST_ASSERT_EQUAL(n, 32, + "RTE_PTR_COMPRESS_BITS_REQUIRED_TO_STORE_VALUE_IN_RANGE " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT(0); + TEST_ASSERT_EQUAL(n, 0, + "RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT(1); + TEST_ASSERT_EQUAL(n, 0, + "RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT(2); + TEST_ASSERT_EQUAL(n, 1, + "RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT(3); + TEST_ASSERT_EQUAL(n, 0, + "RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT " + "macro computation incorrect\n"); + + n = RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT(4); + TEST_ASSERT_EQUAL(n, 2, + "RTE_PTR_COMPRESS_BIT_SHIFT_FROM_ALIGNMENT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT(MAX_16BIT_REGION, 1); + TEST_ASSERT_EQUAL(ret, 1, + "RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT(MAX_16BIT_REGION + 1, 1); + TEST_ASSERT_EQUAL(ret, 0, + "RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT(MAX_16BIT_REGION + 1, 2); + TEST_ASSERT_EQUAL(ret, 1, + "RTE_PTR_COMPRESS_CAN_COMPRESS_16_SHIFT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT(MAX_32BIT_REGION, 1); + TEST_ASSERT_EQUAL(ret, 1, + "RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT(MAX_32BIT_REGION + 1, 1); + TEST_ASSERT_EQUAL(ret, 0, + "RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT " + "macro computation incorrect\n"); + + ret = RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT(MAX_32BIT_REGION + 1, 2); + TEST_ASSERT_EQUAL(ret, 1, + "RTE_PTR_COMPRESS_CAN_COMPRESS_32_SHIFT " + "macro computation incorrect\n"); + + return 0; +} + +REGISTER_FAST_TEST(ptr_compress_autotest, true, true, test_ptr_compress); -- 2.25.1