mm, compaction: simplify contended compaction handling

Async compaction detects contention either due to failing trylock on
zone->lock or lru_lock, or by need_resched().  Since 1f9efdef4f3f ("mm,
compaction: khugepaged should not give up due to need_resched()") the
code got quite complicated to distinguish these two up to the
__alloc_pages_slowpath() level, so different decisions could be taken
for khugepaged allocations.

After the recent changes, khugepaged allocations don't check for
contended compaction anymore, so we again don't need to distinguish lock
and sched contention, and simplify the current convoluted code a lot.

However, I believe it's also possible to simplify even more and
completely remove the check for contended compaction after the initial
async compaction for costly orders, which was originally aimed at THP
page fault allocations.  There are several reasons why this can be done
now:

- with the new defaults, THP page faults no longer do reclaim/compaction at
  all, unless the system admin has overridden the default, or application has
  indicated via madvise that it can benefit from THP's. In both cases, it
  means that the potential extra latency is expected and worth the benefits.
- even if reclaim/compaction proceeds after this patch where it previously
  wouldn't, the second compaction attempt is still async and will detect the
  contention and back off, if the contention persists
- there are still heuristics like deferred compaction and pageblock skip bits
  in place that prevent excessive THP page fault latencies

Link: http://lkml.kernel.org/r/20160721073614.24395-9-vbabka@suse.cz
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Michal Hocko <mhocko@suse.com>
Acked-by: Mel Gorman <mgorman@techsingularity.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 1 insertions, 27 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 26c6fe74f5c5..ea759b935360 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3099,14 +3099,13 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
                 enum compact_priority prio, enum compact_result *compact_result)
 {
         struct page *page;
-        int contended_compaction;
 
         if (!order)
                 return NULL;
 
         current->flags |= PF_MEMALLOC;
         *compact_result = try_to_compact_pages(gfp_mask, order, alloc_flags, ac,
-                                                prio, &contended_compaction);
+                                                                        prio);
         current->flags &= ~PF_MEMALLOC;
 
         if (*compact_result <= COMPACT_INACTIVE)
@@ -3135,24 +3134,6 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
          */
         count_vm_event(COMPACTFAIL);
 
-        /*
-         * In all zones where compaction was attempted (and not
-         * deferred or skipped), lock contention has been detected.
-         * For THP allocation we do not want to disrupt the others
-         * so we fallback to base pages instead.
-         */
-        if (contended_compaction == COMPACT_CONTENDED_LOCK)
-                *compact_result = COMPACT_CONTENDED;
-
-        /*
-         * If compaction was aborted due to need_resched(), we do not
-         * want to further increase allocation latency, unless it is
-         * khugepaged trying to collapse.
-         */
-        if (contended_compaction == COMPACT_CONTENDED_SCHED
-                && !(current->flags & PF_KTHREAD))
-                *compact_result = COMPACT_CONTENDED;
-
         cond_resched();
 
         return NULL;
@@ -3548,13 +3529,6 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
                                 goto nopage;
 
                         /*
-                         * Compaction is contended so rather back off than cause
-                         * excessive stalls.
-                         */
-                        if (compact_result == COMPACT_CONTENDED)
-                                goto nopage;
-
-                        /*
                          * Looks like reclaim/compaction is worth trying, but
                          * sync compaction could be very expensive, so keep
                          * using async compaction.