mm, compaction: distinguish COMPACT_DEFERRED from COMPACT_SKIPPED

try_to_compact_pages() can currently return COMPACT_SKIPPED even when
the compaction is defered for some zone just because zone DMA is skipped
in 99% of cases due to watermark checks.  This makes COMPACT_DEFERRED
basically unusable for the page allocator as a feedback mechanism.

Make sure we distinguish those two states properly and switch their
ordering in the enum.  This would mean that the COMPACT_SKIPPED will be
returned only when all eligible zones are skipped.

As a result COMPACT_DEFERRED handling for THP in __alloc_pages_slowpath
will be more precise and we would bail out rather than reclaim.

Signed-off-by: Michal Hocko <mhocko@suse.com>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Hillf Danton <hillf.zj@alibaba-inc.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Joonsoo Kim <js1304@gmail.com>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Cc: Vladimir Davydov <vdavydov@virtuozzo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index 706cbf0..11f2287 100644 (file)
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -4,13 +4,16 @@
 /* Return values for compact_zone() and try_to_compact_pages() */
 /* When adding new states, please adjust include/trace/events/compaction.h */
 enum compact_result {
-       /* compaction didn't start as it was deferred due to past failures */
-       COMPACT_DEFERRED,
        /*
         * compaction didn't start as it was not possible or direct reclaim
         * was more suitable
         */
        COMPACT_SKIPPED,
+       /* compaction didn't start as it was deferred due to past failures */
+       COMPACT_DEFERRED,
+       /* compaction not active last round */
+       COMPACT_INACTIVE = COMPACT_DEFERRED,
+
        /* compaction should continue to another pageblock */
        COMPACT_CONTINUE,
        /*

diff --git a/include/trace/events/compaction.h b/include/trace/events/compaction.h
index e215bf6..6ba16c8 100644 (file)
--- a/include/trace/events/compaction.h
+++ b/include/trace/events/compaction.h
@@ -10,8 +10,8 @@
 #include <trace/events/mmflags.h>
 
 #define COMPACTION_STATUS                                      \
-       EM( COMPACT_DEFERRED,           "deferred")             \
        EM( COMPACT_SKIPPED,            "skipped")              \
+       EM( COMPACT_DEFERRED,           "deferred")             \
        EM( COMPACT_CONTINUE,           "continue")             \
        EM( COMPACT_PARTIAL,            "partial")              \
        EM( COMPACT_COMPLETE,           "complete")             \

diff --git a/mm/compaction.c b/mm/compaction.c
index 455ecd8..b2b9447 100644 (file)
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -1578,7 +1578,7 @@ enum compact_result try_to_compact_pages(gfp_t gfp_mask, unsigned int order,
        int may_perform_io = gfp_mask & __GFP_IO;
        struct zoneref *z;
        struct zone *zone;
-       enum compact_result rc = COMPACT_DEFERRED;
+       enum compact_result rc = COMPACT_SKIPPED;
        int all_zones_contended = COMPACT_CONTENDED_LOCK; /* init for &= op */
 
        *contended = COMPACT_CONTENDED_NONE;
@@ -1595,8 +1595,10 @@ enum compact_result try_to_compact_pages(gfp_t gfp_mask, unsigned int order,
                enum compact_result status;
                int zone_contended;
 
-               if (compaction_deferred(zone, order))
+               if (compaction_deferred(zone, order)) {
+                       rc = max_t(enum compact_result, COMPACT_DEFERRED, rc);
                        continue;
+               }
 
                status = compact_zone_order(zone, order, gfp_mask, mode,
                                &zone_contended, alloc_flags,
@@ -1667,7 +1669,7 @@ break_loop:
         * If at least one zone wasn't deferred or skipped, we report if all
         * zones that were tried were lock contended.
         */
-       if (rc > COMPACT_SKIPPED && all_zones_contended)
+       if (rc > COMPACT_INACTIVE && all_zones_contended)
                *contended = COMPACT_CONTENDED_LOCK;
 
        return rc;