mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Ridong Chen <ridong.chen@linux.dev>
To: "Barry Song (Xiaomi)" <baohua@kernel.org>,
	akpm@linux-foundation.org, linux-mm@kvack.org
Cc: axelrasmussen@google.com, baolin.wang@linux.alibaba.com,
	baoquan.he@linux.dev, hannes@cmpxchg.org, hui.zhu@linux.dev,
	kasong@tencent.com, kunwu.chan@gmail.com, liam@infradead.org,
	lianux.mm@gmail.com, linux-kernel@vger.kernel.org,
	liuxiang.277@bytedance.com, lyugaofei@xiaomi.com,
	mhocko@kernel.org, mhocko@suse.com, qi.zheng@linux.dev,
	rppt@kernel.org, ryncsn@gmail.com, shakeel.butt@linux.dev,
	surenb@google.com, wangzicheng@honor.com, weixugc@google.com,
	yuanchu@google.com, zhangbo56@xiaomi.com, zhuhui@kylinos.cn,
	sidchintamaneni@gmail.com
Subject: Re: [PATCH v9 07/16] mm/mglru: balance anon and file scan budget by refault rate
Date: Thu, 19 Nov 2026 17:48:38 +0800	[thread overview]
Message-ID: <5238e574-ed22-4781-aac2-b91a6b2d911e@linux.dev> (raw)
In-Reply-To: <20261114200803.23129-8-baohua@kernel.org>



On 11/15/2026 4:07 AM, Barry Song (Xiaomi) wrote:
> From: Kairui Song <kasong@tencent.com>
> 
> Replace get_type_to_scan() and isolate_folios(), which selected one
> type per batch, with a proportional split of the scan budget between
> anon and file, and scan both types each round.
> 
> lru_gen_balance_scan() splits the total by
> 
>          anon : file = swappiness * r_file * w_anon :
>                        (MAX_SWAPPINESS - swappiness) * r_anon * w_file
> 
> where r_anon and r_file are the per-type refault rates scaled by
> 4096, clamped to [1, 4096]; a rate at the 4096 ceiling means the type
> refaults at least as often as it is evicted. The w factors bias the
> split toward the LRU sizes at mild swappiness and follow the IO cost
> ratio at the extremes. Both rate accumulators start at MIN_LRU_BATCH,
> so a type without eviction history reads as 100% until evictions
> accumulate, and the floor of 1 keeps a type that never refaults from
> zeroing out the other type's share. Swappiness 0 and
> SWAPPINESS_ANON_ONLY keep their single-type behavior; at swappiness ==
> MAX_SWAPPINESS the file factor is zero, so anon gets the whole budget,
> as in the classical LRU; swappiness 1 no longer forces file-only
> scanning as the old code did.
> 
> The proportional protection and priority reduction are applied to the
> total once, before the split, and each budget is capped at its type's
> evictable size. Regular reclaim derives the total from the evictable
> sizes, so the budgets sum to it. The proactive path re-splits the
> remaining target each round, so eviction keeps working while either
> type makes progress, until the target is met or no progress is
> possible. The debugfs scan_control gets .priority = DEF_PRIORITY so
> eviction starts from the oldest gen and reports the default priority
> in the tracepoints.
> 
> Note that we are already lenient with the debugfs proactive
> reclaim interface. We may reclaim one generation ahead even
> at `DEF_PRIORITY`, and with extreme swappiness values such
> as 1 and 200, we may not fall back to the other type.
> 
> To address these cases and preserve the behavior of the
> previous model before scan-budget-based reclaim, we would
> need to add another flag to `scan_control`. However, this
> may not be worthwhile for a debugfs interface that is likely
> to be rarely used, especially given that we already have
> memory-level and node-level proactive reclaim interfaces.
> 
> Signed-off-by: Kairui Song <kasong@tencent.com>
> Co-developed-by: Gaofei Lyu <lyugaofei@xiaomi.com>
> Signed-off-by: Gaofei Lyu <lyugaofei@xiaomi.com>
> Signed-off-by: Barry Song (Xiaomi) <baohua@kernel.org>
> ---
>   mm/vmscan.c | 219 +++++++++++++++++++++++++++++++++-------------------
>   1 file changed, 138 insertions(+), 81 deletions(-)
> 
> diff --git a/mm/vmscan.c b/mm/vmscan.c
> index f7fbe91fedf3..18cf1c084e78 100644
> --- a/mm/vmscan.c
> +++ b/mm/vmscan.c
> @@ -4863,79 +4863,110 @@ static int get_tier_idx(struct lruvec *lruvec, int type)
>   	return tier - 1;
>   }
>   
> -static int get_type_to_scan(struct lruvec *lruvec, int swappiness)
> +/*
> + * Balance the anon vs file scan budget using MGLRU's per-type refault
> + * rates, where swappiness is the relative IO cost of anon vs file (see
> + * Documentation/admin-guide/sysctl/vm.rst).
> + *
> + * On entry, nr[] holds the evictable size of each type, on return it
> + * holds each type's scan budget, bounded by its evictable size.
> + *
> + * LRU lock not needed: a stale snapshot merely skews the split for one pass,
> + * and MGLRU aging averages the fault rate so we can simply read it, no need
> + * to do any extra work here. If reclaim is blocked by unfair type hotness or
> + * stall aging, the priority will raise and a raised priority drives the
> + * aging.
> + *
> + * Calculation is basically based on following formula with a LRU size bias:
> + *
> + * anon : file = swappiness * r_file * w_anon :
> + *               (MAX_SWAPPINESS - swappiness) * r_anon * w_file
> + *
> + * r_file / r_anon: refault rate for file / anon.
> + * w_file / w_anon: LRU size weight of file / anon.
> + *
> + * We don't calculate the scan cost. MGLRU uses lazy promotion, which will
> + * cancel the scan budget naturally.
> + */
> +static void lru_gen_balance_scan(struct lruvec *lruvec, int swappiness,
> +		unsigned long total_scan, unsigned long nr[])
>   {
> -	struct ctrl_pos sp, pv;
> +	struct lru_gen_folio *lrugen = &lruvec->lrugen;
> +	u64 refault_rate[ANON_AND_FILE], anon_factor, file_factor;
> +	u64 anon_scan, file_scan, total;
> +	u64 anon_weight, file_weight;
> +	int size_bias;
>   
> -	if (swappiness <= MIN_SWAPPINESS + 1)
> -		return LRU_GEN_FILE;
> +	total = nr[LRU_GEN_ANON] + nr[LRU_GEN_FILE];
> +	if (!total)
> +		return;
>   
> -	if (swappiness >= MAX_SWAPPINESS)
> -		return LRU_GEN_ANON;
> -	/*
> -	 * Compare the sum of all tiers of anon with that of file to determine
> -	 * which type to scan.
> -	 */
> -	read_ctrl_pos(lruvec, LRU_GEN_ANON, LRU_TIER_MIN, LRU_TIER_MAX,
> -		      swappiness, &sp);
> -	read_ctrl_pos(lruvec, LRU_GEN_FILE, LRU_TIER_MIN, LRU_TIER_MAX,
> -		      MAX_SWAPPINESS - swappiness, &pv);
> +	if (swappiness <= MIN_SWAPPINESS) {
> +		nr[LRU_GEN_ANON] = 0;
> +		nr[LRU_GEN_FILE] = min_t(u64, total_scan, nr[LRU_GEN_FILE]);
> +		return;
> +	}
>   
> -	return positive_ctrl_err(&sp, &pv);
> -}
> +	if (swappiness == SWAPPINESS_ANON_ONLY) {
> +		nr[LRU_GEN_FILE] = 0;
> +		nr[LRU_GEN_ANON] = min_t(u64, total_scan, nr[LRU_GEN_ANON]);
> +		return;
> +	}
>   
> -static inline bool is_single_type_reclaim(int swappiness)
> -{
> -	return swappiness == MIN_SWAPPINESS ||
> -	       swappiness == SWAPPINESS_ANON_ONLY;
> -}
> +	for (int type = LRU_GEN_ANON; type <= LRU_GEN_FILE; type++) {
> +		int hist = lru_hist_from_seq(READ_ONCE(lrugen->min_seq[type]));
> +		/* start at MIN_LRU_BATCH to smooth the rate on gen start */
> +		u64 refaulted = MIN_LRU_BATCH, evicted = MIN_LRU_BATCH;
>   
> -static int isolate_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
> -			  struct scan_control *sc, int swappiness,
> -			  struct list_head *list, int *isolated,
> -			  int *isolate_type, int *isolate_scanned)
> -{
> -	bool type_fallback_allowed = !is_single_type_reclaim(swappiness);
> -	int type = get_type_to_scan(lruvec, swappiness);
> -	int total_scanned = 0, scanned, tier;
> -	bool tried = false;
> +		for (int tier = 0; tier < MAX_NR_TIERS; tier++) {
> +			refaulted += READ_ONCE(lrugen->avg_refaulted[type][tier]);
> +			refaulted += atomic_long_read(&lrugen->refaulted[hist][type][tier]);
>   
> -retry:
> -	tier = get_tier_idx(lruvec, type);
> -	scanned = scan_folios(nr_to_scan, lruvec, sc,
> -			      type, tier, list, isolated);
> +			evicted += READ_ONCE(lrugen->avg_total[type][tier]);
> +			evicted += atomic_long_read(&lrugen->evicted[hist][type][tier]);
> +		}
>   
> -	total_scanned += scanned;
> -	if (*isolated) {
> -		*isolate_type = type;
> -		*isolate_scanned = scanned;
> -		return total_scanned;
> +		/*
> +		 * The rate scaled by 4096 to survive integer division, clamped
> +		 * to [1, 4096] (~0% - 100%), the floor of 1 keeps a type that
> +		 * never refaults from zeroing out the other type's share.
> +		 */
> +		refault_rate[type] = mul_u64_u64_div_u64(refaulted, 4096, evicted);
> +		refault_rate[type] = clamp_t(u64, refault_rate[type], 1, 4096);
>   	}
>   
>   	/*
> -	 * We are running out of the current reclaim type. Fall back to
> -	 * the other type if allowed.
> +	 * The more extreme the swappiness, the wider the IO cost gap between
> +	 * anon and file, so the split should follow the IO cost ratio rather
> +	 * than the sizes. With a mild swappiness, balance the scan by the
> +	 * actual LRU size more.
>   	 */
> -	if (!scanned && !tried && type_fallback_allowed) {
> -		type = !type;
> -		tried = true;
> -		type_fallback_allowed = false;
> -		goto retry;
> -	}

Hi Kairui, Barry,

A question about the size weight:

> +	size_bias = max(1, min(swappiness, MAX_SWAPPINESS - swappiness));
> +	anon_weight = nr[LRU_GEN_ANON] + nr[LRU_GEN_FILE] / size_bias;
> +	file_weight = nr[LRU_GEN_FILE] + nr[LRU_GEN_ANON] / size_bias;
> +

In the classic LRU, get_scan_count() weights each type by its own size
only.

Here each weight also includes the other type's size / size_bias. So
around swappiness 100 the split follows the sizes like the classic LRU,
but near swappiness 1 or 199 the sizes cancel out and the split follows
swappiness only.

For example, anon 3G, file 100M, same refault rate, anon share of the
scan budget:

	  swappiness   classic   this patch
		 100         97%        96%
		  10         62%        28%
		   1         13%       0.5%

Having two behaviors in one formula is a bit confusing. What is the
reason for this blending, and is there data behind it? Would weighting
each type only by its own size, like get_scan_count(), work as well?

> +	anon_factor = (u64)swappiness * refault_rate[LRU_GEN_FILE] * anon_weight;
> +	file_factor = (u64)(MAX_SWAPPINESS - swappiness) * refault_rate[LRU_GEN_ANON] * file_weight;
> +
> +	/* Cross-multiply the ratio above. */
> +	anon_scan = mul_u64_u64_div_u64(total_scan, anon_factor, anon_factor + file_factor);
> +	file_scan = (u64)total_scan - anon_scan;
> +
>   	/*
> -	 * We scanned some folios but failed to isolate any due to promotions,
> -	 * protections, or races. Retry once to avoid a larger loop.
> +	 * Bound each type by its evictable size. Hand the exceeding part to
> +	 * the other type. Any excess left when total_scan exceeds both sizes
> +	 * is dropped, since it only stresses the scanner with no gain.
>   	 */
> -	if (scanned && !tried) {
> -		tried = true;
> -		goto retry;
> -	}
> -
> -	return total_scanned;
> +	if (anon_scan > nr[LRU_GEN_ANON])
> +		file_scan += anon_scan - nr[LRU_GEN_ANON];
> +	else if (file_scan > nr[LRU_GEN_FILE])
> +		anon_scan += file_scan - nr[LRU_GEN_FILE];
> +	nr[LRU_GEN_ANON] = min_t(u64, anon_scan, nr[LRU_GEN_ANON]);
> +	nr[LRU_GEN_FILE] = min_t(u64, file_scan, nr[LRU_GEN_FILE]);
>   }
>   
>   static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
> -			struct scan_control *sc, int swappiness)
> +			struct scan_control *sc, int type, int swappiness)
>   {
>   	LIST_HEAD(list);
>   	LIST_HEAD(clean);
> @@ -4944,8 +4975,8 @@ static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
>   	enum node_stat_item item;
>   	struct reclaim_stat stat;
>   	struct lru_gen_mm_walk *walk;
> -	int scanned, reclaimed;
> -	int isolated = 0, nr_isolated = 0, type, type_scanned;
> +	int tier, scanned, reclaimed;
> +	int isolated = 0, nr_isolated = 0;
>   	unsigned long total_reclaimed = 0;
>   	bool skip_retry = false;
>   	struct mem_cgroup *memcg = lruvec_memcg(lruvec);
> @@ -4956,8 +4987,9 @@ static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
>   	/* In case folio deletion left empty old gens, flush them */
>   	try_to_inc_min_seq(lruvec, swappiness);
>   
> -	scanned = isolate_folios(nr_to_scan, lruvec, sc, swappiness,
> -				 &list, &isolated, &type, &type_scanned);
> +	tier = get_tier_idx(lruvec, type);
> +	scanned = scan_folios(nr_to_scan, lruvec, sc,
> +			      type, tier, &list, &isolated);
>   	nr_isolated = isolated;
>   	if (nr_isolated)
>   		__mod_node_page_state(pgdat, NR_ISOLATED_ANON + type,
> @@ -4979,7 +5011,7 @@ static int evict_folios(unsigned long nr_to_scan, struct lruvec *lruvec,
>   	if (isolated)
>   		handle_reclaim_writeback(isolated, pgdat, sc, &stat);
>   	trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
> -			type_scanned, reclaimed, &stat, sc,
> +			scanned, reclaimed, &stat, sc,
>   			type ? LRU_INACTIVE_FILE : LRU_INACTIVE_ANON);
>   
>   	list_for_each_entry_safe_reverse(folio, next, &list, lru) {
> @@ -5056,18 +5088,18 @@ static bool should_run_aging(struct lruvec *lruvec, unsigned long max_seq,
>   	return evictable_min_seq(min_seq, swappiness) + MIN_NR_GENS == max_seq;
>   }
>   
> -static long get_nr_to_scan(struct lruvec *lruvec, struct scan_control *sc,
> -			   struct mem_cgroup *memcg, int swappiness)
> +static void lru_gen_prepare_scan(struct lruvec *lruvec, struct scan_control *sc,
> +		struct mem_cgroup *memcg, int swappiness,
> +		unsigned long nr_to_scan[])
>   {
> -	unsigned long nr_to_scan, evictable, sizes[ANON_AND_FILE];
> -
> -	lruvec_evictable_size(lruvec, swappiness, sizes);
> -	evictable = sizes[LRU_GEN_ANON] + sizes[LRU_GEN_FILE];
> +	unsigned long total;
>   
> -	nr_to_scan = apply_proportional_protection(memcg, sc, evictable);
> -	nr_to_scan >>= sc->priority;
> +	lruvec_evictable_size(lruvec, swappiness, nr_to_scan);
> +	total = nr_to_scan[LRU_GEN_ANON] + nr_to_scan[LRU_GEN_FILE];
>   
> -	return nr_to_scan;
> +	total = apply_proportional_protection(memcg, sc, total);
> +	total >>= sc->priority;
> +	lru_gen_balance_scan(lruvec, swappiness, total, nr_to_scan);
>   }
>   
>   static bool should_abort_scan(struct lruvec *lruvec, struct scan_control *sc)
> @@ -5100,6 +5132,30 @@ static bool should_abort_scan(struct lruvec *lruvec, struct scan_control *sc)
>   	return true;
>   }
>   
> +static long evict_folio_lists(unsigned long nr_to_scan[], struct lruvec *lruvec,
> +			     struct scan_control *sc, int swappiness, unsigned long max_batch)
> +{
> +	int type;
> +	unsigned long batch, scanned, total_scanned = 0;
> +
> +	/*
> +	 * Scan both types with the given budgets; the caller checks if
> +	 * reclaim is satisfied after each pass.
> +	 */
> +	for (type = LRU_GEN_FILE; type >= LRU_GEN_ANON; type--) {
> +		if (!nr_to_scan[type])
> +			continue;
> +
> +		batch = min(nr_to_scan[type], max_batch);
> +		scanned = evict_folios(batch, lruvec, sc, type, swappiness);
> +
> +		nr_to_scan[type] -= min(nr_to_scan[type], scanned);
> +		total_scanned += scanned;
> +	}
> +
> +	return total_scanned;
> +}
> +
>   /*
>    * For future optimizations:
>    * 1. Defer try_to_inc_max_seq() to workqueues to reduce latency for memcg
> @@ -5107,8 +5163,8 @@ static bool should_abort_scan(struct lruvec *lruvec, struct scan_control *sc)
>    */
>   static bool try_to_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc)
>   {
> +	unsigned long nr[ANON_AND_FILE];
>   	bool need_rotate = false, should_age = false;
> -	long nr_batch, nr_to_scan;
>   	int swappiness = get_swappiness(lruvec, sc);
>   	struct mem_cgroup *memcg = lruvec_memcg(lruvec);
>   
> @@ -5125,9 +5181,9 @@ static bool try_to_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc)
>   			return false;
>   	}
>   
> -	nr_to_scan = get_nr_to_scan(lruvec, sc, memcg, swappiness);
> -	while (nr_to_scan > 0) {
> -		int delta;
> +	lru_gen_prepare_scan(lruvec, sc, memcg, swappiness, nr);
> +
> +	while (nr[LRU_GEN_ANON] > 0 || nr[LRU_GEN_FILE] > 0) {
>   		DEFINE_MAX_SEQ(lruvec);
>   
>   		if (mem_cgroup_below_min(sc->target_mem_cgroup, memcg)) {
> @@ -5142,9 +5198,7 @@ static bool try_to_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc)
>   			should_age = true;
>   		}
>   
> -		nr_batch = min(nr_to_scan, MIN_LRU_BATCH);
> -		delta = evict_folios(nr_batch, lruvec, sc, swappiness);
> -		if (!delta)
> +		if (!evict_folio_lists(nr, lruvec, sc, swappiness, MIN_LRU_BATCH))
>   			break;
>   
>   		if (should_abort_scan(lruvec, sc))
> @@ -5157,7 +5211,6 @@ static bool try_to_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc)
>   		if (root_reclaim(sc) && should_age)
>   			break;
>   
> -		nr_to_scan -= delta;
>   		cond_resched();
>   	}
>   
> @@ -5769,8 +5822,8 @@ static int run_aging(struct lruvec *lruvec, unsigned long seq,
>   static int run_eviction(struct lruvec *lruvec, unsigned long seq, struct scan_control *sc,
>   			int swappiness, unsigned long nr_to_reclaim)
>   {
> -	int nr_batch;
>   	DEFINE_MAX_SEQ(lruvec);
> +	unsigned long nr_to_scan[ANON_AND_FILE];
>   
>   	if (seq + MIN_NR_GENS > max_seq)
>   		return -EINVAL;
> @@ -5786,8 +5839,11 @@ static int run_eviction(struct lruvec *lruvec, unsigned long seq, struct scan_co
>   		if (sc->nr_reclaimed >= nr_to_reclaim)
>   			return 0;
>   
> -		nr_batch = min(nr_to_reclaim - sc->nr_reclaimed, MAX_LRU_BATCH);
> -		if (!evict_folios(nr_batch, lruvec, sc, swappiness))
> +		lruvec_evictable_size(lruvec, swappiness, nr_to_scan);
> +		lru_gen_balance_scan(lruvec, swappiness,
> +				     nr_to_reclaim - sc->nr_reclaimed, nr_to_scan);
> +
> +		if (!evict_folio_lists(nr_to_scan, lruvec, sc, swappiness, MAX_LRU_BATCH))
>   			return 0;
>   
>   		cond_resched();
> @@ -5850,6 +5906,7 @@ static ssize_t lru_gen_seq_write(struct file *file, const char __user *src,
>   		.may_writepage = true,
>   		.may_unmap = true,
>   		.may_swap = true,
> +		.priority = DEF_PRIORITY,
>   		.reclaim_idx = MAX_NR_ZONES - 1,
>   		.gfp_mask = GFP_KERNEL,
>   		.proactive = true,

-- 
Best regards
Ridong


  reply	other threads:[~2026-11-19  9:48 UTC|newest]

Thread overview: 31+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-14 20:07 [PATCH v9 00/16] mm: mglru: fix swappiness behavior Barry Song (Xiaomi)
2026-11-14 20:07 ` [PATCH v9 01/16] mm/mglru: report evictable sizes per type Barry Song (Xiaomi)
2026-11-16 11:29   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 02/16] mm/mglru: extract lruvec_populated_min_seq() helper Barry Song (Xiaomi)
2026-11-16 11:58   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 03/16] mm/mglru: reclaim from the oldest populated gen Barry Song (Xiaomi)
2026-11-16 12:27   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 04/16] mm/mglru: lift the forced protection of reclaimer Barry Song (Xiaomi)
2026-11-18 10:50   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 05/16] mm/mglru: skip zones above reclaim_idx instead of rotating them Barry Song (Xiaomi)
2026-11-18 11:22   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 06/16] mm/mglru: return for unavailable anon reclaim earlier Barry Song (Xiaomi)
2026-11-18 11:23   ` Ridong Chen
2026-11-14 20:07 ` [PATCH v9 07/16] mm/mglru: balance anon and file scan budget by refault rate Barry Song (Xiaomi)
2026-11-19  9:48   ` Ridong Chen [this message]
2026-11-14 20:07 ` [PATCH v9 08/16] mm/mglru: lift youngest gen protection for higher priority Barry Song (Xiaomi)
2026-11-14 20:07 ` [PATCH v9 09/16] mm/mglru: Avoid placing rejected folios below populated gen Barry Song (Xiaomi)
2026-11-15 15:15   ` Kairui Song
2026-11-14 20:07 ` [PATCH v9 10/16] mm/mglru: Run aging when pages are rare outside the youngest gen Barry Song (Xiaomi)
2026-11-15 15:54   ` Kairui Song
2026-11-16  4:25     ` Barry Song (Xiaomi)
2026-11-16  4:50       ` Andrew Morton
2026-11-16  5:29         ` Barry Song
2026-11-14 20:07 ` [PATCH v9 11/16] mm/mglru: Run aging when one type is drained Barry Song (Xiaomi)
2026-11-14 20:07 ` [PATCH v9 12/16] mm/mglru: Restrict eviction accounting to eligible zones Barry Song (Xiaomi)
2026-11-14 20:08 ` [PATCH v9 13/16] mm/mglru: Reduce LRU lock contention by shrinking folio batches in inc_min_seq Barry Song (Xiaomi)
2026-11-15 15:52   ` Kairui Song
2026-11-14 20:08 ` [PATCH v9 14/16] mm/mglru: Avoid prolonged anon reclaim with swappiness=200 Barry Song (Xiaomi)
2026-11-14 20:08 ` [PATCH v9 15/16] mm/mglru: Make swappiness=1 file reclaim more aggressive Barry Song (Xiaomi)
2026-11-14 20:08 ` [PATCH v9 16/16] mm/mglru: Avoid scan anon while swapcache is low for GFP_NOIO allocation Barry Song (Xiaomi)
2026-11-14 22:09 ` [PATCH v9 00/16] mm: mglru: fix swappiness behavior Andrew Morton

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=5238e574-ed22-4781-aac2-b91a6b2d911e@linux.dev \
    --to=ridong.chen@linux.dev \
    --cc=akpm@linux-foundation.org \
    --cc=axelrasmussen@google.com \
    --cc=baohua@kernel.org \
    --cc=baolin.wang@linux.alibaba.com \
    --cc=baoquan.he@linux.dev \
    --cc=hannes@cmpxchg.org \
    --cc=hui.zhu@linux.dev \
    --cc=kasong@tencent.com \
    --cc=kunwu.chan@gmail.com \
    --cc=liam@infradead.org \
    --cc=lianux.mm@gmail.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mm@kvack.org \
    --cc=liuxiang.277@bytedance.com \
    --cc=lyugaofei@xiaomi.com \
    --cc=mhocko@kernel.org \
    --cc=mhocko@suse.com \
    --cc=qi.zheng@linux.dev \
    --cc=rppt@kernel.org \
    --cc=ryncsn@gmail.com \
    --cc=shakeel.butt@linux.dev \
    --cc=sidchintamaneni@gmail.com \
    --cc=surenb@google.com \
    --cc=wangzicheng@honor.com \
    --cc=weixugc@google.com \
    --cc=yuanchu@google.com \
    --cc=zhangbo56@xiaomi.com \
    --cc=zhuhui@kylinos.cn \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®