From nobody Fri Jul 24 21:52:27 2026 Received: from out-188.mta1.migadu.com (out-188.mta1.migadu.com [95.215.58.188]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 83BB437CD29 for ; Fri, 24 Jul 2026 05:43:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.188 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784871803; cv=none; b=s5cvSqtzfOHX/3qhqIYgoRq+E4s6CROSYE/8o+Q6mq/kSMj46hwOWj/AL2SqSA7b35g+zD7vOOgsVUZ7lC9COuLMF9EVuZACTPmF4gJlxIU0h4GND2hdAJqM3Uuy0eJSUu5Ck4vTbqTQZD5plisonywdKlsB5jeOlX5EdlxhstI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784871803; c=relaxed/simple; bh=dV3uV20/PI0iEWXcntU76S12HvnDTdd5jMD/Y5p5/eE=; h=From:To:Cc:Subject:Date:Message-ID:MIME-Version; b=Tl517YFQeU3X1xSXA3+BH4NEu5HQkHrd4i+lL6eDWzo/b1qA2vh9miIVN/E+5RMX47I9IN661hI849JLjjKcKI1aQuw54yUnedjiXa8qarEwkd1w8YwSE1xHddGifDMibw1vlvgK7xKfnI32OrUdNnR8XmT4H0heNm1vjAHdHTA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=ZBlFDwU7; arc=none smtp.client-ip=95.215.58.188 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="ZBlFDwU7" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1784871798; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding; bh=WN4Rv67wT+Zm0X2Y2iPxniSvUeDNwworrnfhHDaXBV4=; b=ZBlFDwU7OC0cdAAWcB/mjlOKOY4b7AJDiYXymsXjb663Tc7xCo7hOAEjCz4k6kxhmxB3wX arUCaxdjP7a7k13aLHy84HaLlIxro5T3Lzz+yWoriwhsGwuDT4Yg1Fj+qJdcHhPBQ4RHwI 312R+TNR6z1lo3R8Xp45LBDL3aXPoas= From: Tao Cui To: Andrew Morton Cc: linux-mm@kvack.org, Suren Baghdasaryan , Michal Hocko , David Hildenbrand , Lorenzo Stoakes , "Liam R. Howlett" , Vlastimil Babka , Mike Rapoport , linux-kernel@vger.kernel.org, Tao Cui , cui.tao@linux.dev Subject: [PATCH] mm/vmpressure: scale the vmpressure window with machine size Date: Fri, 24 Jul 2026 13:43:05 +0800 Message-ID: <20260724054305.516126-1-cui.tao@linux.dev> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Migadu-Flow: FLOW_OUT Content-Type: text/plain; charset="utf-8" From: Tao Cui 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 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 --- 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); =20 /* 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); =20 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 =3D SWAP_CLUSTER_MAX * 16; +unsigned long vmpressure_win __read_mostly =3D SWAP_CLUSTER_MAX * 16; + +static int __init vmpressure_init_window(void) +{ + unsigned long mem128m; /* machine memory in 128MB units */ + + mem128m =3D totalram_pages() >> (27 - PAGE_SHIFT); + vmpressure_win =3D SWAP_CLUSTER_MAX * 16 * (1 + fls(mem128m)); + return 0; +} +subsys_initcall(vmpressure_init_window); =20 /* * These thresholds are used when we account memory pressure through --=20 2.43.0