Skip to contentSkip to conversation

mm/page_alloc: Avoid duplicate NR_FREE_PAGES updates in move_to_free_list()

PATCH In review Yajun Deng 5 participants 6 messages Jan 12 – Jan 20

Subsystems (2)
lore
Share & tools
lore

Yajun Deng

author
#0 lore raw

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
index ebfa07632995..d56e94eb4914 100644
@@ -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
#1 lore raw
Quoted 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 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.

Quoted 5 lines

The optimization avoid duplicate NR_FREE_PAGES updates in move_to_free_list().

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.

author
#2 lore raw
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 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().

Quoted 8 lines
Quoted 3 lines

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.

#3 lore raw
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 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().

Quoted 7 lines
Quoted 7 lines
Quoted 3 lines

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(). 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.

Reviewed-by on v2 1/1
#4 lore raw
In reply to Yajun Deng
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 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.

Quoted 5 lines

The optimization avoid duplicate NR_FREE_PAGES updates in move_to_free_list().

Hello Yajun,

LGTM. Thank you for kindly accepting my suggestion!