From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 4B70168F0 for ; Wed, 1 Jun 2016 18:20:04 +0200 (CEST) Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga101.jf.intel.com with ESMTP; 01 Jun 2016 09:20:03 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.26,401,1459839600"; d="scan'208";a="966791476" Received: from sie-lab-214-251.ir.intel.com (HELO silpixa373510.ir.intel.com) ([10.237.214.251]) by orsmga001.jf.intel.com with ESMTP; 01 Jun 2016 09:20:00 -0700 From: David Hunt To: dev@dpdk.org Cc: olivier.matz@6wind.com, viktorin@rehivetech.com, jerin.jacob@caviumnetworks.com Date: Wed, 1 Jun 2016 17:19:53 +0100 Message-Id: <1464797998-76690-1-git-send-email-david.hunt@intel.com> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1463665501-18325-1-git-send-email-david.hunt@intel.com> References: <1463665501-18325-1-git-send-email-david.hunt@intel.com> Subject: [dpdk-dev] [PATCH v6 0/5] mempool: add external mempool manager 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: , X-List-Received-Date: Wed, 01 Jun 2016 16:20:04 -0000 Here's the latest version of the External Mempool Manager patchset. It's re-based on top of the latest head as of 1st June 2016, including Olivier's 35-part patch series on mempool re-org [1] [1] http://dpdk.org/ml/archives/dev/2016-May/039229.html Note: After applying the last patch, run "make config ..." before compiling. It introduces a config file change. Note: Hopefully I've addressed all the extensive comments over the last week. If I've missed any, please let me know, as it would not have been intentional. I hop I've responded to all comments via email on the mailing list. v6 changes: * Moved the flags handling from rte_mempool_create_empty to rte_mempool_create, as it's only there for backward compatibility * Various comment additions and cleanup * Renamed rte_mempool_handler to rte_mempool_ops * Added a union for *pool and u64 pool_id in struct rte_mempool * split the original patch into a few parts for easier review. * rename functions with _ext_ to _ops_. * addressed review comments * renamed put and get functions to enqueue and dequeue * changed occurences of rte_mempool_ops to const, as they contain function pointers (security) * split out the default external mempool handler into a separate patch for easier review v5 changes: * rebasing, as it is dependent on another patch series [1] v4 changes (Olivier Matz): * remove the rte_mempool_create_ext() function. To change the handler, the user has to do the following: - mp = rte_mempool_create_empty() - rte_mempool_set_handler(mp, "my_handler") - rte_mempool_populate_default(mp) This avoids to add another function with more than 10 arguments, duplicating the doxygen comments * change the api of rte_mempool_alloc_t: only the mempool pointer is required as all information is available in it * change the api of rte_mempool_free_t: remove return value * move inline wrapper functions from the .c to the .h (else they won't be inlined). This implies to have one header file (rte_mempool.h), or it would have generate cross dependencies issues. * remove now unused MEMPOOL_F_INT_HANDLER (note: it was misused anyway due to the use of && instead of &) * fix build in debug mode (__MEMPOOL_STAT_ADD(mp, put_pool, n) remaining) * fix build with shared libraries (global handler has to be declared in the .map file) * rationalize #include order * remove unused function rte_mempool_get_handler_name() * rename some structures, fields, functions * remove the static in front of rte_tailq_elem rte_mempool_tailq (comment from Yuanhan) * test the ext mempool handler in the same file than standard mempool tests, avoiding to duplicate the code * rework the custom handler in mempool_test * rework a bit the patch selecting default mbuf pool handler * fix some doxygen comments v3 changes: * simplified the file layout, renamed to rte_mempool_handler.[hc] * moved the default handlers into rte_mempool_default.c * moved the example handler out into app/test/test_ext_mempool.c * removed is_mc/is_mp change, slight perf degredation on sp cached operation * removed stack hanler, may re-introduce at a later date * Changes out of code reviews v2 changes: * There was a lot of duplicate code between rte_mempool_xmem_create and rte_mempool_create_ext. This has now been refactored and is now hopefully cleaner. * The RTE_NEXT_ABI define is now used to allow building of the library in a format that is compatible with binaries built against previous versions of DPDK. * Changes out of code reviews. Hopefully I've got most of them included. The External Mempool Manager is an extension to the mempool API that allows users to add and use an external mempool manager, which allows external memory subsystems such as external hardware memory management systems and software based memory allocators to be used with DPDK. The existing API to the internal DPDK mempool manager will remain unchanged and will be backward compatible. However, there will be an ABI breakage, as the mempool struct is changing. These changes are all contained withing RTE_NEXT_ABI defs, and the current or next code can be changed with the CONFIG_RTE_NEXT_ABI config setting There are two aspects to external mempool manager. 1. Adding the code for your new mempool handler. This is achieved by adding a new mempool handler source file into the librte_mempool library, and using the REGISTER_MEMPOOL_HANDLER macro. 2. Using the new API to call rte_mempool_create_empty and rte_mempool_set_handler to create a new mempool using the name parameter to identify which handler to use. New API calls added 1. A new rte_mempool_create_empty() function 2. rte_mempool_set_handler() which sets the mempool's handler 3. An rte_mempool_populate_default() and rte_mempool_populate_anon() functions which populates the mempool using the relevant handler Several external mempool managers may be used in the same application. A new mempool can then be created by using the new 'create' function, providing the mempool handler name to point the mempool to the relevant mempool manager callback structure. The old 'create' function can still be called by legacy programs, and will internally work out the mempool handle based on the flags provided (single producer, single consumer, etc). By default handles are created internally to implement the built-in DPDK mempool manager and mempool types. The external mempool manager needs to provide the following functions. 1. alloc - allocates the mempool memory, and adds each object onto a ring 2. put - puts an object back into the mempool once an application has finished with it 3. get - gets an object from the mempool for use by the application 4. get_count - gets the number of available objects in the mempool 5. free - frees the mempool memory Every time a get/put/get_count is called from the application/PMD, the callback for that mempool is called. These functions are in the fastpath, and any unoptimised handlers may limit performance. The new APIs are as follows: 1. rte_mempool_create_empty struct rte_mempool * rte_mempool_create_empty(const char *name, unsigned n, unsigned elt_size, unsigned cache_size, unsigned private_data_size, int socket_id, unsigned flags); 2. rte_mempool_set_handler() int rte_mempool_set_handler(struct rte_mempool *mp, const char *name); 3. rte_mempool_populate_default() int rte_mempool_populate_default(struct rte_mempool *mp); 4. rte_mempool_populate_anon() int rte_mempool_populate_anon(struct rte_mempool *mp); Please see rte_mempool.h for further information on the parameters. The important thing to note is that the mempool handler is passed by name to rte_mempool_set_handler, which looks through the handler array to get the handler index, which is then stored in the rte_memool structure. This allow multiple processes to use the same mempool, as the function pointers are accessed via handler index. The mempool handler structure contains callbacks to the implementation of the handler, and is set up for registration as follows: static const struct rte_mempool_handler handler_sp_mc = { .name = "ring_sp_mc", .alloc = rte_mempool_common_ring_alloc, .put = common_ring_sp_put, .get = common_ring_mc_get, .get_count = common_ring_get_count, .free = common_ring_free, }; And then the following macro will register the handler in the array of handlers REGISTER_MEMPOOL_HANDLER(handler_mp_mc); For and example of a simple malloc based mempool manager, see lib/librte_mempool/custom_mempool.c For an example of API usage, please see app/test/test_mempool.c, which implements a rudimentary "custom_handler" mempool manager using simple mallocs for each mempool object. This file also contains the callbacks and self registration for the new handler. David Hunt (4): mempool: support external handler mempool: remove rte_ring from rte_mempool struct mempool: add default external mempool handler mbuf: get default mempool handler from configuration Olivier Matz (1): app/test: test external mempool handler