Re: [PATCH] mm/vmpressure: scale the vmpressure window with machine size

["Lorenzo Stoakes (ARM)" <ljs@kernel.org>]

No thanks.

Firstly, a change like this should be RFC, especially from somebody who has not
established trust in the community yet.

Secondly, this is more or less identical to a previously rejected patch ([0]) so
seems to be plagiarism since you don't reference that at all.

Thirdly, this is the 2nd time I've seen a submission copying that patch
unacknowledged (see my response to the last one at [1]).

I suspect actually that you're not plagiarising here but rather sending
unacknowledged LLM-generated code in violation of kernel guidelines ([2]) -
since the TODO must be a pretty obvious trigger for agents generating this
patch.

But regardless of which it is, this patch is not welcome.

Thanks, Lorenzo

[0]:https://lore.kernel.org/all/20260227221555.29969-1-mcq@disroot.org/
[1]:https://lore.kernel.org/linux-mm/aljYxLusTzZkTfnH@lucifer/
[2]:https://docs.kernel.org/process/coding-assistants.html

Sorry but no - this is a subtle problem that requires expertise and a strong
argument in favour with data to back it not... this.

On Fri, Jul 24, 2026 at 01:43:05PM +0800, Tao Cui wrote:
> From: Tao Cui <cuitao@kylinos.cn>
>
> vmpressure_win -- the number of pages the reclaimer must scan before
> socket pressure is re-evaluated -- has been a fixed 512 pages (2 MB) since
> vmpressure was introduced.  The reclaimer scans more pages on a larger
> machine, so the window is reached far more often there and socket pressure
> is re-armed every handful of scanned pages.  The comment at the definition
> has asked for the window to scale with machine size "as we do for vmstat
> thresholds" for over a decade.
>
> Scale it the same way calculate_normal_threshold() does: logarithmically
> with memory (fls of memory in 128 MB units), computed once in a
> subsys_initcall once totalram_pages() is known.  A machine under 128 MB
> keeps the historical 512 pages; the window then grows by SWAP_CLUSTER_MAX
> * 16 per doubling of memory.
>
> Why this matters: the scanned/reclaimed ratio that drives socket pressure

"Why this matters"... oh I wonder where I've heard that kind of phrasing
before...

> is averaged over the window, and the window rate-limits the evaluation.
> With a fixed 2 MB window the evaluation runs the same number of times
> regardless of machine size, which is disproportionately many on a large
> machine.  Measured by cold-booting one VM at each size and running the
> same cgroup-bound reclaim workload (so the page count is identical across
> sizes):
>
>     config   scaled_win   pages scanned   512-win evals   scaled evals
>     4 GB     3072         11.9 M          23267           3877
>     8 GB     3584         11.9 M          23306           3329
>     16 GB    4096         11.9 M          23281           2910
>     32 GB    4608         11.9 M          23268           2585
>     64 GB    5120         11.9 M          23281           2328
>
> For the same reclaim work the fixed window evaluates ~23k times at every
> machine size; the scaled window evaluates fewer times the larger the
> machine -- a 6x reduction at 4 GB growing to 10x at 64 GB (and the
> logarithmic growth continues: ~11x projected at 128 GB).  Each evaluation
> takes the per-memcg sr_lock and may write the socket_pressure seqlock, so
> on larger machines with more memcgs under pressure this is real overhead
> the fixed window pays needlessly.
>
> The default stays 512 until the initcall runs, so early-boot reclaim is
> unchanged.
>
> Signed-off-by: Tao Cui <cuitao@kylinos.cn>
> ---
>  include/linux/vmpressure.h |  2 +-
>  mm/vmpressure.c            | 20 +++++++++++++++++---
>  2 files changed, 18 insertions(+), 4 deletions(-)
>
> diff --git a/include/linux/vmpressure.h b/include/linux/vmpressure.h
> index b4d13457bc2a..09111f5bdc88 100644
> --- a/include/linux/vmpressure.h
> +++ b/include/linux/vmpressure.h
> @@ -51,7 +51,7 @@ extern struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg);
>  extern struct mem_cgroup *vmpressure_to_memcg(struct vmpressure *vmpr);
>
>  /* Shared with the v1 vmpressure block in mm/memcontrol-v1.c. */
> -extern const unsigned long vmpressure_win;
> +extern unsigned long vmpressure_win;
>  extern enum vmpressure_levels vmpressure_calc_level(unsigned long scanned,
>  						    unsigned long reclaimed);
>
> diff --git a/mm/vmpressure.c b/mm/vmpressure.c
> index 9629240d77ad..4c8671273c79 100644
> --- a/mm/vmpressure.c
> +++ b/mm/vmpressure.c
> @@ -31,10 +31,24 @@
>   * As the vmscan reclaimer logic works with chunks which are multiple of
>   * SWAP_CLUSTER_MAX, it makes sense to use it for the window size as well.
>   *
> - * TODO: Make the window size depend on machine size, as we do for vmstat
> - * thresholds. Currently we set it to 512 pages (2MB for 4KB pages).
> + * Scale the window with machine size, the way vmstat thresholds do: on a
> + * larger machine the reclaimer scans more pages, so a fixed window would
> + * re-evaluate pressure every handful of pages. The scaling is logarithmic
> + * (fls, like calculate_normal_threshold()), keeping the growth moderate.
> + * The default is the historical 512 pages; an early initcall applies the
> + * scaling once totalram_pages() is known.
>   */
> -const unsigned long vmpressure_win = SWAP_CLUSTER_MAX * 16;
> +unsigned long vmpressure_win __read_mostly = SWAP_CLUSTER_MAX * 16;
> +
> +static int __init vmpressure_init_window(void)
> +{
> +	unsigned long mem128m;	/* machine memory in 128MB units */
> +
> +	mem128m = totalram_pages() >> (27 - PAGE_SHIFT);
> +	vmpressure_win = SWAP_CLUSTER_MAX * 16 * (1 + fls(mem128m));
> +	return 0;
> +}
> +subsys_initcall(vmpressure_init_window);
>
>  /*
>   * These thresholds are used when we account memory pressure through
> --
> 2.43.0
>

Cheers, Lorenzo