DPDK patches and discussions
 help / color / mirror / Atom feed
* [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap
@ 2020-04-01 13:11 Anatoly Burakov
  2020-04-01 13:11 ` [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
                   ` (3 more replies)
  0 siblings, 4 replies; 10+ messages in thread
From: Anatoly Burakov @ 2020-04-01 13:11 UTC (permalink / raw)
  To: dev; +Cc: drc

Due to the fact that the rte_realloc() test depends on the layout of
underlying memory, it can sometimes fail due to fragmentation of the
memory. To address this, make it so that the realloc autotests are run
using a newly created external memory heap instead of main memory.

Bugzilla ID: 424

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
---
 app/test/test_malloc.c | 116 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 102 insertions(+), 14 deletions(-)

diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index 67a48ba38a..3a45a00406 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -8,7 +8,9 @@
 #include <stdarg.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <sys/mman.h>
 #include <sys/queue.h>
+#include <unistd.h>
 
 #include <rte_common.h>
 #include <rte_memory.h>
@@ -372,7 +374,7 @@ test_multi_alloc_statistics(void)
 }
 
 static int
-test_realloc(void)
+test_realloc_socket(int socket)
 {
 	const char hello_str[] = "Hello, world!";
 	const unsigned size1 = 1024;
@@ -381,13 +383,15 @@ test_realloc(void)
 	const unsigned size4 = size3 + 1024;
 
 	/* test data is the same even if element is moved*/
-	char *ptr1 = rte_zmalloc(NULL, size1, RTE_CACHE_LINE_SIZE);
+	char *ptr1 = rte_zmalloc_socket(
+			NULL, size1, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr1){
 		printf("NULL pointer returned from rte_zmalloc\n");
 		return -1;
 	}
 	strlcpy(ptr1, hello_str, size1);
-	char *ptr2 = rte_realloc(ptr1, size2, RTE_CACHE_LINE_SIZE);
+	char *ptr2 = rte_realloc_socket(
+			ptr1, size2, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr2){
 		rte_free(ptr1);
 		printf("NULL pointer returned from rte_realloc\n");
@@ -411,7 +415,8 @@ test_realloc(void)
 	/* now allocate third element, free the second
 	 * and resize third. It should not move. (ptr1 is now invalid)
 	 */
-	char *ptr3 = rte_zmalloc(NULL, size3, RTE_CACHE_LINE_SIZE);
+	char *ptr3 = rte_zmalloc_socket(
+			NULL, size3, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr3){
 		printf("NULL pointer returned from rte_zmalloc\n");
 		rte_free(ptr2);
@@ -426,7 +431,8 @@ test_realloc(void)
 		}
 	rte_free(ptr2);
 	/* first resize to half the size of the freed block */
-	char *ptr4 = rte_realloc(ptr3, size4, RTE_CACHE_LINE_SIZE);
+	char *ptr4 = rte_realloc_socket(
+			ptr3, size4, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr4){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr3);
@@ -438,7 +444,8 @@ test_realloc(void)
 		return -1;
 	}
 	/* now resize again to the full size of the freed block */
-	ptr4 = rte_realloc(ptr3, size3 + size2 + size1, RTE_CACHE_LINE_SIZE);
+	ptr4 = rte_realloc_socket(ptr3, size3 + size2 + size1,
+			RTE_CACHE_LINE_SIZE, socket);
 	if (ptr3 != ptr4){
 		printf("Unexpected - ptr4 != ptr3 on second resize\n");
 		rte_free(ptr4);
@@ -449,12 +456,14 @@ test_realloc(void)
 	/* now try a resize to a smaller size, see if it works */
 	const unsigned size5 = 1024;
 	const unsigned size6 = size5 / 2;
-	char *ptr5 = rte_malloc(NULL, size5, RTE_CACHE_LINE_SIZE);
+	char *ptr5 = rte_malloc_socket(
+			NULL, size5, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr5){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
-	char *ptr6 = rte_realloc(ptr5, size6, RTE_CACHE_LINE_SIZE);
+	char *ptr6 = rte_realloc_socket(
+			ptr5, size6, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr6){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr5);
@@ -471,7 +480,7 @@ test_realloc(void)
 	const unsigned size7 = 1024;
 	const unsigned orig_align = RTE_CACHE_LINE_SIZE;
 	unsigned new_align = RTE_CACHE_LINE_SIZE * 2;
-	char *ptr7 = rte_malloc(NULL, size7, orig_align);
+	char *ptr7 = rte_malloc_socket(NULL, size7, orig_align, socket);
 	if (!ptr7){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
@@ -479,7 +488,7 @@ test_realloc(void)
 	/* calc an alignment we don't already have */
 	while(RTE_PTR_ALIGN(ptr7, new_align) == ptr7)
 		new_align *= 2;
-	char *ptr8 = rte_realloc(ptr7, size7, new_align);
+	char *ptr8 = rte_realloc_socket(ptr7, size7, new_align, socket);
 	if (!ptr8){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr7);
@@ -497,18 +506,21 @@ test_realloc(void)
 	 */
 	unsigned size9 = 1024, size10 = 1024;
 	unsigned size11 = size9 + size10 + 256;
-	char *ptr9 = rte_malloc(NULL, size9, RTE_CACHE_LINE_SIZE);
+	char *ptr9 = rte_malloc_socket(
+			NULL, size9, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr9){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
-	char *ptr10 = rte_malloc(NULL, size10, RTE_CACHE_LINE_SIZE);
+	char *ptr10 = rte_malloc_socket(
+			NULL, size10, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr10){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
 	rte_free(ptr9);
-	char *ptr11 = rte_realloc(ptr10, size11, RTE_CACHE_LINE_SIZE);
+	char *ptr11 = rte_realloc_socket(
+			ptr10, size11, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr11){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr10);
@@ -525,7 +537,8 @@ test_realloc(void)
 	 * We should get a malloc of the size requested*/
 	const size_t size12 = 1024;
 	size_t size12_check;
-	char *ptr12 = rte_realloc(NULL, size12, RTE_CACHE_LINE_SIZE);
+	char *ptr12 = rte_realloc_socket(
+			NULL, size12, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr12){
 		printf("NULL pointer returned from rte_realloc\n");
 		return -1;
@@ -537,8 +550,28 @@ test_realloc(void)
 	}
 	rte_free(ptr12);
 
+	/* do the same, but for regular memory */
+	ptr12 = rte_realloc(NULL, size12, RTE_CACHE_LINE_SIZE);
+	if (!ptr12) {
+		printf("NULL pointer returned from rte_realloc\n");
+		return -1;
+	}
+	if (rte_malloc_validate(ptr12, &size12_check) < 0 ||
+			size12_check != size12) {
+		rte_free(ptr12);
+		return -1;
+	}
+	rte_free(ptr12);
+
+	return 0;
+}
+
+static int
+test_realloc_numa(void)
+{
 	/* check realloc_socket part */
 	int32_t socket_count = 0, socket_allocated, socket;
+	void *ptr1, *ptr2;
 	int ret = -1;
 	size_t size = 1024;
 
@@ -577,7 +610,62 @@ test_realloc(void)
 	ret = 0;
 end:
 	rte_free(ptr1);
+	return ret;
+}
 
+static int
+test_realloc(void)
+{
+	const char *heap_name = "realloc_heap";
+	int realloc_heap_socket;
+	unsigned int mem_sz = 1U << 13; /* 8K */
+	unsigned int page_sz = sysconf(_SC_PAGESIZE);
+	void *mem;
+	int ret;
+
+	/*
+	 * the realloc tests depend on specific layout of underlying memory, so
+	 * to prevent accidental failures to do fragmented main heap, we will
+	 * do all of our tests on an artificially created memory.
+	 */
+	if (rte_malloc_heap_create(heap_name) != 0) {
+		printf("Failed to create external heap\n");
+		ret = -1;
+		goto end;
+	}
+	realloc_heap_socket = rte_malloc_heap_get_socket(heap_name);
+
+	mem = mmap(NULL, mem_sz, PROT_READ | PROT_WRITE,
+			MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if (mem == MAP_FAILED) {
+		printf("Failed to allocate memory for external heap\n");
+		ret = -1;
+		goto heap_destroy;
+	}
+
+	if (rte_malloc_heap_memory_add(
+			heap_name, mem, mem_sz, NULL, 0, page_sz) != 0) {
+		printf("Failed to add memory to external heap\n");
+		ret = -1;
+		goto mem_free;
+	}
+
+	/* run the socket-bound tests */
+	ret = test_realloc_socket(realloc_heap_socket);
+
+	if (ret != 0)
+		goto mem_remove;
+
+	/* now, run the NUMA node tests */
+	ret = test_realloc_numa();
+
+mem_remove:
+	rte_malloc_heap_memory_remove(heap_name, mem, mem_sz);
+mem_free:
+	munmap(mem, mem_sz);
+heap_destroy:
+	rte_malloc_heap_destroy(heap_name);
+end:
 	return ret;
 }
 
-- 
2.17.1

^ permalink raw reply	[flat|nested] 10+ messages in thread

* [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc
  2020-04-01 13:11 [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap Anatoly Burakov
@ 2020-04-01 13:11 ` Anatoly Burakov
  2020-04-02  2:43   ` David Christensen
  2020-04-02  2:40 ` [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap David Christensen
                   ` (2 subsequent siblings)
  3 siblings, 1 reply; 10+ messages in thread
From: Anatoly Burakov @ 2020-04-01 13:11 UTC (permalink / raw)
  To: dev; +Cc: drc

Realloc did not have bad parameter autotest. Add them.

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
---
 app/test/test_malloc.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index 3a45a00406..788595ead7 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -826,6 +826,11 @@ test_malloc_bad_params(void)
 	if (bad_ptr != NULL)
 		goto err_return;
 
+	/* rte_realloc expected to return null with inappropriate size */
+	bad_ptr = rte_realloc(NULL, size, align);
+	if (bad_ptr != NULL)
+		goto err_return;
+
 	/* rte_malloc expected to return null with inappropriate alignment */
 	align = 17;
 	size = 1024;
@@ -834,6 +839,11 @@ test_malloc_bad_params(void)
 	if (bad_ptr != NULL)
 		goto err_return;
 
+	/* rte_realloc expected to return null with inappropriate alignment */
+	bad_ptr = rte_realloc(NULL, size, align);
+	if (bad_ptr != NULL)
+		goto err_return;
+
 	return 0;
 
 err_return:
-- 
2.17.1

^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap
  2020-04-01 13:11 [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap Anatoly Burakov
  2020-04-01 13:11 ` [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
@ 2020-04-02  2:40 ` David Christensen
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 " Anatoly Burakov
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
  3 siblings, 0 replies; 10+ messages in thread
From: David Christensen @ 2020-04-02  2:40 UTC (permalink / raw)
  To: Anatoly Burakov, dev



On 4/1/20 6:11 AM, Anatoly Burakov wrote:
> Due to the fact that the rte_realloc() test depends on the layout of
> underlying memory, it can sometimes fail due to fragmentation of the
> memory. To address this, make it so that the realloc autotests are run
> using a newly created external memory heap instead of main memory.
> 
> Bugzilla ID: 424
> 
> Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
...
> +static int
> +test_realloc(void)
> +{
> +	const char *heap_name = "realloc_heap";
> +	int realloc_heap_socket;
> +	unsigned int mem_sz = 1U << 13; /* 8K */
> +	unsigned int page_sz = sysconf(_SC_PAGESIZE);
> +	void *mem;
> +	int ret;
> +
> +	/*
> +	 * the realloc tests depend on specific layout of underlying memory, so
> +	 * to prevent accidental failures to do fragmented main heap, we will
> +	 * do all of our tests on an artificially created memory.
> +	 */
> +	if (rte_malloc_heap_create(heap_name) != 0) {
> +		printf("Failed to create external heap\n");
> +		ret = -1;
> +		goto end;
> +	}
> +	realloc_heap_socket = rte_malloc_heap_get_socket(heap_name);
> +
> +	mem = mmap(NULL, mem_sz, PROT_READ | PROT_WRITE,
> +			MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
> +	if (mem == MAP_FAILED) {
> +		printf("Failed to allocate memory for external heap\n");
> +		ret = -1;
> +		goto heap_destroy;
> +	}
> +
> +	if (rte_malloc_heap_memory_add(
> +			heap_name, mem, mem_sz, NULL, 0, page_sz) != 0) {
> +		printf("Failed to add memory to external heap\n");
> +		ret = -1;
> +		goto mem_free;
> +	}
> +
> +	/* run the socket-bound tests */
> +	ret = test_realloc_socket(realloc_heap_socket);
> +
> +	if (ret != 0)
> +		goto mem_remove;
> +
> +	/* now, run the NUMA node tests */
> +	ret = test_realloc_numa();
> +
> +mem_remove:
> +	rte_malloc_heap_memory_remove(heap_name, mem, mem_sz);
> +mem_free:
> +	munmap(mem, mem_sz);
> +heap_destroy:
> +	rte_malloc_heap_destroy(heap_name);
> +end:
>   	return ret;
>   }
> 

Works on an x86_64 Lenovo server which was previously failing. Still 
fails on a Power 9 system but with a new error:

RTE>>malloc_autotest
test_str_to_size() passed
test_zero_aligned_alloc() passed
test_malloc_bad_params() passed
Failed to add memory to external heap
test_realloc() failed
Test Failed

I'm guessing page_sz is the problem:

(gdb) s
rte_malloc_heap_memory_add (heap_name=0x11bceda0 "realloc_heap", 
va_addr=0x7ffff4c80000, len=8192, iova_addrs=0x0, n_pages=0, page_sz=65536)
     at ../lib/librte_eal/common/rte_malloc.c:358
358		struct malloc_heap *heap = NULL;
(gdb) n
363		if (heap_name == NULL || va_addr == NULL ||
(gdb) n
364				page_sz == 0 || !rte_is_power_of_2(page_sz) ||
(gdb) n
365				RTE_ALIGN(len, page_sz) != len ||
(gdb) n
364				page_sz == 0 || !rte_is_power_of_2(page_sz) ||
(gdb) n
371			rte_errno = EINVAL;

When I change page_sz to 4K the test succeeds.

Dave

^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc
  2020-04-01 13:11 ` [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
@ 2020-04-02  2:43   ` David Christensen
  0 siblings, 0 replies; 10+ messages in thread
From: David Christensen @ 2020-04-02  2:43 UTC (permalink / raw)
  To: Anatoly Burakov, dev



On 4/1/20 6:11 AM, Anatoly Burakov wrote:
> Realloc did not have bad parameter autotest. Add them.
> 
> Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
> ---

Reviewed-by: David Christensen <drc@linux.vnet.ibm.com>

^ permalink raw reply	[flat|nested] 10+ messages in thread

* [dpdk-dev] [PATCH v2 1/2] test/malloc: run realloc tests on external heap
  2020-04-01 13:11 [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap Anatoly Burakov
  2020-04-01 13:11 ` [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
  2020-04-02  2:40 ` [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap David Christensen
@ 2020-04-02  9:02 ` Anatoly Burakov
  2020-04-02 19:54   ` David Christensen
  2020-04-10 11:19   ` David Marchand
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
  3 siblings, 2 replies; 10+ messages in thread
From: Anatoly Burakov @ 2020-04-02  9:02 UTC (permalink / raw)
  To: dev; +Cc: drc

Due to the fact that the rte_realloc() test depends on the layout of
underlying memory, it can sometimes fail due to fragmentation of the
memory. To address this, make it so that the realloc autotests are run
using a newly created external memory heap instead of main memory.

Bugzilla ID: 424

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
---

Notes:
    v2:
    - Fixed 4K page assumption

 app/test/test_malloc.c | 118 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 104 insertions(+), 14 deletions(-)

diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index 67a48ba38a..eed0b20d5a 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -8,7 +8,9 @@
 #include <stdarg.h>
 #include <errno.h>
 #include <stdlib.h>
+#include <sys/mman.h>
 #include <sys/queue.h>
+#include <unistd.h>
 
 #include <rte_common.h>
 #include <rte_memory.h>
@@ -372,7 +374,7 @@ test_multi_alloc_statistics(void)
 }
 
 static int
-test_realloc(void)
+test_realloc_socket(int socket)
 {
 	const char hello_str[] = "Hello, world!";
 	const unsigned size1 = 1024;
@@ -381,13 +383,15 @@ test_realloc(void)
 	const unsigned size4 = size3 + 1024;
 
 	/* test data is the same even if element is moved*/
-	char *ptr1 = rte_zmalloc(NULL, size1, RTE_CACHE_LINE_SIZE);
+	char *ptr1 = rte_zmalloc_socket(
+			NULL, size1, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr1){
 		printf("NULL pointer returned from rte_zmalloc\n");
 		return -1;
 	}
 	strlcpy(ptr1, hello_str, size1);
-	char *ptr2 = rte_realloc(ptr1, size2, RTE_CACHE_LINE_SIZE);
+	char *ptr2 = rte_realloc_socket(
+			ptr1, size2, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr2){
 		rte_free(ptr1);
 		printf("NULL pointer returned from rte_realloc\n");
@@ -411,7 +415,8 @@ test_realloc(void)
 	/* now allocate third element, free the second
 	 * and resize third. It should not move. (ptr1 is now invalid)
 	 */
-	char *ptr3 = rte_zmalloc(NULL, size3, RTE_CACHE_LINE_SIZE);
+	char *ptr3 = rte_zmalloc_socket(
+			NULL, size3, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr3){
 		printf("NULL pointer returned from rte_zmalloc\n");
 		rte_free(ptr2);
@@ -426,7 +431,8 @@ test_realloc(void)
 		}
 	rte_free(ptr2);
 	/* first resize to half the size of the freed block */
-	char *ptr4 = rte_realloc(ptr3, size4, RTE_CACHE_LINE_SIZE);
+	char *ptr4 = rte_realloc_socket(
+			ptr3, size4, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr4){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr3);
@@ -438,7 +444,8 @@ test_realloc(void)
 		return -1;
 	}
 	/* now resize again to the full size of the freed block */
-	ptr4 = rte_realloc(ptr3, size3 + size2 + size1, RTE_CACHE_LINE_SIZE);
+	ptr4 = rte_realloc_socket(ptr3, size3 + size2 + size1,
+			RTE_CACHE_LINE_SIZE, socket);
 	if (ptr3 != ptr4){
 		printf("Unexpected - ptr4 != ptr3 on second resize\n");
 		rte_free(ptr4);
@@ -449,12 +456,14 @@ test_realloc(void)
 	/* now try a resize to a smaller size, see if it works */
 	const unsigned size5 = 1024;
 	const unsigned size6 = size5 / 2;
-	char *ptr5 = rte_malloc(NULL, size5, RTE_CACHE_LINE_SIZE);
+	char *ptr5 = rte_malloc_socket(
+			NULL, size5, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr5){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
-	char *ptr6 = rte_realloc(ptr5, size6, RTE_CACHE_LINE_SIZE);
+	char *ptr6 = rte_realloc_socket(
+			ptr5, size6, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr6){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr5);
@@ -471,7 +480,7 @@ test_realloc(void)
 	const unsigned size7 = 1024;
 	const unsigned orig_align = RTE_CACHE_LINE_SIZE;
 	unsigned new_align = RTE_CACHE_LINE_SIZE * 2;
-	char *ptr7 = rte_malloc(NULL, size7, orig_align);
+	char *ptr7 = rte_malloc_socket(NULL, size7, orig_align, socket);
 	if (!ptr7){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
@@ -479,7 +488,7 @@ test_realloc(void)
 	/* calc an alignment we don't already have */
 	while(RTE_PTR_ALIGN(ptr7, new_align) == ptr7)
 		new_align *= 2;
-	char *ptr8 = rte_realloc(ptr7, size7, new_align);
+	char *ptr8 = rte_realloc_socket(ptr7, size7, new_align, socket);
 	if (!ptr8){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr7);
@@ -497,18 +506,21 @@ test_realloc(void)
 	 */
 	unsigned size9 = 1024, size10 = 1024;
 	unsigned size11 = size9 + size10 + 256;
-	char *ptr9 = rte_malloc(NULL, size9, RTE_CACHE_LINE_SIZE);
+	char *ptr9 = rte_malloc_socket(
+			NULL, size9, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr9){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
-	char *ptr10 = rte_malloc(NULL, size10, RTE_CACHE_LINE_SIZE);
+	char *ptr10 = rte_malloc_socket(
+			NULL, size10, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr10){
 		printf("NULL pointer returned from rte_malloc\n");
 		return -1;
 	}
 	rte_free(ptr9);
-	char *ptr11 = rte_realloc(ptr10, size11, RTE_CACHE_LINE_SIZE);
+	char *ptr11 = rte_realloc_socket(
+			ptr10, size11, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr11){
 		printf("NULL pointer returned from rte_realloc\n");
 		rte_free(ptr10);
@@ -525,7 +537,8 @@ test_realloc(void)
 	 * We should get a malloc of the size requested*/
 	const size_t size12 = 1024;
 	size_t size12_check;
-	char *ptr12 = rte_realloc(NULL, size12, RTE_CACHE_LINE_SIZE);
+	char *ptr12 = rte_realloc_socket(
+			NULL, size12, RTE_CACHE_LINE_SIZE, socket);
 	if (!ptr12){
 		printf("NULL pointer returned from rte_realloc\n");
 		return -1;
@@ -537,8 +550,28 @@ test_realloc(void)
 	}
 	rte_free(ptr12);
 
+	/* do the same, but for regular memory */
+	ptr12 = rte_realloc(NULL, size12, RTE_CACHE_LINE_SIZE);
+	if (!ptr12) {
+		printf("NULL pointer returned from rte_realloc\n");
+		return -1;
+	}
+	if (rte_malloc_validate(ptr12, &size12_check) < 0 ||
+			size12_check != size12) {
+		rte_free(ptr12);
+		return -1;
+	}
+	rte_free(ptr12);
+
+	return 0;
+}
+
+static int
+test_realloc_numa(void)
+{
 	/* check realloc_socket part */
 	int32_t socket_count = 0, socket_allocated, socket;
+	void *ptr1, *ptr2;
 	int ret = -1;
 	size_t size = 1024;
 
@@ -577,7 +610,64 @@ test_realloc(void)
 	ret = 0;
 end:
 	rte_free(ptr1);
+	return ret;
+}
 
+static int
+test_realloc(void)
+{
+	const char *heap_name = "realloc_heap";
+	int realloc_heap_socket;
+	unsigned int mem_sz = 1U << 13; /* 8K */
+	unsigned int page_sz = sysconf(_SC_PAGESIZE);
+	void *mem;
+	int ret;
+
+	/* page size may be bigger than total mem size, so adjust */
+	mem_sz = RTE_MAX(mem_sz, page_sz);
+
+	/*
+	 * the realloc tests depend on specific layout of underlying memory, so
+	 * to prevent accidental failures to do fragmented main heap, we will
+	 * do all of our tests on an artificially created memory.
+	 */
+	if (rte_malloc_heap_create(heap_name) != 0) {
+		printf("Failed to create external heap\n");
+		ret = -1;
+		goto end;
+	}
+	realloc_heap_socket = rte_malloc_heap_get_socket(heap_name);
+
+	mem = mmap(NULL, mem_sz, PROT_READ | PROT_WRITE,
+			MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if (mem == MAP_FAILED) {
+		printf("Failed to allocate memory for external heap\n");
+		ret = -1;
+		goto heap_destroy;
+	}
+
+	if (rte_malloc_heap_memory_add(
+			heap_name, mem, mem_sz, NULL, 0, page_sz) != 0) {
+		printf("Failed to add memory to external heap\n");
+		ret = -1;
+		goto mem_free;
+	}
+
+	/* run the socket-bound tests */
+	ret = test_realloc_socket(realloc_heap_socket);
+	if (ret != 0)
+		goto mem_remove;
+
+	/* now, run the NUMA node tests */
+	ret = test_realloc_numa();
+
+mem_remove:
+	rte_malloc_heap_memory_remove(heap_name, mem, mem_sz);
+mem_free:
+	munmap(mem, mem_sz);
+heap_destroy:
+	rte_malloc_heap_destroy(heap_name);
+end:
 	return ret;
 }
 
-- 
2.17.1

^ permalink raw reply	[flat|nested] 10+ messages in thread

* [dpdk-dev] [PATCH v2 2/2] test/malloc: add bad parameter tests for realloc
  2020-04-01 13:11 [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap Anatoly Burakov
                   ` (2 preceding siblings ...)
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 " Anatoly Burakov
@ 2020-04-02  9:02 ` Anatoly Burakov
  3 siblings, 0 replies; 10+ messages in thread
From: Anatoly Burakov @ 2020-04-02  9:02 UTC (permalink / raw)
  To: dev; +Cc: drc

Realloc did not have bad parameter autotest. Add them.

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Reviewed-by: David Christensen <drc@linux.vnet.ibm.com>
---
 app/test/test_malloc.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/app/test/test_malloc.c b/app/test/test_malloc.c
index eed0b20d5a..04608a97e5 100644
--- a/app/test/test_malloc.c
+++ b/app/test/test_malloc.c
@@ -828,6 +828,11 @@ test_malloc_bad_params(void)
 	if (bad_ptr != NULL)
 		goto err_return;
 
+	/* rte_realloc expected to return null with inappropriate size */
+	bad_ptr = rte_realloc(NULL, size, align);
+	if (bad_ptr != NULL)
+		goto err_return;
+
 	/* rte_malloc expected to return null with inappropriate alignment */
 	align = 17;
 	size = 1024;
@@ -836,6 +841,11 @@ test_malloc_bad_params(void)
 	if (bad_ptr != NULL)
 		goto err_return;
 
+	/* rte_realloc expected to return null with inappropriate alignment */
+	bad_ptr = rte_realloc(NULL, size, align);
+	if (bad_ptr != NULL)
+		goto err_return;
+
 	return 0;
 
 err_return:
-- 
2.17.1

^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH v2 1/2] test/malloc: run realloc tests on external heap
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 " Anatoly Burakov
@ 2020-04-02 19:54   ` David Christensen
  2020-04-21 16:16     ` David Marchand
  2020-04-10 11:19   ` David Marchand
  1 sibling, 1 reply; 10+ messages in thread
From: David Christensen @ 2020-04-02 19:54 UTC (permalink / raw)
  To: Anatoly Burakov, dev



On 4/2/20 2:02 AM, Anatoly Burakov wrote:
> Due to the fact that the rte_realloc() test depends on the layout of
> underlying memory, it can sometimes fail due to fragmentation of the
> memory. To address this, make it so that the realloc autotests are run
> using a newly created external memory heap instead of main memory.
> 
> Bugzilla ID: 424
> 
> Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
...

Tested-by: David Christensen <drc@linux.vnet.ibm.com>

^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH v2 1/2] test/malloc: run realloc tests on external heap
  2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 " Anatoly Burakov
  2020-04-02 19:54   ` David Christensen
@ 2020-04-10 11:19   ` David Marchand
  2020-04-17 12:12     ` Burakov, Anatoly
  1 sibling, 1 reply; 10+ messages in thread
From: David Marchand @ 2020-04-10 11:19 UTC (permalink / raw)
  To: Anatoly Burakov; +Cc: dev, David Christensen

Hello Anatoly,

On Thu, Apr 2, 2020 at 11:07 AM Anatoly Burakov
<anatoly.burakov@intel.com> wrote:
>
> Due to the fact that the rte_realloc() test depends on the layout of
> underlying memory, it can sometimes fail due to fragmentation of the
> memory. To address this, make it so that the realloc autotests are run
> using a newly created external memory heap instead of main memory.
>
> Bugzilla ID: 424

Is it worth backporting?
Thanks.


-- 
David Marchand


^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH v2 1/2] test/malloc: run realloc tests on external heap
  2020-04-10 11:19   ` David Marchand
@ 2020-04-17 12:12     ` Burakov, Anatoly
  0 siblings, 0 replies; 10+ messages in thread
From: Burakov, Anatoly @ 2020-04-17 12:12 UTC (permalink / raw)
  To: David Marchand; +Cc: dev, David Christensen

On 10-Apr-20 12:19 PM, David Marchand wrote:
> Hello Anatoly,
> 
> On Thu, Apr 2, 2020 at 11:07 AM Anatoly Burakov
> <anatoly.burakov@intel.com> wrote:
>>
>> Due to the fact that the rte_realloc() test depends on the layout of
>> underlying memory, it can sometimes fail due to fragmentation of the
>> memory. To address this, make it so that the realloc autotests are run
>> using a newly created external memory heap instead of main memory.
>>
>> Bugzilla ID: 424
> 
> Is it worth backporting?
> Thanks.
> 
> 

I don't think so. It's a very low priority issue and not really a bug.

-- 
Thanks,
Anatoly

^ permalink raw reply	[flat|nested] 10+ messages in thread

* Re: [dpdk-dev] [PATCH v2 1/2] test/malloc: run realloc tests on external heap
  2020-04-02 19:54   ` David Christensen
@ 2020-04-21 16:16     ` David Marchand
  0 siblings, 0 replies; 10+ messages in thread
From: David Marchand @ 2020-04-21 16:16 UTC (permalink / raw)
  To: Anatoly Burakov; +Cc: dev, David Christensen

On Thu, Apr 2, 2020 at 9:55 PM David Christensen <drc@linux.vnet.ibm.com> wrote:
> On 4/2/20 2:02 AM, Anatoly Burakov wrote:
> > Due to the fact that the rte_realloc() test depends on the layout of
> > underlying memory, it can sometimes fail due to fragmentation of the
> > memory. To address this, make it so that the realloc autotests are run
> > using a newly created external memory heap instead of main memory.
> >
> > Bugzilla ID: 424
> >
> > Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
> ...
>
> Tested-by: David Christensen <drc@linux.vnet.ibm.com>

Series applied, thanks.


-- 
David Marchand


^ permalink raw reply	[flat|nested] 10+ messages in thread

end of thread, other threads:[~2020-04-21 16:16 UTC | newest]

Thread overview: 10+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-04-01 13:11 [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap Anatoly Burakov
2020-04-01 13:11 ` [dpdk-dev] [PATCH 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov
2020-04-02  2:43   ` David Christensen
2020-04-02  2:40 ` [dpdk-dev] [PATCH 1/2] test/malloc: run realloc tests on external heap David Christensen
2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 " Anatoly Burakov
2020-04-02 19:54   ` David Christensen
2020-04-21 16:16     ` David Marchand
2020-04-10 11:19   ` David Marchand
2020-04-17 12:12     ` Burakov, Anatoly
2020-04-02  9:02 ` [dpdk-dev] [PATCH v2 2/2] test/malloc: add bad parameter tests for realloc Anatoly Burakov

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror http://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ http://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git