From patchwork Wed Oct 5 03:38:39 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117346 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id B45F8A0542; Wed, 5 Oct 2022 05:39:05 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E555C42670; Wed, 5 Oct 2022 05:39:00 +0200 (CEST) Received: from out203-205-221-235.mail.qq.com (out203-205-221-235.mail.qq.com [203.205.221.235]) by mails.dpdk.org (Postfix) with ESMTP id 46CE840041 for ; Wed, 5 Oct 2022 05:38:57 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941135; bh=kufC0W6a+WsfiQHlRf1PNDEhWzmcZjrhRL9NkE+WX7o=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=BDccHanrlKJV7YyjeJpeUaGbrCOOkOHZ1fLWYwe3nnbUtxT5sE6mc9t2LSvk2Mtyn j0iD5hZhuxD0e5yRF1Sp0vxUROfLmjL1odF4VMf1aO/Ro3kZSHJWbzpONlagL7Nbl1 lxOPTZGlshZNiuxZy37WUHebivKKFcq7WSIoGA3s= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941134t0cr62avw Message-ID: X-QQ-XMAILINFO: MyirvGjpKb1jyyEQN/v5M7dyM+qzuxxjmjDT9qcdNqg8DC3GkBAVXAGTQ0tMIe 4EkP+OpnRDWnMqn1qQANKcsRQzr8XcBcDqJqyvkEIVBFjbTnsKgZ00IFOj+2eUZDWsXCkU+4XICq cy+ZwZwy9hA/yX3bXQEV3gqk0AH0Znb2vyVvWxkstMqxOZrQCtDLaV9PlXmK7fqTDDMiFAZqSS1r tXoL7Ji/gOIGlAlzgz45oXMQccE+mlkN5BBLVxiKDIUU+CAoYPIwGGRj/9REIixH/i/Nmhb93MZy R8STqW4pxIr7V7qALpOUopIe0ydbLPKwKI70QInqSIkROSWmWzI7uBCbigzmWUV2xsNPDEzJzdkn 19HDFABRMXekSl1/NytHvxffbsLVcJa1QItBGxT5050zl1OZoBbPNERsEnydvV8bAJF1g4115lUK oD/chou2AMqVbiZtwGodaw01d066xYgVMCuJtTXtx/NAs9KoZRaSUi/Q/YIWxG27l7S4Tp5P6XdY Mrc4i3nlBLenst0pl5TsWjsscvvbKIhb0rypqSNu06erKPpq8wOEBHO93iiBUnuRm7UlDhCoGVd1 qzeptwV9CPZ0EG4stQoxzWV67/pqTilYJ2+fzLKfs5JHxA64vgwTRn2dfpN1uNPNob0fRJE6XmL6 imUK/gcJ2EA3HmraMp0sf81WBrfyy48EArVKl6y3TEdaiYE8vJOrjsyrFngKT/jToJHypzv2tUe2 jrxkhCy2mvFDQO2Hk662NI4Xf8TryXQQ7aZHCMQVcA61l2feHVZndMCZW/IAsScwqSIJgD2iy/NB V9c3IQ7pC50AgJMBOa648VMnu5foa61sEAAiXwy543WXIxtd1vMj8vz2jMVliBae4ZcZ3U9bDM95 /tkSTACELvWhiOJoPpGzxSchXB+Njtmt9MDzDZ4NklkR+zSBDMCSTHf7eTeuLe2tzPQCPkOkrNLG /DlfczObfb+2zX2yEzYU8/d15e65PJd4agQYMHXvM= From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 01/10] memarea: introduce memarea library Date: Wed, 5 Oct 2022 11:38:39 +0800 X-OQ-MSGID: <20221005033848.2241-2-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng The memarea library is an allocator of variable-size object which based on a memory region. This patch provides create/destroy API. Signed-off-by: Chengwen Feng --- MAINTAINERS | 5 + doc/api/doxy-api-index.md | 3 +- doc/api/doxy-api.conf.in | 1 + doc/guides/prog_guide/index.rst | 1 + doc/guides/prog_guide/memarea_lib.rst | 39 ++++++ doc/guides/rel_notes/release_22_11.rst | 6 + lib/eal/common/eal_common_log.c | 1 + lib/eal/include/rte_log.h | 1 + lib/memarea/memarea_private.h | 30 +++++ lib/memarea/meson.build | 16 +++ lib/memarea/rte_memarea.c | 157 +++++++++++++++++++++++++ lib/memarea/rte_memarea.h | 145 +++++++++++++++++++++++ lib/memarea/version.map | 12 ++ lib/meson.build | 1 + 14 files changed, 417 insertions(+), 1 deletion(-) create mode 100644 doc/guides/prog_guide/memarea_lib.rst create mode 100644 lib/memarea/memarea_private.h create mode 100644 lib/memarea/meson.build create mode 100644 lib/memarea/rte_memarea.c create mode 100644 lib/memarea/rte_memarea.h create mode 100644 lib/memarea/version.map diff --git a/MAINTAINERS b/MAINTAINERS index a55b379d73..b9c638221d 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1550,6 +1550,11 @@ F: app/test/test_lpm* F: app/test/test_func_reentrancy.c F: app/test/test_xmmt_ops.h +Memarea - EXPERIMENTAL +M: Chengwen Feng +F: lib/memarea +F: doc/guides/prog_guide/memarea_lib.rst + Membership - EXPERIMENTAL M: Yipeng Wang M: Sameh Gobriel diff --git a/doc/api/doxy-api-index.md b/doc/api/doxy-api-index.md index de488c7abf..24456604f8 100644 --- a/doc/api/doxy-api-index.md +++ b/doc/api/doxy-api-index.md @@ -62,7 +62,8 @@ The public API headers are grouped by topics: [memzone](@ref rte_memzone.h), [mempool](@ref rte_mempool.h), [malloc](@ref rte_malloc.h), - [memcpy](@ref rte_memcpy.h) + [memcpy](@ref rte_memcpy.h), + [memarea](@ref rte_memarea.h) - **timers**: [cycles](@ref rte_cycles.h), diff --git a/doc/api/doxy-api.conf.in b/doc/api/doxy-api.conf.in index f0886c3bd1..8334ebcbd6 100644 --- a/doc/api/doxy-api.conf.in +++ b/doc/api/doxy-api.conf.in @@ -53,6 +53,7 @@ INPUT = @TOPDIR@/doc/api/doxy-api-index.md \ @TOPDIR@/lib/latencystats \ @TOPDIR@/lib/lpm \ @TOPDIR@/lib/mbuf \ + @TOPDIR@/lib/memarea \ @TOPDIR@/lib/member \ @TOPDIR@/lib/mempool \ @TOPDIR@/lib/meter \ diff --git a/doc/guides/prog_guide/index.rst b/doc/guides/prog_guide/index.rst index 8564883018..e9015d65e3 100644 --- a/doc/guides/prog_guide/index.rst +++ b/doc/guides/prog_guide/index.rst @@ -37,6 +37,7 @@ Programmer's Guide hash_lib toeplitz_hash_lib efd_lib + memarea_lib member_lib lpm_lib lpm6_lib diff --git a/doc/guides/prog_guide/memarea_lib.rst b/doc/guides/prog_guide/memarea_lib.rst new file mode 100644 index 0000000000..b96dad15f6 --- /dev/null +++ b/doc/guides/prog_guide/memarea_lib.rst @@ -0,0 +1,39 @@ +.. SPDX-License-Identifier: BSD-3-Clause + Copyright(c) 2022 HiSilicon Limited + +Memarea Library +=============== + +Introduction +------------ + +The memarea library provides an allocator of variable-size objects, it is +oriented towards the application layer, which could provides 'region-based +memory management' function [1]. + +The main features are as follows: + +* The default aligement size is ``RTE_CACHE_LINE_SIZE``. + +* The memory region can be initialized from the following memory sources: + a) RTE memory: e.g. invoke ``rte_malloc_socket`` to obtain. b) System API: + e.g. invoke posix_memalign to obtain. c) User provided address: it can be from + extendedd memory as long as it is available. d) User provided memarea: it can + be from another memarea. + +* It provides refcnt feature which could be useful in multi-reader scenario. + +* It supports MT-safe as long as it's specified at creation time. + +Library API Overview +-------------------- + +The ``rte_memarea_create()`` function is used to create a memarea, the function +returns the pointer to the created memarea or ``NULL`` if the creation failed. + +The ``rte_memarea_destroy()`` function is used to destroy a memarea. + +Reference +--------- + +[1] https://en.wikipedia.org/wiki/Region-based_memory_management diff --git a/doc/guides/rel_notes/release_22_11.rst b/doc/guides/rel_notes/release_22_11.rst index 5d8ef669b8..4c1f760b98 100644 --- a/doc/guides/rel_notes/release_22_11.rst +++ b/doc/guides/rel_notes/release_22_11.rst @@ -55,6 +55,12 @@ New Features Also, make sure to start the actual text at the margin. ======================================================= +* **Added memarea library.** + + The memarea library is an allocator of variable-size objects, it is oriented + towards the application layer, which could provides 'region-based memory + management' function. + * **Added configuration for asynchronous flow connection tracking.** Added connection tracking action number hint to ``rte_flow_configure`` diff --git a/lib/eal/common/eal_common_log.c b/lib/eal/common/eal_common_log.c index bd7b188ceb..3d62af59c6 100644 --- a/lib/eal/common/eal_common_log.c +++ b/lib/eal/common/eal_common_log.c @@ -369,6 +369,7 @@ static const struct logtype logtype_strings[] = { {RTE_LOGTYPE_EFD, "lib.efd"}, {RTE_LOGTYPE_EVENTDEV, "lib.eventdev"}, {RTE_LOGTYPE_GSO, "lib.gso"}, + {RTE_LOGTYPE_MEMAREA, "lib.memarea"}, {RTE_LOGTYPE_USER1, "user1"}, {RTE_LOGTYPE_USER2, "user2"}, {RTE_LOGTYPE_USER3, "user3"}, diff --git a/lib/eal/include/rte_log.h b/lib/eal/include/rte_log.h index 25ce42cdfc..708f3a39dd 100644 --- a/lib/eal/include/rte_log.h +++ b/lib/eal/include/rte_log.h @@ -48,6 +48,7 @@ extern "C" { #define RTE_LOGTYPE_EFD 18 /**< Log related to EFD. */ #define RTE_LOGTYPE_EVENTDEV 19 /**< Log related to eventdev. */ #define RTE_LOGTYPE_GSO 20 /**< Log related to GSO. */ +#define RTE_LOGTYPE_MEMAREA 21 /**< Log related to memarea. */ /* these log types can be used in an application */ #define RTE_LOGTYPE_USER1 24 /**< User-defined log type 1. */ diff --git a/lib/memarea/memarea_private.h b/lib/memarea/memarea_private.h new file mode 100644 index 0000000000..c76392d3e6 --- /dev/null +++ b/lib/memarea/memarea_private.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2022 HiSilicon Limited + */ + +#ifndef MEMAREA_PRIVATE_H +#define MEMAREA_PRIVATE_H + +#include + +#define MEMAREA_FREE_ELEM_COOKIE 0xFFFFFFFF + +struct memarea_elem { + size_t size; + uint32_t cookie; + int32_t refcnt; /* Non-zero indicates that it has been allocated */ + TAILQ_ENTRY(memarea_elem) elem_node; + TAILQ_ENTRY(memarea_elem) free_node; +} __rte_cache_aligned; + +TAILQ_HEAD(memarea_elem_list, memarea_elem); + +struct rte_memarea { + struct rte_memarea_param init; + rte_spinlock_t lock; + void *area_addr; + struct memarea_elem_list elem_list; + struct memarea_elem_list free_list; +} __rte_cache_aligned; + +#endif /* MEMAREA_PRIVATE_H */ diff --git a/lib/memarea/meson.build b/lib/memarea/meson.build new file mode 100644 index 0000000000..0a74fb4cd1 --- /dev/null +++ b/lib/memarea/meson.build @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2022 HiSilicon Limited + +if is_windows + build = false + reason = 'not supported on Windows' + subdir_done() +endif + +sources = files( + 'rte_memarea.c', +) +headers = files( + 'rte_memarea.h', +) +deps += [] diff --git a/lib/memarea/rte_memarea.c b/lib/memarea/rte_memarea.c new file mode 100644 index 0000000000..868da7661d --- /dev/null +++ b/lib/memarea/rte_memarea.c @@ -0,0 +1,157 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2022 HiSilicon Limited + */ + +#include +#include + +#include +#include +#include +#include + +#include "rte_memarea.h" +#include "memarea_private.h" + +static int +memarea_check_param(const struct rte_memarea_param *init) +{ + size_t len; + + if (init == NULL) { + RTE_LOG(ERR, MEMAREA, "memarea init param is NULL!\n"); + return -EINVAL; + } + + len = strnlen(init->name, RTE_MEMAREA_NAMESIZE); + if (len == 0 || len >= RTE_MEMAREA_NAMESIZE) { + RTE_LOG(ERR, MEMAREA, "memarea name size %zu invalid!\n", len); + return -EINVAL; + } + + if (init->source != RTE_MEMAREA_SOURCE_RTE_MEMORY && + init->source != RTE_MEMAREA_SOURCE_SYSTEM_API && + init->source != RTE_MEMAREA_SOURCE_USER_ADDR && + init->source != RTE_MEMAREA_SOURCE_USER_MEMAREA) { + RTE_LOG(ERR, MEMAREA, "memarea: %s source: %d not supported!\n", + init->name, init->source); + return -EINVAL; + } + + if (init->total_sz <= sizeof(struct memarea_elem)) { + RTE_LOG(ERR, MEMAREA, "memarea: %s total-size: %zu too small!\n", + init->name, init->total_sz); + return -EINVAL; + } + + if (init->source == RTE_MEMAREA_SOURCE_USER_ADDR && init->user_addr == NULL) { + RTE_LOG(ERR, MEMAREA, "memarea: %s user provided addr is NULL!\n", init->name); + return -EINVAL; + } + + if (init->source == RTE_MEMAREA_SOURCE_USER_ADDR && + ((uintptr_t)init->user_addr & (RTE_CACHE_LINE_SIZE - 1))) { + RTE_LOG(ERR, MEMAREA, "memarea: %s user provided addr should align: %d!\n", + init->name, RTE_CACHE_LINE_SIZE); + return -EINVAL; + } + + if (init->source == RTE_MEMAREA_SOURCE_USER_MEMAREA && init->user_memarea == NULL) { + RTE_LOG(ERR, MEMAREA, "memarea: %s user provided memarea is NULL!\n", init->name); + return -EINVAL; + } + + if (init->alg != RTE_MEMAREA_ALG_DEFAULT) { + RTE_LOG(ERR, MEMAREA, "memarea: %s alg: %d not supported!\n", + init->name, init->alg); + return -EINVAL; + } + + return 0; +} + +static void * +memarea_alloc_from_system_api(size_t size) +{ + void *ptr = NULL; + int ret; + + ret = posix_memalign(&ptr, RTE_CACHE_LINE_SIZE, size); + if (ret) + return NULL; + return ptr; +} + +static void * +memarea_alloc_area(const struct rte_memarea_param *init) +{ + void *ptr = NULL; + + if (init->source == RTE_MEMAREA_SOURCE_RTE_MEMORY) + ptr = rte_malloc_socket(NULL, init->total_sz, RTE_CACHE_LINE_SIZE, + init->numa_socket); + else if (init->source == RTE_MEMAREA_SOURCE_SYSTEM_API) + ptr = memarea_alloc_from_system_api(init->total_sz); + else if (init->source == RTE_MEMAREA_SOURCE_USER_ADDR) + ptr = init->user_addr; + + if (ptr == NULL) + RTE_LOG(ERR, MEMAREA, "memarea: %s alloc memory area fail!\n", init->name); + + return ptr; +} + +struct rte_memarea * +rte_memarea_create(const struct rte_memarea_param *init) +{ + struct memarea_elem *elem; + struct rte_memarea *ma; + void *addr; + int ret; + + ret = memarea_check_param(init); + if (ret) + return NULL; + + addr = memarea_alloc_area(init); + if (addr == NULL) + return NULL; + + ma = rte_zmalloc(NULL, sizeof(struct rte_memarea), RTE_CACHE_LINE_SIZE); + if (ma == NULL) { + RTE_LOG(ERR, MEMAREA, "malloc memarea: %s management obj fail!\n", init->name); + return NULL; + } + + ma->init = *init; + rte_spinlock_init(&ma->lock); + TAILQ_INIT(&ma->elem_list); + TAILQ_INIT(&ma->free_list); + ma->area_addr = addr; + elem = addr; + elem->size = init->total_sz - sizeof(struct memarea_elem); + elem->cookie = MEMAREA_FREE_ELEM_COOKIE; + elem->refcnt = 0; + TAILQ_INSERT_TAIL(&ma->elem_list, elem, elem_node); + TAILQ_INSERT_TAIL(&ma->free_list, elem, free_node); + + return ma; +} + +static void +memarea_free_area(struct rte_memarea *ma) +{ + if (ma->init.source == RTE_MEMAREA_SOURCE_RTE_MEMORY) + rte_free(ma->area_addr); + else if (ma->init.source == RTE_MEMAREA_SOURCE_SYSTEM_API) + free(ma->area_addr); +} + +void +rte_memarea_destroy(struct rte_memarea *ma) +{ + if (ma == NULL) + return; + memarea_free_area(ma); + rte_free(ma); +} diff --git a/lib/memarea/rte_memarea.h b/lib/memarea/rte_memarea.h new file mode 100644 index 0000000000..543cda4cac --- /dev/null +++ b/lib/memarea/rte_memarea.h @@ -0,0 +1,145 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2022 HiSilicon Limited + */ + +#ifndef RTE_MEMAREA_H +#define RTE_MEMAREA_H + +/** + * @file + * RTE Memarea. + * + * The memarea is an allocator of variable-size object which based on a memory + * region. It has the following features: + * + * - The default alignment size is RTE_CACHE_LINE_SIZE. + * - The memory region can be initialized from the following memory sources: + * 1. RTE memory: e.g. invoke rte_malloc_socket to obtain. + * 2. System API: e.g. invoke posix_memalign to obtain. + * 3. User provided address: it can be from extended memory as long as it is + * available. The address must be aligned to RTE_CACHE_LINE_SIZE. + * 4) User provided memarea: it can be from another memarea. So we can build + * the following memory management structure: + * \code{.unparsed} + * ------------- + * | memarea-1 | + * ------------- + * | + * v + * ------------------------------- + * | | | + * v v v + * ------------- ------------- ---------- + * | memarea-2 | | memarea-3 | | object | + * ------------- ------------- ---------- + * \endcode + * As shown above, the memarea-2/3 both create from memarea-1's memory. + * - It provides refcnt feature which could be useful in multi-reader scenario. + * - It supports MT-safe as long as it's specified at creation time. If not + * specified, all the functions of the memarea API are lock-free, and assume + * to not be invoked in parallel on different logical cores to work on the + * same memarea. + */ + +#include +#include +#include + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define RTE_MEMAREA_NAMESIZE 64 + +/** + * Memarea memory source. + */ +enum rte_memarea_source { + /** Memory source comes from rte memory. */ + RTE_MEMAREA_SOURCE_RTE_MEMORY, + /** Memory source comes from system API. */ + RTE_MEMAREA_SOURCE_SYSTEM_API, + /** Memory source comes from user-provided address. */ + RTE_MEMAREA_SOURCE_USER_ADDR, + /** Memory source comes from user-provided memarea. */ + RTE_MEMAREA_SOURCE_USER_MEMAREA, +}; + +/** + * Memarea memory management algorithm. + */ +enum rte_memarea_alg { + /* The default management algorithm is a variant of the next fit + * algorithm. It uses a free-list to apply for memory and uses an + * element-list in ascending order of address to support merging + * upon free. + */ + RTE_MEMAREA_ALG_DEFAULT, +}; + +struct rte_memarea; + +struct rte_memarea_param { + char name[RTE_MEMAREA_NAMESIZE]; /**< Name of memarea. */ + enum rte_memarea_source source; /**< Memory source of memarea. */ + enum rte_memarea_alg alg; /**< Memory management algorithm. */ + size_t total_sz; /**< total size (bytes) of memarea. */ + /** Indicates whether the memarea API should be MT-safe. */ + uint32_t mt_safe : 1; + union { + /** Numa socket from which to apply for memarea's memory, this + * field is valid only when the source is set to be + * RTE_MEMAREA_SOURCE_RTE_MEMORY. + */ + int numa_socket; + /** User provided address, this field is valid only when the + * source is set to be RTE_MEMAREA_SOURCE_USER_ADDR. + * Note: the provided address must align at least + * RTE_CACHE_LINE_SIZE. + */ + void *user_addr; + /** User provided memarea, this field is valid only when the + * source is set to be RTE_MEMAREA_SOURCE_USER_MEMAREA. + */ + struct rte_memarea *user_memarea; + }; +}; + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Create memarea. + * + * Create one new memarea. + * + * @param init + * The init parameter of memarea. + * + * @return + * Non-NULL on success. Otherwise NULL is returned. + */ +__rte_experimental +struct rte_memarea *rte_memarea_create(const struct rte_memarea_param *init); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Destroy memarea. + * + * Destroy the memarea. + * + * @param ma + * The pointer of memarea. + */ +__rte_experimental +void rte_memarea_destroy(struct rte_memarea *ma); + +#ifdef __cplusplus +} +#endif + +#endif /* RTE_MEMAREA_H */ diff --git a/lib/memarea/version.map b/lib/memarea/version.map new file mode 100644 index 0000000000..f36a04d7cf --- /dev/null +++ b/lib/memarea/version.map @@ -0,0 +1,12 @@ +EXPERIMENTAL { + global: + + rte_memarea_create; + rte_memarea_destroy; + + local: *; +}; + +INTERNAL { + local: *; +}; diff --git a/lib/meson.build b/lib/meson.build index c648f7d800..521a25d6c0 100644 --- a/lib/meson.build +++ b/lib/meson.build @@ -42,6 +42,7 @@ libraries = [ 'kni', 'latencystats', 'lpm', + 'memarea', 'member', 'pcapng', 'power', From patchwork Wed Oct 5 03:38:40 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117347 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 75750A0542; Wed, 5 Oct 2022 05:39:12 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id D1493427F4; Wed, 5 Oct 2022 05:39:01 +0200 (CEST) Received: from out162-62-58-216.mail.qq.com (out162-62-58-216.mail.qq.com [162.62.58.216]) by mails.dpdk.org (Postfix) with ESMTP id 9996C40694 for ; Wed, 5 Oct 2022 05:38:58 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941137; bh=rG2ZkGplRcelW1XLl2pfPrMLzFQd6n7/OgK5xTE5jeg=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=K3I+Id3yV50+6Bt6P+5TyRt1TVfz5S3qZ2M7WJoo+xmB5JE7S/fJptl5irFx2fVep xJMsGZEor1aIzN/aE5w17jDRvfWa781RGLsvCKdOBDAcozxzUKQNtwoMa9XzLKrYvT eO+3DUuBJZM7UFYZ2k4HSl/WmsnkhpCvAd4nyJkU= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941135tfdeaywvc Message-ID: X-QQ-XMAILINFO: OKKHiI6c9SH3x1lldSLzqkeIiPzkBwDMaLks8i5fPQEWC60fH1ZlUyc7daSNiq JIyhmwYaOynL2zFHwAL+xV8ybes2R+MpeXz1m5sNDDWPVKpxUyr+R7wcpbpe94tLxd/FCKbAU+Fh Powcgr6UoOB8sg9CoEnT6Xjk3Sm55c72bxYVe05cSQSgSFT+u35nxedH89+6s4t3/wXNDHFz4ywu g3lFi7Emx3ZkMp28lknqB0qTj9EYpbtKRZFnrYo4ROjXTlMaoCBe+F50OKyI6IqWt3eJNIw1DQFd f1gOwFh/tJhWN2d4Pufnx8xeEk57mdG9B2uY1W83pRn8X+Gx6QYmYRIl9ebhWz82BAKymgcjzUGQ WaotXfsL+FDZxAKJZSsVa1dRKMo3mRlesqr6W2BME0oILoZBx14JSLf3ia2/t6L8hMuQoQ/S3ifI fcNi4xigb2sYR79PHT8l48zwNUt62QPUzfREBTF4a3jO/KelMlYdVC2yi5JNFb84sn2yvBHhzxdp gPWHJDaQmSTvaeWaAcNwLmLa2WjEwUYdngQHCaCIwzPcYTtXt9I+0hH6h2trV6nxEHNIl6AGhci/ kKgAsAfNLF8bayY1jwM6GuTHSHI8h4goW5I75zxN9lHstMtrDmCEKgpJD9izs2nXxSPnpAuZzpnR +PyvH2ezRuN6vVYgIrDV1cCXZbh8hT629O2qXDLe/vdoxJwgwYlFvBINIt+t8djGyA+TnWsFo8EM Gh6NG5N0DVT+/XSG4CGP3pO2QBAXmUlFM4YFQSHD1AVR4kusERxXw+nGA6obLtFXpi6UtiIojYMb 3BYeEN+pSlWEMF6PWsuUC59bS2e1owoByQGhnYjGzyzQput9WUEoajS7iFL31fzOpkW9Wy30H6/g 9lgz2lzqLsGsxi3Hji+Rne6uY+ICR6sdvmKIED8ORubL7ZPq0jXy+4ZaDJEfuNIEQyWBSAGcu+SG ouEJTxugOTi/8bKlR+bTakVCa4OZFQ3QesIe9jQ03DgxhYTIYU3w== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 02/10] test/memarea: support memarea test Date: Wed, 5 Oct 2022 11:38:40 +0800 X-OQ-MSGID: <20221005033848.2241-3-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports memarea test about API rte_memarea_create and rte_memarea_destroy. Signed-off-by: Chengwen Feng --- MAINTAINERS | 1 + app/test/meson.build | 2 + app/test/test_memarea.c | 149 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 152 insertions(+) create mode 100644 app/test/test_memarea.c diff --git a/MAINTAINERS b/MAINTAINERS index b9c638221d..bfdb36f1b5 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1554,6 +1554,7 @@ Memarea - EXPERIMENTAL M: Chengwen Feng F: lib/memarea F: doc/guides/prog_guide/memarea_lib.rst +F: app/test/test_memarea* Membership - EXPERIMENTAL M: Yipeng Wang diff --git a/app/test/meson.build b/app/test/meson.build index d5cad72116..778de8d65d 100644 --- a/app/test/meson.build +++ b/app/test/meson.build @@ -84,6 +84,7 @@ test_sources = files( 'test_malloc.c', 'test_malloc_perf.c', 'test_mbuf.c', + 'test_memarea.c', 'test_member.c', 'test_member_perf.c', 'test_memcpy.c', @@ -199,6 +200,7 @@ fast_tests = [ ['malloc_autotest', false, true], ['mbuf_autotest', false, true], ['mcslock_autotest', false, true], + ['memarea_autotest', true, true], ['memcpy_autotest', true, true], ['memory_autotest', false, true], ['mempool_autotest', false, true], diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c new file mode 100644 index 0000000000..7c3d78652d --- /dev/null +++ b/app/test/test_memarea.c @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2022 HiSilicon Limited + */ + +#include +#include + +#include "test.h" + +#ifdef RTE_EXEC_ENV_WINDOWS +static int +test_memarea(void) +{ + printf("memarea not supported on Windows, skipping test\n"); + return TEST_SKIPPED; +} + +#else + +#include +#include + +#define MEMAREA_TEST_DEFAULT_SIZE 0x1000 + +#define MEMAREA_TEST_API_RUN(test_func) \ + do { \ + int ret = test_func(); \ + if (ret < 0) \ + printf("%s Failed\n", #test_func); \ + else \ + printf("%s Passed\n", #test_func); \ + } while (0) + +static void +test_memarea_init_def_param(struct rte_memarea_param *init) +{ + memset(init, 0, sizeof(struct rte_memarea_param)); + sprintf(init->name, "%s", "test-memarea"); + init->source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init->total_sz = MEMAREA_TEST_DEFAULT_SIZE; + init->mt_safe = 1; +} + +static int +test_memarea_create_bad_param(void) +{ + struct rte_memarea_param init; + struct rte_memarea *ma; + int i; + + /* test for NULL */ + ma = rte_memarea_create(NULL); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for invalid name */ + memset(&init, 0, sizeof(init)); + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + memset(&init.name, 1, sizeof(init.name)); + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for invalid source */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_MEMAREA + 1; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for total_sz */ + test_memarea_init_def_param(&init); + init.total_sz = 0; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for user address NULL */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_ADDR; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for user address align invalid */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_ADDR; + for (i = 1; i < RTE_CACHE_LINE_SIZE; i++) { + init.user_addr = (void *)((uintptr_t)i); + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + } + + /* test for user memarea NULL */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_MEMAREA; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + /* test for alg invalid */ + test_memarea_init_def_param(&init); + init.alg = RTE_MEMAREA_ALG_DEFAULT + 1; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma == NULL, "Expected NULL"); + + return 0; +} + +static int +test_memarea_create_destroy(void) +{ + uint8_t user_buffer[MEMAREA_TEST_DEFAULT_SIZE + RTE_CACHE_LINE_SIZE]; + struct rte_memarea_param init; + struct rte_memarea *ma; + + /* test for create with RTE memory */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_RTE_MEMORY; + init.numa_socket = SOCKET_ID_ANY; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + rte_memarea_destroy(ma); + + /* test for create with system API */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + rte_memarea_destroy(ma); + + /* test for create with user-address */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_ADDR; + init.user_addr = (void *)(((uintptr_t)user_buffer + RTE_CACHE_LINE_SIZE) & + ~(RTE_CACHE_LINE_SIZE - 1)); + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + rte_memarea_destroy(ma); + + return 0; +} + +static int +test_memarea(void) +{ + MEMAREA_TEST_API_RUN(test_memarea_create_bad_param); + MEMAREA_TEST_API_RUN(test_memarea_create_destroy); + return 0; +} + +#endif /* !RTE_EXEC_ENV_WINDOWS */ + +REGISTER_TEST_COMMAND(memarea_autotest, test_memarea); From patchwork Wed Oct 5 03:38:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117348 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 345CDA0542; Wed, 5 Oct 2022 05:39:20 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 4A43842847; Wed, 5 Oct 2022 05:39:03 +0200 (CEST) Received: from out162-62-58-216.mail.qq.com (out162-62-58-216.mail.qq.com [162.62.58.216]) by mails.dpdk.org (Postfix) with ESMTP id 5BB5740E2D for ; Wed, 5 Oct 2022 05:39:00 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941138; bh=DdRGpalXyqJMKR1ZJLktWKDOrCto9PDN6Wh9r6EUgag=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=im68fMNpLcPaqfZxzQu0N01BPnM4wxVBRqxEFjhm3Fofkwa+vlPz90CzGSjCaS0dB 6VDCf7ddOSLb+mNM1MYGzF+B7XIP3/i7Y9ggZno5/TSad25oSfoODDOowfTtVwyY2Y /FNzvzU6klwNExJcrr+QsVueTkzVV2UQG/0LPGek= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941137te1sr2fce Message-ID: X-QQ-XMAILINFO: Mdc3TkmnJyI/VCmsU84x0LiVo/SSh1zC7h+doiBjUx4pU/pjbTK/KkTy1is1oX TQzw75l6iTZDA+seGU4q9GMzUZ9igLn+nwS7suU6SbOM+I+ffZdad5lcmVUbYCxfEE4evk3sMcpE Sd5WrgN+pBZE6gP8mLLOQB5QhjJVPf/8QkW7yovsIJ9pIggxpNSKdBZeREyklY2DHARLNd0n0K+x JC7jI9dNPoSlxHpn7f77xSPjeAtkeGD6Aq8scRyt5w/10BPxGPthGV8U4Dm79/X+oGNBjIFTQ3kl SOKHTkgwZ6tnp5PVAm2vK+eTco4olkLBckxmmRdHb4S5z5MjvTYEMNaC08q9Qe0/HYp8ya6PZ+IV 8+E8KhzyjjNwUYO5n7k4MJxrzGKzKPeqhwL5Akh4oNz6u8cY2LFjWSeFzdiqS/V22TwX0PsWvDg9 j3CC3+G6Y1XRUjQVdN5DMYcuNxxy/GfNmVt5PzbGQ/lQ0zuQ1HBaUjvwa9o3f+P/Rzjv1n5cnUhM 0cXn8aey3vp47y46MRGUp5l6ZNDd7F1KWxXbcS6+leCY05SIrU66BrQWZ64LP2DztAIvgq6/C/5C NaOkoOztMU7edGOR9Cit4TChwj1hSF+oWkHXVbHDvil2urLS0d+dLCrTi9pFzWBt5lEbTdKuuIHk pRbDLyPF6QLf+aickcg69bm144UtvionaDJQ6k2R8lu86wSi41RHH2jy7U0iKNGgN7+SjjahMdOC b9buXmGXp5hSfM+d5QO+952pdI/LnbTB6mvmTGCMgHGcUMz+TWEvVoI207rlsSuBqazk49p7gpWT G64B85dX8h+4nI95EGfcNyOkpohNck85gHCKnjpAI3LCbwQ1YgvoNOljZGTgQLli4OGsHkDcKNfo xdghN7k0J0ATpF/r0oOFNEEF6fhWeqdlxU6SCZS/27RTOGXSXvGEM3CzyypZakJaLBvRKBFA4STo rTju94CLWMqadcQcR0yw== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 03/10] memarea: support alloc/free/update-refcnt API Date: Wed, 5 Oct 2022 11:38:41 +0800 X-OQ-MSGID: <20221005033848.2241-4-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports rte_memarea_alloc()/rte_memarea_free()/ rte_memarea_update_refcnt() API. Signed-off-by: Chengwen Feng --- doc/guides/prog_guide/memarea_lib.rst | 10 ++ lib/memarea/memarea_private.h | 3 + lib/memarea/rte_memarea.c | 143 ++++++++++++++++++++++++++ lib/memarea/rte_memarea.h | 56 ++++++++++ lib/memarea/version.map | 3 + 5 files changed, 215 insertions(+) diff --git a/doc/guides/prog_guide/memarea_lib.rst b/doc/guides/prog_guide/memarea_lib.rst index b96dad15f6..41bc0a90cd 100644 --- a/doc/guides/prog_guide/memarea_lib.rst +++ b/doc/guides/prog_guide/memarea_lib.rst @@ -33,6 +33,16 @@ returns the pointer to the created memarea or ``NULL`` if the creation failed. The ``rte_memarea_destroy()`` function is used to destroy a memarea. +The ``rte_memarea_alloc()`` function is used to alloc one memory object from +the memarea. + +The ``rte_memarea_free()`` function is used to free one memory object which +allocated by ``rte_memarea_alloc()``. + +The ``rte_memarea_update_refcnt()`` function is used to update the memory +object's reference count, if the count reaches zero, the memory object will +be freed to memarea. + Reference --------- diff --git a/lib/memarea/memarea_private.h b/lib/memarea/memarea_private.h index c76392d3e6..98406879b9 100644 --- a/lib/memarea/memarea_private.h +++ b/lib/memarea/memarea_private.h @@ -25,6 +25,9 @@ struct rte_memarea { void *area_addr; struct memarea_elem_list elem_list; struct memarea_elem_list free_list; + + uint64_t alloc_fails; + uint64_t refcnt_check_fails; } __rte_cache_aligned; #endif /* MEMAREA_PRIVATE_H */ diff --git a/lib/memarea/rte_memarea.c b/lib/memarea/rte_memarea.c index 868da7661d..a072f07f20 100644 --- a/lib/memarea/rte_memarea.c +++ b/lib/memarea/rte_memarea.c @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -94,6 +95,8 @@ memarea_alloc_area(const struct rte_memarea_param *init) ptr = memarea_alloc_from_system_api(init->total_sz); else if (init->source == RTE_MEMAREA_SOURCE_USER_ADDR) ptr = init->user_addr; + else if (init->source == RTE_MEMAREA_SOURCE_USER_MEMAREA) + ptr = rte_memarea_alloc(init->user_memarea, init->total_sz, 0); if (ptr == NULL) RTE_LOG(ERR, MEMAREA, "memarea: %s alloc memory area fail!\n", init->name); @@ -145,6 +148,8 @@ memarea_free_area(struct rte_memarea *ma) rte_free(ma->area_addr); else if (ma->init.source == RTE_MEMAREA_SOURCE_SYSTEM_API) free(ma->area_addr); + else if (ma->init.source == RTE_MEMAREA_SOURCE_USER_MEMAREA) + rte_memarea_free(ma->init.user_memarea, ma->area_addr); } void @@ -155,3 +160,141 @@ rte_memarea_destroy(struct rte_memarea *ma) memarea_free_area(ma); rte_free(ma); } + +static inline void +memarea_lock(struct rte_memarea *ma) +{ + if (ma->init.mt_safe) + rte_spinlock_lock(&ma->lock); +} + +static inline void +memarea_unlock(struct rte_memarea *ma) +{ + if (ma->init.mt_safe) + rte_spinlock_unlock(&ma->lock); +} + +#define memarea_roundup(val, align) ((((val) + ((align) - 1)) / (align)) * (align)) + +static inline bool +memarea_whether_add_node(size_t free_size, size_t need_size) +{ + size_t align_size = memarea_roundup(need_size, RTE_CACHE_LINE_SIZE); + return free_size > align_size && (free_size - align_size) > sizeof(struct memarea_elem); +} + +static inline void +memarea_add_node(struct rte_memarea *ma, struct memarea_elem *elem, size_t need_size) +{ + size_t align_size = memarea_roundup(need_size, RTE_CACHE_LINE_SIZE); + struct memarea_elem *new_elem; + new_elem = (struct memarea_elem *)((uintptr_t)elem + sizeof(struct memarea_elem) + + align_size); + new_elem->size = elem->size - align_size - sizeof(struct memarea_elem); + new_elem->cookie = MEMAREA_FREE_ELEM_COOKIE; + new_elem->refcnt = 0; + TAILQ_INSERT_AFTER(&ma->elem_list, elem, new_elem, elem_node); + TAILQ_INSERT_AFTER(&ma->free_list, elem, new_elem, free_node); + elem->size = align_size; +} + +void * +rte_memarea_alloc(struct rte_memarea *ma, size_t size, uint32_t cookie) +{ + struct memarea_elem *elem; + void *ptr = NULL; + + if (unlikely(ma == NULL || size == 0)) + return NULL; + + memarea_lock(ma); + TAILQ_FOREACH(elem, &ma->free_list, free_node) { + if (elem->size < size) + continue; + if (memarea_whether_add_node(elem->size, size)) + memarea_add_node(ma, elem, size); + elem->cookie = cookie; + elem->refcnt = 1; + TAILQ_REMOVE(&ma->free_list, elem, free_node); + ptr = (void *)((uintptr_t)elem + sizeof(struct memarea_elem)); + break; + } + if (unlikely(ptr == NULL)) + ma->alloc_fails++; + memarea_unlock(ma); + + return ptr; +} + +void +rte_memarea_free(struct rte_memarea *ma, void *ptr) +{ + rte_memarea_update_refcnt(ma, ptr, -1); +} + +static inline void +memarea_merge_node(struct rte_memarea *ma, struct memarea_elem *curr, + struct memarea_elem *next, bool del_next_from_free, + bool add_curr_to_free) +{ + curr->size += next->size + sizeof(struct memarea_elem); + next->size = 0; + next->cookie = 0; + TAILQ_REMOVE(&ma->elem_list, next, elem_node); + if (del_next_from_free) + TAILQ_REMOVE(&ma->free_list, next, free_node); + if (add_curr_to_free) { + curr->cookie = MEMAREA_FREE_ELEM_COOKIE; + TAILQ_INSERT_TAIL(&ma->free_list, curr, free_node); + } +} + +static inline void +memarea_free_elem(struct rte_memarea *ma, struct memarea_elem *elem) +{ + struct memarea_elem *prev, *next; + bool merged = false; + prev = TAILQ_PREV(elem, memarea_elem_list, elem_node); + next = TAILQ_NEXT(elem, elem_node); + if (prev != NULL && prev->refcnt == 0) { + memarea_merge_node(ma, prev, elem, false, false); + elem = prev; + merged = true; + } + if (next != NULL && next->refcnt == 0) { + memarea_merge_node(ma, elem, next, true, !merged); + merged = true; + } + if (!merged) { + elem->cookie = MEMAREA_FREE_ELEM_COOKIE; + TAILQ_INSERT_TAIL(&ma->free_list, elem, free_node); + } +} + +void +rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value) +{ + struct memarea_elem *elem = (struct memarea_elem *)((uintptr_t)ptr - + sizeof(struct memarea_elem)); + + if (unlikely(ma == NULL || ptr == NULL)) + return; + + memarea_lock(ma); + if (unlikely(elem->refcnt <= 0 || elem->refcnt + value < 0)) { + RTE_LOG(ERR, MEMAREA, + "memarea: %s cookie: 0x%x curr refcnt: %d update refcnt: %d check fail!\n", + ma->init.name, elem->cookie, elem->refcnt, value); + ma->refcnt_check_fails++; + if (elem->refcnt > 0) + elem->refcnt += value; + memarea_unlock(ma); + return; + } + + elem->refcnt += value; + if (elem->refcnt == 0) + memarea_free_elem(ma, elem); + memarea_unlock(ma); +} diff --git a/lib/memarea/rte_memarea.h b/lib/memarea/rte_memarea.h index 543cda4cac..10e0d6ad5a 100644 --- a/lib/memarea/rte_memarea.h +++ b/lib/memarea/rte_memarea.h @@ -138,6 +138,62 @@ struct rte_memarea *rte_memarea_create(const struct rte_memarea_param *init); __rte_experimental void rte_memarea_destroy(struct rte_memarea *ma); +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Allocate memory from memarea. + * + * Allocate one memory object from the memarea. + * + * @param ma + * The pointer of memarea. + * @param size + * The memory size to be allocated. + * @param cookie + * User-provided footprint which could used to debug memory leak. + * + * @return + * Non-NULL on success. Otherwise NULL is returned. + */ +__rte_experimental +void *rte_memarea_alloc(struct rte_memarea *ma, size_t size, uint32_t cookie); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Free memory to memarea. + * + * Free one memory object to the memarea. + * + * @param ma + * The pointer of memarea. + * @param ptr + * The pointer of memory object which need be freed. + */ +__rte_experimental +void rte_memarea_free(struct rte_memarea *ma, void *ptr); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Update memory's refcnt. + * + * Update one memory object's refcnt. + * When refcnt is updated to be zero, the memory object is freed. + * + * @param ma + * The pointer of memarea. + * @param ptr + * The pointer of memory object which need be updated refcnt. + * @param value + * The value which need be updated. + */ +__rte_experimental +void rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value); + #ifdef __cplusplus } #endif diff --git a/lib/memarea/version.map b/lib/memarea/version.map index f36a04d7cf..a0026fc5f9 100644 --- a/lib/memarea/version.map +++ b/lib/memarea/version.map @@ -1,8 +1,11 @@ EXPERIMENTAL { global: + rte_memarea_alloc; rte_memarea_create; rte_memarea_destroy; + rte_memarea_free; + rte_memarea_update_refcnt; local: *; }; From patchwork Wed Oct 5 03:38:42 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117353 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 5860EA0542; Wed, 5 Oct 2022 05:39:50 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id AC99A42B82; Wed, 5 Oct 2022 05:39:12 +0200 (CEST) Received: from out162-62-57-49.mail.qq.com (out162-62-57-49.mail.qq.com [162.62.57.49]) by mails.dpdk.org (Postfix) with ESMTP id BDF2440A7D for ; Wed, 5 Oct 2022 05:39:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941140; bh=C8qTE6hkJgFvCGayb+54fGaSBAsMap4/fPWQb5SN1Qk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=CgLD/5JgFTr2k61HeygpUfLM2y2JCT0GBGn1ySR5M96D0T3g8piBbJoINrFvE9dYH 9QRU14TEmzszvhRpS2OfLa0X246v9vhufxo+14awVxPJKRCWoynX9bZ+LKcmxN4Ems /aVb4EhKl+X+oWIeSwc5I752NDkh667myKF0VBqM= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941138t50kguvza Message-ID: X-QQ-XMAILINFO: N7h1OCCDntujQdzF0ZavzbIJNEzzkLscRt1wO7jnT2aE+wZ36vJir2QW5LpLpA 7J7QlVQDrihdb93IPQf4W7TC1kI01eZxjbphvc6Nah1MCpYFb78W+wE6RnUQSD3KHpa2KD23euK/ A9KYSO/5qoQvPuklOmIjcQCXZvKfN/7HxVOvH08WuhXkMVux5K5tfigSGZZxdejseDEpPJ/+sftD upIqnP5ZM1bRExw610BpbWn5aFY3tfAB5ozFyz+17H/vMmR3HPP4oQbtAMR0RKMuCr/ZYBJ5PCIT 4mWCGTN9yU4y8HEBUaSirmJLxZjX/u37oSsQf1vASSZu9CbuW442DsXIzyAejQQxztDcbfnpnS5c vIuYoIoplnsIABNP6KMCgr7sZxivC/xxBkd3Zl3jUP317v5P7o9rJ+f3AHAtLEpLLQrlc/rnqYwQ pU+xhbZ9c259DivApTm0ayoYe8C0ZJFLylu9U7FfcrI1BkLL0Ji2/rXin2kn2QmXyvNA++5cPc0x Z237c4qO7Q1i8M4jITmoTmek9c8/z6lQFZDdMEiGFtOrr9iGGLV2fzNMe/L1RduxlTT72/AaZMA3 6uyB8ZGLmJz4MupNuF0dfMDyiHH7YtKZsC+rMWAjnyA8gCrVlZ83gV1783B3M8tfCKKlbbz2Ckuj hVNQCywXcGccFy4fNT9aqCuE63vXw6qbotNRDCWaH+IeInngSZ364qtVve+mbLjcSEkdoC2r1Sg9 1F7ZlmjJZ6MpgtD3f4aZQK+DJ3Rn/3UpCg3b6R+KUOU2X7Yy3/RIlRUXDUdhMBapK4gxfcIpZhjS mLSBZ0l+0/NiIfGfHaqykv3wzHGWaz63jqAq4jII8dsWRXpkzlAm5eTJ0JUZFtlswJ2hpbHX6bDd oaQ7/l6RPI+kCvmmBCEzAsciSKaAep/7F3t/MacowL1GDlvMjiMEZU2nUb3kiv3yiHJu0xPbA79s lc8coP+VEx8qUC1PlkQQ== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 04/10] test/memarea: support alloc/free/update-refcnt test Date: Wed, 5 Oct 2022 11:38:42 +0800 X-OQ-MSGID: <20221005033848.2241-5-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports rte_memarea_alloc()/rte_memarea_free()/ rte_memarea_update_refcnt() test. Signed-off-by: Chengwen Feng --- app/test/test_memarea.c | 150 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 149 insertions(+), 1 deletion(-) diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c index 7c3d78652d..0a54ede4c1 100644 --- a/app/test/test_memarea.c +++ b/app/test/test_memarea.c @@ -41,6 +41,12 @@ test_memarea_init_def_param(struct rte_memarea_param *init) init->mt_safe = 1; } +static void +test_memarea_fill_allocated_region(void *ptr, size_t size) +{ + memset(ptr, 0xff, size); +} + static int test_memarea_create_bad_param(void) { @@ -106,8 +112,8 @@ static int test_memarea_create_destroy(void) { uint8_t user_buffer[MEMAREA_TEST_DEFAULT_SIZE + RTE_CACHE_LINE_SIZE]; + struct rte_memarea *ma, *user_ma; struct rte_memarea_param init; - struct rte_memarea *ma; /* test for create with RTE memory */ test_memarea_init_def_param(&init); @@ -133,6 +139,145 @@ test_memarea_create_destroy(void) RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); rte_memarea_destroy(ma); + /* test for create with user-memarea */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + user_ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(user_ma != NULL, "Expected Non-NULL"); + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_USER_MEMAREA; + init.total_sz = init.total_sz >> 1; + init.user_memarea = user_ma; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + rte_memarea_destroy(ma); + rte_memarea_destroy(user_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_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + 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_allocated_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_allocated_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; + + /* prepare env */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init.total_sz = MEMAREA_TEST_DEFAULT_SIZE; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + + /* test invalid parameters with update-refcnt */ + rte_memarea_update_refcnt(NULL, (void *)(uintptr_t)1, 0); + rte_memarea_update_refcnt(ma, NULL, 0); + rte_memarea_update_refcnt(NULL, NULL, 0); + + /* test free with refcnt fail */ + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0); + RTE_TEST_ASSERT(ptr != NULL, "Expected Non-NULL"); + test_memarea_fill_allocated_region(ptr, MEMAREA_TEST_DEFAULT_SIZE >> 1); + rte_memarea_free(ma, ptr); + rte_memarea_free(ma, ptr); + + /* test update refcnt with fail */ + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0); + RTE_TEST_ASSERT(ptr != NULL, "Expected Non-NULL"); + test_memarea_fill_allocated_region(ptr, MEMAREA_TEST_DEFAULT_SIZE >> 1); + rte_memarea_update_refcnt(ma, ptr, -2); + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0); + RTE_TEST_ASSERT(ptr == NULL, "Expected NULL"); + + rte_memarea_destroy(ma); + + return 0; +} + +static int +test_memarea_alloc_free(void) +{ +#define ALLOC_MAX_NUM 8 + struct rte_memarea_param init; + struct rte_memarea *ma; + void *ptr[ALLOC_MAX_NUM]; + int i; + + /* prepare env */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + 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, ptr[6]); + + rte_memarea_destroy(ma); + return 0; } @@ -141,6 +286,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 0; } From patchwork Wed Oct 5 03:38:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117349 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 761F4A0542; Wed, 5 Oct 2022 05:39:25 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3785C42B6C; Wed, 5 Oct 2022 05:39:05 +0200 (CEST) Received: from out162-62-58-216.mail.qq.com (out162-62-58-216.mail.qq.com [162.62.58.216]) by mails.dpdk.org (Postfix) with ESMTP id 18F1C4282D for ; Wed, 5 Oct 2022 05:39:02 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941141; bh=z6PloYGYPgA27BvMg9YE4Jjc/waI/xX6qtuVqBf3C2c=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=i6Gc1KnloDmq3eK3+Usp2v5VAogzaH+6V/ns199dR3+bJCf4tNOB/+cUqx3nQ8u0r Q6eQgGDWtx9ZMjAMZHFJ5S5THVlYzKqtA6IYLvTvZn5qZC+LsqptkNb6VIYUSS4S57 QlmKzNVB7SEijEsrT+Yu/0Kk8ruF4xCWGhjX69Q0= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941140tyidr27qx Message-ID: X-QQ-XMAILINFO: NafziRg7Bx69FGYLHkoBI2vx1Unx7YWDMS8rBdC2dK2NMq/4sEUakyvDniVF1E 2zAH1N9wExrbTiRVIm6I3okx8RYMabw1BeaAmHttJRsJiqWkV6g08Ejoxx4zF5r9YRWyx+rxqpYj gD9R/3tMNOgrmJBcgTlky3z6pn3lofL49DU5PfCqwftxAHCmmh7IbyjKS0yZGufPYhl32HGfBz4X uPtmXruaJo8OzJR4Wj6niAU6/Rl/A4CIQzCBVnOut38MaKYpmGEpgC3JflrtPg+Ik/f7WLW5CJ6R NB9aSINVh1SUx0MuObwBEedXHdI4A6Q9YcSykLafY10mJpNVEgJ8hxvmf9csUddCkeXu1XhJW4ua ATfF7AP8m6DEW0FXwnfbFqvS/vByitTxSaeKOTvmHN+ZlU/KTtS+3uOTWWhf3NpEtIkjfZwALAeK HLhAjSjFpj2u1EwniaKNUOkvD7Ay8D4M5FC1UmiB2N8ycCsCX33GsTv2v4u+OZs9H2cQfwvJo/HH cYNhViExq712Q4iNRgR7FUcs+JCODP2rKgwcNQaJeSu6/ThnK9WA81wjjC6K5zIJ+pa0qoIRsKUD TD5nUPxfSD177M/mLeBqht5GTI0VyEReUTrJEc1zQP8VKF4ftI8ZwpNQFyxC8Tx1By/nZN3BTkuR CDKBbAP7BFwVKoIRAYA/1betip7S5EbDYRnW71cy3HmVONDG0RKWaS5Pm8TkNjUrXAW40htpzz5d VExW5fgZ7SysXUf0cu24uKYfthuAnyS+W1zYHEW1qieSI41YY5YodDT47chu0o36Psy97EiU2u5H ovo3cI1jPBGKDDEuLIEDdWOWu5haIZjkZFS7eyi6+XhUDcTT7DRqo32ZM9t+IwyMOK8/u1tT3A+I soJ8BhjkChLlKUoFRWdDlQhNhRiGWCYMdml7hXuIRrQHqPMwcjlsJ1QBHF1mN/GDf4+5Idh3wvU5 ORvDnTHm3KkfBfEhm2FHXFyZyfNFYPuBFTpQSQwC+RiDi6NPE7VQ== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 05/10] memarea: support dump API Date: Wed, 5 Oct 2022 11:38:43 +0800 X-OQ-MSGID: <20221005033848.2241-6-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports rte_memarea_dump() API which could be used for debug. Signed-off-by: Chengwen Feng --- doc/guides/prog_guide/memarea_lib.rst | 3 + lib/memarea/rte_memarea.c | 85 +++++++++++++++++++++++++++ lib/memarea/rte_memarea.h | 21 +++++++ lib/memarea/version.map | 1 + 4 files changed, 110 insertions(+) diff --git a/doc/guides/prog_guide/memarea_lib.rst b/doc/guides/prog_guide/memarea_lib.rst index 41bc0a90cd..c77012fe44 100644 --- a/doc/guides/prog_guide/memarea_lib.rst +++ b/doc/guides/prog_guide/memarea_lib.rst @@ -43,6 +43,9 @@ The ``rte_memarea_update_refcnt()`` function is used to update the memory object's reference count, if the count reaches zero, the memory object will be freed to memarea. ++The ``rte_memarea_dump()`` function is used to dump the internal information ++of a memarea. + Reference --------- diff --git a/lib/memarea/rte_memarea.c b/lib/memarea/rte_memarea.c index a072f07f20..b70830d0bb 100644 --- a/lib/memarea/rte_memarea.c +++ b/lib/memarea/rte_memarea.c @@ -2,6 +2,7 @@ * Copyright(c) 2022 HiSilicon Limited */ +#include #include #include #include @@ -298,3 +299,87 @@ rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value) memarea_free_elem(ma, elem); memarea_unlock(ma); } + +static const char * +memarea_source_name(enum rte_memarea_source source) +{ + if (source == RTE_MEMAREA_SOURCE_RTE_MEMORY) + return "rte-memory"; + else if (source == RTE_MEMAREA_SOURCE_SYSTEM_API) + return "system-api"; + else if (source == RTE_MEMAREA_SOURCE_USER_ADDR) + return "user-addr"; + else if (source == RTE_MEMAREA_SOURCE_USER_MEMAREA) + return "user-memarea"; + else + return "unknown"; +} + +static const char * +memarea_alg_name(enum rte_memarea_alg alg) +{ + if (alg == RTE_MEMAREA_ALG_DEFAULT) + return "default"; + else + return "unknown"; +} + +static uint32_t +memarea_elem_list_num(struct rte_memarea *ma) +{ + struct memarea_elem *elem; + uint32_t num = 0; + + TAILQ_FOREACH(elem, &ma->elem_list, elem_node) + num++; + + return num; +} + +static uint32_t +memarea_free_list_num(struct rte_memarea *ma) +{ + struct memarea_elem *elem; + uint32_t num = 0; + + TAILQ_FOREACH(elem, &ma->free_list, free_node) + num++; + + return num; +} + +static void +memarea_dump_all(struct rte_memarea *ma, FILE *f) +{ + struct memarea_elem *elem; + + fprintf(f, " regions:\n"); + TAILQ_FOREACH(elem, &ma->elem_list, elem_node) + fprintf(f, " size: 0x%zx cookie: 0x%x refcnt: %d\n", + elem->size, elem->cookie, elem->refcnt); +} + +int +rte_memarea_dump(struct rte_memarea *ma, FILE *f, bool dump_all) +{ + if (ma == NULL || f == NULL) + return -EINVAL; + + memarea_lock(ma); + fprintf(f, "memarea name: %s\n", ma->init.name); + fprintf(f, " source: %s\n", memarea_source_name(ma->init.source)); + if (ma->init.source == RTE_MEMAREA_SOURCE_USER_MEMAREA) + fprintf(f, " source-user-memarea: %s\n", ma->init.user_memarea->init.name); + fprintf(f, " algorithm: %s\n", memarea_alg_name(ma->init.alg)); + fprintf(f, " total-size: 0x%zx\n", ma->init.total_sz); + fprintf(f, " mt-safe: %s\n", ma->init.mt_safe ? "yes" : "no"); + fprintf(f, " total-regions: %u\n", memarea_elem_list_num(ma)); + fprintf(f, " total-free-regions: %u\n", memarea_free_list_num(ma)); + fprintf(f, " alloc_fails: %" PRIu64 "\n", ma->alloc_fails); + fprintf(f, " refcnt_check_fails: %" PRIu64 "\n", ma->refcnt_check_fails); + if (dump_all) + memarea_dump_all(ma, f); + memarea_unlock(ma); + + return 0; +} diff --git a/lib/memarea/rte_memarea.h b/lib/memarea/rte_memarea.h index 10e0d6ad5a..10b8229c64 100644 --- a/lib/memarea/rte_memarea.h +++ b/lib/memarea/rte_memarea.h @@ -194,6 +194,27 @@ void rte_memarea_free(struct rte_memarea *ma, void *ptr); __rte_experimental void rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value); +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Dump memarea. + * + * Dump one memarea. + * + * @param ma + * The pointer of memarea. + * @param f + * The file to write the output to. + * @param dump_all + * Indicate whether to dump the allocated and free memory objects information. + * + * @return + * 0 on success. Otherwise negative value is returned. + */ +__rte_experimental +int rte_memarea_dump(struct rte_memarea *ma, FILE *f, bool dump_all); + #ifdef __cplusplus } #endif diff --git a/lib/memarea/version.map b/lib/memarea/version.map index a0026fc5f9..d8ddd93c13 100644 --- a/lib/memarea/version.map +++ b/lib/memarea/version.map @@ -4,6 +4,7 @@ EXPERIMENTAL { rte_memarea_alloc; rte_memarea_create; rte_memarea_destroy; + rte_memarea_dump; rte_memarea_free; rte_memarea_update_refcnt; From patchwork Wed Oct 5 03:38:44 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117350 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 3AFABA0542; Wed, 5 Oct 2022 05:39:31 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 121784280E; Wed, 5 Oct 2022 05:39:07 +0200 (CEST) Received: from out203-205-221-221.mail.qq.com (out203-205-221-221.mail.qq.com [203.205.221.221]) by mails.dpdk.org (Postfix) with ESMTP id E5BED40E5A for ; Wed, 5 Oct 2022 05:39:04 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941143; bh=fW26njVAFz0rUDdqhVnQ5hkZXX9syUTvUSrqKiLbUi0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=iOVFsFd7sGXGyPpvxEFPHsdqEFTfdygQp8OuojLudRdXuoZYGMEVacprh0H/ak8BK /uHMWBSibGmoN2+gLNhqxdVn2eKbBoP1mrJuUz6cFwsb3ITk3zNEPkgFUN36cHkOpm f70LfGFVQaH7paWS8BqOCBNfOGpEou1g/wIzTkUg= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941141tph3762s1 Message-ID: X-QQ-XMAILINFO: N7h1OCCDntujQdzF0ZavzbI19vLiseaeeDZVqHxhYIOJPE9gh/PwKjjgezsnfW ADkOdIFwAwKv1WPBu2D36PugfJcxzpLvl+ADt3CCib27SZ53NKSZYAnDURkslQmbTBrSmNkEe2Wx ibKR/udYFj2h9rPY961RiRJ3NAEDgVKCoyD2jzaTaFMmj51SCeDYDNPi90WvL3+jBlRAF8694MSz NNQ1n28jQNkWje/5FEDMyIe2RfYtKQkUeoRlTIaumC0hmRit7O6ppekoUH/i3pmGfKfIK1JAMfZ0 YNcwPu8aqE9C6+bklm8g9/+wNK2JEpXTylEuREovdPkILieOH9kRrbMZgsDAX/e0vH1bx5BbXJSi op89g0gXYolxXLSGnIveiAFQ+eaKLVB2ROLqEYUnnBUBxA96PpVr6iVe4Renz4rqnlpfwvNEzjdj ZfSgLSO7NJKWFSoJTue9/OuS+nSVKjbjwZpLwze11SzLs4lKQ0SnXS0NTYqhM00z6C2o+XRgXFag RrvY1fx1HN7W3J7BkYzUzN4sKMM25lnSZsT2BKVSXXomIP7Y/Dxqa+NOmZ8OvAMy8Stgy4dAKJfw EMxUuQ43SnqwRyXyBJQhfP7DDFjqvrAUDCx1i/Cct4WILd9TPTM06cxQvSkdmpjNuh6oz2jxN/+b yddapnWpbeD+E/9D8UkVZVvZmkMbpecBy21QcfaMyukXAOnegJewyXbECDoPw+Ze3UQHlM3XCZlA nmPV0TFZEcEq7QAFMwTYt749pmg3bvd0378hUOUosbm4Ln/6yEa/JQrjPafEFeQBhPvJBIOiWopA 0RNgs0eOh3zxlTB0nBEwWo9pJNV9r2Qb6AUyhe9G8Vuz8iprcZADW79/beDw8L5Aqs2uHc7W58at r+agWYmUVtylA0tzRyKOqxSrNm1naimf+TZdd1jH0TY3CMVt7uCYmNsG8e5enPEWQd+Rk9uyGKIG LQMCmODMW2E8nNdEdskw== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 06/10] test/memarea: support dump test Date: Wed, 5 Oct 2022 11:38:44 +0800 X-OQ-MSGID: <20221005033848.2241-7-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports rte_memarea_dump() test. Signed-off-by: Chengwen Feng --- app/test/test_memarea.c | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c index 0a54ede4c1..ab360f0265 100644 --- a/app/test/test_memarea.c +++ b/app/test/test_memarea.c @@ -274,7 +274,39 @@ test_memarea_alloc_free(void) rte_memarea_free(ma, ptr[5]); /* test free NULL */ - rte_memarea_free(ma, ptr[6]); + rte_memarea_free(ma, NULL); + + rte_memarea_destroy(ma); + + return 0; +} + +static int +test_memarea_dump(void) +{ + struct rte_memarea_param init; + struct rte_memarea *ma; + int ret; + + /* prepare env */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init.total_sz = MEMAREA_TEST_DEFAULT_SIZE; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + + /* test for invalid parameters */ + ret = rte_memarea_dump(NULL, stderr, false); + RTE_TEST_ASSERT(ret == -EINVAL, "Expected EINVAL"); + ret = rte_memarea_dump(ma, NULL, false); + RTE_TEST_ASSERT(ret == -EINVAL, "Expected EINVAL"); + + /* test for dump */ + (void)rte_memarea_alloc(ma, 1, 0); + (void)rte_memarea_alloc(ma, 1, 0); + (void)rte_memarea_alloc(ma, 1, 0); + ret = rte_memarea_dump(ma, stderr, true); + RTE_TEST_ASSERT(ret == 0, "Expected ZERO"); rte_memarea_destroy(ma); @@ -289,6 +321,7 @@ test_memarea(void) MEMAREA_TEST_API_RUN(test_memarea_alloc_fail); MEMAREA_TEST_API_RUN(test_memarea_free_fail); MEMAREA_TEST_API_RUN(test_memarea_alloc_free); + MEMAREA_TEST_API_RUN(test_memarea_dump); return 0; } From patchwork Wed Oct 5 03:38:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117351 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id C5EAAA0542; Wed, 5 Oct 2022 05:39:38 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A2C5F42B7A; Wed, 5 Oct 2022 05:39:10 +0200 (CEST) Received: from out162-62-58-211.mail.qq.com (out162-62-58-211.mail.qq.com [162.62.58.211]) by mails.dpdk.org (Postfix) with ESMTP id ED41A40A7D for ; Wed, 5 Oct 2022 05:39:06 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941144; bh=LMmxCGlG6l0rZDAWe4UHhtK6mISXvZkGWi0AQ2eGU3U=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=OcJTYmOzrFz3dWiGBcagzyos5UUT4Gna6Jx5TuSpWJCmbLBQkIXmF/YpDhczXmtqh w8rM1OXORFGGyhb80jESv6pxxkJdHZoXpPuhUE4DY5dZVFQAeJotiPZftJWIYpFCol WaXL8QBLw9FcgT4r0qi5XDSjpqs0BnfLcKPrNB4o= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941143tbaqvahvr Message-ID: X-QQ-XMAILINFO: MBA0Q7b4Uo1hNHCO9UBWqB2oyxElrd/xviCxZ0t/9nniM87/xBy4WZBM8ppIH3 6rI2RjBcXBxmQ6Kb62nEisLkysmSBg23LnZbnhgBoTjkZ2nMAYKgCbGj4fUMzi2dISR0/+1CUXqP Cmt4N2EaMvW7k6TU+3HB1PB7ZBjyzf8V6EEDswQl+3EDyjfLo0F4X/H89DOfdPmztvwGsdDqYsiL cmYVqRE1BvWvL+vHv1+edbNxTNeEYntL2HFZ2RoaQxL7KMcJ19ue8PBlZ/dL9K2xAWZcEcyW14Ro Rd0tRACv1QVq5cdDuizGVXLVx5f29CJ4oHDvW5n4YOKKYerxd5hg/zLz6Ncb/hbRT9pkbDIVPBd+ eUw8JvF3A8xPS2Fu1ZLBlh42IaLZhfblSJdyC/2v4VjwmiK7WD1lEwfp30J13xbZMTfDwdPMHalI oQQKEtHexuWz5kjSUJMeAxpFq3KQE//yrT49LSHisF63uO/cvY6NVOtO6nZc2FGWAtY4peYVUwbL pHFkmqAek82QLurGhhhYFeHn9UoMyIB8OQeeNh3AZBqCiKwUUf5o26CVR4jqp7xzXphawXSsJCpl yPW065djggdQyzHY3lWYkaJpT0AIvCte9jnZ9blMv8H/0ZJMfka5J3rq/TGOFLXNDwPioszNexeD anifJnnq/KI5oUlqeiYGIWKLY1qxhKRNRbLm7uCHgnYzKbeYCqLn4l9g02ZcpdadCvZC+vU+6W84 uc7G5ESLdyGcChnZc0SVHk+TBQ+lZJIt2a3xUgUhlhn8KqWMVexixP2qZRwaF+SY65K09gh+a7CX sJj7xynGtrX12WOIje+WQSRpWUoPN4Okxd5WCTrBlJU+LCHE0Doc6xQ1yM12oyR+HAINhoRHX2zd Ch8Jrw7Fb1wz6vxhBK6SGg0zwOtqZRND8xsTMzplAajxyGOdvVzlSLKUQBx2IGnSLiNkZHnhtpnX kFXi+jR80fNI57QBMqdWmkTtnwqCW14Yy4mMaUf3KE7uvW8b7E8QnpsNeSQk5hNKUGJ6n2LjKx0r AI7DW2Yg== From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 07/10] memarea: support backup memory mechanism Date: Wed, 5 Oct 2022 11:38:45 +0800 X-OQ-MSGID: <20221005033848.2241-8-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports backup memory mechanism, the memarea could use another memarea as a backup. Signed-off-by: Chengwen Feng --- doc/guides/prog_guide/memarea_lib.rst | 3 +++ lib/memarea/memarea_private.h | 2 ++ lib/memarea/rte_memarea.c | 22 ++++++++++++++++++++++ lib/memarea/rte_memarea.h | 7 +++++++ 4 files changed, 34 insertions(+) diff --git a/doc/guides/prog_guide/memarea_lib.rst b/doc/guides/prog_guide/memarea_lib.rst index c77012fe44..842d35f77a 100644 --- a/doc/guides/prog_guide/memarea_lib.rst +++ b/doc/guides/prog_guide/memarea_lib.rst @@ -25,6 +25,9 @@ The main features are as follows: * It supports MT-safe as long as it's specified at creation time. +* It provides backup memory mechanism, the memarea could use another memarea + as a backup. + Library API Overview -------------------- diff --git a/lib/memarea/memarea_private.h b/lib/memarea/memarea_private.h index 98406879b9..08735ca81f 100644 --- a/lib/memarea/memarea_private.h +++ b/lib/memarea/memarea_private.h @@ -23,11 +23,13 @@ struct rte_memarea { struct rte_memarea_param init; rte_spinlock_t lock; void *area_addr; + void *top_addr; struct memarea_elem_list elem_list; struct memarea_elem_list free_list; uint64_t alloc_fails; uint64_t refcnt_check_fails; + uint64_t bak_alloc_fails; } __rte_cache_aligned; #endif /* MEMAREA_PRIVATE_H */ diff --git a/lib/memarea/rte_memarea.c b/lib/memarea/rte_memarea.c index b70830d0bb..f45191aa7f 100644 --- a/lib/memarea/rte_memarea.c +++ b/lib/memarea/rte_memarea.c @@ -132,6 +132,7 @@ rte_memarea_create(const struct rte_memarea_param *init) TAILQ_INIT(&ma->elem_list); TAILQ_INIT(&ma->free_list); ma->area_addr = addr; + ma->top_addr = (void *)((uintptr_t)addr + init->total_sz - 1); elem = addr; elem->size = init->total_sz - sizeof(struct memarea_elem); elem->cookie = MEMAREA_FREE_ELEM_COOKIE; @@ -200,6 +201,15 @@ memarea_add_node(struct rte_memarea *ma, struct memarea_elem *elem, size_t need_ elem->size = align_size; } +static inline void * +memarea_alloc_backup(struct rte_memarea *ma, size_t size, uint32_t cookie) +{ + void *ptr = rte_memarea_alloc(ma->init.bak_memarea, size, cookie); + if (unlikely(ptr == NULL)) + ma->bak_alloc_fails++; + return ptr; +} + void * rte_memarea_alloc(struct rte_memarea *ma, size_t size, uint32_t cookie) { @@ -221,6 +231,8 @@ rte_memarea_alloc(struct rte_memarea *ma, size_t size, uint32_t cookie) ptr = (void *)((uintptr_t)elem + sizeof(struct memarea_elem)); break; } + if (ptr == NULL && ma->init.bak_memarea != NULL) + ptr = memarea_alloc_backup(ma, size, cookie); if (unlikely(ptr == NULL)) ma->alloc_fails++; memarea_unlock(ma); @@ -283,6 +295,12 @@ rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value) return; memarea_lock(ma); + if (ptr < ma->area_addr || ptr > ma->top_addr) { + rte_memarea_update_refcnt(ma->init.bak_memarea, ptr, value); + memarea_unlock(ma); + return; + } + if (unlikely(elem->refcnt <= 0 || elem->refcnt + value < 0)) { RTE_LOG(ERR, MEMAREA, "memarea: %s cookie: 0x%x curr refcnt: %d update refcnt: %d check fail!\n", @@ -373,10 +391,14 @@ rte_memarea_dump(struct rte_memarea *ma, FILE *f, bool dump_all) fprintf(f, " algorithm: %s\n", memarea_alg_name(ma->init.alg)); fprintf(f, " total-size: 0x%zx\n", ma->init.total_sz); fprintf(f, " mt-safe: %s\n", ma->init.mt_safe ? "yes" : "no"); + if (ma->init.bak_memarea) + fprintf(f, " backup-memarea-name: %s\n", ma->init.bak_memarea->init.name); fprintf(f, " total-regions: %u\n", memarea_elem_list_num(ma)); fprintf(f, " total-free-regions: %u\n", memarea_free_list_num(ma)); fprintf(f, " alloc_fails: %" PRIu64 "\n", ma->alloc_fails); fprintf(f, " refcnt_check_fails: %" PRIu64 "\n", ma->refcnt_check_fails); + if (ma->init.bak_memarea) + fprintf(f, " backup_alloc_fails: %" PRIu64 "\n", ma->bak_alloc_fails); if (dump_all) memarea_dump_all(ma, f); memarea_unlock(ma); diff --git a/lib/memarea/rte_memarea.h b/lib/memarea/rte_memarea.h index 10b8229c64..348febab7f 100644 --- a/lib/memarea/rte_memarea.h +++ b/lib/memarea/rte_memarea.h @@ -39,6 +39,9 @@ * specified, all the functions of the memarea API are lock-free, and assume * to not be invoked in parallel on different logical cores to work on the * same memarea. + * - It provides backup memory mechanism, the memarea could use another memarea + * as a backup. It will attempts to allocate object from backup memarea when + * the current memarea failed to allocate. */ #include @@ -105,6 +108,10 @@ struct rte_memarea_param { */ struct rte_memarea *user_memarea; }; + /** Backup memarea, which is used to handle the scenario where the + * current memarea allocation failure. + */ + struct rte_memarea *bak_memarea; }; /** From patchwork Wed Oct 5 03:38:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117352 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 80DF6A0542; Wed, 5 Oct 2022 05:39:44 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A39FC42B71; Wed, 5 Oct 2022 05:39:11 +0200 (CEST) Received: from out162-62-58-216.mail.qq.com (out162-62-58-216.mail.qq.com [162.62.58.216]) by mails.dpdk.org (Postfix) with ESMTP id 42E9342B71 for ; Wed, 5 Oct 2022 05:39:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941146; bh=1K/8Rt7vdqUS1PyVSUzU7CnydL6bqe3VgI77Oh1k5Ec=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=w7AXvg3sk5JONLeDWI4S8Q45OQvcaDcmZkVHvaBKcbiZFD4u7xRYDU5xt6a3Viad2 5I6/AzuZ/YtBUqgzqBnfGRHWvvGhZjPiD0ZxQFL1M2mduCWXV4Fp6p56SXew9RFefN 8R5+JeGOmtK0lZyp9XhXqU3gDxXaprzLAM391UzE= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941144tavswky21 Message-ID: X-QQ-XMAILINFO: OZZSS56D9fAjnm+d5BBD381LObK556byYN4qdTU1Xd4DUSNAH0DEX3ulw6cVUE u7Xd58EdRXS5nt5aHUmV7lmiPjQO77JX3KoGRQuPeut6R0UMoCdjkeCpTiaDlBRx9w0kivD2hDxv ws7iC58vCkyrk2mdTVXkxav6AerPoR8sZih5OYWpC6gObwxZAwmrjyNj0vs7MZjXGKxQXGZJJpSH KCQGGkn7YWZEJ0n64hYXVm/5Nom2tkVYb7Bk/D9Jal4tZlpsrXH+uqe6LrpLNdFDZ0RtabRElo9Q gsNDXg30gFCSNRwIXFCSUfakk1+W0jHyVKeUZCUUOUaQX4VRkIjHE82ELDUFRkqvk9sAMqRrQnBU aKTpLDXR4csQ/bXB28nj5t7J/7TE9ql60S01NZR2xQe+ZzsyOCbqbLLtJIqHLdkASevsrgCD8bFk Af5QNOeW/mY+00Ob7rxuWkEwH1jeDi1ISu9NaQgmSbFNtpWRmQqNMGlvLFu1L+253QE6eEG7HXNI bGwN5AWDMEWscpekGanzU5B2BMLsitxR0NjP8vKOzbMWlNbWm3xBisEBLJybbdycJYQI58rka1h/ LdozID/CqcgTpKVTykDx3wkoeUDdveA7YVwOWrqDzEcb5QvBkGwx3vIGHVFud05TdMLCDOBdvGMX Cj04IyDpTtrWb6eZuBXbVZKPrs5XrDSoHGK8795BkkbBRpogcMjpfbMi9b5a7QglSLEItMR9uX9x p6hJqPsGS8GW18fBvK2PohWumyclr9qQA5OibcHMqYeLL7e7617GdGEy6iEuMPxqX9RfX7thTId8 DWDOabm365quE9mAtYI5SqXU37SgQYBBvgF9a9mFQgdEZ7F8zf6Ym5EaGOGWQepSZuJuYXmq4V1l swTlKwIgWkT5e0ss8eMsNTvE+7sq22KauXGx9syQqlxgB4FuKfHr2YyYIxtRcAalKdCvg7MRonYf 4A4q/6rd0RIti4Yl6L10DuJb1rwUfg From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 08/10] test/memarea: support backup memory test Date: Wed, 5 Oct 2022 11:38:46 +0800 X-OQ-MSGID: <20221005033848.2241-9-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch supports backup memory mechanism test. Signed-off-by: Chengwen Feng --- app/test/test_memarea.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c index ab360f0265..ec3475c354 100644 --- a/app/test/test_memarea.c +++ b/app/test/test_memarea.c @@ -313,6 +313,46 @@ test_memarea_dump(void) return 0; } +static int +test_memarea_backup(void) +{ + struct rte_memarea *ma, *bak_ma; + struct rte_memarea_param init; + void *ptr; + + /* prepare env */ + test_memarea_init_def_param(&init); + strcat(init.name, "_backup"); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init.total_sz = MEMAREA_TEST_DEFAULT_SIZE; + bak_ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(bak_ma != NULL, "Expected Non-NULL"); + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init.total_sz = MEMAREA_TEST_DEFAULT_SIZE >> 2; + init.bak_memarea = bak_ma; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + + /* test for backup */ + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 3, 0); + RTE_TEST_ASSERT(ptr != NULL, "Expected Non-NULL"); + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE >> 1, 0); + RTE_TEST_ASSERT(ptr != NULL, "Expected Non-NULL"); + (void)rte_memarea_dump(ma, stderr, true); + (void)rte_memarea_dump(bak_ma, stderr, true); + rte_memarea_free(ma, ptr); + ptr = rte_memarea_alloc(ma, MEMAREA_TEST_DEFAULT_SIZE, 0); + RTE_TEST_ASSERT(ptr == NULL, "Expected NULL"); + (void)rte_memarea_dump(ma, stderr, true); + (void)rte_memarea_dump(bak_ma, stderr, true); + + rte_memarea_destroy(ma); + rte_memarea_destroy(bak_ma); + + return 0; +} + static int test_memarea(void) { @@ -322,6 +362,7 @@ test_memarea(void) MEMAREA_TEST_API_RUN(test_memarea_free_fail); MEMAREA_TEST_API_RUN(test_memarea_alloc_free); MEMAREA_TEST_API_RUN(test_memarea_dump); + MEMAREA_TEST_API_RUN(test_memarea_backup); return 0; } From patchwork Wed Oct 5 03:38:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117354 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9D4F4A0542; Wed, 5 Oct 2022 05:39:55 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id ACBE042B87; Wed, 5 Oct 2022 05:39:13 +0200 (CEST) Received: from out162-62-58-216.mail.qq.com (out162-62-58-216.mail.qq.com [162.62.58.216]) by mails.dpdk.org (Postfix) with ESMTP id BD1E8410FB for ; Wed, 5 Oct 2022 05:39:08 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941147; bh=KcJjMSvQqPY8hUhtR/4N3rubGJAEXmWPx5/cvCjwI6Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=xVSUjAvfAOmfi9Jh3XhF6nFKvkkfQ6+PrEo6bMRAwFbG6jDo7qzGp7f/jkW6ygIaP oCEwV12FfA3WVspdiLOw9x0P1aGLfacGCdbU2prcZaDUivcdktp+EN8TZdu+oEF9eC N2nvbzFEyU1ze/MLUMS5WRdLokIWtVmfP0ePwspk= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941145tcmkg9a0q Message-ID: X-QQ-XMAILINFO: NkHKfw09D6j8JCbDIkJgXVV+J0vZXqAJwL5dsNiBDc43roCXGB8gFaB/3gX7HA jOGv90gHcbHrCFFN5dsrZsCdwxTmNL4x43nBp3Vo/lzzDZtrl2A5M7/KZniTldIM4QQHvWF2xr4o SULWccKPil4+YPVasgNxFklI6YaAtJ7a8zRRVdqf4oHLe8S5cslBOpGzDwZFZEVOPuJ9aZGze33p AKtVOqsO7TYZaZsMFPyzDsM99sgtphwnjS8J0Qo/qKzMDGn2q5j0n0iouotgxn4+bolnRSz42U55 7JL4+n9xBnknSg5EBGD4UBjHteNY98vN8N/yPmSCE3IE3wLsXRTtwsYSPYsfLNLuOTkP9LTQ3KGv URWQhqJXX7P32Y8ARRJdZJ9f4CZZTwOZifXE76hQC8G61KblVkavXCk4D2R46d9UtfOSfiB5P/SS cN0nFuEpS4JKZdxVHeXxJg9KMGJvw061hpZ6B16hRiQL/cwYutR9oWa8IXKEWM8QEJOHemz7iK/L Yb1Nrpi9sPW5aMTYZ7VNy0hRH+7elCl3ALFQIzFkU9Rbpik2uFaFkOj42Wy5L2dY+FEJeX9Pw5yh qTWIUA9AGyhWYEPhX+EQ8L8e370RcDHcCpT+BFnOeyFEdgIIVtwXIeSPgJRmUic1QsPml8me6sO7 GecciTOXLD39cYM27owESSntF9hP1UDiPQ/5WtXn4LTNqtawLSIprt74i9UmY5LGH+cuX1CQiEN2 haKxyedZ8EAZnISOZ3Up+hvRmIFr7Hj130MuumM7mzu49oJdSTiQ34XnZO6JzKbBwqDEOimF+KxI u1kFet0OmSSpQX3zEcvzVZMaZDoyqnHF7nxnECBXVVpqbj4KmoSdQBsdyKkM/Oo234A05IflQTCJ wPM2a5472oVv1lyvgXFGD52XuCn9wqvASAKWGEsr3jpISqFFpjRNEgEkaF7+CzV7CuV+tjYZfKfB qXS/ax2LKKxnzK3RIa5k8LRmHrJ9DcBkbBjkv1sQpEPtSIjx9eh3rcYSfno01f From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 09/10] memarea: detect memory corruption based on magic Date: Wed, 5 Oct 2022 11:38:47 +0800 X-OQ-MSGID: <20221005033848.2241-10-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng This patch provides lightweight mechanism for detecting memory corruption which based on magic field in each element node. Signed-off-by: Chengwen Feng --- lib/memarea/memarea_private.h | 2 ++ lib/memarea/rte_memarea.c | 29 ++++++++++++++++++++++++++--- 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/lib/memarea/memarea_private.h b/lib/memarea/memarea_private.h index 08735ca81f..4f5393e6f9 100644 --- a/lib/memarea/memarea_private.h +++ b/lib/memarea/memarea_private.h @@ -7,10 +7,12 @@ #include +#define MEMAREA_ELEM_MAGIC_NUM 0xbeef1234 #define MEMAREA_FREE_ELEM_COOKIE 0xFFFFFFFF struct memarea_elem { size_t size; + uint32_t magic; uint32_t cookie; int32_t refcnt; /* Non-zero indicates that it has been allocated */ TAILQ_ENTRY(memarea_elem) elem_node; diff --git a/lib/memarea/rte_memarea.c b/lib/memarea/rte_memarea.c index f45191aa7f..c81d4dd3fa 100644 --- a/lib/memarea/rte_memarea.c +++ b/lib/memarea/rte_memarea.c @@ -135,6 +135,7 @@ rte_memarea_create(const struct rte_memarea_param *init) ma->top_addr = (void *)((uintptr_t)addr + init->total_sz - 1); elem = addr; elem->size = init->total_sz - sizeof(struct memarea_elem); + elem->magic = MEMAREA_ELEM_MAGIC_NUM; elem->cookie = MEMAREA_FREE_ELEM_COOKIE; elem->refcnt = 0; TAILQ_INSERT_TAIL(&ma->elem_list, elem, elem_node); @@ -194,6 +195,7 @@ memarea_add_node(struct rte_memarea *ma, struct memarea_elem *elem, size_t need_ new_elem = (struct memarea_elem *)((uintptr_t)elem + sizeof(struct memarea_elem) + align_size); new_elem->size = elem->size - align_size - sizeof(struct memarea_elem); + new_elem->magic = MEMAREA_ELEM_MAGIC_NUM; new_elem->cookie = MEMAREA_FREE_ELEM_COOKIE; new_elem->refcnt = 0; TAILQ_INSERT_AFTER(&ma->elem_list, elem, new_elem, elem_node); @@ -221,6 +223,8 @@ rte_memarea_alloc(struct rte_memarea *ma, size_t size, uint32_t cookie) memarea_lock(ma); TAILQ_FOREACH(elem, &ma->free_list, free_node) { + if (unlikely(elem->magic != MEMAREA_ELEM_MAGIC_NUM)) + break; if (elem->size < size) continue; if (memarea_whether_add_node(elem->size, size)) @@ -253,6 +257,7 @@ memarea_merge_node(struct rte_memarea *ma, struct memarea_elem *curr, { curr->size += next->size + sizeof(struct memarea_elem); next->size = 0; + next->magic = ~MEMAREA_ELEM_MAGIC_NUM; next->cookie = 0; TAILQ_REMOVE(&ma->elem_list, next, elem_node); if (del_next_from_free) @@ -295,6 +300,13 @@ rte_memarea_update_refcnt(struct rte_memarea *ma, void *ptr, int16_t value) return; memarea_lock(ma); + if (unlikely(elem->magic != MEMAREA_ELEM_MAGIC_NUM)) { + RTE_LOG(ERR, MEMAREA, "memarea: %s magic: 0x%x check fail!\n", + ma->init.name, elem->magic); + memarea_unlock(ma); + return; + } + if (ptr < ma->area_addr || ptr > ma->top_addr) { rte_memarea_update_refcnt(ma->init.bak_memarea, ptr, value); memarea_unlock(ma); @@ -348,8 +360,11 @@ memarea_elem_list_num(struct rte_memarea *ma) struct memarea_elem *elem; uint32_t num = 0; - TAILQ_FOREACH(elem, &ma->elem_list, elem_node) + TAILQ_FOREACH(elem, &ma->elem_list, elem_node) { + if (elem->magic != MEMAREA_ELEM_MAGIC_NUM) + break; num++; + } return num; } @@ -360,8 +375,11 @@ memarea_free_list_num(struct rte_memarea *ma) struct memarea_elem *elem; uint32_t num = 0; - TAILQ_FOREACH(elem, &ma->free_list, free_node) + TAILQ_FOREACH(elem, &ma->free_list, free_node) { + if (elem->magic != MEMAREA_ELEM_MAGIC_NUM) + break; num++; + } return num; } @@ -372,9 +390,14 @@ memarea_dump_all(struct rte_memarea *ma, FILE *f) struct memarea_elem *elem; fprintf(f, " regions:\n"); - TAILQ_FOREACH(elem, &ma->elem_list, elem_node) + TAILQ_FOREACH(elem, &ma->elem_list, elem_node) { + if (elem->magic != MEMAREA_ELEM_MAGIC_NUM) { + fprintf(f, " magic: 0x%x chech fail!\n", elem->magic); + break; + } fprintf(f, " size: 0x%zx cookie: 0x%x refcnt: %d\n", elem->size, elem->cookie, elem->refcnt); + } } int From patchwork Wed Oct 5 03:38:48 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117355 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id AD3ADA0542; Wed, 5 Oct 2022 05:40:00 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id D343742B8B; Wed, 5 Oct 2022 05:39:14 +0200 (CEST) Received: from out203-205-221-245.mail.qq.com (out203-205-221-245.mail.qq.com [203.205.221.245]) by mails.dpdk.org (Postfix) with ESMTP id 8CAD042802 for ; Wed, 5 Oct 2022 05:39:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664941148; bh=tZHTTODRm39GZCm6CBMuq76QhV8hAhOyaUCTYIXz/c8=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=PVTidTOOWymLWvq9RUxD2W2dEFcgOP4Rirmcp5NLtQP5FeXGyLRIx7nJDqKHbLN5v wKfGuQNP9D+6JQpUUsHGq3dOs6BTlf/akXgb0VlrBxaTRoyxWgRxyWatkElq8t2u5a fIZce1vBsxUpQi5uIoeIn4/cAwLKxKStdBXl7JGg= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrszc13.qq.com (NewEsmtp) with SMTP id 9B40FA58; Wed, 05 Oct 2022 11:38:52 +0800 X-QQ-mid: xmsmtpt1664941147t4ql077a3 Message-ID: X-QQ-XMAILINFO: MyHh0PQai9Fpizo/+wK4OrZbcwLze3mMHLI1epS3chhxe5Ap3dVWLicezHuvB4 OOhqChEPnLdSW/F7qQRlstXQCoZn5AxOyV/CMU+Wf/XJrBKlevcownj0cGqQS24PG7M6FR/KPfzU oEKHE0+kt/dOylnAo5o/Ay/YtnG6rzs08YJwIOw6/ANURXZLZAllojxpSBFUr4zR50vOOeV22mmO iVQlkvXugFoZA6BJfmwLOOiHeFy4SCrGXqsmIaZUQaZglAJluVACJvD++SHAOUWcPkSNkxn1VVwl bRLL2U2Kha8NDdIGSXYsRkKK6lNeT6m8Q96AMPv8KKxn0DJGfbjaCr6YiziJNm1AnWvgA/JZ5Nok F2cduBtj4L24WtqbjoL0Yf6DSb0FmMjgvOwXhPD8673fE8p/DcAaViksFLrNyCmvyL8E6+zZmQHe FkHjko12gY68s7ZN+Of4lC3UrgRwU2EjEP0px6pH+Etq2aI2MqFFuUJM0xOrZ5dkuGi3dKReSPpF z/H2ALvLZL8vHMHbffOhf/lMLhV/CTK8h8pzMSKo8H5CrPoayTPTp8v7scRobN7O7b34qJpC6Aq7 YGZ/D3q+QDZGG0NN8mM1QXRbQjX04NQL/0z5RTx82XjfotUipAgZG4q4GQ/iTYn1bJb/nqzuRQyJ 8qHhivDo297kjvajdBt/lb+RGH+EJgoolc7fs0eC86Wxv8BYHLtHaelfXpiO+VKhav2bLs3uQUqF 09ChCgeabd0pPCZ57rMuzKI0E/TfZXrN3ZP3MU2q5l0OgLd51a1agxvtHmedQ+AixyCKpu7o2vus kXffPn4rImJtiH8h81RZaLR9o8OfTFKbaIVTgSW4ZFaynSuFJzUh+6FUtTAB6Tfg226xch139fFJ E49fWFslSvv4XENUyxVE5Jxi/HzdONuGHZXXb46Kupusx5fuTgETMI8H5cyqJnT8BxA+7bWW5yCo phG3xaurTejoG0wQieC5A8YDlz5+1FOkVroDo6tc53SiDAxyCxRR9Zji27r5Z+M6mCUQaAGsQ= From: datshan To: david.marchand@redhat.com, mb@smartsharesystems.com, anatoly.burakov@intel.com, dmitry.kozliuk@gmail.com, jerinjacobk@gmail.com Cc: thomas@monjalon.net, dev@dpdk.org, Chengwen Feng Subject: [PATCH v4 10/10] test/memarea: support no MT-safe test Date: Wed, 5 Oct 2022 11:38:48 +0800 X-OQ-MSGID: <20221005033848.2241-11-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005033848.2241-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005033848.2241-1-datshan@qq.com> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Chengwen Feng MT-safe is enabled by default in previous test, this patch adds no MT-safe test. Signed-off-by: Chengwen Feng --- app/test/test_memarea.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/app/test/test_memarea.c b/app/test/test_memarea.c index ec3475c354..b4012086fc 100644 --- a/app/test/test_memarea.c +++ b/app/test/test_memarea.c @@ -353,6 +353,35 @@ test_memarea_backup(void) return 0; } +static int +test_memarea_no_mt_safe(void) +{ + struct rte_memarea_param init; + struct rte_memarea *ma; + int ret; + + /* prepare env */ + test_memarea_init_def_param(&init); + init.source = RTE_MEMAREA_SOURCE_SYSTEM_API; + init.total_sz = MEMAREA_TEST_DEFAULT_SIZE; + init.mt_safe = false; + ma = rte_memarea_create(&init); + RTE_TEST_ASSERT(ma != NULL, "Expected Non-NULL"); + + /* test for all API */ + (void)rte_memarea_alloc(ma, 1, 0); + (void)rte_memarea_alloc(ma, 1, 0); + rte_memarea_free(ma, rte_memarea_alloc(ma, 1, 0)); + rte_memarea_update_refcnt(ma, rte_memarea_alloc(ma, 1, 0), 1); + rte_memarea_update_refcnt(ma, rte_memarea_alloc(ma, 1, 0), -1); + ret = rte_memarea_dump(ma, stderr, true); + RTE_TEST_ASSERT(ret == 0, "Expected ZERO"); + + rte_memarea_destroy(ma); + + return 0; +} + static int test_memarea(void) { @@ -363,6 +392,7 @@ test_memarea(void) MEMAREA_TEST_API_RUN(test_memarea_alloc_free); MEMAREA_TEST_API_RUN(test_memarea_dump); MEMAREA_TEST_API_RUN(test_memarea_backup); + MEMAREA_TEST_API_RUN(test_memarea_no_mt_safe); return 0; }