From patchwork Tue Feb 16 14:48:11 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Hunt, David" X-Patchwork-Id: 10548 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id C3FC0C31E; Tue, 16 Feb 2016 15:48:54 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 1FB86C30E for ; Tue, 16 Feb 2016 15:48:52 +0100 (CET) Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by orsmga101.jf.intel.com with ESMTP; 16 Feb 2016 06:48:51 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.22,455,1449561600"; d="scan'208";a="48730924" Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga004.fm.intel.com with ESMTP; 16 Feb 2016 06:48:50 -0800 Received: from sivswdev02.ir.intel.com (sivswdev02.ir.intel.com [10.237.217.46]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id u1GEmong011232; Tue, 16 Feb 2016 14:48:50 GMT Received: from sivswdev02.ir.intel.com (localhost [127.0.0.1]) by sivswdev02.ir.intel.com with ESMTP id u1GEmo0a004254; Tue, 16 Feb 2016 14:48:50 GMT Received: (from dhunt5@localhost) by sivswdev02.ir.intel.com with id u1GEmorG004250; Tue, 16 Feb 2016 14:48:50 GMT From: David Hunt To: dev@dpdk.org Date: Tue, 16 Feb 2016 14:48:11 +0000 Message-Id: <1455634095-4183-3-git-send-email-david.hunt@intel.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1455634095-4183-1-git-send-email-david.hunt@intel.com> References: <1453829155-1366-1-git-send-email-david.hunt@intel.com> <1455634095-4183-1-git-send-email-david.hunt@intel.com> Subject: [dpdk-dev] [PATCH 2/6] mempool: add stack (lifo) based external mempool handler X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" adds a simple stack based mempool handler Signed-off-by: David Hunt --- lib/librte_mempool/Makefile | 2 +- lib/librte_mempool/rte_mempool.c | 4 +- lib/librte_mempool/rte_mempool.h | 1 + lib/librte_mempool/rte_mempool_stack.c | 164 +++++++++++++++++++++++++++++++++ 4 files changed, 169 insertions(+), 2 deletions(-) create mode 100644 lib/librte_mempool/rte_mempool_stack.c diff --git a/lib/librte_mempool/Makefile b/lib/librte_mempool/Makefile index aeaffd1..d795b48 100644 --- a/lib/librte_mempool/Makefile +++ b/lib/librte_mempool/Makefile @@ -43,7 +43,7 @@ LIBABIVER := 1 # all source are stored in SRCS-y SRCS-$(CONFIG_RTE_LIBRTE_MEMPOOL) += rte_mempool.c SRCS-$(CONFIG_RTE_LIBRTE_MEMPOOL) += rte_mempool_default.c - +SRCS-$(CONFIG_RTE_LIBRTE_MEMPOOL) += rte_mempool_stack.c ifeq ($(CONFIG_RTE_LIBRTE_XEN_DOM0),y) SRCS-$(CONFIG_RTE_LIBRTE_MEMPOOL) += rte_dom0_mempool.c endif diff --git a/lib/librte_mempool/rte_mempool.c b/lib/librte_mempool/rte_mempool.c index a577a3e..44bc92f 100644 --- a/lib/librte_mempool/rte_mempool.c +++ b/lib/librte_mempool/rte_mempool.c @@ -672,7 +672,9 @@ rte_mempool_xmem_create(const char *name, unsigned n, unsigned elt_size, * examine the * flags to set the correct index into the handler table. */ - if (flags & (MEMPOOL_F_SP_PUT | MEMPOOL_F_SC_GET)) + if (flags & MEMPOOL_F_USE_STACK) + sprintf(handler_name, "%s", "stack"); + else if (flags & (MEMPOOL_F_SP_PUT | MEMPOOL_F_SC_GET)) sprintf(handler_name, "%s", "ring_sp_sc"); else if (flags & MEMPOOL_F_SP_PUT) sprintf(handler_name, "%s", "ring_sp_mc"); diff --git a/lib/librte_mempool/rte_mempool.h b/lib/librte_mempool/rte_mempool.h index 3705fbd..8d8201f 100644 --- a/lib/librte_mempool/rte_mempool.h +++ b/lib/librte_mempool/rte_mempool.h @@ -303,6 +303,7 @@ struct rte_mempool { #define MEMPOOL_F_NO_CACHE_ALIGN 0x0002 /**< Do not align objs on cache lines.*/ #define MEMPOOL_F_SP_PUT 0x0004 /**< Default put is "single-producer".*/ #define MEMPOOL_F_SC_GET 0x0008 /**< Default get is "single-consumer".*/ +#define MEMPOOL_F_USE_STACK 0x0010 /**< Use a stack for the common pool. */ #define MEMPOOL_F_INT_HANDLER 0x0020 /**< Using internal mempool handler */ diff --git a/lib/librte_mempool/rte_mempool_stack.c b/lib/librte_mempool/rte_mempool_stack.c new file mode 100644 index 0000000..d341793 --- /dev/null +++ b/lib/librte_mempool/rte_mempool_stack.c @@ -0,0 +1,164 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include "rte_mempool_internal.h" + +struct rte_mempool_common_stack { + /* Spinlock to protect access */ + rte_spinlock_t sl; + + uint32_t size; + uint32_t len; + void *objs[]; +}; + +static void * +common_stack_alloc(struct rte_mempool *mp, + const char *name, unsigned n, int socket_id, unsigned flags) +{ + struct rte_mempool_common_stack *s; + char stack_name[RTE_RING_NAMESIZE]; + + int size = sizeof(*s) + (n+16)*sizeof(void *); + + flags = flags; + + /* Allocate our local memory structure */ + snprintf(stack_name, sizeof(stack_name), "%s-common-stack", name); + s = rte_zmalloc_socket(stack_name, + size, RTE_CACHE_LINE_SIZE, socket_id); + if (s == NULL) { + RTE_LOG(ERR, MEMPOOL, "Cannot allocate stack!\n"); + return NULL; + } + + /* And the spinlock we use to protect access */ + rte_spinlock_init(&s->sl); + + s->size = n; + mp->rt_pool = (void *) s; + mp->handler_idx = rte_get_mempool_handler_idx("stack"); + + return s; +} + +static int common_stack_put(void *p, void * const *obj_table, + unsigned n) +{ + struct rte_mempool_common_stack *s = + (struct rte_mempool_common_stack *)p; + void **cache_objs; + unsigned index; + + /* Acquire lock */ + rte_spinlock_lock(&s->sl); + cache_objs = &s->objs[s->len]; + + /* Is there sufficient space in the stack ? */ + if ((s->len + n) > s->size) { + rte_spinlock_unlock(&s->sl); + return -ENOENT; + } + + /* Add elements back into the cache */ + for (index = 0; index < n; ++index, obj_table++) + cache_objs[index] = *obj_table; + + s->len += n; + + rte_spinlock_unlock(&s->sl); + return 0; +} + +static int common_stack_get(void *p, void **obj_table, + unsigned n) +{ + struct rte_mempool_common_stack *s = + (struct rte_mempool_common_stack *)p; + void **cache_objs; + unsigned index, len; + + /* Acquire lock */ + rte_spinlock_lock(&s->sl); + + if (unlikely(n > s->len)) { + rte_spinlock_unlock(&s->sl); + return -ENOENT; + } + + cache_objs = s->objs; + + for (index = 0, len = s->len - 1; index < n; + ++index, len--, obj_table++) + *obj_table = cache_objs[len]; + + s->len -= n; + rte_spinlock_unlock(&s->sl); + return n; +} + +static unsigned common_stack_get_count(void *p) +{ + struct rte_mempool_common_stack *s = + (struct rte_mempool_common_stack *)p; + + return s->len; +} + +static int +common_stack_free(struct rte_mempool *mp) +{ + struct rte_mempool_common_stack *s; + + s = mp->rt_pool; + + rte_free(s); + + return 0; +} + +static struct rte_mempool_handler handler_stack = { + .name = "stack", + .alloc = common_stack_alloc, + .put = common_stack_put, + .get = common_stack_get, + .get_count = common_stack_get_count, + .free = common_stack_free +}; + +REGISTER_MEMPOOL_HANDLER(handler_stack);