mm, pcp: decrease PCP high if free pages < high watermark

One target of PCP is to minimize pages in PCP if the system free pages is
too few.  To reach that target, when page reclaiming is active for the
zone (ZONE_RECLAIM_ACTIVE), we will stop increasing PCP high in allocating
path, decrease PCP high and free some pages in freeing path.  But this may
be too late because the background page reclaiming may introduce latency
for some workloads.  So, in this patch, during page allocation we will
detect whether the number of free pages of the zone is below high
watermark.  If so, we will stop increasing PCP high in allocating path,
decrease PCP high and free some pages in freeing path.  With this, we can
reduce the possibility of the premature background page reclaiming caused
by too large PCP.

The high watermark checking is done in allocating path to reduce the
overhead in hotter freeing path.

Link: https://lkml.kernel.org/r/20231016053002.756205-9-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: David Hildenbrand <david@redhat.com>
Cc: Johannes Weiner <jweiner@redhat.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Pavel Tatashin <pasha.tatashin@soleen.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Christoph Lameter <cl@linux.com>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Sudeep Holla <sudeep.holla@arm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 775abc899e80733490f43ca138f98f3d6f64ed71..b92ab001e146856c1591b4e6cf4910430037820e 100644 (file)
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -1016,6 +1016,7 @@ enum zone_flags {
                                         * Cleared when kswapd is woken.
                                         */
        ZONE_RECLAIM_ACTIVE,            /* kswapd may be scanning the zone. */
+       ZONE_BELOW_HIGH,                /* zone is below high watermark. */
 };
 
 static inline unsigned long zone_managed_pages(struct zone *zone)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 83af76a8cef9b0d94f87d55f0d59d7e1f6dd9a9f..58ab8389da05a13c046bc818c71f35d900d1e339 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2407,7 +2407,13 @@ static int nr_pcp_high(struct per_cpu_pages *pcp, struct zone *zone,
                return min(batch << 2, pcp->high);
        }
 
-       if (pcp->count >= high && high_min != high_max) {
+       if (high_min == high_max)
+               return high;
+
+       if (test_bit(ZONE_BELOW_HIGH, &zone->flags)) {
+               pcp->high = max(high - (batch << pcp->free_factor), high_min);
+               high = max(pcp->count, high_min);
+       } else if (pcp->count >= high) {
                int need_high = (batch << pcp->free_factor) + batch;
 
                /* pcp->high should be large enough to hold batch freed pages */
@@ -2457,6 +2463,10 @@ static void free_unref_page_commit(struct zone *zone, struct per_cpu_pages *pcp,
        if (pcp->count >= high) {
                free_pcppages_bulk(zone, nr_pcp_free(pcp, batch, high, free_high),
                                   pcp, pindex);
+               if (test_bit(ZONE_BELOW_HIGH, &zone->flags) &&
+                   zone_watermark_ok(zone, 0, high_wmark_pages(zone),
+                                     ZONE_MOVABLE, 0))
+                       clear_bit(ZONE_BELOW_HIGH, &zone->flags);
        }
 }
 
@@ -2763,7 +2773,7 @@ static int nr_pcp_alloc(struct per_cpu_pages *pcp, struct zone *zone, int order)
         * If we had larger pcp->high, we could avoid to allocate from
         * zone.
         */
-       if (high_min != high_max && !test_bit(ZONE_RECLAIM_ACTIVE, &zone->flags))
+       if (high_min != high_max && !test_bit(ZONE_BELOW_HIGH, &zone->flags))
                high = pcp->high = min(high + batch, high_max);
 
        if (!order) {
@@ -3225,6 +3235,25 @@ retry:
                        }
                }
 
+               /*
+                * Detect whether the number of free pages is below high
+                * watermark.  If so, we will decrease pcp->high and free
+                * PCP pages in free path to reduce the possibility of
+                * premature page reclaiming.  Detection is done here to
+                * avoid to do that in hotter free path.
+                */
+               if (test_bit(ZONE_BELOW_HIGH, &zone->flags))
+                       goto check_alloc_wmark;
+
+               mark = high_wmark_pages(zone);
+               if (zone_watermark_fast(zone, order, mark,
+                                       ac->highest_zoneidx, alloc_flags,
+                                       gfp_mask))
+                       goto try_this_zone;
+               else
+                       set_bit(ZONE_BELOW_HIGH, &zone->flags);
+
+check_alloc_wmark:
                mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
                if (!zone_watermark_fast(zone, order, mark,
                                       ac->highest_zoneidx, alloc_flags,