From: Jim Harris Date: Fri, 14 Dec 2018 17:13:03 +0000 (-0700) Subject: malloc: add option --match-allocations X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=476c847ab6755d233dd786e8b87970c7105fbce2;p=dpdk.git malloc: add option --match-allocations SPDK uses the rte_mem_event_callback_register API to create RDMA memory regions (MRs) for newly allocated regions of memory. This is used in both the SPDK NVMe-oF target and the NVMe-oF host driver. DPDK creates internal malloc_elem structures for these allocated regions. As users malloc and free memory, DPDK will sometimes merge malloc_elems that originated from different allocations that were notified through the registered mem_event callback routine. This results in subsequent allocations that can span across multiple RDMA MRs. This requires SPDK to check each DPDK buffer to see if it crosses an MR boundary, and if so, would have to add considerable logic and complexity to describe that buffer before it can be accessed by the RNIC. It is somewhat analagous to rte_malloc returning a buffer that is not IOVA-contiguous. As a malloc_elem gets split and some of these elements get freed, it can also result in DPDK sending an RTE_MEM_EVENT_FREE notification for a subset of the original RTE_MEM_EVENT_ALLOC notification. This is also problematic for RDMA memory regions, since unregistering the memory region is all-or-nothing. It is not possible to unregister part of a memory region. To support these types of applications, this patch adds a new --match-allocations EAL init flag. When this flag is specified, malloc elements from different hugepage allocations will never be merged. Memory will also only be freed back to the system (with the requisite memory event callback) exactly as it was originally allocated. Since part of this patch is extending the size of struct malloc_elem, we also fix up the malloc autotests so they do not assume its size exactly fits in one cacheline. Signed-off-by: Jim Harris Reviewed-by: Anatoly Burakov --- diff --git a/doc/guides/linux_gsg/linux_eal_parameters.rst b/doc/guides/linux_gsg/linux_eal_parameters.rst index 28aebfbda2..c63f0f49a0 100644 --- a/doc/guides/linux_gsg/linux_eal_parameters.rst +++ b/doc/guides/linux_gsg/linux_eal_parameters.rst @@ -90,6 +90,10 @@ Memory-related options Unlink hugepage files after creating them (implies no secondary process support). +* ``--match-allocations`` + + Free hugepages back to system exactly as they were originally allocated. + Other options ~~~~~~~~~~~~~ diff --git a/doc/guides/prog_guide/env_abstraction_layer.rst b/doc/guides/prog_guide/env_abstraction_layer.rst index 8b5d050c76..19b470e278 100644 --- a/doc/guides/prog_guide/env_abstraction_layer.rst +++ b/doc/guides/prog_guide/env_abstraction_layer.rst @@ -169,6 +169,20 @@ not allow acquiring or releasing hugepages from the system at runtime. If neither ``-m`` nor ``--socket-mem`` were specified, the entire available hugepage memory will be preallocated. ++ Hugepage allocation matching + +This behavior is enabled by specifying the ``--match-allocations`` command-line +switch to the EAL. This switch is Linux-only and not supported with +``--legacy-mem`` nor ``--no-huge``. + +Some applications using memory event callbacks may require that hugepages be +freed exactly as they were allocated. These applications may also require +that any allocation from the malloc heap not span across allocations +associated with two different memory event callbacks. Hugepage allocation +matching can be used by these types of applications to satisfy both of these +requirements. This can result in some increased memory usage which is +very dependent on the memory allocation patterns of the application. + + 32-bit support Additional restrictions are present when running in 32-bit mode. In dynamic diff --git a/doc/guides/rel_notes/release_19_02.rst b/doc/guides/rel_notes/release_19_02.rst index 069f429a7b..aee93953ec 100644 --- a/doc/guides/rel_notes/release_19_02.rst +++ b/doc/guides/rel_notes/release_19_02.rst @@ -54,6 +54,15 @@ New Features Also, make sure to start the actual text at the margin. ========================================================= +* **Added support to free hugepages exactly as originally allocated.** + + Some applications using memory event callbacks (especially for managing + RDMA memory regions) require that memory be freed back to the system + exactly as it was originally allocated. These applications typically + also require that a malloc allocation not span across two separate + hugepage allocations. A new ``--match-allocations`` EAL init flag has + been added to fulfill both of these requirements. + * **Updated the enic driver.** * Added support for ``RTE_ETH_DEV_CLOSE_REMOVE`` flag. diff --git a/lib/librte_eal/common/eal_common_options.c b/lib/librte_eal/common/eal_common_options.c index e31eca5c03..6e3a83b987 100644 --- a/lib/librte_eal/common/eal_common_options.c +++ b/lib/librte_eal/common/eal_common_options.c @@ -79,6 +79,7 @@ eal_long_options[] = { {OPT_VMWARE_TSC_MAP, 0, NULL, OPT_VMWARE_TSC_MAP_NUM }, {OPT_LEGACY_MEM, 0, NULL, OPT_LEGACY_MEM_NUM }, {OPT_SINGLE_FILE_SEGMENTS, 0, NULL, OPT_SINGLE_FILE_SEGMENTS_NUM}, + {OPT_MATCH_ALLOCATIONS, 0, NULL, OPT_MATCH_ALLOCATIONS_NUM}, {0, 0, NULL, 0 } }; @@ -1424,6 +1425,16 @@ eal_check_common_options(struct internal_config *internal_cfg) "with --"OPT_IN_MEMORY"\n"); return -1; } + if (internal_cfg->legacy_mem && internal_cfg->match_allocations) { + RTE_LOG(ERR, EAL, "Option --"OPT_LEGACY_MEM" is not compatible " + "with --"OPT_MATCH_ALLOCATIONS"\n"); + return -1; + } + if (internal_cfg->no_hugetlbfs && internal_cfg->match_allocations) { + RTE_LOG(ERR, EAL, "Option --"OPT_NO_HUGE" is not compatible " + "with --"OPT_MATCH_ALLOCATIONS"\n"); + return -1; + } return 0; } diff --git a/lib/librte_eal/common/eal_internal_cfg.h b/lib/librte_eal/common/eal_internal_cfg.h index 737f17e353..98e314fef4 100644 --- a/lib/librte_eal/common/eal_internal_cfg.h +++ b/lib/librte_eal/common/eal_internal_cfg.h @@ -57,6 +57,8 @@ struct internal_config { /**< true to enable legacy memory behavior (no dynamic allocation, * IOVA-contiguous segments). */ + volatile unsigned match_allocations; + /**< true to free hugepages exactly as allocated */ volatile unsigned single_file_segments; /**< true if storing all pages within single files (per-page-size, * per-node) non-legacy mode only. diff --git a/lib/librte_eal/common/eal_options.h b/lib/librte_eal/common/eal_options.h index 5271f94493..1480c5d77e 100644 --- a/lib/librte_eal/common/eal_options.h +++ b/lib/librte_eal/common/eal_options.h @@ -65,6 +65,8 @@ enum { OPT_SINGLE_FILE_SEGMENTS_NUM, #define OPT_IOVA_MODE "iova-mode" OPT_IOVA_MODE_NUM, +#define OPT_MATCH_ALLOCATIONS "match-allocations" + OPT_MATCH_ALLOCATIONS_NUM, OPT_LONG_MAX_NUM }; diff --git a/lib/librte_eal/common/malloc_elem.c b/lib/librte_eal/common/malloc_elem.c index 9d3dcb6a9e..fcdb18120a 100644 --- a/lib/librte_eal/common/malloc_elem.c +++ b/lib/librte_eal/common/malloc_elem.c @@ -110,7 +110,8 @@ malloc_elem_find_max_iova_contig(struct malloc_elem *elem, size_t align) */ void malloc_elem_init(struct malloc_elem *elem, struct malloc_heap *heap, - struct rte_memseg_list *msl, size_t size) + struct rte_memseg_list *msl, size_t size, + struct malloc_elem *orig_elem, size_t orig_size) { elem->heap = heap; elem->msl = msl; @@ -120,6 +121,8 @@ malloc_elem_init(struct malloc_elem *elem, struct malloc_heap *heap, elem->state = ELEM_FREE; elem->size = size; elem->pad = 0; + elem->orig_elem = orig_elem; + elem->orig_size = orig_size; set_header(elem); set_trailer(elem); } @@ -278,7 +281,8 @@ split_elem(struct malloc_elem *elem, struct malloc_elem *split_pt) const size_t old_elem_size = (uintptr_t)split_pt - (uintptr_t)elem; const size_t new_elem_size = elem->size - old_elem_size; - malloc_elem_init(split_pt, elem->heap, elem->msl, new_elem_size); + malloc_elem_init(split_pt, elem->heap, elem->msl, new_elem_size, + elem->orig_elem, elem->orig_size); split_pt->prev = elem; split_pt->next = next_elem; if (next_elem) @@ -317,14 +321,18 @@ static int next_elem_is_adjacent(struct malloc_elem *elem) { return elem->next == RTE_PTR_ADD(elem, elem->size) && - elem->next->msl == elem->msl; + elem->next->msl == elem->msl && + (!internal_config.match_allocations || + elem->orig_elem == elem->next->orig_elem); } static int prev_elem_is_adjacent(struct malloc_elem *elem) { return elem == RTE_PTR_ADD(elem->prev, elem->prev->size) && - elem->prev->msl == elem->msl; + elem->prev->msl == elem->msl && + (!internal_config.match_allocations || + elem->orig_elem == elem->prev->orig_elem); } /* diff --git a/lib/librte_eal/common/malloc_elem.h b/lib/librte_eal/common/malloc_elem.h index e2bda4c027..207767c945 100644 --- a/lib/librte_eal/common/malloc_elem.h +++ b/lib/librte_eal/common/malloc_elem.h @@ -32,6 +32,8 @@ struct malloc_elem { volatile enum elem_state state; uint32_t pad; size_t size; + struct malloc_elem *orig_elem; + size_t orig_size; #ifdef RTE_MALLOC_DEBUG uint64_t header_cookie; /* Cookie marking start of data */ /* trailer cookie at start + size */ @@ -116,7 +118,9 @@ void malloc_elem_init(struct malloc_elem *elem, struct malloc_heap *heap, struct rte_memseg_list *msl, - size_t size); + size_t size, + struct malloc_elem *orig_elem, + size_t orig_size); void malloc_elem_insert(struct malloc_elem *elem); diff --git a/lib/librte_eal/common/malloc_heap.c b/lib/librte_eal/common/malloc_heap.c index c6a6d4f6bd..4c3632d02b 100644 --- a/lib/librte_eal/common/malloc_heap.c +++ b/lib/librte_eal/common/malloc_heap.c @@ -94,7 +94,7 @@ malloc_heap_add_memory(struct malloc_heap *heap, struct rte_memseg_list *msl, { struct malloc_elem *elem = start; - malloc_elem_init(elem, heap, msl, len); + malloc_elem_init(elem, heap, msl, len, elem, len); malloc_elem_insert(elem); @@ -857,6 +857,13 @@ malloc_heap_free(struct malloc_elem *elem) if (elem->size < page_sz) goto free_unlock; + /* if user requested to match allocations, the sizes must match - if not, + * we will defer freeing these hugepages until the entire original allocation + * can be freed + */ + if (internal_config.match_allocations && elem->size != elem->orig_size) + goto free_unlock; + /* probably, but let's make sure, as we may not be using up full page */ start = elem; len = elem->size; @@ -1259,6 +1266,10 @@ rte_eal_malloc_heap_init(void) struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config; unsigned int i; + if (internal_config.match_allocations) { + RTE_LOG(DEBUG, EAL, "Hugepages will be freed exactly as allocated.\n"); + } + if (rte_eal_process_type() == RTE_PROC_PRIMARY) { /* assign min socket ID to external heaps */ mcfg->next_socket_id = EXTERNAL_HEAP_MIN_SOCKET_ID; diff --git a/lib/librte_eal/linuxapp/eal/eal.c b/lib/librte_eal/linuxapp/eal/eal.c index d252c85919..dadba3385e 100644 --- a/lib/librte_eal/linuxapp/eal/eal.c +++ b/lib/librte_eal/linuxapp/eal/eal.c @@ -518,6 +518,7 @@ eal_usage(const char *prgname) " --"OPT_VFIO_INTR" Interrupt mode for VFIO (legacy|msi|msix)\n" " --"OPT_LEGACY_MEM" Legacy memory mode (no dynamic allocation, contiguous segments)\n" " --"OPT_SINGLE_FILE_SEGMENTS" Put all hugepage memory in single files\n" + " --"OPT_MATCH_ALLOCATIONS" Free hugepages exactly as allocated\n" "\n"); /* Allow the application to print its usage message too if hook is set */ if ( rte_application_usage_hook ) { @@ -786,6 +787,10 @@ eal_parse_args(int argc, char **argv) strdup(optarg); break; + case OPT_MATCH_ALLOCATIONS_NUM: + internal_config.match_allocations = 1; + break; + default: if (opt < OPT_LONG_MIN_NUM && isprint(opt)) { RTE_LOG(ERR, EAL, "Option %c is not supported " diff --git a/test/test/test_malloc.c b/test/test/test_malloc.c index 5e52724194..6b6c6fec11 100644 --- a/test/test/test_malloc.c +++ b/test/test/test_malloc.c @@ -262,13 +262,26 @@ test_multi_alloc_statistics(void) struct rte_malloc_socket_stats pre_stats, post_stats ,first_stats, second_stats; size_t size = 2048; int align = 1024; -#ifndef RTE_MALLOC_DEBUG - int trailer_size = 0; -#else - int trailer_size = RTE_CACHE_LINE_SIZE; -#endif - int overhead = RTE_CACHE_LINE_SIZE + trailer_size; + int overhead = 0; + + /* Dynamically calculate the overhead by allocating one cacheline and + * then comparing what was allocated from the heap. + */ + rte_malloc_get_socket_stats(socket, &pre_stats); + + void *dummy = rte_malloc_socket(NULL, RTE_CACHE_LINE_SIZE, 0, socket); + if (dummy == NULL) + return -1; + + rte_malloc_get_socket_stats(socket, &post_stats); + + /* after subtracting cache line, remainder is overhead */ + overhead = post_stats.heap_allocsz_bytes - pre_stats.heap_allocsz_bytes; + overhead -= RTE_CACHE_LINE_SIZE; + + rte_free(dummy); + /* Now start the real tests */ rte_malloc_get_socket_stats(socket, &pre_stats); void *p1 = rte_malloc_socket("stats", size , align, socket);