From patchwork Wed Oct 11 14:35:11 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adrien Mazarguil X-Patchwork-Id: 30131 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9B3DC1B21C; Wed, 11 Oct 2017 16:36:35 +0200 (CEST) Received: from mail-wm0-f54.google.com (mail-wm0-f54.google.com [74.125.82.54]) by dpdk.org (Postfix) with ESMTP id B02321B1F7 for ; Wed, 11 Oct 2017 16:36:28 +0200 (CEST) Received: by mail-wm0-f54.google.com with SMTP id u138so5338027wmu.5 for ; Wed, 11 Oct 2017 07:36:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=6wind-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=WOK25v2WXJ+IYXnMu2i1WKsQ4CGTTMQP8+UJfAFpKkc=; b=lWAnyBVPmdzURoSjG9H2NP2G6ifRpBeZD9A7Gk01gLUB2Sx+SrzzaUHRhCrxsG0urD bnDiYL8axdSkny0rNstx/GLndL2F0Em23yB4JQj5w57TpTn6iIknWAiIrglOcDlT/mLP D7cFhLY4rNh5d0MxL7bvEuMM3K5dDd9Kw3X6467VrJBmddfbhA1UCKGVKjMD0IPE48HF V8uVSMdMAiJpCMJ44U9+tlRWxW8nolyPzxpH2PfXF+8w7DBw0zpWIHLCOIIuFU7pc04k aGCL0t73Y+1P/9tT0GpRGtVqIUZRDRx/ncXO7DNQgsH3QYVVSgVHGyv0GKjf1/A5UNzK 4Guw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=WOK25v2WXJ+IYXnMu2i1WKsQ4CGTTMQP8+UJfAFpKkc=; b=XqCejSmLUXT3H5zWPy8ic2bQG2jsAC2IszYBOAbXMHvxkUD2gGH55o0V7yMpHPp5Bu 8N+LiGOY1G1ZzmQtbjKj8lav2Z/eRa8sIBZCcmaLR46471dh8ptFBGbvddeYgNBS2SEZ Ah0usuY9OQpPuwo7ds484g7Sr/etBbS4gVTk+oIVzL9whZeCGqxLZE8T1XnBz53fupAf NoJDLrZJF6/P9NkVmaQXC/DGgk9Vus4V7Y4uvGcvBXq7ByWPMh7MGJLTvX0SHCh+ZtyB z/hbxvIyXqBpzO4abrZ1gfHnQvg4g0GPOeWeHKaWvGW0HGQg7hK6CGRStSxNBgo0Wkz8 W+Ag== X-Gm-Message-State: AMCzsaW/iSZfxDQCEzN6jiN8AVNOsIiLRQtgr4263gKgAuJ3I5rp5EEt CnWrEG77gP1ipNohwyI2UVm+5w== X-Google-Smtp-Source: AOwi7QC9g/oCqB8IVtACjCO7N48Oq8r+sRoazfrHjc+h/hLkp/l9IGQ8dksEJpkCNSmxmWEqyNFMJA== X-Received: by 10.223.160.42 with SMTP id k39mr17319838wrk.97.1507732588143; Wed, 11 Oct 2017 07:36:28 -0700 (PDT) Received: from 6wind.com (host.78.145.23.62.rev.coltfrance.com. [62.23.145.78]) by smtp.gmail.com with ESMTPSA id i13sm11375514wre.93.2017.10.11.07.36.27 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 11 Oct 2017 07:36:27 -0700 (PDT) From: Adrien Mazarguil To: Ferruh Yigit Cc: dev@dpdk.org Date: Wed, 11 Oct 2017 16:35:11 +0200 Message-Id: <18771436831105304b9f7c133cc51e8c867f4273.1507730496.git.adrien.mazarguil@6wind.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: References: Subject: [dpdk-dev] [PATCH v1 09/29] mem: add iovec-like allocation wrappers X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" These wrappers implement the ability to allocate room for several disparate objects as a single contiguous allocation while complying with their respective alignment constraints. This is usually more efficient than allocating and freeing them individually if they are not expected to be reallocated with rte_realloc(). A typical use case is when several objects that cannot be dissociated must be allocated together, as shown in the following example: struct b { ... struct d *d; } struct a { ... struct b *b; struct c *c; } struct rte_malloc_vec vec[] = { { .size = sizeof(struct a), .addr = &ptr_a, }, { .size = sizeof(struct b), .addr = &ptr_b, }, { .size = sizeof(struct c), .addr = &ptr_c, }, { .size = sizeof(struct d), .addr = &ptr_d, }, }; if (!rte_mallocv(NULL, vec, RTE_DIM(vec))) goto error; struct a *a = ptr_a; a->b = ptr_b; a->c = ptr_c; a->b->d = ptr_d; ... rte_free(a); Signed-off-by: Adrien Mazarguil Acked-by: Nelio Laranjeiro --- lib/librte_eal/bsdapp/eal/rte_eal_version.map | 9 ++ lib/librte_eal/common/include/rte_malloc.h | 85 ++++++++++++++++++ lib/librte_eal/common/rte_malloc.c | 92 ++++++++++++++++++++ lib/librte_eal/linuxapp/eal/rte_eal_version.map | 9 ++ 4 files changed, 195 insertions(+) diff --git a/lib/librte_eal/bsdapp/eal/rte_eal_version.map b/lib/librte_eal/bsdapp/eal/rte_eal_version.map index de25582..1ab50a5 100644 --- a/lib/librte_eal/bsdapp/eal/rte_eal_version.map +++ b/lib/librte_eal/bsdapp/eal/rte_eal_version.map @@ -201,6 +201,15 @@ DPDK_17.08 { } DPDK_17.05; +DPDK_17.11 { + global: + + rte_mallocv; + rte_mallocv_socket; + rte_zmallocv; + rte_zmallocv_socket; +} DPDK_17.08; + EXPERIMENTAL { global: diff --git a/lib/librte_eal/common/include/rte_malloc.h b/lib/librte_eal/common/include/rte_malloc.h index 3d37f79..545697c 100644 --- a/lib/librte_eal/common/include/rte_malloc.h +++ b/lib/librte_eal/common/include/rte_malloc.h @@ -60,6 +60,13 @@ struct rte_malloc_socket_stats { size_t heap_allocsz_bytes; /**< Total allocated bytes on heap */ }; +/** Object description used with rte_mallocv() and similar functions. */ +struct rte_malloc_vec { + size_t align; /**< Alignment constraint (power of 2), 0 if unknown. */ + size_t size; /**< Object size. */ + void **addr; /**< Storage for allocation address. */ +}; + /** * This function allocates memory from the huge-page area of memory. The memory * is not cleared. In NUMA systems, the memory allocated resides on the same @@ -335,6 +342,84 @@ rte_malloc_set_limit(const char *type, size_t max); phys_addr_t rte_malloc_virt2phy(const void *addr); +/** + * Allocate memory once for several disparate objects. + * + * This function adds iovec-like semantics (e.g. readv()) to rte_malloc(). + * Memory is allocated once for several contiguous objects of nonuniform + * sizes and alignment constraints. + * + * Each entry of @p vec describes the size, alignment constraint and + * provides a buffer address where the resulting object pointer must be + * stored. + * + * The buffer of the first entry is guaranteed to point to the beginning of + * the allocated region and is safe to use with rte_free(). + * + * NULL buffers are silently ignored. + * + * Providing a NULL buffer in the first entry prevents this function from + * allocating any memory but has otherwise no effect on its behavior. In + * this case, the contents of remaining non-NULL buffers are updated with + * addresses relative to zero (i.e. offsets that would have been used during + * the allocation). + * + * @param[in] type + * A string identifying the type of allocated objects (useful for debug + * purposes, such as identifying the cause of a memory leak). Can be NULL. + * @param[in, out] vec + * Description of objects to allocate memory for. + * @param cnt + * Number of entries in @p vec. + * + * @return + * Size in bytes of the allocated region including any padding. In case of + * error, rte_errno is set, 0 is returned and NULL is stored in the + * non-NULL buffers pointed by @p vec. + * + * @see rte_malloc() + * @see struct rte_malloc_vec + */ +size_t +rte_mallocv(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt); + +/** + * Combines the semantics of rte_mallocv() with those of rte_zmalloc(). + * + * @see rte_mallocv() + * @see rte_zmalloc() + */ +size_t +rte_zmallocv(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt); + +/** + * Socket-aware version of rte_mallocv(). + * + * This function takes one additional parameter. + * + * @param socket + * NUMA socket to allocate memory on. If SOCKET_ID_ANY is used, this + * function will behave the same as rte_mallocv(). + * + * @see rte_mallocv() + */ +size_t +rte_mallocv_socket(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt, int socket); + +/** + * Combines the semantics of rte_mallocv_socket() with those of + * rte_zmalloc_socket(). + * + * @see rte_mallocv_socket() + * @see rte_zmalloc_socket() + */ +size_t +rte_zmallocv_socket(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt, int socket); + #ifdef __cplusplus } #endif diff --git a/lib/librte_eal/common/rte_malloc.c b/lib/librte_eal/common/rte_malloc.c index d65c05a..6c7a4f7 100644 --- a/lib/librte_eal/common/rte_malloc.c +++ b/lib/librte_eal/common/rte_malloc.c @@ -41,6 +41,7 @@ #include #include #include +#include #include #include #include @@ -265,3 +266,94 @@ rte_malloc_virt2phy(const void *addr) ((uintptr_t)addr - (uintptr_t)elem->ms->addr); return paddr; } + +/* + * Internal helper to allocate memory once for several disparate objects. + * + * The most restrictive alignment constraint for standard objects is assumed + * to be sizeof(double) and is used as a default value. + * + * C11 code would include stdalign.h and use alignof(max_align_t) however + * we'll stick with C99 for the time being. + */ +static inline size_t +rte_mallocv_inline(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt, int zero, int socket) +{ + unsigned int i; + size_t size; + size_t least; + uint8_t *data = NULL; + int fill = !vec[0].addr; + +fill: + size = 0; + least = 0; + for (i = 0; i < cnt; ++i) { + size_t align = (uintptr_t)vec[i].align; + + if (!align) { + align = sizeof(double); + } else if (!rte_is_power_of_2(align)) { + rte_errno = EINVAL; + goto error; + } + if (least < align) + least = align; + align = RTE_ALIGN_CEIL(size, align); + size = align + vec[i].size; + if (fill && vec[i].addr) + *vec[i].addr = data + align; + } + if (fill) + return size; + if (!zero) + data = rte_malloc_socket(type, size, least, socket); + else + data = rte_zmalloc_socket(type, size, least, socket); + if (data) { + fill = 1; + goto fill; + } + rte_errno = ENOMEM; +error: + for (i = 0; i != cnt; ++i) + if (vec[i].addr) + *vec[i].addr = NULL; + return 0; +} + +/* Allocate memory once for several disparate objects. */ +size_t +rte_mallocv(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt) +{ + return rte_mallocv_inline(type, vec, cnt, 0, SOCKET_ID_ANY); +} + +/* Combines the semantics of rte_mallocv() with those of rte_zmalloc(). */ +size_t +rte_zmallocv(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt) +{ + return rte_mallocv_inline(type, vec, cnt, 1, SOCKET_ID_ANY); +} + +/* Socket-aware version of rte_mallocv(). */ +size_t +rte_mallocv_socket(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt, int socket) +{ + return rte_mallocv_inline(type, vec, cnt, 0, socket); +} + +/* + * Combines the semantics of rte_mallocv_socket() with those of + * rte_zmalloc_socket(). + */ +size_t +rte_zmallocv_socket(const char *type, const struct rte_malloc_vec *vec, + unsigned int cnt, int socket) +{ + return rte_mallocv_inline(type, vec, cnt, 1, socket); +} diff --git a/lib/librte_eal/linuxapp/eal/rte_eal_version.map b/lib/librte_eal/linuxapp/eal/rte_eal_version.map index 146156e..d620da3 100644 --- a/lib/librte_eal/linuxapp/eal/rte_eal_version.map +++ b/lib/librte_eal/linuxapp/eal/rte_eal_version.map @@ -205,6 +205,15 @@ DPDK_17.08 { } DPDK_17.05; +DPDK_17.11 { + global: + + rte_mallocv; + rte_mallocv_socket; + rte_zmallocv; + rte_zmallocv_socket; +} DPDK_17.08; + EXPERIMENTAL { global: