mm: compaction: simplify should_compact_retry()

The different branches for retry are unnecessarily complicated.  There are
really only three outcomes: progress (retry n times), skipped (retry if
reclaim can help), failed (retry with higher priority).

Rearrange the branches and the retry counter to make it simpler.

[hannes@cmpxchg.org: restore behavior when hitting max_retries]
Link: https://lkml.kernel.org/r/20230602144705.GB161817@cmpxchg.org
Link: https://lkml.kernel.org/r/20230519123959.77335-3-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Michal Hocko <mhocko@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index e3a3ebc2dfcece3096a8d7529c13b3225238c7e8..7e8673504a3d36edcf29c123eb0bf2141ebb9bd4 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3469,21 +3469,6 @@ should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
        if (fatal_signal_pending(current))
                return false;
 
-       /*
-        * Compaction managed to coalesce some page blocks, but the
-        * allocation failed presumably due to a race. Retry some.
-        */
-       if (compact_result == COMPACT_SUCCESS)
-               (*compaction_retries)++;
-
-       /*
-        * All zones were scanned completely and still no result. It
-        * doesn't really make much sense to retry except when the
-        * failure could be caused by insufficient priority
-        */
-       if (compact_result == COMPACT_COMPLETE)
-               goto check_priority;
-
        /*
         * Compaction was skipped due to a lack of free order-0
         * migration targets. Continue if reclaim can help.
@@ -3494,35 +3479,31 @@ should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
        }
 
        /*
-        * If compaction backed due to being deferred, due to
-        * contended locks in async mode, or due to scanners meeting
-        * after a partial scan, retry with increased priority.
+        * Compaction managed to coalesce some page blocks, but the
+        * allocation failed presumably due to a race. Retry some.
         */
-       if (compact_result == COMPACT_DEFERRED ||
-           compact_result == COMPACT_CONTENDED ||
-           compact_result == COMPACT_PARTIAL_SKIPPED)
-               goto check_priority;
+       if (compact_result == COMPACT_SUCCESS) {
+               /*
+                * !costly requests are much more important than
+                * __GFP_RETRY_MAYFAIL costly ones because they are de
+                * facto nofail and invoke OOM killer to move on while
+                * costly can fail and users are ready to cope with
+                * that. 1/4 retries is rather arbitrary but we would
+                * need much more detailed feedback from compaction to
+                * make a better decision.
+                */
+               if (order > PAGE_ALLOC_COSTLY_ORDER)
+                       max_retries /= 4;
 
-       /*
-        * !costly requests are much more important than __GFP_RETRY_MAYFAIL
-        * costly ones because they are de facto nofail and invoke OOM
-        * killer to move on while costly can fail and users are ready
-        * to cope with that. 1/4 retries is rather arbitrary but we
-        * would need much more detailed feedback from compaction to
-        * make a better decision.
-        */
-       if (order > PAGE_ALLOC_COSTLY_ORDER)
-               max_retries /= 4;
-       if (*compaction_retries <= max_retries) {
-               ret = true;
-               goto out;
+               if (++(*compaction_retries) <= max_retries) {
+                       ret = true;
+                       goto out;
+               }
        }
 
        /*
-        * Make sure there are attempts at the highest priority if we exhausted
-        * all retries or failed at the lower priorities.
+        * Compaction failed. Retry with increasing priority.
         */
-check_priority:
        min_priority = (order > PAGE_ALLOC_COSTLY_ORDER) ?
                        MIN_COMPACT_COSTLY_PRIORITY : MIN_COMPACT_PRIORITY;