mm: page_alloc: fair zone allocator policy

Each zone that holds userspace pages of one workload must be aged at a
speed proportional to the zone size.  Otherwise, the time an individual
page gets to stay in memory depends on the zone it happened to be
allocated in.  Asymmetry in the zone aging creates rather unpredictable
aging behavior and results in the wrong pages being reclaimed, activated
etc.

But exactly this happens right now because of the way the page allocator
and kswapd interact.  The page allocator uses per-node lists of all zones
in the system, ordered by preference, when allocating a new page.  When
the first iteration does not yield any results, kswapd is woken up and the
allocator retries.  Due to the way kswapd reclaims zones below the high
watermark while a zone can be allocated from when it is above the low
watermark, the allocator may keep kswapd running while kswapd reclaim
ensures that the page allocator can keep allocating from the first zone in
the zonelist for extended periods of time.  Meanwhile the other zones
rarely see new allocations and thus get aged much slower in comparison.

The result is that the occasional page placed in lower zones gets
relatively more time in memory, even gets promoted to the active list
after its peers have long been evicted.  Meanwhile, the bulk of the
working set may be thrashing on the preferred zone even though there may
be significant amounts of memory available in the lower zones.

Even the most basic test -- repeatedly reading a file slightly bigger than
memory -- shows how broken the zone aging is.  In this scenario, no single
page should be able stay in memory long enough to get referenced twice and
activated, but activation happens in spades:

  $ grep active_file /proc/zoneinfo
      nr_inactive_file 0
      nr_active_file 0
      nr_inactive_file 0
      nr_active_file 8
      nr_inactive_file 1582
      nr_active_file 11994
  $ cat data data data data >/dev/null
  $ grep active_file /proc/zoneinfo
      nr_inactive_file 0
      nr_active_file 70
      nr_inactive_file 258753
      nr_active_file 443214
      nr_inactive_file 149793
      nr_active_file 12021

Fix this with a very simple round robin allocator.  Each zone is allowed a
batch of allocations that is proportional to the zone's size, after which
it is treated as full.  The batch counters are reset when all zones have
been tried and the allocator enters the slowpath and kicks off kswapd
reclaim.  Allocation and reclaim is now fairly spread out to all
available/allowable zones:

  $ grep active_file /proc/zoneinfo
      nr_inactive_file 0
      nr_active_file 0
      nr_inactive_file 174
      nr_active_file 4865
      nr_inactive_file 53
      nr_active_file 860
  $ cat data data data data >/dev/null
  $ grep active_file /proc/zoneinfo
      nr_inactive_file 0
      nr_active_file 0
      nr_inactive_file 666622
      nr_active_file 4988
      nr_inactive_file 190969
      nr_active_file 937

When zone_reclaim_mode is enabled, allocations will now spread out to all
zones on the local node, not just the first preferred zone (which on a 4G
node might be a tiny Normal zone).

Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Paul Bolle <paul.bollee@gmail.com>
Cc: Zlatko Calusic <zcalusic@bitsync.net>
Tested-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 63 insertions, 10 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 9884aa0f233a..544d19d681a2 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1551,6 +1551,7 @@ again:
                                           get_pageblock_migratetype(page));
         }
 
+        __mod_zone_page_state(zone, NR_ALLOC_BATCH, -(1 << order));
         __count_zone_vm_events(PGALLOC, zone, 1 << order);
         zone_statistics(preferred_zone, zone, gfp_flags);
         local_irq_restore(flags);
@@ -1817,6 +1818,11 @@ static void zlc_clear_zones_full(struct zonelist *zonelist)
         bitmap_zero(zlc->fullzones, MAX_ZONES_PER_ZONELIST);
 }
 
+static bool zone_local(struct zone *local_zone, struct zone *zone)
+{
+        return node_distance(local_zone->node, zone->node) == LOCAL_DISTANCE;
+}
+
 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
 {
         return node_isset(local_zone->node, zone->zone_pgdat->reclaim_nodes);
@@ -1854,6 +1860,11 @@ static void zlc_clear_zones_full(struct zonelist *zonelist)
 {
 }
 
+static bool zone_local(struct zone *local_zone, struct zone *zone)
+{
+        return true;
+}
+
 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
 {
         return true;
@@ -1901,6 +1912,26 @@ zonelist_scan:
                 if (alloc_flags & ALLOC_NO_WATERMARKS)
                         goto try_this_zone;
                 /*
+                 * Distribute pages in proportion to the individual
+                 * zone size to ensure fair page aging.  The zone a
+                 * page was allocated in should have no effect on the
+                 * time the page has in memory before being reclaimed.
+                 *
+                 * When zone_reclaim_mode is enabled, try to stay in
+                 * local zones in the fastpath.  If that fails, the
+                 * slowpath is entered, which will do another pass
+                 * starting with the local zones, but ultimately fall
+                 * back to remote zones that do not partake in the
+                 * fairness round-robin cycle of this zonelist.
+                 */
+                if (alloc_flags & ALLOC_WMARK_LOW) {
+                        if (zone_page_state(zone, NR_ALLOC_BATCH) <= 0)
+                                continue;
+                        if (zone_reclaim_mode &&
+                            !zone_local(preferred_zone, zone))
+                                continue;
+                }
+                /*
                  * When allocating a page cache page for writing, we
                  * want to get it from a zone that is within its dirty
                  * limit, such that no single zone holds more than its
@@ -2346,16 +2377,30 @@ __alloc_pages_high_priority(gfp_t gfp_mask, unsigned int order,
         return page;
 }
 
-static inline
-void wake_all_kswapd(unsigned int order, struct zonelist *zonelist,
-                                                enum zone_type high_zoneidx,
-                                                enum zone_type classzone_idx)
+static void prepare_slowpath(gfp_t gfp_mask, unsigned int order,
+                             struct zonelist *zonelist,
+                             enum zone_type high_zoneidx,
+                             struct zone *preferred_zone)
 {
         struct zoneref *z;
         struct zone *zone;
 
-        for_each_zone_zonelist(zone, z, zonelist, high_zoneidx)
-                wakeup_kswapd(zone, order, classzone_idx);
+        for_each_zone_zonelist(zone, z, zonelist, high_zoneidx) {
+                if (!(gfp_mask & __GFP_NO_KSWAPD))
+                        wakeup_kswapd(zone, order, zone_idx(preferred_zone));
+                /*
+                 * Only reset the batches of zones that were actually
+                 * considered in the fast path, we don't want to
+                 * thrash fairness information for zones that are not
+                 * actually part of this zonelist's round-robin cycle.
+                 */
+                if (zone_reclaim_mode && !zone_local(preferred_zone, zone))
+                        continue;
+                mod_zone_page_state(zone, NR_ALLOC_BATCH,
+                                    high_wmark_pages(zone) -
+                                    low_wmark_pages(zone) -
+                                    zone_page_state(zone, NR_ALLOC_BATCH));
+        }
 }
 
 static inline int
@@ -2451,9 +2496,8 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
                 goto nopage;
 
 restart:
-        if (!(gfp_mask & __GFP_NO_KSWAPD))
-                wake_all_kswapd(order, zonelist, high_zoneidx,
-                                                zone_idx(preferred_zone));
+        prepare_slowpath(gfp_mask, order, zonelist,
+                         high_zoneidx, preferred_zone);
 
         /*
          * OK, we're below the kswapd watermark and have kicked background
@@ -4753,8 +4797,11 @@ static void __paginginit free_area_init_core(struct pglist_data *pgdat,
                 spin_lock_init(&zone->lru_lock);
                 zone_seqlock_init(zone);
                 zone->zone_pgdat = pgdat;
-
                 zone_pcp_init(zone);
+
+                /* For bootup, initialized properly in watermark setup */
+                mod_zone_page_state(zone, NR_ALLOC_BATCH, zone->managed_pages);
+
                 lruvec_init(&zone->lruvec);
                 if (!size)
                         continue;
@@ -5525,6 +5572,11 @@ static void __setup_per_zone_wmarks(void)
                 zone->watermark[WMARK_LOW]  = min_wmark_pages(zone) + (tmp >> 2);
                 zone->watermark[WMARK_HIGH] = min_wmark_pages(zone) + (tmp >> 1);
 
+                __mod_zone_page_state(zone, NR_ALLOC_BATCH,
+                                      high_wmark_pages(zone) -
+                                      low_wmark_pages(zone) -
+                                      zone_page_state(zone, NR_ALLOC_BATCH));
+
                 setup_zone_migrate_reserve(zone);
                 spin_unlock_irqrestore(&zone->lock, flags);
         }
diff --git a/mm/vmstat.c b/mm/vmstat.c
index ca06e9653827..8a8da1f9b044 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -703,6 +703,7 @@ static void walk_zones_in_node(struct seq_file *m, pg_data_t *pgdat,
 const char * const vmstat_text[] = {
         /* Zoned VM counters */
         "nr_free_pages",
+        "nr_alloc_batch",
         "nr_inactive_anon",
         "nr_active_anon",
         "nr_inactive_file",