From mboxrd@z Thu Jan 1 00:00:00 1970 From: David Hunt Subject: [PATCH 4/6] mempool: add autotest for external mempool custom example Date: Tue, 16 Feb 2016 14:48:13 +0000 Message-ID: <1455634095-4183-5-git-send-email-david.hunt@intel.com> References: <1453829155-1366-1-git-send-email-david.hunt@intel.com> <1455634095-4183-1-git-send-email-david.hunt@intel.com> To: dev@dpdk.org Return-path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 47427C316 for ; Tue, 16 Feb 2016 15:48:54 +0100 (CET) In-Reply-To: <1455634095-4183-1-git-send-email-david.hunt@intel.com> List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Signed-off-by: David Hunt --- app/test/Makefile | 1 + app/test/test_ext_mempool.c | 451 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 452 insertions(+) create mode 100644 app/test/test_ext_mempool.c diff --git a/app/test/Makefile b/app/test/Makefile index ec33e1a..9a2f75f 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -74,6 +74,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_TIMER) += test_timer_perf.c SRCS-$(CONFIG_RTE_LIBRTE_TIMER) += test_timer_racecond.c SRCS-y += test_mempool.c +SRCS-y += test_ext_mempool.c SRCS-y += test_mempool_perf.c SRCS-y += test_mbuf.c diff --git a/app/test/test_ext_mempool.c b/app/test/test_ext_mempool.c new file mode 100644 index 0000000..6beada0 --- /dev/null +++ b/app/test/test_ext_mempool.c @@ -0,0 +1,451 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "test.h" + +/* + * Mempool + * ======= + * + * Basic tests: done on one core with and without cache: + * + * - Get one object, put one object + * - Get two objects, put two objects + * - Get all objects, test that their content is not modified and + * put them back in the pool. + */ + +#define TIME_S 5 +#define MEMPOOL_ELT_SIZE 2048 +#define MAX_KEEP 128 +#define MEMPOOL_SIZE 8192 + +static struct rte_mempool *mp; +static struct rte_mempool *ext_nocache, *ext_cache; + +static rte_atomic32_t synchro; + +/* + * For our tests, we use the following struct to pass info to our create + * callback so it can call rte_mempool_create + */ +struct custom_mempool_alloc_params { + char ring_name[RTE_RING_NAMESIZE]; + unsigned n_elt; + unsigned elt_size; +}; + +/* + * Simple example of custom mempool structure. Holds pointers to all the + * elements which are simply malloc'd in this example. + */ +struct custom_mempool { + struct rte_ring *r; /* Ring to manage elements */ + void *elements[MEMPOOL_SIZE]; /* Element pointers */ +}; + +/* + * save the object number in the first 4 bytes of object data. All + * other bytes are set to 0. + */ +static void +my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg, + void *obj, unsigned i) +{ + uint32_t *objnum = obj; + + memset(obj, 0, mp->elt_size); + *objnum = i; + printf("Setting objnum to %d\n", i); +} + +/* basic tests (done on one core) */ +static int +test_mempool_basic(void) +{ + uint32_t *objnum; + void **objtable; + void *obj, *obj2; + char *obj_data; + int ret = 0; + unsigned i, j; + + /* dump the mempool status */ + rte_mempool_dump(stdout, mp); + + printf("Count = %d\n", rte_mempool_count(mp)); + printf("get an object\n"); + if (rte_mempool_get(mp, &obj) < 0) { + printf("get Failed\n"); + return -1; + } + printf("Count = %d\n", rte_mempool_count(mp)); + rte_mempool_dump(stdout, mp); + + /* tests that improve coverage */ + printf("get object count\n"); + if (rte_mempool_count(mp) != MEMPOOL_SIZE - 1) + return -1; + + printf("get private data\n"); + if (rte_mempool_get_priv(mp) != + (char *) mp + MEMPOOL_HEADER_SIZE(mp, mp->pg_num)) + return -1; + + printf("get physical address of an object\n"); + if (MEMPOOL_IS_CONTIG(mp) && + rte_mempool_virt2phy(mp, obj) != + (phys_addr_t) (mp->phys_addr + + (phys_addr_t) ((char *) obj - (char *) mp))) + return -1; + + printf("put the object back\n"); + rte_mempool_put(mp, obj); + rte_mempool_dump(stdout, mp); + + printf("get 2 objects\n"); + if (rte_mempool_get(mp, &obj) < 0) + return -1; + if (rte_mempool_get(mp, &obj2) < 0) { + rte_mempool_put(mp, obj); + return -1; + } + rte_mempool_dump(stdout, mp); + + printf("put the objects back\n"); + rte_mempool_put(mp, obj); + rte_mempool_put(mp, obj2); + rte_mempool_dump(stdout, mp); + + /* + * get many objects: we cannot get them all because the cache + * on other cores may not be empty. + */ + objtable = malloc(MEMPOOL_SIZE * sizeof(void *)); + if (objtable == NULL) + return -1; + + for (i = 0; i < MEMPOOL_SIZE; i++) { + if (rte_mempool_get(mp, &objtable[i]) < 0) + break; + } + + /* + * for each object, check that its content was not modified, + * and put objects back in pool + */ + while (i--) { + obj = objtable[i]; + obj_data = obj; + objnum = obj; + if (*objnum > MEMPOOL_SIZE) { + printf("bad object number(%d)\n", *objnum); + ret = -1; + break; + } + for (j = sizeof(*objnum); j < mp->elt_size; j++) { + if (obj_data[j] != 0) + ret = -1; + } + + rte_mempool_put(mp, objtable[i]); + } + + free(objtable); + if (ret == -1) + printf("objects were modified!\n"); + + return ret; +} + +static int test_mempool_creation_with_exceeded_cache_size(void) +{ + struct rte_mempool *mp_cov; + + mp_cov = rte_mempool_create("test_mempool_creation_exceeded_cache_size", + MEMPOOL_SIZE, + MEMPOOL_ELT_SIZE, + RTE_MEMPOOL_CACHE_MAX_SIZE + 32, + 0, + NULL, NULL, + my_obj_init, NULL, + SOCKET_ID_ANY, 0); + if (NULL != mp_cov) + return -1; + + return 0; +} + +/* + * it tests some more basic of mempool + */ +static int +test_mempool_basic_ex(struct rte_mempool *mp) +{ + unsigned i; + void **obj; + void *err_obj; + int ret = -1; + + if (mp == NULL) + return ret; + + obj = rte_calloc("test_mempool_basic_ex", + MEMPOOL_SIZE , sizeof(void *), 0); + if (obj == NULL) { + printf("test_mempool_basic_ex fail to rte_malloc\n"); + return ret; + } + printf("test_mempool_basic_ex now mempool (%s) has %u free entries\n", + mp->name, rte_mempool_free_count(mp)); + if (rte_mempool_full(mp) != 1) { + printf("test_mempool_basic_ex the mempool should be full\n"); + goto fail_mp_basic_ex; + } + + for (i = 0; i < MEMPOOL_SIZE; i++) { + if (rte_mempool_mc_get(mp, &obj[i]) < 0) { + printf("test_mp_basic_ex fail to get object for [%u]\n", + i); + goto fail_mp_basic_ex; + } + } + if (rte_mempool_mc_get(mp, &err_obj) == 0) { + printf("test_mempool_basic_ex get an impossible obj\n"); + goto fail_mp_basic_ex; + } + printf("number: %u\n", i); + if (rte_mempool_empty(mp) != 1) { + printf("test_mempool_basic_ex the mempool should be empty\n"); + goto fail_mp_basic_ex; + } + + for (i = 0; i < MEMPOOL_SIZE; i++) + rte_mempool_mp_put(mp, obj[i]); + + if (rte_mempool_full(mp) != 1) { + printf("test_mempool_basic_ex the mempool should be full\n"); + goto fail_mp_basic_ex; + } + + ret = 0; + +fail_mp_basic_ex: + if (obj != NULL) + rte_free((void *)obj); + + return ret; +} + +static int +test_mempool_same_name_twice_creation(void) +{ + struct rte_mempool *mp_tc; + + mp_tc = rte_mempool_create("test_mempool_same_name_twice_creation", + MEMPOOL_SIZE, + MEMPOOL_ELT_SIZE, 0, 0, + NULL, NULL, + NULL, NULL, + SOCKET_ID_ANY, 0); + if (NULL == mp_tc) + return -1; + + mp_tc = rte_mempool_create("test_mempool_same_name_twice_creation", + MEMPOOL_SIZE, + MEMPOOL_ELT_SIZE, 0, 0, + NULL, NULL, + NULL, NULL, + SOCKET_ID_ANY, 0); + if (NULL != mp_tc) + return -1; + + return 0; +} + +/* + * BAsic test for mempool_xmem functions. + */ +static int +test_mempool_xmem_misc(void) +{ + uint32_t elt_num, total_size; + size_t sz; + ssize_t usz; + + elt_num = MAX_KEEP; + total_size = rte_mempool_calc_obj_size(MEMPOOL_ELT_SIZE, 0, NULL); + sz = rte_mempool_xmem_size(elt_num, total_size, MEMPOOL_PG_SHIFT_MAX); + + usz = rte_mempool_xmem_usage(NULL, elt_num, total_size, 0, 1, + MEMPOOL_PG_SHIFT_MAX); + + if (sz != (size_t)usz) { + printf("failure @ %s: rte_mempool_xmem_usage(%u, %u) " + "returns: %#zx, while expected: %#zx;\n", + __func__, elt_num, total_size, sz, (size_t)usz); + return (-1); + } + + return 0; +} + + + +static int +test_ext_mempool(void) +{ + rte_atomic32_init(&synchro); + + /* create an external mempool (without cache) */ + if (ext_nocache == NULL) + ext_nocache = rte_mempool_create_ext( + "ext_nocache", /* Name */ + MEMPOOL_SIZE, /* Number of Elements */ + MEMPOOL_ELT_SIZE, /* Element size */ + 0, /* Cache Size */ + 0, /* Private Data size */ + NULL, NULL, NULL, NULL, + 0, /* socket_id */ + 0, /* flags */ + "custom_handler" + ); + if (ext_nocache == NULL) + return -1; + + /* create an external mempool (with cache) */ + if (ext_cache == NULL) + ext_cache = rte_mempool_create_ext( + "ext_cache", /* Name */ + MEMPOOL_SIZE, /* Number of Elements */ + MEMPOOL_ELT_SIZE, /* Element size */ + 16, /* Cache Size */ + 0, /* Private Data size */ + NULL, NULL, NULL, NULL, + 0, /* socket_id */ + 0, /* flags */ + "custom_handler" + ); + if (ext_cache == NULL) + return -1; + + if (rte_mempool_get_handler_name(ext_nocache)) { + printf("Handler name is \"%s\"\n", + rte_mempool_get_handler_name(ext_nocache)); + } else { + printf("Cannot lookup mempool handler name\n"); + return -1; + } + + if (rte_mempool_get_handler_name(ext_cache)) + printf("Handler name is \"%s\"\n", + rte_mempool_get_handler_name(ext_cache)); + else { + printf("Cannot lookup mempool handler name\n"); + return -1; + } + + /* retrieve the mempool from its name */ + if (rte_mempool_lookup("ext_nocache") != ext_nocache) { + printf("Cannot lookup mempool from its name\n"); + return -1; + } + /* retrieve the mempool from its name */ + if (rte_mempool_lookup("ext_cache") != ext_cache) { + printf("Cannot lookup mempool from its name\n"); + return -1; + } + + rte_mempool_list_dump(stdout); + + printf("Running basic tests\n"); + /* basic tests without cache */ + mp = ext_nocache; + if (test_mempool_basic() < 0) + return -1; + + /* basic tests with cache */ + mp = ext_cache; + if (test_mempool_basic() < 0) + return -1; + + /* more basic tests without cache */ + if (test_mempool_basic_ex(ext_nocache) < 0) + return -1; + + if (test_mempool_creation_with_exceeded_cache_size() < 0) + return -1; + + if (test_mempool_same_name_twice_creation() < 0) + return -1; + return 0; + + if (test_mempool_xmem_misc() < 0) + return -1; + + rte_mempool_list_dump(stdout); + + return 0; +} + +static struct test_command mempool_cmd = { + .command = "ext_mempool_autotest", + .callback = test_ext_mempool, +}; +REGISTER_TEST_COMMAND(mempool_cmd); -- 2.5.0