From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 74B04A0563; Wed, 15 Apr 2020 16:15:39 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 326141D732; Wed, 15 Apr 2020 16:15:38 +0200 (CEST) Received: from out2-smtp.messagingengine.com (out2-smtp.messagingengine.com [66.111.4.26]) by dpdk.org (Postfix) with ESMTP id BD92C1D72E for ; Wed, 15 Apr 2020 16:15:35 +0200 (CEST) Received: from compute7.internal (compute7.nyi.internal [10.202.2.47]) by mailout.nyi.internal (Postfix) with ESMTP id F02D45C0160; Wed, 15 Apr 2020 10:15:34 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute7.internal (MEProxy); Wed, 15 Apr 2020 10:15:34 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=monjalon.net; h= from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; s=mesmtp; bh=LIZ95jBORk UUaZ2E72t4mqXajEvtM4j1Eqf1gbgNCL8=; b=VUVdltfKZ90JGwYebFwVRoWOWu DpMmiZmlMrGeOxpbV7FBx9rP5Bx+CT4TLv83zfW8VotUer//VF4RcXcf72X36QA0 Hdlzq4ou4gJrVAo7cpJfm/Y57I1mAJbAc13XAtwgl0DBp+dsyE9i3or12z+shj5w fpYxlKIfxVgtv17Xs= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:content-transfer-encoding:date:from :in-reply-to:message-id:mime-version:references:subject:to :x-me-proxy:x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s= fm2; bh=LIZ95jBORkUUaZ2E72t4mqXajEvtM4j1Eqf1gbgNCL8=; b=zaHumyTh Obs8I6Uvzj/CaovWSwobwBBuP/QH9oM+2gkhKJRWRv3F0GDKmbuUWUNsvoFKzlGq Gz0Gtvzt07tqKtWd9MxR6q6VeldliAMUyYF9/uPNDHLQwxcXI5p6iMdLuCcdMuSJ RAmjusJZZRu1GPfoD6YDtizUy6Ec+KXMyfYMtmHC1HQfyArkDZOqPBa3Zi3Y4ciy u7W++bu2pDQbLNvQ9xpScShw4TLNV4PjabrFo5vwDzN0HOjHfH9zMh1vLhxUHYk/ 8Vfil6/U1jWRgz9RcCr6Wh0FeglokBiStzuxkGT9Ttb6YF8t1jbJ5liDQykN2CdV 9hRp5TsoykfJtg== X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgeduhedrfeefgdeifecutefuodetggdotefrodftvf curfhrohhfihhlvgemucfhrghsthforghilhdpqfgfvfdpuffrtefokffrpgfnqfghnecu uegrihhlohhuthemuceftddtnecusecvtfgvtghiphhivghnthhsucdlqddutddtmdenuc fjughrpefhvffufffkofgjfhgggfestdekredtredttdenucfhrhhomhepvfhhohhmrghs ucfoohhnjhgrlhhonhcuoehthhhomhgrshesmhhonhhjrghlohhnrdhnvghtqeenucfkph epjeejrddufeegrddvtdefrddukeegnecuvehluhhsthgvrhfuihiivgeptdenucfrrghr rghmpehmrghilhhfrhhomhepthhhohhmrghssehmohhnjhgrlhhonhdrnhgvth X-ME-Proxy: Received: from xps.monjalon.net (184.203.134.77.rev.sfr.net [77.134.203.184]) by mail.messagingengine.com (Postfix) with ESMTPA id C2E503060064; Wed, 15 Apr 2020 10:15:33 -0400 (EDT) From: Thomas Monjalon To: dev@dpdk.org Cc: amo@semihalf.com, Suanming Mou , Cristian Dumitrescu Date: Wed, 15 Apr 2020 16:15:29 +0200 Message-Id: <20200415141529.2057898-1-thomas@monjalon.net> X-Mailer: git-send-email 2.26.0 In-Reply-To: <1583828479-204084-1-git-send-email-suanmingm@mellanox.com> References: <1583828479-204084-1-git-send-email-suanmingm@mellanox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [dpdk-dev] [PATCH v4] bitmap: add init with all bits set X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Suanming Mou Currently, in the case to use bitmap as resource allocator, after bitmap creation, all the bitmap bits should be set to indicate the bit available. Every time when allocate one bit, search for the set bits and clear it to make it in use. Add a new rte_bitmap_init_with_all_set() function to have a quick fill up the bitmap bits. Comparing with the case create the bitmap as empty and set the bitmap one by one, the new function costs less cycles. Signed-off-by: Suanming Mou Acked-by: Cristian Dumitrescu --- v4: - add experimental tags and comments - move functions near original init function - squash test patch - use "init" word in title v3 updates: 1. Implement individual rte_bitmap_init_with_all_set() function. 2. Add new function to clear the overhead bits. v2 updates: 1. Split the common part to __rte_bitmap_init(). 2. Set the slab bits more customized. --- app/test/test_bitmap.c | 57 ++++++++++++++++++- lib/librte_eal/include/rte_bitmap.h | 85 +++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+), 1 deletion(-) diff --git a/app/test/test_bitmap.c b/app/test/test_bitmap.c index 95c5184882..a8204d329f 100644 --- a/app/test/test_bitmap.c +++ b/app/test/test_bitmap.c @@ -146,7 +146,7 @@ test_bitmap_set_get_clear(struct rte_bitmap *bmp) } static int -test_bitmap(void) +test_bitmap_all_clear(void) { void *mem; uint32_t bmp_size; @@ -182,4 +182,59 @@ test_bitmap(void) return TEST_SUCCESS; } +static int +test_bitmap_all_set(void) +{ + void *mem; + uint32_t i; + uint64_t slab; + uint32_t pos; + uint32_t bmp_size; + struct rte_bitmap *bmp; + + bmp_size = + rte_bitmap_get_memory_footprint(MAX_BITS); + + mem = rte_zmalloc("test_bmap", bmp_size, RTE_CACHE_LINE_SIZE); + if (mem == NULL) { + printf("Failed to allocate memory for bitmap\n"); + return TEST_FAILED; + } + + bmp = rte_bitmap_init_with_all_set(MAX_BITS, mem, bmp_size); + if (bmp == NULL) { + printf("Failed to init bitmap\n"); + return TEST_FAILED; + } + + for (i = 0; i < MAX_BITS; i++) { + pos = slab = 0; + if (!rte_bitmap_scan(bmp, &pos, &slab)) { + printf("Failed with init bitmap.\n"); + return TEST_FAILED; + } + pos += (slab ? __builtin_ctzll(slab) : 0); + rte_bitmap_clear(bmp, pos); + } + + if (rte_bitmap_scan(bmp, &pos, &slab)) { + printf("Too much bits set.\n"); + return TEST_FAILED; + } + + rte_bitmap_free(bmp); + rte_free(mem); + + return TEST_SUCCESS; + +} + +static int +test_bitmap(void) +{ + if (test_bitmap_all_clear() != TEST_SUCCESS) + return TEST_FAILED; + return test_bitmap_all_set(); +} + REGISTER_TEST_COMMAND(bitmap_test, test_bitmap); diff --git a/lib/librte_eal/include/rte_bitmap.h b/lib/librte_eal/include/rte_bitmap.h index 6b846f251b..7c90ef333f 100644 --- a/lib/librte_eal/include/rte_bitmap.h +++ b/lib/librte_eal/include/rte_bitmap.h @@ -203,6 +203,91 @@ rte_bitmap_init(uint32_t n_bits, uint8_t *mem, uint32_t mem_size) return bmp; } +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Bitmap clear slab overhead bits. + * + * @param slabs + * Slab array. + * @param slab_size + * Number of 64-bit slabs in the slabs array. + * @param pos + * The start bit position in the slabs to be cleared. + */ +__rte_experimental +static inline void +__rte_bitmap_clear_slab_overhead_bits(uint64_t *slabs, uint32_t slab_size, + uint32_t pos) +{ + uint32_t i; + uint32_t index = pos / RTE_BITMAP_SLAB_BIT_SIZE; + uint32_t offset = pos & RTE_BITMAP_SLAB_BIT_MASK; + + if (offset) { + for (i = offset; i < RTE_BITMAP_SLAB_BIT_SIZE; i++) + slabs[index] &= ~(1llu << i); + index++; + } + if (index < slab_size) + memset(&slabs[index], 0, sizeof(slabs[0]) * + (slab_size - index)); +} + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Bitmap initialization with all bits set + * + * @param n_bits + * Number of pre-allocated bits in array2. + * @param mem + * Base address of array1 and array2. + * @param mem_size + * Minimum expected size of bitmap. + * @return + * Handle to bitmap instance. + */ +__rte_experimental +static inline struct rte_bitmap * +rte_bitmap_init_with_all_set(uint32_t n_bits, uint8_t *mem, uint32_t mem_size) +{ + struct rte_bitmap *bmp; + uint32_t array1_byte_offset, array1_slabs; + uint32_t array2_byte_offset, array2_slabs; + uint32_t size; + + /* Check input arguments */ + if (!n_bits || !mem || (((uintptr_t) mem) & RTE_CACHE_LINE_MASK)) + return NULL; + + size = __rte_bitmap_get_memory_footprint(n_bits, + &array1_byte_offset, &array1_slabs, + &array2_byte_offset, &array2_slabs); + if (size < mem_size) + return NULL; + + /* Setup bitmap */ + bmp = (struct rte_bitmap *) mem; + bmp->array1 = (uint64_t *) &mem[array1_byte_offset]; + bmp->array1_size = array1_slabs; + bmp->array2 = (uint64_t *) &mem[array2_byte_offset]; + bmp->array2_size = array2_slabs; + + __rte_bitmap_scan_init(bmp); + + memset(bmp->array1, 0xff, bmp->array1_size * sizeof(bmp->array1[0])); + memset(bmp->array2, 0xff, bmp->array2_size * sizeof(bmp->array2[0])); + /* Clear overhead bits. */ + __rte_bitmap_clear_slab_overhead_bits(bmp->array1, bmp->array1_size, + bmp->array2_size >> RTE_BITMAP_CL_SLAB_SIZE_LOG2); + __rte_bitmap_clear_slab_overhead_bits(bmp->array2, bmp->array2_size, + n_bits); + return bmp; +} + /** * Bitmap free * -- 2.26.0