reclaim contended folios asynchronously instead of promoting them
Subsystems (7)
v2 cover reclaim contended folios asynchronously instead of promoting them
From: Peifeng Li <[email protected]>
Commit 6d4675e60135 ("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU during shrink_folio_list, even if those folios are very cold.
This can have a detrimental effect on performance by increasing refaults and the likelihood of OOM (Out of Memory) killing.
This patchset introduces a new kthread:kshrinkd thread to asynchronously reclaim contended folios rather than promoting them, thereby preventing excessive violations of LRU rules. We observed a noticeable decrease in refaults and OOM killing as a result.
-v2:
* rewrite the commit messages;
* rebase on top of mm-unstable
-v1:
https://lore.kernel.org/linux-mm/[email protected]/
Peifeng Li (2):
mm/rmap: provide folio_referenced with the options to try_lock or lock
mm: vmscan: reclaim contended folios asynchronously instead of
promoting them
include/linux/mmzone.h | 6 + include/linux/rmap.h | 5 +- include/linux/swap.h | 3 + include/linux/vm_event_item.h | 2 + mm/memory_hotplug.c | 2 + mm/rmap.c | 5 +- mm/vmscan.c | 205 +++++++++++++++++++++++++++++++++- mm/vmstat.c | 2 + 8 files changed, 221 insertions(+), 9 deletions(-)
Signature · 1 line
2.34.1
PATCH v2 1/2 mm/rmap: provide folio_referenced with the options to try_lock or lock
From: Peifeng Li <[email protected]>
The commit 6d4675e60135 ("mm: don't be stuck to rmap lock on reclaim path") unconditionally switches to try_lock to avoid lock contention. This patch introduces a parameter to allow folio_referenced to genuinely wait and hold the lock in certain scenarios.
Before introducing the new context, we always set try_lock to true to maintain the current behavior of the code.
--- include/linux/rmap.h | 5 +++-- mm/rmap.c | 5 +++-- mm/vmscan.c | 16 ++++++++++++++-- 3 files changed, 20 insertions(+), 6 deletions(-)
include/linux/rmap.h +3 -2
@@ -623,7 +623,8 @@ static inline int folio_try_share_anon_rmap_pmd(struct folio *folio,* Called from mm/vmscan.c to handle paging out */ int folio_referenced (struct folio *,int is_locked, -struct mem_cgroup *memcg,unsigned long *vm_flags); +struct mem_cgroup *memcg,unsigned long *vm_flags, +unsigned int rw_try_lock);void try_to_migrate (struct folio *folio,enum ttu_flags flags);void try_to_unmap (struct folio *,enum ttu_flags flags);
@@ -739,7 +740,7 @@ struct anon_vma *folio_lock_anon_vma_read(struct folio *folio,static inline int folio_referenced (struct folio *folio,int is_locked,struct mem_cgroup *memcg, -unsigned long *vm_flags) +unsigned long *vm_flags,unsigned int rw_try_lock) { *vm_flags =0 ;return 0 ;
mm/rmap.c +3 -2
@@ -952,6 +952,7 @@ static bool invalid_folio_referenced_vma(struct vm_area_struct *vma, void *arg)* @is_locked: Caller holds lock on the folio. * @memcg: target memory cgroup * @vm_flags: A combination of all the vma->vm_flags which referenced the folio. +* @rw_try_lock: if try_lock in rmap_walk * * Quick test_and_clear_referenced for all mappings of a folio, *
@@ -959,7 +960,7 @@ static bool invalid_folio_referenced_vma(struct vm_area_struct *vma, void *arg)* the function bailed out due to rmap lock contention. */ int folio_referenced (struct folio *folio,int is_locked, -struct mem_cgroup *memcg,unsigned long *vm_flags) +struct mem_cgroup *memcg,unsigned long *vm_flags,unsigned int rw_try_lock) {int we_locked =0 ;struct folio_referenced_arg pra = {
@@ -970,7 +971,7 @@ int folio_referenced(struct folio *folio, int is_locked, .rmap_one = folio_referenced_one, .arg = (void *)&pra, .anon_lock = folio_lock_anon_vma_read, - .try_lock = true, + .try_lock = rw_try_lock ? true : false, .invalid_vma = invalid_folio_referenced_vma, };
mm/vmscan.c +14 -2
@@ -147,6 +147,9 @@ struct scan_control {/* Always discard instead of demoting to lower tier memory */ unsigned int no_demotion:1; +/* if try_lock in rmap_walk */ + unsigned int rw_try_lock:1; +/* Allocation order */ s8 order;
@@ -850,7 +853,7 @@ static enum folio_references folio_check_references(struct folio *folio,unsigned long vm_flags; referenced_ptes =folio_referenced (folio,1 , sc->target_mem_cgroup, - &vm_flags); + &vm_flags, sc->rw_try_lock); referenced_folio =folio_test_clear_referenced (folio);/*
@@ -1522,6 +1525,7 @@ unsigned int reclaim_clean_pages_from_list(struct zone *zone,struct scan_control sc = { .gfp_mask =GFP_KERNEL , .may_unmap =1 , + .rw_try_lock =1 , };struct reclaim_stat stat;unsigned int nr_reclaimed;
@@ -2059,7 +2063,7 @@ static void shrink_active_list(unsigned long nr_to_scan,/* Referenced or rmap lock contention: rotate */ if (folio_referenced (folio,0 , sc->target_mem_cgroup, - &vm_flags) !=0 ) { + &vm_flags, sc->rw_try_lock) !=0 ) {/* * Identify referenced, file-backed active folios and * give them one more trip around the active list. So
@@ -2114,6 +2118,7 @@ static unsigned int reclaim_folio_list(struct list_head *folio_list, .may_unmap = 1, .may_swap = 1, .no_demotion = 1, + .rw_try_lock = 1, }; nr_reclaimed =shrink_folio_list (folio_list, pgdat, &sc, &dummy_stat, ignore_references);
@@ -5459,6 +5464,7 @@ static ssize_t lru_gen_seq_write(struct file *file, const char __user *src, .may_swap = true, .reclaim_idx = MAX_NR_ZONES - 1, .gfp_mask = GFP_KERNEL, + .rw_try_lock = 1, }; buf =kvmalloc (len +1 ,GFP_KERNEL );
@@ -6436,6 +6442,7 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order, .may_writepage = !laptop_mode, .may_unmap = 1, .may_swap = 1, + .rw_try_lock = 1, };/*
@@ -6481,6 +6488,7 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg, .may_unmap = 1, .reclaim_idx = MAX_NR_ZONES - 1, .may_swap = !noswap, + .rw_try_lock = 1, };WARN_ON_ONCE (!current->reclaim_state);
@@ -6527,6 +6535,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg, .may_unmap = 1, .may_swap = !!(reclaim_options & MEMCG_RECLAIM_MAY_SWAP), .proactive = !!(reclaim_options & MEMCG_RECLAIM_PROACTIVE), + .rw_try_lock = 1, };/* * Traverse the ZONELIST_FALLBACK zonelist of the current node to put
@@ -6788,6 +6797,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int highest_zoneidx) .gfp_mask = GFP_KERNEL, .order = order, .may_unmap = 1, + .rw_try_lock = 1, };set_task_reclaim_state (current, &sc.reclaim_state);
@@ -7257,6 +7267,7 @@ unsigned long shrink_all_memory(unsigned long nr_to_reclaim) .may_unmap = 1, .may_swap = 1, .hibernation_mode = 1, + .rw_try_lock = 1, };struct zonelist *zonelist =node_zonelist (numa_node_id (), sc.gfp_mask);unsigned long nr_reclaimed;
@@ -7415,6 +7426,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in .may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP), .may_swap = 1, .reclaim_idx = gfp_zone(gfp_mask), + .rw_try_lock = 1, };unsigned long pflags;
Signature · 1 line
2.34.1
PATCH v2 2/2 mm: vmscan: reclaim contended folios asynchronously instead of promoting them
In reply to [email protected]From: Peifeng Li <[email protected]>
Commit 6d4675e60135 ("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU during shrink_folio_list, even if those folios are very cold.
While running an Android phone with 6GiB memory for 2 hours, I observed that 321728 folios can be incorrectly placed back to the inactive head of the LRU due to lock contention, which amounts to approximately 44 folios per second. Similarly, the same test conducted on 4GiB phones shows that 106 folios are improperly promoted per second. This can have a detrimental effect on performance by increasing refaults and the likelihood of OOM (Out of Memory) killing.
For this reason, the patch introduces a separate list for contended folios and wakes up a new kthread:kshrinkd thread to asynchronously reclaim them, thus preventing excessive violations of LRU rules. This new thread will set try_lock to false and always wait until it holds the lock.
Below is some data collected from two phones running monkey for two hours(less is better):
Phone with 6GiB memory:
w/o patch w/patch delta workingset_refault 1451043114 1408015823 -2.9% lmkd count 9231 9009 -2.4%
Phone with 4GiB memory:
w/o patch w/patch delta workingset_refault 2674649801 2581150132 -3.4% lmkd count 13800 13061 -5.3%
The Monkey is a program that runs on your emulator or device and generates pseudo-random streams of user events such as clicks, touches, or gestures, as well as a number of system-level events.
The Android low memory killer daemon (lmkd) process monitors the memory state of a running Android system and reacts to high memory pressure by killing the least essential processes to keep the system performing at acceptable levels.
--- include/linux/mmzone.h | 6 ++ include/linux/swap.h | 3 + include/linux/vm_event_item.h | 2 + mm/memory_hotplug.c | 2 + mm/vmscan.c | 189 +++++++++++++++++++++++++++++++++- mm/vmstat.c | 2 + 6 files changed, 201 insertions(+), 3 deletions(-)
include/linux/mmzone.h +6 -0
@@ -1332,6 +1332,12 @@ typedef struct pglist_data {int kswapd_failures;/* Number of 'reclaimed == 0' runs */ +struct list_head kshrinkd_folios;/* rmap_walk contended folios list*/ +spinlock_t kf_lock;/* Protect kshrinkd_folios list*/ + +struct task_struct *kshrinkd;/* reclaim kshrinkd_folios*/ +wait_queue_head_t kshrinkd_wait; +#ifdef CONFIG_COMPACTION int kcompactd_max_order;enum zone_type kcompactd_highest_zoneidx;
include/linux/swap.h +3 -0
@@ -438,6 +438,9 @@ void check_move_unevictable_folios(struct folio_batch *fbatch);extern void __meminit kswapd_run (int nid);extern void __meminit kswapd_stop (int nid); +extern void kshrinkd_run (int nid); +extern void kshrinkd_stop (int nid); +#ifdef CONFIG_SWAP int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
include/linux/vm_event_item.h +2 -0
@@ -38,9 +38,11 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,PGLAZYFREED ,PGREFILL ,PGREUSE , +PGSTEAL_KSHRINKD ,PGSTEAL_KSWAPD ,PGSTEAL_DIRECT ,PGSTEAL_KHUGEPAGED , +PGSCAN_KSHRINKD ,PGSCAN_KSWAPD ,PGSCAN_DIRECT , PGSCAN_KHUGEPAGED,
mm/memory_hotplug.c +2 -0
@@ -1218,6 +1218,7 @@ int __ref online_pages(unsigned long pfn, unsigned long nr_pages,kswapd_run (nid);kcompactd_run (nid); +kshrinkd_run (nid);writeback_set_ratelimit ();
@@ -2098,6 +2099,7 @@ int __ref offline_pages(unsigned long start_pfn, unsigned long nr_pages, }if (arg.status_change_nid >=0 ) { +kshrinkd_stop (node);kcompactd_stop (node);kswapd_stop (node); }
mm/vmscan.c +186 -3
303 lines not on this page · raw message
mm/vmstat.c +2 -0
@@ -1279,9 +1279,11 @@ const char * const vmstat_text[] = {"pgrefill" ,"pgreuse" , +"pgsteal_kshrinkd" ,"pgsteal_kswapd" ,"pgsteal_direct" ,"pgsteal_khugepaged" , +"pgscan_kshrinkd" ,"pgscan_kswapd" ,"pgscan_direct" , "pgscan_khugepaged",
Signature · 1 line
2.34.1
Quoted 4 lines · On Fri, Mar 08, 2024 at 11:11:24AM +0800, [email protected] wrote:
Commit
6d4675e60135("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU duringshrink_folio_list, even if those folios are very cold.
This seems like a lot of new code. Did you consider something simpler like this?
Also, this is Minchan's patch you're complaining about. Add him to the cc.
+++ b/mm/vmscan.c
@@ -817,6 +817,7 @@ enum folio_references {
FOLIOREF_RECLAIM,
FOLIOREF_RECLAIM_CLEAN,
FOLIOREF_KEEP,
+ FOLIOREF_RESCAN,
FOLIOREF_ACTIVATE,
};
@@ -837,9 +838,9 @@ static enum folio_references folio_check_references(struct folio *folio,
if (vm_flags & VM_LOCKED)
return FOLIOREF_ACTIVATE;
- /* rmap lock contention: rotate */
+ /* rmap lock contention: keep at the tail */
if (referenced_ptes == -1)
- return FOLIOREF_KEEP;
+ return FOLIOREF_RESCAN;
if (referenced_ptes) {
/*
@@ -1164,6 +1165,7 @@ static unsigned int shrink_folio_list(struct list_head *folio_list,
case FOLIOREF_ACTIVATE:
goto activate_locked;
case FOLIOREF_KEEP:
+ case FOLIOREF_RESCAN:
stat->nr_ref_keep += nr_pages;
goto keep_locked;
case FOLIOREF_RECLAIM:
@@ -1446,7 +1448,10 @@ static unsigned int shrink_folio_list(struct list_head *folio_list,
keep_locked:
folio_unlock(folio); keep:
- list_add(&folio->lru, &ret_folios);
+ if (references == FOLIOREF_RESCAN)
+ list_add(&folio->lru, &rescan_folios);
+ else
+ list_add(&folio->lru, &ret_folios);
VM_BUG_ON_FOLIO(folio_test_lru(folio) ||
folio_test_unevictable(folio), folio);
}Quoted 42 lines · Matthew Wilcox
Quoted 4 lines · On Fri, Mar 08, 2024 at 11:11:24AM +0800,[email protected] wrote:
Commit
6d4675e60135("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU duringshrink_folio_list, even if those folios are very cold.This seems like a lot of new code. Did you consider something simpler like this?
Also, this is Minchan's patch you're complaining about. Add him to the cc.
+++
b/mm/vmscan.c(quoted diff) +4
-2@@ -817,6 +817,7 @@ enum folio_references { FOLIOREF_RECLAIM, FOLIOREF_RECLAIM_CLEAN, FOLIOREF_KEEP, + FOLIOREF_RESCAN, FOLIOREF_ACTIVATE, };@@ -837,9 +838,9 @@ static enum folio_references folio_check_references(struct folio *folio, if (vm_flags & VM_LOCKED) return FOLIOREF_ACTIVATE; - /* rmap lock contention: rotate */ + /* rmap lock contention: keep at the tail */ if (referenced_ptes == -1) - return FOLIOREF_KEEP; + return FOLIOREF_RESCAN; if (referenced_ptes) { /*@@ -1164,6 +1165,7 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, case FOLIOREF_ACTIVATE: goto activate_locked; case FOLIOREF_KEEP: + case FOLIOREF_RESCAN: stat->nr_ref_keep += nr_pages; goto keep_locked; case FOLIOREF_RECLAIM:@@ -1446,7 +1448,10 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, keep_locked:
Review static unsigned int shrink_folio_list(struct list_head *folio_list, · line 1457
Quoted 10 lines
(quoted diff) +4
-1folio_unlock(folio); keep: - list_add(&folio->lru, &ret_folios); + if (references == FOLIOREF_RESCAN) + list_add(&folio->lru, &rescan_folios); + else + list_add(&folio->lru, &ret_folios); VM_BUG_ON_FOLIO(folio_test_lru(folio) || folio_test_unevictable(folio), folio); }
Actually, we have tested the implementation method you mentioned:
Putting back the contended-folios in the tail of LRU during shrink_folio_list
and rescan it in next shrink_folio_list.
In some cases, we found the another serious problems that more and more
contended-folios were piled up at the tail of the LRU, which caused to the
serious lowmem-situation, because none of folios isolated could be reclaimed
since lock-contended during shrink_folio_list.
Quoted 62 lines · 李培锋
Quoted 42 lines · Matthew Wilcox
Quoted 4 lines · On Fri, Mar 08, 2024 at 11:11:24AM +0800,[email protected] wrote:
Commit
6d4675e60135("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU duringshrink_folio_list, even if those folios are very cold.This seems like a lot of new code. Did you consider something simpler like this?
Also, this is Minchan's patch you're complaining about. Add him to the cc.
+++
b/mm/vmscan.c(quoted diff) +4
-2@@ -817,6 +817,7 @@ enum folio_references { FOLIOREF_RECLAIM, FOLIOREF_RECLAIM_CLEAN, FOLIOREF_KEEP, + FOLIOREF_RESCAN, FOLIOREF_ACTIVATE, };@@ -837,9 +838,9 @@ static enum folio_references folio_check_references(struct folio *folio, if (vm_flags & VM_LOCKED) return FOLIOREF_ACTIVATE; - /* rmap lock contention: rotate */ + /* rmap lock contention: keep at the tail */ if (referenced_ptes == -1) - return FOLIOREF_KEEP; + return FOLIOREF_RESCAN; if (referenced_ptes) { /*@@ -1164,6 +1165,7 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, case FOLIOREF_ACTIVATE: goto activate_locked; case FOLIOREF_KEEP: + case FOLIOREF_RESCAN: stat->nr_ref_keep += nr_pages; goto keep_locked; case FOLIOREF_RECLAIM:@@ -1446,7 +1448,10 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, keep_locked:Review static unsigned int shrink_folio_list(struct list_head *folio_list, · line 1457
Quoted 10 lines
(quoted diff) +4
-1folio_unlock(folio); keep: - list_add(&folio->lru, &ret_folios); + if (references == FOLIOREF_RESCAN) + list_add(&folio->lru, &rescan_folios); + else + list_add(&folio->lru, &ret_folios); VM_BUG_ON_FOLIO(folio_test_lru(folio) || folio_test_unevictable(folio), folio); }Actually, we have tested the implementation method you mentioned:
Putting back the contended-folios in the tail of LRU during
shrink_folio_listand rescan it in next
shrink_folio_list.
Quoted 8 lines
In some cases, we found the another serious problems that more and more
contended-folios were piled up at the tail of the LRU, which caused to the
serious lowmem-situation, because none of folios isolated could be reclaimed
since lock-contended during
shrink_folio_list.
Excuse me, do you have any other modification suggestions?
Quoted 62 lines · 李培锋
Quoted 42 lines · Matthew Wilcox
Quoted 4 lines · On Fri, Mar 08, 2024 at 11:11:24AM +0800,[email protected] wrote:
Commit
6d4675e60135("mm: don't be stuck to rmap lock on reclaim path") prevents the reclaim path from becoming stuck on the rmap lock. However, it reinserts those folios at the head of the LRU duringshrink_folio_list, even if those folios are very cold.This seems like a lot of new code. Did you consider something simpler like this?
Also, this is Minchan's patch you're complaining about. Add him to the cc.
+++
b/mm/vmscan.c(quoted diff) +4
-2@@ -817,6 +817,7 @@ enum folio_references { FOLIOREF_RECLAIM, FOLIOREF_RECLAIM_CLEAN, FOLIOREF_KEEP, + FOLIOREF_RESCAN, FOLIOREF_ACTIVATE, };@@ -837,9 +838,9 @@ static enum folio_references folio_check_references(struct folio *folio, if (vm_flags & VM_LOCKED) return FOLIOREF_ACTIVATE; - /* rmap lock contention: rotate */ + /* rmap lock contention: keep at the tail */ if (referenced_ptes == -1) - return FOLIOREF_KEEP; + return FOLIOREF_RESCAN; if (referenced_ptes) { /*@@ -1164,6 +1165,7 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, case FOLIOREF_ACTIVATE: goto activate_locked; case FOLIOREF_KEEP: + case FOLIOREF_RESCAN: stat->nr_ref_keep += nr_pages; goto keep_locked; case FOLIOREF_RECLAIM:@@ -1446,7 +1448,10 @@ static unsigned int shrink_folio_list(struct list_head *folio_list, keep_locked:Review static unsigned int shrink_folio_list(struct list_head *folio_list, · line 1457
Quoted 10 lines
(quoted diff) +4
-1folio_unlock(folio); keep: - list_add(&folio->lru, &ret_folios); + if (references == FOLIOREF_RESCAN) + list_add(&folio->lru, &rescan_folios); + else + list_add(&folio->lru, &ret_folios); VM_BUG_ON_FOLIO(folio_test_lru(folio) || folio_test_unevictable(folio), folio); }Actually, we have tested the implementation method you mentioned:
Putting back the contended-folios in the tail of LRU during
shrink_folio_listand rescan it in next
shrink_folio_list.
Quoted 8 lines
In some cases, we found the another serious problems that more and more
contended-folios were piled up at the tail of the LRU, which caused to the
serious lowmem-situation, because none of folios isolated could be reclaimed
since lock-contended during
shrink_folio_list.
Let me provide more detail.
In fact, we have tested the implementation you mentioned:
if folio is found to be in rmap lock-contention during shrink_folio_list, it would be put back to the end of LRU and rescanned in the next shrink_fofolio_list.
During the testing, we found a serious problem:
In some shrink_folio_list,all isolated pages could not be reclaimed due to rmap lock-contention, resulting in a serious memory reclam inefficiency and insufficient memfree.
The specific reasons are as follows:
In the case of insufficient memory, if folios are put back to the tail of LRU due to rmap lock-contention during shirnk_folio_list, they will be isolated in shrink_inactive_list soon and attempted to be reclaimed by the next shrink_folio_list.But these folios are still likely to fail to reclaim due to rmap lock-contention in the short term and put back to the tail of LRU again.
As the testing progressed, more and more folios with high probability of rmap lock-contention were put back to the tail of the LRU during shrink_inactive_list, ultimately resulting in no folios isolated could be successfully reclaimed in shrink_folio_list.
The shrink_inactive_list procedure does the following:
shrink_inactive_list()
-> isolate_lru_folios():
isolate the 32 folios from the tail of LRU(some of which may have been put back in LRU last shrink_folio_list since rmap lock-contention)
-> shrink_folio_list():
reclaime folios and putback rmap lock-contended folios to the tail of LRU
For example, assuming all folios which were put back in LRU due to rmap lock-contention in last shrink_folio_list, can not be reclaimed successfully because of rmap lock-contention in some case:
1st shrink_inactive_list():
-> isolate_lru_folios():isolate 32 folios
-> shrink_folio_list():reclaim 24 folios, putback 8 rmap lock-contended folios
2nd shrink_inactive_list():
-> isolate_lru_folios():isolate 32 folios, include 8 rmap lock-contended folios
-> shrink_folio_list():reclaim 16 folios, putback 16 rmap lock-contended folios
3rd shrink_inactive_list():
-> isolate_lru_folios():isolate 32 folios, include 16 rmap lock-contended folios
-> shrink_folio_list():reclaim 8 folios, putback 24 rmap lock-contended folios
4th shrink_inactive_list():
-> isolate_lru_folios():isolate 32 folios, include 24 rmap lock-contended folios
-> shrink_folio_list():reclaim 0 folios, putback 32 rmap lock-contended folios
5th shrink_inactive_list():
-> isolate_lru_folios():isolate 32 folios, include 32 rmap lock-contended folios
-> shrink_folio_list():reclaim 0 folios, putback 32 rmap lock-contended folios