mm/page_alloc: Avoid duplicate NR_FREE_PAGES updates in move_to_free_list()
Subsystems (2)
PATCH v2 1/1 mm/page_alloc: Avoid duplicate NR_FREE_PAGES updates in move_to_free_list()
In move_to_free_list(), when a page block changes its migration type, we need to update free page counts for both the old and new types. Originally, this was done by two calls to account_freepages(), which updates NR_FREE_PAGES and also type-specific counters. However, this causes NR_FREE_PAGES to be updated twice, while the net change is zero in most cases.
This patch adds a condition that updates the NR_FREE_PAGES only if one of the two types is the isolate type. This avoids NR_FREE_PAGES being updates twice.
The optimization avoid duplicate NR_FREE_PAGES updates in move_to_free_list().
---
v2: remove account_freepages_both().
v1: https://lore.kernel.org/all/[email protected]/
--- mm/page_alloc.c | 38 +++++++++++++++++++++++++------------- 1 file changed, 25 insertions(+), 13 deletions(-)
mm/page_alloc.c +25 -13
@@ -812,6 +812,16 @@ compaction_capture(struct capture_control *capc, struct page *page, }#endif /* CONFIG_COMPACTION */ +static inline void account_specific_freepages (struct zone *zone,int nr_pages, +int migratetype) +{ +if (is_migrate_cma (migratetype)) +__mod_zone_page_state (zone,NR_FREE_CMA_PAGES , nr_pages); +else if (migratetype ==MIGRATE_HIGHATOMIC ) +WRITE_ONCE (zone->nr_free_highatomic, + zone->nr_free_highatomic + nr_pages); +} +static inline void account_freepages (struct zone *zone,int nr_pages,int migratetype) {
@@ -822,11 +832,7 @@ static inline void account_freepages(struct zone *zone, int nr_pages,__mod_zone_page_state (zone,NR_FREE_PAGES , nr_pages); -if (is_migrate_cma (migratetype)) -__mod_zone_page_state (zone,NR_FREE_CMA_PAGES , nr_pages); -else if (migratetype ==MIGRATE_HIGHATOMIC ) -WRITE_ONCE (zone->nr_free_highatomic, - zone->nr_free_highatomic + nr_pages); +account_specific_freepages (zone, nr_pages, migratetype); }/* Used for pages not on another list */
@@ -861,6 +867,8 @@ static inline void move_to_free_list(struct page *page, struct zone *zone, {struct free_area *area = &zone->free_area[order];int nr_pages =1 << order; +bool old_isolated =is_migrate_isolate (old_mt); +bool new_isolated =is_migrate_isolate (new_mt);/* Free page moving can fail, so it happens before the type update */ VM_WARN_ONCE(get_pageblock_migratetype(page) != old_mt,
@@ -869,14 +877,18 @@ static inline void move_to_free_list(struct page *page, struct zone *zone,list_move_tail (&page->buddy_list, &area->free_list[new_mt]); -account_freepages (zone, -nr_pages, old_mt); -account_freepages (zone, nr_pages, new_mt); - -if (order >= pageblock_order && -is_migrate_isolate (old_mt) !=is_migrate_isolate (new_mt)) { -if (!is_migrate_isolate (old_mt)) - nr_pages = -nr_pages; -__mod_zone_page_state (zone,NR_FREE_PAGES_BLOCKS , nr_pages); +if (!old_isolated) +account_specific_freepages (zone, -nr_pages, old_mt); +if (!new_isolated) +account_specific_freepages (zone, nr_pages, new_mt); + +/* Only update NR_FREE_PAGES if one of them is isolate type */ +if (old_isolated != new_isolated) { + nr_pages = old_isolated ? nr_pages : -nr_pages; +__mod_zone_page_state (zone,NR_FREE_PAGES , nr_pages); +if (order >= pageblock_order) +__mod_zone_page_state (zone,NR_FREE_PAGES_BLOCKS , + nr_pages); } }
Signature · 1 line
2.34.1
Johannes Weiner
reviewerQuoted 11 lines · Yajun Deng
In
move_to_free_list(), when a page block changes its migration type, we need to update free page counts for both the old and new types. Originally, this was done by two calls toaccount_freepages(), which updatesNR_FREE_PAGESand also type-specific counters. However, this causesNR_FREE_PAGESto be updated twice, while the net change is zero in most cases.This patch adds a condition that updates the
NR_FREE_PAGESonly if one of the two types is the isolate type. This avoidsNR_FREE_PAGESbeing updates twice.
Quoted 5 lines
The optimization avoid duplicate
NR_FREE_PAGESupdates inmove_to_free_list().Signed-off-by Yajun Deng <[email protected]>Suggested-by Joshua Hahn <[email protected]>
I'm not a fan of this.
The code ends up more complicated, more lines, and fragile because the accounting decisions are now spread out over multiple places (again).
Is it worth it? move_to_free_list() is used in page isolation, which has to do the accounting anyway; and migratetype fallbacks, which we are trying to avoid as much as possible. So this path shouldn't be all that hot to begin with.
Simplicity & maintainability trumps here, IMO, unless you have hard data showing this is worth the pain.
Quoted 18 lines · Johannes Weiner
Quoted 15 lines · Yajun Deng
In
move_to_free_list(), when a page block changes its migration type,
we need to update free page counts for both the old and new types. Originally, this was done by two calls toaccount_freepages(), which updatesNR_FREE_PAGESand also type-specific counters. However, this causesNR_FREE_PAGESto be updated twice, while the net change is zero in most cases.This patch adds a condition that updates the
NR_FREE_PAGESonly if one of the two types is the isolate type. This avoidsNR_FREE_PAGESbeing updates twice.The optimization avoid duplicate
NR_FREE_PAGESupdates inmove_to_free_list().
Quoted 8 lines
Quoted 3 lines
Signed-off-by Yajun Deng <[email protected]>Suggested-by Joshua Hahn <[email protected]>I'm not a fan of this.
The code ends up more complicated, more lines, and fragile because the accounting decisions are now spread out over multiple places (again).
How about V1? It will introduce account_freepages_both().
https://lore.kernel.org/all/[email protected]/
Quoted 5 lines
Is it worth it?
move_to_free_list()is used in page isolation, which has to do the accounting anyway; and migratetype fallbacks, which we are trying to avoid as much as possible. So this path shouldn't be all that hot to begin with.
Not all cases are of the isolation type. There are indeed duplicate caculations. move_freepages_block() will be called in __isolate_free_page(). Both old_mt and new_mt are mergeable type in this case.
Quoted 3 lines
Simplicity & maintainability trumps here, IMO, unless you have hard data showing this is worth the pain.
I'm tring to do it, but I haven't yet.
Quoted 21 lines · Yajun Deng
Quoted 18 lines · Johannes Weiner
Quoted 15 lines · Yajun Deng
In
move_to_free_list(), when a page block changes its migration type,
we need to update free page counts for both the old and new types. Originally, this was done by two calls toaccount_freepages(), which updatesNR_FREE_PAGESand also type-specific counters. However, this causesNR_FREE_PAGESto be updated twice, while the net change is zero in most cases.This patch adds a condition that updates the
NR_FREE_PAGESonly if one of the two types is the isolate type. This avoidsNR_FREE_PAGESbeing updates twice.The optimization avoid duplicate
NR_FREE_PAGESupdates inmove_to_free_list().
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines
Signed-off-by Yajun Deng <[email protected]>Suggested-by Joshua Hahn <[email protected]>I'm not a fan of this.
The code ends up more complicated, more lines, and fragile because the accounting decisions are now spread out over multiple places (again).
Agreed.
Quoted 3 lines
Quoted 1 line
How about V1? It will introduce account_freepages_both().
https://lore.kernel.org/all/[email protected]/
Also not a fan myself.
Thanks,
Vlastimil
Quoted 13 lines
Quoted 5 lines
Is it worth it?
move_to_free_list()is used in page isolation, which has to do the accounting anyway; and migratetype fallbacks, which we are trying to avoid as much as possible. So this path shouldn't be all that hot to begin with.Not all cases are of the isolation type. There are indeed duplicate caculations.
move_freepages_block()will be called in __isolate_free_page(). Bothold_mtandnew_mtare mergeable type in this case.Quoted 3 lines
Simplicity & maintainability trumps here, IMO, unless you have hard data showing this is worth the pain.
I'm tring to do it, but I haven't yet.
Quoted 11 lines · On Mon, 12 Jan 2026 20:16:14 +0800 Yajun Deng <[email protected]> wrote:
In
move_to_free_list(), when a page block changes its migration type, we need to update free page counts for both the old and new types. Originally, this was done by two calls toaccount_freepages(), which updatesNR_FREE_PAGESand also type-specific counters. However, this causesNR_FREE_PAGESto be updated twice, while the net change is zero in most cases.This patch adds a condition that updates the
NR_FREE_PAGESonly if one of the two types is the isolate type. This avoidsNR_FREE_PAGESbeing updates twice.
Quoted 5 lines
The optimization avoid duplicate
NR_FREE_PAGESupdates inmove_to_free_list().Signed-off-by Yajun Deng <[email protected]>Suggested-by Joshua Hahn <[email protected]>
Hello Yajun,
LGTM. Thank you for kindly accepting my suggestion!
…
Quoted 1 line
This patch adds a condition that …
See also once more:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/process/submitting-patches.rst?h=v6.19-rc5#n94
Regards,
Markus