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 7415F45D48; Wed, 20 Nov 2024 01:39:35 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 5337642EC8; Wed, 20 Nov 2024 01:38:14 +0100 (CET) Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by mails.dpdk.org (Postfix) with ESMTP id 9E0FE42E72 for ; Wed, 20 Nov 2024 01:37:47 +0100 (CET) Received: by linux.microsoft.com (Postfix, from userid 1213) id 46744205A74E; Tue, 19 Nov 2024 16:37:45 -0800 (PST) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com 46744205A74E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1732063066; bh=Gi9a8r3J+LH79l08j8Ybj++qMC+G6/Mhd11SGC0dy8U=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Bv9FhmyrIn/F+ErvsMjSqhHVjHSHUrS+PsYUC3fXWoBAnnmBbTe6RS4VUAUFalYar n7/xJvy2seG8Ap7/6IZy0HHr8NZeKQoObwhRWBWxD/QqkwJ2+5iH36roIaZXUJxFCK nvrJvqn837KepHOj+Ud+h9K1SxYK7NVgWVhjG8wk= From: Andre Muezerie To: dev@dpdk.org Cc: Andre Muezerie , Andre Muezerie Subject: [PATCH v8 19/21] test: remove use of VLAs for Windows built code in bitset tests Date: Tue, 19 Nov 2024 16:37:26 -0800 Message-Id: <1732063048-12298-20-git-send-email-andremue@linux.microsoft.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1732063048-12298-1-git-send-email-andremue@linux.microsoft.com> References: <1713397319-26135-1-git-send-email-roretzla@linux.microsoft.com> <1732063048-12298-1-git-send-email-andremue@linux.microsoft.com> 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 From: Andre Muezerie 1) MSVC does not support VLAs. Use standard fixed C arrays of maximum size required instead. 2) ../usr/lib/gcc/x86_64-redhat-linux/13/include/emmintrin.h:742:8: error: array subscript 9 is outside array bounds of 'uint64_t[16]' {aka 'long unsigned int[16]'} [-Werror=array-bounds=] 3695 742 | *__P = __B; Compile with -Wno-array-bounds to avoid false positives when using gcc version 11 or newer (gcc compiler bug/limitation). Signed-off-by: Andre Muezerie --- app/test/test_bitset.c | 65 ++++++++++++++++++++------------- app/test/test_lcore_var_perf.c | 2 +- app/test/test_reassembly_perf.c | 4 +- 3 files changed, 42 insertions(+), 29 deletions(-) diff --git a/app/test/test_bitset.c b/app/test/test_bitset.c index 50b8bf0da4..8b30bd258f 100644 --- a/app/test/test_bitset.c +++ b/app/test/test_bitset.c @@ -99,11 +99,13 @@ typedef void clear_fun(uint64_t *bitset, size_t bit_num); typedef void assign_fun(uint64_t *bitset, size_t bit_num, bool value); typedef void flip_fun(uint64_t *bitset, size_t bit_num); +#define RAND_SET_MAX_SIZE 1000 + static int test_set_clear_size(test_fun test_fun, set_fun set_fun, clear_fun clear_fun, size_t size) { size_t i; - bool reference[size]; + bool reference[RAND_SET_MAX_SIZE]; uint64_t *bitset; rand_bool_ary(reference, size); @@ -131,8 +133,7 @@ test_set_clear_size(test_fun test_fun, set_fun set_fun, clear_fun clear_fun, siz return TEST_SUCCESS; } -#define RAND_ITERATIONS (10000) -#define RAND_SET_MAX_SIZE (1000) +#define RAND_ITERATIONS 10000 static int test_set_clear_fun(test_fun test_fun, set_fun set_fun, clear_fun clear_fun) @@ -168,10 +169,16 @@ test_flip_size(test_fun test_fun, assign_fun assign_fun, flip_fun flip_fun, size rand_bitset(bitset, size); for (i = 0; i < size; i++) { - RTE_BITSET_DECLARE(reference, size); + RTE_BITSET_DECLARE(reference, RAND_SET_MAX_SIZE); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Warray-bounds=" + /* gcc >= 11 is giving false positives here when code is optimized */ rte_bitset_copy(reference, bitset, size); +#pragma GCC diagnostic pop + bool value = test_fun(bitset, i); flip_fun(bitset, i); @@ -282,13 +289,13 @@ find_clear(const bool *ary, size_t num_bools, size_t start, size_t len) return find(ary, num_bools, start, len, false); } -#define FFS_ITERATIONS (100) +#define FFS_ITERATIONS 100 static int test_find_size(size_t size, bool set) { uint64_t *bitset; - bool reference[size]; + bool reference[RAND_SET_MAX_SIZE]; size_t i; bitset = alloc_bitset(size); @@ -388,8 +395,8 @@ record_match(ssize_t match_idx, size_t size, int *calls) static int test_foreach_size(ssize_t size, bool may_wrap, bool set) { - bool reference[size]; - int calls[size]; + bool reference[RAND_SET_MAX_SIZE]; + int calls[RAND_SET_MAX_SIZE]; uint64_t *bitset; ssize_t i; ssize_t start_bit; @@ -633,17 +640,19 @@ test_define(void) typedef void bitset_op(uint64_t *dst, const uint64_t *a, const uint64_t *b, size_t bit_num); typedef bool bool_op(bool a, bool b); +#define LOGIC_MAX_SET_SIZE 200 + static int test_logic_op(bitset_op bitset_op, bool_op bool_op) { - const size_t size = 1 + rte_rand_max(200); - RTE_BITSET_DECLARE(bitset_a, size); - RTE_BITSET_DECLARE(bitset_b, size); - RTE_BITSET_DECLARE(bitset_d, size); + const size_t size = 1 + rte_rand_max(LOGIC_MAX_SET_SIZE); + RTE_BITSET_DECLARE(bitset_a, LOGIC_MAX_SET_SIZE); + RTE_BITSET_DECLARE(bitset_b, LOGIC_MAX_SET_SIZE); + RTE_BITSET_DECLARE(bitset_d, LOGIC_MAX_SET_SIZE); - bool ary_a[size]; - bool ary_b[size]; - bool ary_d[size]; + bool ary_a[LOGIC_MAX_SET_SIZE]; + bool ary_b[LOGIC_MAX_SET_SIZE]; + bool ary_d[LOGIC_MAX_SET_SIZE]; rand_bool_ary(ary_a, size); rand_bool_ary(ary_b, size); @@ -708,14 +717,14 @@ test_complement(void) for (i = 0; i < RAND_ITERATIONS; i++) { const size_t size = 1 + rte_rand_max(RAND_SET_MAX_SIZE - 1); - RTE_BITSET_DECLARE(src, size); + RTE_BITSET_DECLARE(src, RAND_SET_MAX_SIZE); rand_bitset(src, size); bool bit_idx = rte_rand_max(size); bool bit_value = rte_bitset_test(src, bit_idx); - RTE_BITSET_DECLARE(dst, size); + RTE_BITSET_DECLARE(dst, RAND_SET_MAX_SIZE); rte_bitset_complement(dst, src, size); @@ -726,6 +735,8 @@ test_complement(void) return TEST_SUCCESS; } +#define SHIFT_SET_MAX_SIZE 500 + static int test_shift(bool right) { @@ -734,12 +745,12 @@ test_shift(bool right) const char *direction = right ? "right" : "left"; for (i = 0; i < 10000; i++) { - const int size = 1 + (int)rte_rand_max(500); + const int size = 1 + (int)rte_rand_max(SHIFT_SET_MAX_SIZE); const int shift_count = (int)rte_rand_max(1.5 * size); int src_idx; - RTE_BITSET_DECLARE(src, size); - RTE_BITSET_DECLARE(reference, size); + RTE_BITSET_DECLARE(src, SHIFT_SET_MAX_SIZE); + RTE_BITSET_DECLARE(reference, SHIFT_SET_MAX_SIZE); rte_bitset_init(src, size); rte_bitset_init(reference, size); @@ -788,12 +799,14 @@ test_shift_left(void) return test_shift(false); } +#define EQUAL_SET_MAX_SIZE 100 + static int test_equal(void) { - const size_t size = 100; - RTE_BITSET_DECLARE(bitset_a, size); - RTE_BITSET_DECLARE(bitset_b, size); + const size_t size = EQUAL_SET_MAX_SIZE; + RTE_BITSET_DECLARE(bitset_a, EQUAL_SET_MAX_SIZE); + RTE_BITSET_DECLARE(bitset_b, EQUAL_SET_MAX_SIZE); rand_buf(bitset_a, RTE_BITSET_SIZE(size)); rand_buf(bitset_b, RTE_BITSET_SIZE(size)); @@ -821,9 +834,9 @@ test_equal(void) static int test_copy(void) { - const size_t size = 100; - RTE_BITSET_DECLARE(bitset_a, size); - RTE_BITSET_DECLARE(bitset_b, size); + const size_t size = EQUAL_SET_MAX_SIZE; + RTE_BITSET_DECLARE(bitset_a, EQUAL_SET_MAX_SIZE); + RTE_BITSET_DECLARE(bitset_b, EQUAL_SET_MAX_SIZE); rand_buf(bitset_a, RTE_BITSET_SIZE(size)); rand_buf(bitset_b, RTE_BITSET_SIZE(size)); diff --git a/app/test/test_lcore_var_perf.c b/app/test/test_lcore_var_perf.c index 41e29bbd49..5a74ce4808 100644 --- a/app/test/test_lcore_var_perf.c +++ b/app/test/test_lcore_var_perf.c @@ -185,7 +185,7 @@ test_lcore_var_access_n(unsigned int num_mods) double tls_latency; double lazy_tls_latency; double lvar_latency; - unsigned int mods[num_mods]; + unsigned int mods[MAX_MODS]; unsigned int i; for (i = 0; i < num_mods; i++) diff --git a/app/test/test_reassembly_perf.c b/app/test/test_reassembly_perf.c index 69cf029468..ac225e2b53 100644 --- a/app/test/test_reassembly_perf.c +++ b/app/test/test_reassembly_perf.c @@ -577,7 +577,7 @@ ipv4_reassembly_interleaved_flows_perf(uint8_t nb_frags) for (j = 0; j < 4; j++) nb_frags += frag_per_flow[i + j]; - struct rte_mbuf *buf_arr[nb_frags]; + struct rte_mbuf *buf_arr[MAX_FRAGMENTS]; for (j = 0; j < 4; j++) { join_array(buf_arr, mbufs[i + j], prev, frag_per_flow[i + j]); @@ -788,7 +788,7 @@ ipv6_reassembly_interleaved_flows_perf(int8_t nb_frags) for (j = 0; j < 4; j++) nb_frags += frag_per_flow[i + j]; - struct rte_mbuf *buf_arr[nb_frags]; + struct rte_mbuf *buf_arr[MAX_FRAGMENTS]; for (j = 0; j < 4; j++) { join_array(buf_arr, mbufs[i + j], prev, frag_per_flow[i + j]); -- 2.47.0.vfs.0.3