d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mempool: add non-IO flag

Browse Source 
Mempool is a generic allocator that is not necessarily used
for device IO operations and its memory for DMA.
Add MEMPOOL_F_NON_IO flag to mark such mempools automatically
a) if their objects are not contiguous;
b) if IOVA is not available for any object.
Other components can inspect this flag
in order to optimize their memory management.

Discussion: https://mails.dpdk.org/archives/dev/2021-August/216654.html

Signed-off-by: Dmitry Kozlyuk <dkozlyuk@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
Reviewed-by: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>
This commit is contained in:
Dmitry Kozlyuk 2021-10-19 01:43:51 +03:00 committed by Thomas Monjalon
parent da2b9cb25e
commit 11541c5c81
5 changed files with 134 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/proc-info/main.c
View File

@ -1295,7 +1295,8 @@ show_mempool(char *name)
"\t -- No cache align (%c)\n"
"\t -- SP put (%c), SC get (%c)\n"
"\t -- Pool created (%c)\n"
"\t -- No IOVA config (%c)\n",
"\t -- No IOVA config (%c)\n"
"\t -- Not used for IO (%c)\n",
ptr->name,
ptr->socket_id,
(flags & MEMPOOL_F_NO_SPREAD) ? 'y' : 'n',
@ -1303,7 +1304,8 @@ show_mempool(char *name)
(flags & MEMPOOL_F_SP_PUT) ? 'y' : 'n',
(flags & MEMPOOL_F_SC_GET) ? 'y' : 'n',
(flags & MEMPOOL_F_POOL_CREATED) ? 'y' : 'n',
(flags & MEMPOOL_F_NO_IOVA_CONTIG) ? 'y' : 'n');
(flags & MEMPOOL_F_NO_IOVA_CONTIG) ? 'y' : 'n',
(flags & MEMPOOL_F_NON_IO) ? 'y' : 'n');
printf(" - Size %u Cache %u element %u\n"
" - header %u trailer %u\n"
" - private data size %u\n",

115
app/test/test_mempool.c
View File

@ -12,6 +12,7 @@
#include <sys/queue.h>
#include <rte_common.h>
#include <rte_eal_paging.h>
#include <rte_log.h>
#include <rte_debug.h>
#include <rte_errno.h>
@ -729,6 +730,112 @@ test_mempool_events_safety(void)
#pragma pop_macro("RTE_TEST_TRACE_FAILURE")
}
#pragma push_macro("RTE_TEST_TRACE_FAILURE")
#undef RTE_TEST_TRACE_FAILURE
#define RTE_TEST_TRACE_FAILURE(...) do { \
ret = TEST_FAILED; \
goto exit; \
} while (0)
static int
test_mempool_flag_non_io_set_when_no_iova_contig_set(void)
{
struct rte_mempool *mp = NULL;
int ret;
mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
MEMPOOL_ELT_SIZE, 0, 0,
SOCKET_ID_ANY, MEMPOOL_F_NO_IOVA_CONTIG);
RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
rte_strerror(rte_errno));
rte_mempool_set_ops_byname(mp, rte_mbuf_best_mempool_ops(), NULL);
ret = rte_mempool_populate_default(mp);
RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
rte_strerror(-ret));
RTE_TEST_ASSERT(mp->flags & MEMPOOL_F_NON_IO,
"NON_IO flag is not set when NO_IOVA_CONTIG is set");
ret = TEST_SUCCESS;
exit:
rte_mempool_free(mp);
return ret;
}
static int
test_mempool_flag_non_io_unset_when_populated_with_valid_iova(void)
{
void *virt = NULL;
rte_iova_t iova;
size_t total_size = MEMPOOL_ELT_SIZE * MEMPOOL_SIZE;
size_t block_size = total_size / 3;
struct rte_mempool *mp = NULL;
int ret;
/*
* Since objects from the pool are never used in the test,
* we don't care for contiguous IOVA, on the other hand,
* reiuring it could cause spurious test failures.
*/
virt = rte_malloc("test_mempool", total_size, rte_mem_page_size());
RTE_TEST_ASSERT_NOT_NULL(virt, "Cannot allocate memory");
iova = rte_mem_virt2iova(virt);
RTE_TEST_ASSERT_NOT_EQUAL(iova, RTE_BAD_IOVA, "Cannot get IOVA");
mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
MEMPOOL_ELT_SIZE, 0, 0,
SOCKET_ID_ANY, 0);
RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
rte_strerror(rte_errno));
ret = rte_mempool_populate_iova(mp, RTE_PTR_ADD(virt, 1 * block_size),
RTE_BAD_IOVA, block_size, NULL, NULL);
RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
rte_strerror(-ret));
RTE_TEST_ASSERT(mp->flags & MEMPOOL_F_NON_IO,
"NON_IO flag is not set when mempool is populated with only RTE_BAD_IOVA");
ret = rte_mempool_populate_iova(mp, virt, iova, block_size, NULL, NULL);
RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
rte_strerror(-ret));
RTE_TEST_ASSERT(!(mp->flags & MEMPOOL_F_NON_IO),
"NON_IO flag is not unset when mempool is populated with valid IOVA");
ret = rte_mempool_populate_iova(mp, RTE_PTR_ADD(virt, 2 * block_size),
RTE_BAD_IOVA, block_size, NULL, NULL);
RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
rte_strerror(-ret));
RTE_TEST_ASSERT(!(mp->flags & MEMPOOL_F_NON_IO),
"NON_IO flag is set even when some objects have valid IOVA");
ret = TEST_SUCCESS;
exit:
rte_mempool_free(mp);
rte_free(virt);
return ret;
}
static int
test_mempool_flag_non_io_unset_by_default(void)
{
struct rte_mempool *mp;
int ret;
mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
MEMPOOL_ELT_SIZE, 0, 0,
SOCKET_ID_ANY, 0);
RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
rte_strerror(rte_errno));
ret = rte_mempool_populate_default(mp);
RTE_TEST_ASSERT_EQUAL(ret, (int)mp->size, "Failed to populate mempool: %s",
rte_strerror(-ret));
RTE_TEST_ASSERT(!(mp->flags & MEMPOOL_F_NON_IO),
"NON_IO flag is set by default");
ret = TEST_SUCCESS;
exit:
rte_mempool_free(mp);
return ret;
}
#pragma pop_macro("RTE_TEST_TRACE_FAILURE")
static int
test_mempool(void)
{
@ -914,6 +1021,14 @@ test_mempool(void)
if (test_mempool_events_safety() < 0)
GOTO_ERR(ret, err);
/* test NON_IO flag inference */
if (test_mempool_flag_non_io_unset_by_default() < 0)
GOTO_ERR(ret, err);
if (test_mempool_flag_non_io_set_when_no_iova_contig_set() < 0)
GOTO_ERR(ret, err);
if (test_mempool_flag_non_io_unset_when_populated_with_valid_iova() < 0)
GOTO_ERR(ret, err);
rte_mempool_list_dump(stdout);
ret = 0;

3
doc/guides/rel_notes/release_21_11.rst
View File

@ -221,6 +221,9 @@ API Changes
removed. Its usages have been replaced by a new function
``rte_kvargs_get_with_value()``.
* mempool: Added ``MEMPOOL_F_NON_IO`` flag to give a hint to DPDK components
that objects from this pool will not be used for device IO (e.g. DMA).
* net: Renamed ``s_addr`` and ``d_addr`` fields of ``rte_ether_hdr`` structure
to ``src_addr`` and ``dst_addr``, respectively.

10
lib/mempool/rte_mempool.c
View File

@ -372,6 +372,10 @@ rte_mempool_populate_iova(struct rte_mempool *mp, char *vaddr,
STAILQ_INSERT_TAIL(&mp->mem_list, memhdr, next);
mp->nb_mem_chunks++;
/* At least some objects in the pool can now be used for IO. */
if (iova != RTE_BAD_IOVA)
mp->flags &= ~MEMPOOL_F_NON_IO;
/* Report the mempool as ready only when fully populated. */
if (mp->populated_size >= mp->size)
mempool_event_callback_invoke(RTE_MEMPOOL_EVENT_READY, mp);
@ -851,6 +855,12 @@ rte_mempool_create_empty(const char *name, unsigned n, unsigned elt_size,
return NULL;
}
/*
* No objects in the pool can be used for IO until it's populated
* with at least some objects with valid IOVA.
*/
flags |= MEMPOOL_F_NON_IO;
/* "no cache align" imply "no spread" */
if (flags & MEMPOOL_F_NO_CACHE_ALIGN)
flags |= MEMPOOL_F_NO_SPREAD;

2
lib/mempool/rte_mempool.h
View File

@ -257,6 +257,8 @@ struct rte_mempool {
#define MEMPOOL_F_SC_GET 0x0008 /**< Default get is "single-consumer".*/
#define MEMPOOL_F_POOL_CREATED 0x0010 /**< Internal: pool is created. */
#define MEMPOOL_F_NO_IOVA_CONTIG 0x0020 /**< Don't need IOVA contiguous objs. */
/** Internal: no object from the pool can be used for device IO (DMA). */
#define MEMPOOL_F_NON_IO 0x0040
/**
* @internal When debug is enabled, store some statistics.