From patchwork Wed Oct 5 04:09:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117357 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 CCF1DA0542; Wed, 5 Oct 2022 06:10:06 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 837AE40E5A; Wed, 5 Oct 2022 06:10:01 +0200 (CEST) Received: from out203-205-221-233.mail.qq.com (out203-205-221-233.mail.qq.com [203.205.221.233]) by mails.dpdk.org (Postfix) with ESMTP id E0A9240694 for ; Wed, 5 Oct 2022 06:09:58 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664942997; bh=kufC0W6a+WsfiQHlRf1PNDEhWzmcZjrhRL9NkE+WX7o=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=gs3Dh65DkZMv9E23/b0H/KYJ/rPtVecjlaHGKrOcwqaB3yMYqAcgSbmQnAdnGNdNS KyqxK1T9/OSuhoi/UhmZGjcFWbSz7aiONx2lulpndRX+Nj7t8Ox1otFnAg2/Cz492S UqYlUXcM+othX/6ZGTNwRxbotk0KsNxMpJRHhL1Q= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664942995ta761kmvq Message-ID: X-QQ-XMAILINFO: OKKHiI6c9SH3x1lldSLzqkdwHFgwxerIsD1wlY69i9twTJd3rbwOaS8NDCyDJ4 4iNAKtnvy1v2+yamfQ3v2ssqzYmkZV7VKpcIn/Wmsa3TZSObtwJMBtAZx0DuXq16YpLfh3cZKYpm 5BPrMueESUOWQ1+xdv2aqqQAE61yFw/H4yba740gLHVJwLLX+jbrKu0pQYk+3jXE6ApKJQW3Em+0 P0jCGQs2nO/hrnQlHuMmZUkDfsYyo6IVD/Xc33RMkr1c2QXVE4qjjwMOhhpOxAwkOYDD/Bpc41yH q7tQqQvG/vwhK72kUoyf40qmFBam2efeKzsZnkKBFUGCjArF25sJLyDtsbKqCOkJIp0gz2Agj9Xo 8Ie2gD6+GgsWZMWel/iV/qU8rWyZtWdbidTcPJMOwEeV34PzMQo+eDzf2VSgueHHNlsWLNpNGDKS jEqaT1VaXX+LM0YvEQDmWme1QZj61DRtE6fRNpUEp0uKR1H2RlffX2H5AdRYOUfBmTWMBiLbgpeF 00+AkgTVMnngUdJES/WMbPURLcy9fOep/2Vxf3XMfACauEAUyEX/qByD+rqLe95KhvHU5xv89Wit f5LM8t8X6QpPk9XzanA41nIr3kU+LqmXPpOWOJqP5Eky9+D31in2fEpI/lpgSucfzIh5+BLgDQD9 Vn7zW+VQf3dQQzQPXdfUWcKrfKNpIYX/80Y4C+HxyshDd595AV3SgeQNVZpoHeqo9VTvCd9wbO/g MZi1Lhc2OmhQi7ijAmtmI5f1DH4YvcfLR2nBYpiS3D4oGz6TtUHQKPZwdjsCzTd3MJhXI6XVp8JO /8k1ZX6OSFSTjVZie+5RXLN3o/e/W2OIDGlBlgRhXu8ZQCfQ+9mtJkLq6ZgESSph5sgnooGv2Kad onovT2TI2WbQC3ka/y41g/Qg9wkRhZQ9DlysuraYCWRZ365EtGfG7UyWKLo+Hh1/+f6w0yVihxG0 8Pz/IfFy/vH24CYnylBMvPr601gR/TwxX36/wkBeFq6HnlEGED273WhboOjkFEJoqPJSkkLIP44G nhSQ7zNmKd3sbnx82mDJsWI5pYkJxyk50hN44I/A== 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 v5 01/10] memarea: introduce memarea library Date: Wed, 5 Oct 2022 12:09:43 +0800 X-OQ-MSGID: <20221005040952.8166-2-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:44 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117358 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 4212FA0542; Wed, 5 Oct 2022 06:10:13 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 55E08427EB; Wed, 5 Oct 2022 06:10:02 +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 03EEF40041 for ; Wed, 5 Oct 2022 06:09:59 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664942998; bh=rG2ZkGplRcelW1XLl2pfPrMLzFQd6n7/OgK5xTE5jeg=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=gjaghcm4cUkIkakCWVVcm8UtSCbC4ysBPUH6/lVt+Q9gSugBV4uKCeLJeFvtw/PfB n3NWSxw/QhWvCMv5QPKv5RI61320IWZ0roUQ4sXo4iJ6VT5ohJbyZzdM0c/7U6qsJ/ w/c6bxJ67O1+krvWUxYkKBDtNGG2Q/+SnjvLwXhc= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664942997t5p461miq Message-ID: X-QQ-XMAILINFO: Nkmip1FNTwAh2vQ3wRV0mnhEqwNYbzPx5G7LtHsOiavFMc81M0sm3DeKJGKxq7 DnCylKbKhClKzlwaXA4egJkAlTENxIVhQhCop50qoci4vWvuVaPWLUVV2b3GuvRTsMDwwaBoeHg0 e/xMgeG3n23x9fjf0fsUAcA9qXLOu9CzZf3N4BXjcsSDpDfVJFROE2UBrlHxG9s1V0vbQV6r+hz+ wYUPk16XFSnW6xMUe+ZC0+KtEczgccS13ALoJw0Hp+LLomg4oUGh+KCY3PFL5z5m6zjejufdPWje +C16zsgDOoRNtQdYRGUIuN3H2v00WWulIZEdaSBNt/ctfIvtqKc01aI7oQRmdTgCYhlV6LeloJ/S nc0DCIckBV7lt9Do4hGC0SyxT5PRp5CW7wpbsFEcbVT/IzxpkbQ0WrePhrD+VYNAnu2iMsWEk7wW pH7iWwX1BGm7RANk1r8k2/o+J+EV4YI/BOuCPIkTW9Oik7dYPHB7phHd+Mm2vFT3M7WNGm84TZBK gHvm8ZiXzxp9zfv7tJ3uTb4bq/lrQhj5GK64dmLXmazQ3AEpAGBMLGfqggknXh46nw88hulLonuh UCN8mTISNVYilzwCDIoxn9OWLlhEOUef5VcFOjThVpPBYJZUj0Z1mjkXpQQDbgHXn9kFnmhxzsqM DxWXSXWb+KDoxJsxXEB/RuSttQDkwzHhz5HKpSSseycbWK92ZWcRroVv3uYhnrOiPAXmC6FLinTM /b1DwV30y+iOsTNQhl7kQrkVq/Q6cn6zNTYWpKTt/LomSai2PYpu5Ur75EYpGY8kBlR2xEMfM9o5 FjOMpjVSaUcXbd8krSwk7MVllskOIY4FHhDmtRljCJ0tduICViRt9bbPjPRrPYiYm6v2Rz+ZHoaJ LNR8OLgPBrm1QaRhcxMAVZQMXAt4GgDWCC5CuG1cwStchOj4CDWgI4+DoeiY3wwQZ8zhk081tUTH dRjyhYLsITPl5Lh8hDK+dDbusqV3OUAC8DEJjPbn+ZrMVnLwd2++g1GCYV4h5j1blVpnNlXSzV0M AISwZPTP5pBprilCxS 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 v5 02/10] test/memarea: support memarea test Date: Wed, 5 Oct 2022 12:09:44 +0800 X-OQ-MSGID: <20221005040952.8166-3-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117359 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 D9369A0542; Wed, 5 Oct 2022 06:10:20 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C7B694282D; Wed, 5 Oct 2022 06:10:03 +0200 (CEST) Received: from out162-62-57-252.mail.qq.com (out162-62-57-252.mail.qq.com [162.62.57.252]) by mails.dpdk.org (Postfix) with ESMTP id 6389F427F0 for ; Wed, 5 Oct 2022 06:10:02 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664942999; bh=DdRGpalXyqJMKR1ZJLktWKDOrCto9PDN6Wh9r6EUgag=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=uyvRQP+O92UmBowTx7RBc5dgVI5yNyEY4sbziDq5lo+4sqVBgdMAVqE/kdPJMeGw3 Pvb1NtUaqg9NX3zD+d9JHMEnRTfsbVUmAAin1tf3vyf8ptznI4YXm2AablCdCYaUh7 XmE61nntUcDgwGLo/4jG+HzUj/t28c78/CWcbzg8= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664942998teyskeoxu Message-ID: X-QQ-XMAILINFO: NQR8mRxMnur9pa8q3vp7hxlD5EZ7DC0urGSExysa0sBQ6aYUAjMIeoiJw2ztBk 4NL9NXY51jkQJi+i4/z2ta8voqnT+MtHiFeFiEBCrTqCaj/TDHmhXwPu/V6rdsiht1hvqrlGUdF4 hCsaMgzCj9vOqc7FM5VUHOA2qnMosonr9fVg7Qt74Xz2MQ+kOxedVLZWAqCAcz48q/Ycw6A3cdr/ c8flKmG6yLc1ZWn2PS1k/sSIePSU6h5C0dG27DLUbB+F2WD9Z9S+RRDUuQLhYjn0mFb0V11HXYy9 z6HgCRY5V/kfPMKteFsB8n9wUYJ1zXVM/X/ciKTpoRC9HVMAO2C16zEq0m44PnFW5K3JAv5IzcWJ NwgaT0cNqGz/+5aaP58aN+6CxwJ7j/1eHxZRoqAgHDhT43J2JRJYv8EMEleMihrIBi4xuVR9IOLL awXOEtLKG9ABRVst31CCbOgD+/gSpG97yEQPSNkPS7ppH8CbKTGIdwFc35yg4gGu6xaidMZT65Uy rj1a3Ygr23esp0ZkNXzLdZOCL0ImDWLPtTEaVtII+nrZ2oSg3rFXGqrQ0n6qVJv0IohsIHSK1ZAp F0jm0rL7S1gfO9s1mz8rCpHtM8XXjvT0NDqvuu1LIJCJnSIBX+R37BISAiq6KfB4arObRXtQ2VH9 iW9eHu/+Z0y9PMHl/AU41wOz19lu5jJOlOA5ayDyfPavdJIteTSGRcnl9hNo9nhEO9HrEiv7Tn4s bRboTE+9irG9t09NOzd+P9WREnsXme5psZY6Do5NrrZwS/B8M0YRwp286bky8MUrTdddk/Y6sJ/8 spJm0zTUzvgP4O0mDtpvvXAEeu6Nvg9A2yUUDOtXuh3/+TbEM5ABD1irixDOe0anq7DIXPNI7ej8 4EfrQ13TBQWoOJd1LvAdaFE5izl/4gSVCg6l64/Zlvx/ZNQp10lie2ekzMtTwy+CIXxi1GDBSU85 T+ZdeGuw3yBOgRhfVN1nQMlJm+j4HJREZyC6qZVZvRweUufNx3WcCCxAOy3r0eRiAn9EMDkbgSi6 yqOuJUILOVd7S+ewuh 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 v5 03/10] memarea: support alloc/free/update-refcnt API Date: Wed, 5 Oct 2022 12:09:45 +0800 X-OQ-MSGID: <20221005040952.8166-4-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117361 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 70161A0542; Wed, 5 Oct 2022 06:10:31 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 9EF7342B70; Wed, 5 Oct 2022 06:10:06 +0200 (CEST) Received: from out203-205-221-190.mail.qq.com (out203-205-221-190.mail.qq.com [203.205.221.190]) by mails.dpdk.org (Postfix) with ESMTP id A8E1542905 for ; Wed, 5 Oct 2022 06:10:04 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943001; bh=C8qTE6hkJgFvCGayb+54fGaSBAsMap4/fPWQb5SN1Qk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=KT7K9g8CBs3QKjUajpEVllHWpXDjmDvF7KEiAj8Dj3xhO2gEhFERxYcLt+uHoEVYl JQAA1U3T8FzOAkwJQCEnQIgf95I+PzBjSvslSSpoDUfRU84k3XPBE7knyJVZ3YzGJF ebGaKfaEOIHTIzM3Us8TtUF0nV19BXE8sqmg2Wg8= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664942999t7or9jqb2 Message-ID: X-QQ-XMAILINFO: NY3HYYTs4gYS90mIxv7t3HlAoAg1MXwa130exnqUpbh/tb8IJbRqcmup0UsBCG 2vO9DtemQEJdr2SLXHnbKgi3sInrBP5a0kJaJfHrjYMkUQvj39ZsPKhBw3h3YDPPqdNqpsraFfj5 muCtq+KstfnmKkRSUEHMIgqrIyWw5B0Loa7M8tQFtnQ1TPkhaYB40wbObj66KLmcwQSAJldXrigK L6SS3EvhFXHA1ylGVNlNQ1k67djbs37sFDzmVaxDdHg7L3cmscmtdRaUCS6s4YR22JVjLUyLW1Y1 sAhClnJW35LQZXiAjfSIIjXAq9yG/yN1RyEdHVsluxm3/DihuO9xSg38H7A4PW9zI8m/DcA7FpIZ nAJlaCupH/FR1sEhseORMekFkAzXx9WxCAilA+KJuh7oHMkjDsEWKhZiHuJa2rkHmlTqku8oRcLK I0rSDcJUxlPENUXatsY/ScpCntwd+y4PexQluXdFVaQ6nDwtg6ZCwST3hk8nb9zuBzAMkybNKuki UxqPDlYStMrg2NvaxbDgGF2f+UFLSRKJpaVnH1qDTbBtqHAG4dJEwSA79uqYQUlNYl5JEcK3apqL onon6OVQvf58aYF4Uvk1Qs81bzP49kMiujPORbM/4yS0gvNbt9857Spaa/jMFQPYEeszTdpv2gta em4n3UouZjNUzaurIm1v52zFumYYQ/AUG1uGMlhLqpUmTR22Gmp5nnZCPg8cKtHKQUfWDkUvMlRJ wdw220otf9dPK5a4S6rJ13qIHuVde2Q/jPlfGpFw1vAIkMji4J0zXPTqViN20XFrF9N7yQFQOvhq xWPPO+/kRb9C7uMtwRcDqA57NyWMq3OBF6VTiZqpfOK0GodH7IrtE8TQubO5+x/y2uMNNoyziot2 OpFjw9lBK6uPxFuu4TlUtpQGQRDl89hTGfaQIihbf2rF4Zn7M/xVNmbXOQw0uxdOePYP6yKOKO// PAW72ao0nx1PMsLVPTcG/O2x0Nv42nRUbLdcJSi7oJp1DzokaKznw4VdZvWWXeEx2zOsVI8xZG5Y TZMlfhDw== 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 v5 04/10] test/memarea: support alloc/free/update-refcnt test Date: Wed, 5 Oct 2022 12:09:46 +0800 X-OQ-MSGID: <20221005040952.8166-5-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117360 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 D86A0A0542; Wed, 5 Oct 2022 06:10:25 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B769F42847; Wed, 5 Oct 2022 06:10:05 +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 3B03E42847 for ; Wed, 5 Oct 2022 06:10:04 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943002; bh=z6PloYGYPgA27BvMg9YE4Jjc/waI/xX6qtuVqBf3C2c=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=ISsGOqRtztritsUESaiqtTMzapOTmsLhW+VSW3i8RqO8WKFgrjCeLkPYP0lI2ZGqA O/HgYdafZfIa+E5c8F3+RlQlpe+TB7FTB1LLDg+7Cqs5wzDL4AiYofcmiG26DzY8+f 6uVRXmsWbucz0Jatz6eGansV1icPRfDxo/hW+XWw= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943001t7842icwi Message-ID: X-QQ-XMAILINFO: OZZSS56D9fAjnm+d5BBD3830ADL+Xbnlpj0WNFUuSea5uoSZnRqwtpiQTAsCUq xl8nw01xVIjpHM0b4TLhfNUZ/OCJZVjfwCt/T0JUseepyilUjr3lwZQRuVOZ8I9Kcnp1u2Bsx8i8 k1RM8HHqRQqp2XiQbx9bVrDPyeeDsKUowQMnyETg/xtFdFQ5OVvXNLV05ls3Wb1X00A0SkcO9wCx JIwcwEq/HSOr0/lMpZ/em1HIGGcPqp73szkwvRj2sFJbCcGxYoLFKaxKUDlqfXtkztqgpmPDHBLE RzQD3S3S8N+asVOmYNXbsyV6ZTD4l2Qvsl5WqkzB/6ev7KjQneK0++AhdNZy72tsbG8chwsKIEL2 jLe3Nh2Tl8ASAEcKLaFuMVaR/42H4QaX7R1y5fCujCTyZG2ccuVuSvEOLr60Bnatlm/HntrqMON+ iB8xZc1z0qwN72Ur3nqpLe3EpuawOKFoAiaUPxsJcdIEEeq0FARj75gjIycVhOu+TVMIobnoIh0x uYPlV2qTjh/XcmsOsf+S+A2KvoIA1r/bVudDoX3sRng6qm/peGzho4F/wvkC1ZSvG2YCQP4xwDUU DA0ehYfnNslNW4hcg0oxX+inmdaOM2jrnXOltnbODJpimZgoVMh2MdpM9qpT/xC+kRRVdgPV/ESs x+qsGLM2o0MW0B0iUsVJSJbDatE5LS6x8Ha+OexaEo9gNBVAJhgofnzRKD2gOD5ZloJFH6Ar6Ayf 9av2pCtPORwFzW1WKmXMhcJ26XIUBSh3eYGuI2XPXMA0Bt1DM3kWI74MTN3igShX8pciXgm0his7 k3KArh0R8JSNEamxrhqTm2bHHorBZ4lrmtaSSuq5PX5gE9L3LbNi3ghA8+mw6kj63SxppeFEns1/ mnzSjRB0GtTJQhRk3HeuFfdmHv8RhQIdJM5tKU/LteaNTuh12Pl7kP3W/dfNnOTC+886PDMbK18n 03+SwrdWnk3SwpX6XMxU731B7Vx/9WIbK2CjJ3OOVSgGcv5SNpl0jYo8vtNM4ZRSw/gIRGTEnJsu doUUO0Ybes+N3hXDBIVQIj/uomdy4= 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 v5 05/10] memarea: support dump API Date: Wed, 5 Oct 2022 12:09:47 +0800 X-OQ-MSGID: <20221005040952.8166-6-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:48 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117364 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 1DEA7A0542; Wed, 5 Oct 2022 06:10:49 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C465D42B7C; Wed, 5 Oct 2022 06:10:12 +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 469A542B82 for ; Wed, 5 Oct 2022 06:10:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943004; bh=fW26njVAFz0rUDdqhVnQ5hkZXX9syUTvUSrqKiLbUi0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=qmpb4IeALCOtYCUlClhvwAgTIkFKoIg5d3+zJ6JiS2jasRyHS+4zdThhkwSa91/k9 WB0mld79YZ9o4s2PoDaklQbyw4+4+xWv6RrODx5h2cWQq4QWlSMsPywo+OsVCDgLuV V9hIxf6qvJgsXnPr4DWKqfFw3Hpiu1woq4E1T9Ng= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943002tf3y39zrj Message-ID: X-QQ-XMAILINFO: N7h1OCCDntujQdzF0ZavzbLseEL/P4vDFSTbxVLt83vqRrxu/oZbWTn3dR0WPt aEO+hITXjRVcQLenFQNbmkgEi7WTd/IxBmcSgOGIdsbK1MWWcnkMvOdzOdUTCs6Zm155I/OjgUrb 3WNXoMS162+NZuhUBOOK+F7ubhkBq4IbXf5DvoPYulWmSx5FN1kzTJttUEgZ7cGUPro9P1h9tRNP TiBoziWJnpxVtXoiFNTWmOvnvsjjzxDzxgfH5OVUUp+R81KHV9kM0pHwQoGL+pBa3o41PnytlAta XLAMVmurUwGOazzxlogEgssrdqWHypxS16nfKXHaAILey7WcdJYGPxfqiERXnm+GeyFVKeUhlHr4 3GgtXArxK9KZInBDhKnlb/SJ3xmRV3SedC9CwMfs6MxA4QJBV8S4z3QY4uNAP12q3ITYIzRpClYj 7bZsQsZSHV/HdbJtlBYxiDc3rL9AucpT+/o7Fif4RcOzPjTUzZghblZVp/YC20+RerXHA5Q7LE12 OQyrz826K0rm3gHM8HarqSH0wnHAKPtpllEVd6yjLFdpWnM/k5ig8d3ypn9JWGS/oKOTwJfwPdZo FBKcgeFgwIhY4xqYLAJxzmwtYA1aQoltpmhdpCLVKejUIkU9UCdW5fRv7PwkIi9JHK0nxGof/i9F sOgDRHKA8ekUrCQtuCto8WBYeunVdYe1ioMABDAZCnqRxfY7ZEVYKygJ+mBlQGnqzV8jHIvO0Hhe IIJBq97Iolt6corCO2qWQ/xuaNKmPcNhV0sZpz6Uf9D8TdW2SxXEj3h+JE4j/EDRO68ZaLOxdmWu Sz40g6Vb4/FbRb2xgnLmdjg+RDnUO0QBYA3BPo05z3neraZRRdSFixkUKES0TrDEXum5b4g7nDRl bHBSspsYpZ1gMlNIIQHY0rOoz0Z0yoe4TaCzbGWXSKyrIWiCb8DlrpRICBnDVygOsPlP+4QDrtF3 s/bJJSotePqHrV2eLOvh+Pzhqam14JM8Epl8uxYXC7ZeMdsgMUPZrX4K3HkrO2F1yGNXKZRfJ480 PCuaFvnA== 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 v5 06/10] test/memarea: support dump test Date: Wed, 5 Oct 2022 12:09:48 +0800 X-OQ-MSGID: <20221005040952.8166-7-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117362 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 8F61CA0542; Wed, 5 Oct 2022 06:10:36 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 6F72542686; Wed, 5 Oct 2022 06:10:08 +0200 (CEST) Received: from out162-62-57-252.mail.qq.com (out162-62-57-252.mail.qq.com [162.62.57.252]) by mails.dpdk.org (Postfix) with ESMTP id 9518642B6E for ; Wed, 5 Oct 2022 06:10:06 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943005; bh=LMmxCGlG6l0rZDAWe4UHhtK6mISXvZkGWi0AQ2eGU3U=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=KJUVEJ38bozofYBdmp18chzRbyVtPZkrhX9p3sGLn9RiqBuNneYwOKi9THFoe8rTR fX3FTJSPUuUNfaHA+lK14gecrrUqLeXFQtN4fk6KYnnzUu7T2No9/5l1Qb3A13LEKX CU0R9d0Mm6WDqL/f3lZttSGNiPOqHPpfeCEzedYY= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943003thqhk0chq Message-ID: X-QQ-XMAILINFO: OKkKo7I1HxIeIqtRWF7IKBCpxHChSb4j41Q1bMcV0wjQWzb+uivg8jXr1/Zh4e kqz3PcvozlvT+SJUve3+5293dvickQDv2l0rU41JYyEisHfD2Zg5DN8wo7Juhk2YOzVpgH9UlQuL GwDLSBmR9y+Hldc4eAiapxYyQ1J4Jh8KiZR7VJS8phayGFUFMZvNnu/KZVktfOgywyfTTUUAMsBJ rTCiT4VNqFUdilRsE6MRkYx/wn7/2D0vTIP7OKza0b11cfR6UIt/9R89SVN9PtiKv4UAyrYcj7w2 yCZx6pDoQmZiuWyjl6hWRcFCCxWj2IEjQbqd9FbYitfdaK68rNWkIMQzsnpRxgru2dbKhFGpb/RJ QS8PKeOzDgPuJ6fy7P5CKumhq5CDYZX8/mYinInhrKfHQSqYpTBM0+DkyQG9ah916uQD2ZqGLE1Z gEnXMCKnCIx/kdfyvtgjR2t8RXErt2jEWkTbojXSzhgj8pYGU/QyP/cs8XnVgnjFxH246672fUAv 0Mg+3fA6Khe1y2VAWU1r7X2vycrXCy+22MUXSh3JRFNvUERpXP1iUzbrarfXL8G5FM0pu0TbdSBc o2oyQ2ZWZCnIZlcnwxf3rBoFjw2Vqc+iNgMP/eWjthAgAYne+ueGKmJ5KCc9c0HE2KRiQQFnkIiH Mus9fmnZ8PiwzOKtSynQ7xUhYFyAG3COT547iBs2b9uw0iv4Wrcu/gY87Qta7aFRJ4ZnzrRqvdLe etdZ3sKRicSd53RD+B8vweKrFnwAEDdVn7i1xdk180UO7pvHIAI6XXYU5s95KzQrrX5T1HKsRIFS mOXOGa9pxFrmTq/TTmnNwtQOj2QiveivPIt03I4XYMAd/YnpL7NVpYouVERPfC3VCN3RaxdFBj/l 7YrcbkKcFqMf1X/L8y+iE6S8Xg/SPBuiTsti9xXGGYqihD2zOjA58OMAWndXTHGddXzLaXj74RyR cE11q/5MBddYh5o0sJJogloAShfE6mX1UOWUXT7U021B+NIPCmFWMsXTnDH7eDBomQGyLIHGJgyd 9bnp5bdmL91uzhEHx2bHQwY7s0s9M= 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 v5 07/10] memarea: support backup memory mechanism Date: Wed, 5 Oct 2022 12:09:49 +0800 X-OQ-MSGID: <20221005040952.8166-8-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:50 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117366 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 35344A0542; Wed, 5 Oct 2022 06:11:00 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 7DBE142B8D; Wed, 5 Oct 2022 06:10:14 +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 C967242B84 for ; Wed, 5 Oct 2022 06:10:12 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943006; bh=1K/8Rt7vdqUS1PyVSUzU7CnydL6bqe3VgI77Oh1k5Ec=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=EqPeI8L8ndzdybXKjWPTAR7wIyWHGdJJnO8YUFCia9Y66AlKzejlwpay4/WGrXoTT MAY1etOX8TWk2oSkoNWcBGk/FFrlTa/4aj0Iw04seHmgq2gYJBbh4rcmhkx5GWJosj k4c1UpdcMfDl8N4gx34RdPxXa2TEjIX59C/2bbPs= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943005tbj7dqm8i Message-ID: X-QQ-XMAILINFO: OKkKo7I1HxIeIqtRWF7IKBC1gGdJ+ZEwa66BK5XpSizFZgU4ogcmdJKzKs1B6j M3QFEtIOPqJQoEh15ce2KLz/7AdOvGIlmS1b9UWsA7RWlD0aJ+RE8STtlU/Y/hKUb7E2E3oIBcUW gqO/BYhZC65llkWDCaWhrRqOYJDktxMIxiogbArlQBuzzFQ9h5+Zg/jflS1pNL6g3aa75pgcfn4h Ay88GXBWG1z5O4+SyQvNhFiJw3+q9nHgdRyhdtydKgmikZ1RZpVvE7GJYJSClZaf26Hx1Og8lK6G aH1VgvmvVbRQQ3tsIXGvJRa5vLHGE5Dmly5L22dM2odALw/4S0JL+fpM4wWSdxlhXRdOMsDBECht OkkKgaot6WYk7pYE/8kIyhh9xBiTD7e5b8hxOJiJYQ9kOwMi5b/dDK0W7S1nicMMY53v0iM2tH/a VRErP5ElrOwFynJicoWPpqSkuIrL+2caCJ5zGK+gYMu7jzY0LNBNW2Ey+X1E4tVPxmIKdKmTQvdd hOJJCo20UihmToNhS0N4nl9DrMNSWNphaErJdzE8XRscUuspgmM+74Y8Q+r4KV+UjTuUBmjl0gGN sJmWEln926RjXEkM1SONUtSrMD1uRd307mgYfRfsdSOl4l3X2/s0SJqjD/BA7x0PD1bWZ9TuD073 uyfPWruTgzh8VXlTZyzisZ1u28vzI9oEyNzUzDLF6AkxK7ko8YBcO1Qu/vLwHRuTRYeM2p21NGBM hox+yMUMjNTPDZKBvQkgJe+bivdeyzf/piLc1qLEEgqV8u0A5I86DyVmH+4O8cHHIXvnnU0WPJaE MGeNxQcxBntmgopjayKpX5bYO/AQeGHCPA+g/Ef91N3vvPwjT+j/llppf7yjssm0bTAvP4jVvx/8 c4T9lmMbMlvFG/kivaiadZPA+eiaFybXxHXk9mtQk6Afgo/1Lq2BSXorOTQb8Kis5Offe4bCnDiM oJn97F2SX3wnEMwNUpovuHft4hg23wBXlv2dUwju0ncdgqezZ4qUDP3BctUCjZSEvclRZ0DDUcGq 0zMEPNvOhrf0g23K0RLtlgmNnqMyk= 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 v5 08/10] test/memarea: support backup memory test Date: Wed, 5 Oct 2022 12:09:50 +0800 X-OQ-MSGID: <20221005040952.8166-9-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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 04:09:51 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117363 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 90958A0542; Wed, 5 Oct 2022 06:10:43 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B05D542B82; Wed, 5 Oct 2022 06:10:11 +0200 (CEST) Received: from out203-205-221-242.mail.qq.com (out203-205-221-242.mail.qq.com [203.205.221.242]) by mails.dpdk.org (Postfix) with ESMTP id 672CC42B7B for ; Wed, 5 Oct 2022 06:10:09 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943007; bh=iFfQNb9bU7wXQev4mmnqW4n48Bba+VmYFGn37TYZ/jY=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=csmAdfAhRuPIh01onNMo6MBN3mxzMPzFLr6ZAZlcK+3ItS/278jy3SRqnX+zBL+Kv JbxVUAX2r5ASqpnuCfkUwoUCbonvuOAfCBuUPWm19Zr4YY7IVwsHWIwzPgf0N9bdog Q//i+1Gw0MG+xlRGohlewL38h0dcZz/iB+khBLK8= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943006tm17swfej Message-ID: X-QQ-XMAILINFO: MGSlRwRrdVfImC/86xI5e+cn/NEdcA2RP/Hscp5pboW5yyk3m4MeSUpo1Dfnsr szFcorIuf09BW7dOc9nT84g2vG36slR4HDSv9ZwMn36akNq/8QIDs9t2NG5e4MR4crxT+meEfcX7 UPes8ga+S06KVAj6hbXhwSpNNs1SuAPZJmeAXr5iZ/oMrfk24sQdh/2xGqDX2+iKEDpXusPhoUc7 XD4Gd+1jZ5HzSfoPzK4y2qZhO42Q/tYycFn+4UkA3Jt2F3Q/2LyX+KKGIsTtnTESPdIqHZtv2x9g kW/bRBF3Z6nYbjfoHbwhIeLNeAWRUUuIijhDwtGNCgAQU9gDqbNLYLvnOErP/X6c6hMT9YGMn2/A cixubLkjoDTKQsF1HvKu9iPHe+L/hOAi4UuCgCT/8IFr80HYrjch5gmbqam5v3VGk8R+NAABu77C +GllXvRIAZo7j4oqHEXecvkL3sH/bufflz2cpXvW3ZX0730GBwGpavyB4sIpo1wV7rUZ2ZZsCeTy CvTWDD4Yzf5qkItaubxRjbuNrRRAsNxFXk4EGJDaJvAv8DSGfpKmh4BJlCbF6gGHY6aOqr//yZ6x TINLRU46N13o8D1QHK5YH+3UtO/IbIGQonoO83//AtMIibG2IRGgyio6mlTHquVDJzvRIrztX/sT roEPmnTn5kF+U5COY36oVfE1mhB+FPxjhzg5DmqT3ZjKrIbkQZwzNss6zesbSCPkDvZPYUB0veSL SKlRYArEM18B05alPbv79sKCSUj5FOblhIDTKdv474MNcIV5zx/obFVGZMV3E66VX1E9CADqwtjy cS/ZASRwWgIqTS6K5LiYFeS+nBXkYK2TRkwv4Z12OySHHkOWHDWvcU0av2wgm4QLMQ9PgPxsEiEZ n437ojjY+mdoP75hJU0CSjbGSX6SjKLKE4PEjuf3eHnrxG8alTmSy1wdCyVyCarjaN54dBsbPhMc xhJi8Y/6ZoZBaCKJkXrllz25iuuagr8fOGuaYJHzczJEZ9lRYFEGuVIQ2qBYWlwv+eKiDo9Czeiz u3hKHpOEmM23/zxammohI5wC5C/dF7N2HVYJxWPjYxgnUXch0z5k40471hWLQ= 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 v5 09/10] memarea: detect memory corruption based on magic Date: Wed, 5 Oct 2022 12:09:51 +0800 X-OQ-MSGID: <20221005040952.8166-10-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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..6290e3449a 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 check 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 04:09:52 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: datshan X-Patchwork-Id: 117365 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 47EEDA0542; Wed, 5 Oct 2022 06:10:54 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 998E642B84; Wed, 5 Oct 2022 06:10:13 +0200 (CEST) Received: from out203-205-221-164.mail.qq.com (out203-205-221-164.mail.qq.com [203.205.221.164]) by mails.dpdk.org (Postfix) with ESMTP id F2B4C42B7B for ; Wed, 5 Oct 2022 06:10:10 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qq.com; s=s201512; t=1664943009; bh=tZHTTODRm39GZCm6CBMuq76QhV8hAhOyaUCTYIXz/c8=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=J/RevneQ0g93FcW1FysRu+R21JzpU/G/ZADbsdjF3uAQ4GwglapR+zquQAsGq/vLS w8UdsJSMONQMI3i0RLAI3eaOqQqfVUEPeuhPyL/sthUF9HkFbdTKrvOsLwtQtM3n7y NNToXcgJx2Qdc5+3mzpA01BHoqRrUxdPV84OlQB0= Received: from qq.com ([120.229.93.179]) by newxmesmtplogicsvrsza31.qq.com (NewEsmtp) with SMTP id 27598E97; Wed, 05 Oct 2022 12:09:53 +0800 X-QQ-mid: xmsmtpt1664943007tv7jmjpi3 Message-ID: X-QQ-XMAILINFO: NyRMGmFSr9jvUKiRmhABfPZF5uGZniyub3Jlsk0Mugi8ZOvpQqr7+wmssblQJ2 DWHFk9c2ZSwVbBIShqAZyfJIOQz8hWeJHDzDoSe7Hh6CrqbnXc+rs8UPrJrKoVe1tjrtjeTGnPfP PBaRF0H1Siy3gSwP0ZRmqlA3n56LW2IwCTJ9Xo3/NQkaVYjMmLMA9oifowtc/Hn2pZSUUL8XQ0Z8 F/jc6wbio7evD9PU4g8w6Mdoj4jXL5FRccZZai8Ha+Q1nQXzMknr7lBkr7vEKlrkKWojw4g3+BAS NleInJHIfDcm0sL2U2LDexCFdUByoHmI5HVQ3a7QbZOtr/qfzV6cZy4pabtukW5nW0pQdICYk4Da Yz8hfjpGbbf8fa0a2QypEdLFSw8PuHUmAlWCenw0On3sULje8qUlvPe+NVn+nQAN2IFNMPN8vSmP woQBvmtS+JLmDv46tqmMOoF+BYv+G3ekIU+pQDx/Lf92ZOiFUouRnMmj9kqR7W3OrMfwkulDEugW h/Nb7LvzOVvIJXqXqmxUA6152kjot4BFPj0zBa3lfuCUC4qwdcqIWOGb8VCNULkxI6gpZFRsbNlf LuD3XA8rnS7gIrjvKczy0YSUu5lPOdN9c7b4h4T7YLMi2kiSiinI2MYDnRop1m6hq93WHNDRn5lk np4MGIqvxTvhv32g/7p+r9wUcbFTsZD6MXSfDfdoxJ+XwmD2k3K5LqtVFJixmxlIg0fkAKtXWziY N3BXbdPftW7PDEaUIKlIVTnvzuDt89nMt4q1uN1FtUWCyq0GeGi+dHvdUlH4EEY8ceZzsYShIu8d HcPrr5dI7YFR7dEJzPwk4SsLv2Qofosy3DWmSkepgV63IqQUvxJrERrH/LgiM73YT8SPB39hkG/E o8398htO6vwMCo/yDaYDewnHqIjEq6d0FaheW6JqxxztgXeZKdQ0x5MA573I3vAQOPQEOqBjgRAr 5oSQF/om8Hf/Bt0lmeFER3YtMpMsLxDboxbH4kpQQQIR2OEtXCXACyOqwsVxwB/jsnmzZoLTYaaH FlLs3/rEQK55AOx/q/md3r31TKkQpPE9dZ9JuKHp2xPQCzMbAg 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 v5 10/10] test/memarea: support no MT-safe test Date: Wed, 5 Oct 2022 12:09:52 +0800 X-OQ-MSGID: <20221005040952.8166-11-datshan@qq.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20221005040952.8166-1-datshan@qq.com> References: <20220721044648.6817-1-fengchengwen@huawei.com> <20221005040952.8166-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; }