From nobody Tue Apr 7 05:44:51 2026 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 9043538BF96; Mon, 16 Mar 2026 11:32:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.140.110.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660754; cv=none; b=sFj5U/njLdOYSfdXmXt101xK27ikYQ8Z/uG0YneZ1a3xTpuw7w3CBRv5QWsuyiLDd5aVeDDsoWkI11t37pSC9f3jtAkOquEyaycBcvUSp5gAzQIGyjavlrlJ59M87YsdZaSy8AIso6EY9tSqGu3H+kbLoCPkjSS+gediCxlhsQk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660754; c=relaxed/simple; bh=j9ektSM111aBXm+TLCgmbJPhh9qRRnFNUtxFe72u3lg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ONSVX8AOTwuK1ZGRANykNK/FLaDkTXOb3P/HJvJVz5LbDRHJ85KSeapCRPWrdQv6x4RxxOLlrmaOUEMx5fAKpHErSoqZanWeSRoOnRTxNMxgD1z2Bbe+WmW1Pr+L/vSxF8KRTN9KacNpCRnJNI8HF/2tJcIY9TnLAaN2dvjN90U= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com; spf=pass smtp.mailfrom=arm.com; arc=none smtp.client-ip=217.140.110.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E556114BF; Mon, 16 Mar 2026 04:32:25 -0700 (PDT) Received: from e142334-100.cambridge.arm.com (e142334-100.cambridge.arm.com [10.1.194.63]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 8484D3F778; Mon, 16 Mar 2026 04:32:29 -0700 (PDT) From: Muhammad Usama Anjum To: Andrew Morton , David Hildenbrand , Lorenzo Stoakes , "Liam R. Howlett" , Vlastimil Babka , Mike Rapoport , Suren Baghdasaryan , Michal Hocko , Brendan Jackman , Johannes Weiner , Zi Yan , Uladzislau Rezki , Nick Terrell , David Sterba , "Vishal Moola (Oracle)" , linux-mm@kvack.org, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Ryan.Roberts@arm.com, david.hildenbrand@arm.com Cc: Ryan Roberts , usama.anjum@arm.com Subject: [PATCH v2 1/3] mm/page_alloc: Optimize free_contig_range() Date: Mon, 16 Mar 2026 11:31:42 +0000 Message-ID: <20260316113209.945853-2-usama.anjum@arm.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260316113209.945853-1-usama.anjum@arm.com> References: <20260316113209.945853-1-usama.anjum@arm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ryan Roberts Decompose the range of order-0 pages to be freed into the set of largest possible power-of-2 size and aligned chunks and free them to the pcp or buddy. This improves on the previous approach which freed each order-0 page individually in a loop. Testing shows performance to be improved by more than 10x in some cases. Since each page is order-0, we must decrement each page's reference count individually and only consider the page for freeing as part of a high order chunk if the reference count goes to zero. Additionally free_pages_prepare() must be called for each individual order-0 page too, so that the struct page state and global accounting state can be appropriately managed. But once this is done, the resulting high order chunks can be freed as a unit to the pcp or buddy. This significantly speeds up the free operation but also has the side benefit that high order blocks are added to the pcp instead of each page ending up on the pcp order-0 list; memory remains more readily available in high orders. vmalloc will shortly become a user of this new optimized free_contig_range() since it aggressively allocates high order non-compound pages, but then calls split_page() to end up with contiguous order-0 pages. These can now be freed much more efficiently. The execution time of the following function was measured in a server class arm64 machine: static int page_alloc_high_order_test(void) { unsigned int order =3D HPAGE_PMD_ORDER; struct page *page; int i; for (i =3D 0; i < 100000; i++) { page =3D alloc_pages(GFP_KERNEL, order); if (!page) return -1; split_page(page, order); free_contig_range(page_to_pfn(page), 1UL << order); } return 0; } Execution time before: 4097358 usec Execution time after: 729831 usec Perf trace before: 99.63% 0.00% kthreadd [kernel.kallsyms] [.] kthread | ---kthread 0xffffb33c12a26af8 | |--98.13%--0xffffb33c12a26060 | | | |--97.37%--free_contig_range | | | | | |--94.93%--___free_pages | | | | | | | |--55.42%--__free_frozen_pa= ges | | | | | | | | | --43.20%--free_= frozen_page_commit | | | | | | | | | --35= .37%--_raw_spin_unlock_irqrestore | | | | | | | |--11.53%--_raw_spin_trylock | | | | | | | |--8.19%--__preempt_count_d= ec_and_test | | | | | | | |--5.64%--_raw_spin_unlock | | | | | | | |--2.37%--__get_pfnblock_fl= ags_mask.isra.0 | | | | | | | --1.07%--free_frozen_page_= commit | | | | | --1.54%--__free_frozen_pages | | | --0.77%--___free_pages | --0.98%--0xffffb33c12a26078 alloc_pages_noprof Perf trace after: 8.42% 2.90% kthreadd [kernel.kallsyms] [k] __free= _contig_range | |--5.52%--__free_contig_range | | | |--5.00%--free_prepared_contig_range | | | | | |--1.43%--__free_frozen_pages | | | | | | | --0.51%--free_frozen_page_com= mit | | | | | |--1.08%--_raw_spin_trylock | | | | | --0.89%--_raw_spin_unlock | | | --0.52%--free_pages_prepare | --2.90%--ret_from_fork kthread 0xffffae1c12abeaf8 0xffffae1c12abe7a0 | --2.69%--vfree __free_contig_range Signed-off-by: Ryan Roberts Co-developed-by: Muhammad Usama Anjum Signed-off-by: Muhammad Usama Anjum --- Changes since v1: - Rebase on mm-new - Move FPI_PREPARED check inside __free_pages_prepare() now that fpi_flags are already being passed. - Add todo (Zi Yan) - Rerun benchmarks - Convert VM_BUG_ON_PAGE() to VM_WARN_ON_ONCE() - Rework order calculation in free_prepared_contig_range() and use MAX_PAGE_ORDER as high limit instead of pageblock_order as it must be up to internal __free_frozen_pages() how it frees them --- include/linux/gfp.h | 2 + mm/page_alloc.c | 110 ++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 108 insertions(+), 4 deletions(-) diff --git a/include/linux/gfp.h b/include/linux/gfp.h index f82d74a77cad8..96ac7aae370c4 100644 --- a/include/linux/gfp.h +++ b/include/linux/gfp.h @@ -467,6 +467,8 @@ void free_contig_frozen_range(unsigned long pfn, unsign= ed long nr_pages); void free_contig_range(unsigned long pfn, unsigned long nr_pages); #endif =20 +unsigned long __free_contig_range(unsigned long pfn, unsigned long nr_page= s); + DEFINE_FREE(free_page, void *, free_page((unsigned long)_T)) =20 #endif /* __LINUX_GFP_H */ diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 75ee81445640b..6a9430f720579 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -91,6 +91,13 @@ typedef int __bitwise fpi_t; /* Free the page without taking locks. Rely on trylock only. */ #define FPI_TRYLOCK ((__force fpi_t)BIT(2)) =20 +/* + * free_pages_prepare() has already been called for page(s) being freed. + * TODO: Perform per-subpage free_pages_prepare() checks for order > 0 pag= es + * (HWPoison, PageNetpp, bad free page). + */ +#define FPI_PREPARED ((__force fpi_t)BIT(3)) + /* prevent >1 _updater_ of zone percpu pageset ->high and ->batch fields */ static DEFINE_MUTEX(pcp_batch_high_lock); #define MIN_PERCPU_PAGELIST_HIGH_FRACTION (8) @@ -1310,6 +1317,9 @@ __always_inline bool __free_pages_prepare(struct page= *page, bool compound =3D PageCompound(page); struct folio *folio =3D page_folio(page); =20 + if (fpi_flags & FPI_PREPARED) + return true; + VM_BUG_ON_PAGE(PageTail(page), page); =20 trace_mm_page_free(page, order); @@ -1579,8 +1589,10 @@ static void __free_pages_ok(struct page *page, unsig= ned int order, unsigned long pfn =3D page_to_pfn(page); struct zone *zone =3D page_zone(page); =20 - if (__free_pages_prepare(page, order, fpi_flags)) - free_one_page(zone, page, pfn, order, fpi_flags); + if (!__free_pages_prepare(page, order, fpi_flags)) + return; + + free_one_page(zone, page, pfn, order, fpi_flags); } =20 void __meminit __free_pages_core(struct page *page, unsigned int order, @@ -6784,6 +6796,93 @@ void __init page_alloc_sysctl_init(void) register_sysctl_init("vm", page_alloc_sysctl_table); } =20 +static void free_prepared_contig_range(struct page *page, + unsigned long nr_pages) +{ + while (nr_pages) { + unsigned int order; + unsigned long pfn; + + pfn =3D page_to_pfn(page); + /* We are limited by the largest buddy order. */ + order =3D pfn ? __ffs(pfn) : MAX_PAGE_ORDER; + /* Don't exceed the number of pages to free. */ + order =3D min(order, ilog2(nr_pages)); + order =3D min_t(unsigned int, order, MAX_PAGE_ORDER); + + /* + * Free the chunk as a single block. Our caller has already + * called free_pages_prepare() for each order-0 page. + */ + __free_frozen_pages(page, order, FPI_PREPARED); + + page +=3D 1UL << order; + nr_pages -=3D 1UL << order; + } +} + +/** + * __free_contig_range - Free contiguous range of order-0 pages. + * @pfn: Page frame number of the first page in the range. + * @nr_pages: Number of pages to free. + * + * For each order-0 struct page in the physically contiguous range, put a + * reference. Free any page who's reference count falls to zero. The + * implementation is functionally equivalent to, but significantly faster = than + * calling __free_page() for each struct page in a loop. + * + * Memory allocated with alloc_pages(order>=3D1) then subsequently split to + * order-0 with split_page() is an example of appropriate contiguous pages= that + * can be freed with this API. + * + * Returns the number of pages which were not freed, because their referen= ce + * count did not fall to zero. + * + * Context: May be called in interrupt context or while holding a normal + * spinlock, but not in NMI context or while holding a raw spinlock. + */ +unsigned long __free_contig_range(unsigned long pfn, unsigned long nr_page= s) +{ + struct page *page =3D pfn_to_page(pfn); + unsigned long not_freed =3D 0; + struct page *start =3D NULL; + unsigned long i; + bool can_free; + + /* + * Chunk the range into contiguous runs of pages for which the refcount + * went to zero and for which free_pages_prepare() succeeded. If + * free_pages_prepare() fails we consider the page to have been freed; + * deliberately leak it. + * + * Code assumes contiguous PFNs have contiguous struct pages, but not + * vice versa. + */ + for (i =3D 0; i < nr_pages; i++, page++) { + VM_WARN_ON_ONCE(PageHead(page)); + VM_WARN_ON_ONCE(PageTail(page)); + + can_free =3D put_page_testzero(page); + if (!can_free) + not_freed++; + else if (!free_pages_prepare(page, 0)) + can_free =3D false; + + if (!can_free && start) { + free_prepared_contig_range(start, page - start); + start =3D NULL; + } else if (can_free && !start) { + start =3D page; + } + } + + if (start) + free_prepared_contig_range(start, page - start); + + return not_freed; +} +EXPORT_SYMBOL(__free_contig_range); + #ifdef CONFIG_CONTIG_ALLOC /* Usage: See admin-guide/dynamic-debug-howto.rst */ static void alloc_contig_dump_pages(struct list_head *page_list) @@ -7327,11 +7426,14 @@ EXPORT_SYMBOL(free_contig_frozen_range); */ void free_contig_range(unsigned long pfn, unsigned long nr_pages) { + unsigned long count; + if (WARN_ON_ONCE(PageHead(pfn_to_page(pfn)))) return; =20 - for (; nr_pages--; pfn++) - __free_page(pfn_to_page(pfn)); + count =3D __free_contig_range(pfn, nr_pages); + WARN(count !=3D 0, "%lu pages are still in use!\n", count); + } EXPORT_SYMBOL(free_contig_range); #endif /* CONFIG_CONTIG_ALLOC */ --=20 2.47.3 From nobody Tue Apr 7 05:44:51 2026 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 4BCC434B410; Mon, 16 Mar 2026 11:32:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.140.110.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660756; cv=none; b=LY47oH72YXmq4wWbIJ92tFmipzWBwyHEoBVAAqJ9THI6LQykf7/IgqcmGeL3yLzt+H8m+TvZe2Qrx8XHb2CJZGzYPqIhCXqzM3aU0YPGXW2PFh58j0cCQIBOiAGhe3z543R9SP3iitiderJcJSlVRg03pjKSMGmF7ID0QlVd9ZA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660756; c=relaxed/simple; bh=91espRvFlRdUlGWv9mAO1VwCJ/vHTPSkGHxBVib2v2Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=NXq6XbBFqF06j1JBHyonnxssDcIz8vOTAIDuTwHsDrpHGHHxeFsGf5cvVbmPHHVZAunnS+Y/ni6Cl3lYB+S7/dUKFsyinuJP3QhnOTBfZSgt39ERjBiUD2tPF+6vVCQdfv6kgMmTty0zl5ttxby25zkSisw72pjFnq6v0WJWyI0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com; spf=pass smtp.mailfrom=arm.com; arc=none smtp.client-ip=217.140.110.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id A58EB1477; Mon, 16 Mar 2026 04:32:28 -0700 (PDT) Received: from e142334-100.cambridge.arm.com (e142334-100.cambridge.arm.com [10.1.194.63]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 492693F778; Mon, 16 Mar 2026 04:32:32 -0700 (PDT) From: Muhammad Usama Anjum To: Andrew Morton , David Hildenbrand , Lorenzo Stoakes , "Liam R. Howlett" , Vlastimil Babka , Mike Rapoport , Suren Baghdasaryan , Michal Hocko , Brendan Jackman , Johannes Weiner , Zi Yan , Uladzislau Rezki , Nick Terrell , David Sterba , "Vishal Moola (Oracle)" , linux-mm@kvack.org, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Ryan.Roberts@arm.com, david.hildenbrand@arm.com Cc: Ryan Roberts , usama.anjum@arm.com Subject: [PATCH v2 2/3] vmalloc: Optimize vfree Date: Mon, 16 Mar 2026 11:31:43 +0000 Message-ID: <20260316113209.945853-3-usama.anjum@arm.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260316113209.945853-1-usama.anjum@arm.com> References: <20260316113209.945853-1-usama.anjum@arm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Ryan Roberts Whenever vmalloc allocates high order pages (e.g. for a huge mapping) it must immediately split_page() to order-0 so that it remains compatible with users that want to access the underlying struct page. Commit a06157804399 ("mm/vmalloc: request large order pages from buddy allocator") recently made it much more likely for vmalloc to allocate high order pages which are subsequently split to order-0. Unfortunately this had the side effect of causing performance regressions for tight vmalloc/vfree loops (e.g. test_vmalloc.ko benchmarks). See Closes: tag. This happens because the high order pages must be gotten from the buddy but then because they are split to order-0, when they are freed they are freed to the order-0 pcp. Previously allocation was for order-0 pages so they were recycled from the pcp. It would be preferable if when vmalloc allocates an (e.g.) order-3 page that it also frees that order-3 page to the order-3 pcp, then the regression could be removed. So let's do exactly that; use the new __free_contig_range() API to batch-free contiguous ranges of pfns. This not only removes the regression, but significantly improves performance of vfree beyond the baseline. A selection of test_vmalloc benchmarks running on arm64 server class system. mm-new is the baseline. Commit a06157804399 ("mm/vmalloc: request large order pages from buddy allocator") was added in v6.19-rc1 where we see regressions. Then with this change performance is much better. (>0 is faster, <0 is slower, (R)/(I) =3D statistically significant Regression/Improvement): +-----------------+--------------------------------------------------------= --+-------------------+--------------------+ | Benchmark | Result Class = | mm-new | this series | +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D+=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D+=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D+=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D+ | micromm/vmalloc | fix_align_alloc_test: p:1, h:0, l:500000 (usec) = | 1331843.33 | (I) 67.17% | | | fix_size_alloc_test: p:1, h:0, l:500000 (usec) = | 415907.33 | -5.14% | | | fix_size_alloc_test: p:4, h:0, l:500000 (usec) = | 755448.00 | (I) 53.55% | | | fix_size_alloc_test: p:16, h:0, l:500000 (usec) = | 1591331.33 | (I) 57.26% | | | fix_size_alloc_test: p:16, h:1, l:500000 (usec) = | 1594345.67 | (I) 68.46% | | | fix_size_alloc_test: p:64, h:0, l:100000 (usec) = | 1071826.00 | (I) 79.27% | | | fix_size_alloc_test: p:64, h:1, l:100000 (usec) = | 1018385.00 | (I) 84.17% | | | fix_size_alloc_test: p:256, h:0, l:100000 (usec) = | 3970899.67 | (I) 77.01% | | | fix_size_alloc_test: p:256, h:1, l:100000 (usec) = | 3821788.67 | (I) 89.44% | | | fix_size_alloc_test: p:512, h:0, l:100000 (usec) = | 7795968.00 | (I) 82.67% | | | fix_size_alloc_test: p:512, h:1, l:100000 (usec) = | 6530169.67 | (I) 118.09% | | | full_fit_alloc_test: p:1, h:0, l:500000 (usec) = | 626808.33 | -0.98% | | | kvfree_rcu_1_arg_vmalloc_test: p:1, h:0, l:500000 (usec= ) | 532145.67 | -1.68% | | | kvfree_rcu_2_arg_vmalloc_test: p:1, h:0, l:500000 (usec= ) | 537032.67 | -0.96% | | | long_busy_list_alloc_test: p:1, h:0, l:500000 (usec) = | 8805069.00 | (I) 74.58% | | | pcpu_alloc_test: p:1, h:0, l:500000 (usec) = | 500824.67 | 4.35% | | | random_size_align_alloc_test: p:1, h:0, l:500000 (usec)= | 1637554.67 | (I) 76.99% | | | random_size_alloc_test: p:1, h:0, l:500000 (usec) = | 4556288.67 | (I) 72.23% | | | vm_map_ram_test: p:1, h:0, l:500000 (usec) = | 107371.00 | -0.70% | +-----------------+--------------------------------------------------------= --+-------------------+--------------------+ Fixes: a06157804399 ("mm/vmalloc: request large order pages from buddy allo= cator") Closes: https://lore.kernel.org/all/66919a28-bc81-49c9-b68f-dd7c73395a0d@ar= m.com/ Signed-off-by: Ryan Roberts Co-developed-by: Muhammad Usama Anjum Signed-off-by: Muhammad Usama Anjum --- Changes since v1: - Rebase on mm-new - Rerun benchmarks --- mm/vmalloc.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/mm/vmalloc.c b/mm/vmalloc.c index c607307c657a6..8b935395fb068 100644 --- a/mm/vmalloc.c +++ b/mm/vmalloc.c @@ -3459,18 +3459,34 @@ void vfree(const void *addr) =20 if (unlikely(vm->flags & VM_FLUSH_RESET_PERMS)) vm_reset_perms(vm); - for (i =3D 0; i < vm->nr_pages; i++) { - struct page *page =3D vm->pages[i]; + + if (vm->nr_pages) { + bool account =3D !(vm->flags & VM_MAP_PUT_PAGES); + unsigned long start_pfn, pfn; + struct page *page =3D vm->pages[0]; + int nr =3D 1; =20 BUG_ON(!page); - /* - * High-order allocs for huge vmallocs are split, so - * can be freed as an array of order-0 allocations - */ - if (!(vm->flags & VM_MAP_PUT_PAGES)) + start_pfn =3D page_to_pfn(page); + if (account) mod_lruvec_page_state(page, NR_VMALLOC, -1); - __free_page(page); - cond_resched(); + + for (i =3D 1; i < vm->nr_pages; i++) { + page =3D vm->pages[i]; + BUG_ON(!page); + if (account) + mod_lruvec_page_state(page, NR_VMALLOC, -1); + pfn =3D page_to_pfn(page); + if (start_pfn + nr =3D=3D pfn) { + nr++; + continue; + } + __free_contig_range(start_pfn, nr); + start_pfn =3D pfn; + nr =3D 1; + cond_resched(); + } + __free_contig_range(start_pfn, nr); } kvfree(vm->pages); kfree(vm); --=20 2.47.3 From nobody Tue Apr 7 05:44:51 2026 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 1AD30388361; Mon, 16 Mar 2026 11:32:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.140.110.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660759; cv=none; b=CH5AuNN7bqAmf8bPhGSfBjGut86Dbe2DJH5ej2pBbaDNTwjX4lJoFy2isdZthvJ1izFIuvVt7BjZfXMX3onClbgdx/BhIwShpXk+TVi226P3cmfAxFqIrJFk5FTX/JjhEcxjivBm0spFXaWYPCmVcI7/qwEXzu2y8t/dQf+oSOM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773660759; c=relaxed/simple; bh=nbYpfaEAsn7PoS9SB1y3ioIZ4TDt//kylLT/jdFXuaQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=f/JLFiVSoi8sGdslMVN9DDKyxAMi7FHNd5Ss4N3NXWjX82Dd7uVwmHsemPx2SOEMN/EMT+LicnDckvvwCIoRmaQOfGsOoPQ06/X5z3i7uSBzdrWEldtH3zt6ZSg1L5qUWWscpZm0OKW44UxGlD+OjNQdeu5R9AEEdMlR2sRRze0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com; spf=pass smtp.mailfrom=arm.com; arc=none smtp.client-ip=217.140.110.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 4DD0E1477; Mon, 16 Mar 2026 04:32:31 -0700 (PDT) Received: from e142334-100.cambridge.arm.com (e142334-100.cambridge.arm.com [10.1.194.63]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 0BC0E3F778; Mon, 16 Mar 2026 04:32:34 -0700 (PDT) From: Muhammad Usama Anjum To: Andrew Morton , David Hildenbrand , Lorenzo Stoakes , "Liam R. Howlett" , Vlastimil Babka , Mike Rapoport , Suren Baghdasaryan , Michal Hocko , Brendan Jackman , Johannes Weiner , Zi Yan , Uladzislau Rezki , Nick Terrell , David Sterba , "Vishal Moola (Oracle)" , linux-mm@kvack.org, linux-kernel@vger.kernel.org, bpf@vger.kernel.org, Ryan.Roberts@arm.com, david.hildenbrand@arm.com Cc: Muhammad Usama Anjum Subject: [PATCH v2 3/3] mm/page_alloc: Optimize __free_contig_frozen_range() Date: Mon, 16 Mar 2026 11:31:44 +0000 Message-ID: <20260316113209.945853-4-usama.anjum@arm.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260316113209.945853-1-usama.anjum@arm.com> References: <20260316113209.945853-1-usama.anjum@arm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Apply the same batch-freeing optimization from free_contig_range() to the frozen page path. The previous __free_contig_frozen_range() freed each order-0 page individually via free_frozen_pages(), which is slow for the same reason the old free_contig_range() was: each page goes to the order-0 pcp list rather than being coalesced into higher-order blocks. Rewrite __free_contig_frozen_range() to call free_pages_prepare() for each order-0 page, then batch the prepared pages into the largest possible power-of-2 aligned chunks via free_prepared_contig_range(). If free_pages_prepare() fails (e.g. HWPoison, bad page) the page is deliberately not freed; it should not be returned to the allocator. I've tested CMA through debugfs. The test allocates 16384 pages per allocation for several iterations. There is 3.5x improvement. Before: 1406 usec per iteration After: 402 usec per iteration Before: 70.89% 0.69% cma [kernel.kallsyms] [.] free_cont= ig_frozen_range | |--70.20%--free_contig_frozen_range | | | |--46.41%--__free_frozen_pages | | | | | --36.18%--free_frozen_page_commit | | | | | --29.63%--_raw_spin_unlock_ir= qrestore | | | |--8.76%--_raw_spin_trylock | | | |--7.03%--__preempt_count_dec_and_test | | | |--4.57%--_raw_spin_unlock | | | |--1.96%--__get_pfnblock_flags_mask.isra.0 | | | --1.15%--free_frozen_page_commit | --0.69%--el0t_64_sync After: 23.57% 0.00% cma [kernel.kallsyms] [.] free_cont= ig_frozen_range | ---free_contig_frozen_range | |--20.45%--__free_contig_frozen_range | | | |--17.77%--free_pages_prepare | | | --0.72%--free_prepared_contig_range | | | --0.55%--__free_frozen_pages | --3.12%--free_pages_prepare Suggested-by: Zi Yan Signed-off-by: Muhammad Usama Anjum Reviewed-by: Vlastimil Babka (SUSE) Reviewed-by: Zi Yan --- mm/page_alloc.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 6a9430f720579..2e99fa85cdc8e 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -7020,8 +7020,22 @@ static int __alloc_contig_verify_gfp_mask(gfp_t gfp_= mask, gfp_t *gfp_cc_mask) =20 static void __free_contig_frozen_range(unsigned long pfn, unsigned long nr= _pages) { - for (; nr_pages--; pfn++) - free_frozen_pages(pfn_to_page(pfn), 0); + struct page *page =3D pfn_to_page(pfn); + struct page *start =3D NULL; + unsigned long i; + + for (i =3D 0; i < nr_pages; i++, page++) { + if (free_pages_prepare(page, 0)) { + if (!start) + start =3D page; + } else if (start) { + free_prepared_contig_range(start, page - start); + start =3D NULL; + } + } + + if (start) + free_prepared_contig_range(start, page - start); } =20 /** --=20 2.47.3