From: Andrew Rybchenko <arybchenko@solarflare.com>
To: <dev@dpdk.org>
Cc: Olivier Matz <olivier.matz@6wind.com>,
"Artem V. Andreev" <Artem.Andreev@oktetlabs.ru>
Subject: [dpdk-dev] [RFC v2 12/17] mempool/bucket: implement bucket mempool manager
Date: Tue, 23 Jan 2018 13:16:07 +0000 [thread overview]
Message-ID: <1516713372-10572-13-git-send-email-arybchenko@solarflare.com> (raw)
In-Reply-To: <1516713372-10572-1-git-send-email-arybchenko@solarflare.com>
From: "Artem V. Andreev" <Artem.Andreev@oktetlabs.ru>
The manager provides a way to allocate physically and virtually
contiguous set of objects.
Signed-off-by: Artem V. Andreev <Artem.Andreev@oktetlabs.ru>
Signed-off-by: Andrew Rybchenko <arybchenko@solarflare.com>
---
MAINTAINERS | 9 +
config/common_base | 2 +
drivers/mempool/Makefile | 1 +
drivers/mempool/bucket/Makefile | 27 +
drivers/mempool/bucket/rte_mempool_bucket.c | 561 +++++++++++++++++++++
.../mempool/bucket/rte_mempool_bucket_version.map | 4 +
mk/rte.app.mk | 1 +
7 files changed, 605 insertions(+)
create mode 100644 drivers/mempool/bucket/Makefile
create mode 100644 drivers/mempool/bucket/rte_mempool_bucket.c
create mode 100644 drivers/mempool/bucket/rte_mempool_bucket_version.map
diff --git a/MAINTAINERS b/MAINTAINERS
index 5788ea0..9df2cf5 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -303,6 +303,15 @@ F: test/test/test_event_eth_rx_adapter.c
F: doc/guides/prog_guide/event_ethernet_rx_adapter.rst
+Memory Pool Drivers
+-------------------
+
+Bucket memory pool
+M: Artem V. Andreev <Artem.Andreev@oktetlabs.ru>
+M: Andrew Rybchenko <arybchenko@solarflare.com>
+F: drivers/mempool/bucket/
+
+
Bus Drivers
-----------
diff --git a/config/common_base b/config/common_base
index 170a389..4fe42f6 100644
--- a/config/common_base
+++ b/config/common_base
@@ -622,6 +622,8 @@ CONFIG_RTE_LIBRTE_MEMPOOL_DEBUG=n
#
# Compile Mempool drivers
#
+CONFIG_RTE_DRIVER_MEMPOOL_BUCKET=y
+CONFIG_RTE_DRIVER_MEMPOOL_BUCKET_SIZE_KB=64
CONFIG_RTE_DRIVER_MEMPOOL_RING=y
CONFIG_RTE_DRIVER_MEMPOOL_STACK=y
diff --git a/drivers/mempool/Makefile b/drivers/mempool/Makefile
index aae2cb1..45fca04 100644
--- a/drivers/mempool/Makefile
+++ b/drivers/mempool/Makefile
@@ -3,6 +3,7 @@
include $(RTE_SDK)/mk/rte.vars.mk
+DIRS-$(CONFIG_RTE_DRIVER_MEMPOOL_BUCKET) += bucket
DIRS-$(CONFIG_RTE_LIBRTE_DPAA_MEMPOOL) += dpaa
DIRS-$(CONFIG_RTE_LIBRTE_DPAA2_MEMPOOL) += dpaa2
DIRS-$(CONFIG_RTE_DRIVER_MEMPOOL_RING) += ring
diff --git a/drivers/mempool/bucket/Makefile b/drivers/mempool/bucket/Makefile
new file mode 100644
index 0000000..7364916
--- /dev/null
+++ b/drivers/mempool/bucket/Makefile
@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: BSD-3-Clause
+#
+# Copyright (c) 2017-2018 Solarflare Communications Inc.
+# All rights reserved.
+#
+# This software was jointly developed between OKTET Labs (under contract
+# for Solarflare) and Solarflare Communications, Inc.
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+#
+# library name
+#
+LIB = librte_mempool_bucket.a
+
+CFLAGS += -O3
+CFLAGS += $(WERROR_FLAGS)
+
+LDLIBS += -lrte_eal -lrte_mempool -lrte_ring
+
+EXPORT_MAP := rte_mempool_bucket_version.map
+
+LIBABIVER := 1
+
+SRCS-$(CONFIG_RTE_DRIVER_MEMPOOL_BUCKET) += rte_mempool_bucket.c
+
+include $(RTE_SDK)/mk/rte.lib.mk
diff --git a/drivers/mempool/bucket/rte_mempool_bucket.c b/drivers/mempool/bucket/rte_mempool_bucket.c
new file mode 100644
index 0000000..dc4e1dc
--- /dev/null
+++ b/drivers/mempool/bucket/rte_mempool_bucket.c
@@ -0,0 +1,561 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 2017-2018 Solarflare Communications Inc.
+ * All rights reserved.
+ *
+ * This software was jointly developed between OKTET Labs (under contract
+ * for Solarflare) and Solarflare Communications, Inc.
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <rte_errno.h>
+#include <rte_ring.h>
+#include <rte_mempool.h>
+#include <rte_malloc.h>
+
+/*
+ * The general idea of the bucket mempool driver is as follows.
+ * We keep track of physically contiguous groups (buckets) of objects
+ * of a certain size. Every such a group has a counter that is
+ * incremented every time an object from that group is enqueued.
+ * Until the bucket is full, no objects from it are eligible for allocation.
+ * If a request is made to dequeue a multiply of bucket size, it is
+ * satisfied by returning the whole buckets, instead of separate objects.
+ */
+
+
+struct bucket_header {
+ unsigned int lcore_id;
+ uint8_t fill_cnt;
+};
+
+struct bucket_stack {
+ unsigned int top;
+ unsigned int limit;
+ void *objects[];
+};
+
+struct bucket_data {
+ unsigned int header_size;
+ unsigned int total_elt_size;
+ unsigned int obj_per_bucket;
+ uintptr_t bucket_page_mask;
+ struct rte_ring *shared_bucket_ring;
+ struct bucket_stack *buckets[RTE_MAX_LCORE];
+ /*
+ * Multi-producer single-consumer ring to hold objects that are
+ * returned to the mempool at a different lcore than initially
+ * dequeued
+ */
+ struct rte_ring *adoption_buffer_rings[RTE_MAX_LCORE];
+ struct rte_ring *shared_orphan_ring;
+ struct rte_mempool *pool;
+ unsigned int bucket_mem_size;
+};
+
+static struct bucket_stack *
+bucket_stack_create(const struct rte_mempool *mp, unsigned int n_elts)
+{
+ struct bucket_stack *stack;
+
+ stack = rte_zmalloc_socket("bucket_stack",
+ sizeof(struct bucket_stack) +
+ n_elts * sizeof(void *),
+ RTE_CACHE_LINE_SIZE,
+ mp->socket_id);
+ if (stack == NULL)
+ return NULL;
+ stack->limit = n_elts;
+ stack->top = 0;
+
+ return stack;
+}
+
+static void
+bucket_stack_push(struct bucket_stack *stack, void *obj)
+{
+ RTE_ASSERT(stack->top < stack->limit);
+ stack->objects[stack->top++] = obj;
+}
+
+static void *
+bucket_stack_pop_unsafe(struct bucket_stack *stack)
+{
+ RTE_ASSERT(stack->top > 0);
+ return stack->objects[--stack->top];
+}
+
+static void *
+bucket_stack_pop(struct bucket_stack *stack)
+{
+ if (stack->top == 0)
+ return NULL;
+ return bucket_stack_pop_unsafe(stack);
+}
+
+static int
+bucket_enqueue_single(struct bucket_data *bd, void *obj)
+{
+ int rc = 0;
+ uintptr_t addr = (uintptr_t)obj;
+ struct bucket_header *hdr;
+ unsigned int lcore_id = rte_lcore_id();
+
+ addr &= bd->bucket_page_mask;
+ hdr = (struct bucket_header *)addr;
+
+ if (likely(hdr->lcore_id == lcore_id)) {
+ if (hdr->fill_cnt < bd->obj_per_bucket - 1) {
+ hdr->fill_cnt++;
+ } else {
+ hdr->fill_cnt = 0;
+ /* Stack is big enough to put all buckets */
+ bucket_stack_push(bd->buckets[lcore_id], hdr);
+ }
+ } else if (hdr->lcore_id != LCORE_ID_ANY) {
+ struct rte_ring *adopt_ring =
+ bd->adoption_buffer_rings[hdr->lcore_id];
+
+ rc = rte_ring_enqueue(adopt_ring, obj);
+ /* Ring is big enough to put all objects */
+ RTE_ASSERT(rc == 0);
+ } else if (hdr->fill_cnt < bd->obj_per_bucket - 1) {
+ hdr->fill_cnt++;
+ } else {
+ hdr->fill_cnt = 0;
+ rc = rte_ring_enqueue(bd->shared_bucket_ring, hdr);
+ /* Ring is big enough to put all buckets */
+ RTE_ASSERT(rc == 0);
+ }
+
+ return rc;
+}
+
+static int
+bucket_enqueue(struct rte_mempool *mp, void * const *obj_table,
+ unsigned int n)
+{
+ struct bucket_data *bd = mp->pool_data;
+ unsigned int i;
+ int rc = 0;
+
+ for (i = 0; i < n; i++) {
+ rc = bucket_enqueue_single(bd, obj_table[i]);
+ RTE_ASSERT(rc == 0);
+ }
+ return rc;
+}
+
+static void **
+bucket_fill_obj_table(const struct bucket_data *bd, void **pstart,
+ void **obj_table, unsigned int n)
+{
+ unsigned int i;
+ uint8_t *objptr = *pstart;
+
+ for (objptr += bd->header_size, i = 0; i < n;
+ i++, objptr += bd->total_elt_size)
+ *obj_table++ = objptr;
+ *pstart = objptr;
+ return obj_table;
+}
+
+static int
+bucket_dequeue_orphans(struct bucket_data *bd, void **obj_table,
+ unsigned int n_orphans)
+{
+ unsigned int i;
+ int rc;
+ uint8_t *objptr;
+
+ rc = rte_ring_dequeue_bulk(bd->shared_orphan_ring, obj_table,
+ n_orphans, NULL);
+ if (unlikely(rc != (int)n_orphans)) {
+ struct bucket_header *hdr;
+
+ objptr = bucket_stack_pop(bd->buckets[rte_lcore_id()]);
+ hdr = (struct bucket_header *)objptr;
+
+ if (objptr == NULL) {
+ rc = rte_ring_dequeue(bd->shared_bucket_ring,
+ (void **)&objptr);
+ if (rc != 0) {
+ rte_errno = ENOBUFS;
+ return -rte_errno;
+ }
+ hdr = (struct bucket_header *)objptr;
+ hdr->lcore_id = rte_lcore_id();
+ }
+ hdr->fill_cnt = 0;
+ bucket_fill_obj_table(bd, (void **)&objptr, obj_table,
+ n_orphans);
+ for (i = n_orphans; i < bd->obj_per_bucket; i++,
+ objptr += bd->total_elt_size) {
+ rc = rte_ring_enqueue(bd->shared_orphan_ring,
+ objptr);
+ if (rc != 0) {
+ RTE_ASSERT(0);
+ rte_errno = -rc;
+ return rc;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int
+bucket_dequeue_buckets(struct bucket_data *bd, void **obj_table,
+ unsigned int n_buckets)
+{
+ struct bucket_stack *cur_stack = bd->buckets[rte_lcore_id()];
+ unsigned int n_buckets_from_stack = RTE_MIN(n_buckets, cur_stack->top);
+ void **obj_table_base = obj_table;
+
+ n_buckets -= n_buckets_from_stack;
+ while (n_buckets_from_stack-- > 0) {
+ void *obj = bucket_stack_pop_unsafe(cur_stack);
+
+ obj_table = bucket_fill_obj_table(bd, &obj, obj_table,
+ bd->obj_per_bucket);
+ }
+ while (n_buckets-- > 0) {
+ struct bucket_header *hdr;
+
+ if (unlikely(rte_ring_dequeue(bd->shared_bucket_ring,
+ (void **)&hdr) != 0)) {
+ /*
+ * Return the already-dequeued buffers
+ * back to the mempool
+ */
+ bucket_enqueue(bd->pool, obj_table_base,
+ obj_table - obj_table_base);
+ rte_errno = ENOBUFS;
+ return -rte_errno;
+ }
+ hdr->lcore_id = rte_lcore_id();
+ obj_table = bucket_fill_obj_table(bd, (void **)&hdr,
+ obj_table,
+ bd->obj_per_bucket);
+ }
+
+ return 0;
+}
+
+static int
+bucket_adopt_orphans(struct bucket_data *bd)
+{
+ int rc = 0;
+ struct rte_ring *adopt_ring =
+ bd->adoption_buffer_rings[rte_lcore_id()];
+
+ if (unlikely(!rte_ring_empty(adopt_ring))) {
+ void *orphan;
+
+ while (rte_ring_sc_dequeue(adopt_ring, &orphan) == 0) {
+ rc = bucket_enqueue_single(bd, orphan);
+ RTE_ASSERT(rc == 0);
+ }
+ }
+ return rc;
+}
+
+static int
+bucket_dequeue(struct rte_mempool *mp, void **obj_table, unsigned int n)
+{
+ struct bucket_data *bd = mp->pool_data;
+ unsigned int n_buckets = n / bd->obj_per_bucket;
+ unsigned int n_orphans = n - n_buckets * bd->obj_per_bucket;
+ int rc = 0;
+
+ bucket_adopt_orphans(bd);
+
+ if (unlikely(n_orphans > 0)) {
+ rc = bucket_dequeue_orphans(bd, obj_table +
+ (n_buckets * bd->obj_per_bucket),
+ n_orphans);
+ if (rc != 0)
+ return rc;
+ }
+
+ if (likely(n_buckets > 0)) {
+ rc = bucket_dequeue_buckets(bd, obj_table, n_buckets);
+ if (unlikely(rc != 0) && n_orphans > 0) {
+ rte_ring_enqueue_bulk(bd->shared_orphan_ring,
+ obj_table + (n_buckets *
+ bd->obj_per_bucket),
+ n_orphans, NULL);
+ }
+ }
+
+ return rc;
+}
+
+static void
+count_underfilled_buckets(struct rte_mempool *mp,
+ void *opaque,
+ struct rte_mempool_memhdr *memhdr,
+ __rte_unused unsigned int mem_idx)
+{
+ unsigned int *pcount = opaque;
+ const struct bucket_data *bd = mp->pool_data;
+ unsigned int bucket_page_sz =
+ (unsigned int)(~bd->bucket_page_mask + 1);
+ uintptr_t align;
+ uint8_t *iter;
+
+ align = (uintptr_t)RTE_PTR_ALIGN_CEIL(memhdr->addr, bucket_page_sz) -
+ (uintptr_t)memhdr->addr;
+
+ for (iter = (uint8_t *)memhdr->addr + align;
+ iter < (uint8_t *)memhdr->addr + memhdr->len;
+ iter += bucket_page_sz) {
+ struct bucket_header *hdr = (struct bucket_header *)iter;
+
+ *pcount += hdr->fill_cnt;
+ }
+}
+
+static unsigned int
+bucket_get_count(const struct rte_mempool *mp)
+{
+ const struct bucket_data *bd = mp->pool_data;
+ unsigned int count =
+ bd->obj_per_bucket * rte_ring_count(bd->shared_bucket_ring) +
+ rte_ring_count(bd->shared_orphan_ring);
+ unsigned int i;
+
+ for (i = 0; i < RTE_MAX_LCORE; i++) {
+ if (!rte_lcore_is_enabled(i))
+ continue;
+ count += bd->obj_per_bucket * bd->buckets[i]->top;
+ }
+
+ rte_mempool_mem_iter((struct rte_mempool *)(uintptr_t)mp,
+ count_underfilled_buckets, &count);
+
+ return count;
+}
+
+static int
+bucket_alloc(struct rte_mempool *mp)
+{
+ int rg_flags = 0;
+ int rc = 0;
+ char rg_name[RTE_RING_NAMESIZE];
+ struct bucket_data *bd;
+ unsigned int i;
+ unsigned int bucket_header_size;
+
+ bd = rte_zmalloc_socket("bucket_pool", sizeof(*bd),
+ RTE_CACHE_LINE_SIZE, mp->socket_id);
+ if (bd == NULL) {
+ rc = -ENOMEM;
+ goto no_mem_for_data;
+ }
+ bd->pool = mp;
+ if (mp->flags & MEMPOOL_F_NO_CACHE_ALIGN)
+ bucket_header_size = sizeof(struct bucket_header);
+ else
+ bucket_header_size = RTE_CACHE_LINE_SIZE;
+ RTE_BUILD_BUG_ON(sizeof(struct bucket_header) > RTE_CACHE_LINE_SIZE);
+ bd->header_size = mp->header_size + bucket_header_size;
+ bd->total_elt_size = mp->header_size + mp->elt_size + mp->trailer_size;
+ bd->bucket_mem_size = RTE_DRIVER_MEMPOOL_BUCKET_SIZE_KB * 1024;
+ bd->obj_per_bucket = (bd->bucket_mem_size - bucket_header_size) /
+ bd->total_elt_size;
+ bd->bucket_page_mask = ~(rte_align64pow2(bd->bucket_mem_size) - 1);
+
+ if (mp->flags & MEMPOOL_F_SP_PUT)
+ rg_flags |= RING_F_SP_ENQ;
+ if (mp->flags & MEMPOOL_F_SC_GET)
+ rg_flags |= RING_F_SC_DEQ;
+
+ for (i = 0; i < RTE_MAX_LCORE; i++) {
+ if (!rte_lcore_is_enabled(i))
+ continue;
+ bd->buckets[i] =
+ bucket_stack_create(mp, mp->size / bd->obj_per_bucket);
+ if (bd->buckets[i] == NULL) {
+ rc = -ENOMEM;
+ goto no_mem_for_stacks;
+ }
+ rc = snprintf(rg_name, sizeof(rg_name),
+ RTE_MEMPOOL_MZ_FORMAT ".a%u", mp->name, i);
+ if (rc < 0 || rc >= (int)sizeof(rg_name)) {
+ rc = -ENAMETOOLONG;
+ goto no_mem_for_stacks;
+ }
+ bd->adoption_buffer_rings[i] =
+ rte_ring_create(rg_name, rte_align32pow2(mp->size + 1),
+ mp->socket_id,
+ rg_flags | RING_F_SC_DEQ);
+ if (bd->adoption_buffer_rings[i] == NULL) {
+ rc = -rte_errno;
+ goto no_mem_for_stacks;
+ }
+ }
+
+ rc = snprintf(rg_name, sizeof(rg_name),
+ RTE_MEMPOOL_MZ_FORMAT ".0", mp->name);
+ if (rc < 0 || rc >= (int)sizeof(rg_name)) {
+ rc = -ENAMETOOLONG;
+ goto invalid_shared_orphan_ring;
+ }
+ bd->shared_orphan_ring =
+ rte_ring_create(rg_name, rte_align32pow2(mp->size + 1),
+ mp->socket_id, rg_flags);
+ if (bd->shared_orphan_ring == NULL) {
+ rc = -rte_errno;
+ goto cannot_create_shared_orphan_ring;
+ }
+
+ rc = snprintf(rg_name, sizeof(rg_name),
+ RTE_MEMPOOL_MZ_FORMAT ".1", mp->name);
+ if (rc < 0 || rc >= (int)sizeof(rg_name)) {
+ rc = -ENAMETOOLONG;
+ goto invalid_shared_bucket_ring;
+ }
+ bd->shared_bucket_ring =
+ rte_ring_create(rg_name,
+ rte_align32pow2((mp->size + 1) /
+ bd->obj_per_bucket),
+ mp->socket_id, rg_flags);
+ if (bd->shared_bucket_ring == NULL) {
+ rc = -rte_errno;
+ goto cannot_create_shared_bucket_ring;
+ }
+
+ mp->pool_data = bd;
+
+ return 0;
+
+cannot_create_shared_bucket_ring:
+invalid_shared_bucket_ring:
+ rte_ring_free(bd->shared_orphan_ring);
+cannot_create_shared_orphan_ring:
+invalid_shared_orphan_ring:
+no_mem_for_stacks:
+ for (i = 0; i < RTE_MAX_LCORE; i++) {
+ rte_free(bd->buckets[i]);
+ rte_ring_free(bd->adoption_buffer_rings[i]);
+ }
+ rte_free(bd);
+no_mem_for_data:
+ rte_errno = -rc;
+ return rc;
+}
+
+static void
+bucket_free(struct rte_mempool *mp)
+{
+ unsigned int i;
+ struct bucket_data *bd = mp->pool_data;
+
+ if (bd == NULL)
+ return;
+
+ for (i = 0; i < RTE_MAX_LCORE; i++) {
+ rte_free(bd->buckets[i]);
+ rte_ring_free(bd->adoption_buffer_rings[i]);
+ }
+
+ rte_ring_free(bd->shared_orphan_ring);
+ rte_ring_free(bd->shared_bucket_ring);
+
+ rte_free(bd);
+}
+
+static ssize_t
+bucket_calc_mem_size(const struct rte_mempool *mp, uint32_t obj_num,
+ __rte_unused uint32_t pg_shift, size_t *min_total_elt_size,
+ size_t *align)
+{
+ struct bucket_data *bd = mp->pool_data;
+ unsigned int bucket_page_sz;
+
+ if (bd == NULL)
+ return -EINVAL;
+
+ bucket_page_sz = rte_align32pow2(bd->bucket_mem_size);
+ *align = bucket_page_sz;
+ *min_total_elt_size = bucket_page_sz;
+ /*
+ * Each bucket occupies its own block aligned to
+ * bucket_page_sz, so the required amount of memory is
+ * a multiple of bucket_page_sz.
+ * We also need extra space for a bucket header
+ */
+ return ((obj_num + bd->obj_per_bucket - 1) /
+ bd->obj_per_bucket) * bucket_page_sz;
+}
+
+static int
+bucket_populate(struct rte_mempool *mp, unsigned int max_objs,
+ void *vaddr, rte_iova_t iova, size_t len,
+ rte_mempool_populate_obj_cb_t *obj_cb)
+{
+ struct bucket_data *bd = mp->pool_data;
+ unsigned int bucket_page_sz;
+ unsigned int bucket_header_sz;
+ unsigned int n_objs;
+ uintptr_t align;
+ uint8_t *iter;
+ int rc;
+
+ if (bd == NULL)
+ return -EINVAL;
+
+ bucket_page_sz = rte_align32pow2(bd->bucket_mem_size);
+ align = RTE_PTR_ALIGN_CEIL((uintptr_t)vaddr, bucket_page_sz) -
+ (uintptr_t)vaddr;
+
+ bucket_header_sz = bd->header_size - mp->header_size;
+ if (iova != RTE_BAD_IOVA)
+ iova += align + bucket_header_sz;
+
+ for (iter = (uint8_t *)vaddr + align, n_objs = 0;
+ iter < (uint8_t *)vaddr + len && n_objs < max_objs;
+ iter += bucket_page_sz) {
+ struct bucket_header *hdr = (struct bucket_header *)iter;
+ unsigned int chunk_len = bd->bucket_mem_size;
+
+ if ((size_t)(iter - (uint8_t *)vaddr) + chunk_len > len)
+ chunk_len = len - (iter - (uint8_t *)vaddr);
+ if (chunk_len <= bucket_header_sz)
+ break;
+ chunk_len -= bucket_header_sz;
+
+ hdr->fill_cnt = 0;
+ hdr->lcore_id = LCORE_ID_ANY;
+ rc = rte_mempool_populate_one_by_one(mp,
+ RTE_MIN(bd->obj_per_bucket,
+ max_objs - n_objs),
+ iter + bucket_header_sz,
+ iova, chunk_len, obj_cb);
+ if (rc < 0)
+ return rc;
+ n_objs += rc;
+ if (iova != RTE_BAD_IOVA)
+ iova += bucket_page_sz;
+ }
+
+ return n_objs;
+}
+
+static const struct rte_mempool_ops ops_bucket = {
+ .name = "bucket",
+ .alloc = bucket_alloc,
+ .free = bucket_free,
+ .enqueue = bucket_enqueue,
+ .dequeue = bucket_dequeue,
+ .get_count = bucket_get_count,
+ .calc_mem_size = bucket_calc_mem_size,
+ .populate = bucket_populate,
+};
+
+
+MEMPOOL_REGISTER_OPS(ops_bucket);
diff --git a/drivers/mempool/bucket/rte_mempool_bucket_version.map b/drivers/mempool/bucket/rte_mempool_bucket_version.map
new file mode 100644
index 0000000..9b9ab1a
--- /dev/null
+++ b/drivers/mempool/bucket/rte_mempool_bucket_version.map
@@ -0,0 +1,4 @@
+DPDK_18.05 {
+
+ local: *;
+};
diff --git a/mk/rte.app.mk b/mk/rte.app.mk
index 0169f3f..405785d 100644
--- a/mk/rte.app.mk
+++ b/mk/rte.app.mk
@@ -116,6 +116,7 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_VDEV_BUS) += -lrte_bus_vdev
ifeq ($(CONFIG_RTE_BUILD_SHARED_LIB),n)
# plugins (link only if static libraries)
+_LDLIBS-$(CONFIG_RTE_DRIVER_MEMPOOL_BUCKET) += -lrte_mempool_bucket
_LDLIBS-$(CONFIG_RTE_DRIVER_MEMPOOL_STACK) += -lrte_mempool_stack
_LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_AF_PACKET) += -lrte_pmd_af_packet
--
2.7.4
next prev parent reply other threads:[~2018-01-23 13:16 UTC|newest]
Thread overview: 197+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-11-24 16:06 [dpdk-dev] [RFC PATCH 0/6] mempool: add bucket mempool driver Andrew Rybchenko
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 1/6] mempool: implement abstract mempool info API Andrew Rybchenko
2017-12-14 13:36 ` Olivier MATZ
2018-01-17 15:03 ` Andrew Rybchenko
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 2/6] mempool: implement clustered object allocation Andrew Rybchenko
2017-12-14 13:37 ` Olivier MATZ
2018-01-17 15:03 ` Andrew Rybchenko
2018-01-17 15:55 ` santosh
2018-01-17 16:37 ` Andrew Rybchenko
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 3/6] mempool/bucket: implement bucket mempool manager Andrew Rybchenko
2017-12-14 13:38 ` Olivier MATZ
2018-01-17 15:06 ` Andrew Rybchenko
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 4/6] mempool: add a function to flush default cache Andrew Rybchenko
2017-12-14 13:38 ` Olivier MATZ
2018-01-17 15:07 ` Andrew Rybchenko
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 5/6] mempool: support block dequeue operation Andrew Rybchenko
2017-12-14 13:38 ` Olivier MATZ
2017-11-24 16:06 ` [dpdk-dev] [RFC PATCH 6/6] mempool/bucket: implement " Andrew Rybchenko
2017-12-14 13:36 ` [dpdk-dev] [RFC PATCH 0/6] mempool: add bucket mempool driver Olivier MATZ
2018-01-17 15:03 ` Andrew Rybchenko
2018-01-23 13:15 ` [dpdk-dev] [RFC v2 00/17] " Andrew Rybchenko
2018-01-23 13:15 ` [dpdk-dev] [RFC v2 01/17] mempool: fix phys contig check if populate default skipped Andrew Rybchenko
2018-01-31 16:45 ` Olivier Matz
2018-02-01 5:05 ` santosh
2018-02-01 6:54 ` Andrew Rybchenko
2018-02-01 9:09 ` santosh
2018-02-01 9:18 ` Andrew Rybchenko
2018-02-01 9:30 ` santosh
2018-02-01 10:00 ` Andrew Rybchenko
2018-02-01 10:14 ` Olivier Matz
2018-02-01 10:33 ` santosh
2018-02-01 14:02 ` Andrew Rybchenko
2018-02-01 10:17 ` santosh
2018-02-01 14:02 ` [dpdk-dev] [PATCH] " Andrew Rybchenko
2018-02-05 23:53 ` [dpdk-dev] [dpdk-stable] " Thomas Monjalon
2018-01-23 13:15 ` [dpdk-dev] [RFC v2 02/17] mempool: add op to calculate memory size to be allocated Andrew Rybchenko
2018-01-31 16:45 ` Olivier Matz
2018-02-01 7:15 ` Andrew Rybchenko
2018-01-23 13:15 ` [dpdk-dev] [RFC v2 03/17] mempool/octeontx: add callback to calculate memory size Andrew Rybchenko
[not found] ` <BN3PR07MB2513732462EB5FE5E1B05713E3FA0@BN3PR07MB2513.namprd07.prod.outlook.com>
2018-02-01 10:01 ` santosh
2018-02-01 13:40 ` santosh
2018-03-10 15:49 ` Andrew Rybchenko
2018-03-11 6:31 ` santosh
2018-01-23 13:15 ` [dpdk-dev] [RFC v2 04/17] mempool: add op to populate objects using provided memory Andrew Rybchenko
2018-01-31 16:45 ` Olivier Matz
2018-02-01 8:51 ` Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 05/17] mempool/octeontx: implement callback to populate objects Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 06/17] mempool: remove callback to get capabilities Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 07/17] mempool: deprecate xmem functions Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 08/17] mempool/octeontx: prepare to remove register memory area op Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 09/17] mempool/dpaa: convert to use populate driver op Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 10/17] mempool: remove callback to register memory area Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 11/17] mempool: ensure the mempool is initialized before populating Andrew Rybchenko
2018-01-31 16:45 ` Olivier Matz
2018-02-01 8:53 ` Andrew Rybchenko
2018-01-23 13:16 ` Andrew Rybchenko [this message]
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 13/17] mempool: support flushing the default cache of the mempool Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 14/17] mempool: implement abstract mempool info API Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 15/17] mempool: support block dequeue operation Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 16/17] mempool/bucket: implement " Andrew Rybchenko
2018-01-23 13:16 ` [dpdk-dev] [RFC v2 17/17] mempool/bucket: do not allow one lcore to grab all buckets Andrew Rybchenko
2018-01-31 16:44 ` [dpdk-dev] [RFC v2 00/17] mempool: add bucket mempool driver Olivier Matz
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 0/9] mempool: prepare to add bucket driver Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 1/9] mempool: add op to calculate memory size to be allocated Andrew Rybchenko
2018-03-11 12:51 ` santosh
2018-03-12 6:53 ` Andrew Rybchenko
2018-03-19 17:03 ` Olivier Matz
2018-03-20 10:29 ` Andrew Rybchenko
2018-03-20 14:41 ` Bruce Richardson
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 2/9] mempool: add op to populate objects using provided memory Andrew Rybchenko
2018-03-19 17:04 ` Olivier Matz
2018-03-21 7:05 ` Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 3/9] mempool: remove callback to get capabilities Andrew Rybchenko
2018-03-14 14:40 ` Burakov, Anatoly
2018-03-14 16:12 ` Andrew Rybchenko
2018-03-14 16:53 ` Burakov, Anatoly
2018-03-14 17:24 ` Andrew Rybchenko
2018-03-15 9:48 ` Burakov, Anatoly
2018-03-15 11:49 ` Andrew Rybchenko
2018-03-15 12:00 ` Burakov, Anatoly
2018-03-15 12:44 ` Andrew Rybchenko
2018-03-19 17:05 ` Olivier Matz
2018-03-19 17:06 ` Olivier Matz
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 4/9] mempool: deprecate xmem functions Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 5/9] mempool/octeontx: prepare to remove register memory area op Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 6/9] mempool/dpaa: " Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 7/9] mempool: remove callback to register memory area Andrew Rybchenko
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 8/9] mempool: ensure the mempool is initialized before populating Andrew Rybchenko
2018-03-19 17:06 ` Olivier Matz
2018-03-20 13:32 ` Andrew Rybchenko
2018-03-20 16:57 ` Olivier Matz
2018-03-10 15:39 ` [dpdk-dev] [PATCH v1 9/9] mempool: support flushing the default cache of the mempool Andrew Rybchenko
2018-03-14 15:49 ` [dpdk-dev] [PATCH v1 0/9] mempool: prepare to add bucket driver santosh
2018-03-14 15:57 ` Andrew Rybchenko
2018-03-19 17:03 ` Olivier Matz
2018-03-20 10:09 ` Andrew Rybchenko
2018-03-20 11:04 ` Thomas Monjalon
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 00/11] " Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 01/11] mempool: fix memhdr leak when no objects are populated Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 02/11] mempool: rename flag to control IOVA-contiguous objects Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 03/11] mempool: ensure the mempool is initialized before populating Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 04/11] mempool: add op to calculate memory size to be allocated Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 05/11] mempool: add op to populate objects using provided memory Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 06/11] mempool: remove callback to get capabilities Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 07/11] mempool: deprecate xmem functions Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 08/11] mempool/octeontx: prepare to remove register memory area op Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 09/11] mempool/dpaa: " Andrew Rybchenko
2018-03-26 7:13 ` Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 10/11] mempool: remove callback to register memory area Andrew Rybchenko
2018-03-25 16:20 ` [dpdk-dev] [PATCH v2 11/11] mempool: support flushing the default cache of the mempool Andrew Rybchenko
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 00/11] mempool: prepare to add bucket driver Andrew Rybchenko
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 01/11] mempool: fix memhdr leak when no objects are populated Andrew Rybchenko
2018-04-06 15:50 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 02/11] mempool: rename flag to control IOVA-contiguous objects Andrew Rybchenko
2018-04-06 15:50 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 03/11] mempool: ensure the mempool is initialized before populating Andrew Rybchenko
2018-04-04 15:06 ` santosh
2018-04-06 15:50 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 04/11] mempool: add op to calculate memory size to be allocated Andrew Rybchenko
2018-04-04 15:08 ` santosh
2018-04-06 15:51 ` Olivier Matz
2018-04-12 15:22 ` Burakov, Anatoly
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 05/11] mempool: add op to populate objects using provided memory Andrew Rybchenko
2018-04-04 15:09 ` santosh
2018-04-06 15:51 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 06/11] mempool: remove callback to get capabilities Andrew Rybchenko
2018-04-04 15:10 ` santosh
2018-04-06 15:51 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 07/11] mempool: deprecate xmem functions Andrew Rybchenko
2018-04-06 15:52 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 08/11] mempool/octeontx: prepare to remove register memory area op Andrew Rybchenko
2018-04-04 15:12 ` santosh
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 09/11] mempool/dpaa: " Andrew Rybchenko
2018-04-05 8:25 ` Hemant Agrawal
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 10/11] mempool: remove callback to register memory area Andrew Rybchenko
2018-04-04 15:13 ` santosh
2018-04-06 15:52 ` Olivier Matz
2018-03-26 16:09 ` [dpdk-dev] [PATCH v3 11/11] mempool: support flushing the default cache of the mempool Andrew Rybchenko
2018-04-06 15:53 ` Olivier Matz
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 0/6] mempool: add bucket driver Andrew Rybchenko
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 1/6] mempool/bucket: implement bucket mempool manager Andrew Rybchenko
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 2/6] mempool: implement abstract mempool info API Andrew Rybchenko
2018-04-19 16:42 ` Olivier Matz
2018-04-25 9:57 ` Andrew Rybchenko
2018-04-25 10:26 ` Olivier Matz
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 3/6] mempool: support block dequeue operation Andrew Rybchenko
2018-04-19 16:41 ` Olivier Matz
2018-04-25 9:49 ` Andrew Rybchenko
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 4/6] mempool/bucket: implement " Andrew Rybchenko
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 5/6] mempool/bucket: do not allow one lcore to grab all buckets Andrew Rybchenko
2018-03-26 16:12 ` [dpdk-dev] [PATCH v1 6/6] doc: advertise bucket mempool driver Andrew Rybchenko
2018-04-19 16:43 ` Olivier Matz
2018-04-19 16:41 ` [dpdk-dev] [PATCH v1 0/6] mempool: add bucket driver Olivier Matz
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 00/11] mempool: prepare to " Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 01/11] mempool: fix memhdr leak when no objects are populated Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 02/11] mempool: rename flag to control IOVA-contiguous objects Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 03/11] mempool: ensure the mempool is initialized before populating Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 04/11] mempool: add op to calculate memory size to be allocated Andrew Rybchenko
2018-04-16 15:33 ` Olivier Matz
2018-04-16 15:41 ` Andrew Rybchenko
2018-04-17 10:23 ` Burakov, Anatoly
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 05/11] mempool: add op to populate objects using provided memory Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 06/11] mempool: remove callback to get capabilities Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 07/11] mempool: deprecate xmem functions Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 08/11] mempool/octeontx: prepare to remove register memory area op Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 09/11] mempool/dpaa: " Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 10/11] mempool: remove callback to register memory area Andrew Rybchenko
2018-04-16 13:24 ` [dpdk-dev] [PATCH v4 11/11] mempool: support flushing the default cache of the mempool Andrew Rybchenko
2018-04-24 0:20 ` [dpdk-dev] [PATCH v4 00/11] mempool: prepare to add bucket driver Thomas Monjalon
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 0/6] mempool: " Andrew Rybchenko
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 1/6] mempool/bucket: implement bucket mempool manager Andrew Rybchenko
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 2/6] mempool: implement abstract mempool info API Andrew Rybchenko
2018-04-25 8:44 ` Olivier Matz
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 3/6] mempool: support block dequeue operation Andrew Rybchenko
2018-04-25 8:45 ` Olivier Matz
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 4/6] mempool/bucket: implement " Andrew Rybchenko
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 5/6] mempool/bucket: do not allow one lcore to grab all buckets Andrew Rybchenko
2018-04-16 13:33 ` [dpdk-dev] [PATCH v2 6/6] doc: advertise bucket mempool driver Andrew Rybchenko
2018-04-24 23:00 ` [dpdk-dev] [PATCH v2 0/6] mempool: add bucket driver Thomas Monjalon
2018-04-25 8:43 ` Olivier Matz
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 " Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 1/6] mempool/bucket: implement bucket mempool manager Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 2/6] mempool: implement abstract mempool info API Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 3/6] mempool: support block dequeue operation Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 4/6] mempool/bucket: implement " Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 5/6] mempool/bucket: do not allow one lcore to grab all buckets Andrew Rybchenko
2018-04-25 16:32 ` [dpdk-dev] [PATCH v3 6/6] doc: advertise bucket mempool driver Andrew Rybchenko
2018-04-25 21:56 ` Thomas Monjalon
2018-04-25 22:04 ` Thomas Monjalon
2018-04-26 9:50 ` Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 0/5] mempool: add bucket driver Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 1/5] mempool/bucket: implement bucket mempool manager Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 2/5] mempool: implement abstract mempool info API Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 3/5] mempool: support block dequeue operation Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 4/5] mempool/bucket: implement " Andrew Rybchenko
2018-04-26 10:59 ` [dpdk-dev] [PATCH v4 5/5] mempool/bucket: do not allow one lcore to grab all buckets Andrew Rybchenko
2018-04-26 21:35 ` [dpdk-dev] [PATCH v4 0/5] mempool: add bucket driver Thomas Monjalon
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1516713372-10572-13-git-send-email-arybchenko@solarflare.com \
--to=arybchenko@solarflare.com \
--cc=Artem.Andreev@oktetlabs.ru \
--cc=dev@dpdk.org \
--cc=olivier.matz@6wind.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).