patch 'test/malloc: improve resiliency' has been queued to stable release 24.11.3
Kevin Traynor
ktraynor at redhat.com
Fri Jul 18 21:30:00 CEST 2025
Hi,
FYI, your patch has been queued to stable release 24.11.3
Note it hasn't been pushed to http://dpdk.org/browse/dpdk-stable yet.
It will be pushed if I get no objections before 07/23/25. So please
shout if anyone has objections.
Also note that after the patch there's a diff of the upstream commit vs the
patch applied to the branch. This will indicate if there was any rebasing
needed to apply to the stable branch. If there were code changes for rebasing
(ie: not only metadata diffs), please double check that the rebase was
correctly done.
Queued patches are on a temporary branch at:
https://github.com/kevintraynor/dpdk-stable
This queued commit can be viewed at:
https://github.com/kevintraynor/dpdk-stable/commit/935bcec6d4bc380929e209d06baac9d7e3df61e4
Thanks.
Kevin
---
>From 935bcec6d4bc380929e209d06baac9d7e3df61e4 Mon Sep 17 00:00:00 2001
From: Bruce Richardson <bruce.richardson at intel.com>
Date: Wed, 26 Mar 2025 17:13:24 +0000
Subject: [PATCH] test/malloc: improve resiliency
[ upstream commit 7777215715d475b5e884179de39ff4bc6b8cbf72 ]
The test case "test_multi_alloc_statistics" was brittle in that it did
some allocations and frees and then checked statistics without
considering the initial state of the malloc heaps. This meant that,
depending on what allocations/frees were done beforehand, the test can
sometimes fail.
We can improve resiliency by running the test using a new malloc heap,
which means it is unaffected by any previous allocations.
Bugzilla ID: 1579
Fixes: a40a1f8231b4 ("app: various tests update")
Signed-off-by: Bruce Richardson <bruce.richardson at intel.com>
Acked-by: Chengwen Feng <fengchengwen at huawei.com>
---
app/test/test_malloc.c | 77 +++++++++++++++++++++++++++++++++++-------
1 file changed, 64 insertions(+), 13 deletions(-)
diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index 02a7d8ef20..d6f8da3b24 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -26,4 +26,5 @@
#include <rte_cycles.h>
#include <rte_random.h>
+#include <rte_eal_paging.h>
#include <rte_string_fns.h>
@@ -268,4 +269,5 @@ static int
test_multi_alloc_statistics(void)
{
+ int ret = -1; /* default return is error, cleared at end on success */
int socket = 0;
struct rte_malloc_socket_stats pre_stats, post_stats ,first_stats, second_stats;
@@ -273,4 +275,40 @@ test_multi_alloc_statistics(void)
int align = 1024;
int overhead = 0;
+ const size_t pgsz = rte_mem_page_size();
+ const size_t heap_size = (1 << 22);
+
+ if (pgsz > heap_size) {
+ printf("Page size (%zu) is bigger than heap size, skipping alloc stats test\n",
+ pgsz);
+ return TEST_SKIPPED;
+ }
+ if (heap_size % pgsz != 0) {
+ printf("Heap size (%zu) is not a multiple of page size (%zu), skipping alloc stats test\n",
+ heap_size, pgsz);
+ return TEST_SKIPPED;
+ }
+
+ if (rte_malloc_heap_create(__func__) != 0) {
+ printf("Failed to create test malloc heap\n");
+ goto end;
+ }
+
+ /* Allocate some memory using malloc and add it to our test heap. */
+ void *unaligned_memory = malloc(heap_size + pgsz);
+ if (unaligned_memory == NULL) {
+ printf("Failed to allocate memory\n");
+ goto cleanup_empty_heap;
+ }
+ void *memory = RTE_PTR_ALIGN(unaligned_memory, pgsz);
+ if (rte_malloc_heap_memory_add(__func__, memory, heap_size, NULL,
+ heap_size / pgsz, pgsz) != 0) {
+ printf("Failed to add memory to heap\n");
+ goto cleanup_allocated_memory;
+ }
+ socket = rte_malloc_heap_get_socket(__func__);
+ if (socket < 0) {
+ printf("Failed to get socket for test malloc heap.\n");
+ goto cleanup_all;
+ }
/* Dynamically calculate the overhead by allocating one cacheline and
@@ -281,5 +319,5 @@ test_multi_alloc_statistics(void)
void *dummy = rte_malloc_socket(NULL, RTE_CACHE_LINE_SIZE, 0, socket);
if (dummy == NULL)
- return -1;
+ goto cleanup_all;
rte_malloc_get_socket_stats(socket, &post_stats);
@@ -296,5 +334,6 @@ test_multi_alloc_statistics(void)
void *p1 = rte_malloc_socket("stats", size , align, socket);
if (!p1)
- return -1;
+ goto cleanup_all;
+
rte_free(p1);
rte_malloc_dump_stats(stdout, "stats");
@@ -309,5 +348,5 @@ test_multi_alloc_statistics(void)
(post_stats.free_count != pre_stats.free_count)) {
printf("Malloc statistics are incorrect - freed alloc\n");
- return -1;
+ goto cleanup_all;
}
/* Check two consecutive allocations */
@@ -317,10 +356,10 @@ test_multi_alloc_statistics(void)
void *p2 = rte_malloc_socket("add", size ,align, socket);
if (!p2)
- return -1;
+ goto cleanup_all;
rte_malloc_get_socket_stats(socket,&first_stats);
void *p3 = rte_malloc_socket("add2", size,align, socket);
if (!p3)
- return -1;
+ goto cleanup_all;
rte_malloc_get_socket_stats(socket,&second_stats);
@@ -334,5 +373,5 @@ test_multi_alloc_statistics(void)
if(second_stats.heap_totalsz_bytes != first_stats.heap_totalsz_bytes) {
printf("Incorrect heap statistics: Total size \n");
- return -1;
+ goto cleanup_all;
}
/* Check allocated size is equal to two additions plus overhead */
@@ -340,15 +379,15 @@ test_multi_alloc_statistics(void)
size + overhead + first_stats.heap_allocsz_bytes) {
printf("Incorrect heap statistics: Allocated size \n");
- return -1;
+ goto cleanup_all;
}
/* Check that allocation count increments correctly i.e. +1 */
if (second_stats.alloc_count != first_stats.alloc_count + 1) {
printf("Incorrect heap statistics: Allocated count \n");
- return -1;
+ goto cleanup_all;
}
if (second_stats.free_count != first_stats.free_count){
printf("Incorrect heap statistics: Free count \n");
- return -1;
+ goto cleanup_all;
}
@@ -356,10 +395,10 @@ test_multi_alloc_statistics(void)
if (post_stats.greatest_free_size != pre_stats.greatest_free_size) {
printf("Incorrect heap statistics: Greatest free size \n");
- return -1;
+ goto cleanup_all;
}
/* Free size must equal the original free size minus the new allocation*/
if (first_stats.heap_freesz_bytes <= second_stats.heap_freesz_bytes) {
printf("Incorrect heap statistics: Free size \n");
- return -1;
+ goto cleanup_all;
}
@@ -370,7 +409,19 @@ test_multi_alloc_statistics(void)
(post_stats.free_count != pre_stats.free_count)) {
printf("Malloc statistics are incorrect - freed alloc\n");
- return -1;
+ goto cleanup_all;
}
- return 0;
+
+ /* set return value as success before cleanup */
+ ret = 0;
+
+ /* cleanup */
+cleanup_all:
+ rte_malloc_heap_memory_remove(__func__, memory, heap_size);
+cleanup_allocated_memory:
+ free(unaligned_memory);
+cleanup_empty_heap:
+ rte_malloc_heap_destroy(__func__);
+end:
+ return ret;
}
--
2.50.0
---
Diff of the applied patch vs upstream commit (please double-check if non-empty:
---
--- - 2025-07-18 20:29:13.350744772 +0100
+++ 0066-test-malloc-improve-resiliency.patch 2025-07-18 20:29:10.966907441 +0100
@@ -1 +1 @@
-From 7777215715d475b5e884179de39ff4bc6b8cbf72 Mon Sep 17 00:00:00 2001
+From 935bcec6d4bc380929e209d06baac9d7e3df61e4 Mon Sep 17 00:00:00 2001
@@ -5,0 +6,2 @@
+[ upstream commit 7777215715d475b5e884179de39ff4bc6b8cbf72 ]
+
@@ -17 +18,0 @@
-Cc: stable at dpdk.org
More information about the stable
mailing list