This patch supports rte_memarea_alloc() and rte_memarea_free() API
test.
Signed-off-by: Chengwen Feng <fengcheng...@huawei.com>
Reviewed-by: Dongdong Liu <liudongdo...@huawei.com>
---
app/test/test_memarea.c | 135 +++++++++++++++++++++++++++++++++++++++-
1 file changed, 134 insertions(+), 1 deletion(-)
diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c
index c9de779a1d..efabc594b7 100644
--- a/app/test/test_memarea.c
+++ b/app/test/test_memarea.c
@@ -47,6 +47,12 @@ test_memarea_init_param(struct rte_memarea_param *init)
init->mt_safe = 1;
}
+static void
+test_memarea_fill_region(void *ptr, size_t size)
+{
+ memset(ptr, 0xff, size);
+}
+
static int
test_memarea_create_bad_param(void)
{
@@ -95,8 +101,8 @@ test_memarea_create_bad_param(void)
static int
test_memarea_create_destroy(void)
{
+ struct rte_memarea *ma, *src_ma;
struct rte_memarea_param init;
- struct rte_memarea *ma;
/* test for create with HEAP */
test_memarea_init_param(&init);
@@ -113,6 +119,130 @@ test_memarea_create_destroy(void)
RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL");
rte_memarea_destroy(ma);
+ /* test for create with another memarea */
+ test_memarea_init_param(&init);
+ init.source = RTE_MEMAREA_SOURCE_LIBC;
+ src_ma = rte_memarea_create(&init);
+ RTE_TEST_ASSERT(src_ma != NULL, "Expected Non-NULL");
+ test_memarea_init_param(&init);
+ init.source = RTE_MEMAREA_SOURCE_MEMAREA;
+ init.total_sz = init.total_sz >> 1;
+ init.src_memarea = src_ma;
+ ma = rte_memarea_create(&init);
+ RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL");
+ rte_memarea_destroy(ma);
+ rte_memarea_destroy(src_ma);
+
+ return 0;
+}
+
+static int
+test_memarea_alloc_fail(void)
+{
+ struct rte_memarea_param init;
+ struct rte_memarea *ma;
+ void *ptr[2];
+
+ test_memarea_init_param(&init);
+ init.source = RTE_MEMAREA_SOURCE_LIBC;
+ init.total_sz = MEMAREA_TEST_DEFAULT_SIZE;
+ ma = rte_memarea_create(&init);
+ RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL");
+
+ /* test alloc fail with big size */
+ ptr[0] = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE, 0);
+ RTE_TEST_ASSERT(ptr[0] == NULL, "Expected NULL");
+
+ /* test alloc fail because no memory */
+ ptr[0] = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE -
RTE_CACHE_LINE_SIZE, 0);
+ RTE_TEST_ASSERT(ptr[0] != NULL, "Expected Non-NULL");
+ ptr[1] = rte_memarea_alloc(ma, 1, 0);
+ RTE_TEST_ASSERT(ptr[1] == NULL, "Expected NULL");
+ rte_memarea_free(ma, ptr[0]);
+
+ /* test alloc fail when second fail */
+ ptr[0] = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0);
+ RTE_TEST_ASSERT(ptr[0] != NULL, "Expected Non-NULL");
+ test_memarea_fill_region(ptr[0], MEMAREA_TEST_DEFAULT_SIZE >> 1);
+ ptr[1] = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0);
+ RTE_TEST_ASSERT(ptr[1] == NULL, "Expected NULL");
+ rte_memarea_free(ma, ptr[0]);
+ ptr[1] = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0);
+ RTE_TEST_ASSERT(ptr[1] != NULL, "Expected Non-NULL");
+ test_memarea_fill_region(ptr[1], MEMAREA_TEST_DEFAULT_SIZE >> 1);
+ rte_memarea_free(ma, ptr[1]);
+
+ rte_memarea_destroy(ma);
+
+ return 0;
+}
+
+static int
+test_memarea_free_fail(void)
+{
+ struct rte_memarea_param init;
+ struct rte_memarea *ma;
+ void *ptr;
+
+ test_memarea_init_param(&init);
+ init.source = RTE_MEMAREA_SOURCE_LIBC;
+ init.total_sz = MEMAREA_TEST_DEFAULT_SIZE;
+ ma = rte_memarea_create(&init);
+ RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL");
+
+ /* test repeat free */
+ ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0);
+ RTE_TEST_ASSERT(ptr != NULL, "Expected Non-NULL");
+ test_memarea_fill_region(ptr, MEMAREA_TEST_DEFAULT_SIZE >> 1);
+ rte_memarea_free(ma, ptr);
+ rte_memarea_free(ma, ptr);
+
+ rte_memarea_destroy(ma);
+
+ return 0;
+}
+
+static int
+test_memarea_alloc_free(void)
+{
+#define ALLOC_MAX_NUM 8
+ struct rte_memarea_param init;
+ void *ptr[ALLOC_MAX_NUM];
+ struct rte_memarea *ma;
+ int i;
+
+ test_memarea_init_param(&init);
+ init.source = RTE_MEMAREA_SOURCE_LIBC;
+ init.total_sz = MEMAREA_TEST_DEFAULT_SIZE;
+ ma = rte_memarea_create(&init);
+ RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL");
+ memset(ptr, 0, sizeof(ptr));
+
+ /* test random alloc and free */
+ for (i = 0; i < ALLOC_MAX_NUM; i++)
+ ptr[i] = rte_memarea_alloc(ma, 1, 0);
+
+ /* test merge left */
+ rte_memarea_free(ma, ptr[0]);
+ rte_memarea_free(ma, ptr[1]);
+
+ /* test merge right */
+ rte_memarea_free(ma, ptr[7]);
+ rte_memarea_free(ma, ptr[6]);
+
+ /* test merge left and right */
+ rte_memarea_free(ma, ptr[3]);
+ rte_memarea_free(ma, ptr[2]);
+
+ /* test merge remains */
+ rte_memarea_free(ma, ptr[4]);
+ rte_memarea_free(ma, ptr[5]);
+
+ /* test free NULL */
+ rte_memarea_free(ma, NULL);
+
+ rte_memarea_destroy(ma);
+
return 0;
}
@@ -123,6 +253,9 @@ test_memarea(void)
MEMAREA_TEST_API_RUN(test_memarea_create_bad_param);
MEMAREA_TEST_API_RUN(test_memarea_create_destroy);
+ MEMAREA_TEST_API_RUN(test_memarea_alloc_fail);
+ MEMAREA_TEST_API_RUN(test_memarea_free_fail);
+ MEMAREA_TEST_API_RUN(test_memarea_alloc_free);
return test_memarea_retcode();
}
--
2.33.0
