test: improve resiliency of malloc autotest
Checks
Commit Message
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")
Cc: stable@dpdk.org
Signed-off-by: Bruce Richardson <bruce.richardson@intel.com>
---
app/test/test_malloc.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
@@ -25,6 +25,7 @@
#include <rte_malloc.h>
#include <rte_cycles.h>
#include <rte_random.h>
+#include <rte_eal_paging.h>
#include <rte_string_fns.h>
#define N 10000
@@ -272,6 +273,28 @@ test_multi_alloc_statistics(void)
size_t size = 2048;
int align = 1024;
int overhead = 0;
+ const size_t heap_size = (1 << 21);
+
+ if (rte_malloc_heap_create(__func__) != 0) {
+ printf("Failed to create test malloc heap\n");
+ return -1;
+ }
+ /* allocate some memory using malloc and add it to our test heap. */
+ void *memory = mmap(NULL, heap_size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (memory == MAP_FAILED) {
+ printf("Failed to allocate memory\n");
+ return -1;
+ }
+ if (rte_malloc_heap_memory_add(__func__, memory, heap_size, NULL, 1, heap_size) != 0) {
+ printf("Failed to add memory to heap\n");
+ return -1;
+ }
+ socket = rte_malloc_heap_get_socket(__func__);
+ if (socket < 0) {
+ printf("Failed to get socket for test malloc heap.\n");
+ return -1;
+ }
/* Dynamically calculate the overhead by allocating one cacheline and
* then comparing what was allocated from the heap.
@@ -371,6 +394,11 @@ test_multi_alloc_statistics(void)
printf("Malloc statistics are incorrect - freed alloc\n");
return -1;
}
+
+ /* cleanup */
+ rte_malloc_heap_memory_remove(__func__, memory, heap_size);
+ rte_malloc_heap_destroy(__func__);
+ munmap(memory, heap_size);
return 0;
}