From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id 91AC3935A for ; Tue, 26 Jan 2016 18:26:11 +0100 (CET) Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by orsmga103.jf.intel.com with ESMTP; 26 Jan 2016 09:26:10 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.22,350,1449561600"; d="scan'208";a="36514385" Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga004.fm.intel.com with ESMTP; 26 Jan 2016 09:26:10 -0800 Received: from sivswdev02.ir.intel.com (sivswdev02.ir.intel.com [10.237.217.46]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id u0QHQ8BX007660; Tue, 26 Jan 2016 17:26:09 GMT Received: from sivswdev02.ir.intel.com (localhost [127.0.0.1]) by sivswdev02.ir.intel.com with ESMTP id u0QHQ80i001440; Tue, 26 Jan 2016 17:26:08 GMT Received: (from dhunt5@localhost) by sivswdev02.ir.intel.com with id u0QHQ8Ks001436; Tue, 26 Jan 2016 17:26:08 GMT From: David Hunt To: dev@dpdk.org Date: Tue, 26 Jan 2016 17:25:54 +0000 Message-Id: <1453829155-1366-5-git-send-email-david.hunt@intel.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1453829155-1366-1-git-send-email-david.hunt@intel.com> References: <1453829155-1366-1-git-send-email-david.hunt@intel.com> Subject: [dpdk-dev] [PATCH 4/5] mempool: add autotest for external mempool custom example X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 26 Jan 2016 17:26:12 -0000 Signed-off-by: David Hunt --- app/test/Makefile | 1 + app/test/test_ext_mempool.c | 474 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 475 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..b434f8b --- /dev/null +++ b/app/test/test_ext_mempool.c @@ -0,0 +1,474 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2016 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) +{ + int16_t handler_idx; + + rte_atomic32_init(&synchro); + + + handler_idx = rte_get_mempool_handler("ring_mp_mc"); + if (handler_idx < 0) { + printf("could not find ring_mp_mc mempool manager\n"); + return -1; + } + + handler_idx = rte_get_mempool_handler("ring_sp_sc"); + if (handler_idx < 0) { + printf("could not find ring_sp_sc mempool manager\n"); + return -1; + } + + handler_idx = rte_get_mempool_handler("ring_mp_sc"); + if (handler_idx < 0) { + printf("could not find ring_mp_sc mempool manager\n"); + return -1; + } + + handler_idx = rte_get_mempool_handler("ring_sp_mc"); + if (handler_idx < 0) { + printf("could not find ring_sp_mc mempool manager\n"); + return -1; + } + + handler_idx = rte_get_mempool_handler("stack"); + if (handler_idx < 0) { + printf("could not find stack mempool manager\n"); + return -1; + } + + handler_idx = rte_get_mempool_handler("custom_handler"); + if (handler_idx < 0) { + printf("could not find custom_handler mempool manager\n"); + return -1; + } + + /* 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; + + /* 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); -- 1.9.3